
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			(			a__  )       ->  Optional[int]:
				__a										=    ["""layers""", """blocks"""]
				for k in ignore_keys:
								state_dict.pop(_lowerCamelCase						,    _lowerCamelCase  )


A     :	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     __lowerCAmelCase			(			a__  )       ->  str:
				__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(_lowerCamelCase						,    _lowerCamelCase  )

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

								__a										=    s_dict.pop(_lowerCamelCase  )
				return s_dict


def     __lowerCAmelCase			(			a__  )       ->  List[Any]:
				__a										=    emb.weight.shape
				__a										=    nn.Linear(_lowerCamelCase						,    _lowerCamelCase						,    bias=_lowerCamelCase  )
				__a										=    emb.weight.data
				return lin_layer


def     __lowerCAmelCase			(			a__						,    a__  )       ->  int:
				os.makedirs(_lowerCamelCase						,    exist_ok=_lowerCamelCase  )
				__a										=    os.path.basename(_lowerCamelCase  )

				__a										=    url.split('''/'''  )[-2]
				__a										=    os.path.join(_lowerCamelCase						,    _lowerCamelCase  )

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

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

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

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

				__a										=    WhisperConfig(
				    vocab_size=dimensions['''n_vocab''']						,    encoder_ffn_dim=_lowerCamelCase						,    decoder_ffn_dim=_lowerCamelCase						,    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(_lowerCamelCase  )
				__a										=    model.model.load_state_dict(_lowerCamelCase						,    strict=_lowerCamelCase  )
				if len(_lowerCamelCase  ) > 0 and not set(_lowerCamelCase  ) <= {
				    "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(_lowerCamelCase  )


if __name__ == "__main__":
					A     :	int    = 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     :	Optional[Any]    = parser.parse_args()

					convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)




'''simple docstring'''




# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCamelCase__       :	List[Any]    = [
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]


def 				lowerCAmelCase_   (	_lowerCamelCase:   str       ,      _lowerCamelCase:   Union[str, Any]=None       ,      _lowerCamelCase:   Optional[int]=None       ,      _lowerCamelCase:   str=None					):
		__SCREAMING_SNAKE_CASE       :		Optional[int]           =		True
		while ask_again:
				__SCREAMING_SNAKE_CASE       :		Tuple           =		input(_lowerCamelCase					)
				try:
						if default is not None and len(_lowerCamelCase					) == 0:
								return default
						return convert_value(_lowerCamelCase					) if convert_value is not None else result
				except Exception:
						if error_message is not None:
								print(_lowerCamelCase					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple       ,      _lowerCamelCase:   Union[str, Any]=[]       ,      _lowerCamelCase:   List[Any]=None       ,      _lowerCamelCase:   Optional[Any]=0					):
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		BulletMenu(_lowerCamelCase       ,      _lowerCamelCase					)
		__SCREAMING_SNAKE_CASE       :		Dict           =		menu.run(default_choice=_lowerCamelCase					)
		return convert_value(_lowerCamelCase					) if convert_value is not None else result


def 				lowerCAmelCase_   (	_lowerCamelCase:   Optional[Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return ComputeEnvironment(["""LOCAL_MACHINE""", """AMAZON_SAGEMAKER"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Any					):
		__SCREAMING_SNAKE_CASE       :		str           =		int(_lowerCamelCase					)
		return DistributedType(["""NO""", """MULTI_CPU""", """MULTI_XPU""", """MULTI_GPU""", """MULTI_NPU""", """TPU"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		Tuple           =		int(_lowerCamelCase					)
		return DynamoBackend(DYNAMO_BACKENDS[value]					).value


def 				lowerCAmelCase_   (	_lowerCamelCase:   Union[str, Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return PrecisionType(["""no""", """fp16""", """bf16""", """fp8"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		int           =		int(_lowerCamelCase					)
		return SageMakerDistributedType(["""NO""", """DATA_PARALLEL""", """MODEL_PARALLEL"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   List[Any]					):
		return {"yes": True, "no": False}[value.lower()]






class 						_UpperCamelCase  (							argparse.RawDescriptionHelpFormatter    ):


			'''simple docstring'''

			def UpperCamelCase__					(							self     : Tuple							,     lowerCAmelCase__     : Optional[Any]							,     lowerCAmelCase__     : Dict							,     lowerCAmelCase__     : List[Any]							,     lowerCAmelCase__     : List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		super()._format_usage(lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		Any           =		usage.replace("""<command> [<args>] """							,     """"""						)
					return usage