



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 		a__      (		_UpperCamelCase      :			Optional[Any]			,_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			List[str]			,_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			str				):
   for attribute in key.split('''.'''				):
      __lowerCamelCase    				=     getattr(_UpperCamelCase			,_UpperCamelCase				)

   if weight_type is not None:
      __lowerCamelCase    				=     getattr(_UpperCamelCase			,_UpperCamelCase				).shape
   else:
      __lowerCamelCase    				=     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":
      __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 		a__      (		_UpperCamelCase      :			int			,_UpperCamelCase      :			List[str]				):
   __lowerCamelCase    				=     []
   __lowerCamelCase    				=     fairseq_model.state_dict()

   __lowerCamelCase    				=     hf_model.unispeech_sat.feature_extractor

   for name, value in fairseq_dict.items():
      __lowerCamelCase    				=     False
      if "conv_layers" in name:
         load_conv_layer(
             _UpperCamelCase			,_UpperCamelCase			,_UpperCamelCase			,_UpperCamelCase			,hf_model.config.feat_extract_norm == '''group'''			,)
         __lowerCamelCase    				=     True
      else:
         for key, mapped_key in MAPPING.items():
            __lowerCamelCase    				=     '''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
               __lowerCamelCase    				=     True
               if "*" in mapped_key:
                  __lowerCamelCase    				=     name.split(_UpperCamelCase				)[0].split('''.'''				)[-2]
                  __lowerCamelCase    				=     mapped_key.replace('''*'''			,_UpperCamelCase				)
               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:
                  # TODO: don't match quantizer.weight_proj
                  __lowerCamelCase    				=     '''weight'''
               else:
                  __lowerCamelCase    				=     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 		a__      (		_UpperCamelCase      :			Optional[Any]			,_UpperCamelCase      :			Union[str, Any]			,_UpperCamelCase      :			Union[str, Any]			,_UpperCamelCase      :			Any			,_UpperCamelCase      :			List[str]				):
   __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:
         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."""				)
         __lowerCamelCase    				=     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."""				)
         __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:
         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."""				)
         __lowerCamelCase    				=     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."""				)
         __lowerCamelCase    				=     value
         logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""				)
   else:
      unused_weights.append(_UpperCamelCase				)





@torch.no_grad()
def 		a__      (		_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			int			,_UpperCamelCase      :			int=None			,_UpperCamelCase      :			Any=None			,_UpperCamelCase      :			Dict=True				):
   if config_path is not None:
      __lowerCamelCase    				=     UniSpeechSatConfig.from_pretrained(_UpperCamelCase				)
   else:
      __lowerCamelCase    				=     UniSpeechSatConfig()

   __lowerCamelCase    				=     ''''''

   if is_finetuned:
      __lowerCamelCase    				=     UniSpeechSatForCTC(_UpperCamelCase				)
   else:
      __lowerCamelCase    				=     UniSpeechSatForPreTraining(_UpperCamelCase				)

   __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()

   recursively_load_weights(_UpperCamelCase			,_UpperCamelCase				)

   hf_wavavec.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_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
  )











def 		a__      (		_UpperCamelCase      :			list[int]				):
   if not numbers:
      return 0

   if not isinstance(_UpperCamelCase			,(list, tuple)				) or not all(
       isinstance(_UpperCamelCase			,_UpperCamelCase				) for number in numbers				):
      raise ValueError('''numbers must be an iterable of integers'''				)

   __lowerCamelCase    				=     __lowerCamelCase    				=     __lowerCamelCase    				=     numbers[0]

   for i in range(1			,len(_UpperCamelCase				)				):
      # update the maximum and minimum subarray products
      __lowerCamelCase    				=     numbers[i]
      if number < 0:
         __lowerCamelCase				,__lowerCamelCase    				=     min_till_now, max_till_now
      __lowerCamelCase    				=     max(_UpperCamelCase			,max_till_now * number				)
      __lowerCamelCase    				=     min(_UpperCamelCase			,min_till_now * number				)

      # update the maximum product found till now
      __lowerCamelCase    				=     max(_UpperCamelCase			,_UpperCamelCase				)

   return max_prod






