

"""simple docstring"""




import argparse
import glob
import importlib.util
import os
import re

import black
from doc_builder.style_doc import style_docstrings_in_code


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
_lowercase					:     Dict				 =		'src/diffusers'
_lowercase					:     Any				 =		'.'


# This is to make sure the diffusers module imported is the one in the repo.
_lowercase					:     List[Any]				 =		importlib.util.spec_from_file_location(
    'diffusers',
    os.path.join(DIFFUSERS_PATH, '__init__.py'),
    submodule_search_locations=[DIFFUSERS_PATH],
)
_lowercase					:     int				 =		spec.loader.load_module()





def 	lowercase__		(    snake_case_					:Optional[Any]       ,						snake_case_					:Optional[Any]  ):
	return line.startswith(UpperCamelCase__  ) or len(UpperCamelCase__  ) <= 1 or re.search(r'''^\s*\)(\s*->.*:|:)\s*$'''       ,						UpperCamelCase__  ) is not None





def 	lowercase__		(    snake_case_					:Tuple  ):
	__UpperCAmelCase							=      object_name.split('''.'''  )
	__UpperCAmelCase							=      0

	# First let's find the module where our object lives.
	__UpperCAmelCase							=      parts[i]
	while i < len(UpperCamelCase__  ) and not os.path.isfile(os.path.join(UpperCamelCase__       ,						F'''{module}.py'''  )  ):
		i += 1
		if i < len(UpperCamelCase__  ):
			__UpperCAmelCase							=      os.path.join(UpperCamelCase__       ,						parts[i]  )
	if i >= len(UpperCamelCase__  ):
		raise ValueError(F'''`object_name` should begin with the name of a module of diffusers but got {object_name}.'''  )

	with open(os.path.join(UpperCamelCase__       ,						F'''{module}.py'''  )       ,						'''r'''       ,						encoding='''utf-8'''       ,						newline='''\n'''  ) as f:
		__UpperCAmelCase							=      f.readlines()

	# Now let's find the class / func in the code!
	__UpperCAmelCase							=      ''''''
	__UpperCAmelCase							=      0
	for name in parts[i + 1 :]:
		while (
		    line_index < len(UpperCamelCase__  ) and re.search(rF'''^{indent}(class|def)\s+{name}(\(|\:)'''       ,						lines[line_index]  ) is None
		):
			line_index += 1
		indent += "    "
		line_index += 1

	if line_index >= len(UpperCamelCase__  ):
		raise ValueError(F''' {object_name} does not match any function or class in {module}.'''  )

	# We found the beginning of the class / func, now let's find the end (when the indent diminishes).
	__UpperCAmelCase							=      line_index
	while line_index < len(UpperCamelCase__  ) and _should_continue(lines[line_index]       ,						UpperCamelCase__  ):
		line_index += 1
	# Clean up empty lines at the end (if any).
	while len(lines[line_index - 1]  ) <= 1:
		line_index -= 1

	__UpperCAmelCase							=      lines[start_index:line_index]
	return "".join(UpperCamelCase__  )


_lowercase					:     List[str]				 =		re.compile(r'^(\s*)#\s*Copied from\s+diffusers\.(\S+\.\S+)\s*($|\S.*$)')
_lowercase					:     List[Any]				 =		re.compile(r'^\s*(\S+)->(\S+)(\s+.*|$)')
_lowercase					:     List[Any]				 =		re.compile(r'<FILL\s+[^>]*>')





def 	lowercase__		(    snake_case_					:int  ):
	__UpperCAmelCase							=      code.split('''\n'''  )
	__UpperCAmelCase							=      0
	while idx < len(UpperCamelCase__  ) and len(lines[idx]  ) == 0:
		idx += 1
	if idx < len(UpperCamelCase__  ):
		return re.search(r'''^(\s*)\S'''       ,						lines[idx]  ).groups()[0]
	return ""





def 	lowercase__		(    snake_case_					:Tuple  ):
	__UpperCAmelCase							=      len(get_indent(UpperCamelCase__  )  ) > 0
	if has_indent:
		__UpperCAmelCase							=      F'''class Bla:\n{code}'''
	__UpperCAmelCase							=      black.Mode(target_versions={black.TargetVersion.PYaa}       ,						line_length=119       ,						preview=UpperCamelCase__  )
	__UpperCAmelCase							=      black.format_str(UpperCamelCase__       ,						mode=UpperCamelCase__  )
	__UpperCAmelCase						,				__UpperCAmelCase							=      style_docstrings_in_code(UpperCamelCase__  )
	return result[len('''class Bla:\n'''  ) :] if has_indent else result





def 	lowercase__		(    snake_case_					:Optional[Any]       ,						snake_case_					:Tuple=False  ):


	with open(UpperCamelCase__       ,						'''r'''       ,						encoding='''utf-8'''       ,						newline='''\n'''  ) as f:
		__UpperCAmelCase							=      f.readlines()
	__UpperCAmelCase							=      []
	__UpperCAmelCase							=      0
	# Not a for loop cause `lines` is going to change (if `overwrite=True`).
	while line_index < len(UpperCamelCase__  ):
		__UpperCAmelCase							=      _re_copy_warning.search(lines[line_index]  )
		if search is None:
			line_index += 1
			continue

		# There is some copied code here, let's retrieve the original.
		__UpperCAmelCase						,				__UpperCAmelCase						,				__UpperCAmelCase							=      search.groups()
		__UpperCAmelCase							=      find_code_in_diffusers(UpperCamelCase__  )
		__UpperCAmelCase							=      get_indent(UpperCamelCase__  )

		__UpperCAmelCase							=      line_index + 1 if indent == theoretical_indent else line_index + 2
		__UpperCAmelCase							=      theoretical_indent
		__UpperCAmelCase							=      start_index

		# Loop to check the observed code, stop when indentation diminishes or if we see a End copy comment.
		__UpperCAmelCase							=      True
		while line_index < len(UpperCamelCase__  ) and should_continue:
			line_index += 1
			if line_index >= len(UpperCamelCase__  ):
				break
			__UpperCAmelCase							=      lines[line_index]
			__UpperCAmelCase							=      _should_continue(UpperCamelCase__       ,						UpperCamelCase__  ) and re.search(F'''^{indent}# End copy'''       ,						UpperCamelCase__  ) is None
		# Clean up empty lines at the end (if any).
		while len(lines[line_index - 1]  ) <= 1:
			line_index -= 1

		__UpperCAmelCase							=      lines[start_index:line_index]
		__UpperCAmelCase							=      ''''''.join(UpperCamelCase__  )

		# Remove any nested `Copied from` comments to avoid circular copies
		__UpperCAmelCase							=      [line for line in theoretical_code.split('''\n'''  ) if _re_copy_warning.search(UpperCamelCase__  ) is None]
		__UpperCAmelCase							=      '''\n'''.join(UpperCamelCase__  )

		# Before comparing, use the `replace_pattern` on the original code.
		if len(UpperCamelCase__  ) > 0:
			__UpperCAmelCase							=      replace_pattern.replace('''with'''       ,						''''''  ).split(''','''  )
			__UpperCAmelCase							=      [_re_replace_pattern.search(UpperCamelCase__  ) for p in patterns]
			for pattern in patterns:
				if pattern is None:
					continue
				__UpperCAmelCase						,				__UpperCAmelCase						,				__UpperCAmelCase							=      pattern.groups()
				__UpperCAmelCase							=      re.sub(UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__  )
				if option.strip() == "all-casing":
					__UpperCAmelCase							=      re.sub(obja.lower()       ,						obja.lower()       ,						UpperCamelCase__  )
					__UpperCAmelCase							=      re.sub(obja.upper()       ,						obja.upper()       ,						UpperCamelCase__  )

            # Blackify after replacement. To be able to do that, we need the header (class or function definition)
            # from the previous line
			__UpperCAmelCase							=      blackify(lines[start_index - 1] + theoretical_code  )
			__UpperCAmelCase							=      theoretical_code[len(lines[start_index - 1]  ) :]

		# Test for a diff and act accordingly.
		if observed_code != theoretical_code:
			diffs.append([object_name, start_index]  )
			if overwrite:
				__UpperCAmelCase							=      lines[:start_index] + [theoretical_code] + lines[line_index:]
				__UpperCAmelCase							=      start_index + 1

	if overwrite and len(UpperCamelCase__  ) > 0:
		# Warn the user a file has been modified.
		print(F'''Detected changes, rewriting {filename}.'''  )
		with open(UpperCamelCase__       ,						'''w'''       ,						encoding='''utf-8'''       ,						newline='''\n'''  ) as f:
			f.writelines(UpperCamelCase__  )
	return diffs





def 	lowercase__		(    snake_case_					:bool = False  ):
	__UpperCAmelCase							=      glob.glob(os.path.join(UpperCamelCase__       ,						'''**/*.py'''  )       ,						recursive=UpperCamelCase__  )
	__UpperCAmelCase							=      []
	for filename in all_files:
		__UpperCAmelCase							=      is_copy_consistent(UpperCamelCase__       ,						UpperCamelCase__  )
		diffs += [F'''- {filename}: copy does not match {d[0]} at line {d[1]}''' for d in new_diffs]
	if not overwrite and len(UpperCamelCase__  ) > 0:
		__UpperCAmelCase							=      '''\n'''.join(UpperCamelCase__  )
		raise Exception(
		    '''Found the following copy inconsistencies:\n'''
		    + diff
		    + '''\nRun `make fix-copies` or `python utils/check_copies.py --fix_and_overwrite` to fix them.'''  )


if __name__ == "__main__":
				_lowercase					:     Any				 =		argparse.ArgumentParser()
				parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
				_lowercase					:     Union[str, Any]				 =		parser.parse_args()

				check_copies(args.fix_and_overwrite)






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()
__A        =    logging.get_logger(__name__)

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







def 			lowerCamelCase_		(       UpperCamelCase__				:      Any ,     UpperCamelCase__				:      Any ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[int]      )     ->       Tuple:





				"""simple docstring"""


				for attribute in key.split('.'      ):
								__lowerCamelCase		       =    getattr(UpperCamelCase__ ,     UpperCamelCase__      )

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

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







def 			lowerCamelCase_		(       UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Tuple      )     ->       Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    []
				__lowerCamelCase		       =    fairseq_model.state_dict()

				__lowerCamelCase		       =    hf_model.feature_extractor
				__lowerCamelCase		       =    hf_model.adapter

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





				"""simple docstring"""


				__lowerCamelCase		       =    full_name.split('conv_layers.'      )[-1]
				__lowerCamelCase		       =    name.split('.'      )
				__lowerCamelCase		       =    int(items[0]      )
				__lowerCamelCase		       =    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."""
												)
												__lowerCamelCase		       =    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."""
												)
												__lowerCamelCase		       =    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."
												)
												__lowerCamelCase		       =    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."""
												)
												__lowerCamelCase		       =    value
												logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""      )
				else:
								unused_weights.append(UpperCamelCase__      )







def 			lowerCamelCase_		(       UpperCamelCase__				:      Tuple ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Any ,     UpperCamelCase__				:      int      )     ->       Union[str, Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    full_name.split('adaptor.'      )[-1]
				__lowerCamelCase		       =    name.split('.'      )

				if items[1].isdigit():
								__lowerCamelCase		       =    int(items[1]      )
				else:
								__lowerCamelCase		       =    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."""
																__lowerCamelCase		       =    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."""
																__lowerCamelCase		       =    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."""
																__lowerCamelCase		       =    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."""
																__lowerCamelCase		       =    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."""
												__lowerCamelCase		       =    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."""
												__lowerCamelCase		       =    value
												logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""      )
				else:
								unused_weights.append(UpperCamelCase__      )







def 			lowerCamelCase_		(       UpperCamelCase__				:      Tuple      )     ->       Tuple:





				"""simple docstring"""


				__lowerCamelCase       ,						__lowerCamelCase		       =    emb.weight.shape
				__lowerCamelCase		       =    nn.Linear(UpperCamelCase__ ,     UpperCamelCase__ ,     bias=UpperCamelCase__      )
				__lowerCamelCase		       =    emb.weight.data
				return lin_layer







@torch.no_grad()
def 			lowerCamelCase_		(       UpperCamelCase__				:      List[str] ,     UpperCamelCase__				:      List[Any] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Dict ,     UpperCamelCase__				:      List[str] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[int] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      str ,     UpperCamelCase__				:      Optional[Any] ,     )     ->       str:





				"""simple docstring"""


				__lowerCamelCase		       =    WavaVecaConfig.from_pretrained(
				    UpperCamelCase__ ,     add_adapter=UpperCamelCase__ ,     adapter_stride=UpperCamelCase__ ,     adapter_kernel_size=UpperCamelCase__ ,     use_auth_token=UpperCamelCase__ ,     output_hidden_size=UpperCamelCase__ ,     )
				__lowerCamelCase		       =    MBartConfig.from_pretrained(UpperCamelCase__      )

				# load model
				__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    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,
				    } ,     )
				__lowerCamelCase		       =    model[0].eval()

				# load feature extractor
				__lowerCamelCase		       =    WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__ ,     use_auth_token=UpperCamelCase__      )

				# set weights for wav2vec2 encoder
				__lowerCamelCase		       =    WavaVecaModel(UpperCamelCase__      )

				recursively_load_weights_wavaveca(model.encoder ,     UpperCamelCase__      )

				# load decoder weights
				__lowerCamelCase		       =    MBartForCausalLM(UpperCamelCase__      )
				__lowerCamelCase       ,						__lowerCamelCase		       =    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}"""      )

				__lowerCamelCase		       =    SpeechEncoderDecoderModel(encoder=UpperCamelCase__ ,     decoder=UpperCamelCase__      )
				__lowerCamelCase		       =    False

				__lowerCamelCase		       =    MBartaaTokenizer(UpperCamelCase__      )
				tokenizer.save_pretrained(UpperCamelCase__      )

				__lowerCamelCase		       =    hf_wavavec.config.to_dict()
				__lowerCamelCase		       =    tokenizer.pad_token_id
				__lowerCamelCase		       =    tokenizer.bos_token_id
				__lowerCamelCase		       =    tokenizer.eos_token_id
				__lowerCamelCase		       =    'mbart50'
				__lowerCamelCase		       =    'wav2vec2'

				__lowerCamelCase		       =    tokenizer.eos_token_id
				__lowerCamelCase		       =    25_0004
				__lowerCamelCase		       =    tokenizer.eos_token_id

				__lowerCamelCase		       =    SpeechEncoderDecoderConfig.from_dict(UpperCamelCase__      )

				hf_wavavec.save_pretrained(UpperCamelCase__      )
				feature_extractor.save_pretrained(UpperCamelCase__      )


if __name__ == "__main__":
					__A        =    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=10_24, type=int, help="encoder output dim")
					parser.add_argument("--start_token_id", default=25_00_04, type=int, help="`decoder_start_token_id` of model config")

					__A        =    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,
					)


