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


__snake_case						  =		{
    """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_      (       SCREAMING_SNAKE_CASE_						)			->List[str]:
  lowercase_     =       ["""layers""", """blocks"""]
  for k in ignore_keys:
    state_dict.pop(SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)


__snake_case						  =		{
    """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_      (       SCREAMING_SNAKE_CASE_						)			->Any:
  lowercase_     =       list(s_dict.keys()						)
  for key in keys:
    lowercase_     =       key
    for k, v in WHISPER_MAPPING.items():
      if k in key:
        lowercase_     =       new_key.replace(SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)

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

    lowercase_     =       s_dict.pop(SCREAMING_SNAKE_CASE_						)
  return s_dict

def   A_      (       SCREAMING_SNAKE_CASE_						)			->str:
  lowercase_     ,	lowercase_     =       emb.weight.shape
  lowercase_     =       nn.Linear(SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_ ,	bias=SCREAMING_SNAKE_CASE_						)
  lowercase_     =       emb.weight.data
  return lin_layer

def   A_      (       SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)			->bytes:
  os.makedirs(SCREAMING_SNAKE_CASE_ ,	exist_ok=SCREAMING_SNAKE_CASE_						)
  lowercase_     =       os.path.basename(SCREAMING_SNAKE_CASE_						)

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

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

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

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

  lowercase_     =       open(SCREAMING_SNAKE_CASE_ ,	"""rb"""						).read()
  if hashlib.shaaaa(SCREAMING_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_      (       SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)			->Optional[Any]:
  if ".pt" not in checkpoint_path:
    lowercase_     =       _download(_MODELS[checkpoint_path]						)
  else:
    lowercase_     =       torch.load(SCREAMING_SNAKE_CASE_ ,	map_location="""cpu"""						)
  lowercase_     =       original_checkpoint["""dims"""]
  lowercase_     =       original_checkpoint["""model_state_dict"""]
  lowercase_     =       state_dict["""decoder.token_embedding.weight"""]
  remove_ignore_keys_(SCREAMING_SNAKE_CASE_						)
  rename_keys(SCREAMING_SNAKE_CASE_						)
  lowercase_     =       True
  lowercase_     =       state_dict["""decoder.layers.0.fc1.weight"""].shape[0]

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

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

  model.save_pretrained(SCREAMING_SNAKE_CASE_						)


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

       convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)


'''simple docstring'''


from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
       import torch

if is_torch_tpu_available(check_device=False):
       import torch_xla.core.xla_model as xm


__snake_case						  =		logging.get_logger(__name__)





@dataclass
class       _a    (		__a      ):


  """simple docstring"""

  A_    							=						[
      '''no_inference''',
      '''no_cuda''',
      '''no_tpu''',
      '''no_speed''',
      '''no_memory''',
      '''no_env_print''',
      '''no_multi_process''',
  ]




  def __init__(		self      :       int   ,				**lowercase_      :       int      ):







    '''simple docstring'''


    for deprecated_arg in self.deprecated_args:
      if deprecated_arg in kwargs:
        lowercase_     =       deprecated_arg[3:]
        setattr(self   ,				lowercase_   ,				not kwargs.pop(lowercase_      )      )
        logger.warning(
            F"""{deprecated_arg} is depreciated. Please use --no_{positive_arg} or"""
            F""" {positive_arg}={kwargs[positive_arg]}"""      )

    lowercase_     =       kwargs.pop("""torchscript"""   ,				self.torchscript      )
    lowercase_     =       kwargs.pop("""torch_xla_tpu_print_metrics"""   ,				self.torch_xla_tpu_print_metrics      )
    lowercase_     =       kwargs.pop("""fp16_opt_level"""   ,				self.fpaa_opt_level      )
    super().__init__(**lowercase_      )

  A_    							=						field(default=__a ,				metadata={'''help''': '''Trace the models using torchscript'''}      )
  A_    							=						field(default=__a ,				metadata={'''help''': '''Print Xla/PyTorch tpu metrics'''}      )
  A_    							=						field(
      default='''O1''' ,				metadata={
          '''help''': (
              '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '''
              '''See details at https://nvidia.github.io/apex/amp.html'''
          )
      } ,				)




  @cached_property
  def 		lowerCamelCase__  (		self      :       Dict      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    logger.info("""PyTorch: setting up devices"""      )
    if not self.cuda:
      lowercase_     =       torch.device("""cpu"""      )
      lowercase_     =       0
    elif is_torch_tpu_available():
      lowercase_     =       xm.xla_device()
      lowercase_     =       0
    else:
      lowercase_     =       torch.device("""cuda""" if torch.cuda.is_available() else """cpu"""      )
      lowercase_     =       torch.cuda.device_count()
    return device, n_gpu




  @property
  def 		lowerCamelCase__  (		self      :       List[str]      ):







    '''simple docstring'''


    return is_torch_tpu_available() and self.tpu




  @property
  def 		lowerCamelCase__  (		self      :       Tuple      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    # TODO(PVP): currently only single GPU is supported
    return torch.cuda.current_device()




  @property
  def 		lowerCamelCase__  (		self      :       Dict      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    return self._setup_devices[0]




  @property
  def 		lowerCamelCase__  (		self      :       Any      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    return self._setup_devices[1]





  @property
  def 		lowerCamelCase__  (		self      :       Optional[int]      ):







    '''simple docstring'''


    return self.n_gpu > 0

