


import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
UpperCAmelCase    =					sys.version_info >= (3, 10)






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE=None      ,      SCREAMING_SNAKE_CASE=None      )->						List[str]:




      """simple docstring"""

      return field(default_factory=lambda: default      ,      metadata=SCREAMING_SNAKE_CASE      )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						4_2
 __snake_case				=						4_2
 __snake_case				=						4_2
 __snake_case				=						4_2







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						4_2
 __snake_case				=						field(default="toto"      ,		metadata={"help": "help message"} )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						False
 __snake_case				=						True
 __snake_case				=						None







class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

 __snake_case				=						"titi"
 __snake_case				=						"toto"







class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

 __snake_case				=						"titi"
 __snake_case				=						"toto"
 __snake_case				=						4_2







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						"toto"



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   BasicEnum(self.foo      )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						"toto"



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   MixedTypeEnum(self.foo      )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						None
 __snake_case				=						field(default=lowerCamelCase__      ,		metadata={"help": "help message"} )
 __snake_case				=						None
 __snake_case				=						list_field(default=[] )
 __snake_case				=						list_field(default=[] )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						list_field(default=[] )
 __snake_case				=						list_field(default=[1, 2, 3] )
 __snake_case				=						list_field(default=["Hallo", "Bonjour", "Hello"] )
 __snake_case				=						list_field(default=[0.1, 0.2, 0.3] )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						field()
 __snake_case				=						field()
 __snake_case				=						field()



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   BasicEnum(self.required_enum      )







@dataclass
class lowerCAmelCase_		:

 '''simple docstring'''

 __snake_case				=						4_2
 __snake_case				=						field()
 __snake_case				=						None
 __snake_case				=						field(default="toto"      ,		metadata={"help": "help message"} )
 __snake_case				=						list_field(default=["Hallo", "Bonjour", "Hello"] )


if is_python_no_less_than_3_10:







  @dataclass
  class lowerCAmelCase_		:

   '''simple docstring'''

   __snake_case				=						False
   __snake_case				=						True
   __snake_case				=						None







  @dataclass
  class lowerCAmelCase_		:

   '''simple docstring'''

   __snake_case				=						None
   __snake_case				=						field(default=lowerCamelCase__      ,		metadata={"help": "help message"} )
   __snake_case				=						None
   __snake_case				=						list_field(default=[] )
   __snake_case				=						list_field(default=[] )







class lowerCAmelCase_		(				unittest.TestCase ):

 '''simple docstring'''

 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       self.assertEqual(len(a._actions      )	,   len(b._actions      )      )
       for x, y in zip(a._actions	,   b._actions      ):
             snake_case_ =   {k: v for k, v in vars(_UpperCAmelCase      ).items() if k != '''container'''}
             snake_case_ =   {k: v for k, v in vars(_UpperCAmelCase      ).items() if k != '''container'''}

             # Choices with mixed type have custom function as "type"
             # So we need to compare results directly for equality
             if xx.get('''choices'''	,   _UpperCAmelCase      ) and yy.get('''choices'''	,   _UpperCAmelCase      ):
                   for expected_choice in yy["choices"] + xx["choices"]:
                         self.assertEqual(xx['''type'''](_UpperCAmelCase      )	,   yy['''type'''](_UpperCAmelCase      )      )
                   del xx["type"], yy["type"]

             self.assertEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument('''--bar'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument('''--baz'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument('''--flag'''	,   type=_UpperCAmelCase	,   default=_UpperCAmelCase	,   const=_UpperCAmelCase	,   nargs='''?'''      )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

       snake_case_ =   ['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
       ((snake_case_					) ,										) =   parser.parse_args_into_dataclasses(_UpperCAmelCase	,   look_for_args_file=_UpperCAmelCase      )
       self.assertFalse(example.flag      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo'''	,   default=42	,   type=_UpperCAmelCase      )
       expected.add_argument('''--baz'''	,   default='''toto'''	,   type=_UpperCAmelCase	,   help='''help message'''      )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo'''	,   type=_UpperCAmelCase	,   default=_UpperCAmelCase	,   const=_UpperCAmelCase	,   nargs='''?'''      )
       expected.add_argument('''--baz'''	,   type=_UpperCAmelCase	,   default=_UpperCAmelCase	,   const=_UpperCAmelCase	,   nargs='''?'''      )
       # A boolean no_* argument always has to come after its "default: True" regular counter-part
       # and its default must be set to False
       expected.add_argument('''--no_baz'''	,   action='''store_false'''	,   default=_UpperCAmelCase	,   dest='''baz'''      )
       expected.add_argument('''--opt'''	,   type=_UpperCAmelCase	,   default=_UpperCAmelCase      )

       snake_case_ =   [WithDefaultBoolExample]
       if is_python_no_less_than_3_10:
             dataclass_types.append(_UpperCAmelCase      )

       for dataclass_type in dataclass_types:
             snake_case_ =   HfArgumentParser(_UpperCAmelCase      )
             self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

             snake_case_ =   parser.parse_args([]      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   opt=_UpperCAmelCase      )      )

             snake_case_ =   parser.parse_args(['''--foo''', '''--no_baz''']      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   opt=_UpperCAmelCase      )      )

             snake_case_ =   parser.parse_args(['''--foo''', '''--baz''']      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   opt=_UpperCAmelCase      )      )

             snake_case_ =   parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True''']      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   opt=_UpperCAmelCase      )      )

             snake_case_ =   parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False''']      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   opt=_UpperCAmelCase      )      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument(
           '''--foo'''	,   default='''toto'''	,   choices=['''titi''', '''toto''', 42]	,   type=make_choice_type_function(['''titi''', '''toto''', 42]      )	,   )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

       snake_case_ =   parser.parse_args([]      )
       self.assertEqual(args.foo	,   '''toto'''      )
       snake_case_ =   parser.parse_args_into_dataclasses([]      )[0]
       self.assertEqual(enum_ex.foo	,   MixedTypeEnum.toto      )

       snake_case_ =   parser.parse_args(['''--foo''', '''titi''']      )
       self.assertEqual(args.foo	,   '''titi'''      )
       snake_case_ =   parser.parse_args_into_dataclasses(['''--foo''', '''titi''']      )[0]
       self.assertEqual(enum_ex.foo	,   MixedTypeEnum.titi      )

       snake_case_ =   parser.parse_args(['''--foo''', '''42''']      )
       self.assertEqual(args.foo	,   42      )
       snake_case_ =   parser.parse_args_into_dataclasses(['''--foo''', '''42''']      )[0]
       self.assertEqual(enum_ex.foo	,   MixedTypeEnum.fourtytwo      )



 def 		UpperCamelCase__  (			self      ):







       @dataclass
       class lowerCAmelCase_		:

        '''simple docstring'''

        __snake_case				=						"toto"





       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument(
           '''--foo'''	,   default='''toto'''	,   choices=('''titi''', '''toto''', 42)	,   type=make_choice_type_function(['''titi''', '''toto''', 42]      )	,   )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

       snake_case_ =   parser.parse_args([]      )
       self.assertEqual(args.foo	,   '''toto'''      )

       snake_case_ =   parser.parse_args(['''--foo''', '''titi''']      )
       self.assertEqual(args.foo	,   '''titi'''      )

       snake_case_ =   parser.parse_args(['''--foo''', '''42''']      )
       self.assertEqual(args.foo	,   42      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo_int'''	,   nargs='''+'''	,   default=[]	,   type=_UpperCAmelCase      )
       expected.add_argument('''--bar_int'''	,   nargs='''+'''	,   default=[1, 2, 3]	,   type=_UpperCAmelCase      )
       expected.add_argument('''--foo_str'''	,   nargs='''+'''	,   default=['''Hallo''', '''Bonjour''', '''Hello''']	,   type=_UpperCAmelCase      )
       expected.add_argument('''--foo_float'''	,   nargs='''+'''	,   default=[0.1, 0.2, 0.3]	,   type=_UpperCAmelCase      )

       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

       snake_case_ =   parser.parse_args([]      )
       self.assertEqual(
           _UpperCAmelCase	,   Namespace(foo_int=[]	,   bar_int=[1, 2, 3]	,   foo_str=['''Hallo''', '''Bonjour''', '''Hello''']	,   foo_float=[0.1, 0.2, 0.3]      )	,   )

       snake_case_ =   parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split()      )
       self.assertEqual(_UpperCAmelCase	,   Namespace(foo_int=[1]	,   bar_int=[2, 3]	,   foo_str=['''a''', '''b''', '''c''']	,   foo_float=[0.1, 0.7]      )      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo'''	,   default=_UpperCAmelCase	,   type=_UpperCAmelCase      )
       expected.add_argument('''--bar'''	,   default=_UpperCAmelCase	,   type=_UpperCAmelCase	,   help='''help message'''      )
       expected.add_argument('''--baz'''	,   default=_UpperCAmelCase	,   type=_UpperCAmelCase      )
       expected.add_argument('''--ces'''	,   nargs='''+'''	,   default=[]	,   type=_UpperCAmelCase      )
       expected.add_argument('''--des'''	,   nargs='''+'''	,   default=[]	,   type=_UpperCAmelCase      )

       snake_case_ =   [OptionalExample]
       if is_python_no_less_than_3_10:
             dataclass_types.append(_UpperCAmelCase      )

       for dataclass_type in dataclass_types:
             snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

             self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )

             snake_case_ =   parser.parse_args([]      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=_UpperCAmelCase	,   bar=_UpperCAmelCase	,   baz=_UpperCAmelCase	,   ces=[]	,   des=[]      )      )

             snake_case_ =   parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split()      )
             self.assertEqual(_UpperCAmelCase	,   Namespace(foo=12	,   bar=3.14	,   baz='''42'''	,   ces=['''a''', '''b''', '''c''']	,   des=[1, 2, 3]      )      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--required_list'''	,   nargs='''+'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument('''--required_str'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument(
           '''--required_enum'''	,   type=make_choice_type_function(['''titi''', '''toto''']      )	,   choices=['''titi''', '''toto''']	,   required=_UpperCAmelCase	,   )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   argparse.ArgumentParser()
       expected.add_argument('''--foo'''	,   type=_UpperCAmelCase	,   required=_UpperCAmelCase      )
       expected.add_argument(
           '''--required_enum'''	,   type=make_choice_type_function(['''titi''', '''toto''']      )	,   choices=['''titi''', '''toto''']	,   required=_UpperCAmelCase	,   )
       expected.add_argument('''--opt'''	,   type=_UpperCAmelCase	,   default=_UpperCAmelCase      )
       expected.add_argument('''--baz'''	,   default='''toto'''	,   type=_UpperCAmelCase	,   help='''help message'''      )
       expected.add_argument('''--foo_str'''	,   nargs='''+'''	,   default=['''Hallo''', '''Bonjour''', '''Hello''']	,   type=_UpperCAmelCase      )
       self.argparsersEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   {
           '''foo''': 12,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }

       snake_case_ =   parser.parse_dict(_UpperCAmelCase      )[0]
       snake_case_ =   BasicExample(**_UpperCAmelCase      )
       self.assertEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   {
           '''foo''': 12,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
           '''extra''': 42,
       }

       self.assertRaises(_UpperCAmelCase	,   parser.parse_dict	,   _UpperCAmelCase	,   allow_extra_keys=_UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   {
           '''foo''': 12,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }
       with tempfile.TemporaryDirectory() as tmp_dir:
             snake_case_ =   os.path.join(_UpperCAmelCase	,   '''temp_json'''      )
             os.mkdir(_UpperCAmelCase      )
             with open(temp_local_path + '''.json'''	,   '''w+'''      ) as f:
                   json.dump(_UpperCAmelCase	,   _UpperCAmelCase      )
             snake_case_ =   parser.parse_yaml_file(Path(temp_local_path + '''.json'''      )      )[0]

       snake_case_ =   BasicExample(**_UpperCAmelCase      )
       self.assertEqual(_UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )

       snake_case_ =   {
           '''foo''': 12,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }
       with tempfile.TemporaryDirectory() as tmp_dir:
             snake_case_ =   os.path.join(_UpperCAmelCase	,   '''temp_yaml'''      )
             os.mkdir(_UpperCAmelCase      )
             with open(temp_local_path + '''.yaml'''	,   '''w+'''      ) as f:
                   yaml.dump(_UpperCAmelCase	,   _UpperCAmelCase      )
             snake_case_ =   parser.parse_yaml_file(Path(temp_local_path + '''.yaml'''      )      )[0]
       snake_case_ =   BasicExample(**_UpperCAmelCase      )
       self.assertEqual(_UpperCAmelCase	,   _UpperCAmelCase      )





 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   HfArgumentParser(_UpperCAmelCase      )
       self.assertIsNotNone(_UpperCAmelCase      )



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  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )->						Tuple:




      """simple docstring"""

      for attribute in key.split('''.'''      ):
            snake_case_ =   getattr(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )

      if weight_type is not None:
            snake_case_ =   getattr(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ).shape
      else:
            snake_case_ =   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":
            snake_case_ =   value
      elif weight_type == "weight_g":
            snake_case_ =   value
      elif weight_type == "weight_v":
            snake_case_ =   value
      elif weight_type == "bias":
            snake_case_ =   value
      else:
            snake_case_ =   value

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






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )->						Any:




      """simple docstring"""

      snake_case_ =   []
      snake_case_ =   fairseq_model.state_dict()

      snake_case_ =   hf_model.unispeech_sat.feature_extractor

      for name, value in fairseq_dict.items():
            snake_case_ =   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'''      ,      )
                  snake_case_ =   True
            else:
                  for key, mapped_key in MAPPING.items():
                        snake_case_ =   '''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
                              snake_case_ =   True
                              if "*" in mapped_key:
                                    snake_case_ =   name.split(SCREAMING_SNAKE_CASE      )[0].split('''.'''      )[-2]
                                    snake_case_ =   mapped_key.replace('''*'''      ,      SCREAMING_SNAKE_CASE      )
                              if "weight_g" in name:
                                    snake_case_ =   '''weight_g'''
                              elif "weight_v" in name:
                                    snake_case_ =   '''weight_v'''
                              elif "bias" in name:
                                    snake_case_ =   '''bias'''
                              elif "weight" in name:
                                    # TODO: don't match quantizer.weight_proj
                                    snake_case_ =   '''weight'''
                              else:
                                    snake_case_ =   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  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )->						Tuple:




      """simple docstring"""

      snake_case_ =   full_name.split('''conv_layers.'''      )[-1]
      snake_case_ =   name.split('''.'''      )
      snake_case_ =   int(items[0]      )
      snake_case_ =   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.'''      )
                  snake_case_ =   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.'''      )
                  snake_case_ =   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.'''      )
                  snake_case_ =   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.'''      )
                  snake_case_ =   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  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE=None      ,      SCREAMING_SNAKE_CASE=None      ,      SCREAMING_SNAKE_CASE=True      )->						Dict:




      """simple docstring"""

      if config_path is not None:
            snake_case_ =   UniSpeechSatConfig.from_pretrained(SCREAMING_SNAKE_CASE      )
      else:
            snake_case_ =   UniSpeechSatConfig()

      snake_case_ =   ''''''

      if is_finetuned:
            snake_case_ =   UniSpeechSatForCTC(SCREAMING_SNAKE_CASE      )
      else:
            snake_case_ =   UniSpeechSatForPreTraining(SCREAMING_SNAKE_CASE      )

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

      recursively_load_weights(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )

      hf_wavavec.save_pretrained(SCREAMING_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
   )