
"""simple docstring"""







# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile

def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	multiprocessing.Manager()
      UpperCAmelCase          =	manager.list()

      UpperCAmelCase          =	multiprocessing.Process(target=lowerCamelCase_				,	args=(check_program, result, timeout)							)
      p.start()
      p.join(timeout=timeout + 1							)
      if p.is_alive():
            p.kill()

      if not result:
            result.append("""timed out"""							)

      return {
          "task_id": task_id,
          "passed": result[0] == "passed",
          "result": result[0],
          "completion_id": completion_id,
      }

def _a			(		_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      with create_tempdir():
            # These system calls are needed when cleaning up tempdir.
            import os
            import shutil

            UpperCAmelCase          =	shutil.rmtree
            UpperCAmelCase          =	os.rmdir
            UpperCAmelCase          =	os.chdir

            # Disable functionalities that can make destructive changes to the test.
            reliability_guard()

            # Run program.
            try:
                  UpperCAmelCase          =	{}
                  with swallow_io():
                        with time_limit(lowerCamelCase_							):
                              exec(lowerCamelCase_				,	lowerCamelCase_							)
                  result.append("""passed"""							)
            except TimeoutException:
                  result.append("""timed out"""							)
            except BaseException as e:
                  result.append(F'''failed: {e}'''							)

            # Needed for cleaning up.
            UpperCAmelCase          =	rmtree
            UpperCAmelCase          =	rmdir
            UpperCAmelCase          =	chdir

@contextlib.contextmanager
def _a			(		_snake_case							):







      """simple docstring"""






      def signal_handler(_snake_case				,	_snake_case							):
            raise TimeoutException("""Timed out!"""							)

      signal.setitimer(signal.ITIMER_REAL				,	lowerCamelCase_							)
      signal.signal(signal.SIGALRM				,	lowerCamelCase_							)
      try:
            yield
      finally:
            signal.setitimer(signal.ITIMER_REAL				,	0							)

@contextlib.contextmanager
def _a			(		):







      """simple docstring"""






      UpperCAmelCase          =	WriteOnlyStringIO()
      with contextlib.redirect_stdout(lowerCamelCase_							):
            with contextlib.redirect_stderr(lowerCamelCase_							):
                  with redirect_stdin(lowerCamelCase_							):
                        yield

@contextlib.contextmanager
def _a			(		):







      """simple docstring"""






      with tempfile.TemporaryDirectory() as dirname:
            with chdir(lowerCamelCase_							):
                  yield dirname







class  lowerCamelCase__ (	_a			):
    pass







class  lowerCamelCase__ (	io.StringIO			):






    def     _UpperCamelCase							(			self     ,*A     ,**A ):
          raise OSError






    def     _UpperCamelCase							(			self     ,*A     ,**A ):
          raise OSError






    def     _UpperCamelCase							(			self     ,*A     ,**A ):
          raise OSError






    def     _UpperCamelCase							(			self     ,*A     ,**A ):
          return False







class  lowerCamelCase__ (	contextlib._RedirectStream			):  # type: ignore
    SCREAMING_SNAKE_CASE		=      """stdin"""







@contextlib.contextmanager
def _a			(		_snake_case							):







      """simple docstring"""






      if root == ".":
            yield
            return
      UpperCAmelCase          =	os.getcwd()
      os.chdir(lowerCamelCase_							)
      try:
            yield
      except BaseException as exc:
            raise exc
      finally:
            os.chdir(lowerCamelCase_							)






def _a			(		_snake_case=None							):







      """simple docstring"""






      if maximum_memory_bytes is not None:
            import resource

            resource.setrlimit(resource.RLIMIT_AS				,	(maximum_memory_bytes, maximum_memory_bytes)							)
            resource.setrlimit(resource.RLIMIT_DATA				,	(maximum_memory_bytes, maximum_memory_bytes)							)
            if not platform.uname().system == "Darwin":
                  resource.setrlimit(resource.RLIMIT_STACK				,	(maximum_memory_bytes, maximum_memory_bytes)							)

      faulthandler.disable()

      import builtins

      UpperCAmelCase          =	None
      UpperCAmelCase          =	None

      import os

      UpperCAmelCase          =	'1'

      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None

      import shutil

      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None

      import subprocess

      UpperCAmelCase          =	None  # type: ignore

      UpperCAmelCase          =	None

      import sys

      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None
      UpperCAmelCase          =	None











"""simple docstring"""







import argparse

import fairseq
import torch

from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging


logging.set_verbosity_info()
_UpperCamelCase					      =  logging.get_logger(__name__)

_UpperCamelCase					      =  {
    """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""",
}
_UpperCamelCase					      =  [
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
    """label_embeddings_concat""",
    """speaker_proj""",
    """layer_norm_for_extract""",
]

def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      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 _a			(		_snake_case				,	_snake_case							):







      """simple docstring"""






      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 _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case				,	_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[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 _a			(		_snake_case				,	_snake_case				,	_snake_case=None				,	_snake_case=None				,	_snake_case=True							):







      """simple docstring"""






      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__":
  _UpperCamelCase					      =  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"""
  )
  _UpperCamelCase					      =  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
  )



