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


SCREAMING_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     lowercase__						(					lowerCAmelCase				:					Tuple ) ->      Optional[int]:






				"""simple docstring"""




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


SCREAMING_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     lowercase__						(					lowerCAmelCase				:					Tuple ) ->      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(lowerCAmelCase ,				lowerCAmelCase )

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

								UpperCAmelCase									=					s_dict.pop(lowerCAmelCase )
				return s_dict




def     lowercase__						(					lowerCAmelCase				:					str ) ->      List[Any]:






				"""simple docstring"""




				UpperCAmelCase			,							UpperCAmelCase									=					emb.weight.shape
				UpperCAmelCase									=					nn.Linear(lowerCAmelCase ,				lowerCAmelCase ,				bias=lowerCAmelCase )
				UpperCAmelCase									=					emb.weight.data
				return lin_layer




def     lowercase__						(					lowerCAmelCase				:					str ,				lowerCAmelCase				:					str ) ->      bytes:






				"""simple docstring"""




				os.makedirs(lowerCAmelCase ,				exist_ok=lowerCAmelCase )
				UpperCAmelCase									=					os.path.basename(lowerCAmelCase )

				UpperCAmelCase									=					url.split('/' )[-2]
				UpperCAmelCase									=					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 ):
								UpperCAmelCase									=					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=1_024 ) as loop:
												while True:
																UpperCAmelCase									=					source.read(8_192 )
																if not buffer:
																				break

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

				UpperCAmelCase									=					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     lowercase__						(					lowerCAmelCase				:					List[str] ,				lowerCAmelCase				:					Dict ) ->      List[str]:






				"""simple docstring"""




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

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

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

				model.save_pretrained(lowerCAmelCase )


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

			convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)





"""simple docstring"""

def     lowercase__						(					lowerCAmelCase				:					int ,				lowerCAmelCase				:					list ) ->      int:






    """simple docstring"""




    _enforce_args(lowerCAmelCase ,				lowerCAmelCase )
    if n == 0:
        return 0
    UpperCAmelCase									=					float('-inf' )
    for i in range(1 ,				n + 1 ):
        UpperCAmelCase									=					max(
            lowerCAmelCase ,				prices[i - 1] + naive_cut_rod_recursive(n - i ,				lowerCAmelCase ) )

    return max_revue




def     lowercase__						(					lowerCAmelCase				:					int ,				lowerCAmelCase				:					list ) ->      Dict:






    """simple docstring"""




    _enforce_args(lowerCAmelCase ,				lowerCAmelCase )
    UpperCAmelCase									=					[float('-inf' ) for _ in range(n + 1 )]
    return _top_down_cut_rod_recursive(lowerCAmelCase ,				lowerCAmelCase ,				lowerCAmelCase )




def     lowercase__						(					lowerCAmelCase				:					int ,				lowerCAmelCase				:					list ,				lowerCAmelCase				:					list ) ->      int:






    """simple docstring"""




    if max_rev[n] >= 0:
        return max_rev[n]
    elif n == 0:
        return 0
    else:
        UpperCAmelCase									=					float('-inf' )
        for i in range(1 ,				n + 1 ):
            UpperCAmelCase									=					max(
                lowerCAmelCase ,				prices[i - 1] + _top_down_cut_rod_recursive(n - i ,				lowerCAmelCase ,				lowerCAmelCase ) ,				)

        UpperCAmelCase									=					max_revenue

    return max_rev[n]




def     lowercase__						(					lowerCAmelCase				:					int ,				lowerCAmelCase				:					list ) ->      Optional[int]:






    """simple docstring"""




    _enforce_args(lowerCAmelCase ,				lowerCAmelCase )

    # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
    # length 0.
    UpperCAmelCase									=					[float('-inf' ) for _ in range(n + 1 )]
    UpperCAmelCase									=					0

    for i in range(1 ,				n + 1 ):
        UpperCAmelCase									=					max_rev[i]
        for j in range(1 ,				i + 1 ):
            UpperCAmelCase									=					max(lowerCAmelCase ,				prices[j - 1] + max_rev[i - j] )

        UpperCAmelCase									=					max_revenue_i

    return max_rev[n]




def     lowercase__						(					lowerCAmelCase				:					int ,				lowerCAmelCase				:					list ) ->      Union[str, Any]:






    """simple docstring"""




    if n < 0:
        UpperCAmelCase									=					F"n must be greater than or equal to 0. Got n = {n}"
        raise ValueError(lowerCAmelCase )

    if n > len(lowerCAmelCase ):
        UpperCAmelCase									=					(
            'Each integral piece of rod must have a corresponding price. '
            F"Got n = {n} but length of prices = {len(lowerCAmelCase )}"
        )
        raise ValueError(lowerCAmelCase )




def     lowercase__						(					) ->      Optional[int]:






    """simple docstring"""




    UpperCAmelCase									=					[6, 10, 12, 15, 20, 23]
    UpperCAmelCase									=					len(lowerCAmelCase )

    # the best revenue comes from cutting the rod into 6 pieces, each
    # of length 1 resulting in a revenue of 6 * 6 = 36.
    UpperCAmelCase									=					36

    UpperCAmelCase									=					top_down_cut_rod(lowerCAmelCase ,				lowerCAmelCase )
    UpperCAmelCase									=					bottom_up_cut_rod(lowerCAmelCase ,				lowerCAmelCase )
    UpperCAmelCase									=					naive_cut_rod_recursive(lowerCAmelCase ,				lowerCAmelCase )

    assert expected_max_revenue == max_rev_top_down
    assert max_rev_top_down == max_rev_bottom_up
    assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
   main()



