
'''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 	snake_case_							(				_a  :				Tuple      ):
      snake_case_    							=				"https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"

      with open(_SCREAMING_SNAKE_CASE			,       "wb"      ) as f:
            with requests.get(_SCREAMING_SNAKE_CASE			,       stream=_SCREAMING_SNAKE_CASE      ) as req:
                  for chunk in req.iter_content(chunk_size=2_048      ):
                        f.write(_SCREAMING_SNAKE_CASE      )
def 	snake_case_							(				):
      snake_case_    							=				VivitConfig()

      snake_case_    							=				400
      snake_case_    							=				"huggingface/label-files"
      snake_case_    							=				"kinetics400-id2label.json"

      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_							(				):
      snake_case_    							=				hf_hub_download(
          repo_id="hf-internal-testing/spaghetti-video"			,       filename="eating_spaghetti_32_frames.npy"			,       repo_type="dataset"      )
      snake_case_    							=				np.load(_SCREAMING_SNAKE_CASE      )
      return list(_SCREAMING_SNAKE_CASE      )
def 	snake_case_							(				_a  :				Optional[Any]      ):






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

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

      else:
            raise Exception(F'''Invalid number of dimesions: {np.ndim(_SCREAMING_SNAKE_CASE      )}'''      )
def 	snake_case_							(				_a  :				Dict      ):
      return current.flatten()
def 	snake_case_							(				_a  :				Union[str, Any]      ):
      return np.reshape(_SCREAMING_SNAKE_CASE			,       (current.shape[0], current.shape[1] * current.shape[2])      ).T
def 	snake_case_							(				_a  :				Dict      ):
      return np.reshape(_SCREAMING_SNAKE_CASE			,       (current.shape[0] * current.shape[1], current.shape[2])      ).T
def 	snake_case_							(				_a  :				List[str]			,       _a  :				Tuple      ):
      snake_case_    							=				state_dict["optimizer"]["target"]["Transformer"][F'''encoderblock_{i}''']

      snake_case_    							=				F'''encoder.layer.{i}.'''
      snake_case_    							=				{
          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 	snake_case_							(				_a  :				Optional[int]      ):
      return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()]      )
def 	snake_case_							(				_a  :				Tuple			,       _a  :				List[str]=False      ):
      snake_case_    							=				get_n_layers(_SCREAMING_SNAKE_CASE      )

      snake_case_    							=				OrderedDict()

      snake_case_    							=				state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
      snake_case_    							=				state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]

      snake_case_    							=				np.transpose(
          state_dict["optimizer"]["target"]["embedding"]["kernel"]			,       (4, 3, 0, 1, 2)      )
      snake_case_    							=				state_dict["optimizer"]["target"]["embedding"]["bias"]

      snake_case_    							=				state_dict["optimizer"]["target"]["cls"]
      snake_case_    							=				state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
          "pos_embedding"
      ]

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

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

      return {k: torch.tensor(_SCREAMING_SNAKE_CASE      ) for k, v in new_state.items()}
def 	snake_case_							(				):
      snake_case_    							=				VivitImageProcessor()

      assert extractor.do_resize is True
      assert extractor.size == {"shortest_edge": 256}
      assert extractor.do_center_crop is True
      assert extractor.crop_size == {"width": 224, "height": 224}
      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 / 255

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

      return extractor
def 	snake_case_							(				_a  :				Dict      ):
      snake_case_    							=				"checkpoint"

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

      snake_case_    							=				restore_checkpoint(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE      )
      snake_case_    							=				transform_state(_SCREAMING_SNAKE_CASE			,       classification_head=_SCREAMING_SNAKE_CASE      )

      snake_case_    							=				get_vivit_config()

      assert config.image_size == 224
      assert config.num_frames == 32

      snake_case_    							=				VivitForVideoClassification(_SCREAMING_SNAKE_CASE      )
      model.load_state_dict(_SCREAMING_SNAKE_CASE      )
      model.eval()

      snake_case_    							=				get_processor()

      snake_case_    							=				prepare_video()
      snake_case_    							=				extractor(_SCREAMING_SNAKE_CASE			,       return_tensors="pt"      )

      snake_case_    							=				model(**_SCREAMING_SNAKE_CASE      )

      snake_case_    							=				torch.Size([1, 400]      )
      snake_case_    							=				torch.tensor([-1.0_5_4_3, 2.0_7_6_4, -0.2_1_0_4, 0.4_4_3_9, -0.9_6_5_8]      )

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

      model.save_pretrained(_SCREAMING_SNAKE_CASE      )
      extractor.save_pretrained(_SCREAMING_SNAKE_CASE      )


if __name__ == "__main__":
     A							     = argparse.ArgumentParser()

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

     A							     = parser.parse_args()
     convert(args.output_model_name)



from __future__ import annotations

from string import ascii_letters




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							_UpperCAmelCase  :			List[Any]	       =		alphabet or ascii_letters

							# The final result string
							_UpperCAmelCase  :			Optional[Any]	       =		""

							for character in input_string:
														if character not in alpha:
																					# Append without encryption if character is not in the alphabet
																					result += character
														else:
																					# Get the index of the new key and make sure it isn't too large
																					_UpperCAmelCase  :			Any	       =		(alpha.index(_SCREAMING_SNAKE_CASE  ) + key) % len(_SCREAMING_SNAKE_CASE  )

																					# Append the encoded character to the alphabet
																					result += alpha[new_key]

							return result




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							key *= -1

							return encrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      dict[int, str]:

							"""simple docstring"""






							_UpperCAmelCase  :			Any	       =		alphabet or ascii_letters

							# To store data on all the combinations
							_UpperCAmelCase  :			Dict	       =		{}

							# Cycle through each combination
							for key in range(1      ,	len(_SCREAMING_SNAKE_CASE  ) + 1  ):
														# Decrypt the message and store the result in the data
														_UpperCAmelCase  :			Union[str, Any]	       =		decrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )

							return brute_force_data


if __name__ == "__main__":
				while True:
								print(f'''\n{'-' * 1_0}\n Menu\n{'-' * 1_0}''')
								print(*['1.Encrypt', '2.Decrypt', '3.BruteForce', '4.Quit'], sep='\n')

								# get user input
								__lowerCamelCase								=					input('\nWhat would you like to do?: ').strip() or '4'

								# run functions based on what the user chose
								if choice not in ("1", "2", "3", "4"):
												print('Invalid choice, please enter a valid choice')
								elif choice == "1":
												__lowerCamelCase								=					input('Please enter the string to be encrypted: ')
												__lowerCamelCase								=					int(input('Please enter off-set: ').strip())

												print(encrypt(input_string, key))
								elif choice == "2":
												__lowerCamelCase								=					input('Please enter the string to be decrypted: ')
												__lowerCamelCase								=					int(input('Please enter off-set: ').strip())

												print(decrypt(input_string, key))
								elif choice == "3":
												__lowerCamelCase								=					input('Please enter the string to be decrypted: ')
												__lowerCamelCase								=					brute_force(input_string)

												for key, value in brute_force_data.items():
																print(f'''Key: {key} | Message: {value}''')

								elif choice == "4":
												print('Goodbye.')
												break




