





import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
__lowerCamelCase						: Dict		=   logging.get_logger(__name__)

__lowerCamelCase						: Dict		=   {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.linear_k": "encoder.layers.*.self_attn.linear_k",
    "self_attn.linear_v": "encoder.layers.*.self_attn.linear_v",
    "self_attn.linear_q": "encoder.layers.*.self_attn.linear_q",
    "self_attn.pos_bias_u": "encoder.layers.*.self_attn.pos_bias_u",
    "self_attn.pos_bias_v": "encoder.layers.*.self_attn.pos_bias_v",
    "self_attn.linear_out": "encoder.layers.*.self_attn.linear_out",
    "self_attn.linear_pos": "encoder.layers.*.self_attn.linear_pos",
    "self_attn.rotary_emb": "encoder.embed_positions",
    "self_attn_layer_norm": "encoder.layers.*.self_attn_layer_norm",
    "conv_module.pointwise_conv1": "encoder.layers.*.conv_module.pointwise_conv1",
    "conv_module.pointwise_conv2": "encoder.layers.*.conv_module.pointwise_conv2",
    "conv_module.depthwise_conv": "encoder.layers.*.conv_module.depthwise_conv",
    "conv_module.batch_norm": "encoder.layers.*.conv_module.batch_norm",
    "conv_module.layer_norm": "encoder.layers.*.conv_module.layer_norm",
    "ffn1.w_1": "encoder.layers.*.ffn1.intermediate_dense",
    "ffn1.w_2": "encoder.layers.*.ffn1.output_dense",
    "ffn1.layer_norm": "encoder.layers.*.ffn1_layer_norm",
    "ffn2.w_1": "encoder.layers.*.ffn2.intermediate_dense",
    "ffn2.w_2": "encoder.layers.*.ffn2.output_dense",
    "ffn2.layer_norm": "encoder.layers.*.ffn2_layer_norm",
    "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",
}
__lowerCamelCase						: Dict		=   [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  for attribute in key.split('''.'''   ):
    _UpperCamelCase       			=getattr(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE   )

  if weight_type is not None:
    _UpperCamelCase       			=getattr(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_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
  elif weight_type == "running_mean":
    _UpperCamelCase       			=value
  elif weight_type == "running_var":
    _UpperCamelCase       			=value
  elif weight_type == "num_batches_tracked":
    _UpperCamelCase       			=value
  elif weight_type == "inv_freq":
    _UpperCamelCase       			=value
  else:
    _UpperCamelCase       			=value

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


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=[]
  _UpperCamelCase       			=fairseq_model.state_dict()

  _UpperCamelCase       			=hf_model.wavaveca_conformer.feature_extractor

  for name, value in fairseq_dict.items():
    _UpperCamelCase       			=False
    if "conv_layers" in name:
      load_conv_layer(
          _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      hf_model.config.feat_extract_norm == '''group'''  ,      )
      _UpperCamelCase       			=True
    else:
      for key, mapped_key in MAPPING.items():
        _UpperCamelCase       			='''wav2vec2_conformer.''' + 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]:
          _UpperCamelCase       			=True
          if "*" in mapped_key:
            _UpperCamelCase       			=name.split(_SCREAMING_SNAKE_CASE   )[0].split('''.'''   )[-2]
            _UpperCamelCase       			=mapped_key.replace('''*'''  ,      _SCREAMING_SNAKE_CASE   )
          if "pos_bias_u" in name:
            _UpperCamelCase       			=None
          elif "pos_bias_v" in name:
            _UpperCamelCase       			=None
          elif "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'''
          elif "running_mean" in name:
            _UpperCamelCase       			='''running_mean'''
          elif "inv_freq" in name:
            _UpperCamelCase       			='''inv_freq'''
          elif "running_var" in name:
            _UpperCamelCase       			='''running_var'''
          elif "num_batches_tracked" in name:
            _UpperCamelCase       			='''num_batches_tracked'''
          else:
            _UpperCamelCase       			=None
          set_recursively(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE   )
        continue
    if not is_used:
      unused_weights.append(_SCREAMING_SNAKE_CASE   )

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


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _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.conv_layers[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.conv_layers[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(_SCREAMING_SNAKE_CASE   )


@torch.no_grad()
def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE=None  ,      __SCREAMING_SNAKE_CASE=None  ,      __SCREAMING_SNAKE_CASE=True   ):


  """simple docstring"""

  if config_path is not None:
    _UpperCamelCase       			=WavaVecaConformerConfig.from_pretrained(_SCREAMING_SNAKE_CASE  ,      hidden_act='''swish'''   )
  else:
    _UpperCamelCase       			=WavaVecaConformerConfig()

  if "rope" in checkpoint_path:
    _UpperCamelCase       			='''rotary'''

  if is_finetuned:
    if dict_path:
      _UpperCamelCase       			=Dictionary.load(_SCREAMING_SNAKE_CASE   )

      # 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(_SCREAMING_SNAKE_CASE  ,      '''vocab.json'''   )
      if not os.path.isdir(_SCREAMING_SNAKE_CASE   ):
        logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(_SCREAMING_SNAKE_CASE   )   )
        return
      os.makedirs(_SCREAMING_SNAKE_CASE  ,      exist_ok=_SCREAMING_SNAKE_CASE   )
      _UpperCamelCase       			=target_dict.indices

      # fairseq has the <pad> and <s> switched
      _UpperCamelCase       			=0
      _UpperCamelCase       			=1
      with open(_SCREAMING_SNAKE_CASE  ,      '''w'''  ,      encoding='''utf-8'''   ) as vocab_handle:
        json.dump(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE   )
      _UpperCamelCase       			=WavaVecaCTCTokenizer(
          _SCREAMING_SNAKE_CASE  ,      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=_SCREAMING_SNAKE_CASE  ,      )
      _UpperCamelCase       			=True if config.feat_extract_norm == '''layer''' else False
      _UpperCamelCase       			=WavaVecaFeatureExtractor(
          feature_size=1  ,      sampling_rate=1_6000  ,      padding_value=0  ,      do_normalize=_SCREAMING_SNAKE_CASE  ,      return_attention_mask=_SCREAMING_SNAKE_CASE  ,      )
      _UpperCamelCase       			=WavaVecaProcessor(feature_extractor=_SCREAMING_SNAKE_CASE  ,      tokenizer=_SCREAMING_SNAKE_CASE   )
      processor.save_pretrained(_SCREAMING_SNAKE_CASE   )

    _UpperCamelCase       			=WavaVecaConformerForCTC(_SCREAMING_SNAKE_CASE   )
  else:
    _UpperCamelCase       			=WavaVecaConformerForPreTraining(_SCREAMING_SNAKE_CASE   )

  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       			=argparse.Namespace(task='''audio_pretraining'''   )
    _UpperCamelCase       			=fairseq.tasks.setup_task(_SCREAMING_SNAKE_CASE   )

    _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase       			=fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]  ,      task=_SCREAMING_SNAKE_CASE   )

  _UpperCamelCase       			=model[0].eval()

  recursively_load_weights(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE  ,      not is_finetuned   )

  hf_wavavec.save_pretrained(_SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
      __lowerCamelCase						: Dict		=   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'
      )
      __lowerCamelCase						: Optional[Any]		=   parser.parse_args()
      convert_wavaveca_conformer_checkpoint(
          args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
      )













'''simple docstring'''






from collections.abc import Generator
from math import sin


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  if len(__SCREAMING_SNAKE_CASE   ) != 32:
    raise ValueError('''Input must be of length 32'''   )

  _UpperCamelCase       			=b''''''
  for i in [3, 2, 1, 0]:
    little_endian += string_aa[8 * i : 8 * i + 8]
  return little_endian


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  if i < 0:
    raise ValueError('''Input must be non-negative'''   )

  _UpperCamelCase       			=format(__SCREAMING_SNAKE_CASE  ,      '''08x'''   )[-8:]
  _UpperCamelCase       			=b''''''
  for i in [3, 2, 1, 0]:
    little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8'''   )
  return little_endian_hex


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=b''''''
  for char in message:
    bit_string += format(__SCREAMING_SNAKE_CASE  ,      '''08b'''   ).encode('''utf-8'''   )
  _UpperCamelCase       			=format(len(__SCREAMING_SNAKE_CASE   )  ,      '''064b'''   ).encode('''utf-8'''   )

  # Pad bit_string to a multiple of 512 chars
  bit_string += b"1"
  while len(__SCREAMING_SNAKE_CASE   ) % 512 != 448:
    bit_string += b"0"
  bit_string += to_little_endian(start_len[32:]   ) + to_little_endian(start_len[:32]   )

  return bit_string


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  if len(__SCREAMING_SNAKE_CASE   ) % 512 != 0:
    raise ValueError('''Input must have length that\'s a multiple of 512'''   )

  for pos in range(0  ,      len(__SCREAMING_SNAKE_CASE   )  ,      512   ):
    _UpperCamelCase       			=bit_string[pos : pos + 512]
    _UpperCamelCase       			=[]
    for i in range(0  ,      512  ,      32   ):
      block_words.append(int(to_little_endian(block[i : i + 32]   )  ,      2   )   )
    yield block_words


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  if i < 0:
    raise ValueError('''Input must be non-negative'''   )

  _UpperCamelCase       			=format(__SCREAMING_SNAKE_CASE  ,      '''032b'''   )
  _UpperCamelCase       			=''''''
  for c in i_str:
    new_str += "1" if c == "0" else "0"
  return int(__SCREAMING_SNAKE_CASE  ,      2   )


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  return (a + b) % 2**32


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  if i < 0:
    raise ValueError('''Input must be non-negative'''   )
  if shift < 0:
    raise ValueError('''Shift must be non-negative'''   )
  return ((i << shift) ^ (i >> (32 - shift))) % 2**32


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=preprocess(__SCREAMING_SNAKE_CASE   )

  _UpperCamelCase       			=[int(2**32 * abs(sin(i + 1   )   )   ) for i in range(64   )]

  # Starting states
  _UpperCamelCase       			=0X6745_2301
  _UpperCamelCase       			=0Xefcd_ab89
  _UpperCamelCase       			=0X98ba_dcfe
  _UpperCamelCase       			=0X1032_5476

  _UpperCamelCase       			=[
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
  ]

  # Process bit string in chunks, each with 16 32-char words
  for block_words in get_block_words(__SCREAMING_SNAKE_CASE   ):
    _UpperCamelCase       			=aa
    _UpperCamelCase       			=ba
    _UpperCamelCase       			=ca
    _UpperCamelCase       			=da

    # Hash current chunk
    for i in range(64   ):
      if i <= 15:
        # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
        _UpperCamelCase       			=d ^ (b & (c ^ d))
        _UpperCamelCase       			=i
      elif i <= 31:
        # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
        _UpperCamelCase       			=c ^ (d & (b ^ c))
        _UpperCamelCase       			=(5 * i + 1) % 16
      elif i <= 47:
        _UpperCamelCase       			=b ^ c ^ d
        _UpperCamelCase       			=(3 * i + 5) % 16
      else:
        _UpperCamelCase       			=c ^ (b | not_aa(__SCREAMING_SNAKE_CASE   ))
        _UpperCamelCase       			=(7 * i) % 16
      _UpperCamelCase       			=(f + a + added_consts[i] + block_words[g]) % 2**32
      _UpperCamelCase       			=d
      _UpperCamelCase       			=c
      _UpperCamelCase       			=b
      _UpperCamelCase       			=sum_aa(__SCREAMING_SNAKE_CASE  ,      left_rotate_aa(__SCREAMING_SNAKE_CASE  ,      shift_amounts[i]   )   )

    # Add hashed chunk to running total
    _UpperCamelCase       			=sum_aa(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
    _UpperCamelCase       			=sum_aa(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
    _UpperCamelCase       			=sum_aa(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )
    _UpperCamelCase       			=sum_aa(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   )

  _UpperCamelCase       			=reformat_hex(__SCREAMING_SNAKE_CASE   ) + reformat_hex(__SCREAMING_SNAKE_CASE   ) + reformat_hex(__SCREAMING_SNAKE_CASE   ) + reformat_hex(__SCREAMING_SNAKE_CASE   )
  return digest


if __name__ == "__main__":
      import doctest

      doctest.testmod()






