






from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TFCvtForImageClassification, TFCvtModel
				from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor

class 		_snake_case	(	A__       ):






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Union[str, Any]:
						SCREAMING_SNAKE_CASE							=			self.config_class(**self.inputs_dict)
						self.parent.assertTrue(hasattr(a		,       'embed_dim'))
						self.parent.assertTrue(hasattr(a		,       'num_heads'))



class 		_snake_case	:






			def __init__(							self		,       a		,       a=13		,       a=64		,       a=3		,       a=[16, 48, 96]		,       a=[1, 3, 6]		,       a=[1, 2, 10]		,       a=[7, 3, 3]		,       a=[4, 2, 2]		,       a=[2, 1, 1]		,       a=[2, 2, 2]		,       a=[False, False, True]		,       a=[0.0, 0.0, 0.0]		,       a=0.02		,       a=1E-12		,       a=True		,       a=True		,       a=2		,       )   ->							str:
						SCREAMING_SNAKE_CASE							=			parent
						SCREAMING_SNAKE_CASE							=			batch_size
						SCREAMING_SNAKE_CASE							=			image_size
						SCREAMING_SNAKE_CASE							=			patch_sizes
						SCREAMING_SNAKE_CASE							=			patch_stride
						SCREAMING_SNAKE_CASE							=			patch_padding
						SCREAMING_SNAKE_CASE							=			is_training
						SCREAMING_SNAKE_CASE							=			use_labels
						SCREAMING_SNAKE_CASE							=			num_labels
						SCREAMING_SNAKE_CASE							=			num_channels
						SCREAMING_SNAKE_CASE							=			embed_dim
						SCREAMING_SNAKE_CASE							=			num_heads
						SCREAMING_SNAKE_CASE							=			stride_kv
						SCREAMING_SNAKE_CASE							=			depth
						SCREAMING_SNAKE_CASE							=			cls_token
						SCREAMING_SNAKE_CASE							=			attention_drop_rate
						SCREAMING_SNAKE_CASE							=			initializer_range
						SCREAMING_SNAKE_CASE							=			layer_norm_eps






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						SCREAMING_SNAKE_CASE							=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

						SCREAMING_SNAKE_CASE							=			None
						if self.use_labels:
									# create a random int32 tensor of given shape
									SCREAMING_SNAKE_CASE							=			ids_tensor([self.batch_size]		,       self.num_labels)

						SCREAMING_SNAKE_CASE							=			self.get_config()
						return config, pixel_values, labels






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Union[str, Any]:
						return CvtConfig(
						    image_size=self.image_size		,       num_labels=self.num_labels		,       num_channels=self.num_channels		,       embed_dim=self.embed_dim		,       num_heads=self.num_heads		,       patch_sizes=self.patch_sizes		,       patch_padding=self.patch_padding		,       patch_stride=self.patch_stride		,       stride_kv=self.stride_kv		,       depth=self.depth		,       cls_token=self.cls_token		,       attention_drop_rate=self.attention_drop_rate		,       initializer_range=self.initializer_range		,       )






			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a		,       a)   ->							Dict:
						SCREAMING_SNAKE_CASE							=			TFCvtModel(config=a)
						SCREAMING_SNAKE_CASE							=			model(a		,       training=a)
						SCREAMING_SNAKE_CASE							=			(self.image_size, self.image_size)
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			image_size[0], image_size[1]
						for i in range(len(self.depth)):
									SCREAMING_SNAKE_CASE							=			floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1)
									SCREAMING_SNAKE_CASE							=			floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1)
						self.parent.assertEqual(result.last_hidden_state.shape		,       (self.batch_size, self.embed_dim[-1], height, width))






			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a		,       a)   ->							List[str]:
						SCREAMING_SNAKE_CASE							=			self.num_labels
						SCREAMING_SNAKE_CASE							=			TFCvtForImageClassification(a)
						SCREAMING_SNAKE_CASE							=			model(a		,       labels=a		,       training=a)
						self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.num_labels))







			def  SCREAMING_SNAKE_CASE__     (							self)   ->							int:
						SCREAMING_SNAKE_CASE							=			self.prepare_config_and_inputs()
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			config_and_inputs
						SCREAMING_SNAKE_CASE							=			{'pixel_values': pixel_values}
						return config, inputs_dict



@require_tf
class 		_snake_case	(	A__ ,     A__ ,     unittest.TestCase       ):
			_lowercase		:     Optional[Any]        =				(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
			_lowercase		:     str        =				(
			    {'''feature-extraction''': TFCvtModel, '''image-classification''': TFCvtForImageClassification}
			    if is_tf_available()
			    else {}
			)
			_lowercase		:     Dict        =				False
			_lowercase		:     Optional[int]        =				False
			_lowercase		:     Optional[Any]        =				False
			_lowercase		:     Dict        =				False
			_lowercase		:     List[Any]        =				False






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE							=			TFCvtModelTester(self)
						SCREAMING_SNAKE_CASE							=			TFCvtConfigTester(self		,       config_class=a		,       has_text_modality=a		,       hidden_size=37)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Union[str, Any]:
						self.config_tester.create_and_test_config_common_properties()
						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()






			@unittest.skip(reason='Cvt does not output attentions')
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						pass






			@unittest.skip(reason='Cvt does not use inputs_embeds')
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							str:
						pass






			@unittest.skip(reason='Cvt does not support input and output embeddings')
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[Any]:
						pass






			@unittest.skipIf(
			    not is_tf_available() or len(tf.config.list_physical_devices('GPU')) == 0		,       reason='TF does not support backprop for grouped convolutions on CPU.'		,       )
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						super().test_dataset_conversion()






			@unittest.skipIf(
			    not is_tf_available() or len(tf.config.list_physical_devices('GPU')) == 0		,       reason='TF does not support backprop for grouped convolutions on CPU.'		,       )
			@slow
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Any:
						super().test_keras_fit()






			@unittest.skip(reason='Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8')
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE							=			tf.keras.mixed_precision.Policy('mixed_float16')
						tf.keras.mixed_precision.set_global_policy(a)
						super().test_keras_fit()
						tf.keras.mixed_precision.set_global_policy('float32')






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE							=			model_class(a)
									SCREAMING_SNAKE_CASE							=			inspect.signature(model.call)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									SCREAMING_SNAKE_CASE							=			[*signature.parameters.keys()]

									SCREAMING_SNAKE_CASE							=			['pixel_values']
									self.assertListEqual(arg_names[:1]		,       a)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Union[str, Any]:
						def check_hidden_states_output(a		,       a		,       a):
									SCREAMING_SNAKE_CASE							=			model_class(a)

									SCREAMING_SNAKE_CASE							=			model(**self._prepare_for_class(a		,       a))
									SCREAMING_SNAKE_CASE							=			outputs.hidden_states

									SCREAMING_SNAKE_CASE							=			len(self.model_tester.depth)
									self.assertEqual(len(a)		,       a)

									# verify the first hidden states (first block)
									self.assertListEqual(
									    list(hidden_states[0].shape[-3:])		,       [
									        self.model_tester.embed_dim[0],
									        self.model_tester.image_size // 4,
									        self.model_tester.image_size // 4,
									    ]		,       )

						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE							=			True
									check_hidden_states_output(a		,       a		,       a)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									SCREAMING_SNAKE_CASE							=			True

									check_hidden_states_output(a		,       a		,       a)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[int]:
						SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*a)






			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE							=			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*a)







			@slow
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[str]:
						for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE							=			TFCvtModel.from_pretrained(a)
									self.assertIsNotNone(a)






def 					lowerCamelCase__					():
			SCREAMING_SNAKE_CASE							=			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
			return image







@require_tf
@require_vision
class 		_snake_case	(	unittest.TestCase       ):






			@cached_property
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							List[str]:
						return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0])







			@slow
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Optional[Any]:
						SCREAMING_SNAKE_CASE							=			TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0])

						SCREAMING_SNAKE_CASE							=			self.default_image_processor
						SCREAMING_SNAKE_CASE							=			prepare_img()
						SCREAMING_SNAKE_CASE							=			image_processor(images=a		,       return_tensors='tf')

						# forward pass
						SCREAMING_SNAKE_CASE							=			model(**a)

						# verify the logits
						SCREAMING_SNAKE_CASE							=			tf.TensorShape((1, 1000))
						self.assertEqual(outputs.logits.shape		,       a)

						SCREAMING_SNAKE_CASE							=			tf.constant([0.92_85, 0.90_15, -0.31_50])
						self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()		,       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_nllb import NllbTokenizer
else:
       __a  			=						None


__a  			=						logging.get_logger(__name__)


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

__a  			=						{
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/sentencepiece.bpe.model"
        ),
    },
    "tokenizer_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/tokenizer.json"
        ),
    },
}

__a  			=						{
    "facebook/nllb-large-en-ro": 1024,
    "facebook/nllb-200-distilled-600M": 1024,
}

# fmt: off
__a  			=						["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]







class        UpperCAmelCase_			(			_a      ):
    """simple docstring"""







    lowercase   =						VOCAB_FILES_NAMES
    lowercase   =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowercase   =						PRETRAINED_VOCAB_FILES_MAP
    lowercase   =						["input_ids", "attention_mask"]
    lowercase   =						NllbTokenizer

    lowercase   =						[]
    lowercase   =						[]




    def __init__(       self   :	List[str]					,	snake_case_   :	int=None					,	snake_case_   :	Optional[int]=None					,	snake_case_   :	Dict="<s>"					,	snake_case_   :	Optional[Any]="</s>"					,	snake_case_   :	Union[str, Any]="</s>"					,	snake_case_   :	Optional[int]="<s>"					,	snake_case_   :	Any="<unk>"					,	snake_case_   :	Tuple="<pad>"					,	snake_case_   :	Any="<mask>"					,	snake_case_   :	Union[str, Any]=None					,	snake_case_   :	Tuple=None					,	snake_case_   :	Union[str, Any]=None					,	snake_case_   :	Optional[int]=False					,	**snake_case_   :	List[Any]					,	):
          # Mask token behave like a normal word, i.e. include the space before it
          snake_case__    :       Any       		= AddedToken(snake_case_					,	lstrip=snake_case_					,	rstrip=snake_case_		) if isinstance(snake_case_					,	snake_case_		) else mask_token
          snake_case__    :       str       		= legacy_behaviour
          super().__init__(
              vocab_file=snake_case_					,	tokenizer_file=snake_case_					,	bos_token=snake_case_					,	eos_token=snake_case_					,	sep_token=snake_case_					,	cls_token=snake_case_					,	unk_token=snake_case_					,	pad_token=snake_case_					,	mask_token=snake_case_					,	src_lang=snake_case_					,	tgt_lang=snake_case_					,	additional_special_tokens=snake_case_					,	legacy_behaviour=snake_case_					,	**snake_case_					,	)

          snake_case__    :       Optional[Any]       		= vocab_file
          snake_case__    :       str       		= False if not self.vocab_file else True

          snake_case__    :       List[str]       		= 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}		)
          snake_case__    :       Optional[int]       		= {
              lang_code: self.convert_tokens_to_ids(snake_case_		) for lang_code in FAIRSEQ_LANGUAGE_CODES
          }

          snake_case__    :       Any       		= src_lang if src_lang is not None else """eng_Latn"""
          snake_case__    :       Optional[int]       		= self.convert_tokens_to_ids(self._src_lang		)
          snake_case__    :       Any       		= tgt_lang
          self.set_src_lang_special_tokens(self._src_lang		)




    @property
    def lowerCamelCase			(       self   :	str		):
          return self._src_lang




    @src_lang.setter
    def lowerCamelCase			(       self   :	str					,	snake_case_   :	str		):
          snake_case__    :       Any       		= new_src_lang
          self.set_src_lang_special_tokens(self._src_lang		)




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




    def lowerCamelCase			(       self   :	int					,	snake_case_   :	List[str]					,	snake_case_   :	str = "eng_Latn"					,	snake_case_   :	Optional[List[str]] = None					,	snake_case_   :	str = "fra_Latn"					,	**snake_case_   :	str					,	):
          snake_case__    :       str       		= src_lang
          snake_case__    :       List[Any]       		= tgt_lang
          return super().prepare_seqaseq_batch(snake_case_					,	snake_case_					,	**snake_case_		)




    def lowerCamelCase			(       self   :	List[str]		):
          return self.set_src_lang_special_tokens(self.src_lang		)




    def lowerCamelCase			(       self   :	Any		):
          return self.set_tgt_lang_special_tokens(self.tgt_lang		)




    def lowerCamelCase			(       self   :	Optional[Any]					,	snake_case_   :	List[str]		):
          snake_case__    :       List[Any]       		= self.convert_tokens_to_ids(snake_case_		)

          if self.legacy_behaviour:
                snake_case__    :       Tuple       		= []
                snake_case__    :       Optional[int]       		= [self.eos_token_id, self.cur_lang_code]
          else:
                snake_case__    :       Tuple       		= [self.cur_lang_code]
                snake_case__    :       int       		= [self.eos_token_id]

          snake_case__    :       List[str]       		= self.convert_ids_to_tokens(self.prefix_tokens		)
          snake_case__    :       Tuple       		= self.convert_ids_to_tokens(self.suffix_tokens		)

          snake_case__    :       Union[str, 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 lowerCamelCase			(       self   :	int					,	snake_case_   :	str		):
          snake_case__    :       List[str]       		= self.convert_tokens_to_ids(snake_case_		)
          if self.legacy_behaviour:
                snake_case__    :       int       		= []
                snake_case__    :       Optional[Any]       		= [self.eos_token_id, self.cur_lang_code]
          else:
                snake_case__    :       Dict       		= [self.cur_lang_code]
                snake_case__    :       Dict       		= [self.eos_token_id]

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

          snake_case__    :       List[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 lowerCamelCase			(       self   :	str					,	snake_case_   :	str					,	snake_case_   :	Optional[str] = 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(snake_case_		):
                logger.error(f"Vocabulary path ({save_directory}) should be a directory."		)
                return
          snake_case__    :       Dict       		= os.path.join(
              snake_case_					,	(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]		)

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

          return (out_vocab_file,)
