





'''simple docstring'''







import argparse
import json
from pathlib import Path

import torch
import torchaudio
from datasets import load_dataset
from huggingface_hub import hf_hub_download

from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase_					:    Union[str, Any]      	=			logging.get_logger(__name__)






def  _lowerCamelCase				( lowercase						:      List[Any]						)	->	str:
				_a								= ASTConfig()

				if "10-10" in model_name:
								pass
				elif "speech-commands" in model_name:
								_a								= 128
				elif "12-12" in model_name:
								_a								= 12
								_a								= 12
				elif "14-14" in model_name:
								_a								= 14
								_a								= 14
				elif "16-16" in model_name:
								_a								= 16
								_a								= 16
				else:
								raise ValueError("Model not supported"						)

				_a								= "huggingface/label-files"
				if "speech-commands" in model_name:
								_a								= 35
								_a								= "speech-commands-v2-id2label.json"
				else:
								_a								= 527
								_a								= "audioset-id2label.json"

				_a								= json.load(open(hf_hub_download(lowercase    ,							lowercase    ,							repo_type="dataset"						)    ,							"r"						)						)
				_a								= {int(lowercase						): v for k, v in idalabel.items()}
				_a								= idalabel
				_a								= {v: k for k, v in idalabel.items()}

				return config






def  _lowerCamelCase				( lowercase						:      Dict						)	->	Optional[Any]:
				if "module.v" in name:
								_a								= name.replace("module.v"    ,							"audio_spectrogram_transformer"						)
				if "cls_token" in name:
								_a								= name.replace("cls_token"    ,							"embeddings.cls_token"						)
				if "dist_token" in name:
								_a								= name.replace("dist_token"    ,							"embeddings.distillation_token"						)
				if "pos_embed" in name:
								_a								= name.replace("pos_embed"    ,							"embeddings.position_embeddings"						)
				if "patch_embed.proj" in name:
								_a								= name.replace("patch_embed.proj"    ,							"embeddings.patch_embeddings.projection"						)
				# transformer blocks
				if "blocks" in name:
								_a								= name.replace("blocks"    ,							"encoder.layer"						)
				if "attn.proj" in name:
								_a								= name.replace("attn.proj"    ,							"attention.output.dense"						)
				if "attn" in name:
								_a								= name.replace("attn"    ,							"attention.self"						)
				if "norm1" in name:
								_a								= name.replace("norm1"    ,							"layernorm_before"						)
				if "norm2" in name:
								_a								= name.replace("norm2"    ,							"layernorm_after"						)
				if "mlp.fc1" in name:
								_a								= name.replace("mlp.fc1"    ,							"intermediate.dense"						)
				if "mlp.fc2" in name:
								_a								= name.replace("mlp.fc2"    ,							"output.dense"						)
				# final layernorm
				if "audio_spectrogram_transformer.norm" in name:
								_a								= name.replace("audio_spectrogram_transformer.norm"    ,							"audio_spectrogram_transformer.layernorm"						)
				# classifier head
				if "module.mlp_head.0" in name:
								_a								= name.replace("module.mlp_head.0"    ,							"classifier.layernorm"						)
				if "module.mlp_head.1" in name:
								_a								= name.replace("module.mlp_head.1"    ,							"classifier.dense"						)

				return name






def  _lowerCamelCase				( lowercase						:      Any    ,							lowercase						:      Tuple						)	->	List[str]:
				for key in orig_state_dict.copy().keys():
								_a								= orig_state_dict.pop(lowercase						)

								if "qkv" in key:
												_a								= key.split("."						)
												_a								= int(key_split[3]						)
												_a								= config.hidden_size
												if "weight" in key:
																_a								= val[:dim, :]
																_a								= val[dim : dim * 2, :]
																_a								= val[-dim:, :]
												else:
																_a								= val[:dim]
																_a								= val[dim : dim * 2]
																_a								= val[-dim:]
								else:
												_a								= val

				return orig_state_dict






def  _lowerCamelCase				( lowercase						:      Optional[int]						)	->	Optional[int]:
				_a								= [
				    "module.v.head.weight",
				    "module.v.head.bias",
				    "module.v.head_dist.weight",
				    "module.v.head_dist.bias",
				]
				for k in ignore_keys:
								state_dict.pop(lowercase    ,							lowercase						)






@torch.no_grad()
def  _lowerCamelCase				( lowercase						:      Union[str, Any]    ,							lowercase						:      List[Any]    ,							lowercase						:      Dict=False						)	->	int:
				_a								= get_audio_spectrogram_transformer_config(lowercase						)

				_a								= {
				    "ast-finetuned-audioset-10-10-0.4593": (
				        "https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-10-10-0.450": (
				        "https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-10-10-0.448": (
				        "https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-10-10-0.448-v2": (
				        "https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-12-12-0.447": (
				        "https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-14-14-0.443": (
				        "https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1"
				    ),
				    "ast-finetuned-audioset-16-16-0.442": (
				        "https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1"
				    ),
				    "ast-finetuned-speech-commands-v2": (
				        "https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1"
				    ),
				}

				# load original state_dict
				_a								= model_name_to_url[model_name]
				_a								= torch.hub.load_state_dict_from_url(lowercase    ,							map_location="cpu"						)
				# remove some keys
				remove_keys(lowercase						)
				# rename some keys
				_a								= convert_state_dict(lowercase    ,							lowercase						)

				# load 🤗 model
				_a								= ASTForAudioClassification(lowercase						)
				model.eval()

				model.load_state_dict(lowercase						)

				# verify outputs on dummy input
				# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
				_a								= -4.2_67_73_93 if "speech-commands" not in model_name else -6.84_59_78
				_a								= 4.5_68_99_74 if "speech-commands" not in model_name else 5.5_65_45_26
				_a								= 1024 if "speech-commands" not in model_name else 128
				_a								= ASTFeatureExtractor(mean=lowercase    ,							std=lowercase    ,							max_length=lowercase						)

				if "speech-commands" in model_name:
								_a								= load_dataset("speech_commands"    ,							"v0.02"    ,							split="validation"						)
								_a								= dataset[0]["audio"]["array"]
				else:
								_a								= hf_hub_download(
								    repo_id="nielsr/audio-spectogram-transformer-checkpoint"    ,							filename="sample_audio.flac"    ,							repo_type="dataset"    ,							)

								_a	,					_a								= torchaudio.load(lowercase						)
								_a								= waveform.squeeze().numpy()

				_a								= feature_extractor(lowercase    ,							sampling_rate=1_6000    ,							return_tensors="pt"						)

				# forward pass
				_a								= model(**lowercase						)
				_a								= outputs.logits

				if model_name == "ast-finetuned-audioset-10-10-0.4593":
								_a								= torch.tensor([-0.87_60, -7.00_42, -8.66_02]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.450":
								_a								= torch.tensor([-1.19_86, -7.09_03, -8.27_18]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.448":
								_a								= torch.tensor([-2.61_28, -8.00_80, -9.43_44]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
								_a								= torch.tensor([-1.50_80, -7.45_34, -8.89_17]						)
				elif model_name == "ast-finetuned-audioset-12-12-0.447":
								_a								= torch.tensor([-0.50_50, -6.58_33, -8.08_43]						)
				elif model_name == "ast-finetuned-audioset-14-14-0.443":
								_a								= torch.tensor([-0.38_26, -7.03_36, -8.24_13]						)
				elif model_name == "ast-finetuned-audioset-16-16-0.442":
								_a								= torch.tensor([-1.21_13, -6.91_01, -8.34_70]						)
				elif model_name == "ast-finetuned-speech-commands-v2":
								_a								= torch.tensor([6.15_89, -8.05_66, -8.79_84]						)
				else:
								raise ValueError("Unknown model name"						)
				if not torch.allclose(logits[0, :3]    ,							lowercase    ,							atol=1E-4						):
								raise ValueError("Logits don't match"						)
				print("Looks ok!"						)

				if pytorch_dump_folder_path is not None:
								Path(lowercase						).mkdir(exist_ok=lowercase						)
								print(F'Saving model {model_name} to {pytorch_dump_folder_path}'						)
								model.save_pretrained(lowercase						)
								print(F'Saving feature extractor to {pytorch_dump_folder_path}'						)
								feature_extractor.save_pretrained(lowercase						)

				if push_to_hub:
								print("Pushing model and feature extractor to the hub..."						)
								model.push_to_hub(F'MIT/{model_name}'						)
								feature_extractor.push_to_hub(F'MIT/{model_name}'						)


if __name__ == "__main__":
					lowerCAmelCase_					:    Tuple      	=			argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--model_name',
					    default='ast-finetuned-audioset-10-10-0.4593',
					    type=str,
					    help='Name of the Audio Spectrogram Transformer model you\'d like to convert.',
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
					)
					parser.add_argument(
					    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
					)

					lowerCAmelCase_					:    Dict      	=			parser.parse_args()
					convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





import string


def 			UpperCamelCase(  __UpperCamelCase							:		str ):
		for key in range(len(string.ascii_uppercase ) ):
				lowerCAmelCase_			:     List[Any]									= ''''''
				for symbol in message:
						if symbol in string.ascii_uppercase:
								lowerCAmelCase_			:     Optional[int]									= string.ascii_uppercase.find(__UpperCamelCase )
								lowerCAmelCase_			:     Optional[int]									= num - key
								if num < 0:
										lowerCAmelCase_			:     int									= num + len(string.ascii_uppercase )
								lowerCAmelCase_			:     int									= translated + string.ascii_uppercase[num]
						else:
								lowerCAmelCase_			:     Optional[int]									= translated + symbol
				print(f"""Decryption using Key #{key}: {translated}""" )


def 			UpperCamelCase(  ):
		lowerCAmelCase_			:     Dict									= input('''Encrypted message: ''' )
		lowerCAmelCase_			:     List[str]									= message.upper()
		decrypt(__UpperCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()





