
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()
lowercase    :   Any		       =				logging.get_logger(__name__)







def 		_snake_case(    SCREAMING_SNAKE_CASE__							)					->       Dict:
       lowercase				:	int			      = ASTConfig()

       if "10-10" in model_name:
              pass
       elif "speech-commands" in model_name:
              lowercase				:	str			      = 128
       elif "12-12" in model_name:
              lowercase				:	str			      = 12
              lowercase				:	Dict			      = 12
       elif "14-14" in model_name:
              lowercase				:	Any			      = 14
              lowercase				:	Any			      = 14
       elif "16-16" in model_name:
              lowercase				:	Optional[Any]			      = 16
              lowercase				:	List[str]			      = 16
       else:
              raise ValueError("""Model not supported"""							)

       lowercase				:	Optional[Any]			      = """huggingface/label-files"""
       if "speech-commands" in model_name:
              lowercase				:	Optional[Any]			      = 35
              lowercase				:	List[Any]			      = """speech-commands-v2-id2label.json"""
       else:
              lowercase				:	Any			      = 527
              lowercase				:	Optional[int]			      = """audioset-id2label.json"""

       lowercase				:	Dict			      = json.load(open(hf_hub_download(__a   ,      __a   ,      repo_type="""dataset"""							)   ,      """r"""							)							)
       lowercase				:	List[str]			      = {int(__a							): v for k, v in idalabel.items()}
       lowercase				:	Union[str, Any]			      = idalabel
       lowercase				:	Optional[Any]			      = {v: k for k, v in idalabel.items()}

       return config







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

       return name







def 		_snake_case(    SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__							)					->       Dict:
       for key in orig_state_dict.copy().keys():
              lowercase				:	Any			      = orig_state_dict.pop(__a							)

              if "qkv" in key:
                     lowercase				:	Dict			      = key.split("""."""							)
                     lowercase				:	int			      = int(key_split[3]							)
                     lowercase				:	List[Any]			      = config.hidden_size
                     if "weight" in key:
                            lowercase				:	Tuple			      = val[:dim, :]
                            lowercase				:	Any			      = val[dim : dim * 2, :]
                            lowercase				:	Union[str, Any]			      = val[-dim:, :]
                     else:
                            lowercase				:	List[Any]			      = val[:dim]
                            lowercase				:	Tuple			      = val[dim : dim * 2]
                            lowercase				:	int			      = val[-dim:]
              else:
                     lowercase				:	Optional[int]			      = val

       return orig_state_dict







def 		_snake_case(    SCREAMING_SNAKE_CASE__							)					->       Dict:
       lowercase				:	Optional[Any]			      = [
           """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(__a   ,      __a							)







@torch.no_grad()
def 		_snake_case(    SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__   ,      SCREAMING_SNAKE_CASE__=False							)					->       Optional[Any]:
       lowercase				:	Dict			      = get_audio_spectrogram_transformer_config(__a							)

       lowercase				:	Optional[Any]			      = {
           """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
       lowercase				:	Tuple			      = model_name_to_url[model_name]
       lowercase				:	Union[str, Any]			      = torch.hub.load_state_dict_from_url(__a   ,      map_location="""cpu"""							)
       # remove some keys
       remove_keys(__a							)
       # rename some keys
       lowercase				:	Any			      = convert_state_dict(__a   ,      __a							)

       # load 🤗 model
       lowercase				:	List[Any]			      = ASTForAudioClassification(__a							)
       model.eval()

       model.load_state_dict(__a							)

       # verify outputs on dummy input
       # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
       lowercase				:	Union[str, Any]			      = -4.2677393 if """speech-commands""" not in model_name else -6.845978
       lowercase				:	Optional[int]			      = 4.5689974 if """speech-commands""" not in model_name else 5.5654526
       lowercase				:	Optional[int]			      = 1_024 if """speech-commands""" not in model_name else 128
       lowercase				:	Any			      = ASTFeatureExtractor(mean=__a   ,      std=__a   ,      max_length=__a							)

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

              lowercase      ,     lowercase				:	Optional[Any]			      = torchaudio.load(__a							)
              lowercase				:	Any			      = waveform.squeeze().numpy()

       lowercase				:	Optional[int]			      = feature_extractor(__a   ,      sampling_rate=16_000   ,      return_tensors="""pt"""							)

       # forward pass
       lowercase				:	Tuple			      = model(**__a							)
       lowercase				:	Tuple			      = outputs.logits

       if model_name == "ast-finetuned-audioset-10-10-0.4593":
              lowercase				:	Any			      = torch.tensor([-0.8760, -7.0042, -8.6602]							)
       elif model_name == "ast-finetuned-audioset-10-10-0.450":
              lowercase				:	List[Any]			      = torch.tensor([-1.1986, -7.0903, -8.2718]							)
       elif model_name == "ast-finetuned-audioset-10-10-0.448":
              lowercase				:	Optional[Any]			      = torch.tensor([-2.6128, -8.0080, -9.4344]							)
       elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
              lowercase				:	Union[str, Any]			      = torch.tensor([-1.5080, -7.4534, -8.8917]							)
       elif model_name == "ast-finetuned-audioset-12-12-0.447":
              lowercase				:	str			      = torch.tensor([-0.5050, -6.5833, -8.0843]							)
       elif model_name == "ast-finetuned-audioset-14-14-0.443":
              lowercase				:	Optional[int]			      = torch.tensor([-0.3826, -7.0336, -8.2413]							)
       elif model_name == "ast-finetuned-audioset-16-16-0.442":
              lowercase				:	Optional[Any]			      = torch.tensor([-1.2113, -6.9101, -8.3470]							)
       elif model_name == "ast-finetuned-speech-commands-v2":
              lowercase				:	List[str]			      = torch.tensor([6.1589, -8.0566, -8.7984]							)
       else:
              raise ValueError("""Unknown model name"""							)
       if not torch.allclose(logits[0, :3]   ,      __a   ,      atol=1e-4							):
              raise ValueError("""Logits don\'t match"""							)
       print("""Looks ok!"""							)

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

       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__":
  lowercase    :   List[str]		       =				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."""
  )

  lowercase    :   Union[str, Any]		       =				parser.parse_args()
  convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




_lowerCAmelCase:						List[str]   				=       'ABCDEFGHIJKLMNOPQRSTUVWXYZ'






def   _lowercase(					):
							a__      =input('Enter message: '     )
							a__      =input('Enter key [alphanumeric]: '     )
							a__      =input('Encrypt/Decrypt [e/d]: '     )

							if mode.lower().startswith('e'     ):
														a__      ='encrypt'
														a__      =encrypt_message(__a    ,     __a     )
							elif mode.lower().startswith('d'     ):
														a__      ='decrypt'
														a__      =decrypt_message(__a    ,     __a     )

							print(f"""\n{mode.title()}ed message:"""     )
							print(__a     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'encrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'decrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str    ,     __a				:						str     ):
							a__      =[]
							a__      =0
							a__      =key.upper()

							for symbol in message:
														a__      =LETTERS.find(symbol.upper()     )
														if num != -1:
																					if mode == "encrypt":
																												num += LETTERS.find(key[key_index]     )
																					elif mode == "decrypt":
																												num -= LETTERS.find(key[key_index]     )

																					num %= len(__a     )

																					if symbol.isupper():
																												translated.append(LETTERS[num]     )
																					elif symbol.islower():
																												translated.append(LETTERS[num].lower()     )

																					key_index += 1
																					if key_index == len(__a     ):
																												a__      =0
														else:
																					translated.append(__a     )
							return "".join(__a     )


if __name__ == "__main__":
	main()

