
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


lowercase__							:							str									=			{
    "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_ (							snake_case							:   Dict )      ->    Any:



						'''simple docstring'''

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


lowercase__							:							Tuple									=			{
    "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_ (							snake_case							:   Union[str, Any] )      ->    List[Any]:



						'''simple docstring'''

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

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

												__UpperCamelCase       =			s_dict.pop(snake_case )
						return s_dict




def 	A_ (							snake_case							:   str )      ->    List[str]:



						'''simple docstring'''

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




def 	A_ (							snake_case							:   str ,      snake_case							:   str )      ->    bytes:



						'''simple docstring'''

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

						__UpperCamelCase       =			url.split('''/''' )[-2]
						__UpperCamelCase       =			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 ):
												__UpperCamelCase       =			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=1024 ) as loop:
																		while True:
																								__UpperCamelCase       =			source.read(8192 )
																								if not buffer:
																														break

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

						__UpperCamelCase       =			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 	A_ (							snake_case							:   Tuple ,      snake_case							:   int )      ->    Optional[int]:



						'''simple docstring'''

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

						__UpperCamelCase       =			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'''] ,      )

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

						model.save_pretrained(snake_case )


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

				convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)






from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


lowercase__							:							Tuple									=			logging.get_logger(__name__)

lowercase__							:							int									=			{
    "microsoft/table-transformer-detection": (
        "https://huggingface.co/microsoft/table-transformer-detection/resolve/main/config.json"
    ),
}






class        SCREAMING_SNAKE_CASE__    (							SCREAMING_SNAKE_CASE_    ):

							"""simple docstring"""






							_snake_case     		=  'table-transformer'
							_snake_case     		=  ['past_key_values']
							_snake_case     		=  {
							    'hidden_size': 'd_model',
							    'num_attention_heads': 'encoder_attention_heads',
							}



							def __init__(  self     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=3     ,	SCREAMING_SNAKE_CASE_=100     ,	SCREAMING_SNAKE_CASE_=6     ,	SCREAMING_SNAKE_CASE_=2048     ,	SCREAMING_SNAKE_CASE_=8     ,	SCREAMING_SNAKE_CASE_=6     ,	SCREAMING_SNAKE_CASE_=2048     ,	SCREAMING_SNAKE_CASE_=8     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_="relu"     ,	SCREAMING_SNAKE_CASE_=256     ,	SCREAMING_SNAKE_CASE_=0.1     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=0.0     ,	SCREAMING_SNAKE_CASE_=0.0_2     ,	SCREAMING_SNAKE_CASE_=1.0     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_="sine"     ,	SCREAMING_SNAKE_CASE_="resnet50"     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_=1     ,	SCREAMING_SNAKE_CASE_=5     ,	SCREAMING_SNAKE_CASE_=2     ,	SCREAMING_SNAKE_CASE_=1     ,	SCREAMING_SNAKE_CASE_=1     ,	SCREAMING_SNAKE_CASE_=5     ,	SCREAMING_SNAKE_CASE_=2     ,	SCREAMING_SNAKE_CASE_=0.1     ,	**SCREAMING_SNAKE_CASE_     ,	)->   Tuple:





													'''simple docstring'''






													if backbone_config is not None and use_timm_backbone:
																			raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.'''			)

													if not use_timm_backbone:
																			if backbone_config is None:
																									logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''			)
																									__UpperCamelCase       =			CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']			)
																			elif isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			):
																									__UpperCamelCase       =			backbone_config.get('''model_type'''			)
																									__UpperCamelCase       =			CONFIG_MAPPING[backbone_model_type]
																									__UpperCamelCase       =			config_class.from_dict(SCREAMING_SNAKE_CASE_			)
																			# set timm attributes to None
																			__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase       =			None, None, None

													__UpperCamelCase       =			use_timm_backbone
													__UpperCamelCase       =			backbone_config
													__UpperCamelCase       =			num_channels
													__UpperCamelCase       =			num_queries
													__UpperCamelCase       =			d_model
													__UpperCamelCase       =			encoder_ffn_dim
													__UpperCamelCase       =			encoder_layers
													__UpperCamelCase       =			encoder_attention_heads
													__UpperCamelCase       =			decoder_ffn_dim
													__UpperCamelCase       =			decoder_layers
													__UpperCamelCase       =			decoder_attention_heads
													__UpperCamelCase       =			dropout
													__UpperCamelCase       =			attention_dropout
													__UpperCamelCase       =			activation_dropout
													__UpperCamelCase       =			activation_function
													__UpperCamelCase       =			init_std
													__UpperCamelCase       =			init_xavier_std
													__UpperCamelCase       =			encoder_layerdrop
													__UpperCamelCase       =			decoder_layerdrop
													__UpperCamelCase       =			encoder_layers
													__UpperCamelCase       =			auxiliary_loss
													__UpperCamelCase       =			position_embedding_type
													__UpperCamelCase       =			backbone
													__UpperCamelCase       =			use_pretrained_backbone
													__UpperCamelCase       =			dilation
													# Hungarian matcher
													__UpperCamelCase       =			class_cost
													__UpperCamelCase       =			bbox_cost
													__UpperCamelCase       =			giou_cost
													# Loss coefficients
													__UpperCamelCase       =			mask_loss_coefficient
													__UpperCamelCase       =			dice_loss_coefficient
													__UpperCamelCase       =			bbox_loss_coefficient
													__UpperCamelCase       =			giou_loss_coefficient
													__UpperCamelCase       =			eos_coefficient
													super().__init__(is_encoder_decoder=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_			)



							@property
							def     A__		(  self			)->   int:





													'''simple docstring'''






													return self.encoder_attention_heads



							@property
							def     A__		(  self			)->   int:





													'''simple docstring'''






													return self.d_model






class        SCREAMING_SNAKE_CASE__    (							SCREAMING_SNAKE_CASE_    ):

							"""simple docstring"""






							_snake_case     		=  version.parse('1.11'    )



							@property
							def     A__		(  self			)->   Mapping[str, Mapping[int, str]]:





													'''simple docstring'''






													return OrderedDict(
													    [
													        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
													        ('''pixel_mask''', {0: '''batch'''}),
													    ]			)



							@property
							def     A__		(  self			)->   float:





													'''simple docstring'''






													return 1E-5



							@property
							def     A__		(  self			)->   int:





													'''simple docstring'''






													return 12




