






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:
		UpperCamelCase												=      None


UpperCamelCase												=      logging.get_logger(__name__)

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

UpperCamelCase												=      {
    '''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'''
        ),
    },
}

UpperCamelCase												=      {
    '''facebook/mbart-large-50-one-to-many-mmt''': 1_024,
}

# fmt: off
UpperCamelCase												=      ['''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						(__SCREAMING_SNAKE_CASE       ):
			__snake_case							: Tuple							=				VOCAB_FILES_NAMES
			__snake_case							: Tuple							=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__snake_case							: Union[str, Any]							=				PRETRAINED_VOCAB_FILES_MAP
			__snake_case							: Optional[Any]							=				["input_ids", "attention_mask"]
			__snake_case							: Tuple							=				MBartaaTokenizer

			__snake_case							: Dict							=				[]
			__snake_case							: Optional[int]							=				[]







			def __init__(      self:    str ,      UpperCAmelCase_:    Union[str, Any]=None ,      UpperCAmelCase_:    Any=None ,      UpperCAmelCase_:    Any=None ,      UpperCAmelCase_:    List[Any]=None ,      UpperCAmelCase_:    Optional[int]="</s>" ,      UpperCAmelCase_:    str="</s>" ,      UpperCAmelCase_:    Any="<s>" ,      UpperCAmelCase_:    List[Any]="<unk>" ,      UpperCAmelCase_:    int="<pad>" ,      UpperCAmelCase_:    str="<mask>" ,      **UpperCAmelCase_:    List[Any] ,      ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    AddedToken(lowerCamelCase_ ,      lstrip=lowerCamelCase_ ,      rstrip=lowerCamelCase_	) if isinstance(lowerCamelCase_ ,      lowerCamelCase_	) else mask_token

									_SCREAMING_SNAKE_CASE       =    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__(
									    lowerCamelCase_ ,      src_lang=lowerCamelCase_ ,      tgt_lang=lowerCamelCase_ ,      tokenizer_file=lowerCamelCase_ ,      eos_token=lowerCamelCase_ ,      sep_token=lowerCamelCase_ ,      cls_token=lowerCamelCase_ ,      unk_token=lowerCamelCase_ ,      pad_token=lowerCamelCase_ ,      mask_token=lowerCamelCase_ ,      **lowerCamelCase_ ,      )

									_SCREAMING_SNAKE_CASE       =    vocab_file
									_SCREAMING_SNAKE_CASE       =    False if not self.vocab_file else True

									_SCREAMING_SNAKE_CASE       =    {
									    lang_code: self.convert_tokens_to_ids(lowerCamelCase_	) for lang_code in FAIRSEQ_LANGUAGE_CODES
									}

									_SCREAMING_SNAKE_CASE       =    src_lang if src_lang is not None else """en_XX"""
									_SCREAMING_SNAKE_CASE       =    tgt_lang
									_SCREAMING_SNAKE_CASE       =    self.lang_code_to_id[self._src_lang]
									self.set_src_lang_special_tokens(self._src_lang	)







			@property
			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									return self._src_lang







			@src_lang.setter
			def 				UpperCamelCase (      self:    Optional[int] ,      UpperCAmelCase_:    str	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    new_src_lang
									self.set_src_lang_special_tokens(self._src_lang	)







			def 				UpperCamelCase (      self:    Any ,      UpperCAmelCase_:    List[int] ,      UpperCAmelCase_:    Optional[List[int]] = 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 				UpperCamelCase (      self:    Optional[Any] ,      UpperCAmelCase_:    List[str] ,      UpperCAmelCase_:    str = "en_XX" ,      UpperCAmelCase_:    Optional[List[str]] = None ,      UpperCAmelCase_:    str = "ro_RO" ,      **UpperCAmelCase_:    int ,      ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    src_lang
									_SCREAMING_SNAKE_CASE       =    tgt_lang
									return super().prepare_seqaseq_batch(lowerCamelCase_ ,      lowerCamelCase_ ,      **lowerCamelCase_	)







			def 				UpperCamelCase (      self:    Dict	):







									'''simple docstring'''




									return self.set_src_lang_special_tokens(self.src_lang	)







			def 				UpperCamelCase (      self:    str	):







									'''simple docstring'''




									return self.set_tgt_lang_special_tokens(self.tgt_lang	)







			def 				UpperCamelCase (      self:    str ,      UpperCAmelCase_:    str	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.convert_tokens_to_ids(lowerCamelCase_	)
									_SCREAMING_SNAKE_CASE       =    [self.cur_lang_code_id]
									_SCREAMING_SNAKE_CASE       =    [self.eos_token_id]

									_SCREAMING_SNAKE_CASE       =    self.convert_ids_to_tokens(self.prefix_tokens	)
									_SCREAMING_SNAKE_CASE       =    self.convert_ids_to_tokens(self.suffix_tokens	)

									_SCREAMING_SNAKE_CASE       =    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 				UpperCamelCase (      self:    Tuple ,      UpperCAmelCase_:    str	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.convert_tokens_to_ids(lowerCamelCase_	)
									_SCREAMING_SNAKE_CASE       =    [self.cur_lang_code_id]
									_SCREAMING_SNAKE_CASE       =    [self.eos_token_id]

									_SCREAMING_SNAKE_CASE       =    self.convert_ids_to_tokens(self.prefix_tokens	)
									_SCREAMING_SNAKE_CASE       =    self.convert_ids_to_tokens(self.suffix_tokens	)

									_SCREAMING_SNAKE_CASE       =    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 				UpperCamelCase (      self:    Union[str, Any] ,      UpperCAmelCase_:    Dict ,      UpperCAmelCase_:    str ,      UpperCAmelCase_:    Optional[str] ,      UpperCAmelCase_:    Optional[str] ,      **UpperCAmelCase_:    str	):







									'''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"""	)
									_SCREAMING_SNAKE_CASE       =    src_lang
									_SCREAMING_SNAKE_CASE       =    self(lowerCamelCase_ ,      add_special_tokens=lowerCamelCase_ ,      return_tensors=lowerCamelCase_ ,      **lowerCamelCase_	)
									_SCREAMING_SNAKE_CASE       =    self.convert_tokens_to_ids(lowerCamelCase_	)
									_SCREAMING_SNAKE_CASE       =    tgt_lang_id
									return inputs







			def 				UpperCamelCase (      self:    Union[str, Any] ,      UpperCAmelCase_:    str ,      UpperCAmelCase_:    Optional[str] = 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(lowerCamelCase_	):
															logger.error(F'Vocabulary path ({save_directory}) should be a directory'	)
															return
									_SCREAMING_SNAKE_CASE       =    os.path.join(
									    lowerCamelCase_ ,      (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]	)

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

									return (out_vocab_file,)





"""simple docstring"""







def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 9 / 5) + 32						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(float(_UpperCamelCase			) + 273.15						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 9 / 5) + 491.67						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) - 32) * 5 / 9						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(((float(_UpperCamelCase			) - 32) * 5 / 9) + 273.15						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(float(_UpperCamelCase			) + 459.67						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(float(_UpperCamelCase			) - 273.15						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(((float(_UpperCamelCase			) - 273.15) * 9 / 5) + 32						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 9 / 5)						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) - 491.67) * 5 / 9						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round(float(_UpperCamelCase			) - 459.67						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 5 / 9)						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 1.25 + 273.15)						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 2.25 + 32)						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 1.25)						,      _UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase = 2			):





						"""simple docstring"""

						return round((float(_UpperCamelCase			) * 2.25 + 32 + 459.67)						,      _UpperCamelCase			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()