


from typing import TYPE_CHECKING

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


__UpperCAmelCase : List[str] 			=				{"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase : List[Any] 			=				["YolosFeatureExtractor"]
  __UpperCAmelCase : List[str] 			=				["YolosImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase : List[Any] 			=				[
      "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST",
      "YolosForObjectDetection",
      "YolosModel",
      "YolosPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_yolos import YolosFeatureExtractor
    from .image_processing_yolos import YolosImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_yolos import (
        YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST,
        YolosForObjectDetection,
        YolosModel,
        YolosPreTrainedModel,
    )


else:
  import sys

  __UpperCAmelCase : Optional[int] 			=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





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_mbart import MBartTokenizer
else:
  __UpperCAmelCase : Optional[int] 			=				None


__UpperCAmelCase : int 			=				logging.get_logger(__name__)


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

__UpperCAmelCase : str 			=				{
    "vocab_file": {
        "facebook/mbart-large-en-ro": (
            "https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model"
        ),
        "facebook/mbart-large-cc25": (
            "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model"
        ),
    },
    "tokenizer_file": {
        "facebook/mbart-large-en-ro": "https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json",
        "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json",
    },
}

__UpperCAmelCase : Union[str, Any] 			=				{
    "facebook/mbart-large-en-ro": 1024,
    "facebook/mbart-large-cc25": 1024,
}

# fmt: off
__UpperCAmelCase : Any 			=				["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"]



class    UpperCAmelCase_	(							_a):
       '''simple docstring'''
       __UpperCamelCase      :     List[str]							=					VOCAB_FILES_NAMES
       __UpperCamelCase      :     str							=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       __UpperCamelCase      :     Tuple							=					PRETRAINED_VOCAB_FILES_MAP
       __UpperCamelCase      :     Union[str, Any]							=					["input_ids", "attention_mask"]
       __UpperCamelCase      :     Any							=					MBartTokenizer

       __UpperCamelCase      :     List[int]							=					[]
       __UpperCamelCase      :     List[int]							=					[]






       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 ,					):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		AddedToken(__SCREAMING_SNAKE_CASE ,					lstrip=__SCREAMING_SNAKE_CASE ,					rstrip=__SCREAMING_SNAKE_CASE						) if isinstance(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						) else mask_token

              super().__init__(
                  vocab_file=__SCREAMING_SNAKE_CASE ,					tokenizer_file=__SCREAMING_SNAKE_CASE ,					bos_token=__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 ,					src_lang=__SCREAMING_SNAKE_CASE ,					tgt_lang=__SCREAMING_SNAKE_CASE ,					additional_special_tokens=__SCREAMING_SNAKE_CASE ,					**__SCREAMING_SNAKE_CASE ,					)

              UpperCamelCase    :	Dict   	=		vocab_file
              UpperCamelCase    :	List[str]   	=		False if not self.vocab_file else True

              UpperCamelCase    :	List[Any]   	=		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}						)
              UpperCamelCase    :	List[Any]   	=		{
                  lang_code: self.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE						) for lang_code in FAIRSEQ_LANGUAGE_CODES
              }

              UpperCamelCase    :	Dict   	=		src_lang if src_lang is not None else '''en_XX'''
              UpperCamelCase    :	List[Any]   	=		self.convert_tokens_to_ids(self._src_lang						)
              UpperCamelCase    :	str   	=		tgt_lang
              self.set_src_lang_special_tokens(self._src_lang						)






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return self._src_lang






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




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		new_src_lang
              self.set_src_lang_special_tokens(self._src_lang						)






       def  _lowercase   (     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  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE = None						):




              """simple docstring"""




              UpperCamelCase    :	str   	=		[self.sep_token_id]
              UpperCamelCase    :	Union[str, 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  _lowercase   (     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'''						)
              UpperCamelCase    :	List[str]   	=		src_lang
              UpperCamelCase    :	Dict   	=		self(__SCREAMING_SNAKE_CASE ,					add_special_tokens=__SCREAMING_SNAKE_CASE ,					return_tensors=__SCREAMING_SNAKE_CASE ,					**__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	List[Any]   	=		self.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	Any   	=		tgt_lang_id
              return inputs






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE = "en_XX" ,					__SCREAMING_SNAKE_CASE = None ,					__SCREAMING_SNAKE_CASE = "ro_RO" ,					**__SCREAMING_SNAKE_CASE ,					):




              """simple docstring"""




              UpperCamelCase    :	Optional[Any]   	=		src_lang
              UpperCamelCase    :	Optional[int]   	=		tgt_lang
              return super().prepare_seqaseq_batch(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					**__SCREAMING_SNAKE_CASE						)






       def  _lowercase   (     self						):




              """simple docstring"""




              return self.set_src_lang_special_tokens(self.src_lang						)






       def  _lowercase   (     self						):




              """simple docstring"""




              return self.set_tgt_lang_special_tokens(self.tgt_lang						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		self.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	Any   	=		[]
              UpperCamelCase    :	Dict   	=		[self.eos_token_id, self.cur_lang_code]

              UpperCamelCase    :	Union[str, Any]   	=		self.convert_ids_to_tokens(self.prefix_tokens						)
              UpperCamelCase    :	int   	=		self.convert_ids_to_tokens(self.suffix_tokens						)

              UpperCamelCase    :	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  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		self.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	int   	=		[]
              UpperCamelCase    :	Optional[Any]   	=		[self.eos_token_id, self.cur_lang_code]

              UpperCamelCase    :	Optional[Any]   	=		self.convert_ids_to_tokens(self.prefix_tokens						)
              UpperCamelCase    :	List[str]   	=		self.convert_ids_to_tokens(self.suffix_tokens						)

              UpperCamelCase    :	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  _lowercase   (     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(__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,)

