


"""simple docstring"""






import argparse
import os
import re


__snake_case				=				'src/diffusers'

# Pattern that looks at the indentation in a line.
__snake_case				=				re.compile(r'''^(\s*)\S''')
# Pattern that matches `"key":" and puts `key` in group 0.
__snake_case				=				re.compile(r'''^\s*"([^"]+)":''')
# Pattern that matches `_import_structure["key"]` and puts `key` in group 0.
__snake_case				=				re.compile(r'''^\s*_import_structure\["([^"]+)"\]''')
# Pattern that matches `"key",` and puts `key` in group 0.
__snake_case				=				re.compile(r'''^\s*"([^"]+)",\s*$''')
# Pattern that matches any `[stuff]` and puts `stuff` in group 0.
__snake_case				=				re.compile(r'''\[([^\]]+)\]''')
def 					A_      (      _lowerCAmelCase   :    Optional[Any]				):






     """simple docstring"""

     _a					= _re_indent.search(_SCREAMING_SNAKE_CASE				)
     return "" if search is None else search.groups()[0]
def 					A_      (      _lowerCAmelCase   :    Optional[int],   _lowerCAmelCase   :    Optional[int]="",   _lowerCAmelCase   :    Any=None,   _lowerCAmelCase   :    Dict=None				):






     """simple docstring"""

     _a					= 0
     _a					= code.split('''\n'''				)
     if start_prompt is not None:
          while not lines[index].startswith(_SCREAMING_SNAKE_CASE				):
               index += 1
          _a					= ['\n'.join(lines[:index]				)]
     else:
          _a					= []

     # We split into blocks until we get to the `end_prompt` (or the end of the block).
     _a					= [lines[index]]
     index += 1
     while index < len(_SCREAMING_SNAKE_CASE				) and (end_prompt is None or not lines[index].startswith(_SCREAMING_SNAKE_CASE				)):
          if len(lines[index]				) > 0 and get_indent(lines[index]				) == indent_level:
               if len(_SCREAMING_SNAKE_CASE				) > 0 and get_indent(current_block[-1]				).startswith(indent_level + ''' '''				):
                    current_block.append(lines[index]				)
                    blocks.append('''\n'''.join(_SCREAMING_SNAKE_CASE				)				)
                    if index < len(_SCREAMING_SNAKE_CASE				) - 1:
                         _a					= [lines[index + 1]]
                         index += 1
                    else:
                         _a					= []
               else:
                    blocks.append('''\n'''.join(_SCREAMING_SNAKE_CASE				)				)
                    _a					= [lines[index]]
          else:
               current_block.append(lines[index]				)
          index += 1

     # Adds current block if it's nonempty.
     if len(_SCREAMING_SNAKE_CASE				) > 0:
          blocks.append('''\n'''.join(_SCREAMING_SNAKE_CASE				)				)

     # Add final block after end_prompt if provided.
     if end_prompt is not None and index < len(_SCREAMING_SNAKE_CASE				):
          blocks.append('''\n'''.join(lines[index:]				)				)

     return blocks
def 					A_      (      _lowerCAmelCase   :    Union[str, Any]				):






     """simple docstring"""

     def _inner(_lowerCAmelCase   :    Optional[int]				):
          return key(_SCREAMING_SNAKE_CASE				).lower().replace('''_''',   ''''''				)

     return _inner
def 					A_      (      _lowerCAmelCase   :    Union[str, Any],   _lowerCAmelCase   :    Optional[Any]=None				):






     """simple docstring"""

     def noop(_lowerCAmelCase   :    int				):
          return x

     if key is None:
          _a					= noop
     # Constants are all uppercase, they go first.
     _a					= [obj for obj in objects if key(_SCREAMING_SNAKE_CASE				).isupper()]
     # Classes are not all uppercase but start with a capital, they go second.
     _a					= [obj for obj in objects if key(_SCREAMING_SNAKE_CASE				)[0].isupper() and not key(_SCREAMING_SNAKE_CASE				).isupper()]
     # Functions begin with a lowercase, they go last.
     _a					= [obj for obj in objects if not key(_SCREAMING_SNAKE_CASE				)[0].isupper()]

     _a					= ignore_underscore(_SCREAMING_SNAKE_CASE				)
     return sorted(_SCREAMING_SNAKE_CASE,   key=_SCREAMING_SNAKE_CASE				) + sorted(_SCREAMING_SNAKE_CASE,   key=_SCREAMING_SNAKE_CASE				) + sorted(_SCREAMING_SNAKE_CASE,   key=_SCREAMING_SNAKE_CASE				)
def 					A_      (      _lowerCAmelCase   :    str				):






     """simple docstring"""

     def _replace(_lowerCAmelCase   :    List[str]				):
          _a					= match.groups()[0]
          if "," not in imports:
               return f'[{imports}]'
          _a					= [part.strip().replace('''"''',   ''''''				) for part in imports.split(''','''				)]
          # We will have a final empty element if the line finished with a comma.
          if len(keys[-1]				) == 0:
               _a					= keys[:-1]
          return "[" + ", ".join([f'\"{k}\"' for k in sort_objects(_SCREAMING_SNAKE_CASE				)]				) + "]"

     _a					= import_statement.split('''\n'''				)
     if len(_SCREAMING_SNAKE_CASE				) > 3:
          # Here we have to sort internal imports that are on several lines (one per name):
          # key: [
          #     "object1",
          #     "object2",
          #     ...
          # ]

          # We may have to ignore one or two lines on each side.
          _a					= 2 if lines[1].strip() == '[' else 1
          _a					= [(i, _re_strip_line.search(_SCREAMING_SNAKE_CASE				).groups()[0]) for i, line in enumerate(lines[idx:-idx]				)]
          _a					= sort_objects(_SCREAMING_SNAKE_CASE,   key=lambda _lowerCAmelCase				: x[1]				)
          _a					= [lines[x[0] + idx] for x in sorted_indices]
          return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]				)
     elif len(_SCREAMING_SNAKE_CASE				) == 3:
          # Here we have to sort internal imports that are on one separate line:
          # key: [
          #     "object1", "object2", ...
          # ]
          if _re_bracket_content.search(lines[1]				) is not None:
               _a					= _re_bracket_content.sub(_replace,   lines[1]				)
          else:
               _a					= [part.strip().replace('''"''',   ''''''				) for part in lines[1].split(''','''				)]
               # We will have a final empty element if the line finished with a comma.
               if len(keys[-1]				) == 0:
                    _a					= keys[:-1]
               _a					= get_indent(lines[1]				) + ', '.join([f'\"{k}\"' for k in sort_objects(_SCREAMING_SNAKE_CASE				)]				)
          return "\n".join(_SCREAMING_SNAKE_CASE				)
     else:
          # Finally we have to deal with imports fitting on one line
          _a					= _re_bracket_content.sub(_replace,   _SCREAMING_SNAKE_CASE				)
          return import_statement
def 					A_      (      _lowerCAmelCase   :    Optional[int],   _lowerCAmelCase   :    Union[str, Any]=True				):






     """simple docstring"""

     with open(_SCREAMING_SNAKE_CASE,   '''r'''				) as f:
          _a					= f.read()

     if "_import_structure" not in code:
          return

     # Blocks of indent level 0
     _a					= split_code_in_indented_blocks(
         _SCREAMING_SNAKE_CASE,   start_prompt='''_import_structure = {''',   end_prompt='''if TYPE_CHECKING:'''				)

     # We ignore block 0 (everything until start_prompt) and the last block (everything after end_prompt).
     for block_idx in range(1,   len(_SCREAMING_SNAKE_CASE				) - 1				):
          # Check if the block contains some `_import_structure`s thingy to sort.
          _a					= main_blocks[block_idx]
          _a					= block.split('''\n'''				)

          # Get to the start of the imports.
          _a					= 0
          while line_idx < len(_SCREAMING_SNAKE_CASE				) and "_import_structure" not in block_lines[line_idx]:
               # Skip dummy import blocks
               if "import dummy" in block_lines[line_idx]:
                    _a					= len(_SCREAMING_SNAKE_CASE				)
               else:
                    line_idx += 1
          if line_idx >= len(_SCREAMING_SNAKE_CASE				):
               continue

          # Ignore beginning and last line: they don't contain anything.
          _a					= '\n'.join(block_lines[line_idx:-1]				)
          _a					= get_indent(block_lines[1]				)
          # Slit the internal block into blocks of indent level 1.
          _a					= split_code_in_indented_blocks(_SCREAMING_SNAKE_CASE,   indent_level=_SCREAMING_SNAKE_CASE				)
          # We have two categories of import key: list or _import_structure[key].append/extend
          _a					= _re_direct_key if '_import_structure' in block_lines[0] else _re_indirect_key
          # Grab the keys, but there is a trap: some lines are empty or just comments.
          _a					= [(pattern.search(_SCREAMING_SNAKE_CASE				).groups()[0] if pattern.search(_SCREAMING_SNAKE_CASE				) is not None else None) for b in internal_blocks]
          # We only sort the lines with a key.
          _a					= [(i, key) for i, key in enumerate(_SCREAMING_SNAKE_CASE				) if key is not None]
          _a					= [x[0] for x in sorted(_SCREAMING_SNAKE_CASE,   key=lambda _lowerCAmelCase				: x[1]				)]

          # We reorder the blocks by leaving empty lines/comments as they were and reorder the rest.
          _a					= 0
          _a					= []
          for i in range(len(_SCREAMING_SNAKE_CASE				)				):
               if keys[i] is None:
                    reordered_blocks.append(internal_blocks[i]				)
               else:
                    _a					= sort_objects_in_import(internal_blocks[sorted_indices[count]]				)
                    reordered_blocks.append(_SCREAMING_SNAKE_CASE				)
                    count += 1

        # And we put our main block back together with its first and last line.
          _a					= '\n'.join(block_lines[:line_idx] + reordered_blocks + [block_lines[-1]]				)

     if code != "\n".join(_SCREAMING_SNAKE_CASE				):
          if check_only:
               return True
          else:
               print(f'Overwriting {file}.'				)
               with open(_SCREAMING_SNAKE_CASE,   '''w'''				) as f:
                    f.write('''\n'''.join(_SCREAMING_SNAKE_CASE				)				)
def 					A_      (      _lowerCAmelCase   :    Union[str, Any]=True				):






     """simple docstring"""

     _a					= []
     for root, _, files in os.walk(_SCREAMING_SNAKE_CASE				):
          if "__init__.py" in files:
               _a					= sort_imports(os.path.join(_SCREAMING_SNAKE_CASE,   '''__init__.py'''				),   check_only=_SCREAMING_SNAKE_CASE				)
               if result:
                    _a					= [os.path.join(_SCREAMING_SNAKE_CASE,   '''__init__.py'''				)]
     if len(_SCREAMING_SNAKE_CASE				) > 0:
          raise ValueError(f'Would overwrite {len(_SCREAMING_SNAKE_CASE				)} files, run `make style`.'				)


if __name__ == "__main__":
   __snake_case				=				argparse.ArgumentParser()
   parser.add_argument('''--check_only''', action='''store_true''', help='''Whether to only check or fix style.''')
   __snake_case				=				parser.parse_args()

   sort_imports_in_all_inits(check_only=args.check_only)



'''simple docstring'''



import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
__lowercase	:						Union[str, Any]       =	logging.get_logger(__name__)

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






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple						,      _SCREAMING_SNAKE_CASE      :   Union[str, Any]						,      _SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   Dict   ):
					for attribute in key.split('.'   ):
										__a			:       Any					    =  getattr(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					if weight_type is not None:
										__a			:       List[Any]					    =  getattr(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   ).shape
					else:
										__a			:       Any					    =  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":
										__a			:       Tuple					    =  value
					elif weight_type == "weight_g":
										__a			:       str					    =  value
					elif weight_type == "weight_v":
										__a			:       Optional[Any]					    =  value
					elif weight_type == "bias":
										__a			:       Union[str, Any]					    =  value
					else:
										__a			:       List[Any]					    =  value

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






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict						,      _SCREAMING_SNAKE_CASE      :   Optional[Any]   ):
					__a			:       int					    =  []
					__a			:       List[str]					    =  fairseq_model.state_dict()

					__a			:       Tuple					    =  hf_model.feature_extractor

					# if encoder has different dim to decoder -> use proj_weight
					__a			:       int					    =  None

					for name, value in fairseq_dict.items():
										__a			:       List[str]					    =  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'						,      )
															__a			:       List[str]					    =  True
										elif name.split('.'   )[0] == "proj":
															__a			:       Tuple					    =  fairseq_model.proj
															__a			:       str					    =  True
										else:
															for key, mapped_key in MAPPING.items():
																				if key in name or key.split('w2v_model.'   )[-1] == name.split('.'   )[0]:
																									__a			:       List[Any]					    =  True
																									if "*" in mapped_key:
																														__a			:       str					    =  name.split(_SCREAMING_SNAKE_CASE   )[0].split('.'   )[-2]
																														__a			:       int					    =  mapped_key.replace('*'						,      _SCREAMING_SNAKE_CASE   )
																									if "weight_g" in name:
																														__a			:       List[Any]					    =  'weight_g'
																									elif "weight_v" in name:
																														__a			:       List[Any]					    =  'weight_v'
																									elif "bias" in name:
																														__a			:       Optional[Any]					    =  'bias'
																									elif "weight" in name:
																														__a			:       Tuple					    =  'weight'
																									else:
																														__a			:       Optional[Any]					    =  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}"""   )

					return proj_weight






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   Dict						,      _SCREAMING_SNAKE_CASE      :   Optional[int]						,      _SCREAMING_SNAKE_CASE      :   List[Any]						,      _SCREAMING_SNAKE_CASE      :   Optional[Any]   ):
					__a			:       List[str]					    =  full_name.split('conv_layers.'   )[-1]
					__a			:       Any					    =  name.split('.'   )
					__a			:       List[str]					    =  int(items[0]   )
					__a			:       List[Any]					    =  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."""
															)
															__a			:       List[str]					    =  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."""
															)
															__a			:       str					    =  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."
															)
															__a			:       Tuple					    =  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."""
															)
															__a			:       List[Any]					    =  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   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int   ):
					__a    ,				__a			:       List[str]					    =  emb.weight.shape
					__a			:       str					    =  nn.Linear(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      bias=_SCREAMING_SNAKE_CASE   )
					__a			:       Optional[int]					    =  emb.weight.data
					return lin_layer






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any   ):
					with open(_SCREAMING_SNAKE_CASE						,      'r'						,      encoding='utf-8'   ) as f:
										__a			:       Union[str, Any]					    =  f.readlines()
										__a			:       Tuple					    =  [line.split(' '   )[0] for line in lines]

					__a			:       int					    =  len(_SCREAMING_SNAKE_CASE   )

					__a			:       List[Any]					    =  {
					    '<s>': 0,
					    '<pad>': 1,
					    '</s>': 2,
					    '<unk>': 3,
					}

					vocab_dict.update(dict(zip(_SCREAMING_SNAKE_CASE						,      range(4						,      num_words + 4   )   )   )   )
					return vocab_dict






@torch.no_grad()
def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]						,      _SCREAMING_SNAKE_CASE      :   List[Any]						,      _SCREAMING_SNAKE_CASE      :   str						,      _SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   str						,      _SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   Optional[int]						,      ):
					__a			:       Optional[int]					    =  WavaVecaConfig.from_pretrained(_SCREAMING_SNAKE_CASE   )
					__a			:       Any					    =  SpeechaTextaConfig.from_pretrained(
					    _SCREAMING_SNAKE_CASE						,      vocab_size=_SCREAMING_SNAKE_CASE						,      decoder_layers=_SCREAMING_SNAKE_CASE						,      do_stable_layer_norm=_SCREAMING_SNAKE_CASE   )

					__a			:       Dict					    =  WavaVecaFeatureExtractor(
					    feature_size=1						,      sampling_rate=16_000						,      padding_value=0						,      do_normalize=_SCREAMING_SNAKE_CASE						,      return_attention_mask=_SCREAMING_SNAKE_CASE						,      )

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

					# set weights for wav2vec2 encoder
					__a			:       Tuple					    =  WavaVecaModel(_SCREAMING_SNAKE_CASE   )
					__a			:       int					    =  recursively_load_weights_wavaveca(model.encoder						,      _SCREAMING_SNAKE_CASE   )

					__a			:       Dict					    =  SpeechaTextaForCausalLM(_SCREAMING_SNAKE_CASE   )
					__a    ,				__a			:       Optional[int]					    =  hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()						,      strict=_SCREAMING_SNAKE_CASE   )

					# set output linear layer
					unexpected_keys.remove('embed_out'   )
					__a			:       Optional[Any]					    =  nn.Parameter(model.decoder.embed_out.detach()   )

					# layer norm is init to identity matrix so leaving it is fine
					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}"""   )

					__a			:       Tuple					    =  SpeechEncoderDecoderModel(encoder=_SCREAMING_SNAKE_CASE						,      decoder=_SCREAMING_SNAKE_CASE   )
					__a			:       int					    =  False

					# add projection layer
					__a			:       str					    =  nn.Parameter(projection_layer.weight   )
					__a			:       Any					    =  nn.Parameter(projection_layer.bias   )

					__a			:       str					    =  create_vocab_dict(_SCREAMING_SNAKE_CASE   )

					with open(os.path.join(_SCREAMING_SNAKE_CASE						,      'vocab.json'   )						,      'w'   ) as fp:
										json.dump(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					__a			:       Optional[Any]					    =  SpeechaTextaTokenizer(os.path.join(_SCREAMING_SNAKE_CASE						,      'vocab.json'   )   )
					tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE   )

					__a			:       Union[str, Any]					    =  hf_wavavec.config.to_dict()
					__a			:       Tuple					    =  tokenizer.pad_token_id
					__a			:       Optional[int]					    =  tokenizer.bos_token_id
					__a			:       Union[str, Any]					    =  tokenizer.eos_token_id
					__a			:       Tuple					    =  'speech_to_text_2'
					__a			:       Tuple					    =  'wav2vec2'

					__a			:       List[str]					    =  SpeechEncoderDecoderConfig.from_dict(_SCREAMING_SNAKE_CASE   )

					hf_wavavec.save_pretrained(_SCREAMING_SNAKE_CASE   )
					feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
	__lowercase	:						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(
	    '--encoder_config_path',
	    default='facebook/wav2vec2-large-lv60',
	    type=str,
	    help='Path to hf encoder wav2vec2 checkpoint config',
	)
	parser.add_argument(
	    '--decoder_config_path',
	    default='facebook/s2t-small-mustc-en-fr-st',
	    type=str,
	    help='Path to hf decoder s2t checkpoint config',
	)
	parser.add_argument('--vocab_size', default=1_02_24, type=int, help='Vocab size of decoder')
	parser.add_argument('--num_decoder_layers', default=7, type=int, help='Number of decoder layers')

	__lowercase	:						Tuple       =	parser.parse_args()
	convert_wavaveca_checkpoint(
	    args.checkpoint_path,
	    args.pytorch_dump_folder_path,
	    args.dict_path,
	    encoder_config_path=args.encoder_config_path,
	    decoder_config_path=args.decoder_config_path,
	    vocab_size=args.vocab_size,
	    num_decoder_layers=args.num_decoder_layers,
	)



