



"""simple docstring"""


import argparse
import hashlib
import os
import urllib
import warnings

import torch
from torch import nn
from tqdm import tqdm

from transformers import WhisperConfig, WhisperForConditionalGeneration


snake_case_    					=	{
    """tiny.en""": """https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt""",
    """tiny""": """https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt""",
    """base.en""": """https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt""",
    """base""": """https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt""",
    """small.en""": """https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt""",
    """small""": """https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt""",
    """medium.en""": """https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt""",
    """medium""": """https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt""",
    """large""": """https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt""",
    """large-v2""": """https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt""",
}

def 			_lowerCAmelCase				(       lowercase_						):
						UpperCAmelCase					=			['layers', 'blocks']
						for k in ignore_keys:
												state_dict.pop(lowercase_		,     lowercase_						)


snake_case_    					=	{
    """blocks""": """layers""",
    """mlp.0""": """fc1""",
    """mlp.2""": """fc2""",
    """mlp_ln""": """final_layer_norm""",
    """.attn.query""": """.self_attn.q_proj""",
    """.attn.key""": """.self_attn.k_proj""",
    """.attn.value""": """.self_attn.v_proj""",
    """.attn_ln""": """.self_attn_layer_norm""",
    """.attn.out""": """.self_attn.out_proj""",
    """.cross_attn.query""": """.encoder_attn.q_proj""",
    """.cross_attn.key""": """.encoder_attn.k_proj""",
    """.cross_attn.value""": """.encoder_attn.v_proj""",
    """.cross_attn_ln""": """.encoder_attn_layer_norm""",
    """.cross_attn.out""": """.encoder_attn.out_proj""",
    """decoder.ln.""": """decoder.layer_norm.""",
    """encoder.ln.""": """encoder.layer_norm.""",
    """token_embedding""": """embed_tokens""",
    """encoder.positional_embedding""": """encoder.embed_positions.weight""",
    """decoder.positional_embedding""": """decoder.embed_positions.weight""",
    """ln_post""": """layer_norm""",
}

def 			_lowerCAmelCase				(       lowercase_						):
						UpperCAmelCase					=			list(s_dict.keys()						)
						for key in keys:
												UpperCAmelCase					=			key
												for k, v in WHISPER_MAPPING.items():
																		if k in key:
																								UpperCAmelCase					=			new_key.replace(lowercase_		,     lowercase_						)

												print(F"""{key} -> {new_key}"""						)

												UpperCAmelCase					=			s_dict.pop(lowercase_						)
						return s_dict

def 			_lowerCAmelCase				(       lowercase_						):
						UpperCAmelCase				,   UpperCAmelCase					=			emb.weight.shape
						UpperCAmelCase					=			nn.Linear(lowercase_		,     lowercase_		,     bias=lowercase_						)
						UpperCAmelCase					=			emb.weight.data
						return lin_layer

def 			_lowerCAmelCase				(       lowercase_		,     lowercase_						):
						os.makedirs(lowercase_		,     exist_ok=lowercase_						)
						UpperCAmelCase					=			os.path.basename(lowercase_						)

						UpperCAmelCase					=			url.split('/'						)[-2]
						UpperCAmelCase					=			os.path.join(lowercase_		,     lowercase_						)

						if os.path.exists(lowercase_						) and not os.path.isfile(lowercase_						):
												raise RuntimeError(F"""{download_target} exists and is not a regular file"""						)

						if os.path.isfile(lowercase_						):
												UpperCAmelCase					=			open(lowercase_		,     'rb'						).read()
												if hashlib.shaaaa(lowercase_						).hexdigest() == expected_shaaaa:
																		return model_bytes
												else:
																		warnings.warn(F"""{download_target} exists, but the SHA256 checksum does not match; re-downloading the file"""						)

						with urllib.request.urlopen(lowercase_						) as source, open(lowercase_		,     'wb'						) as output:
												with tqdm(
												    total=int(source.info().get('Content-Length'						)						)		,     ncols=80		,     unit='iB'		,     unit_scale=lowercase_		,     unit_divisor=1024						) as loop:
																		while True:
																								UpperCAmelCase					=			source.read(8192						)
																								if not buffer:
																														break

																								output.write(lowercase_						)
																								loop.update(len(lowercase_						)						)

						UpperCAmelCase					=			open(lowercase_		,     'rb'						).read()
						if hashlib.shaaaa(lowercase_						).hexdigest() != expected_shaaaa:
												raise RuntimeError(
												    'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.'						)

						return model_bytes

def 			_lowerCAmelCase				(       lowercase_		,     lowercase_						):
						if ".pt" not in checkpoint_path:
												UpperCAmelCase					=			_download(_MODELS[checkpoint_path]						)
						else:
												UpperCAmelCase					=			torch.load(lowercase_		,     map_location='cpu'						)
						UpperCAmelCase					=			original_checkpoint['dims']
						UpperCAmelCase					=			original_checkpoint['model_state_dict']
						UpperCAmelCase					=			state_dict['decoder.token_embedding.weight']
						remove_ignore_keys_(lowercase_						)
						rename_keys(lowercase_						)
						UpperCAmelCase					=			True
						UpperCAmelCase					=			state_dict['decoder.layers.0.fc1.weight'].shape[0]

						UpperCAmelCase					=			WhisperConfig(
						    vocab_size=dimensions['n_vocab']		,     encoder_ffn_dim=lowercase_		,     decoder_ffn_dim=lowercase_		,     num_mel_bins=dimensions['n_mels']		,     d_model=dimensions['n_audio_state']		,     max_target_positions=dimensions['n_text_ctx']		,     encoder_layers=dimensions['n_audio_layer']		,     encoder_attention_heads=dimensions['n_audio_head']		,     decoder_layers=dimensions['n_text_layer']		,     decoder_attention_heads=dimensions['n_text_state']		,     max_source_positions=dimensions['n_audio_ctx']		,     )

						UpperCAmelCase					=			WhisperForConditionalGeneration(lowercase_						)
						UpperCAmelCase				,   UpperCAmelCase					=			model.model.load_state_dict(lowercase_		,     strict=lowercase_						)
						if len(lowercase_						) > 0 and not set(lowercase_						) <= {
						    "encoder.embed_positions.weights",
						    "decoder.embed_positions.weights",
						}:
												raise ValueError(
												    'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,'
												    F""" but all the following weights are missing {missing}"""						)

						if tie_embeds:
												UpperCAmelCase					=			make_linear_from_emb(model.model.decoder.embed_tokens						)
						else:
												UpperCAmelCase					=			proj_out_weights

						model.save_pretrained(lowercase_						)


if __name__ == "__main__":
				snake_case_    					=	argparse.ArgumentParser()
				# # Required parameters
				parser.add_argument("""--checkpoint_path""", type=str, help="""Patht to the downloaded checkpoints""")
				parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
				snake_case_    					=	parser.parse_args()

				convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)









"""simple docstring"""


from math import factorial, radians

def 			_lowerCAmelCase				(       lowercase_		,     lowercase_ = 18		,     lowercase_ = 10						):
						UpperCAmelCase					=			angle_in_degrees - ((angle_in_degrees // 3_6_0.0) * 3_6_0.0)

						# Converting from degrees to radians
						UpperCAmelCase					=			radians(lowercase_						)

						UpperCAmelCase					=			angle_in_radians
						UpperCAmelCase					=			3
						UpperCAmelCase					=			-1

						for _ in range(lowercase_						):
												result += (b * (angle_in_radians**a)) / factorial(lowercase_						)

												UpperCAmelCase					=			-b  # One positive term and the next will be negative and so on...
												a += 2  # Increased by 2 for every term.

						return round(lowercase_		,     lowercase_						)


if __name__ == "__main__":
				__import__("""doctest""").testmod()





