




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				Dict:
						_UpperCAmelCase      =			[]
						if len(snake_case       ) == 1:
												return [nums.copy()]
						for _ in range(len(snake_case       )       ):
												_UpperCAmelCase      =			nums.pop(0       )
												_UpperCAmelCase      =			permute(snake_case       )
												for perm in permutations:
																		perm.append(snake_case       )
												result.extend(snake_case       )
												nums.append(snake_case       )
						return result




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				Dict:






						def backtrack(snake_case       ):
												if start == len(snake_case       ) - 1:
																		output.append(nums[:]       )
												else:
																		for i in range(snake_case			,     len(snake_case       )       ):
																								_UpperCAmelCase    ,					_UpperCAmelCase      =			nums[i], nums[start]
																								backtrack(start + 1       )
																								_UpperCAmelCase    ,					_UpperCAmelCase      =			nums[i], nums[start]  # backtrack

						_UpperCAmelCase      =			[]
						backtrack(0       )
						return output


if __name__ == "__main__":
				import doctest

				# use res to print the data in permute2 function
				a													=			permutea([1, 2, 3])
				print(res)
				doctest.testmod()





import argparse

import fairseq
import torch

from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, 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",
    "encoder.layer_norm_for_extract": "layer_norm_for_extract",
    "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",
    "label_embs_concat": "label_embeddings_concat",
    "mask_emb": "masked_spec_embed",
    "spk_proj": "speaker_proj",
}
a													=			[
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
    "label_embeddings_concat",
    "speaker_proj",
    "layer_norm_for_extract",
]




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case       )						->				List[str]:
						for attribute in key.split("""."""       ):
												_UpperCAmelCase      =			getattr(snake_case			,     snake_case       )

						if weight_type is not None:
												_UpperCAmelCase      =			getattr(snake_case			,     snake_case       ).shape
						else:
												_UpperCAmelCase      =			hf_pointer.shape

						if hf_shape != value.shape:
												raise ValueError(
												    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      =			value
						elif weight_type == "weight_g":
												_UpperCAmelCase      =			value
						elif weight_type == "weight_v":
												_UpperCAmelCase      =			value
						elif weight_type == "bias":
												_UpperCAmelCase      =			value
						else:
												_UpperCAmelCase      =			value

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




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				Optional[int]:
						_UpperCAmelCase      =			[]
						_UpperCAmelCase      =			fairseq_model.state_dict()

						_UpperCAmelCase      =			hf_model.unispeech_sat.feature_extractor

						for name, value in fairseq_dict.items():
												_UpperCAmelCase      =			False
												if "conv_layers" in name:
																		load_conv_layer(
																		    snake_case			,     snake_case			,     snake_case			,     snake_case			,     hf_model.config.feat_extract_norm == """group"""			,     )
																		_UpperCAmelCase      =			True
												else:
																		for key, mapped_key in MAPPING.items():
																								_UpperCAmelCase      =			"""unispeech_sat.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
																								if key in name or key.split("""w2v_model."""       )[-1] == name.split("""."""       )[0]:
																														if "layer_norm_for_extract" in name and (".".join(name.split("""."""       )[:-1]       ) != key):
																																				# special case since naming is very similar
																																				continue
																														_UpperCAmelCase      =			True
																														if "*" in mapped_key:
																																				_UpperCAmelCase      =			name.split(snake_case       )[0].split("""."""       )[-2]
																																				_UpperCAmelCase      =			mapped_key.replace("""*"""			,     snake_case       )
																														if "weight_g" in name:
																																				_UpperCAmelCase      =			"""weight_g"""
																														elif "weight_v" in name:
																																				_UpperCAmelCase      =			"""weight_v"""
																														elif "bias" in name:
																																				_UpperCAmelCase      =			"""bias"""
																														elif "weight" in name:
																																				# TODO: don't match quantizer.weight_proj
																																				_UpperCAmelCase      =			"""weight"""
																														else:
																																				_UpperCAmelCase      =			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}"       )




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case       )						->				str:
						_UpperCAmelCase      =			full_name.split("""conv_layers."""       )[-1]
						_UpperCAmelCase      =			name.split("""."""       )
						_UpperCAmelCase      =			int(items[0]       )
						_UpperCAmelCase      =			int(items[1]       )

						if type_id == 0:
												if "bias" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
																								raise ValueError(
																								    f"{full_name} has size {value.shape}, but"
																								    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."       )
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."       )
												elif "weight" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
																								raise ValueError(
																								    f"{full_name} has size {value.shape}, but"
																								    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."       )
																		_UpperCAmelCase      =			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:
																		if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
																								raise ValueError(
																								    f"{full_name} has size {value.shape}, but"
																								    f" {feature_extractor[layer_id].layer_norm.bias.data.shape} was found."       )
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."       )
												elif "weight" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
																								raise ValueError(
																								    f"{full_name} has size {value.shape}, but"
																								    f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."       )
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."       )
						else:
												unused_weights.append(snake_case       )




@torch.no_grad()
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case=None			,     snake_case=None			,     snake_case=True       )						->				List[Any]:
						if config_path is not None:
												_UpperCAmelCase      =			UniSpeechSatConfig.from_pretrained(snake_case       )
						else:
												_UpperCAmelCase      =			UniSpeechSatConfig()

						_UpperCAmelCase      =			""""""

						if is_finetuned:
												_UpperCAmelCase      =			UniSpeechSatForCTC(snake_case       )
						else:
												_UpperCAmelCase      =			UniSpeechSatForPreTraining(snake_case       )

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

						recursively_load_weights(snake_case			,     snake_case       )

						hf_wavavec.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("--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_unispeech_sat_checkpoint(
				    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
				)