


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					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_ )    ->List[str]:
   for attribute in key.split(""".""" ):
      UpperCAmelCase      					=  getattr(lowerCAmelCase_	,    lowerCAmelCase_ )

   if weight_type is not None:
      UpperCAmelCase      					=  getattr(lowerCAmelCase_	,    lowerCAmelCase_ ).shape
   else:
      UpperCAmelCase      					=  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      					=  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 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Optional[Any]:
   UpperCAmelCase      					=  []
   UpperCAmelCase      					=  fairseq_model.state_dict()

   UpperCAmelCase      					=  hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

   for name, value in fairseq_dict.items():
      UpperCAmelCase      					=  False
      if "conv_layers" in name:
         load_conv_layer(
             lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    hf_model.config.feat_extract_norm == """group"""	,    )
         UpperCAmelCase      					=  True
      else:
         for key, mapped_key in MAPPING.items():
            UpperCAmelCase      					=  """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      					=  True
               if "*" in mapped_key:
                  UpperCAmelCase      					=  name.split(lowerCAmelCase_ )[0].split(""".""" )[-2]
                  UpperCAmelCase      					=  mapped_key.replace("""*"""	,    lowerCAmelCase_ )
               if "weight_g" in name:
                  UpperCAmelCase      					=  """weight_g"""
               elif "weight_v" in name:
                  UpperCAmelCase      					=  """weight_v"""
               elif "weight" in name:
                  UpperCAmelCase      					=  """weight"""
               elif "bias" in name:
                  UpperCAmelCase      					=  """bias"""
               else:
                  UpperCAmelCase      					=  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					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Tuple:
   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:
         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      					=  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      					=  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      					=  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      					=  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					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_=None	,    lowerCAmelCase_=None	,    lowerCAmelCase_=True )    ->Dict:
   if config_path is not None:
      UpperCAmelCase      					=  HubertConfig.from_pretrained(lowerCAmelCase_ )
   else:
      UpperCAmelCase      					=  HubertConfig()

   if is_finetuned:
      if dict_path:
         UpperCAmelCase      					=  Dictionary.load(lowerCAmelCase_ )

         # important change bos & pad token id since CTC symbol is <pad> and
         # not <s> as in fairseq
         UpperCAmelCase      					=  target_dict.pad_index
         UpperCAmelCase      					=  target_dict.bos_index
         UpperCAmelCase      					=  target_dict.eos_index
         UpperCAmelCase      					=  len(target_dict.symbols )
         UpperCAmelCase      					=  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      					=  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      					=  True if config.feat_extract_norm == """layer""" else False
         UpperCAmelCase      					=  WavaVecaFeatureExtractor(
             feature_size=1	,    sampling_rate=1_6_0_0_0	,    padding_value=0	,    do_normalize=lowerCAmelCase_	,    return_attention_mask=lowerCAmelCase_	,    )
         UpperCAmelCase      					=  WavaVecaProcessor(feature_extractor=lowerCAmelCase_	,    tokenizer=lowerCAmelCase_ )
         processor.save_pretrained(lowerCAmelCase_ )

      UpperCAmelCase      					=  HubertForCTC(lowerCAmelCase_ )
   else:
      UpperCAmelCase      					=  HubertModel(lowerCAmelCase_ )

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

   UpperCAmelCase      					=  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
 )







__a	 =      256
# Modulus to hash a string
__a	 =      100_0003
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->bool:
   UpperCAmelCase      					=  len(lowerCAmelCase_ )
   UpperCAmelCase      					=  len(lowerCAmelCase_ )
   if p_len > t_len:
      return False

   UpperCAmelCase      					=  0
   UpperCAmelCase      					=  0
   UpperCAmelCase      					=  1

   # Calculating the hash of pattern and substring of text
   for i in range(lowerCAmelCase_ ):
      UpperCAmelCase      					=  (ord(pattern[i] ) + p_hash * alphabet_size) % modulus
      UpperCAmelCase      					=  (ord(text[i] ) + text_hash * alphabet_size) % modulus
      if i == p_len - 1:
         continue
      UpperCAmelCase      					=  (modulus_power * alphabet_size) % modulus

   for i in range(0	,    t_len - p_len + 1 ):
      if text_hash == p_hash and text[i : i + p_len] == pattern:
         return True
      if i == t_len - p_len:
         continue
      # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
      UpperCAmelCase      					=  (
          (text_hash - ord(text[i] ) * modulus_power) * alphabet_size
          + ord(text[i + p_len] )
      ) % modulus
   return False
def 	_UpperCamelCase					(    )    ->None:
   UpperCAmelCase      					=  """abc1abc12"""
   UpperCAmelCase      					=  """alskfjaldsabc1abc1abc12k23adsfabcabc"""
   UpperCAmelCase      					=  """alskfjaldsk23adsfabcabc"""
   assert rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ ) and not rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )

   # Test 2)
   UpperCAmelCase      					=  """ABABX"""
   UpperCAmelCase      					=  """ABABZABABYABABX"""
   assert rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )

   # Test 3)
   UpperCAmelCase      					=  """AAAB"""
   UpperCAmelCase      					=  """ABAAAAAB"""
   assert rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )

   # Test 4)
   UpperCAmelCase      					=  """abcdabcy"""
   UpperCAmelCase      					=  """abcxabcdabxabcdabcdabcy"""
   assert rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )

   # Test 5)
   UpperCAmelCase      					=  """Lü"""
   UpperCAmelCase      					=  """Lüsai"""
   assert rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )
   UpperCAmelCase      					=  """Lue"""
   assert not rabin_karp(lowerCAmelCase_	,    lowerCAmelCase_ )
   print("""Success.""" )


if __name__ == "__main__":
 test_rabin_karp()



