


"""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


A     :   Dict			    =			{
    "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	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			["layers", "blocks"]
			for k in ignore_keys:
						state_dict.pop(_UpperCamelCase    , _UpperCamelCase      )


A     :   Any			    =			{
    "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	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			list(s_dict.keys()      )
			for key in keys:
						__lowerCAmelCase				    =			key
						for k, v in WHISPER_MAPPING.items():
									if k in key:
												__lowerCAmelCase				    =			new_key.replace(_UpperCamelCase    , _UpperCamelCase      )

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

						__lowerCAmelCase				    =			s_dict.pop(_UpperCamelCase      )
			return s_dict


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase    ,	__lowerCAmelCase				    =			emb.weight.shape
			__lowerCAmelCase				    =			nn.Linear(_UpperCamelCase    , _UpperCamelCase    , bias=_UpperCamelCase      )
			__lowerCAmelCase				    =			emb.weight.data
			return lin_layer


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




			os.makedirs(_UpperCamelCase    , exist_ok=_UpperCamelCase      )
			__lowerCAmelCase				    =			os.path.basename(_UpperCamelCase      )

			__lowerCAmelCase				    =			url.split("/"      )[-2]
			__lowerCAmelCase				    =			os.path.join(_UpperCamelCase    , _UpperCamelCase      )

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

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

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

			__lowerCAmelCase				    =			open(_UpperCamelCase    , "rb"      ).read()
			if hashlib.shaaaa(_UpperCamelCase      ).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	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




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

			__lowerCAmelCase				    =			WhisperConfig(
			    vocab_size=dimensions["n_vocab"]    , encoder_ffn_dim=_UpperCamelCase    , decoder_ffn_dim=_UpperCamelCase    , 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"]    , )

			__lowerCAmelCase				    =			WhisperForConditionalGeneration(_UpperCamelCase      )
			__lowerCAmelCase    ,	__lowerCAmelCase				    =			model.model.load_state_dict(_UpperCamelCase    , strict=_UpperCamelCase      )
			if len(_UpperCamelCase      ) > 0 and not set(_UpperCamelCase      ) <= {
			    "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:
						__lowerCAmelCase				    =			make_linear_from_emb(model.model.decoder.embed_tokens      )
			else:
						__lowerCAmelCase				    =			proj_out_weights

			model.save_pretrained(_UpperCamelCase      )


if __name__ == "__main__":
	A     :   List[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.")
	A     :   Tuple			    =			parser.parse_args()

	convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)








"""simple docstring"""


import warnings
from typing import Dict, List, Optional, Tuple

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


A     :   str			    =			logging.get_logger(__name__)
class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							__UpperCAmelCase						:    str				      =["""input_ids""", """attention_mask"""]

							def __init__(     self    ,   __a="</s>"    ,   __a="<unk>"    ,   __a="<pad>"    ,   __a=1_25    ,   __a=None    ,   **__a    ,   ):
										# Add extra_ids to the special token list
										if extra_ids > 0 and additional_special_tokens is None:
													__lowerCAmelCase				    =			[f"<extra_id_{i}>" for i in range(__a	)]
										elif extra_ids > 0 and additional_special_tokens is not None:
													# Check that we have the right number of extra_id special tokens
													__lowerCAmelCase				    =			len(set(filter(lambda __a	: bool("extra_id" in str(__a	)	)    ,   __a	)	)	)
													if extra_tokens != extra_ids:
																raise ValueError(
																    f"Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"
																    " provided to ByT5Tokenizer. In this case the additional_special_tokens must include the"
																    " extra_ids tokens"	)

										__lowerCAmelCase				    =			AddedToken(__a    ,   lstrip=__a    ,   rstrip=__a	) if isinstance(__a    ,   __a	) else pad_token
										__lowerCAmelCase				    =			AddedToken(__a    ,   lstrip=__a    ,   rstrip=__a	) if isinstance(__a    ,   __a	) else eos_token
										__lowerCAmelCase				    =			AddedToken(__a    ,   lstrip=__a    ,   rstrip=__a	) if isinstance(__a    ,   __a	) else unk_token

										super().__init__(
										    eos_token=__a    ,   unk_token=__a    ,   pad_token=__a    ,   extra_ids=__a    ,   additional_special_tokens=__a    ,   **__a    ,   )

										__lowerCAmelCase				    =			extra_ids

										__lowerCAmelCase				    =			2**8  # utf is 8 bits

										# define special tokens dict
										__lowerCAmelCase				    =			{
										    self.pad_token: 0,
										    self.eos_token: 1,
										    self.unk_token: 2,
										}
										__lowerCAmelCase				    =			len(self.special_tokens_encoder	)
										__lowerCAmelCase				    =			len(__a	)
										for i, token in enumerate(__a	):
													__lowerCAmelCase				    =			self.vocab_size + i - n
										__lowerCAmelCase				    =			{v: k for k, v in self.special_tokens_encoder.items()}

							@property
							def 			snake_case				(     self	):
										return self._utf_vocab_size + self._num_special_tokens + self._extra_ids

							def 			snake_case				(     self    ,   __a    ,   __a = None    ,   __a = False	):
										if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=__a    ,   token_ids_a=__a    ,   already_has_special_tokens=__a	)

										# normal case: some special tokens
										if token_ids_a is None:
													return ([0] * len(__a	)) + [1]
										return ([0] * len(__a	)) + [1] + ([0] * len(__a	)) + [1]

							def 			snake_case				(     self    ,   __a	):
										if len(__a	) > 0 and token_ids[-1] == self.eos_token_id:
													warnings.warn(
													    f"This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated"
													    " eos tokens being added."	)
													return token_ids
										else:
													return token_ids + [self.eos_token_id]

							def 			snake_case				(     self    ,   __a    ,   __a = None	):
										__lowerCAmelCase				    =			[self.eos_token_id]

										if token_ids_a is None:
													return len(token_ids_a + eos	) * [0]
										return len(token_ids_a + eos + token_ids_a + eos	) * [0]

							def 			snake_case				(     self    ,   __a    ,   __a = None	):
										__lowerCAmelCase				    =			self._add_eos_if_not_present(__a	)
										if token_ids_a is None:
													return token_ids_a
										else:
													__lowerCAmelCase				    =			self._add_eos_if_not_present(__a	)
													return token_ids_a + token_ids_a

							def 			snake_case				(     self    ,   __a	):
										__lowerCAmelCase				    =			[chr(__a	) for i in text.encode("utf-8"	)]
										return tokens

							def 			snake_case				(     self    ,   __a	):
										if token in self.special_tokens_encoder:
													__lowerCAmelCase				    =			self.special_tokens_encoder[token]
										elif token in self.added_tokens_encoder:
													__lowerCAmelCase				    =			self.added_tokens_encoder[token]
										elif len(__a	) != 1:
													__lowerCAmelCase				    =			self.unk_token_id
										else:
													__lowerCAmelCase				    =			ord(__a	) + self._num_special_tokens
										return token_id

							def 			snake_case				(     self    ,   __a	):
										if index in self.special_tokens_decoder:
													__lowerCAmelCase				    =			self.special_tokens_decoder[index]
										else:
													__lowerCAmelCase				    =			chr(index - self._num_special_tokens	)
										return token

							def 			snake_case				(     self    ,   __a	):
										__lowerCAmelCase				    =			B""
										for token in tokens:
													if token in self.special_tokens_decoder:
																__lowerCAmelCase				    =			self.special_tokens_decoder[token].encode("utf-8"	)
													elif token in self.added_tokens_decoder:
																__lowerCAmelCase				    =			self.special_tokens_decoder[token].encode("utf-8"	)
													elif token in self.special_tokens_encoder:
																__lowerCAmelCase				    =			token.encode("utf-8"	)
													elif token in self.added_tokens_encoder:
																__lowerCAmelCase				    =			token.encode("utf-8"	)
													else:
																__lowerCAmelCase				    =			bytes([ord(__a	)]	)
													bstring += tok_string
										__lowerCAmelCase				    =			bstring.decode("utf-8"    ,   errors="ignore"	)
										return string



							def 			snake_case				(     self    ,   __a    ,   __a = None	):
										return ()




