




"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__A :		str      							=			{
    '''configuration_mobilenet_v1''': [
        '''MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''MobileNetV1Config''',
        '''MobileNetV1OnnxConfig''',
    ],
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A :		Union[str, Any]      							=			['''MobileNetV1FeatureExtractor''']
  __A :		Tuple      							=			['''MobileNetV1ImageProcessor''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A :		List[str]      							=			[
      '''MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''MobileNetV1ForImageClassification''',
      '''MobileNetV1Model''',
      '''MobileNetV1PreTrainedModel''',
      '''load_tf_weights_in_mobilenet_v1''',
  ]


if TYPE_CHECKING:
  from .configuration_mobilenet_va import (
      MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
      MobileNetVaConfig,
      MobileNetVaOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
    from .image_processing_mobilenet_va import MobileNetVaImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mobilenet_va import (
        MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
        MobileNetVaForImageClassification,
        MobileNetVaModel,
        MobileNetVaPreTrainedModel,
        load_tf_weights_in_mobilenet_va,
    )


else:
  import sys

  __A :		Tuple      							=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)










"""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 :		Tuple      							=    None


__A :		Optional[Any]      							=    logging.get_logger(__name__)

__A :		Optional[Any]      							=    {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

__A :		Optional[Any]      							=    {
    '''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 :		List[Any]      							=    {
    '''facebook/mbart-large-50-one-to-many-mmt''': 1024,
}

# fmt: off
__A :		Dict      							=    ['''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 							lowerCamelCase		( _UpperCAmelCase				):
   lowercase       :  List[Any]      =				VOCAB_FILES_NAMES
   lowercase       :  Optional[Any]      =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   lowercase       :  List[Any]      =				PRETRAINED_VOCAB_FILES_MAP
   lowercase       :  Tuple      =				['input_ids', 'attention_mask']
   lowercase       :  Optional[int]      =				MBartaaTokenizer

   lowercase       :  List[int]      =				[]
   lowercase       :  List[int]      =				[]







   def __init__(							self    ,      SCREAMING_SNAKE_CASE_=None    ,      SCREAMING_SNAKE_CASE_=None    ,      SCREAMING_SNAKE_CASE_=None    ,      SCREAMING_SNAKE_CASE_=None    ,      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_    ,      ):
       # Mask token behave like a normal word, i.e. include the space before it
       UpperCamelCase				:   Optional[int]          =							AddedToken(SCREAMING_SNAKE_CASE_    ,      lstrip=SCREAMING_SNAKE_CASE_    ,      rstrip=SCREAMING_SNAKE_CASE_ ) if isinstance(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ ) else mask_token

       UpperCamelCase				:   Dict          =							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__(
           SCREAMING_SNAKE_CASE_    ,      src_lang=SCREAMING_SNAKE_CASE_    ,      tgt_lang=SCREAMING_SNAKE_CASE_    ,      tokenizer_file=SCREAMING_SNAKE_CASE_    ,      eos_token=SCREAMING_SNAKE_CASE_    ,      sep_token=SCREAMING_SNAKE_CASE_    ,      cls_token=SCREAMING_SNAKE_CASE_    ,      unk_token=SCREAMING_SNAKE_CASE_    ,      pad_token=SCREAMING_SNAKE_CASE_    ,      mask_token=SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_    ,      )

       UpperCamelCase				:   int          =							vocab_file
       UpperCamelCase				:   Optional[Any]          =							False if not self.vocab_file else True

       UpperCamelCase				:   List[Any]          =							{
           lang_code: self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_ ) for lang_code in FAIRSEQ_LANGUAGE_CODES
       }

       UpperCamelCase				:   List[str]          =							src_lang if src_lang is not None else """en_XX"""
       UpperCamelCase				:   Union[str, Any]          =							tgt_lang
       UpperCamelCase				:   Union[str, Any]          =							self.lang_code_to_id[self._src_lang]
       self.set_src_lang_special_tokens(self._src_lang )







   @property
   def       a_							(							self ):
       return self._src_lang







   @src_lang.setter
   def       a_							(							self    ,      SCREAMING_SNAKE_CASE_ ):
       UpperCamelCase				:   str          =							new_src_lang
       self.set_src_lang_special_tokens(self._src_lang )







   def       a_							(							self    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ = None ):
       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       a_							(							self    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ = "en_XX"    ,      SCREAMING_SNAKE_CASE_ = None    ,      SCREAMING_SNAKE_CASE_ = "ro_RO"    ,      **SCREAMING_SNAKE_CASE_    ,      ):
       UpperCamelCase				:   str          =							src_lang
       UpperCamelCase				:   Optional[Any]          =							tgt_lang
       return super().prepare_seqaseq_batch(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )







   def       a_							(							self ):
       return self.set_src_lang_special_tokens(self.src_lang )







   def       a_							(							self ):
       return self.set_tgt_lang_special_tokens(self.tgt_lang )







   def       a_							(							self    ,      SCREAMING_SNAKE_CASE_ ):
       UpperCamelCase				:   Optional[Any]          =							self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_ )
       UpperCamelCase				:   Tuple          =							[self.cur_lang_code_id]
       UpperCamelCase				:   Optional[int]          =							[self.eos_token_id]

       UpperCamelCase				:   Dict          =							self.convert_ids_to_tokens(self.prefix_tokens )
       UpperCamelCase				:   Any          =							self.convert_ids_to_tokens(self.suffix_tokens )

       UpperCamelCase				:   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       a_							(							self    ,      SCREAMING_SNAKE_CASE_ ):
       UpperCamelCase				:   Any          =							self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_ )
       UpperCamelCase				:   Optional[Any]          =							[self.cur_lang_code_id]
       UpperCamelCase				:   Tuple          =							[self.eos_token_id]

       UpperCamelCase				:   str          =							self.convert_ids_to_tokens(self.prefix_tokens )
       UpperCamelCase				:   Dict          =							self.convert_ids_to_tokens(self.suffix_tokens )

       UpperCamelCase				:   Dict          =							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       a_							(							self    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ ):
       if src_lang is None or tgt_lang is None:
           raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model""" )
       UpperCamelCase				:   Optional[int]          =							src_lang
       UpperCamelCase				:   Optional[int]          =							self(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_    ,      return_tensors=SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
       UpperCamelCase				:   Dict          =							self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_ )
       UpperCamelCase				:   str          =							tgt_lang_id
       return inputs







   def       a_							(							self    ,      SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ = None ):
       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(SCREAMING_SNAKE_CASE_ ):
           logger.error(f'Vocabulary path ({save_directory}) should be a directory' )
           return
       UpperCamelCase				:   Optional[int]          =							os.path.join(
           SCREAMING_SNAKE_CASE_    ,      (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )

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

       return (out_vocab_file,)




