
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


lowercase__							:							str									=			{
    "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 	A_ (							snake_case							:   Dict )      ->    Any:



						'''simple docstring'''

						__UpperCamelCase       =			['''layers''', '''blocks''']
						for k in ignore_keys:
												state_dict.pop(snake_case ,      snake_case )


lowercase__							:							Tuple									=			{
    "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 	A_ (							snake_case							:   Union[str, Any] )      ->    List[Any]:



						'''simple docstring'''

						__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(snake_case ,      snake_case )

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

												__UpperCamelCase       =			s_dict.pop(snake_case )
						return s_dict




def 	A_ (							snake_case							:   str )      ->    List[str]:



						'''simple docstring'''

						__UpperCamelCase  ,							__UpperCamelCase       =			emb.weight.shape
						__UpperCamelCase       =			nn.Linear(snake_case ,      snake_case ,      bias=snake_case )
						__UpperCamelCase       =			emb.weight.data
						return lin_layer




def 	A_ (							snake_case							:   str ,      snake_case							:   str )      ->    bytes:



						'''simple docstring'''

						os.makedirs(snake_case ,      exist_ok=snake_case )
						__UpperCamelCase       =			os.path.basename(snake_case )

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

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

						if os.path.isfile(snake_case ):
												__UpperCamelCase       =			open(snake_case ,      '''rb''' ).read()
												if hashlib.shaaaa(snake_case ).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(snake_case ) as source, open(snake_case ,      '''wb''' ) as output:
												with tqdm(
												    total=int(source.info().get('''Content-Length''' ) ) ,      ncols=80 ,      unit='''iB''' ,      unit_scale=snake_case ,      unit_divisor=1024 ) as loop:
																		while True:
																								__UpperCamelCase       =			source.read(8192 )
																								if not buffer:
																														break

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

						__UpperCamelCase       =			open(snake_case ,      '''rb''' ).read()
						if hashlib.shaaaa(snake_case ).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 	A_ (							snake_case							:   Tuple ,      snake_case							:   int )      ->    Optional[int]:



						'''simple docstring'''

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

						__UpperCamelCase       =			WhisperConfig(
						    vocab_size=dimensions['''n_vocab'''] ,      encoder_ffn_dim=snake_case ,      decoder_ffn_dim=snake_case ,      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(snake_case )
						__UpperCamelCase  ,							__UpperCamelCase       =			model.model.load_state_dict(snake_case ,      strict=snake_case )
						if len(snake_case ) > 0 and not set(snake_case ) <= {
						    "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(snake_case )


if __name__ == "__main__":
			lowercase__							:							Optional[Any]									=			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.")
			lowercase__							:							Any									=			parser.parse_args()

			convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)






# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


lowercase__							:							List[str]									=			"3"

print("Python version:", sys.version)

print("OS platform:", platform.platform())
print("OS architecture:", platform.machine())

try:
				import torch

				print("Torch version:", torch.__version__)
				print("Cuda available:", torch.cuda.is_available())
				print("Cuda version:", torch.version.cuda)
				print("CuDNN version:", torch.backends.cudnn.version())
				print("Number of GPUs available:", torch.cuda.device_count())
except ImportError:
				print("Torch version:", None)

try:
				import transformers

				print("transformers version:", transformers.__version__)
except ImportError:
				print("transformers version:", None)




