





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




def      a__			(       lowercase__	):






   '''simple docstring'''






   UpperCAmelCase_           =ASTConfig()

   if "10-10" in model_name:
      pass
   elif "speech-commands" in model_name:
      UpperCAmelCase_           =1_2_8
   elif "12-12" in model_name:
      UpperCAmelCase_           =1_2
      UpperCAmelCase_           =1_2
   elif "14-14" in model_name:
      UpperCAmelCase_           =1_4
      UpperCAmelCase_           =1_4
   elif "16-16" in model_name:
      UpperCAmelCase_           =1_6
      UpperCAmelCase_           =1_6
   else:
      raise ValueError("Model not supported"	)

   UpperCAmelCase_           ="huggingface/label-files"
   if "speech-commands" in model_name:
      UpperCAmelCase_           =3_5
      UpperCAmelCase_           ="speech-commands-v2-id2label.json"
   else:
      UpperCAmelCase_           =5_2_7
      UpperCAmelCase_           ="audioset-id2label.json"

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

   return config




def      a__			(       lowercase__	):






   '''simple docstring'''






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

   return name




def      a__			(       lowercase__	,     lowercase__	):






   '''simple docstring'''






   for key in orig_state_dict.copy().keys():
      UpperCAmelCase_           =orig_state_dict.pop(lowercase__	)

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

   return orig_state_dict




def      a__			(       lowercase__	):






   '''simple docstring'''






   UpperCAmelCase_           =[
       "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      a__			(       lowercase__	,     lowercase__	,     lowercase__=False	):






   '''simple docstring'''






   UpperCAmelCase_           =get_audio_spectrogram_transformer_config(lowercase__	)

   UpperCAmelCase_           ={
       "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
   UpperCAmelCase_           =model_name_to_url[model_name]
   UpperCAmelCase_           =torch.hub.load_state_dict_from_url(lowercase__	,     map_location="cpu"	)
   # remove some keys
   remove_keys(lowercase__	)
   # rename some keys
   UpperCAmelCase_           =convert_state_dict(lowercase__	,     lowercase__	)

   # load 🤗 model
   UpperCAmelCase_           =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
   UpperCAmelCase_           =-4.267_7393 if "speech-commands" not in model_name else -6.84_5978
   UpperCAmelCase_           =4.568_9974 if "speech-commands" not in model_name else 5.565_4526
   UpperCAmelCase_           =1_0_2_4 if "speech-commands" not in model_name else 1_2_8
   UpperCAmelCase_           =ASTFeatureExtractor(mean=lowercase__	,     std=lowercase__	,     max_length=lowercase__	)

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

      UpperCAmelCase_    ,							UpperCAmelCase_           =torchaudio.load(lowercase__	)
      UpperCAmelCase_           =waveform.squeeze().numpy()

   UpperCAmelCase_           =feature_extractor(lowercase__	,     sampling_rate=1_6_0_0_0	,     return_tensors="pt"	)

   # forward pass
   UpperCAmelCase_           =model(**lowercase__	)
   UpperCAmelCase_           =outputs.logits

   if model_name == "ast-finetuned-audioset-10-10-0.4593":
      UpperCAmelCase_           =torch.tensor([-0.8760, -7.0042, -8.6602]	)
   elif model_name == "ast-finetuned-audioset-10-10-0.450":
      UpperCAmelCase_           =torch.tensor([-1.1986, -7.0903, -8.2718]	)
   elif model_name == "ast-finetuned-audioset-10-10-0.448":
      UpperCAmelCase_           =torch.tensor([-2.6128, -8.0080, -9.4344]	)
   elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
      UpperCAmelCase_           =torch.tensor([-1.5080, -7.4534, -8.8917]	)
   elif model_name == "ast-finetuned-audioset-12-12-0.447":
      UpperCAmelCase_           =torch.tensor([-0.5050, -6.5833, -8.0843]	)
   elif model_name == "ast-finetuned-audioset-14-14-0.443":
      UpperCAmelCase_           =torch.tensor([-0.3826, -7.0336, -8.2413]	)
   elif model_name == "ast-finetuned-audioset-16-16-0.442":
      UpperCAmelCase_           =torch.tensor([-1.2113, -6.9101, -8.3470]	)
   elif model_name == "ast-finetuned-speech-commands-v2":
      UpperCAmelCase_           =torch.tensor([6.1589, -8.0566, -8.7984]	)
   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__":
     __lowercase	: Optional[int]       =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	: Optional[int]       =parser.parse_args()
     convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











import argparse
import struct
import unittest


class        __magic_name__	:





     """simple docstring"""



     def __init__(				self							:str      ,   snake_case							:bytes	):





        '''simple docstring'''




        A_       :					Dict        =      data

        # Initialize hash values
        A_       :					Union[str, Any]        =      [
            0x6a_09_e6_67,
            0xbb_67_ae_85,
            0x3c_6e_f3_72,
            0xa5_4f_f5_3a,
            0x51_0e_52_7f,
            0x9b_05_68_8c,
            0x1f_83_d9_ab,
            0x5b_e0_cd_19,
        ]

        # Initialize round constants
        A_       :					List[Any]        =      [
            0x42_8a_2f_98,
            0x71_37_44_91,
            0xb5_c0_fb_cf,
            0xe9_b5_db_a5,
            0x39_56_c2_5b,
            0x59_f1_11_f1,
            0x92_3f_82_a4,
            0xab_1c_5e_d5,
            0xd8_07_aa_98,
            0x12_83_5b_01,
            0x24_31_85_be,
            0x55_0c_7d_c3,
            0x72_be_5d_74,
            0x80_de_b1_fe,
            0x9b_dc_06_a7,
            0xc1_9b_f1_74,
            0xe4_9b_69_c1,
            0xef_be_47_86,
            0x0f_c1_9d_c6,
            0x24_0c_a1_cc,
            0x2d_e9_2c_6f,
            0x4a_74_84_aa,
            0x5c_b0_a9_dc,
            0x76_f9_88_da,
            0x98_3e_51_52,
            0xa8_31_c6_6d,
            0xb0_03_27_c8,
            0xbf_59_7f_c7,
            0xc6_e0_0b_f3,
            0xd5_a7_91_47,
            0x06_ca_63_51,
            0x14_29_29_67,
            0x27_b7_0a_85,
            0x2e_1b_21_38,
            0x4d_2c_6d_fc,
            0x53_38_0d_13,
            0x65_0a_73_54,
            0x76_6a_0a_bb,
            0x81_c2_c9_2e,
            0x92_72_2c_85,
            0xa2_bf_e8_a1,
            0xa8_1a_66_4b,
            0xc2_4b_8b_70,
            0xc7_6c_51_a3,
            0xd1_92_e8_19,
            0xd6_99_06_24,
            0xf4_0e_35_85,
            0x10_6a_a0_70,
            0x19_a4_c1_16,
            0x1e_37_6c_08,
            0x27_48_77_4c,
            0x34_b0_bc_b5,
            0x39_1c_0c_b3,
            0x4e_d8_aa_4a,
            0x5b_9c_ca_4f,
            0x68_2e_6f_f3,
            0x74_8f_82_ee,
            0x78_a5_63_6f,
            0x84_c8_78_14,
            0x8c_c7_02_08,
            0x90_be_ff_fa,
            0xa4_50_6c_eb,
            0xbe_f9_a3_f7,
            0xc6_71_78_f2,
        ]

        A_       :					Any        =      self.preprocessing(self.data	)
        self.final_hash()



     @staticmethod
     def     SCREAMING_SNAKE_CASE		(				snake_case							:bytes	):





        '''simple docstring'''




        A_       :					List[Any]        =      B"\x80" + (B"\x00" * (63 - (len(snake_case	) + 8) % 64))
        A_       :					str        =      struct.pack(">Q"      ,   (len(snake_case	) * 8)	)
        return data + padding + big_endian_integer



     def     SCREAMING_SNAKE_CASE		(				self							:Any	):





        '''simple docstring'''




        A_       :					Tuple        =      [
            self.preprocessed_data[x : x + 64]
            for x in range(0      ,   len(self.preprocessed_data	)      ,   64	)
        ]

        for block in self.blocks:
           # Convert the given block into a list of 4 byte integers
           A_       :					Dict        =      list(struct.unpack(">16L"      ,   snake_case	)	)
           # add 48 0-ed integers
           words += [0] * 48

           A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_       :					int        =      self.hashes

           for index in range(0      ,   64	):
              if index > 15:
                 # modify the zero-ed indexes at the end of the array
                 A_       :					int        =      (
                     self.ror(words[index - 15]      ,   7	)
                     ^ self.ror(words[index - 15]      ,   18	)
                     ^ (words[index - 15] >> 3)
                 )
                 A_       :					Any        =      (
                     self.ror(words[index - 2]      ,   17	)
                     ^ self.ror(words[index - 2]      ,   19	)
                     ^ (words[index - 2] >> 10)
                 )

                 A_       :					Optional[int]        =      (
                     words[index - 16] + sa + words[index - 7] + sa
                 ) % 0x1_00_00_00_00

              # Compression
              A_       :					Dict        =      self.ror(snake_case      ,   6	) ^ self.ror(snake_case      ,   11	) ^ self.ror(snake_case      ,   25	)
              A_       :					int        =      (e & f) ^ ((~e & 0xff_ff_ff_ff) & g)
              A_       :					Optional[Any]        =      (
                  h + sa + ch + self.round_constants[index] + words[index]
              ) % 0x1_00_00_00_00
              A_       :					List[str]        =      self.ror(snake_case      ,   2	) ^ self.ror(snake_case      ,   13	) ^ self.ror(snake_case      ,   22	)
              A_       :					List[Any]        =      (a & b) ^ (a & c) ^ (b & c)
              A_       :					Dict        =      (sa + maj) % 0x1_00_00_00_00

              A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_   ,    A_       :					Optional[int]        =      (
                  g,
                  f,
                  e,
                  ((d + tempa) % 0x1_00_00_00_00),
                  c,
                  b,
                  a,
                  ((tempa + tempa) % 0x1_00_00_00_00),
              )

           A_       :					List[str]        =      [a, b, c, d, e, f, g, h]

           # Modify final values
           A_       :					List[str]        =      [
               ((element + mutated_hash_values[index]) % 0x1_00_00_00_00)
               for index, element in enumerate(self.hashes	)
           ]

        A_       :					Optional[int]        =      "".join([hex(snake_case	)[2:].zfill(8	) for value in self.hashes]	)





     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]      ,   snake_case							:int      ,   snake_case							:int	):





        '''simple docstring'''




        return 0xff_ff_ff_ff & (value << (32 - rotations)) | (value >> rotations)




class        __magic_name__	(				unittest.TestCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]	):





        '''simple docstring'''




        import hashlib

        A_       :					int        =      bytes("Test String"      ,   "utf-8"	)
        self.assertEqual(SHAaaa(snake_case	).hash      ,   hashlib.shaaaa(snake_case	).hexdigest()	)




def   __snake_case    (       )			->    None:
   import doctest

   doctest.testmod()

   A_       :					Optional[Any]        =      argparse.ArgumentParser()
   parser.add_argument(
       "-s"					,					"--string"					,					dest="input_string"					,					default="Hello World!! Welcome to Cryptography"					,					help="Hash the string"					,					)
   parser.add_argument(
       "-f"					,					"--file"					,					dest="input_file"					,					help="Hash contents of a file"						)

   A_       :					List[Any]        =      parser.parse_args()

   A_       :					List[Any]        =      args.input_string

   # hash input should be a bytestring
   if args.input_file:
      with open(args.input_file					,					"rb"						) as f:
         A_       :					Optional[Any]        =      f.read()
   else:
      A_       :					Any        =      bytes(_lowerCAmelCase					,					"utf-8"						)

   print(SHAaaa(_lowerCAmelCase						).hash						)


if __name__ == "__main__":
 main()
