




'''simple docstring'''





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_		:     List[str]          =		sys.version_info >= (3, 10)





def       __a      (  _UpperCamelCase:       Optional[Any]=None   ,		_UpperCamelCase:       List[str]=None       )		->					Dict:

     """simple docstring"""




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

@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       int
     SCREAMING_SNAKE_CASE_				:       float
     SCREAMING_SNAKE_CASE_				:       str
     SCREAMING_SNAKE_CASE_				:       bool







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       int       							=		42
     SCREAMING_SNAKE_CASE_				:       str       							=		field(default="""toto"""   ,   metadata={"""help""": """help message"""}				)







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       bool       							=		False
     SCREAMING_SNAKE_CASE_				:       bool       							=		True
     SCREAMING_SNAKE_CASE_				:       Optional[bool]       							=		None







class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       List[str]       							=		"""titi"""
     SCREAMING_SNAKE_CASE_				:       List[str]       							=		"""toto"""







class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       Union[str, Any]       							=		"""titi"""
     SCREAMING_SNAKE_CASE_				:       List[Any]       							=		"""toto"""
     SCREAMING_SNAKE_CASE_				:       Union[str, Any]       							=		42







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       BasicEnum       							=		"toto"






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				= BasicEnum(self.foo       )







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       MixedTypeEnum       							=		"toto"






     def 							_lowercase      (					self       )				->     Any:
          _snake_case				= MixedTypeEnum(self.foo       )







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		None
     SCREAMING_SNAKE_CASE_				:       Optional[float]       							=		field(default=__lowerCAmelCase   ,   metadata={"""help""": """help message"""}				)
     SCREAMING_SNAKE_CASE_				:       Optional[str]       							=		None
     SCREAMING_SNAKE_CASE_				:       Optional[List[str]]       							=		list_field(default=[]				)
     SCREAMING_SNAKE_CASE_				:       Optional[List[int]]       							=		list_field(default=[]				)







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       List[int]       							=		list_field(default=[]				)
     SCREAMING_SNAKE_CASE_				:       List[int]       							=		list_field(default=[1, 2, 3]				)
     SCREAMING_SNAKE_CASE_				:       List[str]       							=		list_field(default=["""Hallo""", """Bonjour""", """Hello"""]				)
     SCREAMING_SNAKE_CASE_				:       List[float]       							=		list_field(default=[0.1, 0.2, 0.3]				)







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       List[int]       							=		field()
     SCREAMING_SNAKE_CASE_				:       str       							=		field()
     SCREAMING_SNAKE_CASE_				:       BasicEnum       							=		field()






     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				= BasicEnum(self.required_enum       )







@dataclass
class   _a							:
     SCREAMING_SNAKE_CASE_				:       int
     SCREAMING_SNAKE_CASE_				:       "BasicEnum"       							=		field()
     SCREAMING_SNAKE_CASE_				:       "Optional[bool]"       							=		None
     SCREAMING_SNAKE_CASE_				:       "str"       							=		field(default="""toto"""   ,   metadata={"""help""": """help message"""}				)
     SCREAMING_SNAKE_CASE_				:       "List[str]"       							=		list_field(default=["""Hallo""", """Bonjour""", """Hello"""]				)


if is_python_no_less_than_3_10:

   @dataclass
   class   _a							:
        SCREAMING_SNAKE_CASE_				:       bool       							=		False
        SCREAMING_SNAKE_CASE_				:       bool       							=		True
        SCREAMING_SNAKE_CASE_				:       bool | None       							=		None







   @dataclass
   class   _a							:
        SCREAMING_SNAKE_CASE_				:       int | None       							=		None
        SCREAMING_SNAKE_CASE_				:       float | None       							=		field(default=__lowerCAmelCase   ,   metadata={"""help""": """help message"""}				)
        SCREAMING_SNAKE_CASE_				:       str | None       							=		None
        SCREAMING_SNAKE_CASE_				:       list[str] | None       							=		list_field(default=[]				)
        SCREAMING_SNAKE_CASE_				:       list[int] | None       							=		list_field(default=[]				)





class   _a							(		unittest.TestCase				):






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Optional[Any]:
          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(_SCREAMING_SNAKE_CASE       ).items() if k != "container"}
               _snake_case				= {k: v for k, v in vars(_SCREAMING_SNAKE_CASE       ).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"   ,_SCREAMING_SNAKE_CASE       ) and yy.get("choices"   ,_SCREAMING_SNAKE_CASE       ):
                    for expected_choice in yy["choices"] + xx["choices"]:
                         self.assertEqual(xx["type"](_SCREAMING_SNAKE_CASE       )   ,yy["type"](_SCREAMING_SNAKE_CASE       )       )
                    del xx["type"], yy["type"]

               self.assertEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Optional[Any]:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= argparse.ArgumentParser()
          expected.add_argument("--foo"   ,type=_SCREAMING_SNAKE_CASE   ,required=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--bar"   ,type=_SCREAMING_SNAKE_CASE   ,required=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--baz"   ,type=_SCREAMING_SNAKE_CASE   ,required=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--flag"   ,type=_SCREAMING_SNAKE_CASE   ,default=_SCREAMING_SNAKE_CASE   ,const=_SCREAMING_SNAKE_CASE   ,nargs="?"       )
          self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          _snake_case				= ["--foo", "1", "--baz", "quux", "--bar", "0.5"]
          ((_snake_case)				,   )				= parser.parse_args_into_dataclasses(_SCREAMING_SNAKE_CASE   ,look_for_args_file=_SCREAMING_SNAKE_CASE       )
          self.assertFalse(example.flag       )






     def 							_lowercase      (					self       )				->     Optional[Any]:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= argparse.ArgumentParser()
          expected.add_argument("--foo"   ,default=42   ,type=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--baz"   ,default="toto"   ,type=_SCREAMING_SNAKE_CASE   ,help="help message"       )
          self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				= argparse.ArgumentParser()
          expected.add_argument("--foo"   ,type=_SCREAMING_SNAKE_CASE   ,default=_SCREAMING_SNAKE_CASE   ,const=_SCREAMING_SNAKE_CASE   ,nargs="?"       )
          expected.add_argument("--baz"   ,type=_SCREAMING_SNAKE_CASE   ,default=_SCREAMING_SNAKE_CASE   ,const=_SCREAMING_SNAKE_CASE   ,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=_SCREAMING_SNAKE_CASE   ,dest="baz"       )
          expected.add_argument("--opt"   ,type=_SCREAMING_SNAKE_CASE   ,default=_SCREAMING_SNAKE_CASE       )

          _snake_case				= [WithDefaultBoolExample]
          if is_python_no_less_than_3_10:
               dataclass_types.append(_SCREAMING_SNAKE_CASE       )

          for dataclass_type in dataclass_types:
               _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )
               self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

               _snake_case				= parser.parse_args([]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,opt=_SCREAMING_SNAKE_CASE       )       )

               _snake_case				= parser.parse_args(["--foo", "--no_baz"]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,opt=_SCREAMING_SNAKE_CASE       )       )

               _snake_case				= parser.parse_args(["--foo", "--baz"]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,opt=_SCREAMING_SNAKE_CASE       )       )

               _snake_case				= parser.parse_args(["--foo", "True", "--baz", "True", "--opt", "True"]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,opt=_SCREAMING_SNAKE_CASE       )       )

               _snake_case				= parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,opt=_SCREAMING_SNAKE_CASE       )       )






     def 							_lowercase      (					self       )				->     int:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= argparse.ArgumentParser()
          expected.add_argument(
              "--foo"   ,default="toto"   ,choices=["titi", "toto", 42]   ,type=make_choice_type_function(["titi", "toto", 42]       )   ,)
          self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          _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 							_lowercase      (					self       )				->     str:

          @dataclass
          class   _a							:
               SCREAMING_SNAKE_CASE_				:       Literal["titi", "toto", 42]       							=		"toto"







          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= argparse.ArgumentParser()
          expected.add_argument(
              "--foo"   ,default="toto"   ,choices=("titi", "toto", 42)   ,type=make_choice_type_function(["titi", "toto", 42]       )   ,)
          self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          _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 							_lowercase      (					self       )				->     Any:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

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

          self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          _snake_case				= parser.parse_args([]       )
          self.assertEqual(
              _SCREAMING_SNAKE_CASE   ,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(_SCREAMING_SNAKE_CASE   ,Namespace(foo_int=[1]   ,bar_int=[2, 3]   ,foo_str=["a", "b", "c"]   ,foo_float=[0.1, 0.7]       )       )






     def 							_lowercase      (					self       )				->     Optional[Any]:
          _snake_case				= argparse.ArgumentParser()
          expected.add_argument("--foo"   ,default=_SCREAMING_SNAKE_CASE   ,type=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--bar"   ,default=_SCREAMING_SNAKE_CASE   ,type=_SCREAMING_SNAKE_CASE   ,help="help message"       )
          expected.add_argument("--baz"   ,default=_SCREAMING_SNAKE_CASE   ,type=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--ces"   ,nargs="+"   ,default=[]   ,type=_SCREAMING_SNAKE_CASE       )
          expected.add_argument("--des"   ,nargs="+"   ,default=[]   ,type=_SCREAMING_SNAKE_CASE       )

          _snake_case				= [OptionalExample]
          if is_python_no_less_than_3_10:
               dataclass_types.append(_SCREAMING_SNAKE_CASE       )

          for dataclass_type in dataclass_types:
               _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

               self.argparsersEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

               _snake_case				= parser.parse_args([]       )
               self.assertEqual(_SCREAMING_SNAKE_CASE   ,Namespace(foo=_SCREAMING_SNAKE_CASE   ,bar=_SCREAMING_SNAKE_CASE   ,baz=_SCREAMING_SNAKE_CASE   ,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(_SCREAMING_SNAKE_CASE   ,Namespace(foo=12   ,bar=3.1_4   ,baz="42"   ,ces=["a", "b", "c"]   ,des=[1, 2, 3]       )       )






     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

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






     def 							_lowercase      (					self       )				->     str:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

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






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= {
              "foo": 12,
              "bar": 3.1_4,
              "baz": "42",
              "flag": True,
          }

          _snake_case				= parser.parse_dict(_SCREAMING_SNAKE_CASE       )[0]
          _snake_case				= BasicExample(**_SCREAMING_SNAKE_CASE       )
          self.assertEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     int:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

          _snake_case				= {
              "foo": 12,
              "bar": 3.1_4,
              "baz": "42",
              "flag": True,
              "extra": 42,
          }

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






     def 							_lowercase      (					self       )				->     Any:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

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

          _snake_case				= BasicExample(**_SCREAMING_SNAKE_CASE       )
          self.assertEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self       )				->     Optional[Any]:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )

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






     def 							_lowercase      (					self       )				->     str:
          _snake_case				= HfArgumentParser(_SCREAMING_SNAKE_CASE       )
          self.assertIsNotNone(_SCREAMING_SNAKE_CASE       )








'''simple docstring'''





import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
UpperCamelCase_		:     str          =		logging.get_logger(__name__)

UpperCamelCase_		:     Optional[int]          =		{
    '''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''',
    '''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''',
}
UpperCamelCase_		:     int          =		[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]





def       __a      (  _UpperCamelCase:       int   ,		_UpperCamelCase:       List[str]   ,		_UpperCamelCase:       Any   ,		_UpperCamelCase:       List[Any]   ,		_UpperCamelCase:       Optional[int]       )		->					int:

     """simple docstring"""




     for attribute in key.split("."       ):
          _snake_case				= getattr(_UpperCamelCase   ,		_UpperCamelCase       )

     if weight_type is not None:
          _snake_case				= getattr(_UpperCamelCase   ,		_UpperCamelCase       ).shape
     else:
          _snake_case				= 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":
          _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       __a      (  _UpperCamelCase:       int   ,		_UpperCamelCase:       Tuple       )		->					str:

     """simple docstring"""




     _snake_case				= []
     _snake_case				= fairseq_model.state_dict()

     _snake_case				= hf_model.feature_extractor
     _snake_case				= hf_model.adapter

     for name, value in fairseq_dict.items():
          _snake_case				= False
          if "conv_layers" in name:
               load_conv_layer(
                   _UpperCamelCase   ,		_UpperCamelCase   ,		_UpperCamelCase   ,		_UpperCamelCase   ,		hf_model.config.feat_extract_norm == "group"   ,		)
               _snake_case				= True
          elif any(x in name for x in ["adaptor", "w2v_encoder.proj.", "w2v_proj_ln."]       ):
               load_adapter(_UpperCamelCase   ,		_UpperCamelCase   ,		_UpperCamelCase   ,		_UpperCamelCase       )
               _snake_case				= True
          else:
               for key, mapped_key in MAPPING.items():
                    if key in name or key.split("w2v_model."       )[-1] == name.split("."       )[0]:
                         _snake_case				= True
                         if "*" in mapped_key:
                              _snake_case				= name.split(_UpperCamelCase       )[0].split("."       )[-2]
                              _snake_case				= mapped_key.replace("*"   ,		_UpperCamelCase       )
                         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:
                              _snake_case				= "weight"
                         else:
                              _snake_case				= 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:       Dict   ,		_UpperCamelCase:       List[Any]   ,		_UpperCamelCase:       Optional[int]   ,		_UpperCamelCase:       Optional[Any]   ,		_UpperCamelCase:       Optional[Any]       )		->					Dict:

     """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:
               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."""
               )
               _snake_case				= 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."""
               )
               _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:
               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."
               )
               _snake_case				= 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."""
               )
               _snake_case				= value
               logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""       )
     else:
          unused_weights.append(_UpperCamelCase       )





def       __a      (  _UpperCamelCase:       Dict   ,		_UpperCamelCase:       str   ,		_UpperCamelCase:       Optional[int]   ,		_UpperCamelCase:       Tuple       )		->					Any:

     """simple docstring"""




     _snake_case				= full_name.split("adaptor."       )[-1]
     _snake_case				= name.split("."       )

     if items[1].isdigit():
          _snake_case				= int(items[1]       )
     else:
          _snake_case				= None

     if "adaptor" not in full_name:
          if "proj_ln" in full_name:
               # has to be layer norm
               if "bias" in name:
                    assert (
                        value.shape == adapter.proj_layer_norm.bias.data.shape
                    ), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found."""
                    _snake_case				= value
                    logger.info(F"""Adapter proj layer norm bias was initialized from {full_name}."""       )
               if "weight" in name:
                    assert (
                        value.shape == adapter.proj_layer_norm.weight.data.shape
                    ), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found."""
                    _snake_case				= value
          else:
               # has to be projection layer
               if "bias" in name:
                    assert (
                        value.shape == adapter.proj.bias.data.shape
                    ), F"""{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found."""
                    _snake_case				= value
                    logger.info(F"""Adapter proj layer bias was initialized from {full_name}."""       )
               if "weight" in name:
                    assert (
                        value.shape == adapter.proj.weight.data.shape
                    ), F"""{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found."""
                    _snake_case				= value
                    logger.info(F"""Adapter proj layer weight was initialized from {full_name}."""       )
     elif isinstance(_UpperCamelCase   ,		_UpperCamelCase       ):
          if "bias" in name:
               assert (
                   value.shape == adapter.layers[layer_id].conv.bias.data.shape
               ), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found."""
               _snake_case				= value
               logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""       )
          elif "weight" in name:
               assert (
                   value.shape == adapter.layers[layer_id].conv.weight.data.shape
               ), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found."""
               _snake_case				= value
               logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""       )
     else:
          unused_weights.append(_UpperCamelCase       )





def       __a      (  _UpperCamelCase:       Tuple       )		->					Optional[Any]:

     """simple docstring"""




     _snake_case				,   _snake_case				= emb.weight.shape
     _snake_case				= nn.Linear(_UpperCamelCase   ,		_UpperCamelCase   ,		bias=_UpperCamelCase       )
     _snake_case				= emb.weight.data
     return lin_layer





@torch.no_grad()
def       __a      (  _UpperCamelCase:       List[str]   ,		_UpperCamelCase:       Dict   ,		_UpperCamelCase:       Dict   ,		_UpperCamelCase:       str   ,		_UpperCamelCase:       Union[str, Any]   ,		_UpperCamelCase:       Tuple   ,		_UpperCamelCase:       Any   ,		_UpperCamelCase:       Tuple   ,		_UpperCamelCase:       List[Any]   ,		_UpperCamelCase:       Union[str, Any]   ,		_UpperCamelCase:       Tuple   ,		)		->					List[str]:

     """simple docstring"""




     _snake_case				= WavaVecaConfig.from_pretrained(
         _UpperCamelCase   ,		add_adapter=_UpperCamelCase   ,		adapter_stride=_UpperCamelCase   ,		adapter_kernel_size=_UpperCamelCase   ,		use_auth_token=_UpperCamelCase   ,		output_hidden_size=_UpperCamelCase   ,		)
     _snake_case				= MBartConfig.from_pretrained(_UpperCamelCase       )

     # load model
     _snake_case				,   _snake_case				,   _snake_case				= fairseq.checkpoint_utils.load_model_ensemble_and_task(
         [checkpoint_path]   ,		arg_overrides={
             "config_yaml": config_yaml_path,
             "data": "/".join(dict_path.split("/"       )[:-1]       ),
             "w2v_path": checkpoint_path,
             "load_pretrained_decoder_from": None,
         }   ,		)
     _snake_case				= model[0].eval()

     # load feature extractor
     _snake_case				= WavaVecaFeatureExtractor.from_pretrained(_UpperCamelCase   ,		use_auth_token=_UpperCamelCase       )

     # set weights for wav2vec2 encoder
     _snake_case				= WavaVecaModel(_UpperCamelCase       )

     recursively_load_weights_wavaveca(model.encoder   ,		_UpperCamelCase       )

     # load decoder weights
     _snake_case				= MBartForCausalLM(_UpperCamelCase       )
     _snake_case				,   _snake_case				= hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()   ,		strict=_UpperCamelCase       )
     logger.warning(F"""The following keys are missing when loading the decoder weights: {missing_keys}"""       )
     logger.warning(F"""The following keys are unexpected when loading the decoder weights: {unexpected_keys}"""       )

     _snake_case				= SpeechEncoderDecoderModel(encoder=_UpperCamelCase   ,		decoder=_UpperCamelCase       )
     _snake_case				= False

     _snake_case				= MBartaaTokenizer(_UpperCamelCase       )
     tokenizer.save_pretrained(_UpperCamelCase       )

     _snake_case				= hf_wavavec.config.to_dict()
     _snake_case				= tokenizer.pad_token_id
     _snake_case				= tokenizer.bos_token_id
     _snake_case				= tokenizer.eos_token_id
     _snake_case				= "mbart50"
     _snake_case				= "wav2vec2"

     _snake_case				= tokenizer.eos_token_id
     _snake_case				= 250_004
     _snake_case				= tokenizer.eos_token_id

     _snake_case				= SpeechEncoderDecoderConfig.from_dict(_UpperCamelCase       )

     hf_wavavec.save_pretrained(_UpperCamelCase       )
     feature_extractor.save_pretrained(_UpperCamelCase       )


if __name__ == "__main__":
   UpperCamelCase_		:     str          =		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_yaml_path''', default=None, type=str, help='''Path to yaml file of fine-tuned model''')
   parser.add_argument(
       '''--encoder_config_path''',
       default='''facebook/wav2vec2-xls-r-1b''',
       type=str,
       help='''Path to hf encoder wav2vec2 checkpoint config''',
   )
   parser.add_argument(
       '''--decoder_config_path''',
       default='''facebook/mbart-large-50-one-to-many-mmt''',
       type=str,
       help='''Path to hf decoder checkpoint config''',
   )
   parser.add_argument('''--add_adapter''', default=True, type=bool, help='''whethere to add model adapter layers''')
   parser.add_argument('''--adapter_stride''', default=2, type=int, help='''stride of adapter layers''')
   parser.add_argument('''--adapter_kernel_size''', default=3, type=int, help='''kernel size of adapter layers''')
   parser.add_argument('''--encoder_output_dim''', default=1024, type=int, help='''encoder output dim''')
   parser.add_argument('''--start_token_id''', default=250004, type=int, help='''`decoder_start_token_id` of model config''')

   UpperCamelCase_		:     Tuple          =		parser.parse_args()
   convert_wavaveca_checkpoint(
       args.checkpoint_path,
       args.pytorch_dump_folder_path,
       args.dict_path,
       args.config_yaml_path,
       encoder_config_path=args.encoder_config_path,
       decoder_config_path=args.decoder_config_path,
       add_adapter=args.add_adapter,
       adapter_kernel_size=args.adapter_kernel_size,
       adapter_stride=args.adapter_stride,
       decoder_start_token_id=args.start_token_id,
       encoder_output_dim=args.encoder_output_dim,
   )


