"""simple docstring"""




import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConfig,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaForPreTraining,
    WavaVecaProcessor,
    logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification


logging.set_verbosity_info()
__lowerCAmelCase     :				Any    				=    logging.get_logger(__name__)

__lowerCAmelCase     :				str    				=    {
    "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",
    "adapter_layer": "encoder.layers.*.adapter_layer",
    "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",
    "pooling_layer.linear": "projector",
    "pooling_layer.projection": "classifier",
}
__lowerCAmelCase     :				List[Any]    				=    [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
    "projector",
    "classifier",
]







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		lowerCAmelCase__   = {}
		with open(lowerCamelCase__      ,	"""r"""  ) as file:
				for line_number, line in enumerate(lowerCamelCase__  ):
						lowerCAmelCase__   = line.strip()
						if line:
								lowerCAmelCase__   = line.split()
								lowerCAmelCase__   = line_number
								lowerCAmelCase__   = words[0]
								lowerCAmelCase__   = value
		return result







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		for attribute in key.split("""."""  ):
				lowerCAmelCase__   = getattr(lowerCamelCase__      ,	lowerCamelCase__  )

		lowerCAmelCase__   = None
		for param_key in PARAM_MAPPING.keys():
				if full_name.endswith(lowerCamelCase__  ):
						lowerCAmelCase__   = PARAM_MAPPING[full_name.split("""."""  )[-1]]
						lowerCAmelCase__   = """param"""

		if weight_type is not None and weight_type != "param":
				lowerCAmelCase__   = getattr(lowerCamelCase__      ,	lowerCamelCase__  ).shape
		elif weight_type is not None and weight_type == "param":
				lowerCAmelCase__   = hf_pointer
				for attribute in hf_param_name.split("""."""  ):
						lowerCAmelCase__   = getattr(lowerCamelCase__      ,	lowerCamelCase__  )
				lowerCAmelCase__   = shape_pointer.shape

				# let's reduce dimension
				lowerCAmelCase__   = value[0]
		else:
				lowerCAmelCase__   = 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":
				lowerCAmelCase__   = value
		elif weight_type == "weight_g":
				lowerCAmelCase__   = value
		elif weight_type == "weight_v":
				lowerCAmelCase__   = value
		elif weight_type == "bias":
				lowerCAmelCase__   = value
		elif weight_type == "param":
				for attribute in hf_param_name.split("""."""  ):
						lowerCAmelCase__   = getattr(lowerCamelCase__      ,	lowerCamelCase__  )
				lowerCAmelCase__   = value
		else:
				lowerCAmelCase__   = value

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







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		lowerCAmelCase__   = None
		for param_key in PARAM_MAPPING.keys():
				if full_name.endswith(lowerCamelCase__  ):
						lowerCAmelCase__   = PARAM_MAPPING[full_name.split("""."""  )[-1]]
						lowerCAmelCase__   = """param"""

		if weight_type is not None and weight_type != "param":
				lowerCAmelCase__   = """.""".join([key, weight_type]  )
		elif weight_type is not None and weight_type == "param":
				lowerCAmelCase__   = """.""".join([key, hf_param_name]  )
		else:
				lowerCAmelCase__   = key

		lowerCAmelCase__   = value if """lm_head""" in full_key else value[0]


__lowerCAmelCase     :				Optional[Any]    				=    {
    "W_a": "linear_1.weight",
    "W_b": "linear_2.weight",
    "b_a": "linear_1.bias",
    "b_b": "linear_2.bias",
    "ln_W": "norm.weight",
    "ln_b": "norm.bias",
}







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__=None      ,	lowerCamelCase__=None  ):





		"""simple docstring"""




		lowerCAmelCase__   = False
		for key, mapped_key in MAPPING.items():
				lowerCAmelCase__   = """wav2vec2.""" + 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]:
						lowerCAmelCase__   = True
						if "*" in mapped_key:
								lowerCAmelCase__   = name.split(lowerCamelCase__  )[0].split("""."""  )[-2]
								lowerCAmelCase__   = mapped_key.replace("""*"""      ,	lowerCamelCase__  )
						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:
								# TODO: don't match quantizer.weight_proj
								lowerCAmelCase__   = """weight"""
						else:
								lowerCAmelCase__   = None
						if hf_dict is not None:
								rename_dict(lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  )
						else:
								set_recursively(lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  )
						return is_used
		return is_used







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		lowerCAmelCase__   = []
		lowerCAmelCase__   = fairseq_model.state_dict()

		lowerCAmelCase__   = hf_model.wavaveca.feature_extractor

		for name, value in fairseq_dict.items():
				lowerCAmelCase__   = False
				if "conv_layers" in name:
						load_conv_layer(
						    lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	hf_model.config.feat_extract_norm == """group"""      ,	)
						lowerCAmelCase__   = True
				else:
						lowerCAmelCase__   = load_wavaveca_layer(lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  )
				if not is_used:
						unused_weights.append(lowerCamelCase__  )

		logger.warning(f"""Unused weights: {unused_weights}"""  )







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__  ):





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







@torch.no_grad()
def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__=None      ,	lowerCamelCase__=None      ,	lowerCamelCase__=True      ,	lowerCamelCase__=False  ):





		"""simple docstring"""




		if config_path is not None:
				lowerCAmelCase__   = WavaVecaConfig.from_pretrained(lowerCamelCase__  )
		else:
				lowerCAmelCase__   = WavaVecaConfig()

		if is_seq_class:
				lowerCAmelCase__   = read_txt_into_dict(lowerCamelCase__  )
				lowerCAmelCase__   = idalabel
				lowerCAmelCase__   = WavaVecaForSequenceClassification(lowerCamelCase__  )
				lowerCAmelCase__   = WavaVecaFeatureExtractor(
				    feature_size=1      ,	sampling_rate=1_6000      ,	padding_value=0      ,	do_normalize=lowerCamelCase__      ,	return_attention_mask=lowerCamelCase__      ,	)
				feature_extractor.save_pretrained(lowerCamelCase__  )

		elif is_finetuned:
				if dict_path:
						lowerCAmelCase__   = Dictionary.load(lowerCamelCase__  )

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

						# fairseq has the <pad> and <s> switched
						lowerCAmelCase__   = 0
						lowerCAmelCase__   = 1
						with open(lowerCamelCase__      ,	"""w"""      ,	encoding="""utf-8"""  ) as vocab_handle:
								json.dump(lowerCamelCase__      ,	lowerCamelCase__  )
						lowerCAmelCase__   = WavaVecaCTCTokenizer(
						    lowerCamelCase__      ,	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=lowerCamelCase__      ,	)
						lowerCAmelCase__   = True if config.feat_extract_norm == """layer""" else False
						lowerCAmelCase__   = WavaVecaFeatureExtractor(
						    feature_size=1      ,	sampling_rate=1_6000      ,	padding_value=0      ,	do_normalize=lowerCamelCase__      ,	return_attention_mask=lowerCamelCase__      ,	)
						lowerCAmelCase__   = WavaVecaProcessor(feature_extractor=lowerCamelCase__      ,	tokenizer=lowerCamelCase__  )
						processor.save_pretrained(lowerCamelCase__  )

				lowerCAmelCase__   = WavaVecaForCTC(lowerCamelCase__  )
		else:
				lowerCAmelCase__   = WavaVecaForPreTraining(lowerCamelCase__  )

		if is_finetuned or is_seq_class:
				lowerCAmelCase__ ,       lowerCAmelCase__ ,       lowerCAmelCase__   = fairseq.checkpoint_utils.load_model_ensemble_and_task(
				    [checkpoint_path]      ,	arg_overrides={"""data""": """/""".join(dict_path.split("""/"""  )[:-1]  )}  )
		else:
				lowerCAmelCase__   = argparse.Namespace(task="""audio_pretraining"""  )
				lowerCAmelCase__   = fairseq.tasks.setup_task(lowerCamelCase__  )

				lowerCAmelCase__ ,       lowerCAmelCase__ ,       lowerCAmelCase__   = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]      ,	task=lowerCamelCase__  )

		lowerCAmelCase__   = model[0].eval()

		recursively_load_weights(lowerCamelCase__      ,	lowerCamelCase__      ,	not is_finetuned  )

		hf_wavavec.save_pretrained(lowerCamelCase__  )


if __name__ == "__main__":
			__lowerCAmelCase     :				Tuple    				=    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"
			)
			parser.add_argument(
			    "--is_seq_class",
			    action="store_true",
			    help="Whether the model to convert is a fine-tuned sequence classification model or not",
			)
			__lowerCAmelCase     :				Optional[Any]    				=    parser.parse_args()

			__lowerCAmelCase     :				List[str]    				=    not args.not_finetuned and not args.is_seq_class
			convert_wavaveca_checkpoint(
			    args.checkpoint_path,
			    args.pytorch_dump_folder_path,
			    args.config_path,
			    args.dict_path,
			    is_finetuned,
			    args.is_seq_class,
			)





"""simple docstring"""




from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


__lowerCAmelCase     :				Dict    				=    "CompVis/stable-diffusion-v1-1"
__lowerCAmelCase     :				int    				=    "CompVis/stable-diffusion-v1-2"
__lowerCAmelCase     :				int    				=    "CompVis/stable-diffusion-v1-3"
__lowerCAmelCase     :				Union[str, Any]    				=    "CompVis/stable-diffusion-v1-4"

class    a_   (  __UpperCamelCase      ):




					def __init__(						self    :  List[Any]	,    snake_case__    :  AutoencoderKL	,    snake_case__    :  CLIPTextModel	,    snake_case__    :  CLIPTokenizer	,    snake_case__    :  UNetaDConditionModel	,    snake_case__    :  Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]	,    snake_case__    :  StableDiffusionSafetyChecker	,    snake_case__    :  CLIPImageProcessor	,    snake_case__    :  bool = True	,    ):
							super()._init_()

							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = StableDiffusionPipeline.from_pretrained(snake_case__  )
							lowerCAmelCase__   = StableDiffusionPipeline(
							    vae=snake_case__	,    text_encoder=snake_case__	,    tokenizer=snake_case__	,    unet=snake_case__	,    scheduler=snake_case__	,    safety_checker=snake_case__	,    feature_extractor=snake_case__	,    requires_safety_checker=snake_case__	,    )

							self.register_modules(pipelinea=self.pipea	,    pipelinea=self.pipea	,    pipelinea=self.pipea	,    pipelinea=self.pipea  )




					@property
					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple  ):
							return {k: getattr(self	,    snake_case__  ) for k in self.config.keys() if not k.startswith("""_"""  )}




					def     _SCREAMING_SNAKE_CASE    (						self    :  List[Any]	,    snake_case__    :  Optional[Union[str, int]] = "auto"  ):
							if slice_size == "auto":
									# half the attention head size is usually a good trade-off between
									# speed and memory
									lowerCAmelCase__   = self.unet.config.attention_head_dim // 2
							self.unet.set_attention_slice(snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							self.enable_attention_slicing(snake_case__  )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  int	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    snake_case__    :  float = 7.5	,    snake_case__    :  Optional[Union[str, List[str]]] = None	,    snake_case__    :  Optional[int] = 1	,    snake_case__    :  float = 0.0	,    snake_case__    :  Optional[torch.Generator] = None	,    snake_case__    :  Optional[torch.FloatTensor] = None	,    snake_case__    :  Optional[str] = "pil"	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,    snake_case__    :  int = 1	,    **snake_case__    :  List[Any]	,    ):
							return self.pipea(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    snake_case__    :  float = 7.5	,    snake_case__    :  Optional[Union[str, List[str]]] = None	,    snake_case__    :  Optional[int] = 1	,    snake_case__    :  float = 0.0	,    snake_case__    :  Optional[torch.Generator] = None	,    snake_case__    :  Optional[torch.FloatTensor] = None	,    snake_case__    :  Optional[str] = "pil"	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,    snake_case__    :  int = 1	,    **snake_case__    :  Tuple	,    ):
							return self.pipea(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[int]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    snake_case__    :  float = 7.5	,    snake_case__    :  Optional[Union[str, List[str]]] = None	,    snake_case__    :  Optional[int] = 1	,    snake_case__    :  float = 0.0	,    snake_case__    :  Optional[torch.Generator] = None	,    snake_case__    :  Optional[torch.FloatTensor] = None	,    snake_case__    :  Optional[str] = "pil"	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,    snake_case__    :  int = 1	,    **snake_case__    :  Optional[Any]	,    ):
							return self.pipea(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  List[str]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    snake_case__    :  float = 7.5	,    snake_case__    :  Optional[Union[str, List[str]]] = None	,    snake_case__    :  Optional[int] = 1	,    snake_case__    :  float = 0.0	,    snake_case__    :  Optional[torch.Generator] = None	,    snake_case__    :  Optional[torch.FloatTensor] = None	,    snake_case__    :  Optional[str] = "pil"	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,    snake_case__    :  int = 1	,    **snake_case__    :  str	,    ):
							return self.pipea(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )




					@torch.no_grad()
					def     _SCREAMING_SNAKE_CASE    (						self    :  Union[str, Any]	,    snake_case__    :  Union[str, List[str]]	,    snake_case__    :  int = 512	,    snake_case__    :  int = 512	,    snake_case__    :  int = 50	,    snake_case__    :  float = 7.5	,    snake_case__    :  Optional[Union[str, List[str]]] = None	,    snake_case__    :  Optional[int] = 1	,    snake_case__    :  float = 0.0	,    snake_case__    :  Optional[torch.Generator] = None	,    snake_case__    :  Optional[torch.FloatTensor] = None	,    snake_case__    :  Optional[str] = "pil"	,    snake_case__    :  bool = True	,    snake_case__    :  Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,    snake_case__    :  int = 1	,    **snake_case__    :  Optional[Any]	,    ):
							lowerCAmelCase__   = """cuda""" if torch.cuda.is_available() else """cpu"""
							self.to(snake_case__  )

							# Checks if the height and width are divisible by 8 or not
							if height % 8 != 0 or width % 8 != 0:
									raise ValueError(F"""`height` and `width` must be divisible by 8 but are {height} and {width}."""  )

							# Get first result from Stable Diffusion Checkpoint v1.1
							lowerCAmelCase__   = self.textaimg_sda_a(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )

							# Get first result from Stable Diffusion Checkpoint v1.2
							lowerCAmelCase__   = self.textaimg_sda_a(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )

							# Get first result from Stable Diffusion Checkpoint v1.3
							lowerCAmelCase__   = self.textaimg_sda_a(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )

							# Get first result from Stable Diffusion Checkpoint v1.4
							lowerCAmelCase__   = self.textaimg_sda_a(
							    prompt=snake_case__	,    height=snake_case__	,    width=snake_case__	,    num_inference_steps=snake_case__	,    guidance_scale=snake_case__	,    negative_prompt=snake_case__	,    num_images_per_prompt=snake_case__	,    eta=snake_case__	,    generator=snake_case__	,    latents=snake_case__	,    output_type=snake_case__	,    return_dict=snake_case__	,    callback=snake_case__	,    callback_steps=snake_case__	,    **snake_case__	,    )

							# Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
							return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]  )




