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   :     Union[str, Any]       =				{
    "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__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     ["layers", "blocks"]
      for k in ignore_keys:
            state_dict.pop(__UpperCamelCase   ,					__UpperCamelCase )


A   :     Optional[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    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     list(s_dict.keys() )
      for key in keys:
            SCREAMING_SNAKE_CASE_      =     key
            for k, v in WHISPER_MAPPING.items():
                  if k in key:
                        SCREAMING_SNAKE_CASE_      =     new_key.replace(__UpperCamelCase   ,					__UpperCamelCase )

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

            SCREAMING_SNAKE_CASE_      =     s_dict.pop(__UpperCamelCase )
      return s_dict


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     emb.weight.shape
      SCREAMING_SNAKE_CASE_      =     nn.Linear(__UpperCamelCase   ,					__UpperCamelCase   ,					bias=__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     emb.weight.data
      return lin_layer


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase ):
      os.makedirs(__UpperCamelCase   ,					exist_ok=__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     os.path.basename(__UpperCamelCase )

      SCREAMING_SNAKE_CASE_      =     url.split("/" )[-2]
      SCREAMING_SNAKE_CASE_      =     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 ):
            SCREAMING_SNAKE_CASE_      =     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=8_0   ,					unit="iB"   ,					unit_scale=__UpperCamelCase   ,					unit_divisor=1_0_2_4 ) as loop:
                  while True:
                        SCREAMING_SNAKE_CASE_      =     source.read(8_1_9_2 )
                        if not buffer:
                              break

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

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

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

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

      model.save_pretrained(__UpperCamelCase )


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

      convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)



import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
      from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
      from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
      from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


A   :     Tuple       =				DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

A   :     Dict       =				"main"
# Default branch name
A   :     List[str]       =				"f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
A   :     Tuple       =				"aaaaaaa"
# This commit does not exist, so we should 404.

A   :     int       =				"d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
A   :     Tuple       =				"4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"


@contextlib.contextmanager
def    a__       (						):
      print("Welcome!" )
      yield
      print("Bye!" )


@contextlib.contextmanager
def    a__       (						):
      print("Bonjour!" )
      yield
      print("Au revoir!" )


class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  def       __A   (							self       :				Union[str, Any]      )     ->		Any:
        # If the spec is missing, importlib would not be able to import the module dynamically.
        assert transformers.__spec__ is not None
        assert importlib.util.find_spec("transformers"      ) is not None



class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  @unittest.mock.patch("sys.stdout"     ,   new_callable=io.StringIO      )
  def       __A   (							self       :				Tuple     ,   __magic_name__       :				Union[str, Any]      )     ->		Union[str, Any]:
        with ContextManagers([]      ):
              print("Transformers are awesome!"      )
        # The print statement adds a new line at the end of the output
        self.assertEqual(mock_stdout.getvalue()     ,   "Transformers are awesome!\n"      )







  @unittest.mock.patch("sys.stdout"     ,   new_callable=io.StringIO      )
  def       __A   (							self       :				Dict     ,   __magic_name__       :				Union[str, Any]      )     ->		int:
        with ContextManagers([context_en()]      ):
              print("Transformers are awesome!"      )
        # The output should be wrapped with an English welcome and goodbye
        self.assertEqual(mock_stdout.getvalue()     ,   "Welcome!\nTransformers are awesome!\nBye!\n"      )







  @unittest.mock.patch("sys.stdout"     ,   new_callable=io.StringIO      )
  def       __A   (							self       :				Tuple     ,   __magic_name__       :				str      )     ->		Union[str, Any]:
        with ContextManagers([context_fr(), context_en()]      ):
              print("Transformers are awesome!"      )
        # The output should be wrapped with an English and French welcome and goodbye
        self.assertEqual(mock_stdout.getvalue()     ,   "Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"      )







  @require_torch
  def       __A   (							self       :				List[str]      )     ->		Union[str, Any]:
        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels"]      )
        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels", "next_sentence_label"]      )
        self.assertEqual(find_labels(__magic_name__      )     ,   ["start_positions", "end_positions"]      )


        class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
          """simple docstring"""







          pass



        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels"]      )







  @require_tf
  def       __A   (							self       :				List[str]      )     ->		Optional[Any]:
        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels"]      )
        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels", "next_sentence_label"]      )
        self.assertEqual(find_labels(__magic_name__      )     ,   ["start_positions", "end_positions"]      )


        class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
          """simple docstring"""







          pass



        self.assertEqual(find_labels(__magic_name__      )     ,   ["labels"]      )







  @require_flax
  def       __A   (							self       :				int      )     ->		Tuple:
        # Flax models don't have labels
        self.assertEqual(find_labels(__magic_name__      )     ,   []      )
        self.assertEqual(find_labels(__magic_name__      )     ,   []      )
        self.assertEqual(find_labels(__magic_name__      )     ,   []      )


        class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
          """simple docstring"""







          pass



        self.assertEqual(find_labels(__magic_name__      )     ,   []      )


