

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    :int      =			{
    '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       __snake_case						( __UpperCamelCase	: List[Any]    ):



      """simple docstring"""

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


__a    :List[str]      =			{
    '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       __snake_case						( __UpperCamelCase	: Dict    ):



      """simple docstring"""

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

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

            A_						  =				s_dict.pop(__UpperCamelCase    )
      return s_dict

def       __snake_case						( __UpperCamelCase	: Optional[int]    ):



      """simple docstring"""

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

def       __snake_case						( __UpperCamelCase	: str				,__UpperCamelCase	: str    ):



      """simple docstring"""

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

      A_						  =				url.split("/"    )[-2]
      A_						  =				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    ):
            A_						  =				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:
                        A_						  =				source.read(8192    )
                        if not buffer:
                              break

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

      A_						  =				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       __snake_case						( __UpperCamelCase	: List[str]				,__UpperCamelCase	: Any    ):



      """simple docstring"""

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

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

      A_						  =				WhisperForConditionalGeneration(__UpperCamelCase    )
      A_  ,     A_						  =				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:
            A_						  =				make_linear_from_emb(model.model.decoder.embed_tokens    )
      else:
            A_						  =				proj_out_weights

      model.save_pretrained(__UpperCamelCase    )


if __name__ == "__main__":
      __a    :str      =			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    :List[str]      =			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      A__  (    __SCREAMING_SNAKE_CASE    ,						__SCREAMING_SNAKE_CASE    ,						__SCREAMING_SNAKE_CASE				):




	'''simple docstring'''





	@register_to_config
	def __init__(	self:						List[str]			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						float			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						int			,     _SCREAMING_SNAKE_CASE:						str			,     _SCREAMING_SNAKE_CASE:						bool = False			,     )							->			Any:

				"""simple docstring"""

				super().__init__()

				__lowerCAmelCase :    str				=			nn.Embedding(_SCREAMING_SNAKE_CASE			,     _SCREAMING_SNAKE_CASE)

				__lowerCAmelCase :    Dict				=			nn.Embedding(_SCREAMING_SNAKE_CASE			,     _SCREAMING_SNAKE_CASE)
				__lowerCAmelCase :    str				=			False

				__lowerCAmelCase :    Optional[Any]				=			nn.Dropout(p=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase :    Dict				=			TaConfig(
				    vocab_size=_SCREAMING_SNAKE_CASE			,     d_model=_SCREAMING_SNAKE_CASE			,     num_heads=_SCREAMING_SNAKE_CASE			,     d_kv=_SCREAMING_SNAKE_CASE			,     d_ff=_SCREAMING_SNAKE_CASE			,     dropout_rate=_SCREAMING_SNAKE_CASE			,     feed_forward_proj=_SCREAMING_SNAKE_CASE			,     is_decoder=_SCREAMING_SNAKE_CASE			,     is_encoder_decoder=_SCREAMING_SNAKE_CASE			,     )

				__lowerCAmelCase :    str				=			nn.ModuleList()
				for lyr_num in range(_SCREAMING_SNAKE_CASE):
							__lowerCAmelCase :    int				=			TaBlock(_SCREAMING_SNAKE_CASE)
							self.encoders.append(_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase :    Dict				=			TaLayerNorm(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase :    Any				=			nn.Dropout(p=_SCREAMING_SNAKE_CASE)







	def 				_SCREAMING_SNAKE_CASE  (	self:						Any			,     _SCREAMING_SNAKE_CASE:						Tuple			,     _SCREAMING_SNAKE_CASE:						str)							->			List[str]:

				"""simple docstring"""

				__lowerCAmelCase :    Union[str, Any]				=			self.token_embedder(_SCREAMING_SNAKE_CASE)

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

				__lowerCAmelCase :    List[Any]				=			self.dropout_pre(_SCREAMING_SNAKE_CASE)

				# inverted the attention mask
				__lowerCAmelCase :    List[Any]				=			encoder_input_tokens.size()
				__lowerCAmelCase :    Any				=			self.get_extended_attention_mask(_SCREAMING_SNAKE_CASE			,     _SCREAMING_SNAKE_CASE)

				for lyr in self.encoders:
							__lowerCAmelCase :    Union[str, Any]				=			lyr(_SCREAMING_SNAKE_CASE			,     _SCREAMING_SNAKE_CASE)[0]
				__lowerCAmelCase :    int				=			self.layer_norm(_SCREAMING_SNAKE_CASE)

				return self.dropout_post(_SCREAMING_SNAKE_CASE), encoder_inputs_mask