

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()
lowerCAmelCase_			      =      logging.get_logger(__name__)

lowerCAmelCase_			      =      {
    '''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''',
}
lowerCAmelCase_			      =      [
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			):
						for attribute in key.split('''.'''			):
												snake_case_  =      getattr(UpperCAmelCase_    ,						UpperCAmelCase_			)

						if weight_type is not None:
												snake_case_  =      getattr(UpperCAmelCase_    ,						UpperCAmelCase_			).shape
						else:
												snake_case_  =      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_  =      value
						elif weight_type == "weight_g":
												snake_case_  =      value
						elif weight_type == "weight_v":
												snake_case_  =      value
						elif weight_type == "bias":
												snake_case_  =      value
						else:
												snake_case_  =      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__    ,						SCREAMING_SNAKE_CASE__			):
						snake_case_  =      []
						snake_case_  =      fairseq_model.state_dict()

						snake_case_  =      hf_model.feature_extractor

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

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

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

						return proj_weight


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			):
						snake_case_  =      full_name.split('''conv_layers.'''			)[-1]
						snake_case_  =      name.split('''.'''			)
						snake_case_  =      int(items[0]			)
						snake_case_  =      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_  =      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_  =      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_  =      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_  =      value
																		logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''			)
						else:
												unused_weights.append(UpperCAmelCase_			)


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__			):
						snake_case_  =      emb.weight.shape
						snake_case_  =      nn.Linear(UpperCAmelCase_    ,						UpperCAmelCase_    ,						bias=UpperCAmelCase_			)
						snake_case_  =      emb.weight.data
						return lin_layer


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__			):
						with open(UpperCAmelCase_    ,						'''r'''    ,						encoding='''utf-8'''			) as f:
												snake_case_  =      f.readlines()
												snake_case_  =      [line.split(''' '''			)[0] for line in lines]

						snake_case_  =      len(UpperCAmelCase_			)

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

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


@torch.no_grad()
def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						):
						snake_case_  =      WavaVecaConfig.from_pretrained(UpperCAmelCase_			)
						snake_case_  =      SpeechaTextaConfig.from_pretrained(
						    UpperCAmelCase_    ,						vocab_size=UpperCAmelCase_    ,						decoder_layers=UpperCAmelCase_    ,						do_stable_layer_norm=UpperCAmelCase_			)

						snake_case_  =      WavaVecaFeatureExtractor(
						    feature_size=1    ,						sampling_rate=16000    ,						padding_value=0    ,						do_normalize=UpperCAmelCase_    ,						return_attention_mask=UpperCAmelCase_    ,						)

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

						# set weights for wav2vec2 encoder
						snake_case_  =      WavaVecaModel(UpperCAmelCase_			)
						snake_case_  =      recursively_load_weights_wavaveca(model.encoder    ,						UpperCAmelCase_			)

						snake_case_  =      SpeechaTextaForCausalLM(UpperCAmelCase_			)
						snake_case_  =      hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()    ,						strict=UpperCAmelCase_			)

						# set output linear layer
						unexpected_keys.remove('''embed_out'''			)
						snake_case_  =      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_  =      SpeechEncoderDecoderModel(encoder=UpperCAmelCase_    ,						decoder=UpperCAmelCase_			)
						snake_case_  =      False

						# add projection layer
						snake_case_  =      nn.Parameter(projection_layer.weight			)
						snake_case_  =      nn.Parameter(projection_layer.bias			)

						snake_case_  =      create_vocab_dict(UpperCAmelCase_			)

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

						snake_case_  =      SpeechaTextaTokenizer(os.path.join(UpperCAmelCase_    ,						'''vocab.json'''			)			)
						tokenizer.save_pretrained(UpperCAmelCase_			)

						snake_case_  =      hf_wavavec.config.to_dict()
						snake_case_  =      tokenizer.pad_token_id
						snake_case_  =      tokenizer.bos_token_id
						snake_case_  =      tokenizer.eos_token_id
						snake_case_  =      '''speech_to_text_2'''
						snake_case_  =      '''wav2vec2'''

						snake_case_  =      SpeechEncoderDecoderConfig.from_dict(UpperCAmelCase_			)

						hf_wavavec.save_pretrained(UpperCAmelCase_			)
						feature_extractor.save_pretrained(UpperCAmelCase_			)


if __name__ == "__main__":
					lowerCAmelCase_			      =      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=1_02_24, type=int, help='''Vocab size of decoder''')
					parser.add_argument('''--num_decoder_layers''', default=7, type=int, help='''Number of decoder layers''')

					lowerCAmelCase_			      =      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,
					)

import string

import numpy
def 							SCREAMING_SNAKE_CASE_	(					UpperCAmelCase_	:     int			,							UpperCAmelCase_	:     int				)			->						int:
       return b if a == 0 else greatest_common_divisor(b % a			,							UpperCAmelCase_				)


class 			lowercase_		:
       __lowerCamelCase				       =						string.ascii_uppercase + string.digits
       # This cipher takes alphanumerics into account
       # i.e. a total of 36 characters

       # take x and return x % len(key_string)
       __lowerCamelCase				       =						numpy.vectorize(lambda A       : x % 3_6       )

       __lowerCamelCase				       =						numpy.vectorize(A       )


       def __init__(    self						,       __A				)						->    None:
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=self.modulus(__A				)  # mod36 calc's on the encrypt key
              self.check_determinant()  # validate the determinant of the encryption key
              SCREAMING_SNAKE_CASE_							:				Dict		=encrypt_key.shape[0]


       def 	_snake_case				(    self						,       __A				)						->    int:
              return self.key_string.index(__A				)


       def 	_snake_case				(    self						,       __A				)						->    str:
              return self.key_string[round(__A				)]


       def 	_snake_case				(    self				)						->    None:
              SCREAMING_SNAKE_CASE_							:				List[str]		=round(numpy.linalg.det(self.encrypt_key				)				)

              if det < 0:
                     SCREAMING_SNAKE_CASE_							:				Optional[int]		=det % len(self.key_string				)

              SCREAMING_SNAKE_CASE_							:				List[Any]		=len(self.key_string				)
              if greatest_common_divisor(__A						,       len(self.key_string				)				) != 1:
                     SCREAMING_SNAKE_CASE_							:				Any		=(
                         F'determinant modular {req_l} of encryption key({det}) '
                         F'is not co prime w.r.t {req_l}.\nTry another key.'
                     )
                     raise ValueError(__A				)


       def 	_snake_case				(    self						,       __A				)						->    str:
              SCREAMING_SNAKE_CASE_							:				List[Any]		=[char for char in text.upper() if char in self.key_string]

              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=chars[-1]
              while len(__A				) % self.break_key != 0:
                     chars.append(__A				)

              return "".join(__A				)


       def 	_snake_case				(    self						,       __A				)						->    str:
              SCREAMING_SNAKE_CASE_							:				Dict		=self.process_text(text.upper()				)
              SCREAMING_SNAKE_CASE_							:				Dict		=''''''

              for i in range(0						,       len(__A				) - self.break_key + 1						,       self.break_key				):
                     SCREAMING_SNAKE_CASE_							:				Any		=text[i : i + self.break_key]
                     SCREAMING_SNAKE_CASE_							:				Optional[int]		=[self.replace_letters(__A				) for char in batch]
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=numpy.array([vec]				).T
                     SCREAMING_SNAKE_CASE_							:				List[str]		=self.modulus(self.encrypt_key.dot(__A				)				).T.tolist()[
                         0
                     ]
                     SCREAMING_SNAKE_CASE_							:				List[Any]		=''''''.join(
                         self.replace_digits(__A				) for num in batch_encrypted				)
                     encrypted += encrypted_batch

              return encrypted


       def 	_snake_case				(    self				)						->    numpy.ndarray:
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=round(numpy.linalg.det(self.encrypt_key				)				)

              if det < 0:
                     SCREAMING_SNAKE_CASE_							:				Optional[Any]		=det % len(self.key_string				)
              SCREAMING_SNAKE_CASE_							:				List[Any]		=None
              for i in range(len(self.key_string				)				):
                     if (det * i) % len(self.key_string				) == 1:
                            SCREAMING_SNAKE_CASE_							:				List[str]		=i
                            break

              SCREAMING_SNAKE_CASE_							:				List[str]		=(
                  det_inv
                  * numpy.linalg.det(self.encrypt_key				)
                  * numpy.linalg.inv(self.encrypt_key				)
              )

              return self.to_int(self.modulus(__A				)				)





       def 	_snake_case				(    self						,       __A				)						->    str:
              SCREAMING_SNAKE_CASE_							:				int		=self.make_decrypt_key()
              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=self.process_text(text.upper()				)
              SCREAMING_SNAKE_CASE_							:				Any		=''''''

              for i in range(0						,       len(__A				) - self.break_key + 1						,       self.break_key				):
                     SCREAMING_SNAKE_CASE_							:				List[str]		=text[i : i + self.break_key]
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=[self.replace_letters(__A				) for char in batch]
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=numpy.array([vec]				).T
                     SCREAMING_SNAKE_CASE_							:				str		=self.modulus(decrypt_key.dot(__A				)				).T.tolist()[0]
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=''''''.join(
                         self.replace_digits(__A				) for num in batch_decrypted				)
                     decrypted += decrypted_batch

              return decrypted






def 							SCREAMING_SNAKE_CASE_	(					)			->						None:
       SCREAMING_SNAKE_CASE_							:				List[str]		=int(input('''Enter the order of the encryption key: '''				)				)
       SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=[]

       print('''Enter each row of the encryption key with space separated integers'''				)
       for _ in range(UpperCAmelCase_				):
              SCREAMING_SNAKE_CASE_							:				Tuple		=[int(UpperCAmelCase_				) for x in input().split()]
              hill_matrix.append(UpperCAmelCase_				)

       SCREAMING_SNAKE_CASE_							:				Optional[int]		=HillCipher(numpy.array(UpperCAmelCase_				)				)

       print('''Would you like to encrypt or decrypt some text? (1 or 2)'''				)
       SCREAMING_SNAKE_CASE_							:				Dict		=input('''\n1. Encrypt\n2. Decrypt\n'''				)
       if option == "1":
              SCREAMING_SNAKE_CASE_							:				List[Any]		=input('''What text would you like to encrypt?: '''				)
              print('''Your encrypted text is:'''				)
              print(hc.encrypt(UpperCAmelCase_				)				)
       elif option == "2":
              SCREAMING_SNAKE_CASE_							:				Any		=input('''What text would you like to decrypt?: '''				)
              print('''Your decrypted text is:'''				)
              print(hc.decrypt(UpperCAmelCase_				)				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 main()
