



"""simple docstring"""

import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
a_			   =					logging.get_logger(__name__)

a_			   =					{
    '''post_extract_proj''': '''feature_projection.projection''',
    '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''',
    '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''',
    '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''',
    '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''',
    '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''',
    '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''',
    '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''',
    '''fc2''': '''encoder.layers.*.feed_forward.output_dense''',
    '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''encoder.layer_norm''',
    '''w2v_model.layer_norm''': '''feature_projection.layer_norm''',
    '''quantizer.weight_proj''': '''quantizer.weight_proj''',
    '''quantizer.vars''': '''quantizer.codevectors''',
    '''project_q''': '''project_q''',
    '''final_proj''': '''project_hid''',
    '''w2v_encoder.proj''': '''lm_head''',
    '''mask_emb''': '''masked_spec_embed''',
}
a_			   =					[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  List[str]				,    SCREAMING_SNAKE_CASE__ :  Any				,    SCREAMING_SNAKE_CASE__ :  List[Any]				,    SCREAMING_SNAKE_CASE__ :  List[str]				,    SCREAMING_SNAKE_CASE__ :  str			):



					"""simple docstring"""





					for attribute in key.split("""."""			):
										snake_case_					:		Optional[int] 					=					getattr(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)

					if weight_type is not None:
										snake_case_					:		Any 					=					getattr(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			).shape
					else:
										snake_case_					:		str 					=					hf_pointer.shape

					assert hf_shape == value.shape, (
					    f'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
					    f' {value.shape} for {full_name}'
					)

					if weight_type == "weight":
										snake_case_					:		Dict 					=					value
					elif weight_type == "weight_g":
										snake_case_					:		Optional[int] 					=					value
					elif weight_type == "weight_v":
										snake_case_					:		Optional[Any] 					=					value
					elif weight_type == "bias":
										snake_case_					:		Union[str, Any] 					=					value
					else:
										snake_case_					:		Dict 					=					value

					logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  List[Any]				,    SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					snake_case_					:		int 					=					[]
					snake_case_					:		List[Any] 					=					fairseq_model.state_dict()

					snake_case_					:		Union[str, Any] 					=					hf_model.feature_extractor

					# if encoder has different dim to decoder -> use proj_weight
					snake_case_					:		Any 					=					None

					for name, value in fairseq_dict.items():
										snake_case_					:		List[str] 					=					False
										if "conv_layers" in name:
															load_conv_layer(
															    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    hf_model.config.feat_extract_norm == """group"""				,    )
															snake_case_					:		Dict 					=					True
										elif name.split("""."""			)[0] == "proj":
															snake_case_					:		Any 					=					fairseq_model.proj
															snake_case_					:		str 					=					True
										else:
															for key, mapped_key in MAPPING.items():
																				if key in name or key.split("""w2v_model."""			)[-1] == name.split("""."""			)[0]:
																									snake_case_					:		Tuple 					=					True
																									if "*" in mapped_key:
																														snake_case_					:		List[Any] 					=					name.split(SCREAMING_SNAKE_CASE__			)[0].split("""."""			)[-2]
																														snake_case_					:		List[Any] 					=					mapped_key.replace("""*"""				,    SCREAMING_SNAKE_CASE__			)
																									if "weight_g" in name:
																														snake_case_					:		Optional[Any] 					=					"""weight_g"""
																									elif "weight_v" in name:
																														snake_case_					:		Any 					=					"""weight_v"""
																									elif "bias" in name:
																														snake_case_					:		Tuple 					=					"""bias"""
																									elif "weight" in name:
																														snake_case_					:		int 					=					"""weight"""
																									else:
																														snake_case_					:		Optional[Any] 					=					None
																									set_recursively(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)
																				continue
										if not is_used:
															unused_weights.append(SCREAMING_SNAKE_CASE__			)

					logger.warning(f'Unused weights: {unused_weights}'			)

					return proj_weight







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Optional[int]				,    SCREAMING_SNAKE_CASE__ :  Dict				,    SCREAMING_SNAKE_CASE__ :  Tuple				,    SCREAMING_SNAKE_CASE__ :  Union[str, Any]				,    SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					full_name.split("""conv_layers."""			)[-1]
					snake_case_					:		List[str] 					=					name.split("""."""			)
					snake_case_					:		Dict 					=					int(items[0]			)
					snake_case_					:		str 					=					int(items[1]			)

					if type_id == 0:
										if "bias" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
															    f'{full_name} has size {value.shape}, but'
															    f' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
															)
															snake_case_					:		Optional[int] 					=					value
															logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'			)
										elif "weight" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
															    f'{full_name} has size {value.shape}, but'
															    f' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
															)
															snake_case_					:		Tuple 					=					value
															logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'			)
					elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
										if "bias" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
															    f'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
															    " found."
															)
															snake_case_					:		int 					=					value
															logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'			)
										elif "weight" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
															    f'{full_name} has size {value.shape}, but'
															    f' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
															)
															snake_case_					:		List[Any] 					=					value
															logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'			)
					else:
										unused_weights.append(SCREAMING_SNAKE_CASE__			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  str			):



					"""simple docstring"""





					snake_case_					,			snake_case_					:		List[str] 					=					emb.weight.shape
					snake_case_					:		Optional[int] 					=					nn.Linear(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    bias=SCREAMING_SNAKE_CASE__			)
					snake_case_					:		Optional[int] 					=					emb.weight.data
					return lin_layer







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Dict			):



					"""simple docstring"""





					with open(SCREAMING_SNAKE_CASE__				,    """r"""				,    encoding="""utf-8"""			) as f:
										snake_case_					:		List[Any] 					=					f.readlines()
										snake_case_					:		List[str] 					=					[line.split(""" """			)[0] for line in lines]

					snake_case_					:		Optional[Any] 					=					len(SCREAMING_SNAKE_CASE__			)

					snake_case_					:		str 					=					{
					    """<s>""": 0,
					    """<pad>""": 1,
					    """</s>""": 2,
					    """<unk>""": 3,
					}

					vocab_dict.update(dict(zip(SCREAMING_SNAKE_CASE__				,    range(4				,    num_words + 4			)			)			)			)
					return vocab_dict







@torch.no_grad()
def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int				,    SCREAMING_SNAKE_CASE__ :  Any				,    SCREAMING_SNAKE_CASE__ :  List[Any]				,    SCREAMING_SNAKE_CASE__ :  Union[str, Any]				,    SCREAMING_SNAKE_CASE__ :  Any				,    SCREAMING_SNAKE_CASE__ :  Optional[Any]				,    SCREAMING_SNAKE_CASE__ :  Optional[Any]				,    ):



					"""simple docstring"""





					snake_case_					:		List[Any] 					=					WavaVecaConfig.from_pretrained(SCREAMING_SNAKE_CASE__			)
					snake_case_					:		Dict 					=					SpeechaTextaConfig.from_pretrained(
					    SCREAMING_SNAKE_CASE__				,    vocab_size=SCREAMING_SNAKE_CASE__				,    decoder_layers=SCREAMING_SNAKE_CASE__				,    do_stable_layer_norm=SCREAMING_SNAKE_CASE__			)

					snake_case_					:		Optional[int] 					=					WavaVecaFeatureExtractor(
					    feature_size=1				,    sampling_rate=1_6_0_0_0				,    padding_value=0				,    do_normalize=SCREAMING_SNAKE_CASE__				,    return_attention_mask=SCREAMING_SNAKE_CASE__				,    )

					snake_case_					,			snake_case_					,			snake_case_					:		Optional[int] 					=					fairseq.checkpoint_utils.load_model_ensemble_and_task(
					    [checkpoint_path]				,    arg_overrides={"""data""": """/""".join(dict_path.split("""/"""			)[:-1]			)}			)
					snake_case_					:		Optional[Any] 					=					model[0].eval()

					# set weights for wav2vec2 encoder
					snake_case_					:		Any 					=					WavaVecaModel(SCREAMING_SNAKE_CASE__			)
					snake_case_					:		Optional[Any] 					=					recursively_load_weights_wavaveca(model.encoder				,    SCREAMING_SNAKE_CASE__			)

					snake_case_					:		Tuple 					=					SpeechaTextaForCausalLM(SCREAMING_SNAKE_CASE__			)
					snake_case_					,			snake_case_					:		List[str] 					=					hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()				,    strict=SCREAMING_SNAKE_CASE__			)

					# set output linear layer
					unexpected_keys.remove("""embed_out"""			)
					snake_case_					:		Any 					=					nn.Parameter(model.decoder.embed_out.detach()			)

					# layer norm is init to identity matrix so leaving it is fine
					logger.warning(f'The following keys are missing when loading the decoder weights: {missing_keys}'			)
					logger.warning(f'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'			)

					snake_case_					:		Dict 					=					SpeechEncoderDecoderModel(encoder=SCREAMING_SNAKE_CASE__				,    decoder=SCREAMING_SNAKE_CASE__			)
					snake_case_					:		List[Any] 					=					False

					# add projection layer
					snake_case_					:		Dict 					=					nn.Parameter(projection_layer.weight			)
					snake_case_					:		List[Any] 					=					nn.Parameter(projection_layer.bias			)

					snake_case_					:		List[Any] 					=					create_vocab_dict(SCREAMING_SNAKE_CASE__			)

					with open(os.path.join(SCREAMING_SNAKE_CASE__				,    """vocab.json"""			)				,    """w"""			) as fp:
										json.dump(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)

					snake_case_					:		Optional[int] 					=					SpeechaTextaTokenizer(os.path.join(SCREAMING_SNAKE_CASE__				,    """vocab.json"""			)			)
					tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__			)

					snake_case_					:		int 					=					hf_wavavec.config.to_dict()
					snake_case_					:		Optional[Any] 					=					tokenizer.pad_token_id
					snake_case_					:		Optional[Any] 					=					tokenizer.bos_token_id
					snake_case_					:		Union[str, Any] 					=					tokenizer.eos_token_id
					snake_case_					:		List[str] 					=					"""speech_to_text_2"""
					snake_case_					:		str 					=					"""wav2vec2"""

					snake_case_					:		Optional[Any] 					=					SpeechEncoderDecoderConfig.from_dict(SCREAMING_SNAKE_CASE__			)

					hf_wavavec.save_pretrained(SCREAMING_SNAKE_CASE__			)
					feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__			)


if __name__ == "__main__":
			a_			   =					argparse.ArgumentParser()
			parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
			parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
			parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''')
			parser.add_argument(
			    '''--encoder_config_path''',
			    default='''facebook/wav2vec2-large-lv60''',
			    type=str,
			    help='''Path to hf encoder wav2vec2 checkpoint config''',
			)
			parser.add_argument(
			    '''--decoder_config_path''',
			    default='''facebook/s2t-small-mustc-en-fr-st''',
			    type=str,
			    help='''Path to hf decoder s2t checkpoint config''',
			)
			parser.add_argument('''--vocab_size''', default=10224, type=int, help='''Vocab size of decoder''')
			parser.add_argument('''--num_decoder_layers''', default=7, type=int, help='''Number of decoder layers''')

			a_			   =					parser.parse_args()
			convert_wavaveca_checkpoint(
			    args.checkpoint_path,
			    args.pytorch_dump_folder_path,
			    args.dict_path,
			    encoder_config_path=args.encoder_config_path,
			    decoder_config_path=args.decoder_config_path,
			    vocab_size=args.vocab_size,
			    num_decoder_layers=args.num_decoder_layers,
			)









"""simple docstring"""

import random







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					num - 1
					snake_case_					:		List[str] 					=					0

					while s % 2 == 0:
										snake_case_					:		str 					=					s // 2
										t += 1

					for _ in range(5			):
										snake_case_					:		List[Any] 					=					random.randrange(2				,    num - 1			)
										snake_case_					:		Dict 					=					pow(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)
										if v != 1:
															snake_case_					:		int 					=					0
															while v != (num - 1):
																				if i == t - 1:
																									return False
																				else:
																									snake_case_					:		str 					=					i + 1
																									snake_case_					:		int 					=					(v**2) % num
					return True







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					if num < 2:
										return False

					snake_case_					:		Dict 					=					[
					    2,
					    3,
					    5,
					    7,
					    1_1,
					    1_3,
					    1_7,
					    1_9,
					    2_3,
					    2_9,
					    3_1,
					    3_7,
					    4_1,
					    4_3,
					    4_7,
					    5_3,
					    5_9,
					    6_1,
					    6_7,
					    7_1,
					    7_3,
					    7_9,
					    8_3,
					    8_9,
					    9_7,
					    1_0_1,
					    1_0_3,
					    1_0_7,
					    1_0_9,
					    1_1_3,
					    1_2_7,
					    1_3_1,
					    1_3_7,
					    1_3_9,
					    1_4_9,
					    1_5_1,
					    1_5_7,
					    1_6_3,
					    1_6_7,
					    1_7_3,
					    1_7_9,
					    1_8_1,
					    1_9_1,
					    1_9_3,
					    1_9_7,
					    1_9_9,
					    2_1_1,
					    2_2_3,
					    2_2_7,
					    2_2_9,
					    2_3_3,
					    2_3_9,
					    2_4_1,
					    2_5_1,
					    2_5_7,
					    2_6_3,
					    2_6_9,
					    2_7_1,
					    2_7_7,
					    2_8_1,
					    2_8_3,
					    2_9_3,
					    3_0_7,
					    3_1_1,
					    3_1_3,
					    3_1_7,
					    3_3_1,
					    3_3_7,
					    3_4_7,
					    3_4_9,
					    3_5_3,
					    3_5_9,
					    3_6_7,
					    3_7_3,
					    3_7_9,
					    3_8_3,
					    3_8_9,
					    3_9_7,
					    4_0_1,
					    4_0_9,
					    4_1_9,
					    4_2_1,
					    4_3_1,
					    4_3_3,
					    4_3_9,
					    4_4_3,
					    4_4_9,
					    4_5_7,
					    4_6_1,
					    4_6_3,
					    4_6_7,
					    4_7_9,
					    4_8_7,
					    4_9_1,
					    4_9_9,
					    5_0_3,
					    5_0_9,
					    5_2_1,
					    5_2_3,
					    5_4_1,
					    5_4_7,
					    5_5_7,
					    5_6_3,
					    5_6_9,
					    5_7_1,
					    5_7_7,
					    5_8_7,
					    5_9_3,
					    5_9_9,
					    6_0_1,
					    6_0_7,
					    6_1_3,
					    6_1_7,
					    6_1_9,
					    6_3_1,
					    6_4_1,
					    6_4_3,
					    6_4_7,
					    6_5_3,
					    6_5_9,
					    6_6_1,
					    6_7_3,
					    6_7_7,
					    6_8_3,
					    6_9_1,
					    7_0_1,
					    7_0_9,
					    7_1_9,
					    7_2_7,
					    7_3_3,
					    7_3_9,
					    7_4_3,
					    7_5_1,
					    7_5_7,
					    7_6_1,
					    7_6_9,
					    7_7_3,
					    7_8_7,
					    7_9_7,
					    8_0_9,
					    8_1_1,
					    8_2_1,
					    8_2_3,
					    8_2_7,
					    8_2_9,
					    8_3_9,
					    8_5_3,
					    8_5_7,
					    8_5_9,
					    8_6_3,
					    8_7_7,
					    8_8_1,
					    8_8_3,
					    8_8_7,
					    9_0_7,
					    9_1_1,
					    9_1_9,
					    9_2_9,
					    9_3_7,
					    9_4_1,
					    9_4_7,
					    9_5_3,
					    9_6_7,
					    9_7_1,
					    9_7_7,
					    9_8_3,
					    9_9_1,
					    9_9_7,
					]

					if num in low_primes:
										return True

					for prime in low_primes:
										if (num % prime) == 0:
															return False

					return rabin_miller(SCREAMING_SNAKE_CASE__			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int = 1_0_2_4			):



					"""simple docstring"""





					while True:
										snake_case_					:		Tuple 					=					random.randrange(2 ** (keysize - 1)				,    2 ** (keysize)			)
										if is_prime_low_num(SCREAMING_SNAKE_CASE__			):
															return num


if __name__ == "__main__":
			a_			   =					generate_large_prime()
			print(('''Prime number:''', num))
			print(('''is_prime_low_num:''', is_prime_low_num(num)))




