



import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_PRETRAINING_MAPPING,
							    ElectraForCausalLM,
							    ElectraForMaskedLM,
							    ElectraForMultipleChoice,
							    ElectraForPreTraining,
							    ElectraForQuestionAnswering,
							    ElectraForSequenceClassification,
							    ElectraForTokenClassification,
							    ElectraModel,
							)
							from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST
class  _snake_case	:




				def __init__(  self    :  Dict,    __lowercase    :  Dict,    __lowercase    :  str=13,    __lowercase    :  int=7,    __lowercase    :  Dict=True,    __lowercase    :  Tuple=True,    __lowercase    :  str=True,    __lowercase    :  List[Any]=True,    __lowercase    :  List[str]=99,    __lowercase    :  Dict=32,    __lowercase    :  List[Any]=5,    __lowercase    :  str=4,    __lowercase    :  Any=37,    __lowercase    :  Tuple="gelu",    __lowercase    :  Union[str, Any]=0.1,    __lowercase    :  int=0.1,    __lowercase    :  Tuple=512,    __lowercase    :  int=16,    __lowercase    :  int=2,    __lowercase    :  str=0.02,    __lowercase    :  str=3,    __lowercase    :  Optional[int]=4,    __lowercase    :  str=None,    ):
							lowercase__         = parent
							lowercase__         = batch_size
							lowercase__         = seq_length
							lowercase__         = is_training
							lowercase__         = use_input_mask
							lowercase__         = use_token_type_ids
							lowercase__         = use_labels
							lowercase__         = vocab_size
							lowercase__         = hidden_size
							lowercase__         = num_hidden_layers
							lowercase__         = num_attention_heads
							lowercase__         = intermediate_size
							lowercase__         = hidden_act
							lowercase__         = hidden_dropout_prob
							lowercase__         = attention_probs_dropout_prob
							lowercase__         = max_position_embeddings
							lowercase__         = type_vocab_size
							lowercase__         = type_sequence_label_size
							lowercase__         = initializer_range
							lowercase__         = num_labels
							lowercase__         = num_choices
							lowercase__         = scope




				def 							A__					(  self    :  Tuple  ):
							lowercase__         = ids_tensor([self.batch_size, self.seq_length],    self.vocab_size  )

							lowercase__         = None
							if self.use_input_mask:
										lowercase__         = random_attention_mask([self.batch_size, self.seq_length]  )

							lowercase__         = None
							if self.use_token_type_ids:
										lowercase__         = ids_tensor([self.batch_size, self.seq_length],    self.type_vocab_size  )

							lowercase__         = None
							lowercase__         = None
							lowercase__         = None
							if self.use_labels:
										lowercase__         = ids_tensor([self.batch_size],    self.type_sequence_label_size  )
										lowercase__         = ids_tensor([self.batch_size, self.seq_length],    self.num_labels  )
										lowercase__         = ids_tensor([self.batch_size],    self.num_choices  )
										lowercase__         = ids_tensor([self.batch_size, self.seq_length],    1  )

							lowercase__         = self.get_config()

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    fake_token_labels,
							)




				def 							A__					(  self    :  Any  ):
							return ElectraConfig(
							    vocab_size=self.vocab_size,    hidden_size=self.hidden_size,    num_hidden_layers=self.num_hidden_layers,    num_attention_heads=self.num_attention_heads,    intermediate_size=self.intermediate_size,    hidden_act=self.hidden_act,    hidden_dropout_prob=self.hidden_dropout_prob,    attention_probs_dropout_prob=self.attention_probs_dropout_prob,    max_position_embeddings=self.max_position_embeddings,    type_vocab_size=self.type_vocab_size,    is_decoder=__a,    initializer_range=self.initializer_range,    )




				def 							A__					(  self    :  Optional[int]  ):
							(
							    lowercase__     
							)         = self.prepare_config_and_inputs()

							lowercase__         = True
							lowercase__         = floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
							lowercase__         = ids_tensor([self.batch_size, self.seq_length],    vocab_size=2  )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    encoder_hidden_states,
							    encoder_attention_mask,
							)




				def 							A__					(  self    :  List[str],    __lowercase    :  Optional[int],    __lowercase    :  Any,    __lowercase    :  int,    __lowercase    :  Optional[Any],    __lowercase    :  Optional[int],    __lowercase    :  Any,    __lowercase    :  Any,    __lowercase    :  List[str],    ):
							lowercase__         = ElectraModel(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a  )
							lowercase__         = model(__a,    token_type_ids=__a  )
							lowercase__         = model(__a  )
							self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size)  )




				def 							A__					(  self    :  int,    __lowercase    :  List[str],    __lowercase    :  Tuple,    __lowercase    :  Optional[int],    __lowercase    :  Tuple,    __lowercase    :  str,    __lowercase    :  Tuple,    __lowercase    :  Optional[int],    __lowercase    :  Dict,    __lowercase    :  List[str],    ):
							lowercase__         = True
							lowercase__         = ElectraModel(__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(
							    __a,    attention_mask=__a,    token_type_ids=__a,    encoder_hidden_states=__a,    encoder_attention_mask=__a,    )
							lowercase__         = model(
							    __a,    attention_mask=__a,    token_type_ids=__a,    encoder_hidden_states=__a,    )
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a  )
							self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size)  )




				def 							A__					(  self    :  Optional[int],    __lowercase    :  int,    __lowercase    :  Any,    __lowercase    :  int,    __lowercase    :  Union[str, Any],    __lowercase    :  int,    __lowercase    :  Union[str, Any],    __lowercase    :  Any,    __lowercase    :  str,    ):
							lowercase__         = ElectraForMaskedLM(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a,    labels=__a  )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.vocab_size)  )




				def 							A__					(  self    :  List[str],    __lowercase    :  Dict,    __lowercase    :  int,    __lowercase    :  Tuple,    __lowercase    :  str,    __lowercase    :  Optional[int],    __lowercase    :  List[str],    __lowercase    :  Optional[Any],    __lowercase    :  Union[str, Any],    __lowercase    :  Dict,    ):
							lowercase__         = ElectraForCausalLM(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a,    labels=__a  )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.vocab_size)  )




				def 							A__					(  self    :  List[Any],    __lowercase    :  Tuple,    __lowercase    :  Tuple,    __lowercase    :  Optional[Any],    __lowercase    :  int,    __lowercase    :  int,    __lowercase    :  Any,    __lowercase    :  str,    __lowercase    :  Optional[int],    ):
							lowercase__         = self.num_labels
							lowercase__         = ElectraForTokenClassification(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a,    labels=__a  )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.num_labels)  )




				def 							A__					(  self    :  Dict,    __lowercase    :  Optional[Any],    __lowercase    :  List[Any],    __lowercase    :  Optional[int],    __lowercase    :  Union[str, Any],    __lowercase    :  Any,    __lowercase    :  Optional[Any],    __lowercase    :  Optional[Any],    __lowercase    :  Tuple,    ):
							lowercase__         = self.num_labels
							lowercase__         = ElectraForPreTraining(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a,    labels=__a  )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length)  )




				def 							A__					(  self    :  str,    __lowercase    :  Optional[int],    __lowercase    :  Optional[int],    __lowercase    :  Optional[int],    __lowercase    :  str,    __lowercase    :  List[Any],    __lowercase    :  List[str],    __lowercase    :  Optional[int],    __lowercase    :  Optional[Any],    ):
							lowercase__         = self.num_labels
							lowercase__         = ElectraForSequenceClassification(__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(__a,    attention_mask=__a,    token_type_ids=__a,    labels=__a  )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels)  )




				def 							A__					(  self    :  Optional[int],    __lowercase    :  int,    __lowercase    :  int,    __lowercase    :  Union[str, Any],    __lowercase    :  Union[str, Any],    __lowercase    :  Any,    __lowercase    :  Union[str, Any],    __lowercase    :  Tuple,    __lowercase    :  Optional[int],    ):
							lowercase__         = ElectraForQuestionAnswering(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = model(
							    __a,    attention_mask=__a,    token_type_ids=__a,    start_positions=__a,    end_positions=__a,    )
							self.parent.assertEqual(result.start_logits.shape,    (self.batch_size, self.seq_length)  )
							self.parent.assertEqual(result.end_logits.shape,    (self.batch_size, self.seq_length)  )




				def 							A__					(  self    :  Optional[Any],    __lowercase    :  Dict,    __lowercase    :  List[str],    __lowercase    :  Optional[Any],    __lowercase    :  List[Any],    __lowercase    :  Dict,    __lowercase    :  Any,    __lowercase    :  Any,    __lowercase    :  Dict,    ):
							lowercase__         = self.num_choices
							lowercase__         = ElectraForMultipleChoice(config=__a  )
							model.to(__a  )
							model.eval()
							lowercase__         = input_ids.unsqueeze(1  ).expand(-1,    self.num_choices,    -1  ).contiguous()
							lowercase__         = token_type_ids.unsqueeze(1  ).expand(-1,    self.num_choices,    -1  ).contiguous()
							lowercase__         = input_mask.unsqueeze(1  ).expand(-1,    self.num_choices,    -1  ).contiguous()
							lowercase__         = model(
							    __a,    attention_mask=__a,    token_type_ids=__a,    labels=__a,    )
							self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_choices)  )




				def 							A__					(  self    :  Optional[int]  ):
							lowercase__         = self.prepare_config_and_inputs()
							(
							    lowercase__     
							)         = config_and_inputs
							lowercase__         = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
							return config, inputs_dict
@require_torch
class  _snake_case	(    _UpperCamelCase			,		_UpperCamelCase			,		unittest.TestCase):
				UpperCamelCase__ :    Dict   						=(
				    (
				        ElectraModel,
				        ElectraForPreTraining,
				        ElectraForMaskedLM,
				        ElectraForCausalLM,
				        ElectraForMultipleChoice,
				        ElectraForTokenClassification,
				        ElectraForSequenceClassification,
				        ElectraForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase__ :    List[str]   						=(
				    {
				        "feature-extraction": ElectraModel,
				        "fill-mask": ElectraForMaskedLM,
				        "question-answering": ElectraForQuestionAnswering,
				        "text-classification": ElectraForSequenceClassification,
				        "text-generation": ElectraForCausalLM,
				        "token-classification": ElectraForTokenClassification,
				        "zero-shot": ElectraForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				UpperCamelCase__ :    List[str]   						=True




				def 							A__					(  self    :  Tuple,    __lowercase    :  List[Any],    __lowercase    :  List[str],    __lowercase    :  int=False  ):
							lowercase__         = super()._prepare_for_class(__a,    __a,    return_labels=__a  )

							if return_labels:
										if model_class in get_values(__a  ):
													lowercase__         = torch.zeros(
													    (self.model_tester.batch_size, self.model_tester.seq_length),    dtype=torch.long,    device=__a  )
							return inputs_dict




				def 							A__					(  self    :  Any  ):
							lowercase__         = ElectraModelTester(self  )
							lowercase__         = ConfigTester(self,    config_class=__a,    hidden_size=37  )




				def 							A__					(  self    :  Tuple  ):
							self.config_tester.run_common_tests()




				def 							A__					(  self    :  Tuple  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_model(*__a  )




				def 							A__					(  self    :  Dict  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs_for_decoder()
							self.model_tester.create_and_check_electra_model_as_decoder(*__a  )




				def 							A__					(  self    :  Dict  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
										lowercase__         = type
										self.model_tester.create_and_check_electra_model(*__a  )




				def 							A__					(  self    :  Tuple  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_masked_lm(*__a  )




				def 							A__					(  self    :  Union[str, Any]  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_token_classification(*__a  )




				def 							A__					(  self    :  List[str]  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_pretraining(*__a  )




				def 							A__					(  self    :  Optional[Any]  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_sequence_classification(*__a  )




				def 							A__					(  self    :  Union[str, Any]  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_question_answering(*__a  )




				def 							A__					(  self    :  Tuple  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_electra_for_multiple_choice(*__a  )




				@slow
				def 							A__					(  self    :  Dict  ):
							for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase__         = ElectraModel.from_pretrained(__a  )
										self.assertIsNotNone(__a  )




				def 							A__					(  self    :  Optional[int]  ):
							lowercase__         = self.model_tester.prepare_config_and_inputs_for_decoder()
							self.model_tester.create_and_check_electra_for_causal_lm(*__a  )
@require_torch
class  _snake_case	(    unittest.TestCase):




				@slow
				def 							A__					(  self    :  Tuple  ):
							lowercase__         = ElectraModel.from_pretrained("google/electra-small-discriminator"  )
							lowercase__         = torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
							lowercase__         = torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
							lowercase__         = model(__a,    attention_mask=__a  )[0]
							lowercase__         = torch.Size((1, 11, 256)  )
							self.assertEqual(output.shape,    __a  )
							lowercase__         = torch.tensor(
							    [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]]  )

							self.assertTrue(torch.allclose(output[:, 1:4, 1:4],    __a,    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,)
