

'''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()
SCREAMING_SNAKE_CASE							:				Tuple     	=			logging.get_logger(__name__)




def 							_UpperCamelCase				(   lowerCAmelCase__:					Dict   )      -> Optional[Any]:
							SCREAMING_SNAKE_CASE_				=				ASTConfig()

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

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

							SCREAMING_SNAKE_CASE_				=				json.load(open(hf_hub_download(lowerCAmelCase__		,lowerCAmelCase__		,repo_type='dataset'   )		,'r'   )   )
							SCREAMING_SNAKE_CASE_				=				{int(lowerCAmelCase__   ): v for k, v in idalabel.items()}
							SCREAMING_SNAKE_CASE_				=				idalabel
							SCREAMING_SNAKE_CASE_				=				{v: k for k, v in idalabel.items()}

							return config




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

							return name




def 							_UpperCamelCase				(   lowerCAmelCase__:					Optional[Any]		,lowerCAmelCase__:					Tuple   )      -> List[str]:
							for key in orig_state_dict.copy().keys():
														SCREAMING_SNAKE_CASE_				=				orig_state_dict.pop(lowerCAmelCase__   )

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

							return orig_state_dict




def 							_UpperCamelCase				(   lowerCAmelCase__:					Union[str, Any]   )      -> int:
							SCREAMING_SNAKE_CASE_				=				[
							    '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(lowerCAmelCase__		,lowerCAmelCase__   )




@torch.no_grad()
def 							_UpperCamelCase				(   lowerCAmelCase__:					Tuple		,lowerCAmelCase__:					Tuple		,lowerCAmelCase__:					int=False   )      -> str:
							SCREAMING_SNAKE_CASE_				=				get_audio_spectrogram_transformer_config(lowerCAmelCase__   )

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

							# load 🤗 model
							SCREAMING_SNAKE_CASE_				=				ASTForAudioClassification(lowerCAmelCase__   )
							model.eval()

							model.load_state_dict(lowerCAmelCase__   )

							# verify outputs on dummy input
							# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
							SCREAMING_SNAKE_CASE_				=				-4.2_677_393 if 'speech-commands' not in model_name else -6.845_978
							SCREAMING_SNAKE_CASE_				=				4.5_689_974 if 'speech-commands' not in model_name else 5.5_654_526
							SCREAMING_SNAKE_CASE_				=				1024 if 'speech-commands' not in model_name else 128
							SCREAMING_SNAKE_CASE_				=				ASTFeatureExtractor(mean=lowerCAmelCase__		,std=lowerCAmelCase__		,max_length=lowerCAmelCase__   )

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

														SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				=				torchaudio.load(lowerCAmelCase__   )
														SCREAMING_SNAKE_CASE_				=				waveform.squeeze().numpy()

							SCREAMING_SNAKE_CASE_				=				feature_extractor(lowerCAmelCase__		,sampling_rate=1_6000		,return_tensors='pt'   )

							# forward pass
							SCREAMING_SNAKE_CASE_				=				model(**lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				outputs.logits

							if model_name == "ast-finetuned-audioset-10-10-0.4593":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-0.8_760, -7.0_042, -8.6_602]   )
							elif model_name == "ast-finetuned-audioset-10-10-0.450":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-1.1_986, -7.0_903, -8.2_718]   )
							elif model_name == "ast-finetuned-audioset-10-10-0.448":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-2.6_128, -8.0_080, -9.4_344]   )
							elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-1.5_080, -7.4_534, -8.8_917]   )
							elif model_name == "ast-finetuned-audioset-12-12-0.447":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-0.5_050, -6.5_833, -8.0_843]   )
							elif model_name == "ast-finetuned-audioset-14-14-0.443":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-0.3_826, -7.0_336, -8.2_413]   )
							elif model_name == "ast-finetuned-audioset-16-16-0.442":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([-1.2_113, -6.9_101, -8.3_470]   )
							elif model_name == "ast-finetuned-speech-commands-v2":
														SCREAMING_SNAKE_CASE_				=				torch.tensor([6.1_589, -8.0_566, -8.7_984]   )
							else:
														raise ValueError('Unknown model name'   )
							if not torch.allclose(logits[0, :3]		,lowerCAmelCase__		,atol=1E-4   ):
														raise ValueError('Logits don\'t match'   )
							print('Looks ok!'   )

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

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

							SCREAMING_SNAKE_CASE							:				int     	=			parser.parse_args()
							convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








'''simple docstring'''

import argparse
import hashlib  # hashlib is only used inside the Test class
import struct






class    snake_case     :






				"""simple docstring"""



				def __init__(    self,     _lowercase       )     ->							Optional[Any]:
											SCREAMING_SNAKE_CASE_				=				data
											SCREAMING_SNAKE_CASE_				=				[0x6_7_4_5_2_3_0_1, 0xe_f_c_d_a_b_8_9, 0x9_8_b_a_d_c_f_e, 0x1_0_3_2_5_4_7_6, 0xc_3_d_2_e_1_f_0]



				@staticmethod
				def   a__					(    _lowercase,     _lowercase       )     ->							List[str]:
											return ((n << b) | (n >> (32 - b))) & 0xf_f_f_f_f_f_f_f



				def   a__					(    self       )     ->							List[str]:
											SCREAMING_SNAKE_CASE_				=				B'\x80' + B'\x00' * (63 - (len(self.data       ) + 8) % 64)
											SCREAMING_SNAKE_CASE_				=				self.data + padding + struct.pack('>Q',     8 * len(self.data       )       )
											return padded_data



				def   a__					(    self       )     ->							Optional[Any]:
											return [
											    self.padded_data[i : i + 64] for i in range(0,     len(self.padded_data       ),     64       )
											]



				def   a__					(    self,     _lowercase       )     ->							int:
											SCREAMING_SNAKE_CASE_				=				list(struct.unpack('>16L',     _lowercase       )       ) + [0] * 64
											for i in range(16,     80       ):
																		SCREAMING_SNAKE_CASE_				=				self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]),     1       )
											return w





				def   a__					(    self       )     ->							List[str]:
											SCREAMING_SNAKE_CASE_				=				self.padding()
											SCREAMING_SNAKE_CASE_				=				self.split_blocks()
											for block in self.blocks:
																		SCREAMING_SNAKE_CASE_				=				self.expand_block(_lowercase       )
																		SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				=				self.h
																		for i in range(0,     80       ):
																									if 0 <= i < 20:
																																SCREAMING_SNAKE_CASE_				=				(b & c) | ((~b) & d)
																																SCREAMING_SNAKE_CASE_				=				0x5_a_8_2_7_9_9_9
																									elif 20 <= i < 40:
																																SCREAMING_SNAKE_CASE_				=				b ^ c ^ d
																																SCREAMING_SNAKE_CASE_				=				0x6_e_d_9_e_b_a_1
																									elif 40 <= i < 60:
																																SCREAMING_SNAKE_CASE_				=				(b & c) | (b & d) | (c & d)
																																SCREAMING_SNAKE_CASE_				=				0x8_f_1_b_b_c_d_c
																									elif 60 <= i < 80:
																																SCREAMING_SNAKE_CASE_				=				b ^ c ^ d
																																SCREAMING_SNAKE_CASE_				=				0xc_a_6_2_c_1_d_6
																									SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				=				(
																									    self.rotate(_lowercase,     5       ) + f + e + k + expanded_block[i] & 0xf_f_f_f_f_f_f_f,
																									    a,
																									    self.rotate(_lowercase,     30       ),
																									    c,
																									    d,
																									)
																		SCREAMING_SNAKE_CASE_				=				(
																		    self.h[0] + a & 0xf_f_f_f_f_f_f_f,
																		    self.h[1] + b & 0xf_f_f_f_f_f_f_f,
																		    self.h[2] + c & 0xf_f_f_f_f_f_f_f,
																		    self.h[3] + d & 0xf_f_f_f_f_f_f_f,
																		    self.h[4] + e & 0xf_f_f_f_f_f_f_f,
																		)
											return ("{:08x}" * 5).format(*self.h       )




def 							_UpperCamelCase				(   )      -> Optional[int]:
							SCREAMING_SNAKE_CASE_				=				B'Test String'
							assert SHAaHash(lowerCAmelCase__   ).final_hash() == hashlib.shaa(lowerCAmelCase__   ).hexdigest()  # noqa: S324




def 							_UpperCamelCase				(   )      -> Any:
							SCREAMING_SNAKE_CASE_				=				argparse.ArgumentParser(description='Process some strings or files'   )
							parser.add_argument(
							    '--string'		,dest='input_string'		,default='Hello World!! Welcome to Cryptography'		,help='Hash the string'		,)
							parser.add_argument('--file'		,dest='input_file'		,help='Hash contents of a file'   )
							SCREAMING_SNAKE_CASE_				=				parser.parse_args()
							SCREAMING_SNAKE_CASE_				=				args.input_string
							# In any case hash input should be a bytestring
							if args.input_file:
														with open(args.input_file		,'rb'   ) as f:
																					SCREAMING_SNAKE_CASE_				=				f.read()
							else:
														SCREAMING_SNAKE_CASE_				=				bytes(lowerCAmelCase__		,'utf-8'   )
							print(SHAaHash(lowerCAmelCase__   ).final_hash()   )


if __name__ == "__main__":
							main()
							import doctest

							doctest.testmod()





