




import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor



def    lowerCamelCase_   (  _lowercase    )							->	Optional[int]:
		__A							:   List[str]	  =				TimesformerConfig()

		if "large" in model_name:
				__A							:   Dict	  =				96

		if "hr" in model_name:
				__A							:   Optional[int]	  =				16
				__A							:   Dict	  =				448

		__A							:   Any	  =				'huggingface/label-files'
		if "k400" in model_name:
				__A							:   int	  =				400
				__A							:   Optional[int]	  =				'kinetics400-id2label.json'
		elif "k600" in model_name:
				__A							:   Optional[Any]	  =				600
				__A							:   str	  =				'kinetics600-id2label.json'
		elif "ssv2" in model_name:
				__A							:   Tuple	  =				174
				__A							:   Any	  =				'something-something-v2-id2label.json'
		else:
				raise ValueError("Model name should either contain \'k400\', \'k600\' or \'ssv2\'."    )
		__A							:   int	  =				json.load(open(hf_hub_download(A__ ,     A__ ,     repo_type="dataset"    ) ,     "r"    )    )
		__A							:   Tuple	  =				{int(A__    ): v for k, v in idalabel.items()}
		__A							:   int	  =				idalabel
		__A							:   Optional[int]	  =				{v: k for k, v in idalabel.items()}

		return config



def    lowerCamelCase_   (  _lowercase    )							->	List[Any]:
		if "encoder." in name:
				__A							:   Optional[Any]	  =				name.replace("encoder." ,     ""    )
		if "cls_token" in name:
				__A							:   Dict	  =				name.replace("cls_token" ,     "timesformer.embeddings.cls_token"    )
		if "pos_embed" in name:
				__A							:   Optional[Any]	  =				name.replace("pos_embed" ,     "timesformer.embeddings.position_embeddings"    )
		if "time_embed" in name:
				__A							:   List[Any]	  =				name.replace("time_embed" ,     "timesformer.embeddings.time_embeddings"    )
		if "patch_embed.proj" in name:
				__A							:   Any	  =				name.replace("patch_embed.proj" ,     "timesformer.embeddings.patch_embeddings.projection"    )
		if "patch_embed.norm" in name:
				__A							:   int	  =				name.replace("patch_embed.norm" ,     "timesformer.embeddings.norm"    )
		if "blocks" in name:
				__A							:   List[Any]	  =				name.replace("blocks" ,     "timesformer.encoder.layer"    )
		if "attn.proj" in name:
				__A							:   List[Any]	  =				name.replace("attn.proj" ,     "attention.output.dense"    )
		if "attn" in name and "bias" not in name and "temporal" not in name:
				__A							:   Union[str, Any]	  =				name.replace("attn" ,     "attention.self"    )
		if "attn" in name and "temporal" not in name:
				__A							:   Dict	  =				name.replace("attn" ,     "attention.attention"    )
		if "temporal_norm1" in name:
				__A							:   Dict	  =				name.replace("temporal_norm1" ,     "temporal_layernorm"    )
		if "temporal_attn.proj" in name:
				__A							:   List[Any]	  =				name.replace("temporal_attn" ,     "temporal_attention.output.dense"    )
		if "temporal_fc" in name:
				__A							:   Optional[Any]	  =				name.replace("temporal_fc" ,     "temporal_dense"    )
		if "norm1" in name and "temporal" not in name:
				__A							:   List[Any]	  =				name.replace("norm1" ,     "layernorm_before"    )
		if "norm2" in name:
				__A							:   Dict	  =				name.replace("norm2" ,     "layernorm_after"    )
		if "mlp.fc1" in name:
				__A							:   str	  =				name.replace("mlp.fc1" ,     "intermediate.dense"    )
		if "mlp.fc2" in name:
				__A							:   List[Any]	  =				name.replace("mlp.fc2" ,     "output.dense"    )
		if "norm.weight" in name and "fc" not in name and "temporal" not in name:
				__A							:   List[str]	  =				name.replace("norm.weight" ,     "timesformer.layernorm.weight"    )
		if "norm.bias" in name and "fc" not in name and "temporal" not in name:
				__A							:   List[Any]	  =				name.replace("norm.bias" ,     "timesformer.layernorm.bias"    )
		if "head" in name:
				__A							:   int	  =				name.replace("head" ,     "classifier"    )

		return name



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	List[Any]:
		for key in orig_state_dict.copy().keys():
				__A							:   Union[str, Any]	  =				orig_state_dict.pop(A__    )

				if key.startswith("model."    ):
						__A							:   Any	  =				key.replace("model." ,     ""    )

				if "qkv" in key:
						__A							:   Optional[int]	  =				key.split("."    )
						__A							:   Optional[int]	  =				int(key_split[1]    )
						__A							:   Optional[Any]	  =				'timesformer.encoder.layer.'
						if "temporal" in key:
								__A							:   List[Any]	  =				'.temporal_attention.attention.qkv.'
						else:
								__A							:   List[Any]	  =				'.attention.attention.qkv.'
						if "weight" in key:
								__A							:   int	  =				val
						else:
								__A							:   Union[str, Any]	  =				val
				else:
						__A							:   Any	  =				val

		return orig_state_dict



def    lowerCamelCase_   (  )							->	List[str]:
		__A							:   Optional[Any]	  =				hf_hub_download(
		    repo_id="hf-internal-testing/spaghetti-video" ,     filename="eating_spaghetti.npy" ,     repo_type="dataset"    )
		__A							:   Dict	  =				np.load(A__    )
		return list(A__    )



def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase ,     _lowercase    )							->	int:
		__A							:   str	  =				get_timesformer_config(A__    )

		__A							:   int	  =				TimesformerForVideoClassification(A__    )

		# download original checkpoint, hosted on Google Drive
		__A							:   Dict	  =				'pytorch_model.bin'
		gdown.cached_download(A__ ,     A__ ,     quiet=A__    )
		__A							:   Optional[Any]	  =				torch.load(A__ ,     map_location="cpu"    )
		if "model" in files:
				__A							:   str	  =				files['model']
		elif "module" in files:
				__A							:   Optional[Any]	  =				files['module']
		else:
				__A							:   Optional[Any]	  =				files['model_state']
		__A							:   List[str]	  =				convert_state_dict(A__ ,     A__    )

		model.load_state_dict(A__    )
		model.eval()

		# verify model on basic input
		__A							:   List[str]	  =				VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,     image_std=[0.5, 0.5, 0.5]    )
		__A							:   int	  =				prepare_video()
		__A							:   Optional[int]	  =				image_processor(video[:8] ,     return_tensors="pt"    )

		__A							:   Dict	  =				model(**A__    )
		__A							:   Optional[Any]	  =				outputs.logits

		__A							:   List[Any]	  =				[
		    # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
		    'timesformer-base-finetuned-k400',
		    'timesformer-large-finetuned-k400',
		    'timesformer-hr-finetuned-k400',
		    # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
		    'timesformer-base-finetuned-k600',
		    'timesformer-large-finetuned-k600',
		    'timesformer-hr-finetuned-k600',
		    # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
		    'timesformer-base-finetuned-ssv2',
		    'timesformer-large-finetuned-ssv2',
		    'timesformer-hr-finetuned-ssv2',
		]

		# NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
		if model_name == "timesformer-base-finetuned-k400":
				__A							:   int	  =				torch.Size([1, 400]    )
				__A							:   List[str]	  =				torch.tensor([-0.30_16, -0.77_13, -0.42_05]    )
		elif model_name == "timesformer-base-finetuned-k600":
				__A							:   Tuple	  =				torch.Size([1, 600]    )
				__A							:   List[str]	  =				torch.tensor([-0.72_67, -0.74_66, 3.24_04]    )
		elif model_name == "timesformer-base-finetuned-ssv2":
				__A							:   Tuple	  =				torch.Size([1, 174]    )
				__A							:   Dict	  =				torch.tensor([-0.90_59, 0.64_33, -3.14_57]    )
		elif model_name == "timesformer-large-finetuned-k400":
				__A							:   int	  =				torch.Size([1, 400]    )
				__A							:   List[Any]	  =				torch.tensor([0, 0, 0]    )
		elif model_name == "timesformer-large-finetuned-k600":
				__A							:   str	  =				torch.Size([1, 600]    )
				__A							:   Tuple	  =				torch.tensor([0, 0, 0]    )
		elif model_name == "timesformer-large-finetuned-ssv2":
				__A							:   Tuple	  =				torch.Size([1, 174]    )
				__A							:   int	  =				torch.tensor([0, 0, 0]    )
		elif model_name == "timesformer-hr-finetuned-k400":
				__A							:   List[str]	  =				torch.Size([1, 400]    )
				__A							:   Any	  =				torch.tensor([-0.96_17, -3.73_11, -3.77_08]    )
		elif model_name == "timesformer-hr-finetuned-k600":
				__A							:   Union[str, Any]	  =				torch.Size([1, 600]    )
				__A							:   Optional[Any]	  =				torch.tensor([2.52_73, 0.71_27, 1.88_48]    )
		elif model_name == "timesformer-hr-finetuned-ssv2":
				__A							:   List[Any]	  =				torch.Size([1, 174]    )
				__A							:   str	  =				torch.tensor([-3.67_56, -0.75_13, 0.71_80]    )
		else:
				raise ValueError(F"Model name not supported. Should be one of {model_names}"    )

		# verify logits
		assert logits.shape == expected_shape
		assert torch.allclose(logits[0, :3] ,     A__ ,     atol=1E-4    )
		print("Logits ok!"    )

		if pytorch_dump_folder_path is not None:
				print(F"Saving model and image processor to {pytorch_dump_folder_path}"    )
				image_processor.save_pretrained(A__    )
				model.save_pretrained(A__    )

		if push_to_hub:
				print("Pushing to the hub..."    )
				model.push_to_hub(F"fcakyon/{model_name}"    )


if __name__ == "__main__":
					UpperCamelCase      			=     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--checkpoint_url',
					    default='https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download',
					    type=str,
					    help=(
					        'URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'
					        ' download link.'
					    ),
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path',
					    default='',
					    type=str,
					    help='Path to the output PyTorch model directory.',
					)
					parser.add_argument('--model_name', default='timesformer-base-finetuned-k400', type=str, help='Name of the model.')
					parser.add_argument(
					    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
					)

					UpperCamelCase      			=     parser.parse_args()
					convert_timesformer_checkpoint(
					    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
					)






import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata



def    lowerCamelCase_   (  _lowercase    )							->	str:
		__A							:   Optional[int]	  =				min(re.search("^ +" ,     _lowercase    ).end() if t.startswith(" "    ) else 0 for t in string.splitlines()    )
		return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(_lowercase    )]    )


UpperCamelCase      			=     '\\n---\nlanguage:\n- zh\n- en\ntask_ids:\n- sentiment-classification\n---\n# Begin of markdown\n\nSome cool dataset card\n'

UpperCamelCase      			=     '\\n---\n---\n# Begin of markdown\n\nSome cool dataset card\n'


UpperCamelCase      			=     '\\n# Begin of markdown\n\nSome cool dataset card\n'





class _a       (	unittest.TestCase ):

	'''simple docstring'''



	def 					__UpperCAmelCase(       self   ):
			with tempfile.TemporaryDirectory() as tmp_dir:
					__A							:   List[Any]	  =				Path(__UpperCAmelCase   ) / "README.md"
					with open(__UpperCAmelCase							,			"w+"   ) as readme_file:
							readme_file.write(__UpperCAmelCase   )
					__A							:   Tuple	  =				DatasetMetadata.from_readme(__UpperCAmelCase   )
					self.assertDictEqual(__UpperCAmelCase							,			{"language": ["zh", "en"], "task_ids": ["sentiment-classification"]}   )

					with open(__UpperCAmelCase							,			"w+"   ) as readme_file:
							readme_file.write(__UpperCAmelCase   )
					__A							:   Any	  =				DatasetMetadata.from_readme(__UpperCAmelCase   )
					self.assertDictEqual(__UpperCAmelCase							,			{}   )

					with open(__UpperCAmelCase							,			"w+"   ) as readme_file:
							readme_file.write(__UpperCAmelCase   )
					__A							:   Union[str, Any]	  =				DatasetMetadata.from_readme(__UpperCAmelCase   )
					self.assertEqual(__UpperCAmelCase							,			{}   )







	def 					__UpperCAmelCase(       self   ):
			__A							:   List[str]	  =				_dedent(
			    "\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            "   )
			assert DatasetMetadata.from_yaml_string(__UpperCAmelCase   )

			__A							:   List[Any]	  =				_dedent(
			    "\\n            annotations_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            task_ids:\n            - open-domain-qa\n            "   )
			with self.assertRaises(__UpperCAmelCase   ):
					DatasetMetadata.from_yaml_string(__UpperCAmelCase   )

			__A							:   Optional[int]	  =				_dedent(
			    "\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - text-classification\n            task_ids:\n            - multi-class-classification\n            paperswithcode_id:\n            - squad\n            configs:\n            - en\n            train-eval-index:\n            - config: en\n              task: text-classification\n              task_id: multi_class_classification\n              splits:\n                train_split: train\n                eval_split: test\n              col_mapping:\n                text: text\n                label: target\n              metrics:\n                - type: accuracy\n                  name: Accuracy\n            extra_gated_prompt: |\n              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:\n              [RESEARCHER_FULLNAME] (the \"Researcher\") has requested permission to use the ImageNet database (the \"Database\") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:\n              1. Researcher shall use the Database only for non-commercial research and educational purposes.\n            extra_gated_fields:\n              Company: text\n              Country: text\n              I agree to use this model for non-commerical use ONLY: checkbox\n            "   )
			assert DatasetMetadata.from_yaml_string(__UpperCAmelCase   )





