


'''simple docstring'''



import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    HubertConfig,
    HubertForCTC,
    HubertModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    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',
    'w2v_encoder.proj': 'lm_head',
    'mask_emb': 'masked_spec_embed',
}







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					):
			for attribute in key.split("""."""					):
						UpperCAmelCase__  :					List[Any]        =     getattr(_lowerCamelCase ,      _lowerCamelCase					)

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

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







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					):
			UpperCAmelCase__  :					List[Any]        =     []
			UpperCAmelCase__  :					Optional[int]        =     fairseq_model.state_dict()

			UpperCAmelCase__  :					Any        =     hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

			for name, value in fairseq_dict.items():
						UpperCAmelCase__  :					int        =     False
						if "conv_layers" in name:
									load_conv_layer(
									    _lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase ,      hf_model.config.feat_extract_norm == """group""" ,      )
									UpperCAmelCase__  :					Optional[Any]        =     True
						else:
									for key, mapped_key in MAPPING.items():
												UpperCAmelCase__  :					Dict        =     "hubert." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key

												if key in name or (key.split("""w2v_model."""					)[-1] == name.split("""."""					)[0] and not is_finetuned):
															UpperCAmelCase__  :					str        =     True
															if "*" in mapped_key:
																		UpperCAmelCase__  :					str        =     name.split(_lowerCamelCase					)[0].split("""."""					)[-2]
																		UpperCAmelCase__  :					Tuple        =     mapped_key.replace("""*""" ,      _lowerCamelCase					)
															if "weight_g" in name:
																		UpperCAmelCase__  :					List[str]        =     "weight_g"
															elif "weight_v" in name:
																		UpperCAmelCase__  :					int        =     "weight_v"
															elif "weight" in name:
																		UpperCAmelCase__  :					Tuple        =     "weight"
															elif "bias" in name:
																		UpperCAmelCase__  :					int        =     "bias"
															else:
																		UpperCAmelCase__  :					Dict        =     None
															set_recursively(_lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase					)
												continue
						if not is_used:
									unused_weights.append(_lowerCamelCase					)

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







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







@torch.no_grad()
def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__=None ,      UpperCamelCase__=None ,      UpperCamelCase__=True					):
			if config_path is not None:
						UpperCAmelCase__  :					List[Any]        =     HubertConfig.from_pretrained(_lowerCamelCase					)
			else:
						UpperCAmelCase__  :					List[Any]        =     HubertConfig()

			if is_finetuned:
						if dict_path:
									UpperCAmelCase__  :					Optional[int]        =     Dictionary.load(_lowerCamelCase					)

									# important change bos & pad token id since CTC symbol is <pad> and
									# not <s> as in fairseq
									UpperCAmelCase__  :					Dict        =     target_dict.pad_index
									UpperCAmelCase__  :					Any        =     target_dict.bos_index
									UpperCAmelCase__  :					Tuple        =     target_dict.eos_index
									UpperCAmelCase__  :					int        =     len(target_dict.symbols					)
									UpperCAmelCase__  :					Tuple        =     os.path.join(_lowerCamelCase ,      """vocab.json"""					)
									if not os.path.isdir(_lowerCamelCase					):
												logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(_lowerCamelCase					)					)
												return
									os.makedirs(_lowerCamelCase ,      exist_ok=_lowerCamelCase					)
									with open(_lowerCamelCase ,      """w""" ,      encoding="""utf-8"""					) as vocab_handle:
												json.dump(target_dict.indices ,      _lowerCamelCase					)
									UpperCAmelCase__  :					Optional[Any]        =     WavaVecaCTCTokenizer(
									    _lowerCamelCase ,      unk_token=target_dict.unk_word ,      pad_token=target_dict.pad_word ,      bos_token=target_dict.bos_word ,      eos_token=target_dict.eos_word ,      word_delimiter_token="""|""" ,      do_lower_case=_lowerCamelCase ,      )
									UpperCAmelCase__  :					Dict        =     True if config.feat_extract_norm == "layer" else False
									UpperCAmelCase__  :					Tuple        =     WavaVecaFeatureExtractor(
									    feature_size=1 ,      sampling_rate=1_6_0_0_0 ,      padding_value=0 ,      do_normalize=_lowerCamelCase ,      return_attention_mask=_lowerCamelCase ,      )
									UpperCAmelCase__  :					int        =     WavaVecaProcessor(feature_extractor=_lowerCamelCase ,      tokenizer=_lowerCamelCase					)
									processor.save_pretrained(_lowerCamelCase					)

						UpperCAmelCase__  :					str        =     HubertForCTC(_lowerCamelCase					)
			else:
						UpperCAmelCase__  :					int        =     HubertModel(_lowerCamelCase					)

			if is_finetuned:
						UpperCAmelCase__  :					Optional[Any]        =     fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path] ,      arg_overrides={"""data""": """/""".join(dict_path.split("""/"""					)[:-1]					)}					)
			else:
						UpperCAmelCase__  :					List[Any]        =     fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]					)

			UpperCAmelCase__  :					Optional[Any]        =     model[0].eval()

			recursively_load_weights(_lowerCamelCase ,      _lowerCamelCase ,      _lowerCamelCase					)

			hf_wavavec.save_pretrained(_lowerCamelCase					)


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_path', default=None, type=str, help='Path to hf config.json of model to convert')
		parser.add_argument(
		    '--not_finetuned', action='store_true', help='Whether the model to convert is a fine-tuned model or not'
		)
		__A	=parser.parse_args()
		convert_hubert_checkpoint(
		    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
		)



'''simple docstring'''



from itertools import permutations







def     _UpperCamelCase      (		UpperCamelCase__					):
			if num[3] % 2 != 0:
						return False

			if (num[2] + num[3] + num[4]) % 3 != 0:
						return False

			if num[5] % 5 != 0:
						return False

			UpperCAmelCase__  :					Optional[int]        =     [7, 1_1, 1_3, 1_7]
			for i, test in enumerate(UpperCamelCase__					):
						if (num[i + 4] * 1_0_0 + num[i + 5] * 1_0 + num[i + 6]) % test != 0:
									return False
			return True







def     _UpperCamelCase      (		UpperCamelCase__ = 1_0					):
			return sum(
			    int("""""".join(map(UpperCamelCase__ ,      UpperCamelCase__					)					)					)
			    for num in permutations(range(UpperCamelCase__					)					)
			    if is_substring_divisible(UpperCamelCase__					)					)


if __name__ == "__main__":
		print(f"""{solution() = }""")