



'''simple docstring'''







import subprocess
from argparse import ArgumentParser
from typing import List, Union

from huggingface_hub.hf_api import HfFolder, create_repo, whoami
from requests.exceptions import HTTPError

from . import BaseTransformersCLICommand




class 				__lowerCAmelCase(							UpperCamelCase__      ):






			@staticmethod
			def 				_lowercase	(   SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[Any]										=      parser.add_parser('login'      ,       help='Log in using the same credentials as on huggingface.co'	)
					login_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE	: LoginCommand(SCREAMING_SNAKE_CASE	)	)
					SCREAMING_SNAKE_CASE_						:Dict										=      parser.add_parser('whoami'      ,       help='Find out which huggingface.co account you are logged in as.'	)
					whoami_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE	: WhoamiCommand(SCREAMING_SNAKE_CASE	)	)
					SCREAMING_SNAKE_CASE_						:List[str]										=      parser.add_parser('logout'      ,       help='Log out'	)
					logout_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE	: LogoutCommand(SCREAMING_SNAKE_CASE	)	)

					# new system: git-based repo system
					SCREAMING_SNAKE_CASE_						:int										=      parser.add_parser(
					    'repo'      ,       help='Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.'      ,       )
					SCREAMING_SNAKE_CASE_						:Dict										=      repo_parser.add_subparsers(
					    help='Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands'	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      repo_subparsers.add_parser(
					    'create'      ,       help='Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co'	)
					repo_create_parser.add_argument(
					    'name'      ,       type=SCREAMING_SNAKE_CASE      ,       help='Name for your model\'s repo. Will be namespaced under your username to build the model id.'      ,       )
					repo_create_parser.add_argument('--organization'      ,       type=SCREAMING_SNAKE_CASE      ,       help='Optional: organization namespace.'	)
					repo_create_parser.add_argument('-y'      ,       '--yes'      ,       action='store_true'      ,       help='Optional: answer Yes to the prompt'	)
					repo_create_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE	: RepoCreateCommand(SCREAMING_SNAKE_CASE	)	)




class 				__lowerCAmelCase:
			__snake_case  :		Optional[int]		=      """\u001b[1m"""
			__snake_case  :		List[str]		=      """\u001b[31m"""
			__snake_case  :		Tuple		=      """\u001b[90m"""
			__snake_case  :		Optional[int]		=      """\u001b[0m"""






			@classmethod
			def 				_lowercase	(   cls  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					return f'{cls._bold}{s}{cls._reset}'






			@classmethod
			def 				_lowercase	(   cls  :							List[Any]      ,       SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					return f'{cls._bold}{cls._red}{s}{cls._reset}'






			@classmethod
			def 				_lowercase	(   cls  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					return f'{cls._gray}{s}{cls._reset}'







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:Dict										=      [max(len(str(SCREAMING_SNAKE_CASE     )     ) for x in col     ) for col in zip(*SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )]
		SCREAMING_SNAKE_CASE_						:List[Any]										=      ('{{:{}}} ' * len(SCREAMING_SNAKE_CASE     )).format(*SCREAMING_SNAKE_CASE     )
		SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      []
		lines.append(row_format.format(*SCREAMING_SNAKE_CASE     )     )
		lines.append(row_format.format(*['-' * w for w in col_widths]     )     )
		for row in rows:
				lines.append(row_format.format(*SCREAMING_SNAKE_CASE     )     )
		return "\n".join(SCREAMING_SNAKE_CASE     )




class 				__lowerCAmelCase:






			def __init__(   self  :							Any      ,       SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Any										=      args




class 				__lowerCAmelCase(							UpperCamelCase__      ):






			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					print(
					    ANSI.red(
					        'ERROR! `huggingface-cli login` uses an outdated login mechanism '
					        'that is not compatible with the Hugging Face Hub backend anymore. '
					        'Please use `huggingface-cli login instead.'	)	)




class 				__lowerCAmelCase(							UpperCamelCase__      ):






			def 				_lowercase	(   self  :							int	):




					"""simple docstring"""







					print(
					    ANSI.red(
					        'WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '
					        '`huggingface-cli whoami` instead.'	)	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      HfFolder.get_token()
					if token is None:
							print('Not logged in'	)
							exit()
					try:
							SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:int										=      whoami(SCREAMING_SNAKE_CASE	)
							print(SCREAMING_SNAKE_CASE	)
							if orgs:
									print(ANSI.bold('orgs: '	)      ,       ','.join(SCREAMING_SNAKE_CASE	)	)
					except HTTPError as e:
							print(SCREAMING_SNAKE_CASE	)
							print(ANSI.red(e.response.text	)	)
							exit(1	)




class 				__lowerCAmelCase(							UpperCamelCase__      ):






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					print(
					    ANSI.red(
					        'ERROR! `transformers-cli logout` uses an outdated logout mechanism '
					        'that is not compatible with the Hugging Face Hub backend anymore. '
					        'Please use `huggingface-cli logout instead.'	)	)




class 				__lowerCAmelCase(							UpperCamelCase__      ):






			def 				_lowercase	(   self  :							Union[str, Any]	):




					"""simple docstring"""







					print(
					    ANSI.red(
					        'WARNING! Managing repositories through transformers-cli is deprecated. '
					        'Please use `huggingface-cli` instead.'	)	)
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      HfFolder.get_token()
					if token is None:
							print('Not logged in'	)
							exit(1	)
					try:
							SCREAMING_SNAKE_CASE_						:int										=      subprocess.check_output(['git', '--version']	).decode('utf-8'	)
							print(ANSI.gray(stdout.strip()	)	)
					except FileNotFoundError:
							print('Looks like you do not have git installed, please install.'	)

					try:
							SCREAMING_SNAKE_CASE_						:Dict										=      subprocess.check_output(['git-lfs', '--version']	).decode('utf-8'	)
							print(ANSI.gray(stdout.strip()	)	)
					except FileNotFoundError:
							print(
							    ANSI.red(
							        'Looks like you do not have git-lfs installed, please install.'
							        ' You can install from https://git-lfs.github.com/.'
							        ' Then run `git lfs install` (you only have to do this once).'	)	)
					print(''	)

					SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:Optional[int]										=      whoami(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      self.args.organization if self.args.organization is not None else user
					SCREAMING_SNAKE_CASE_						:Dict										=      f'{namespace}/{self.args.name}'
					print(f'You are about to create {ANSI.bold(SCREAMING_SNAKE_CASE	)}'	)

					if not self.args.yes:
							SCREAMING_SNAKE_CASE_						:Tuple										=      input('Proceed? [Y/n] '	).lower()
							if not (choice == "" or choice == "y" or choice == "yes"):
									print('Abort'	)
									exit()
					try:
							SCREAMING_SNAKE_CASE_						:Dict										=      create_repo(SCREAMING_SNAKE_CASE      ,       name=self.args.name      ,       organization=self.args.organization	)
					except HTTPError as e:
							print(SCREAMING_SNAKE_CASE	)
							print(ANSI.red(e.response.text	)	)
							exit(1	)
					print('\nYour repo now lives at:'	)
					print(f'  {ANSI.bold(SCREAMING_SNAKE_CASE	)}'	)
					print('\nYou can clone it locally with the command below, and commit/push as usual.'	)
					print(f'\n  git clone {url}'	)
					print(''	)





'''simple docstring'''



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       (				lowerCamelCase :    str       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	TimesformerConfig()

	if "large" in model_name:
		__lowerCAmelCase       				=	96

	if "hr" in model_name:
		__lowerCAmelCase       				=	16
		__lowerCAmelCase       				=	4_48

	__lowerCAmelCase       				=	"huggingface/label-files"
	if "k400" in model_name:
		__lowerCAmelCase       				=	4_00
		__lowerCAmelCase       				=	"kinetics400-id2label.json"
	elif "k600" in model_name:
		__lowerCAmelCase       				=	6_00
		__lowerCAmelCase       				=	"kinetics600-id2label.json"
	elif "ssv2" in model_name:
		__lowerCAmelCase       				=	1_74
		__lowerCAmelCase       				=	"something-something-v2-id2label.json"
	else:
		raise ValueError("Model name should either contain 'k400', 'k600' or 'ssv2'."       )
	__lowerCAmelCase       				=	json.load(open(hf_hub_download(lowerCamelCase					,		lowerCamelCase					,		repo_type="dataset"       )					,		"r"       )       )
	__lowerCAmelCase       				=	{int(lowerCamelCase       ): v for k, v in idalabel.items()}
	__lowerCAmelCase       				=	idalabel
	__lowerCAmelCase       				=	{v: k for k, v in idalabel.items()}

	return config



def 	__lowerCAmelCase       (				lowerCamelCase :    int       ):






	'''simple docstring'''




	if "encoder." in name:
		__lowerCAmelCase       				=	name.replace("encoder."					,		""       )
	if "cls_token" in name:
		__lowerCAmelCase       				=	name.replace("cls_token"					,		"timesformer.embeddings.cls_token"       )
	if "pos_embed" in name:
		__lowerCAmelCase       				=	name.replace("pos_embed"					,		"timesformer.embeddings.position_embeddings"       )
	if "time_embed" in name:
		__lowerCAmelCase       				=	name.replace("time_embed"					,		"timesformer.embeddings.time_embeddings"       )
	if "patch_embed.proj" in name:
		__lowerCAmelCase       				=	name.replace("patch_embed.proj"					,		"timesformer.embeddings.patch_embeddings.projection"       )
	if "patch_embed.norm" in name:
		__lowerCAmelCase       				=	name.replace("patch_embed.norm"					,		"timesformer.embeddings.norm"       )
	if "blocks" in name:
		__lowerCAmelCase       				=	name.replace("blocks"					,		"timesformer.encoder.layer"       )
	if "attn.proj" in name:
		__lowerCAmelCase       				=	name.replace("attn.proj"					,		"attention.output.dense"       )
	if "attn" in name and "bias" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("attn"					,		"attention.self"       )
	if "attn" in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("attn"					,		"attention.attention"       )
	if "temporal_norm1" in name:
		__lowerCAmelCase       				=	name.replace("temporal_norm1"					,		"temporal_layernorm"       )
	if "temporal_attn.proj" in name:
		__lowerCAmelCase       				=	name.replace("temporal_attn"					,		"temporal_attention.output.dense"       )
	if "temporal_fc" in name:
		__lowerCAmelCase       				=	name.replace("temporal_fc"					,		"temporal_dense"       )
	if "norm1" in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm1"					,		"layernorm_before"       )
	if "norm2" in name:
		__lowerCAmelCase       				=	name.replace("norm2"					,		"layernorm_after"       )
	if "mlp.fc1" in name:
		__lowerCAmelCase       				=	name.replace("mlp.fc1"					,		"intermediate.dense"       )
	if "mlp.fc2" in name:
		__lowerCAmelCase       				=	name.replace("mlp.fc2"					,		"output.dense"       )
	if "norm.weight" in name and "fc" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm.weight"					,		"timesformer.layernorm.weight"       )
	if "norm.bias" in name and "fc" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm.bias"					,		"timesformer.layernorm.bias"       )
	if "head" in name:
		__lowerCAmelCase       				=	name.replace("head"					,		"classifier"       )

	return name



def 	__lowerCAmelCase       (				lowerCamelCase :    int					,		lowerCamelCase :    List[str]       ):






	'''simple docstring'''




	for key in orig_state_dict.copy().keys():
		__lowerCAmelCase       				=	orig_state_dict.pop(lowerCamelCase       )

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

		if "qkv" in key:
			__lowerCAmelCase       				=	key.split("."       )
			__lowerCAmelCase       				=	int(key_split[1]       )
			__lowerCAmelCase       				=	"timesformer.encoder.layer."
			if "temporal" in key:
				__lowerCAmelCase       				=	".temporal_attention.attention.qkv."
			else:
				__lowerCAmelCase       				=	".attention.attention.qkv."
			if "weight" in key:
				__lowerCAmelCase       				=	val
			else:
				__lowerCAmelCase       				=	val
		else:
			__lowerCAmelCase       				=	val

	return orig_state_dict



def 	__lowerCAmelCase       (				):






	'''simple docstring'''




	__lowerCAmelCase       				=	hf_hub_download(
	    repo_id="hf-internal-testing/spaghetti-video"					,		filename="eating_spaghetti.npy"					,		repo_type="dataset"       )
	__lowerCAmelCase       				=	np.load(lowerCamelCase       )
	return list(lowerCamelCase       )



def 	__lowerCAmelCase       (				lowerCamelCase :    Union[str, Any]					,		lowerCamelCase :    Dict					,		lowerCamelCase :    List[Any]					,		lowerCamelCase :    Optional[Any]       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	get_timesformer_config(lowerCamelCase       )

	__lowerCAmelCase       				=	TimesformerForVideoClassification(lowerCamelCase       )

	# download original checkpoint, hosted on Google Drive
	__lowerCAmelCase       				=	"pytorch_model.bin"
	gdown.cached_download(lowerCamelCase					,		lowerCamelCase					,		quiet=lowerCamelCase       )
	__lowerCAmelCase       				=	torch.load(lowerCamelCase					,		map_location="cpu"       )
	if "model" in files:
		__lowerCAmelCase       				=	files["model"]
	elif "module" in files:
		__lowerCAmelCase       				=	files["module"]
	else:
		__lowerCAmelCase       				=	files["model_state"]
	__lowerCAmelCase       				=	convert_state_dict(lowerCamelCase					,		lowerCamelCase       )

	model.load_state_dict(lowerCamelCase       )
	model.eval()

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

	__lowerCAmelCase       				=	model(**lowerCamelCase       )
	__lowerCAmelCase       				=	outputs.logits

	__lowerCAmelCase       				=	[
	    # 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":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]       )
	elif model_name == "timesformer-base-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]       )
	elif model_name == "timesformer-base-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]       )
	elif model_name == "timesformer-large-finetuned-k400":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-large-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-large-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-hr-finetuned-k400":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]       )
	elif model_name == "timesformer-hr-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]       )
	elif model_name == "timesformer-hr-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]       )
	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]					,		lowerCamelCase					,		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(lowerCamelCase       )
		model.save_pretrained(lowerCamelCase       )

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


if __name__ == "__main__":
	lowerCAmelCase						:		Dict						      = 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.'''
	)

	lowerCAmelCase						:		Optional[int]						      = parser.parse_args()
	convert_timesformer_checkpoint(
	    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
	)