
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
SCREAMING_SNAKE_CASE							:int							 =				'src/transformers'


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


# Regexes that match TF/Flax/PT model names.
SCREAMING_SNAKE_CASE							:Optional[Any]							 =				re.compile(R'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
SCREAMING_SNAKE_CASE							:str							 =				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.
SCREAMING_SNAKE_CASE							:Tuple							 =				re.compile(R'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
SCREAMING_SNAKE_CASE							:int							 =				[
    ('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 						UpperCAmelCase			(	a_						)		->	Dict:







				"""simple docstring"""



				__A   			= re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"		,   a_						)
				return [m.group(0						) for m in matches]


def 						UpperCAmelCase			(	)		->	int:







				"""simple docstring"""



				__A   			= transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
				__A   			= {
				    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.
				__A   			= collections.defaultdict(a_						)
				__A   			= collections.defaultdict(a_						)
				__A   			= 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_						):
								__A   			= None
								if _re_tf_models.match(a_						) is not None:
												__A   			= tf_models
												__A   			= _re_tf_models.match(a_						).groups()[0]
								elif _re_flax_models.match(a_						) is not None:
												__A   			= flax_models
												__A   			= _re_flax_models.match(a_						).groups()[0]
								elif _re_pt_models.match(a_						) is not None:
												__A   			= pt_models
												__A   			= _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:
																				__A   			= True
																				break
																# Try again after removing the last word in the name
																__A   			= "".join(camel_case_split(a_						)[:-1]						)

				__A   			= set(list(pt_models.keys()						) + list(tf_models.keys()						) + list(flax_models.keys()						)						)
				__A   			= list(a_						)
				all_models.sort()

				__A   			= {"model_type": all_models}
				__A   			= [pt_models[t] for t in all_models]
				__A   			= [tf_models[t] for t in all_models]
				__A   			= [flax_models[t] for t in all_models]

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

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

				return pd.DataFrame(a_						)


def 						UpperCAmelCase			(	a_						)		->	Any:







				"""simple docstring"""



				__A   			= [
				    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:
								__A   			= [model_mapping, F'''TF_{model_mapping}''', F'''FLAX_{model_mapping}''']
								__A   			= [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
												__A   			= []
												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 						UpperCAmelCase			(	a_		,   a_						)		->	Tuple:







				"""simple docstring"""



				__A   			= get_frameworks_table()
				__A   			= Dataset.from_pandas(a_						)

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

				# Sort the model classes to avoid some nondeterministic updates to create false update commits.
				__A   			= sorted(table.keys()						)
				__A   			= 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],
				    }						)
				__A   			= 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:
												__A   			= (
												    F'''Update with commit {commit_sha}\n\nSee: '''
												    F'''https://github.com/huggingface/transformers/commit/{commit_sha}'''
												)
								else:
												__A   			= "Update"

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


def 						UpperCAmelCase			(	)		->	Union[str, Any]:







				"""simple docstring"""



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

				if len(a_						) > 0:
								__A   			= ", ".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__":
					SCREAMING_SNAKE_CASE							:Optional[int]							 =				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.')
					SCREAMING_SNAKE_CASE							:int							 =				parser.parse_args()

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


import argparse
import os

import torch

from transformers import FlavaConfig, FlavaForPreTraining
from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint


def 						UpperCAmelCase			(	a_						)		->	List[str]:







				"""simple docstring"""



				return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items()						)


def 						UpperCAmelCase			(	a_		,   a_						)		->	Tuple:







				"""simple docstring"""



				__A   			= {}

				for key, value in state_dict.items():
								if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key:
												continue

								__A   			= key.replace("heads.cmd.mim_head.cls.predictions"		,   "mmm_image_head"						)
								__A   			= key.replace("heads.cmd.mlm_head.cls.predictions"		,   "mmm_text_head"						)
								__A   			= key.replace("heads.cmd.itm_head.cls"		,   "itm_head"						)
								__A   			= key.replace("heads.cmd.itm_head.pooler"		,   "itm_head.pooler"						)
								__A   			= key.replace("heads.cmd.clip_head.logit_scale"		,   "flava.logit_scale"						)
								__A   			= key.replace("heads.fairseq_mlm.cls.predictions"		,   "mlm_head"						)
								__A   			= key.replace("heads.imagenet.mim_head.cls.predictions"		,   "mim_head"						)
								__A   			= key.replace("mm_text_projection"		,   "flava.text_to_mm_projection"						)
								__A   			= key.replace("mm_image_projection"		,   "flava.image_to_mm_projection"						)
								__A   			= key.replace("image_encoder.module"		,   "flava.image_model"						)
								__A   			= key.replace("text_encoder.module"		,   "flava.text_model"						)
								__A   			= key.replace("mm_encoder.module.encoder.cls_token"		,   "flava.multimodal_model.cls_token"						)
								__A   			= key.replace("mm_encoder.module"		,   "flava.multimodal_model"						)
								__A   			= key.replace("text_projection"		,   "flava.text_projection"						)
								__A   			= key.replace("image_projection"		,   "flava.image_projection"						)

								__A   			= value.float()

				for key, value in codebook_state_dict.items():
								__A   			= value

				return upgrade


@torch.no_grad()
def 						UpperCAmelCase			(	a_		,   a_		,   a_		,   a_=None						)		->	Tuple:







				"""simple docstring"""



				if config_path is not None:
								__A   			= FlavaConfig.from_pretrained(a_						)
				else:
								__A   			= FlavaConfig()

				__A   			= FlavaForPreTraining(a_						).eval()

				__A   			= convert_dalle_checkpoint(a_		,   a_		,   save_checkpoint=a_						)

				if os.path.exists(a_						):
								__A   			= torch.load(a_		,   map_location="cpu"						)
				else:
								__A   			= torch.hub.load_state_dict_from_url(a_		,   map_location="cpu"						)

				__A   			= upgrade_state_dict(a_		,   a_						)
				hf_model.load_state_dict(a_						)
				__A   			= hf_model.state_dict()
				__A   			= count_parameters(a_						)
				__A   			= count_parameters(a_						) + count_parameters(a_						)

				assert torch.allclose(a_		,   a_		,   atol=1E-3						)

				hf_model.save_pretrained(a_						)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE							:Any							 =				argparse.ArgumentParser()
					parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
					parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to flava checkpoint')
					parser.add_argument('--codebook_path', default=None, type=str, help='Path to flava codebook checkpoint')
					parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
					SCREAMING_SNAKE_CASE							:Optional[int]							 =				parser.parse_args()

					convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)
