





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


UpperCAmelCase_							=				{
    """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  __magic_name__  (				lowercase				)				-> Dict:

							"""simple docstring"""



							lowercase_	:   Dict  				=     ["""layers""", """blocks"""]
							for k in ignore_keys:
														state_dict.pop(lowercase				,       lowercase				)


UpperCAmelCase_							=				{
    """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  __magic_name__  (				lowercase				)				-> Any:

							"""simple docstring"""



							lowercase_	:   Any  				=     list(s_dict.keys()				)
							for key in keys:
														lowercase_	:   Union[str, Any]  				=     key
														for k, v in WHISPER_MAPPING.items():
																					if k in key:
																												lowercase_	:   List[Any]  				=     new_key.replace(lowercase				,       lowercase				)

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

														lowercase_	:   List[str]  				=     s_dict.pop(lowercase				)
							return s_dict





def  __magic_name__  (				lowercase				)				-> str:

							"""simple docstring"""



							lowercase_				,		lowercase_	:   Optional[int]  				=     emb.weight.shape
							lowercase_	:   Union[str, Any]  				=     nn.Linear(lowercase				,       lowercase				,       bias=lowercase				)
							lowercase_	:   Dict  				=     emb.weight.data
							return lin_layer





def  __magic_name__  (				lowercase				,       lowercase				)				-> bytes:

							"""simple docstring"""



							os.makedirs(lowercase				,       exist_ok=lowercase				)
							lowercase_	:   Union[str, Any]  				=     os.path.basename(lowercase				)

							lowercase_	:   str  				=     url.split("""/"""				)[-2]
							lowercase_	:   int  				=     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				):
														lowercase_	:   Optional[Any]  				=     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:
																												lowercase_	:   Tuple  				=     source.read(8192				)
																												if not buffer:
																																			break

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

							lowercase_	:   Any  				=     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  __magic_name__  (				lowercase				,       lowercase				)				-> str:

							"""simple docstring"""



							if ".pt" not in checkpoint_path:
														lowercase_	:   int  				=     _download(_MODELS[checkpoint_path]				)
							else:
														lowercase_	:   Optional[int]  				=     torch.load(lowercase				,       map_location="""cpu"""				)
							lowercase_	:   Union[str, Any]  				=     original_checkpoint["""dims"""]
							lowercase_	:   str  				=     original_checkpoint["""model_state_dict"""]
							lowercase_	:   Optional[Any]  				=     state_dict["""decoder.token_embedding.weight"""]
							remove_ignore_keys_(lowercase				)
							rename_keys(lowercase				)
							lowercase_	:   Any  				=     True
							lowercase_	:   Any  				=     state_dict["""decoder.layers.0.fc1.weight"""].shape[0]

							lowercase_	:   Dict  				=     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"""]				,       )

							lowercase_	:   Optional[Any]  				=     WhisperForConditionalGeneration(lowercase				)
							lowercase_				,		lowercase_	:   Optional[Any]  				=     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:
														lowercase_	:   str  				=     make_linear_from_emb(model.model.decoder.embed_tokens				)
							else:
														lowercase_	:   Union[str, Any]  				=     proj_out_weights

							model.save_pretrained(lowercase				)


if __name__ == "__main__":
							UpperCAmelCase_							=				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.""")
							UpperCAmelCase_							=				parser.parse_args()

							convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)






from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray





def  __magic_name__  (				lowercase				,       lowercase				,       lowercase				,       lowercase				,       )				-> list[float]:

							"""simple docstring"""



							lowercase_				,		lowercase_	:   List[str]  				=     coefficient_matrix.shape
							lowercase_				,		lowercase_	:   Any  				=     constant_matrix.shape

							if rowsa != colsa:
														lowercase_	:   List[Any]  				=     f"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
														raise ValueError(lowercase				)

							if colsa != 1:
														lowercase_	:   Optional[int]  				=     f"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
														raise ValueError(lowercase				)

							if rowsa != rowsa:
														lowercase_	:   Tuple  				=     (
														    """Coefficient and constant matrices dimensions must be nxn and nx1 but """
														    f"""received {rowsa}x{colsa} and {rowsa}x{colsa}"""
														)
														raise ValueError(lowercase				)

							if len(lowercase				) != rowsa:
														lowercase_	:   int  				=     (
														    """Number of initial values must be equal to number of rows in coefficient """
														    f"""matrix but received {len(lowercase				)} and {rowsa}"""
														)
														raise ValueError(lowercase				)

							if iterations <= 0:
														raise ValueError("""Iterations must be at least 1"""				)

							lowercase_	:   NDArray[floataa]  				=     np.concatenate(
							    (coefficient_matrix, constant_matrix)				,       axis=1				)

							lowercase_				,		lowercase_	:   Dict  				=     table.shape

							strictly_diagonally_dominant(lowercase				)

							# Iterates the whole matrix for given number of times
							for _ in range(lowercase				):
														lowercase_	:   str  				=     []
														for row in range(lowercase				):
																					lowercase_	:   Dict  				=     0
																					for col in range(lowercase				):
																												if col == row:
																																			lowercase_	:   Optional[Any]  				=     table[row][col]
																												elif col == cols - 1:
																																			lowercase_	:   Tuple  				=     table[row][col]
																												else:
																																			temp += (-1) * table[row][col] * init_val[col]
																					lowercase_	:   List[Any]  				=     (temp + val) / denom
																					new_val.append(lowercase				)
														lowercase_	:   Optional[int]  				=     new_val

							return [float(lowercase				) for i in new_val]





def  __magic_name__  (				lowercase				)				-> bool:

							"""simple docstring"""



							lowercase_				,		lowercase_	:   str  				=     table.shape

							lowercase_	:   str  				=     True

							for i in range(0				,       lowercase				):
														lowercase_	:   Any  				=     0
														for j in range(0				,       cols - 1				):
																					if i == j:
																												continue
																					else:
																												total += table[i][j]

														if table[i][i] <= total:
																					raise ValueError("""Coefficient matrix is not strictly diagonally dominant"""				)

							return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
							import doctest

							doctest.testmod()