"""simple docstring"""







import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling
def     __UpperCAmelCase							(       UpperCAmelCase_       :							str    )				->     Dict:

	'''simple docstring'''





	__snake_case     :				Any 						=					"""https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"""

	with open(UpperCAmelCase_     ,				'wb'    ) as f:
		with requests.get(UpperCAmelCase_     ,				stream=UpperCAmelCase_    ) as req:
			for chunk in req.iter_content(chunk_size=20_48    ):
				f.write(UpperCAmelCase_    )
def     __UpperCAmelCase							(       )				->     List[Any]:

	'''simple docstring'''





	__snake_case     :				Optional[int] 						=					VivitConfig()

	__snake_case     :				Optional[int] 						=					4_00
	__snake_case     :				Optional[Any] 						=					"""huggingface/label-files"""
	__snake_case     :				int 						=					"""kinetics400-id2label.json"""

	__snake_case     :				Any 						=					json.load(open(hf_hub_download(UpperCAmelCase_     ,				UpperCAmelCase_     ,				repo_type='dataset'    )     ,				'r'    )    )
	__snake_case     :				List[Any] 						=					{int(UpperCAmelCase_    ): v for k, v in idalabel.items()}
	__snake_case     :				Union[str, Any] 						=					idalabel
	__snake_case     :				int 						=					{v: k for k, v in idalabel.items()}
	return config
def     __UpperCAmelCase							(       )				->     Optional[Any]:

	'''simple docstring'''





	__snake_case     :				int 						=					hf_hub_download(
	    repo_id='hf-internal-testing/spaghetti-video'     ,				filename='eating_spaghetti_32_frames.npy'     ,				repo_type='dataset'    )
	__snake_case     :				Optional[int] 						=					np.load(UpperCAmelCase_    )
	return list(UpperCAmelCase_    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Union[str, Any]    )				->     Dict:

	'''simple docstring'''





	if np.ndim(UpperCAmelCase_    ) == 2:
		return transform_attention_bias(UpperCAmelCase_    )

	elif np.ndim(UpperCAmelCase_    ) == 3:
		return transform_attention_kernel(UpperCAmelCase_    )

	else:
		raise Exception(F"Invalid number of dimesions: {np.ndim(UpperCAmelCase_    )}"    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							int    )				->     Dict:

	'''simple docstring'''





	return current.flatten()
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[str]    )				->     List[Any]:

	'''simple docstring'''





	return np.reshape(UpperCAmelCase_     ,				(current.shape[0], current.shape[1] * current.shape[2])    ).T
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Optional[int]    )				->     Union[str, Any]:

	'''simple docstring'''





	return np.reshape(UpperCAmelCase_     ,				(current.shape[0] * current.shape[1], current.shape[2])    ).T
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Tuple     ,				UpperCAmelCase_       :							Tuple    )				->     Union[str, Any]:

	'''simple docstring'''





	__snake_case     :				str 						=					state_dict["""optimizer"""]["""target"""]["""Transformer"""][F"encoderblock_{i}"]

	__snake_case     :				List[str] 						=					F"encoder.layer.{i}."
	__snake_case     :				str 						=					{
	    prefix + """intermediate.dense.bias""": state["""MlpBlock_0"""]["""Dense_0"""]["""bias"""],
	    prefix + """intermediate.dense.weight""": np.transpose(state['MlpBlock_0']['Dense_0']['kernel']    ),
	    prefix + """output.dense.bias""": state["""MlpBlock_0"""]["""Dense_1"""]["""bias"""],
	    prefix + """output.dense.weight""": np.transpose(state['MlpBlock_0']['Dense_1']['kernel']    ),
	    prefix + """layernorm_before.bias""": state["""LayerNorm_0"""]["""bias"""],
	    prefix + """layernorm_before.weight""": state["""LayerNorm_0"""]["""scale"""],
	    prefix + """layernorm_after.bias""": state["""LayerNorm_1"""]["""bias"""],
	    prefix + """layernorm_after.weight""": state["""LayerNorm_1"""]["""scale"""],
	    prefix
	    + """attention.attention.query.bias""": transform_attention(
	        state['MultiHeadDotProductAttention_0']['query']['bias']    ),
	    prefix
	    + """attention.attention.query.weight""": transform_attention(
	        state['MultiHeadDotProductAttention_0']['query']['kernel']    ),
	    prefix
	    + """attention.attention.key.bias""": transform_attention(state['MultiHeadDotProductAttention_0']['key']['bias']    ),
	    prefix
	    + """attention.attention.key.weight""": transform_attention(
	        state['MultiHeadDotProductAttention_0']['key']['kernel']    ),
	    prefix
	    + """attention.attention.value.bias""": transform_attention(
	        state['MultiHeadDotProductAttention_0']['value']['bias']    ),
	    prefix
	    + """attention.attention.value.weight""": transform_attention(
	        state['MultiHeadDotProductAttention_0']['value']['kernel']    ),
	    prefix + """attention.output.dense.bias""": state["""MultiHeadDotProductAttention_0"""]["""out"""]["""bias"""],
	    prefix
	    + """attention.output.dense.weight""": transform_attention_output_weight(
	        state['MultiHeadDotProductAttention_0']['out']['kernel']    ),
	}

	return new_state
def     __UpperCAmelCase							(       UpperCAmelCase_       :							List[str]    )				->     Union[str, Any]:

	'''simple docstring'''





	return sum([1 if 'encoderblock_' in k else 0 for k in state_dict['optimizer']['target']['Transformer'].keys()]    )
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Optional[int]     ,				UpperCAmelCase_       :							Dict=False    )				->     str:

	'''simple docstring'''





	__snake_case     :				Optional[int] 						=					get_n_layers(UpperCAmelCase_    )

	__snake_case     :				Optional[int] 						=					OrderedDict()

	__snake_case     :				str 						=					state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""bias"""]
	__snake_case     :				Union[str, Any] 						=					state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""scale"""]

	__snake_case     :				Union[str, Any] 						=					np.transpose(
	    state_dict['optimizer']['target']['embedding']['kernel']     ,				(4, 3, 0, 1, 2)    )
	__snake_case     :				List[Any] 						=					state_dict["""optimizer"""]["""target"""]["""embedding"""]["""bias"""]

	__snake_case     :				str 						=					state_dict["""optimizer"""]["""target"""]["""cls"""]
	__snake_case     :				Union[str, Any] 						=					state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""posembed_input"""][
	    """pos_embedding"""
	]

	for i in range(UpperCAmelCase_    ):
		new_state.update(transform_state_encoder_block(UpperCAmelCase_     ,				UpperCAmelCase_    )    )

	if classification_head:
		__snake_case     :				Any 						=					{"""vivit.""" + k: v for k, v in new_state.items()}
		__snake_case     :				Optional[Any] 						=					np.transpose(state_dict['optimizer']['target']['output_projection']['kernel']    )
		__snake_case     :				int 						=					np.transpose(state_dict['optimizer']['target']['output_projection']['bias']    )

	return {k: torch.tensor(UpperCAmelCase_    ) for k, v in new_state.items()}
def     __UpperCAmelCase							(       )				->     List[str]:

	'''simple docstring'''





	__snake_case     :				Tuple 						=					VivitImageProcessor()

	assert extractor.do_resize is True
	assert extractor.size == {"shortest_edge": 2_56}
	assert extractor.do_center_crop is True
	assert extractor.crop_size == {"width": 2_24, "height": 2_24}
	assert extractor.resample == PILImageResampling.BILINEAR

	# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
	# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
	# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
	assert extractor.do_normalize is False
	assert extractor.do_rescale is True
	assert extractor.rescale_factor == 1 / 2_55

	# zero-centering = True in original implementation
	assert extractor.do_zero_centering is True

	return extractor
def     __UpperCAmelCase							(       UpperCAmelCase_       :							Union[str, Any]    )				->     Optional[Any]:

	'''simple docstring'''





	__snake_case     :				Dict 						=					"""checkpoint"""

	if not os.path.exists(UpperCAmelCase_    ):
		download_checkpoint(UpperCAmelCase_    )

	__snake_case     :				Optional[int] 						=					restore_checkpoint(UpperCAmelCase_     ,				UpperCAmelCase_    )
	__snake_case     :				Optional[int] 						=					transform_state(UpperCAmelCase_     ,				classification_head=UpperCAmelCase_    )

	__snake_case     :				Optional[int] 						=					get_vivit_config()

	assert config.image_size == 2_24
	assert config.num_frames == 32

	__snake_case     :				Dict 						=					VivitForVideoClassification(UpperCAmelCase_    )
	model.load_state_dict(UpperCAmelCase_    )
	model.eval()

	__snake_case     :				Optional[Any] 						=					get_processor()

	__snake_case     :				Optional[Any] 						=					prepare_video()
	__snake_case     :				Any 						=					extractor(UpperCAmelCase_     ,				return_tensors='pt'    )

	__snake_case     :				Tuple 						=					model(**UpperCAmelCase_    )

	__snake_case     :				List[Any] 						=					torch.Size([1, 4_00]    )
	__snake_case     :				Dict 						=					torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]    )

	assert outputs.logits.shape == expected_shape
	assert torch.allclose(outputs.logits[0, :5]     ,				UpperCAmelCase_     ,				atol=1E-4    ), outputs.logits[0, :5]

	model.save_pretrained(UpperCAmelCase_    )
	extractor.save_pretrained(UpperCAmelCase_    )


if __name__ == "__main__":
	_a	:	Optional[int]=					argparse.ArgumentParser()

	parser.add_argument("--output_model_name", "-o", type=str, help="Output path for the converted HuggingFace model")

	_a	:	Optional[Any]=					parser.parse_args()
	convert(args.output_model_name)











'''simple docstring'''





from __future__ import annotations

import random
import string




class      UpperCamelCase       :



  def __init__(			self		,     __lowerCAmelCase = None ):







      '''simple docstring'''


      _a				:							List[Any]							       =      passcode or self.__passcode_creator()
      _a				:							List[str]							       =      self.__make_key_list()
      _a				:							Optional[int]							       =      self.__make_shift_key()



  def __str__(			self ):







      '''simple docstring'''


      return "".join(self.__passcode )



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      for i in range(1		,     len(__lowerCAmelCase )		,     2 ):
          iterlist[i] *= -1
      return iterlist



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Optional[int]							       =      string.ascii_letters + string.digits
      _a				:							str							       =      [random.choice(__lowerCAmelCase ) for _ in range(random.randint(10		,     20 ) )]
      return password



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Dict							       =      (
          string.ascii_letters + string.digits + string.punctuation + """ \t\n"""
      )

      _a				:							str							       =      []

      # creates points known as breakpoints to break the key_list_options at those
      # points and pivot each substring
      _a				:							Dict							       =      sorted(set(self.__passcode ) )
      _a				:							list[str]							       =      []

      # algorithm for creating a new shuffled list, keys_l, out of key_list_options
      for i in key_list_options:
          temp_list.extend(__lowerCAmelCase )

          # checking breakpoints at which to pivot temporary sublist and add it into
          # keys_l
          if i in breakpoints or i == key_list_options[-1]:
              keys_l.extend(temp_list[::-1] )
              temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
      return keys_l



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Optional[Any]							       =      sum(self.__neg_pos([ord(__lowerCAmelCase ) for x in self.__passcode] ) )
      return num if num > 0 else len(self.__passcode )



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Tuple							       =      """"""

      # decoding shift like Caesar cipher algorithm implementing negative shift or
      # reverse shift or left shift
      for i in encoded_message:
          _a				:							List[str]							       =      self.__key_list.index(__lowerCAmelCase )
          decoded_message += self.__key_list[
              (position - self.__shift_key) % -len(self.__key_list )
          ]

      return decoded_message



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							List[str]							       =      """"""

      # encoding shift like Caesar cipher algorithm implementing positive shift or
      # forward shift or right shift
      for i in plaintext:
          _a				:							Any							       =      self.__key_list.index(__lowerCAmelCase )
          encoded_message += self.__key_list[
              (position + self.__shift_key) % len(self.__key_list )
          ]

      return encoded_message






def UpperCAmelCase    (       UpperCAmelCase_ = "Hello, this is a modified Caesar cipher"						):
    _a				:							Union[str, Any]							       =      ShuffledShiftCipher()
    return cipa.decrypt(cipa.encrypt(UpperCAmelCase_						)						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()


