





'''simple docstring'''






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
lowerCAmelCase									=   """src/transformers"""


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


# Regexes that match TF/Flax/PT model names.
lowerCAmelCase									=   re.compile(R"""TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")
lowerCAmelCase									=   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.
lowerCAmelCase									=   re.compile(R"""(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
lowerCAmelCase									=   [
    ("""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   __A    (				a_    :	Union[str, Any]						):
		lowerCAmelCase  :     List[str]       						= re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"   ,a_						)
		return [m.group(0						) for m in matches]






def   __A    (				):
		lowerCAmelCase  :     List[Any]       						= transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
		lowerCAmelCase  :     Any       						= {
		    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.
		lowerCAmelCase  :     Any       						= collections.defaultdict(a_						)
		lowerCAmelCase  :     Dict       						= collections.defaultdict(a_						)
		lowerCAmelCase  :     Any       						= collections.defaultdict(a_						)

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

				if lookup_dict is not None:
						while len(a_						) > 0:
								if attr_name in model_prefix_to_model_type:
										lowerCAmelCase  :     Optional[int]       						= True
										break
								# Try again after removing the last word in the name
								lowerCAmelCase  :     str       						= "".join(camel_case_split(a_						)[:-1]						)

		lowerCAmelCase  :     List[str]       						= set(list(pt_models.keys()						) + list(tf_models.keys()						) + list(flax_models.keys()						)						)
		lowerCAmelCase  :     List[Any]       						= list(a_						)
		all_models.sort()

		lowerCAmelCase  :     Union[str, Any]       						= {"model_type": all_models}
		lowerCAmelCase  :     str       						= [pt_models[t] for t in all_models]
		lowerCAmelCase  :     Tuple       						= [tf_models[t] for t in all_models]
		lowerCAmelCase  :     Any       						= [flax_models[t] for t in all_models]

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

		lowerCAmelCase  :     Union[str, Any]       						= [processors[t] for t in all_models]

		return pd.DataFrame(a_						)






def   __A    (				a_    :	int						):
		lowerCAmelCase  :     str       						= [
		    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:
				lowerCAmelCase  :     Dict       						= [model_mapping, f'''TF_{model_mapping}''', f'''FLAX_{model_mapping}''']
				lowerCAmelCase  :     List[Any]       						= [auto_class, f'''TF_{auto_class}''', f'''Flax_{auto_class}''']
				# Loop through all three frameworks
				for module, cls, mapping in zip(a_   ,a_   ,a_						):
						# The type of pipeline may not exist in this framework
						if not hasattr(a_   ,a_						):
								continue
						# First extract all model_names
						lowerCAmelCase  :     Optional[Any]       						= []
						for name in getattr(a_   ,a_						).values():
								if isinstance(a_   ,a_						):
										model_names.append(a_						)
								else:
										model_names.extend(list(a_						)						)

            # 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   __A    (				a_    :	str   ,a_    :	Any						):
		lowerCAmelCase  :     str       						= get_frameworks_table()
		lowerCAmelCase  :     str       						= Dataset.from_pandas(a_						)

		lowerCAmelCase  :     Optional[Any]       						= hf_hub_download(
		    "huggingface/transformers-metadata"   ,"pipeline_tags.json"   ,repo_type="dataset"   ,token=a_						)
		lowerCAmelCase  :     Dict       						= Dataset.from_json(a_						)
		lowerCAmelCase  :     Dict       						= {
		    tags_dataset[i]["model_class"]: (tags_dataset[i]["pipeline_tag"], tags_dataset[i]["auto_class"])
		    for i in range(len(a_						)						)
		}
		lowerCAmelCase  :     List[Any]       						= update_pipeline_and_auto_class_table(a_						)

		# Sort the model classes to avoid some nondeterministic updates to create false update commits.
		lowerCAmelCase  :     Tuple       						= sorted(table.keys()						)
		lowerCAmelCase  :     Tuple       						= 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],
		    }						)
		lowerCAmelCase  :     List[str]       						= Dataset.from_pandas(a_						)

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

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

				upload_folder(
				    repo_id="huggingface/transformers-metadata"   ,folder_path=a_   ,repo_type="dataset"   ,token=a_   ,commit_message=a_   ,)






def   __A    (				):
		lowerCAmelCase  :     Union[str, Any]       						= {tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
		lowerCAmelCase  :     List[Any]       						= transformers_module.pipelines.SUPPORTED_TASKS
		lowerCAmelCase  :     List[Any]       						= []
		for key in pipeline_tasks:
				if key not in in_table:
						lowerCAmelCase  :     Optional[int]       						= pipeline_tasks[key]["pt"]
						if isinstance(a_   ,(list, tuple)						):
								lowerCAmelCase  :     Union[str, Any]       						= model[0]
						lowerCAmelCase  :     List[Any]       						= model.__name__
						if model not in in_table.values():
								missing.append(a_						)

		if len(a_						) > 0:
				lowerCAmelCase  :     Tuple       						= ", ".join(a_						)
				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__":
					lowerCAmelCase									=   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.""")
					lowerCAmelCase									=   parser.parse_args()

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










'''simple docstring'''






import math

import tensorflow as tf
from packaging import version






def   __A    (				a_    :	List[Any]						):
		lowerCAmelCase  :     Any       						= tf.convert_to_tensor(a_						)
		lowerCAmelCase  :     List[Any]       						= 0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0						)   ,x.dtype						)						))

		return x * cdf






def   __A    (				a_    :	int						):
		lowerCAmelCase  :     Dict       						= tf.convert_to_tensor(a_						)
		lowerCAmelCase  :     int       						= tf.cast(math.pi   ,x.dtype						)
		lowerCAmelCase  :     Dict       						= tf.cast(0.0_4_4_7_1_5   ,x.dtype						)
		lowerCAmelCase  :     Dict       						= 0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi						) * (x + coeff * tf.pow(a_   ,3						))						))

		return x * cdf






def   __A    (				a_    :	Union[str, Any]						):
		lowerCAmelCase  :     Any       						= tf.convert_to_tensor(a_						)

		return x * tf.tanh(tf.math.softplus(a_						)						)






def   __A    (				a_    :	List[str]						):
		lowerCAmelCase  :     Dict       						= tf.convert_to_tensor(a_						)
		lowerCAmelCase  :     Any       						= tf.cast(0.0_4_4_7_1_5   ,x.dtype						)
		lowerCAmelCase  :     Optional[int]       						= tf.cast(0.7_9_7_8_8_4_5_6_0_8   ,x.dtype						)

		return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x)						))






def   __A    (				a_    :	Union[str, Any]						):
		lowerCAmelCase  :     Optional[int]       						= tf.convert_to_tensor(a_						)
		lowerCAmelCase  :     List[Any]       						= tf.cast(1.7_0_2   ,x.dtype						)
		return x * tf.math.sigmoid(coeff * x						)






def   __A    (				a_    :	List[Any]						):
		return tf.clip_by_value(_gelu(a_						)   ,-1_0   ,1_0						)






def   __A    (				a_    :	List[Any]   ,a_    :	List[Any]=-1						):
		lowerCAmelCase						,		lowerCAmelCase  :     Optional[int]       						= tf.split(a_   ,2   ,axis=a_						)
		return a * tf.math.sigmoid(a_						)


if version.parse(tf.version.VERSION) >= version.parse("""2.4"""):






					def   __A    (				a_    :	Optional[Any]						):
							return tf.keras.activations.gelu(a_   ,approximate=a_						)

					lowerCAmelCase									=   tf.keras.activations.gelu

					lowerCAmelCase									=   approximate_gelu_wrap
else:
					lowerCAmelCase									=   _gelu
					lowerCAmelCase									=   _gelu_new


lowerCAmelCase									=   {
    """gelu""": gelu,
    """gelu_10""": gelu_aa,
    """gelu_fast""": gelu_fast,
    """gelu_new""": gelu_new,
    """glu""": glu,
    """mish""": mish,
    """quick_gelu""": quick_gelu,
    """relu""": tf.keras.activations.relu,
    """sigmoid""": tf.keras.activations.sigmoid,
    """silu""": tf.keras.activations.swish,
    """swish""": tf.keras.activations.swish,
    """tanh""": tf.keras.activations.tanh,
}






def   __A    (				a_    :	int						):
		if activation_string in ACTaFN:
				return ACTaFN[activation_string]
		else:
				raise KeyError(f'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()						)}'''						)



