


'''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 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Dict )		->       Optional[Any]:





   '''simple docstring'''







   UpperCamelCase__			    =    TimesformerConfig()

   if "large" in model_name:
      UpperCamelCase__			    =    96

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

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

   return config



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Optional[int] )		->       Tuple:





   '''simple docstring'''







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

   return name



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int     ,		_UpperCamelCase   :					int )		->       Optional[int]:





   '''simple docstring'''







   for key in orig_state_dict.copy().keys():
      UpperCamelCase__			    =    orig_state_dict.pop(_UpperCamelCase )

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

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

   return orig_state_dict



def 							SCREAMING_SNAKE_CASE__(		)		->       int:





   '''simple docstring'''







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



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Optional[int]     ,		_UpperCamelCase   :					Optional[int]     ,		_UpperCamelCase   :					List[str]     ,		_UpperCamelCase   :					List[str] )		->       Optional[Any]:





   '''simple docstring'''







   UpperCamelCase__			    =    get_timesformer_config(_UpperCamelCase )

   UpperCamelCase__			    =    TimesformerForVideoClassification(_UpperCamelCase )

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

   model.load_state_dict(_UpperCamelCase )
   model.eval()

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

   UpperCamelCase__			    =    model(**_UpperCamelCase )
   UpperCamelCase__			    =    outputs.logits

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

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


if __name__ == "__main__":
       __lowercase:		str    						=  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."
       )

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





"""simple docstring"""





_lowercase						   =     (1, 1_53, 3_70, 3_71, 16_34, 24_67_80_51, 1_15_13_22_19_01_87_63_99_25_65_09_55_97_97_39_71_52_24_01)
_lowercase						   =     (-1_53, -1, 0, 1.2, 2_00, "A", [], {}, None)

def 		lowerCAmelCase				(			lowerCamelCase		):
						'''simple docstring'''


						if not isinstance(lowerCamelCase   ,      lowerCamelCase		) or n < 1:
												return False

						# Initialization of sum and number of digits.
						snake_case__							:       Optional[Any]				      =       0
						snake_case__							:       Union[str, Any]				      =       0
						snake_case__							:       List[str]				      =       n
						# Calculation of digits of the number
						while temp > 0:
												number_of_digits += 1
												temp //= 10
						# Dividing number into separate digits and find Armstrong number
						snake_case__							:       Optional[int]				      =       n
						while temp > 0:
												snake_case__							:       Optional[int]				      =       temp % 10
												total += rem**number_of_digits
												temp //= 10
						return n == total

def 		lowerCAmelCase				(			lowerCamelCase		):
						'''simple docstring'''


						if not isinstance(lowerCamelCase   ,      lowerCamelCase		) or n < 1:
												return False

						# Init a "histogram" of the digits
						snake_case__							:       Union[str, Any]				      =       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
						snake_case__							:       int				      =       0
						snake_case__							:       int				      =       0
						snake_case__							:       Dict				      =       n
						while temp > 0:
												snake_case__      ,						snake_case__							:       Optional[int]				      =       divmod(lowerCamelCase   ,      10		)
												digit_histogram[rem] += 1
												digit_total += 1

						for cnt, i in zip(lowerCamelCase   ,      range(len(lowerCamelCase		)		)		):
												total += cnt * i**digit_total

						return n == total

def 		lowerCAmelCase				(			lowerCamelCase		):
						'''simple docstring'''


						if not isinstance(lowerCamelCase   ,      lowerCamelCase		) or n < 1:
												return False
						snake_case__							:       Union[str, Any]				      =       len(str(lowerCamelCase		)		)  # the power that all digits will be raised to
						# check if sum of each digit multiplied expo times is equal to number
						return n == sum(int(lowerCamelCase		) ** expo for i in str(lowerCamelCase		)		)

def 		lowerCAmelCase				(			):
						'''simple docstring'''


						snake_case__							:       Dict				      =       int(input('''Enter an integer to see if it is an Armstrong number: '''		).strip()		)
						print(f'''{num} is {'' if armstrong_number(lowerCamelCase		) else 'not '}an Armstrong number.'''		)
						print(f'''{num} is {'' if narcissistic_number(lowerCamelCase		) else 'not '}an Armstrong number.'''		)
						print(f'''{num} is {'' if pluperfect_number(lowerCamelCase		) else 'not '}an Armstrong number.'''		)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()


