






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


_lowerCAmelCase       =				{
    "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       __UpperCamelCase						(		snake_case__       ):
	A_		:    Dict						     = ["""layers""", """blocks"""]
	for k in ignore_keys:
		state_dict.pop(snake_case__ , snake_case__       )


_lowerCAmelCase       =				{
    "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       __UpperCamelCase						(		snake_case__       ):
	A_		:    List[str]						     = list(s_dict.keys()       )
	for key in keys:
		A_		:    int						     = key
		for k, v in WHISPER_MAPPING.items():
			if k in key:
				A_		:    int						     = new_key.replace(snake_case__ , snake_case__       )

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

		A_		:    List[str]						     = s_dict.pop(snake_case__       )
	return s_dict






def       __UpperCamelCase						(		snake_case__       ):
	A_     ,  A_		:    Dict						     = emb.weight.shape
	A_		:    Dict						     = nn.Linear(snake_case__ , snake_case__ , bias=snake_case__       )
	A_		:    Tuple						     = emb.weight.data
	return lin_layer






def       __UpperCamelCase						(		snake_case__ , snake_case__       ):
	os.makedirs(snake_case__ , exist_ok=snake_case__       )
	A_		:    Optional[Any]						     = os.path.basename(snake_case__       )

	A_		:    Union[str, Any]						     = url.split("""/"""       )[-2]
	A_		:    List[Any]						     = 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__       ):
		A_		:    Optional[int]						     = 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=1_024       ) as loop:
			while True:
				A_		:    Any						     = source.read(8_192       )
				if not buffer:
					break

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

	A_		:    Optional[Any]						     = 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       __UpperCamelCase						(		snake_case__ , snake_case__       ):
	if ".pt" not in checkpoint_path:
		A_		:    int						     = _download(_MODELS[checkpoint_path]       )
	else:
		A_		:    Union[str, Any]						     = torch.load(snake_case__ , map_location="""cpu"""       )
	A_		:    Optional[Any]						     = original_checkpoint["""dims"""]
	A_		:    int						     = original_checkpoint["""model_state_dict"""]
	A_		:    Tuple						     = state_dict["""decoder.token_embedding.weight"""]
	remove_ignore_keys_(snake_case__       )
	rename_keys(snake_case__       )
	A_		:    Union[str, Any]						     = True
	A_		:    List[Any]						     = state_dict["""decoder.layers.0.fc1.weight"""].shape[0]

	A_		:    str						     = 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"""] , )

	A_		:    List[str]						     = WhisperForConditionalGeneration(snake_case__       )
	A_     ,  A_		:    int						     = 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:
		A_		:    Tuple						     = make_linear_from_emb(model.model.decoder.embed_tokens       )
	else:
		A_		:    Optional[Any]						     = proj_out_weights

	model.save_pretrained(snake_case__       )


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

							convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)









"""simple docstring"""
import torch
import torch.nn as nn
from transformers.modeling_utils import ModuleUtilsMixin
from transformers.models.ta.modeling_ta import TaBlock, TaConfig, TaLayerNorm

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin



class   SCREAMING_SNAKE_CASE	(					_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE    ):





	"""simple docstring"""




	@register_to_config
	def __init__(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_  ,  lowerCAmelCase_ = False  ,  ):
		super().__init__()

		A_		:    Tuple						     = nn.Embedding(lowerCAmelCase_  ,  lowerCAmelCase_				)

		A_		:    List[str]						     = nn.Embedding(lowerCAmelCase_  ,  lowerCAmelCase_				)
		A_		:    Any						     = False

		A_		:    Tuple						     = nn.Dropout(p=lowerCAmelCase_				)

		A_		:    List[str]						     = TaConfig(
		    vocab_size=lowerCAmelCase_  ,  d_model=lowerCAmelCase_  ,  num_heads=lowerCAmelCase_  ,  d_kv=lowerCAmelCase_  ,  d_ff=lowerCAmelCase_  ,  dropout_rate=lowerCAmelCase_  ,  feed_forward_proj=lowerCAmelCase_  ,  is_decoder=lowerCAmelCase_  ,  is_encoder_decoder=lowerCAmelCase_  ,  )

		A_		:    Optional[Any]						     = nn.ModuleList()
		for lyr_num in range(lowerCAmelCase_				):
			A_		:    Tuple						     = TaBlock(lowerCAmelCase_				)
			self.encoders.append(lowerCAmelCase_				)

		A_		:    Any						     = TaLayerNorm(lowerCAmelCase_				)
		A_		:    Union[str, Any]						     = nn.Dropout(p=lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    List[Any]						     = self.token_embedder(lowerCAmelCase_				)

		A_		:    Optional[Any]						     = encoder_input_tokens.shape[1]
		A_		:    Any						     = torch.arange(lowerCAmelCase_  ,  device=encoder_input_tokens.device				)
		x += self.position_encoding(lowerCAmelCase_				)

		A_		:    Optional[Any]						     = self.dropout_pre(lowerCAmelCase_				)

		# inverted the attention mask
		A_		:    int						     = encoder_input_tokens.size()
		A_		:    Optional[Any]						     = self.get_extended_attention_mask(lowerCAmelCase_  ,  lowerCAmelCase_				)

		for lyr in self.encoders:
			A_		:    int						     = lyr(lowerCAmelCase_  ,  lowerCAmelCase_				)[0]
		A_		:    List[str]						     = self.layer_norm(lowerCAmelCase_				)

		return self.dropout_post(lowerCAmelCase_				), encoder_inputs_mask

