





import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch
       from torch import nn

       from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
       from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
       from PIL import Image

       from transformers import SwinaSRImageProcessor





class 	lowerCAmelCase__:






       '''simple docstring'''


       def __init__(					self			,  __lowerCamelCase			,  __lowerCamelCase=1_3			,  __lowerCamelCase=3_2			,  __lowerCamelCase=1			,  __lowerCamelCase=3			,  __lowerCamelCase=1_6			,  __lowerCamelCase=[1, 2, 1]			,  __lowerCamelCase=[2, 2, 4]			,  __lowerCamelCase=2			,  __lowerCamelCase=2.0			,  __lowerCamelCase=True			,  __lowerCamelCase=0.0			,  __lowerCamelCase=0.0			,  __lowerCamelCase=0.1			,  __lowerCamelCase="gelu"			,  __lowerCamelCase=False			,  __lowerCamelCase=True			,  __lowerCamelCase=0.02			,  __lowerCamelCase=1E-5			,  __lowerCamelCase=True			,  __lowerCamelCase=None			,  __lowerCamelCase=False			,  __lowerCamelCase=2			,  )	->   List[str]:
            _SCREAMING_SNAKE_CASE				:		str  			=							parent
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							batch_size
            _SCREAMING_SNAKE_CASE				:		int  			=							image_size
            _SCREAMING_SNAKE_CASE				:		int  			=							patch_size
            _SCREAMING_SNAKE_CASE				:		Dict  			=							num_channels
            _SCREAMING_SNAKE_CASE				:		Any  			=							embed_dim
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							depths
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							num_heads
            _SCREAMING_SNAKE_CASE				:		int  			=							window_size
            _SCREAMING_SNAKE_CASE				:		Any  			=							mlp_ratio
            _SCREAMING_SNAKE_CASE				:		Dict  			=							qkv_bias
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							hidden_dropout_prob
            _SCREAMING_SNAKE_CASE				:		str  			=							attention_probs_dropout_prob
            _SCREAMING_SNAKE_CASE				:		Dict  			=							drop_path_rate
            _SCREAMING_SNAKE_CASE				:		Any  			=							hidden_act
            _SCREAMING_SNAKE_CASE				:		Any  			=							use_absolute_embeddings
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							patch_norm
            _SCREAMING_SNAKE_CASE				:		Dict  			=							layer_norm_eps
            _SCREAMING_SNAKE_CASE				:		int  			=							initializer_range
            _SCREAMING_SNAKE_CASE				:		int  			=							is_training
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							scope
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							use_labels
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							upscale

            # here we set some attributes to make tests pass
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							len(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							embed_dim
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							(image_size // patch_size) ** 2




       def 			UpperCamelCase_	(					self							)	->   List[str]:
            _SCREAMING_SNAKE_CASE				:		int  			=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							None
            if self.use_labels:
                 _SCREAMING_SNAKE_CASE				:		str  			=							ids_tensor([self.batch_size]			,  self.type_sequence_label_size							)

            _SCREAMING_SNAKE_CASE				:		Dict  			=							self.get_config()

            return config, pixel_values, labels




       def 			UpperCamelCase_	(					self							)	->   Optional[Any]:
            return SwinaSRConfig(
                image_size=self.image_size			,  patch_size=self.patch_size			,  num_channels=self.num_channels			,  embed_dim=self.embed_dim			,  depths=self.depths			,  num_heads=self.num_heads			,  window_size=self.window_size			,  mlp_ratio=self.mlp_ratio			,  qkv_bias=self.qkv_bias			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  drop_path_rate=self.drop_path_rate			,  hidden_act=self.hidden_act			,  use_absolute_embeddings=self.use_absolute_embeddings			,  path_norm=self.patch_norm			,  layer_norm_eps=self.layer_norm_eps			,  initializer_range=self.initializer_range			,  upscale=self.upscale			,  )




       def 			UpperCamelCase_	(					self			,  __lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE				:		Any  			=							SwinaSRModel(config=__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()
            _SCREAMING_SNAKE_CASE				:		str  			=							model(__lowerCamelCase							)

            self.parent.assertEqual(
                result.last_hidden_state.shape			,  (self.batch_size, self.embed_dim, self.image_size, self.image_size)							)




       def 			UpperCamelCase_	(					self			,  __lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							SwinaSRForImageSuperResolution(__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							model(__lowerCamelCase							)

            _SCREAMING_SNAKE_CASE				:		Any  			=							self.image_size * self.upscale
            self.parent.assertEqual(
                result.reconstruction.shape			,  (self.batch_size, self.num_channels, expected_image_size, expected_image_size)							)







       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							self.prepare_config_and_inputs()
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		List[str]  			=							config_and_inputs
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							{"pixel_values": pixel_values}
            return config, inputs_dict





@require_torch
class 	lowerCAmelCase__(       __lowercase     ,   __lowercase     ,   unittest.TestCase			):






       '''simple docstring'''


       __snake_case       	=			(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
       __snake_case       	=			{'feature-extraction': SwinaSRModel} if is_torch_available() else {}

       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False




       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							SwinaSRModelTester(self							)
            _SCREAMING_SNAKE_CASE				:		str  			=							ConfigTester(self			,  config_class=__lowerCamelCase			,  embed_dim=3_7							)




       def 			UpperCamelCase_	(					self							)	->   Any:
            self.config_tester.create_and_test_config_to_json_string()
            self.config_tester.create_and_test_config_to_json_file()
            self.config_tester.create_and_test_config_from_and_save_pretrained()
            self.config_tester.create_and_test_config_with_num_labels()
            self.config_tester.check_config_can_be_init_without_params()
            self.config_tester.check_config_arguments_init()




       def 			UpperCamelCase_	(					self							)	->   int:
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCamelCase							)




       def 			UpperCamelCase_	(					self							)	->   Optional[Any]:
            _SCREAMING_SNAKE_CASE				:		Any  			=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_super_resolution(*__lowerCamelCase							)




       @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."							)
       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            pass




       @unittest.skip(reason="Swin2SR does not use inputs_embeds"							)
       def 			UpperCamelCase_	(					self							)	->   List[str]:
            pass




       @unittest.skip(reason="Swin2SR does not support training yet"							)
       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            pass




       @unittest.skip(reason="Swin2SR does not support training yet"							)
       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            pass




       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		str  			=							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							model_class(__lowerCamelCase							)
                 self.assertIsInstance(model.get_input_embeddings()			,  (nn.Module)							)
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(__lowerCamelCase			,  nn.Linear							)							)




       def 			UpperCamelCase_	(					self							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		Optional[int]  			=							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 _SCREAMING_SNAKE_CASE				:		str  			=							model_class(__lowerCamelCase							)
                 _SCREAMING_SNAKE_CASE				:		List[Any]  			=							inspect.signature(model.forward							)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 _SCREAMING_SNAKE_CASE				:		int  			=							[*signature.parameters.keys()]

                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							["pixel_values"]
                 self.assertListEqual(arg_names[:1]			,  __lowerCamelCase							)




       @slow
       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _SCREAMING_SNAKE_CASE				:		str  			=							SwinaSRModel.from_pretrained(__lowerCamelCase							)
                 self.assertIsNotNone(__lowerCamelCase							)




       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		str  			=							self.model_tester.prepare_config_and_inputs_for_common()

            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							_config_zero_init(__lowerCamelCase							)
            for model_class in self.all_model_classes:
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							model_class(config=__lowerCamelCase							)
                 for name, param in model.named_parameters():
                      if "logit_scale" in name:
                           continue
                      if param.requires_grad:
                           self.assertIn(
                               ((param.data.mean() * 1E9).round() / 1E9).item()			,  [0.0, 1.0]			,  msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""			,  )







       def 			UpperCamelCase_	(					self							)	->   List[str]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		str  			=							self.model_tester.prepare_config_and_inputs_for_common()
            _SCREAMING_SNAKE_CASE				:		Any  			=							True

            for model_class in self.all_model_classes:
                 _SCREAMING_SNAKE_CASE				:		List[Any]  			=							True
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							False
                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							True
                 _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							model_class(__lowerCamelCase							)
                 model.to(__lowerCamelCase							)
                 model.eval()
                 with torch.no_grad():
                      _SCREAMING_SNAKE_CASE				:		Tuple  			=							model(**self._prepare_for_class(__lowerCamelCase			,  __lowerCamelCase							)							)
                 _SCREAMING_SNAKE_CASE				:		List[Any]  			=							outputs.attentions
                 _SCREAMING_SNAKE_CASE				:		List[str]  			=							len(self.model_tester.depths							)
                 self.assertEqual(len(__lowerCamelCase							)			,  __lowerCamelCase							)

                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							True
                 _SCREAMING_SNAKE_CASE				:		List[str]  			=							config.window_size**2
                 _SCREAMING_SNAKE_CASE				:		int  			=							model_class(__lowerCamelCase							)
                 model.to(__lowerCamelCase							)
                 model.eval()
                 with torch.no_grad():
                      _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							model(**self._prepare_for_class(__lowerCamelCase			,  __lowerCamelCase							)							)
                 _SCREAMING_SNAKE_CASE				:		Dict  			=							outputs.attentions
                 self.assertEqual(len(__lowerCamelCase							)			,  __lowerCamelCase							)

                 self.assertListEqual(
                     list(attentions[0].shape[-3:]							)			,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared]			,  )
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							len(__lowerCamelCase							)

                 # Check attention is always last and order is fine
                 _SCREAMING_SNAKE_CASE				:		List[Any]  			=							True
                 _SCREAMING_SNAKE_CASE				:		str  			=							True
                 _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							model_class(__lowerCamelCase							)
                 model.to(__lowerCamelCase							)
                 model.eval()
                 with torch.no_grad():
                      _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							model(**self._prepare_for_class(__lowerCamelCase			,  __lowerCamelCase							)							)

                 self.assertEqual(out_len + 1			,  len(__lowerCamelCase							)							)

                 _SCREAMING_SNAKE_CASE				:		Dict  			=							outputs.attentions

                 self.assertEqual(len(__lowerCamelCase							)			,  __lowerCamelCase							)

                 self.assertListEqual(
                     list(self_attentions[0].shape[-3:]							)			,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared]			,  )





@require_vision
@require_torch
@slow
class 	lowerCAmelCase__(       unittest.TestCase			):






       '''simple docstring'''


       def 			UpperCamelCase_	(					self							)	->   Any:
            _SCREAMING_SNAKE_CASE				:		int  			=							SwinaSRImageProcessor()
            _SCREAMING_SNAKE_CASE				:		Any  			=							SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"							).to(__lowerCamelCase							)

            _SCREAMING_SNAKE_CASE				:		str  			=							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							processor(images=__lowerCamelCase			,  return_tensors="pt"							).to(__lowerCamelCase							)

            # forward pass
            with torch.no_grad():
                 _SCREAMING_SNAKE_CASE				:		int  			=							model(**__lowerCamelCase							)

            # verify the logits
            _SCREAMING_SNAKE_CASE				:		int  			=							torch.Size([1, 3, 9_7_6, 1_2_9_6]							)
            self.assertEqual(outputs.reconstruction.shape			,  __lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							torch.tensor(
                [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]							).to(__lowerCamelCase							)
            self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]			,  __lowerCamelCase			,  atol=1E-4							)							)






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


lowerCamelCase__      =      logging.get_logger(__name__)

lowerCamelCase__      =      {"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

lowerCamelCase__      =      {
    "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"
        ),
    },
}

lowerCamelCase__      =      {
    "facebook/mbart-large-50-one-to-many-mmt": 1024,
}

# fmt: off
lowerCamelCase__      =      ["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    __SCREAMING_SNAKE_CASE			(  _UpperCamelCase      ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:Tuple		   =    VOCAB_FILES_NAMES
  SCREAMING_SNAKE_CASE__							:List[Any]		   =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  SCREAMING_SNAKE_CASE__							:Union[str, Any]		   =    PRETRAINED_VOCAB_FILES_MAP
  SCREAMING_SNAKE_CASE__							:int		   =    ["input_ids", "attention_mask"]
  SCREAMING_SNAKE_CASE__							:Dict		   =    MBartaaTokenizer

  SCREAMING_SNAKE_CASE__							:List[int]		   =    []
  SCREAMING_SNAKE_CASE__							:List[int]		   =    []

  def __init__(						self      :				str    ,      __a      :				int=None    ,      __a      :				List[str]=None    ,      __a      :				Optional[Any]=None    ,      __a      :				List[str]=None    ,      __a      :				Tuple="</s>"    ,      __a      :				Union[str, Any]="</s>"    ,      __a      :				str="<s>"    ,      __a      :				Any="<unk>"    ,      __a      :				List[str]="<pad>"    ,      __a      :				Optional[Any]="<mask>"    ,      **__a      :				Any    ,      )						-> Union[str, Any]:
        # Mask token behave like a normal word, i.e. include the space before it
        _UpperCamelCase					:		Dict  =				AddedToken(__a    ,      lstrip=__a    ,      rstrip=__a		) if isinstance(__a    ,      __a		) else mask_token

        _UpperCamelCase					:		str  =				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    ,      )

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

        _UpperCamelCase					:		int  =				{
            lang_code: self.convert_tokens_to_ids(__a		) for lang_code in FAIRSEQ_LANGUAGE_CODES
        }

        _UpperCamelCase					:		List[str]  =				src_lang if src_lang is not None else "en_XX"
        _UpperCamelCase					:		Dict  =				tgt_lang
        _UpperCamelCase					:		int  =				self.lang_code_to_id[self._src_lang]
        self.set_src_lang_special_tokens(self._src_lang		)

  @property
  def       __SCREAMING_SNAKE_CASE (						self      :				Optional[int]		)						-> str:
        return self._src_lang

  @src_lang.setter
  def       __SCREAMING_SNAKE_CASE (						self      :				Union[str, Any]    ,      __a      :				str		)						-> None:
        _UpperCamelCase					:		int  =				new_src_lang
        self.set_src_lang_special_tokens(self._src_lang		)

  def       __SCREAMING_SNAKE_CASE (						self      :				Optional[int]    ,      __a      :				List[int]    ,      __a      :				Optional[List[int]] = None		)						-> List[int]:
        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       __SCREAMING_SNAKE_CASE (						self      :				Any    ,      __a      :				List[str]    ,      __a      :				str = "en_XX"    ,      __a      :				Optional[List[str]] = None    ,      __a      :				str = "ro_RO"    ,      **__a      :				Tuple    ,      )						-> BatchEncoding:
        _UpperCamelCase					:		List[Any]  =				src_lang
        _UpperCamelCase					:		Union[str, Any]  =				tgt_lang
        return super().prepare_seqaseq_batch(__a    ,      __a    ,      **__a		)

  def       __SCREAMING_SNAKE_CASE (						self      :				List[str]		)						-> int:
        return self.set_src_lang_special_tokens(self.src_lang		)

  def       __SCREAMING_SNAKE_CASE (						self      :				Tuple		)						-> Tuple:
        return self.set_tgt_lang_special_tokens(self.tgt_lang		)

  def       __SCREAMING_SNAKE_CASE (						self      :				List[str]    ,      __a      :				str		)						-> None:
        _UpperCamelCase					:		List[Any]  =				self.convert_tokens_to_ids(__a		)
        _UpperCamelCase					:		Union[str, Any]  =				[self.cur_lang_code_id]
        _UpperCamelCase					:		List[Any]  =				[self.eos_token_id]

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

        _UpperCamelCase					:		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       __SCREAMING_SNAKE_CASE (						self      :				Dict    ,      __a      :				str		)						-> None:
        _UpperCamelCase					:		Tuple  =				self.convert_tokens_to_ids(__a		)
        _UpperCamelCase					:		Union[str, Any]  =				[self.cur_lang_code_id]
        _UpperCamelCase					:		Optional[Any]  =				[self.eos_token_id]

        _UpperCamelCase					:		int  =				self.convert_ids_to_tokens(self.prefix_tokens		)
        _UpperCamelCase					:		Any  =				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       __SCREAMING_SNAKE_CASE (						self      :				Dict    ,      __a      :				Optional[int]    ,      __a      :				str    ,      __a      :				Optional[str]    ,      __a      :				Optional[str]    ,      **__a      :				int		)						-> List[str]:
        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					:		List[str]  =				self(__a    ,      add_special_tokens=__a    ,      return_tensors=__a    ,      **__a		)
        _UpperCamelCase					:		str  =				self.convert_tokens_to_ids(__a		)
        _UpperCamelCase					:		str  =				tgt_lang_id
        return inputs


  def       __SCREAMING_SNAKE_CASE (						self      :				Union[str, Any]    ,      __a      :				str    ,      __a      :				Optional[str] = None		)						-> Tuple[str]:
        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
        _UpperCamelCase					:		int  =				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,)
