


'''simple docstring'''
import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


lowerCAmelCase   : Any             =				logging.get_logger(__name__)  # pylint: disable=invalid-name




class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE):


				'''simple docstring'''


				def __init__(     self							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      )    ->  Union[str, Any]:
					super().__init__()
					self.register_modules(
					    vae=a_							,      text_encoder=a_							,      tokenizer=a_							,      unet=a_							,      scheduler=a_							,      safety_checker=a_							,      feature_extractor=a_							,      )

				def 	a__		(     self							,      a_ = "auto"							)    ->  Dict:
					if slice_size == "auto":
						# half the attention head size is usually a good trade-off between
						# speed and memory
						lowercase						:		Union[str, Any]   					=		self.unet.config.attention_head_dim // 2
					self.unet.set_attention_slice(a_							)

				def 	a__		(     self							)    ->  Dict:
					self.enable_attention_slicing(a_							)


				@torch.no_grad()
				def __call__(     self							,      a_							,      a_ = 5_1_2							,      a_ = 5_1_2							,      a_ = 5_0							,      a_ = 7.5							,      a_ = None							,      a_ = 1							,      a_ = 0.0							,      a_ = None							,      a_ = None							,      a_ = "pil"							,      a_ = True							,      a_ = None							,      a_ = 1							,      a_ = None							,      **a_							,      )    ->  Union[str, Any]:

					if isinstance(a_							,      a_							):
						lowercase						:		Tuple   					=		1
					elif isinstance(a_							,      a_							):
						lowercase						:		int   					=		len(a_							)
					else:
						raise ValueError(F'''`prompt` has to be of type `str` or `list` but is {type(a_							)}'''							)

					if height % 8 != 0 or width % 8 != 0:
						raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''							)

					if (callback_steps is None) or (
					    callback_steps is not None and (not isinstance(a_							,      a_							) or callback_steps <= 0)
					):
						raise ValueError(
						    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
						    F''' {type(a_							)}.'''							)

					# get prompt text embeddings
					lowercase						:		int   					=		self.tokenizer(
					    a_							,      padding="max_length"							,      max_length=self.tokenizer.model_max_length							,      return_tensors="pt"							,      )
					lowercase						:		List[Any]   					=		text_inputs.input_ids

					if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
						lowercase						:		str   					=		self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]							)
						logger.warning(
						    "The following part of your input was truncated because CLIP can only handle sequences up to"
						    F''' {self.tokenizer.model_max_length} tokens: {removed_text}'''							)
						lowercase						:		Dict   					=		text_input_ids[:, : self.tokenizer.model_max_length]

					if text_embeddings is None:
						lowercase						:		List[Any]   					=		self.text_encoder(text_input_ids.to(self.device							)							)[0]

					# duplicate text embeddings for each generation per prompt, using mps friendly method
					lowercase					,		lowercase					,		lowercase						:		List[Any]   					=		text_embeddings.shape
					lowercase						:		Tuple   					=		text_embeddings.repeat(1							,      a_							,      1							)
					lowercase						:		Optional[int]   					=		text_embeddings.view(bs_embed * num_images_per_prompt							,      a_							,      -1							)

					# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
					# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
					# corresponds to doing no classifier free guidance.
					lowercase						:		str   					=		guidance_scale > 1.0
					# get unconditional embeddings for classifier free guidance
					if do_classifier_free_guidance:
						lowercase						:		List[str]
						if negative_prompt is None:
							lowercase						:		Optional[Any]   					=		[""]
						elif type(a_							) is not type(a_							):
							raise TypeError(
							    F'''`negative_prompt` should be the same type to `prompt`, but got {type(a_							)} !='''
							    F''' {type(a_							)}.'''							)
						elif isinstance(a_							,      a_							):
							lowercase						:		Tuple   					=		[negative_prompt]
						elif batch_size != len(a_							):
							raise ValueError(
							    F'''`negative_prompt`: {negative_prompt} has batch size {len(a_							)}, but `prompt`:'''
							    F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
							    " the batch size of `prompt`."							)
						else:
							lowercase						:		Dict   					=		negative_prompt

						lowercase						:		Tuple   					=		text_input_ids.shape[-1]
						lowercase						:		Any   					=		self.tokenizer(
						    a_							,      padding="max_length"							,      max_length=a_							,      truncation=a_							,      return_tensors="pt"							,      )
						lowercase						:		Any   					=		self.text_encoder(uncond_input.input_ids.to(self.device							)							)[0]

						# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
						lowercase						:		Union[str, Any]   					=		uncond_embeddings.shape[1]
						lowercase						:		Tuple   					=		uncond_embeddings.repeat(a_							,      a_							,      1							)
						lowercase						:		Optional[int]   					=		uncond_embeddings.view(batch_size * num_images_per_prompt							,      a_							,      -1							)

						# For classifier free guidance, we need to do two forward passes.
						# Here we concatenate the unconditional and text embeddings into a single batch
						# to avoid doing two forward passes
						lowercase						:		Optional[Any]   					=		torch.cat([uncond_embeddings, text_embeddings]							)

					# get the initial random noise unless the user supplied it

					# Unlike in other pipelines, latents need to be generated in the target device
					# for 1-to-1 results reproducibility with the CompVis implementation.
					# However this currently doesn't work in `mps`.
					lowercase						:		List[str]   					=		(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
					lowercase						:		Union[str, Any]   					=		(batch_size * num_images_per_prompt, self.unet.config.in_channels, 6_4, 6_4)
					lowercase						:		Union[str, Any]   					=		text_embeddings.dtype
					if latents is None:
						if self.device.type == "mps":
							# randn does not exist on mps
							lowercase						:		List[str]   					=		torch.randn(
							    a_							,      generator=a_							,      device="cpu"							,      dtype=a_							).to(self.device							)
							lowercase						:		Any   					=		torch.randn(a_							,      generator=a_							,      device="cpu"							,      dtype=a_							).to(
							    self.device							)
						else:
							lowercase						:		List[Any]   					=		torch.randn(
							    a_							,      generator=a_							,      device=self.device							,      dtype=a_							)
							lowercase						:		Optional[Any]   					=		torch.randn(a_							,      generator=a_							,      device=self.device							,      dtype=a_							)
					else:
						if latents_reference.shape != latents_shape:
							raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''							)
						lowercase						:		Dict   					=		latents_reference.to(self.device							)
						lowercase						:		int   					=		latents.to(self.device							)

					# This is the key part of the pipeline where we
					# try to ensure that the generated images w/ the same seed
					# but different sizes actually result in similar images
					lowercase						:		int   					=		(latents_shape[3] - latents_shape_reference[3]) // 2
					lowercase						:		Union[str, Any]   					=		(latents_shape[2] - latents_shape_reference[2]) // 2
					lowercase						:		int   					=		latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
					lowercase						:		Dict   					=		latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
					lowercase						:		Optional[int]   					=		0 if dx < 0 else dx
					lowercase						:		Tuple   					=		0 if dy < 0 else dy
					lowercase						:		Optional[int]   					=		max(-dx							,      0							)
					lowercase						:		int   					=		max(-dy							,      0							)
					# import pdb
					# pdb.set_trace()
					lowercase						:		Union[str, Any]   					=		latents_reference[:, :, dy : dy + h, dx : dx + w]

					# set timesteps
					self.scheduler.set_timesteps(a_							)

					# Some schedulers like PNDM have timesteps as arrays
					# It's more optimized to move all timesteps to correct device beforehand
					lowercase						:		List[Any]   					=		self.scheduler.timesteps.to(self.device							)

					# scale the initial noise by the standard deviation required by the scheduler
					lowercase						:		List[str]   					=		latents * self.scheduler.init_noise_sigma

					# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
					# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
					# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
					# and should be between [0, 1]
					lowercase						:		Optional[Any]   					=		"eta" in set(inspect.signature(self.scheduler.step							).parameters.keys()							)
					lowercase						:		List[str]   					=		{}
					if accepts_eta:
						lowercase						:		List[str]   					=		eta

					for i, t in enumerate(self.progress_bar(a_							)							):
						# expand the latents if we are doing classifier free guidance
						lowercase						:		Optional[int]   					=		torch.cat([latents] * 2							) if do_classifier_free_guidance else latents
						lowercase						:		int   					=		self.scheduler.scale_model_input(a_							,      a_							)

						# predict the noise residual
						lowercase						:		Dict   					=		self.unet(a_							,      a_							,      encoder_hidden_states=a_							).sample

						# perform guidance
						if do_classifier_free_guidance:
							lowercase					,		lowercase						:		Dict   					=		noise_pred.chunk(2							)
							lowercase						:		Optional[int]   					=		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

						# compute the previous noisy sample x_t -> x_t-1
						lowercase						:		int   					=		self.scheduler.step(a_							,      a_							,      a_							,      **a_							).prev_sample

						# call the callback, if provided
						if callback is not None and i % callback_steps == 0:
							callback(a_							,      a_							,      a_							)

					lowercase						:		List[Any]   					=		1 / 0.1_82_15 * latents
					lowercase						:		Tuple   					=		self.vae.decode(a_							).sample

					lowercase						:		Any   					=		(image / 2 + 0.5).clamp(0							,      1							)

					# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
					lowercase						:		Any   					=		image.cpu().permute(0							,      2							,      3							,      1							).float().numpy()

					if self.safety_checker is not None:
						lowercase						:		Tuple   					=		self.feature_extractor(self.numpy_to_pil(a_							)							,      return_tensors="pt"							).to(
						    self.device							)
						lowercase					,		lowercase						:		Tuple   					=		self.safety_checker(
						    images=a_							,      clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype							)							)
					else:
						lowercase						:		Union[str, Any]   					=		None

					if output_type == "pil":
						lowercase						:		Union[str, Any]   					=		self.numpy_to_pil(a_							)

					if not return_dict:
						return (image, has_nsfw_concept)

					return StableDiffusionPipelineOutput(images=a_							,      nsfw_content_detected=a_							)






'''simple docstring'''
import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
lowerCAmelCase   : int             =				logging.get_logger(__name__)

lowerCAmelCase   : Dict             =				{
    """post_extract_proj""": """feature_projection.projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.linear_k""": """encoder.layers.*.self_attn.linear_k""",
    """self_attn.linear_v""": """encoder.layers.*.self_attn.linear_v""",
    """self_attn.linear_q""": """encoder.layers.*.self_attn.linear_q""",
    """self_attn.pos_bias_u""": """encoder.layers.*.self_attn.pos_bias_u""",
    """self_attn.pos_bias_v""": """encoder.layers.*.self_attn.pos_bias_v""",
    """self_attn.linear_out""": """encoder.layers.*.self_attn.linear_out""",
    """self_attn.linear_pos""": """encoder.layers.*.self_attn.linear_pos""",
    """self_attn.rotary_emb""": """encoder.embed_positions""",
    """self_attn_layer_norm""": """encoder.layers.*.self_attn_layer_norm""",
    """conv_module.pointwise_conv1""": """encoder.layers.*.conv_module.pointwise_conv1""",
    """conv_module.pointwise_conv2""": """encoder.layers.*.conv_module.pointwise_conv2""",
    """conv_module.depthwise_conv""": """encoder.layers.*.conv_module.depthwise_conv""",
    """conv_module.batch_norm""": """encoder.layers.*.conv_module.batch_norm""",
    """conv_module.layer_norm""": """encoder.layers.*.conv_module.layer_norm""",
    """ffn1.w_1""": """encoder.layers.*.ffn1.intermediate_dense""",
    """ffn1.w_2""": """encoder.layers.*.ffn1.output_dense""",
    """ffn1.layer_norm""": """encoder.layers.*.ffn1_layer_norm""",
    """ffn2.w_1""": """encoder.layers.*.ffn2.intermediate_dense""",
    """ffn2.w_2""": """encoder.layers.*.ffn2.output_dense""",
    """ffn2.layer_norm""": """encoder.layers.*.ffn2_layer_norm""",
    """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""",
}
lowerCAmelCase   : Optional[Any]             =				[
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
]




def 	_A  (       A							,A							,A							,A							,A							)  ->				Tuple:
	for attribute in key.split("."							):
		lowercase						:		Dict   					=		getattr(A							,A							)

	if weight_type is not None:
		lowercase						:		List[str]   					=		getattr(A							,A							).shape
	else:
		lowercase						:		Any   					=		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":
		lowercase						:		List[Any]   					=		value
	elif weight_type == "weight_g":
		lowercase						:		List[Any]   					=		value
	elif weight_type == "weight_v":
		lowercase						:		int   					=		value
	elif weight_type == "bias":
		lowercase						:		Any   					=		value
	elif weight_type == "running_mean":
		lowercase						:		Tuple   					=		value
	elif weight_type == "running_var":
		lowercase						:		Dict   					=		value
	elif weight_type == "num_batches_tracked":
		lowercase						:		Optional[int]   					=		value
	elif weight_type == "inv_freq":
		lowercase						:		List[Any]   					=		value
	else:
		lowercase						:		Dict   					=		value

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




def 	_A  (       A							,A							,A							)  ->				int:
	lowercase						:		Optional[int]   					=		[]
	lowercase						:		Tuple   					=		fairseq_model.state_dict()

	lowercase						:		Optional[Any]   					=		hf_model.wavaveca_conformer.feature_extractor

	for name, value in fairseq_dict.items():
		lowercase						:		str   					=		False
		if "conv_layers" in name:
			load_conv_layer(
			    A							,A							,A							,A							,hf_model.config.feat_extract_norm == "group"							,)
			lowercase						:		Dict   					=		True
		else:
			for key, mapped_key in MAPPING.items():
				lowercase						:		List[str]   					=		"wav2vec2_conformer." + 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]:
					lowercase						:		List[str]   					=		True
					if "*" in mapped_key:
						lowercase						:		int   					=		name.split(A							)[0].split("."							)[-2]
						lowercase						:		Optional[Any]   					=		mapped_key.replace("*"							,A							)
					if "pos_bias_u" in name:
						lowercase						:		str   					=		None
					elif "pos_bias_v" in name:
						lowercase						:		Optional[int]   					=		None
					elif "weight_g" in name:
						lowercase						:		int   					=		"weight_g"
					elif "weight_v" in name:
						lowercase						:		Dict   					=		"weight_v"
					elif "bias" in name:
						lowercase						:		List[str]   					=		"bias"
					elif "weight" in name:
						# TODO: don't match quantizer.weight_proj
						lowercase						:		Optional[int]   					=		"weight"
					elif "running_mean" in name:
						lowercase						:		Optional[int]   					=		"running_mean"
					elif "inv_freq" in name:
						lowercase						:		Dict   					=		"inv_freq"
					elif "running_var" in name:
						lowercase						:		int   					=		"running_var"
					elif "num_batches_tracked" in name:
						lowercase						:		Optional[Any]   					=		"num_batches_tracked"
					else:
						lowercase						:		int   					=		None
					set_recursively(A							,A							,A							,A							,A							)
				continue
		if not is_used:
			unused_weights.append(A							)

	logger.warning(F'''Unused weights: {unused_weights}'''							)




def 	_A  (       A							,A							,A							,A							,A							)  ->				List[str]:
	lowercase						:		Tuple   					=		full_name.split("conv_layers."							)[-1]
	lowercase						:		Optional[Any]   					=		name.split("."							)
	lowercase						:		str   					=		int(items[0]							)
	lowercase						:		List[Any]   					=		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.'''							)
			lowercase						:		Union[str, Any]   					=		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.'''							)
			lowercase						:		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:
			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.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'''							)
			lowercase						:		int   					=		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.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'''							)
			lowercase						:		str   					=		value
			logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
	else:
		unused_weights.append(A							)




@torch.no_grad()
def 	_A  (       A							,A							,A=None							,A=None							,A=True							)  ->				Optional[Any]:
	if config_path is not None:
		lowercase						:		Tuple   					=		WavaVecaConformerConfig.from_pretrained(A							,hidden_act="swish"							)
	else:
		lowercase						:		Any   					=		WavaVecaConformerConfig()

	if "rope" in checkpoint_path:
		lowercase						:		str   					=		"rotary"

	if is_finetuned:
		if dict_path:
			lowercase						:		List[str]   					=		Dictionary.load(A							)

			# important change bos & pad token id since CTC symbol is <pad> and
			# not <s> as in fairseq
			lowercase						:		Optional[int]   					=		target_dict.pad_index
			lowercase						:		Optional[int]   					=		target_dict.bos_index
			lowercase						:		Optional[Any]   					=		target_dict.eos_index
			lowercase						:		str   					=		len(target_dict.symbols							)
			lowercase						:		List[Any]   					=		os.path.join(A							,"vocab.json"							)
			if not os.path.isdir(A							):
				logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(A							)							)
				return
			os.makedirs(A							,exist_ok=A							)
			lowercase						:		Any   					=		target_dict.indices

			# fairseq has the <pad> and <s> switched
			lowercase						:		Any   					=		0
			lowercase						:		Tuple   					=		1
			with open(A							,"w"							,encoding="utf-8"							) as vocab_handle:
				json.dump(A							,A							)
			lowercase						:		Tuple   					=		WavaVecaCTCTokenizer(
			    A							,unk_token=target_dict.unk_word							,pad_token=target_dict.pad_word							,bos_token=target_dict.bos_word							,eos_token=target_dict.eos_word							,word_delimiter_token="|"							,do_lower_case=A							,)
			lowercase						:		Dict   					=		True if config.feat_extract_norm == "layer" else False
			lowercase						:		List[str]   					=		WavaVecaFeatureExtractor(
			    feature_size=1							,sampling_rate=1_6_0_0_0							,padding_value=0							,do_normalize=A							,return_attention_mask=A							,)
			lowercase						:		List[str]   					=		WavaVecaProcessor(feature_extractor=A							,tokenizer=A							)
			processor.save_pretrained(A							)

		lowercase						:		Any   					=		WavaVecaConformerForCTC(A							)
	else:
		lowercase						:		str   					=		WavaVecaConformerForPreTraining(A							)

	if is_finetuned:
		lowercase					,		lowercase					,		lowercase						:		List[str]   					=		fairseq.checkpoint_utils.load_model_ensemble_and_task(
		    [checkpoint_path]							,arg_overrides={"data": "/".join(dict_path.split("/"							)[:-1]							)}							)
	else:
		lowercase						:		List[str]   					=		argparse.Namespace(task="audio_pretraining"							)
		lowercase						:		Union[str, Any]   					=		fairseq.tasks.setup_task(A							)

		lowercase					,		lowercase					,		lowercase						:		Optional[Any]   					=		fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]							,task=A							)

	lowercase						:		List[str]   					=		model[0].eval()

	recursively_load_weights(A							,A							,not is_finetuned							)

	hf_wavavec.save_pretrained(A							)


if __name__ == "__main__":
					lowerCAmelCase   : 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_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"""
					)
					lowerCAmelCase   : int             =				parser.parse_args()
					convert_wavaveca_conformer_checkpoint(
					    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
					)


