
'''simple docstring'''






import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    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    UpperCAmelCase							(  UpperCAmelCase__							:							Dict       ,							UpperCAmelCase__							:							List[str]       ,							UpperCAmelCase__							:							int       ,							UpperCAmelCase__							:							List[str]       ,							UpperCAmelCase__							:							int):
				for attribute in key.split('.'):
								lowerCamelCase					:			List[Any]									= getattr(UpperCAmelCase__       ,							UpperCAmelCase__)

				if weight_type is not None:
								lowerCamelCase					:			List[Any]									= getattr(UpperCAmelCase__       ,							UpperCAmelCase__).shape
				else:
								lowerCamelCase					:			Dict									= 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					:			List[str]									= value
				elif weight_type == "weight_g":
								lowerCamelCase					:			int									= value
				elif weight_type == "weight_v":
								lowerCamelCase					:			Any									= value
				elif weight_type == "bias":
								lowerCamelCase					:			Any									= value
				else:
								lowerCamelCase					:			List[Any]									= value

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





def    UpperCAmelCase							(  UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							str):
				lowerCamelCase					:			Any									= []
				lowerCamelCase					:			List[str]									= fairseq_model.state_dict()

				lowerCamelCase					:			Optional[Any]									= hf_model.feature_extractor
				lowerCamelCase					:			Tuple									= hf_model.adapter

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

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





def    UpperCAmelCase							(  UpperCAmelCase__							:							Optional[Any]       ,							UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							int       ,							UpperCAmelCase__							:							Tuple       ,							UpperCAmelCase__							:							Tuple):
				lowerCamelCase					:			Optional[int]									= full_name.split('conv_layers.')[-1]
				lowerCamelCase					:			Any									= name.split('.')
				lowerCamelCase					:			Dict									= int(items[0])
				lowerCamelCase					:			int									= 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					:			List[str]									= 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					:			Optional[int]									= 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					:			Optional[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.'''
												)
												lowerCamelCase					:			List[Any]									= value
												logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''')
				else:
								unused_weights.append(UpperCAmelCase__)





def    UpperCAmelCase							(  UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							Optional[int]       ,							UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							List[Any]):
				lowerCamelCase					:			str									= full_name.split('adaptor.')[-1]
				lowerCamelCase					:			int									= name.split('.')

				if items[1].isdigit():
								lowerCamelCase					:			Dict									= int(items[1])
				else:
								lowerCamelCase					:			Optional[Any]									= None

				if "adaptor" not in full_name:
								if "proj_ln" in full_name:
												# has to be layer norm
												if "bias" in name:
																assert (
																    value.shape == adapter.proj_layer_norm.bias.data.shape
																), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.'''
																lowerCamelCase					:			Tuple									= value
																logger.info(F'''Adapter proj layer norm bias was initialized from {full_name}.''')
												if "weight" in name:
																assert (
																    value.shape == adapter.proj_layer_norm.weight.data.shape
																), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.'''
																lowerCamelCase					:			List[str]									= value
								else:
												# has to be projection layer
												if "bias" in name:
																assert (
																    value.shape == adapter.proj.bias.data.shape
																), F'''{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.'''
																lowerCamelCase					:			List[Any]									= value
																logger.info(F'''Adapter proj layer bias was initialized from {full_name}.''')
												if "weight" in name:
																assert (
																    value.shape == adapter.proj.weight.data.shape
																), F'''{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.'''
																lowerCamelCase					:			Tuple									= value
																logger.info(F'''Adapter proj layer weight was initialized from {full_name}.''')
				elif isinstance(UpperCAmelCase__       ,							UpperCAmelCase__):
								if "bias" in name:
												assert (
												    value.shape == adapter.layers[layer_id].conv.bias.data.shape
												), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.'''
												lowerCamelCase					:			Any									= value
												logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''')
								elif "weight" in name:
												assert (
												    value.shape == adapter.layers[layer_id].conv.weight.data.shape
												), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.'''
												lowerCamelCase					:			int									= value
												logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''')
				else:
								unused_weights.append(UpperCAmelCase__)





def    UpperCAmelCase							(  UpperCAmelCase__							:							Tuple):
				lowerCamelCase					:			Dict									= emb.weight.shape
				lowerCamelCase					:			int									= nn.Linear(UpperCAmelCase__       ,							UpperCAmelCase__       ,							bias=UpperCAmelCase__)
				lowerCamelCase					:			Tuple									= emb.weight.data
				return lin_layer





@torch.no_grad()
def    UpperCAmelCase							(  UpperCAmelCase__							:							int       ,							UpperCAmelCase__							:							int       ,							UpperCAmelCase__							:							Optional[int]       ,							UpperCAmelCase__							:							Optional[Any]       ,							UpperCAmelCase__							:							List[str]       ,							UpperCAmelCase__							:							int       ,							UpperCAmelCase__							:							List[Any]       ,							UpperCAmelCase__							:							str       ,							UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							Any       ,							UpperCAmelCase__							:							Dict       ,							):
				lowerCamelCase					:			str									= WavaVecaConfig.from_pretrained(
				    UpperCAmelCase__       ,							add_adapter=UpperCAmelCase__       ,							adapter_stride=UpperCAmelCase__       ,							adapter_kernel_size=UpperCAmelCase__       ,							use_auth_token=UpperCAmelCase__       ,							output_hidden_size=UpperCAmelCase__       ,							)
				lowerCamelCase					:			List[Any]									= MBartConfig.from_pretrained(UpperCAmelCase__)

				# load model
				lowerCamelCase					:			Tuple									= fairseq.checkpoint_utils.load_model_ensemble_and_task(
				    [checkpoint_path]       ,							arg_overrides={
				        'config_yaml': config_yaml_path,
				        'data': '/'.join(dict_path.split('/')[:-1]),
				        'w2v_path': checkpoint_path,
				        'load_pretrained_decoder_from': None,
				    }       ,							)
				lowerCamelCase					:			Union[str, Any]									= model[0].eval()

				# load feature extractor
				lowerCamelCase					:			int									= WavaVecaFeatureExtractor.from_pretrained(UpperCAmelCase__       ,							use_auth_token=UpperCAmelCase__)

				# set weights for wav2vec2 encoder
				lowerCamelCase					:			str									= WavaVecaModel(UpperCAmelCase__)

				recursively_load_weights_wavaveca(model.encoder       ,							UpperCAmelCase__)

				# load decoder weights
				lowerCamelCase					:			int									= MBartForCausalLM(UpperCAmelCase__)
				lowerCamelCase					:			Union[str, Any]									= hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()       ,							strict=UpperCAmelCase__)
				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					:			List[str]									= SpeechEncoderDecoderModel(encoder=UpperCAmelCase__       ,							decoder=UpperCAmelCase__)
				lowerCamelCase					:			Dict									= False

				lowerCamelCase					:			Union[str, Any]									= MBartaaTokenizer(UpperCAmelCase__)
				tokenizer.save_pretrained(UpperCAmelCase__)

				lowerCamelCase					:			Any									= hf_wavavec.config.to_dict()
				lowerCamelCase					:			str									= tokenizer.pad_token_id
				lowerCamelCase					:			Tuple									= tokenizer.bos_token_id
				lowerCamelCase					:			Tuple									= tokenizer.eos_token_id
				lowerCamelCase					:			Optional[int]									= 'mbart50'
				lowerCamelCase					:			Any									= 'wav2vec2'

				lowerCamelCase					:			List[str]									= tokenizer.eos_token_id
				lowerCamelCase					:			str									= 25_00_04
				lowerCamelCase					:			Dict									= tokenizer.eos_token_id

				lowerCamelCase					:			str									= SpeechEncoderDecoderConfig.from_dict(UpperCAmelCase__)

				hf_wavavec.save_pretrained(UpperCAmelCase__)
				feature_extractor.save_pretrained(UpperCAmelCase__)


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('--config_yaml_path', default=None, type=str, help='Path to yaml file of fine-tuned model')
					parser.add_argument(
					    '--encoder_config_path',
					    default='facebook/wav2vec2-xls-r-1b',
					    type=str,
					    help='Path to hf encoder wav2vec2 checkpoint config',
					)
					parser.add_argument(
					    '--decoder_config_path',
					    default='facebook/mbart-large-50-one-to-many-mmt',
					    type=str,
					    help='Path to hf decoder checkpoint config',
					)
					parser.add_argument('--add_adapter', default=True, type=bool, help='whethere to add model adapter layers')
					parser.add_argument('--adapter_stride', default=2, type=int, help='stride of adapter layers')
					parser.add_argument('--adapter_kernel_size', default=3, type=int, help='kernel size of adapter layers')
					parser.add_argument('--encoder_output_dim', default=1024, type=int, help='encoder output dim')
					parser.add_argument('--start_token_id', default=25_0004, type=int, help='`decoder_start_token_id` of model config')

					A			      =      parser.parse_args()
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.dict_path,
					    args.config_yaml_path,
					    encoder_config_path=args.encoder_config_path,
					    decoder_config_path=args.decoder_config_path,
					    add_adapter=args.add_adapter,
					    adapter_kernel_size=args.adapter_kernel_size,
					    adapter_stride=args.adapter_stride,
					    decoder_start_token_id=args.start_token_id,
					    encoder_output_dim=args.encoder_output_dim,
					)







'''simple docstring'''






def    UpperCAmelCase							(  UpperCAmelCase__							:							int = 10_00):
				lowerCamelCase					:			Optional[Any]									= 2**power
				lowerCamelCase					:			str									= str(UpperCAmelCase__)
				lowerCamelCase					:			Union[str, Any]									= list(UpperCAmelCase__)
				lowerCamelCase					:			Optional[Any]									= 0

				for i in list_num:
								sum_of_num += int(UpperCAmelCase__)

				return sum_of_num


if __name__ == "__main__":
					A			      =      int(input('Enter the power of 2: ').strip())
					print('2 ^ ', power, ' = ', 2**power)
					A			      =      solution(power)
					print('Sum of the digits is: ', result)
