"""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_mbartaa import MBartaaTokenizer
else:
				_A         =		None


_A         =		logging.get_logger(__name__)

_A         =		{'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

_A         =		{
    '''vocab_file''': {
        '''facebook/mbart-large-50-one-to-many-mmt''': (
            '''https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/mbart-large-50-one-to-many-mmt''': (
            '''https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/tokenizer.json'''
        ),
    },
}

_A         =		{
    '''facebook/mbart-large-50-one-to-many-mmt''': 10_24,
}

# fmt: off
_A         =		['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''', '''af_ZA''', '''az_AZ''', '''bn_IN''', '''fa_IR''', '''he_IL''', '''hr_HR''', '''id_ID''', '''ka_GE''', '''km_KH''', '''mk_MK''', '''ml_IN''', '''mn_MN''', '''mr_IN''', '''pl_PL''', '''ps_AF''', '''pt_XX''', '''sv_SE''', '''sw_KE''', '''ta_IN''', '''te_IN''', '''th_TH''', '''tl_XX''', '''uk_UA''', '''ur_PK''', '''xh_ZA''', '''gl_ES''', '''sl_SI''']
class 	__UpperCAmelCase						(lowercase__    ):







			'''simple docstring'''
			_UpperCamelCase     :	int				    =							VOCAB_FILES_NAMES
			_UpperCamelCase     :	Tuple				    =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			_UpperCamelCase     :	Dict				    =							PRETRAINED_VOCAB_FILES_MAP
			_UpperCamelCase     :	Union[str, Any]				    =							["""input_ids""", """attention_mask"""]
			_UpperCamelCase     :	Optional[Any]				    =							MBartaaTokenizer

			_UpperCamelCase     :	List[int]				    =							[]
			_UpperCamelCase     :	List[int]				    =							[]





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







										'''simple docstring'''


										A__					:    int														= AddedToken(_A      ,			lstrip=_A      ,			rstrip=_A       ) if isinstance(_A      ,			_A       ) else mask_token

										A__					:    Optional[Any]														= kwargs.get("""additional_special_tokens"""      ,			[]       )
										kwargs["additional_special_tokens"] += [
										    code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
										]

										super().__init__(
										    _A      ,			src_lang=_A      ,			tgt_lang=_A      ,			tokenizer_file=_A      ,			eos_token=_A      ,			sep_token=_A      ,			cls_token=_A      ,			unk_token=_A      ,			pad_token=_A      ,			mask_token=_A      ,			**_A      ,			)

										A__					:    Optional[Any]														= vocab_file
										A__					:    List[Any]														= False if not self.vocab_file else True

										A__					:    Union[str, Any]														= {
										    lang_code: self.convert_tokens_to_ids(_A       ) for lang_code in FAIRSEQ_LANGUAGE_CODES
										}

										A__					:    Any														= src_lang if src_lang is not None else 'en_XX'
										A__					:    Dict														= tgt_lang
										A__					:    Dict														= self.lang_code_to_id[self._src_lang]
										self.set_src_lang_special_tokens(self._src_lang       )





			@property
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return self._src_lang





			@src_lang.setter
			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    List[str]														= new_src_lang
										self.set_src_lang_special_tokens(self._src_lang       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			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 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = "en_XX"      ,			snake_case_ = None      ,			snake_case_ = "ro_RO"      ,			**snake_case_      ,			):







										'''simple docstring'''


										A__					:    List[str]														= src_lang
										A__					:    Optional[int]														= tgt_lang
										return super().prepare_seqaseq_batch(_A      ,			_A      ,			**_A       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return self.set_src_lang_special_tokens(self.src_lang       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return self.set_tgt_lang_special_tokens(self.tgt_lang       )





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.convert_tokens_to_ids(_A       )
										A__					:    Optional[Any]														= [self.cur_lang_code_id]
										A__					:    List[Any]														= [self.eos_token_id]

										A__					:    int														= self.convert_ids_to_tokens(self.prefix_tokens       )
										A__					:    Optional[Any]														= self.convert_ids_to_tokens(self.suffix_tokens       )

										A__					:    Tuple														= 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 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    Any														= self.convert_tokens_to_ids(_A       )
										A__					:    List[Any]														= [self.cur_lang_code_id]
										A__					:    Dict														= [self.eos_token_id]

										A__					:    Dict														= self.convert_ids_to_tokens(self.prefix_tokens       )
										A__					:    Union[str, Any]														= self.convert_ids_to_tokens(self.suffix_tokens       )

										A__					:    Optional[int]														= 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 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			**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"""       )
										A__					:    List[Any]														= src_lang
										A__					:    str														= self(_A      ,			add_special_tokens=_A      ,			return_tensors=_A      ,			**_A       )
										A__					:    Tuple														= self.convert_tokens_to_ids(_A       )
										A__					:    Optional[Any]														= tgt_lang_id
										return inputs





			def 		lowerCamelCase				( self      ,			snake_case_      ,			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
										A__					:    Union[str, 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"""



def    _A(		lowerCAmelCase       ):
							if not isinstance(lowerCAmelCase ,     lowerCAmelCase       ):
														A__					:    int														= F'''Input value of [number={number}] must be an integer'''
														raise TypeError(lowerCAmelCase       )
							if number < 0 or number % 2 == 1:
														return False
							A__					:    List[Any]														= int(number**0.5       )
							return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
				import doctest

				doctest.testmod()





