




import argparse
import struct
import unittest





class     lowerCamelCase__:
      def __init__(				self: Optional[int]    ,       UpperCamelCase_: Dict   ):
             __lowerCamelCase   =						data

             # Initialize hash values
             __lowerCamelCase   =						[
                 0x6a09e667,
                 0xbb67ae85,
                 0x3c6ef372,
                 0xa54ff53a,
                 0x510e527f,
                 0x9b05688c,
                 0x1f83d9ab,
                 0x5be0cd19,
             ]

             # Initialize round constants
             __lowerCamelCase   =						[
                 0x428a2f98,
                 0x71374491,
                 0xb5c0fbcf,
                 0xe9b5dba5,
                 0x3956c25b,
                 0x59f111f1,
                 0x923f82a4,
                 0xab1c5ed5,
                 0xd807aa98,
                 0x12835b01,
                 0x243185be,
                 0x550c7dc3,
                 0x72be5d74,
                 0x80deb1fe,
                 0x9bdc06a7,
                 0xc19bf174,
                 0xe49b69c1,
                 0xefbe4786,
                 0x0fc19dc6,
                 0x240ca1cc,
                 0x2de92c6f,
                 0x4a7484aa,
                 0x5cb0a9dc,
                 0x76f988da,
                 0x983e5152,
                 0xa831c66d,
                 0xb00327c8,
                 0xbf597fc7,
                 0xc6e00bf3,
                 0xd5a79147,
                 0x06ca6351,
                 0x14292967,
                 0x27b70a85,
                 0x2e1b2138,
                 0x4d2c6dfc,
                 0x53380d13,
                 0x650a7354,
                 0x766a0abb,
                 0x81c2c92e,
                 0x92722c85,
                 0xa2bfe8a1,
                 0xa81a664b,
                 0xc24b8b70,
                 0xc76c51a3,
                 0xd192e819,
                 0xd6990624,
                 0xf40e3585,
                 0x106aa070,
                 0x19a4c116,
                 0x1e376c08,
                 0x2748774c,
                 0x34b0bcb5,
                 0x391c0cb3,
                 0x4ed8aa4a,
                 0x5b9cca4f,
                 0x682e6ff3,
                 0x748f82ee,
                 0x78a5636f,
                 0x84c87814,
                 0x8cc70208,
                 0x90befffa,
                 0xa4506ceb,
                 0xbef9a3f7,
                 0xc67178f2,
             ]

             __lowerCamelCase   =						self.preprocessing(self.data   )
             self.final_hash()
      @staticmethod
      def 			lowerCAmelCase__						(				UpperCamelCase_: Union[str, Any]   ):
             __lowerCamelCase   =						B"""\x80""" + (B"""\x00""" * (63 - (len(__lowerCAmelCase   ) + 8) % 64))
             __lowerCamelCase   =						struct.pack(""">Q"""    ,       (len(__lowerCAmelCase   ) * 8)   )
             return data + padding + big_endian_integer
      def 			lowerCAmelCase__						(				self: str   ):
             __lowerCamelCase   =						[
                 self.preprocessed_data[x : x + 64]
                 for x in range(0    ,       len(self.preprocessed_data   )    ,       64   )
             ]

             for block in self.blocks:
                    # Convert the given block into a list of 4 byte integers
                    __lowerCamelCase   =						list(struct.unpack(""">16L"""    ,       __lowerCAmelCase   )   )
                    # add 48 0-ed integers
                    words += [0] * 48

                    __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase   =						self.hashes

                    for index in range(0    ,       64   ):
                           if index > 15:
                                  # modify the zero-ed indexes at the end of the array
                                  __lowerCamelCase   =						(
                                      self.ror(words[index - 15]    ,       7   )
                                      ^ self.ror(words[index - 15]    ,       18   )
                                      ^ (words[index - 15] >> 3)
                                  )
                                  __lowerCamelCase   =						(
                                      self.ror(words[index - 2]    ,       17   )
                                      ^ self.ror(words[index - 2]    ,       19   )
                                      ^ (words[index - 2] >> 10)
                                  )

                                  __lowerCamelCase   =						(
                                      words[index - 16] + sa + words[index - 7] + sa
                                  ) % 0x100000000

                           # Compression
                           __lowerCamelCase   =						self.ror(__lowerCAmelCase    ,       6   ) ^ self.ror(__lowerCAmelCase    ,       11   ) ^ self.ror(__lowerCAmelCase    ,       25   )
                           __lowerCamelCase   =						(e & f) ^ ((~e & 0xffffffff) & g)
                           __lowerCamelCase   =						(
                               h + sa + ch + self.round_constants[index] + words[index]
                           ) % 0x100000000
                           __lowerCamelCase   =						self.ror(__lowerCAmelCase    ,       2   ) ^ self.ror(__lowerCAmelCase    ,       13   ) ^ self.ror(__lowerCAmelCase    ,       22   )
                           __lowerCamelCase   =						(a & b) ^ (a & c) ^ (b & c)
                           __lowerCamelCase   =						(sa + maj) % 0x100000000

                           __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase   =						(
                               g,
                               f,
                               e,
                               ((d + tempa) % 0x100000000),
                               c,
                               b,
                               a,
                               ((tempa + tempa) % 0x100000000),
                           )

                    __lowerCamelCase   =						[a, b, c, d, e, f, g, h]

                    # Modify final values
                    __lowerCamelCase   =						[
                        ((element + mutated_hash_values[index]) % 0x100000000)
                        for index, element in enumerate(self.hashes   )
                    ]

             __lowerCamelCase   =						"""""".join([hex(__lowerCAmelCase   )[2:].zfill(8   ) for value in self.hashes]   )




      def 			lowerCAmelCase__						(				self: Dict    ,       UpperCamelCase_: Union[str, Any]    ,       UpperCamelCase_: Dict   ):
             return 0xffffffff & (value << (32 - rotations)) | (value >> rotations)





class     lowerCamelCase__(					unittest.TestCase):
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             import hashlib

             __lowerCamelCase   =						bytes("""Test String"""    ,       """utf-8"""   )
             self.assertEqual(SHAaaa(__lowerCAmelCase   ).hash    ,       hashlib.shaaaa(__lowerCAmelCase   ).hexdigest()   )




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       import doctest

       doctest.testmod()

       __lowerCamelCase   =						argparse.ArgumentParser()
       parser.add_argument(
           """-s"""  ,			"""--string"""  ,			dest="""input_string"""  ,			default="""Hello World!! Welcome to Cryptography"""  ,			help="""Hash the string"""  ,			)
       parser.add_argument(
           """-f"""  ,			"""--file"""  ,			dest="""input_file"""  ,			help="""Hash contents of a file"""	)

       __lowerCamelCase   =						parser.parse_args()

       __lowerCamelCase   =						args.input_string

       # hash input should be a bytestring
       if args.input_file:
              with open(args.input_file  ,			"""rb"""	) as f:
                     __lowerCamelCase   =						f.read()
       else:
              __lowerCamelCase   =						bytes(__snake_case  ,			"""utf-8"""	)

       print(SHAaaa(__snake_case	).hash	)


if __name__ == "__main__":
       main()








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 lowerCAmelCase__(__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,__snake_case							)				->      Optional[Any]:







	'''simple docstring'''







	for attribute in key.split('''.'''							):
		lowerCamelCase__								=		getattr(__snake_case       ,__snake_case							)

	if weight_type is not None:
		lowerCamelCase__								=		getattr(__snake_case       ,__snake_case							).shape
	else:
		lowerCamelCase__								=		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":
		lowerCamelCase__								=		value
	elif weight_type == "weight_g":
		lowerCamelCase__								=		value
	elif weight_type == "weight_v":
		lowerCamelCase__								=		value
	elif weight_type == "bias":
		lowerCamelCase__								=		value
	else:
		lowerCamelCase__								=		value

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





def lowerCAmelCase__(__snake_case       ,__snake_case							)				->      int:







	'''simple docstring'''







	lowerCamelCase__								=		[]
	lowerCamelCase__								=		fairseq_model.state_dict()

	lowerCamelCase__								=		hf_model.feature_extractor

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

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

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

	return proj_weight





def lowerCAmelCase__(__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,__snake_case							)				->      Optional[int]:







	'''simple docstring'''







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





def lowerCAmelCase__(__snake_case							)				->      Any:







	'''simple docstring'''







	lowerCamelCase__				,	lowerCamelCase__								=		emb.weight.shape
	lowerCamelCase__								=		nn.Linear(__snake_case       ,__snake_case       ,bias=__snake_case							)
	lowerCamelCase__								=		emb.weight.data
	return lin_layer





def lowerCAmelCase__(__snake_case							)				->      Any:







	'''simple docstring'''







	with open(__snake_case       ,'''r'''       ,encoding='''utf-8'''							) as f:
		lowerCamelCase__								=		f.readlines()
		lowerCamelCase__								=		[line.split(''' '''							)[0] for line in lines]

	lowerCamelCase__								=		len(__snake_case							)

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

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





@torch.no_grad()
def lowerCAmelCase__(__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,__snake_case       ,)				->      Optional[Any]:







	'''simple docstring'''







	lowerCamelCase__								=		WavaVecaConfig.from_pretrained(__snake_case							)
	lowerCamelCase__								=		SpeechaTextaConfig.from_pretrained(
	    __snake_case       ,vocab_size=__snake_case       ,decoder_layers=__snake_case       ,do_stable_layer_norm=__snake_case							)

	lowerCamelCase__								=		WavaVecaFeatureExtractor(
	    feature_size=1       ,sampling_rate=16000       ,padding_value=0       ,do_normalize=__snake_case       ,return_attention_mask=__snake_case       ,)

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

	# set weights for wav2vec2 encoder
	lowerCamelCase__								=		WavaVecaModel(__snake_case							)
	lowerCamelCase__								=		recursively_load_weights_wavaveca(model.encoder       ,__snake_case							)

	lowerCamelCase__								=		SpeechaTextaForCausalLM(__snake_case							)
	lowerCamelCase__				,	lowerCamelCase__								=		hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()       ,strict=__snake_case							)

	# set output linear layer
	unexpected_keys.remove('''embed_out'''							)
	lowerCamelCase__								=		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}'							)

	lowerCamelCase__								=		SpeechEncoderDecoderModel(encoder=__snake_case       ,decoder=__snake_case							)
	lowerCamelCase__								=		False

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

	lowerCamelCase__								=		create_vocab_dict(__snake_case							)

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

	lowerCamelCase__								=		SpeechaTextaTokenizer(os.path.join(__snake_case       ,'''vocab.json'''							)							)
	tokenizer.save_pretrained(__snake_case							)

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

	lowerCamelCase__								=		SpeechEncoderDecoderConfig.from_dict(__snake_case							)

	hf_wavavec.save_pretrained(__snake_case							)
	feature_extractor.save_pretrained(__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=10_224, 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,
			)



