

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       snake_case_(_UpperCamelCase     )							->	List[str]:



  """simple docstring"""






  _snake_case						=							TimesformerConfig()

  if "large" in model_name:
    _snake_case						=							96

  if "hr" in model_name:
    _snake_case						=							16
    _snake_case						=							448

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

  return config



def       snake_case_(_UpperCamelCase     )							->	List[str]:



  """simple docstring"""






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

  return name



def       snake_case_(_UpperCamelCase ,       _UpperCamelCase     )							->	List[str]:



  """simple docstring"""






  for key in orig_state_dict.copy().keys():
    _snake_case						=							orig_state_dict.pop(_SCREAMING_SNAKE_CASE     )

    if key.startswith('''model.'''     ):
      _snake_case						=							key.replace('''model.''' ,       ''''''     )

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

  return orig_state_dict



def       snake_case_()							->	Optional[Any]:



  """simple docstring"""






  _snake_case						=							hf_hub_download(
      repo_id='''hf-internal-testing/spaghetti-video''' ,       filename='''eating_spaghetti.npy''' ,       repo_type='''dataset'''     )
  _snake_case						=							np.load(_SCREAMING_SNAKE_CASE     )
  return list(_SCREAMING_SNAKE_CASE     )



def       snake_case_(_UpperCamelCase ,       _UpperCamelCase ,       _UpperCamelCase ,       _UpperCamelCase     )							->	int:



  """simple docstring"""






  _snake_case						=							get_timesformer_config(_SCREAMING_SNAKE_CASE     )

  _snake_case						=							TimesformerForVideoClassification(_SCREAMING_SNAKE_CASE     )

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

  model.load_state_dict(_SCREAMING_SNAKE_CASE     )
  model.eval()

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

  _snake_case						=							model(**_SCREAMING_SNAKE_CASE     )
  _snake_case						=							outputs.logits

  _snake_case						=							[
      # 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":
    _snake_case						=							torch.Size([1, 400]     )
    _snake_case						=							torch.tensor([-0.3016, -0.7713, -0.4205]     )
  elif model_name == "timesformer-base-finetuned-k600":
    _snake_case						=							torch.Size([1, 600]     )
    _snake_case						=							torch.tensor([-0.7267, -0.7466, 3.2404]     )
  elif model_name == "timesformer-base-finetuned-ssv2":
    _snake_case						=							torch.Size([1, 174]     )
    _snake_case						=							torch.tensor([-0.9059, 0.6433, -3.1457]     )
  elif model_name == "timesformer-large-finetuned-k400":
    _snake_case						=							torch.Size([1, 400]     )
    _snake_case						=							torch.tensor([0, 0, 0]     )
  elif model_name == "timesformer-large-finetuned-k600":
    _snake_case						=							torch.Size([1, 600]     )
    _snake_case						=							torch.tensor([0, 0, 0]     )
  elif model_name == "timesformer-large-finetuned-ssv2":
    _snake_case						=							torch.Size([1, 174]     )
    _snake_case						=							torch.tensor([0, 0, 0]     )
  elif model_name == "timesformer-hr-finetuned-k400":
    _snake_case						=							torch.Size([1, 400]     )
    _snake_case						=							torch.tensor([-0.9617, -3.7311, -3.7708]     )
  elif model_name == "timesformer-hr-finetuned-k600":
    _snake_case						=							torch.Size([1, 600]     )
    _snake_case						=							torch.tensor([2.5273, 0.7127, 1.8848]     )
  elif model_name == "timesformer-hr-finetuned-ssv2":
    _snake_case						=							torch.Size([1, 174]     )
    _snake_case						=							torch.tensor([-3.6756, -0.7513, 0.7180]     )
  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] ,       _SCREAMING_SNAKE_CASE ,       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(_SCREAMING_SNAKE_CASE     )
    model.save_pretrained(_SCREAMING_SNAKE_CASE     )

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


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

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




'''simple docstring'''
import math
from itertools import permutations


def       a__    (  _SCREAMING_SNAKE_CASE					:    int							)			-> bool:


	"""simple docstring"""





	if 1 < number < 4:
		# 2 and 3 are primes
		return True
	elif number < 2 or number % 2 == 0 or number % 3 == 0:
		# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
		return False

	# All primes number are in format of 6k +/- 1
	for i in range(5     ,							int(math.sqrt(_SCREAMING_SNAKE_CASE							) + 1							)     ,							6							):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True


def       a__    (  _SCREAMING_SNAKE_CASE					:    int     ,							_SCREAMING_SNAKE_CASE					:    list							)			-> bool:


	"""simple docstring"""





	UpperCAmelCase_ , UpperCAmelCase_			:	Any      =   0, len(_SCREAMING_SNAKE_CASE							) - 1
	while left <= right:
		UpperCAmelCase_			:	List[str]      =   (left + right) // 2
		if prime_list[middle] == target:
			return True
		elif prime_list[middle] < target:
			UpperCAmelCase_			:	Dict      =   middle + 1
		else:
			UpperCAmelCase_			:	int      =   middle - 1

	return False


def       a__    (  )			-> Tuple:


	"""simple docstring"""





	UpperCAmelCase_			:	Dict      =   [n for n in range(10_01     ,							1_00_00     ,							2							) if is_prime(_SCREAMING_SNAKE_CASE							)]
	UpperCAmelCase_			:	Optional[int]      =   []

	for number in prime_list:
		UpperCAmelCase_			:	Optional[Any]      =   []

		for prime_member in permutations(list(str(_SCREAMING_SNAKE_CASE							)							)							):
			UpperCAmelCase_			:	List[Any]      =   int("".join(_SCREAMING_SNAKE_CASE							)							)

			if prime % 2 == 0:
				continue

			if search(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE							):
				tmp_numbers.append(_SCREAMING_SNAKE_CASE							)

		tmp_numbers.sort()
		if len(_SCREAMING_SNAKE_CASE							) >= 3:
			candidates.append(_SCREAMING_SNAKE_CASE							)

	UpperCAmelCase_			:	Tuple      =   []
	for candidate in candidates:
		UpperCAmelCase_			:	Union[str, Any]      =   len(_SCREAMING_SNAKE_CASE							)
		UpperCAmelCase_			:	Any      =   False

		for i in range(_SCREAMING_SNAKE_CASE							):
			for j in range(i + 1     ,							_SCREAMING_SNAKE_CASE							):
				for k in range(j + 1     ,							_SCREAMING_SNAKE_CASE							):
					if (
					    abs(candidate[i] - candidate[j]							)
					    == abs(candidate[j] - candidate[k]							)
					    and len({candidate[i], candidate[j], candidate[k]}							) == 3
					):
						passed.append(
						    sorted([candidate[i], candidate[j], candidate[k]]							)							)
						UpperCAmelCase_			:	Optional[Any]      =   True

					if found:
						break
				if found:
					break
			if found:
				break

	UpperCAmelCase_			:	Any      =   set()
	for seq in passed:
		answer.add("".join([str(_SCREAMING_SNAKE_CASE							) for i in seq]							)							)

	return max(int(_SCREAMING_SNAKE_CASE							) for x in answer							)


if __name__ == "__main__":
					print(solution())




