



"""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      A      (			_A							):




					"""simple docstring"""
					snake_case_						:Dict								=						"https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"

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




					"""simple docstring"""
					snake_case_						:str								=						VivitConfig()

					snake_case_						:Union[str, Any]								=						400
					snake_case_						:Union[str, Any]								=						"huggingface/label-files"
					snake_case_						:int								=						"kinetics400-id2label.json"

					snake_case_						:Any								=						json.load(open(hf_hub_download(_A,     _A,     repo_type="dataset"							),     "r"							)							)
					snake_case_						:int								=						{int(_A							): v for k, v in idalabel.items()}
					snake_case_						:Union[str, Any]								=						idalabel
					snake_case_						:Tuple								=						{v: k for k, v in idalabel.items()}
					return config
def      A      (			):




					"""simple docstring"""
					snake_case_						:Optional[int]								=						hf_hub_download(
					    repo_id="hf-internal-testing/spaghetti-video",     filename="eating_spaghetti_32_frames.npy",     repo_type="dataset"							)
					snake_case_						:Union[str, Any]								=						np.load(_A							)
					return list(_A							)
def      A      (			_A							):




					"""simple docstring"""
					if np.ndim(_A							) == 2:
										return transform_attention_bias(_A							)

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

					else:
										raise Exception(F'''Invalid number of dimesions: {np.ndim(_A							)}'''							)
def      A      (			_A							):




					"""simple docstring"""
					return current.flatten()
def      A      (			_A							):




					"""simple docstring"""
					return np.reshape(_A,     (current.shape[0], current.shape[1] * current.shape[2])							).T
def      A      (			_A							):




					"""simple docstring"""
					return np.reshape(_A,     (current.shape[0] * current.shape[1], current.shape[2])							).T
def      A      (			_A,     _A							):




					"""simple docstring"""
					snake_case_						:Union[str, Any]								=						state_dict["optimizer"]["target"]["Transformer"][F'''encoderblock_{i}''']

					snake_case_						:Any								=						F'''encoder.layer.{i}.'''
					snake_case_						:List[Any]								=						{
					    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      A      (			_A							):




					"""simple docstring"""
					return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()]							)
def      A      (			_A,     _A=False							):




					"""simple docstring"""
					snake_case_						:str								=						get_n_layers(_A							)

					snake_case_						:int								=						OrderedDict()

					snake_case_						:str								=						state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
					snake_case_						:int								=						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_						:str								=						state_dict["optimizer"]["target"]["embedding"]["bias"]

					snake_case_						:Dict								=						state_dict["optimizer"]["target"]["cls"]
					snake_case_						:List[str]								=						state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
					    "pos_embedding"
					]

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

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

					return {k: torch.tensor(_A							) for k, v in new_state.items()}
def      A      (			):




					"""simple docstring"""
					snake_case_						:Any								=						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      A      (			_A							):




					"""simple docstring"""
					snake_case_						:Optional[Any]								=						"checkpoint"

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

					snake_case_						:Any								=						restore_checkpoint(_A,     _A							)
					snake_case_						:str								=						transform_state(_A,     classification_head=_A							)

					snake_case_						:Union[str, Any]								=						get_vivit_config()

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

					snake_case_						:Union[str, Any]								=						VivitForVideoClassification(_A							)
					model.load_state_dict(_A							)
					model.eval()

					snake_case_						:Optional[Any]								=						get_processor()

					snake_case_						:Union[str, Any]								=						prepare_video()
					snake_case_						:Dict								=						extractor(_A,     return_tensors="pt"							)

					snake_case_						:List[str]								=						model(**_A							)

					snake_case_						:int								=						torch.Size([1, 400]							)
					snake_case_						:Tuple								=						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],     _A,     atol=1e-4							), outputs.logits[0, :5]

					model.save_pretrained(_A							)
					extractor.save_pretrained(_A							)


if __name__ == "__main__":
				__UpperCAmelCase      :      List[Any]   					=					argparse.ArgumentParser()

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

				__UpperCAmelCase      :      Tuple   					=					parser.parse_args()
				convert(args.output_model_name)






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("plaintext must be a string"							)
					if not isinstance(_A,     _A							):
										raise TypeError("key must be a string"							)

					if not plaintext:
										raise ValueError("plaintext is empty"							)
					if not key:
										raise ValueError("key is empty"							)

					key += plaintext
					snake_case_						:Optional[int]								=						plaintext.lower()
					snake_case_						:Union[str, Any]								=						key.lower()
					snake_case_						:Any								=						0
					snake_case_						:str								=						0
					snake_case_						:Union[str, Any]								=						""
					while plaintext_iterator < len(_A							):
										if (
										    ord(plaintext[plaintext_iterator]							) < 97
										    or ord(plaintext[plaintext_iterator]							) > 122
										):
															ciphertext += plaintext[plaintext_iterator]
															plaintext_iterator += 1
										elif ord(key[key_iterator]							) < 97 or ord(key[key_iterator]							) > 122:
															key_iterator += 1
										else:
															ciphertext += chr(
															    (
															        (ord(plaintext[plaintext_iterator]							) - 97 + ord(key[key_iterator]							))
															        - 97
															    )
															    % 26
															    + 97							)
															key_iterator += 1
															plaintext_iterator += 1
					return ciphertext
def      A      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("ciphertext must be a string"							)
					if not isinstance(_A,     _A							):
										raise TypeError("key must be a string"							)

					if not ciphertext:
										raise ValueError("ciphertext is empty"							)
					if not key:
										raise ValueError("key is empty"							)

					snake_case_						:Tuple								=						key.lower()
					snake_case_						:Tuple								=						0
					snake_case_						:int								=						0
					snake_case_						:int								=						""
					while ciphertext_iterator < len(_A							):
										if (
										    ord(ciphertext[ciphertext_iterator]							) < 97
										    or ord(ciphertext[ciphertext_iterator]							) > 122
										):
															plaintext += ciphertext[ciphertext_iterator]
										else:
															plaintext += chr(
															    (ord(ciphertext[ciphertext_iterator]							) - ord(key[key_iterator]							)) % 26
															    + 97							)
															key += chr(
															    (ord(ciphertext[ciphertext_iterator]							) - ord(key[key_iterator]							)) % 26
															    + 97							)
															key_iterator += 1
										ciphertext_iterator += 1
					return plaintext


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				__UpperCAmelCase      :      Dict   					=					int(input('Type 1 to encrypt or 2 to decrypt:'))
				if operation == 1:
								__UpperCAmelCase      :      List[str]   					=					input('Typeplaintext to be encrypted:\n')
								__UpperCAmelCase      :      Optional[int]   					=					input('Type the key:\n')
								print(encrypt(plaintext, key))
				elif operation == 2:
								__UpperCAmelCase      :      List[Any]   					=					input('Type the ciphertext to be decrypted:\n')
								__UpperCAmelCase      :      Dict   					=					input('Type the key:\n')
								print(decrypt(ciphertext, key))
				decrypt('jsqqs avvwo', 'coffee')

