
import importlib
import os
import platform
from pathlib import Path

from packaging import version

from .utils.logging import get_logger


__a							  =						get_logger(__name__)

# Datasets
__a							  =						"""https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets"""
__a							  =						"""https://cdn-datasets.huggingface.co/datasets/datasets"""
__a							  =						"""https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}"""

# Metrics
__a							  =						"""https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics"""
__a							  =						"""https://cdn-datasets.huggingface.co/datasets/metric"""
__a							  =						"""https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}"""

# Hub
__a							  =						os.environ.get("""HF_ENDPOINT""", """https://huggingface.co""")
__a							  =						HF_ENDPOINT + """/datasets/{repo_id}/resolve/{revision}/{path}"""
__a							  =						"""main"""

__a							  =						version.parse(platform.python_version())

if PY_VERSION < version.parse("""3.8"""):
	import importlib_metadata
else:
	import importlib.metadata as importlib_metadata

# General environment variables accepted values for booleans
__a							  =						{"""1""", """ON""", """YES""", """TRUE"""}
__a							  =						ENV_VARS_TRUE_VALUES.union({"""AUTO"""})


# Imports
__a							  =						version.parse(importlib_metadata.version("""dill"""))
__a							  =						version.parse(importlib_metadata.version("""pandas"""))
__a							  =						version.parse(importlib_metadata.version("""pyarrow"""))

__a							  =						os.environ.get("""USE_TF""", """AUTO""").upper()
__a							  =						os.environ.get("""USE_TORCH""", """AUTO""").upper()
__a							  =						os.environ.get("""USE_JAX""", """AUTO""").upper()

__a							  =						"""N/A"""
__a							  =						False

if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
	__a							  =						importlib.util.find_spec("""torch""") is not None
	if TORCH_AVAILABLE:
		try:
			__a							  =						version.parse(importlib_metadata.version("""torch"""))
			logger.info(F'''PyTorch version {TORCH_VERSION} available.''')
		except importlib_metadata.PackageNotFoundError:
			pass
else:
	logger.info("""Disabling PyTorch because USE_TF is set""")

__a							  =						"""N/A"""
__a							  =						False

if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
	__a							  =						importlib.util.find_spec("""tensorflow""") is not None
	if TF_AVAILABLE:
		# For the metadata, we have to look for both tensorflow and tensorflow-cpu
		for package in [
		    "tensorflow",
		    "tensorflow-cpu",
		    "tensorflow-gpu",
		    "tf-nightly",
		    "tf-nightly-cpu",
		    "tf-nightly-gpu",
		    "intel-tensorflow",
		    "tensorflow-rocm",
		    "tensorflow-macos",
		]:
			try:
				__a							  =						version.parse(importlib_metadata.version(package))
			except importlib_metadata.PackageNotFoundError:
				continue
			else:
				break
		else:
			__a							  =						False
	if TF_AVAILABLE:
		if TF_VERSION.major < 2:
			logger.info(F'''TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.''')
			__a							  =						False
		else:
			logger.info(F'''TensorFlow version {TF_VERSION} available.''')
else:
	logger.info("""Disabling Tensorflow because USE_TORCH is set""")


__a							  =						"""N/A"""
__a							  =						False

if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
	__a							  =						importlib.util.find_spec("""jax""") is not None and importlib.util.find_spec("""jaxlib""") is not None
	if JAX_AVAILABLE:
		try:
			__a							  =						version.parse(importlib_metadata.version("""jax"""))
			logger.info(F'''JAX version {JAX_VERSION} available.''')
		except importlib_metadata.PackageNotFoundError:
			pass
else:
	logger.info("""Disabling JAX because USE_JAX is set to False""")


__a							  =						os.environ.get("""USE_BEAM""", """AUTO""").upper()
__a							  =						"""N/A"""
__a							  =						False
if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
	try:
		__a							  =						version.parse(importlib_metadata.version("""apache_beam"""))
		__a							  =						True
		logger.info(F'''Apache Beam version {BEAM_VERSION} available.''')
	except importlib_metadata.PackageNotFoundError:
		pass
else:
	logger.info("""Disabling Apache Beam because USE_BEAM is set to False""")


# Optional tools for data loading
__a							  =						importlib.util.find_spec("""sqlalchemy""") is not None

# Optional tools for feature decoding
__a							  =						importlib.util.find_spec("""PIL""") is not None
__a							  =						importlib.util.find_spec("""soundfile""") is not None and version.parse(
    importlib.import_module("""soundfile""").__libsndfile_version__
) >= version.parse("""1.0.31""")
__a							  =						importlib.util.find_spec("""soundfile""") is not None and version.parse(
    importlib.import_module("""soundfile""").__libsndfile_version__
) >= version.parse("""1.1.0""")

# Optional compression tools
__a							  =						importlib.util.find_spec("""rarfile""") is not None
__a							  =						importlib.util.find_spec("""zstandard""") is not None
__a							  =						importlib.util.find_spec("""lz4""") is not None
__a							  =						importlib.util.find_spec("""py7zr""") is not None


# Cache location
__a							  =						"""~/.cache"""
__a							  =						os.getenv("""XDG_CACHE_HOME""", DEFAULT_XDG_CACHE_HOME)
__a							  =						os.path.join(XDG_CACHE_HOME, """huggingface""")
__a							  =						os.path.expanduser(os.getenv("""HF_HOME""", DEFAULT_HF_CACHE_HOME))

__a							  =						os.path.join(HF_CACHE_HOME, """datasets""")
__a							  =						Path(os.getenv("""HF_DATASETS_CACHE""", DEFAULT_HF_DATASETS_CACHE))

__a							  =						os.path.join(HF_CACHE_HOME, """metrics""")
__a							  =						Path(os.getenv("""HF_METRICS_CACHE""", DEFAULT_HF_METRICS_CACHE))

__a							  =						os.path.join(HF_CACHE_HOME, """modules""")
__a							  =						Path(os.getenv("""HF_MODULES_CACHE""", DEFAULT_HF_MODULES_CACHE))

__a							  =						"""downloads"""
__a							  =						os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
__a							  =						Path(os.getenv("""HF_DATASETS_DOWNLOADED_DATASETS_PATH""", DEFAULT_DOWNLOADED_DATASETS_PATH))

__a							  =						"""extracted"""
__a							  =						os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
__a							  =						Path(os.getenv("""HF_DATASETS_EXTRACTED_DATASETS_PATH""", DEFAULT_EXTRACTED_DATASETS_PATH))

# Download count for the website
__a							  =						(
    os.environ.get("""HF_UPDATE_DOWNLOAD_COUNTS""", """AUTO""").upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
)

# Batch size constants. For more info, see:
# https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
__a							  =						1_0_0_0

# Size of the preloaded record batch in `Dataset.__iter__`
__a							  =						1_0

# Pickling tables works only for small tables (<4GiB)
# For big tables, we write them on disk instead
__a							  =						4 << 3_0

# Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
__a							  =						"""500MB"""

# Parquet configuration
__a							  =						1_0_0
__a							  =						1_0_0
__a							  =						1_0_0

# Offline mode
__a							  =						os.environ.get("""HF_DATASETS_OFFLINE""", """AUTO""").upper() in ENV_VARS_TRUE_VALUES

# In-memory
__a							  =						0  # Disabled
__a							  =						float(os.environ.get("""HF_DATASETS_IN_MEMORY_MAX_SIZE""", DEFAULT_IN_MEMORY_MAX_SIZE))

# File names
__a							  =						"""dataset.arrow"""
__a							  =						"""indices.arrow"""
__a							  =						"""state.json"""
__a							  =						"""dataset_info.json"""
__a							  =						"""dataset_infos.json"""
__a							  =						"""LICENSE"""
__a							  =						"""metric_info.json"""
__a							  =						"""dataset_dict.json"""

__a							  =						"""datasets_modules"""

__a							  =						2_5_5

# Streaming
__a							  =						2_0
__a							  =						5

# Datasets without script
__a							  =						2_0_0
__a							  =						1_0
__a							  =						2_0_0

# Progress bars
__a							  =						0.05  # 20 progress updates per sec






import json
import os
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
	from transformers.pipelines.conversational import Conversation

__a							  =						logging.get_logger(__name__)

__a							  =						{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

__a							  =						{
    """vocab_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json"""
        ),
    },
    """merges_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt"""
        ),
    },
}

__a							  =						{
    """microsoft/deberta-base""": 5_1_2,
    """microsoft/deberta-large""": 5_1_2,
    """microsoft/deberta-xlarge""": 5_1_2,
    """microsoft/deberta-base-mnli""": 5_1_2,
    """microsoft/deberta-large-mnli""": 5_1_2,
    """microsoft/deberta-xlarge-mnli""": 5_1_2,
}

__a							  =						{
    """microsoft/deberta-base""": {"""do_lower_case""": False},
    """microsoft/deberta-large""": {"""do_lower_case""": False},
}

def    UpperCamelCase_ (	)     ->Optional[int]:
		A				=(
		    list(range(ord("!"		)  ,				ord("~"		) + 1		)		) + list(range(ord("¡"		)  ,				ord("¬"		) + 1		)		) + list(range(ord("®"		)  ,				ord("ÿ"		) + 1		)		)
		)
		A				=bs[:]
		A				=0
		for b in range(2**8		):
				if b not in bs:
						bs.append(a_		)
						cs.append(2**8 + n		)
						n += 1
		A				=[chr(a_		) for n in cs]
		return dict(zip(a_  ,				a_		)		)

def    UpperCamelCase_ (	a_		)     ->Dict:
		A				=set()
		A				=word[0]
		for char in word[1:]:
				pairs.add((prev_char, char)		)
				A				=char
		return pairs






class        UpperCamelCase__(    lowerCAmelCase__	):

	"""simple docstring"""

	_A  =		VOCAB_FILES_NAMES
	_A  =		PRETRAINED_VOCAB_FILES_MAP
	_A  =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_A  =		["input_ids", "attention_mask", "token_type_ids"]







	def __init__(      self				:			Union[str, Any]							,			snake_case__				:			Tuple							,			snake_case__				:			Union[str, Any]							,			snake_case__				:			Union[str, Any]="replace"							,			snake_case__				:			Any="[CLS]"							,			snake_case__				:			List[Any]="[SEP]"							,			snake_case__				:			str="[SEP]"							,			snake_case__				:			Tuple="[CLS]"							,			snake_case__				:			Optional[Any]="[UNK]"							,			snake_case__				:			Union[str, Any]="[PAD]"							,			snake_case__				:			List[Any]="[MASK]"							,			snake_case__				:			Any=False							,			snake_case__				:			List[str]=False							,			**snake_case__				:			str							,			):
			"""simple docstring"""





			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else bos_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else eos_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else sep_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else cls_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else unk_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else pad_token

			# Mask token behave like a normal word, i.e. include the space before it
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else mask_token

			super().__init__(
			    errors=snake_case__							,			bos_token=snake_case__							,			eos_token=snake_case__							,			unk_token=snake_case__							,			sep_token=snake_case__							,			cls_token=snake_case__							,			pad_token=snake_case__							,			mask_token=snake_case__							,			add_prefix_space=snake_case__							,			add_bos_token=snake_case__							,			**snake_case__							,			)
			A				=add_bos_token

			with open(snake_case__							,			encoding="utf-8" ) as vocab_handle:
					A				=json.load(snake_case__ )
			A				={v: k for k, v in self.encoder.items()}
			A				=errors  # how to handle errors in decoding
			A				=bytes_to_unicode()
			A				={v: k for k, v in self.byte_encoder.items()}
			with open(snake_case__							,			encoding="utf-8" ) as merges_handle:
					A				=merges_handle.read().split("\n" )[1:-1]
			A				=[tuple(merge.split() ) for merge in bpe_merges]
			A				=dict(zip(snake_case__							,			range(len(snake_case__ ) ) ) )
			A				={}
			A				=add_prefix_space

			# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
			A				=re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" )







	@property
	# Copied from transformers.models.gpt2.tokenization_gpt2.GPT2Tokenizer.vocab_size
	def        _a					(      self				:			Optional[int] ):
			"""simple docstring"""





			return len(self.encoder )







	def        _a					(      self				:			int ):
			"""simple docstring"""





			return dict(self.encoder							,			**self.added_tokens_encoder )







	def        _a					(      self				:			List[str]							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			if token in self.cache:
					return self.cache[token]
			A				=tuple(snake_case__ )
			A				=get_pairs(snake_case__ )

			if not pairs:
					return token

			while True:
					A				=min(snake_case__							,			key=lambda snake_case__ : self.bpe_ranks.get(snake_case__							,			float("inf" ) ) )
					if bigram not in self.bpe_ranks:
							break
					A			,    A				=bigram
					A				=[]
					A				=0
					while i < len(snake_case__ ):
							try:
									A				=word.index(snake_case__							,			snake_case__ )
							except ValueError:
									new_word.extend(word[i:] )
									break
							else:
									new_word.extend(word[i:j] )
									A				=j

							if word[i] == first and i < len(snake_case__ ) - 1 and word[i + 1] == second:
									new_word.append(first + second )
									i += 2
							else:
									new_word.append(word[i] )
									i += 1
					A				=tuple(snake_case__ )
					A				=new_word
					if len(snake_case__ ) == 1:
							break
					else:
							A				=get_pairs(snake_case__ )
			A				=" ".join(snake_case__ )
			A				=word
			return word







	def        _a					(      self				:			Any							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None ):
			"""simple docstring"""





			if token_ids_a is None:
					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
			A				=[self.cls_token_id]
			A				=[self.sep_token_id]
			return cls + token_ids_a + sep + token_ids_a + sep







	def        _a					(      self				:			List[Any]							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None							,			snake_case__				:			bool = False ):
			"""simple docstring"""





			if already_has_special_tokens:
					return super().get_special_tokens_mask(
					    token_ids_a=snake_case__							,			token_ids_a=snake_case__							,			already_has_special_tokens=snake_case__ )

			if token_ids_a is None:
					return [1] + ([0] * len(snake_case__ )) + [1]
			return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1]







	def        _a					(      self				:			str							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None ):
			"""simple docstring"""





			A				=[self.sep_token_id]
			A				=[self.cls_token_id]

			if token_ids_a is None:
					return len(cls + token_ids_a + sep ) * [0]
			return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]







	def        _a					(      self				:			List[str]							,			snake_case__				:			List[Any] ):
			"""simple docstring"""





			A				=[]
			for token in re.findall(self.pat							,			snake_case__ ):
					A				="".join(
					    self.byte_encoder[b] for b in token.encode("utf-8" ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
					bpe_tokens.extend(bpe_token for bpe_token in self.bpe(snake_case__ ).split(" " ) )
			return bpe_tokens







	def        _a					(      self				:			List[Any]							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			return self.encoder.get(snake_case__							,			self.encoder.get(self.unk_token ) )







	def        _a					(      self				:			int							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			return self.decoder.get(snake_case__ )







	def        _a					(      self				:			Union[str, Any]							,			snake_case__				:			Optional[int] ):
			"""simple docstring"""





			A				="".join(snake_case__ )
			A				=bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8"							,			errors=self.errors )
			return text







	def        _a					(      self				:			int							,			snake_case__				:			str							,			snake_case__				:			Optional[str] = None ):
			"""simple docstring"""





			if not os.path.isdir(snake_case__ ):
					logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
					return
			A				=os.path.join(
			    snake_case__							,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
			A				=os.path.join(
			    snake_case__							,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )

			with open(snake_case__							,			"w"							,			encoding="utf-8" ) as f:
					f.write(json.dumps(self.encoder							,			indent=2							,			sort_keys=snake_case__							,			ensure_ascii=snake_case__ ) + "\n" )

			A				=0
			with open(snake_case__							,			"w"							,			encoding="utf-8" ) as writer:
					writer.write("#version: 0.2\n" )
					for bpe_tokens, token_index in sorted(self.bpe_ranks.items()							,			key=lambda snake_case__ : kv[1] ):
							if index != token_index:
									logger.warning(
									    f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
									    " Please check that the tokenizer is not corrupted!" )
									A				=token_index
							writer.write(" ".join(snake_case__ ) + "\n" )
							index += 1

			return vocab_file, merge_file







	def        _a					(      self				:			List[Any]							,			snake_case__				:			Optional[Any]							,			snake_case__				:			Any=False							,			**snake_case__				:			Optional[int] ):
			"""simple docstring"""





			A				=kwargs.pop("add_prefix_space"							,			self.add_prefix_space )
			if (is_split_into_words or add_prefix_space) and (len(snake_case__ ) > 0 and not text[0].isspace()):
					A				=" " + text
			return (text, kwargs)







	def        _a					(      self				:			List[str]							,			snake_case__				:			"Conversation" ):
			"""simple docstring"""





			A				=[]
			for is_user, text in conversation.iter_texts():
					input_ids.extend(self.encode(snake_case__							,			add_special_tokens=snake_case__ ) + [self.eos_token_id] )
			if len(snake_case__ ) > self.model_max_length:
					A				=input_ids[-self.model_max_length :]
			return input_ids




