
'''simple docstring'''







import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
							from .tokenization_nllb import NllbTokenizer
else:
							_lowercase			:  List[str]   							=	None


_lowercase			:  str   							=	logging.get_logger(__name__)


_lowercase			:  List[str]   							=	{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

_lowercase			:  Dict   							=	{
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/sentencepiece.bpe.model"
        ),
    },
    "tokenizer_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/tokenizer.json"
        ),
    },
}

_lowercase			:  str   							=	{
    "facebook/nllb-large-en-ro": 1_0_2_4,
    "facebook/nllb-200-distilled-600M": 1_0_2_4,
}

# fmt: off
_lowercase			:  List[str]   							=	["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]






class 			lowerCAmelCase__       (  lowerCamelCase_					):






					"""simple docstring"""




					lowerCAmelCase_					       =					VOCAB_FILES_NAMES
					lowerCAmelCase_					       =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowerCAmelCase_					       =					PRETRAINED_VOCAB_FILES_MAP
					lowerCAmelCase_					       =					['''input_ids''', '''attention_mask''']
					lowerCAmelCase_					       =					NllbTokenizer

					lowerCAmelCase_					       =					[]
					lowerCAmelCase_					       =					[]






					def __init__(       self    ,							__SCREAMING_SNAKE_CASE=None    ,							__SCREAMING_SNAKE_CASE=None    ,							__SCREAMING_SNAKE_CASE="<s>"    ,							__SCREAMING_SNAKE_CASE="</s>"    ,							__SCREAMING_SNAKE_CASE="</s>"    ,							__SCREAMING_SNAKE_CASE="<s>"    ,							__SCREAMING_SNAKE_CASE="<unk>"    ,							__SCREAMING_SNAKE_CASE="<pad>"    ,							__SCREAMING_SNAKE_CASE="<mask>"    ,							__SCREAMING_SNAKE_CASE=None    ,							__SCREAMING_SNAKE_CASE=None    ,							__SCREAMING_SNAKE_CASE=None    ,							__SCREAMING_SNAKE_CASE=False    ,							**__SCREAMING_SNAKE_CASE    ,							):


											"""simple docstring"""





											lowercase_     :					Dict													=	AddedToken(_a    ,							lstrip=_a    ,							rstrip=_a		) if isinstance(_a    ,							_a		) else mask_token
											lowercase_     :					Optional[int]													=	legacy_behaviour
											super().__init__(
											    vocab_file=_a    ,							tokenizer_file=_a    ,							bos_token=_a    ,							eos_token=_a    ,							sep_token=_a    ,							cls_token=_a    ,							unk_token=_a    ,							pad_token=_a    ,							mask_token=_a    ,							src_lang=_a    ,							tgt_lang=_a    ,							additional_special_tokens=_a    ,							legacy_behaviour=_a    ,							**_a    ,							)

											lowercase_     :					Any													=	vocab_file
											lowercase_     :					Any													=	False if not self.vocab_file else True

											lowercase_     :					Dict													=	FAIRSEQ_LANGUAGE_CODES.copy()

											if additional_special_tokens is not None:
																	# Only add those special tokens if they are not already there.
																	_additional_special_tokens.extend(
																	    [t for t in additional_special_tokens if t not in _additional_special_tokens]		)

											self.add_special_tokens({'''additional_special_tokens''': _additional_special_tokens}		)
											lowercase_     :					Union[str, Any]													=	{
											    lang_code: self.convert_tokens_to_ids(_a		) for lang_code in FAIRSEQ_LANGUAGE_CODES
											}

											lowercase_     :					List[Any]													=	src_lang if src_lang is not None else '''eng_Latn'''
											lowercase_     :					Any													=	self.convert_tokens_to_ids(self._src_lang		)
											lowercase_     :					Optional[Any]													=	tgt_lang
											self.set_src_lang_special_tokens(self._src_lang		)






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return self._src_lang






					@src_lang.setter
					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	new_src_lang
											self.set_src_lang_special_tokens(self._src_lang		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE = None		):


											"""simple docstring"""





											if token_ids_a is None:
																	return self.prefix_tokens + token_ids_a + self.suffix_tokens
											# We don't expect to process pairs, but leave the pair logic for API consistency
											return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE = None		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	[self.sep_token_id]
											lowercase_     :					Any													=	[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 + sep + token_ids_a + sep		) * [0]






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											if src_lang is None or tgt_lang is None:
																	raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model'''		)
											lowercase_     :					Tuple													=	src_lang
											lowercase_     :					str													=	self(_a    ,							add_special_tokens=_a    ,							return_tensors=_a    ,							**_a		)
											lowercase_     :					Optional[int]													=	self.convert_tokens_to_ids(_a		)
											lowercase_     :					Union[str, Any]													=	tgt_lang_id
											return inputs






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE = "eng_Latn"    ,							__SCREAMING_SNAKE_CASE = None    ,							__SCREAMING_SNAKE_CASE = "fra_Latn"    ,							**__SCREAMING_SNAKE_CASE    ,							):


											"""simple docstring"""





											lowercase_     :					str													=	src_lang
											lowercase_     :					Tuple													=	tgt_lang
											return super().prepare_seqaseq_batch(_a    ,							_a    ,							**_a		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											return self.set_src_lang_special_tokens(self.src_lang		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											return self.set_tgt_lang_special_tokens(self.tgt_lang		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					int													=	self.convert_tokens_to_ids(_a		)

											if self.legacy_behaviour:
																	lowercase_     :					Optional[Any]													=	[]
																	lowercase_     :					Optional[Any]													=	[self.eos_token_id, self.cur_lang_code]
											else:
																	lowercase_     :					Optional[int]													=	[self.cur_lang_code]
																	lowercase_     :					Optional[Any]													=	[self.eos_token_id]

											lowercase_     :					int													=	self.convert_ids_to_tokens(self.prefix_tokens		)
											lowercase_     :					str													=	self.convert_ids_to_tokens(self.suffix_tokens		)

											lowercase_     :					str													=	processors.TemplateProcessing(
											    single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str    ,							pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str    ,							special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str    ,							self.prefix_tokens + self.suffix_tokens		)		)    ,							)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Union[str, Any]													=	self.convert_tokens_to_ids(_a		)
											if self.legacy_behaviour:
																	lowercase_     :					str													=	[]
																	lowercase_     :					List[str]													=	[self.eos_token_id, self.cur_lang_code]
											else:
																	lowercase_     :					Dict													=	[self.cur_lang_code]
																	lowercase_     :					Dict													=	[self.eos_token_id]

											lowercase_     :					Any													=	self.convert_ids_to_tokens(self.prefix_tokens		)
											lowercase_     :					List[Any]													=	self.convert_ids_to_tokens(self.suffix_tokens		)

											lowercase_     :					Optional[Any]													=	processors.TemplateProcessing(
											    single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str    ,							pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str    ,							special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str    ,							self.prefix_tokens + self.suffix_tokens		)		)    ,							)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE = None		):


											"""simple docstring"""





											if not self.can_save_slow_tokenizer:
																	raise ValueError(
																	    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
																	    '''tokenizer.'''		)

											if not os.path.isdir(_a		):
																	logger.error(F'''Vocabulary path ({save_directory}) should be a directory.'''		)
																	return
											lowercase_     :					Optional[Any]													=	os.path.join(
											    _a    ,							(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']		)

											if os.path.abspath(self.vocab_file		) != os.path.abspath(_a		):
																	copyfile(self.vocab_file    ,							_a		)

											return (out_vocab_file,)





'''simple docstring'''







import unittest

from datasets import load_dataset

from transformers import BloomTokenizerFast
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class 			lowerCAmelCase__       (  lowerCamelCase_   ,						unittest.TestCase					):
					lowerCAmelCase_					       =					None
					lowerCAmelCase_					       =					BloomTokenizerFast
					lowerCAmelCase_					       =					BloomTokenizerFast
					lowerCAmelCase_					       =					True
					lowerCAmelCase_					       =					False
					lowerCAmelCase_					       =					'''tokenizer_file'''
					lowerCAmelCase_					       =					{'''bos_token''': '''<s>''', '''eos_token''': '''</s>''', '''unk_token''': '''<unk>''', '''pad_token''': '''<pad>'''}






					def      _snake_case   (       self		):


											"""simple docstring"""





											super().setUp()
											lowercase_     :					List[Any]													=	BloomTokenizerFast.from_pretrained('''bigscience/tokenizer'''		)
											tokenizer.save_pretrained(self.tmpdirname		)






					def      _snake_case   (       self    ,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											kwargs.update(self.special_tokens_map		)
											return BloomTokenizerFast.from_pretrained(self.tmpdirname    ,							**__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Tuple													=	self.get_rust_tokenizer()

											lowercase_     :					Optional[Any]													=	['''The quick brown fox</s>''', '''jumps over the lazy dog</s>''']
											lowercase_     :					Union[str, Any]													=	[[21_75, 2_37_14, 7_31_73, 14_42_52, 2], [77, 13_26_19, 34_78, 3_68, 10_95_86, 3_54_33, 2]]

											lowercase_     :					Dict													=	tokenizer.batch_encode_plus(__SCREAMING_SNAKE_CASE		)['''input_ids''']
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Tuple													=	tokenizer.batch_decode(__SCREAMING_SNAKE_CASE		)
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE=6		):


											"""simple docstring"""





											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
																							lowercase_     :					int													=	self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE    ,							**__SCREAMING_SNAKE_CASE		)
																							# tokenizer_r.pad_token = None # Hotfixing padding = None
																							# Simple input
																							lowercase_     :					Optional[int]													=	'''This is a simple input'''
																							lowercase_     :					List[str]													=	['''This is a simple input 1''', '''This is a simple input 2''']
																							lowercase_     :					List[str]													=	('''This is a simple input''', '''This is a pair''')
																							lowercase_     :					Union[str, Any]													=	[
																							    ('''This is a simple input 1''', '''This is a simple input 2'''),
																							    ('''This is a simple pair 1''', '''This is a simple pair 2'''),
																							]

																							# Simple input tests
																							try:
																													tokenizer_r.encode(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)

																													tokenizer_r.batch_encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.encode(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.batch_encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																							except ValueError:
																													self.fail('''Bloom Tokenizer should be able to deal with padding'''		)

																							lowercase_     :					Optional[Any]													=	None  # Hotfixing padding = None
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Simple input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Simple input
																							self.assertRaises(
																							    __SCREAMING_SNAKE_CASE    ,							tokenizer_r.batch_encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''    ,							)

																							# Pair input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Pair input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Pair input
																							self.assertRaises(
																							    __SCREAMING_SNAKE_CASE    ,							tokenizer_r.batch_encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''    ,							)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	self.get_rust_tokenizer()
											lowercase_     :					Tuple													=	load_dataset('''xnli'''    ,							'''all_languages'''    ,							split='''test'''    ,							streaming=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	next(iter(__SCREAMING_SNAKE_CASE		)		)['''premise''']  # pick up one data
											lowercase_     :					List[Any]													=	list(sample_data.values()		)

											lowercase_     :					Tuple													=	list(map(tokenizer.encode    ,							__SCREAMING_SNAKE_CASE		)		)
											lowercase_     :					Any													=	[tokenizer.decode(__SCREAMING_SNAKE_CASE    ,							clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE		) for x in output_tokens]
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map		)    ,							1		)
											self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values()		)[0]		)    ,							1		)



