




import argparse
import collections
import os
import re
import tempfile

import pandas as pd
from datasets import Dataset
from huggingface_hub import hf_hub_download, upload_folder

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/update_metadata.py
__A						:							Any							=  """src/transformers"""


# This is to make sure the transformers module imported is the one in the repo.
__A						:							Any							=  direct_transformers_import(TRANSFORMERS_PATH)


# Regexes that match TF/Flax/PT model names.
__A						:							Tuple							=  re.compile(r"""TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")
__A						:							Optional[Any]							=  re.compile(r"""Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
__A						:							Optional[int]							=  re.compile(r"""(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
__A						:							str							=  [
    ("""pretraining""", """MODEL_FOR_PRETRAINING_MAPPING_NAMES""", """AutoModelForPreTraining"""),
    ("""feature-extraction""", """MODEL_MAPPING_NAMES""", """AutoModel"""),
    ("""audio-classification""", """MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES""", """AutoModelForAudioClassification"""),
    ("""text-generation""", """MODEL_FOR_CAUSAL_LM_MAPPING_NAMES""", """AutoModelForCausalLM"""),
    ("""automatic-speech-recognition""", """MODEL_FOR_CTC_MAPPING_NAMES""", """AutoModelForCTC"""),
    ("""image-classification""", """MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES""", """AutoModelForImageClassification"""),
    ("""image-segmentation""", """MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES""", """AutoModelForImageSegmentation"""),
    ("""fill-mask""", """MODEL_FOR_MASKED_LM_MAPPING_NAMES""", """AutoModelForMaskedLM"""),
    ("""object-detection""", """MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES""", """AutoModelForObjectDetection"""),
    (
        """zero-shot-object-detection""",
        """MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES""",
        """AutoModelForZeroShotObjectDetection""",
    ),
    ("""question-answering""", """MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES""", """AutoModelForQuestionAnswering"""),
    ("""text2text-generation""", """MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES""", """AutoModelForSeq2SeqLM"""),
    ("""text-classification""", """MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES""", """AutoModelForSequenceClassification"""),
    ("""automatic-speech-recognition""", """MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES""", """AutoModelForSpeechSeq2Seq"""),
    (
        """table-question-answering""",
        """MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES""",
        """AutoModelForTableQuestionAnswering""",
    ),
    ("""token-classification""", """MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES""", """AutoModelForTokenClassification"""),
    ("""multiple-choice""", """MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES""", """AutoModelForMultipleChoice"""),
    (
        """next-sentence-prediction""",
        """MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES""",
        """AutoModelForNextSentencePrediction""",
    ),
    (
        """audio-frame-classification""",
        """MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES""",
        """AutoModelForAudioFrameClassification""",
    ),
    ("""audio-xvector""", """MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES""", """AutoModelForAudioXVector"""),
    (
        """document-question-answering""",
        """MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES""",
        """AutoModelForDocumentQuestionAnswering""",
    ),
    (
        """visual-question-answering""",
        """MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES""",
        """AutoModelForVisualQuestionAnswering""",
    ),
    ("""image-to-text""", """MODEL_FOR_FOR_VISION_2_SEQ_MAPPING_NAMES""", """AutoModelForVision2Seq"""),
    (
        """zero-shot-image-classification""",
        """MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES""",
        """AutoModelForZeroShotImageClassification""",
    ),
    ("""depth-estimation""", """MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES""", """AutoModelForDepthEstimation"""),
    ("""video-classification""", """MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES""", """AutoModelForVideoClassification"""),
    ("""mask-generation""", """MODEL_FOR_MASK_GENERATION_MAPPING_NAMES""", """AutoModelForMaskGeneration"""),
]
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					re.finditer(""".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"""					,	__lowercase   )
			return [m.group(0   ) for m in matches]
def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
			SCREAMING_SNAKE_CASE           =					{
			    config.replace("""Config"""					,	""""""   ): model_type for model_type, config in config_maping_names.items()
			}

			# Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
			SCREAMING_SNAKE_CASE           =					collections.defaultdict(__lowercase   )
			SCREAMING_SNAKE_CASE           =					collections.defaultdict(__lowercase   )
			SCREAMING_SNAKE_CASE           =					collections.defaultdict(__lowercase   )

			# Let's lookup through all transformers object (once) and find if models are supported by a given backend.
			for attr_name in dir(__lowercase   ):
						SCREAMING_SNAKE_CASE           =					None
						if _re_tf_models.match(__lowercase   ) is not None:
									SCREAMING_SNAKE_CASE           =					tf_models
									SCREAMING_SNAKE_CASE           =					_re_tf_models.match(__lowercase   ).groups()[0]
						elif _re_flax_models.match(__lowercase   ) is not None:
									SCREAMING_SNAKE_CASE           =					flax_models
									SCREAMING_SNAKE_CASE           =					_re_flax_models.match(__lowercase   ).groups()[0]
						elif _re_pt_models.match(__lowercase   ) is not None:
									SCREAMING_SNAKE_CASE           =					pt_models
									SCREAMING_SNAKE_CASE           =					_re_pt_models.match(__lowercase   ).groups()[0]

						if lookup_dict is not None:
									while len(__lowercase   ) > 0:
												if attr_name in model_prefix_to_model_type:
															SCREAMING_SNAKE_CASE           =					True
															break
												# Try again after removing the last word in the name
												SCREAMING_SNAKE_CASE           =					''.join(camel_case_split(__lowercase   )[:-1]   )

			SCREAMING_SNAKE_CASE           =					set(list(pt_models.keys()   ) + list(tf_models.keys()   ) + list(flax_models.keys()   )   )
			SCREAMING_SNAKE_CASE           =					list(__lowercase   )
			all_models.sort()

			SCREAMING_SNAKE_CASE           =					{'model_type': all_models}
			SCREAMING_SNAKE_CASE           =					[pt_models[t] for t in all_models]
			SCREAMING_SNAKE_CASE           =					[tf_models[t] for t in all_models]
			SCREAMING_SNAKE_CASE           =					[flax_models[t] for t in all_models]

			# Now let's use the auto-mapping names to make sure
			SCREAMING_SNAKE_CASE           =					{}
			for t in all_models:
						if t in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES:
									SCREAMING_SNAKE_CASE           =					'AutoProcessor'
						elif t in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES:
									SCREAMING_SNAKE_CASE           =					'AutoTokenizer'
						elif t in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES:
									SCREAMING_SNAKE_CASE           =					'AutoFeatureExtractor'
						else:
									# Default to AutoTokenizer if a model has nothing, for backward compatibility.
									SCREAMING_SNAKE_CASE           =					'AutoTokenizer'

			SCREAMING_SNAKE_CASE           =					[processors[t] for t in all_models]

			return pd.DataFrame(__lowercase   )
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					[
			    transformers_module.models.auto.modeling_auto,
			    transformers_module.models.auto.modeling_tf_auto,
			    transformers_module.models.auto.modeling_flax_auto,
			]
			for pipeline_tag, model_mapping, auto_class in PIPELINE_TAGS_AND_AUTO_MODELS:
						SCREAMING_SNAKE_CASE           =					[model_mapping, f"""TF_{model_mapping}""", f"""FLAX_{model_mapping}"""]
						SCREAMING_SNAKE_CASE           =					[auto_class, f"""TF_{auto_class}""", f"""Flax_{auto_class}"""]
						# Loop through all three frameworks
						for module, cls, mapping in zip(__lowercase					,	__lowercase					,	__lowercase   ):
									# The type of pipeline may not exist in this framework
									if not hasattr(__lowercase					,	__lowercase   ):
												continue
									# First extract all model_names
									SCREAMING_SNAKE_CASE           =					[]
									for name in getattr(__lowercase					,	__lowercase   ).values():
												if isinstance(__lowercase					,	__lowercase   ):
															model_names.append(__lowercase   )
												else:
															model_names.extend(list(__lowercase   )   )

            # Add pipeline tag and auto model class for those models
									table.update({model_name: (pipeline_tag, cls) for model_name in model_names}   )

			return table
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					get_frameworks_table()
			SCREAMING_SNAKE_CASE           =					Dataset.from_pandas(__lowercase   )

			SCREAMING_SNAKE_CASE           =					hf_hub_download(
			    """huggingface/transformers-metadata"""					,	"""pipeline_tags.json"""					,	repo_type="""dataset"""					,	token=__lowercase   )
			SCREAMING_SNAKE_CASE           =					Dataset.from_json(__lowercase   )
			SCREAMING_SNAKE_CASE           =					{
			    tags_dataset[i]['model_class']: (tags_dataset[i]['pipeline_tag'], tags_dataset[i]['auto_class'])
			    for i in range(len(__lowercase   )   )
			}
			SCREAMING_SNAKE_CASE           =					update_pipeline_and_auto_class_table(__lowercase   )

			# Sort the model classes to avoid some nondeterministic updates to create false update commits.
			SCREAMING_SNAKE_CASE           =					sorted(table.keys()   )
			SCREAMING_SNAKE_CASE           =					pd.DataFrame(
			    {
			        """model_class""": model_classes,
			        """pipeline_tag""": [table[m][0] for m in model_classes],
			        """auto_class""": [table[m][1] for m in model_classes],
			    }   )
			SCREAMING_SNAKE_CASE           =					Dataset.from_pandas(__lowercase   )

			with tempfile.TemporaryDirectory() as tmp_dir:
						frameworks_dataset.to_json(os.path.join(__lowercase					,	"""frameworks.json"""   )   )
						tags_dataset.to_json(os.path.join(__lowercase					,	"""pipeline_tags.json"""   )   )

						if commit_sha is not None:
									SCREAMING_SNAKE_CASE           =					(
									    f"""Update with commit {commit_sha}\n\nSee: """
									    f"""https://github.com/huggingface/transformers/commit/{commit_sha}"""
									)
						else:
									SCREAMING_SNAKE_CASE           =					'Update'

						upload_folder(
						    repo_id="""huggingface/transformers-metadata"""					,	folder_path=__lowercase					,	repo_type="""dataset"""					,	token=__lowercase					,	commit_message=__lowercase					,	)
def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					{tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
			SCREAMING_SNAKE_CASE           =					transformers_module.pipelines.SUPPORTED_TASKS
			SCREAMING_SNAKE_CASE           =					[]
			for key in pipeline_tasks:
						if key not in in_table:
									SCREAMING_SNAKE_CASE           =					pipeline_tasks[key]['pt']
									if isinstance(__lowercase					,	(list, tuple)   ):
												SCREAMING_SNAKE_CASE           =					model[0]
									SCREAMING_SNAKE_CASE           =					model.__name__
									if model not in in_table.values():
												missing.append(__lowercase   )

			if len(__lowercase   ) > 0:
						SCREAMING_SNAKE_CASE           =					', '.join(__lowercase   )
						raise ValueError(
						    """The following pipeline tags are not present in the `PIPELINE_TAGS_AND_AUTO_MODELS` constant inside """
						    f"""`utils/update_metadata.py`: {msg}. Please add them!"""   )


if __name__ == "__main__":
		__A						:							Optional[Any]							=  argparse.ArgumentParser()
		parser.add_argument("""--token""", type=str, help="""The token to use to push to the transformers-metadata dataset.""")
		parser.add_argument("""--commit_sha""", type=str, help="""The sha of the commit going with this update.""")
		parser.add_argument("""--check-only""", action="""store_true""", help="""Activate to just check all pipelines are present.""")
		__A						:							List[str]							=  parser.parse_args()

		if args.check_only:
				check_pipeline_tags()
		else:
				update_metadata(args.token, args.commit_sha)












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


__A						:							Any							=  logging.get_logger(__name__)


__A						:							Union[str, Any]							=  {"""vocab_file""": """sentencepiece.bpe.model""", """tokenizer_file""": """tokenizer.json"""}

__A						:							List[Any]							=  {
    """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""",
    },
}

__A						:							int							=  {
    """facebook/mbart-large-en-ro""": 1_0_2_4,
    """facebook/mbart-large-cc25""": 1_0_2_4,
}

# fmt: off
__A						:							List[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'''



							a__						  =     VOCAB_FILES_NAMES
							a__						  =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							a__						  =     PRETRAINED_VOCAB_FILES_MAP
							a__						  =     ['''input_ids''', '''attention_mask''']
							a__						  =     MBartTokenizer

							a__						  =     []
							a__						  =     []





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

										super().__init__(
										    vocab_file=a       ,     tokenizer_file=a       ,     bos_token=a       ,     eos_token=a       ,     sep_token=a       ,     cls_token=a       ,     unk_token=a       ,     pad_token=a       ,     mask_token=a       ,     src_lang=a       ,     tgt_lang=a       ,     additional_special_tokens=a       ,     **a       ,     )

										SCREAMING_SNAKE_CASE           =					vocab_file
										SCREAMING_SNAKE_CASE           =					False if not self.vocab_file else True

										SCREAMING_SNAKE_CASE           =					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}			)
										SCREAMING_SNAKE_CASE           =					{
										    lang_code: self.convert_tokens_to_ids(a			) for lang_code in FAIRSEQ_LANGUAGE_CODES
										}

										SCREAMING_SNAKE_CASE           =					src_lang if src_lang is not None else """en_XX"""
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(self._src_lang			)
										SCREAMING_SNAKE_CASE           =					tgt_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							@property
							def    _UpperCAmelCase     (					self       :	int			)			->					str:
										return self._src_lang





							@src_lang.setter
							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					new_src_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     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    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	List[int]       ,     a       :	Optional[List[int]] = None			)			->					List[int]:
										SCREAMING_SNAKE_CASE           =					[self.sep_token_id]
										SCREAMING_SNAKE_CASE           =					[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    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Optional[int]       ,     a       :	str       ,     a       :	Optional[str]       ,     a       :	Optional[str]       ,     **a       :	Optional[Any]			)			->					Optional[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"""			)
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					self(a       ,     add_special_tokens=a       ,     return_tensors=a       ,     **a			)
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					tgt_lang_id
										return inputs





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	List[str]       ,     a       :	str = "en_XX"       ,     a       :	Optional[List[str]] = None       ,     a       :	str = "ro_RO"       ,     **a       :	List[str]       ,     )			->					BatchEncoding:
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					tgt_lang
										return super().prepare_seqaseq_batch(a       ,     a       ,     **a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					str:
										return self.set_src_lang_special_tokens(self.src_lang			)





							def    _UpperCAmelCase     (					self       :	str			)			->					List[str]:
										return self.set_tgt_lang_special_tokens(self.tgt_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[str]			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					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    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					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    _UpperCAmelCase     (					self       :	Dict       ,     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
										SCREAMING_SNAKE_CASE           =					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,)






