






'''simple docstring'''

from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


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

SCREAMING_SNAKE_CASE__											=     '\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")\n        >>> pipe_prior.to("cuda")\n        >>> prompt = "red cat, 4k photo"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> zero_image_emb = out.negative_image_embeds\n        >>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")\n        >>> pipe.to("cuda")\n        >>> image = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=50,\n        ... ).images\n        >>> image[0].save("cat.png")\n        ```\n'







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase=8					)->				str:
      UpperCamelCase       						=      height // scale_factor**2
      if height % scale_factor**2 != 0:
            new_height += 1
      UpperCamelCase       						=      width // scale_factor**2
      if width % scale_factor**2 != 0:
            new_width += 1
      return new_height * scale_factor, new_width * scale_factor






class        a_		(    lowerCamelCase       ):

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	)						->   Union[str, Any]:



        """simple docstring"""






        super().__init__()

        self.register_modules(
            unet=_SCREAMING_SNAKE_CASE    ,	scheduler=_SCREAMING_SNAKE_CASE    ,	movq=_SCREAMING_SNAKE_CASE    ,	)
        UpperCamelCase       						=      2 ** (len(self.movq.config.block_out_channels   ) - 1)

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   List[Any]:



        """simple docstring"""






        if latents is None:
              UpperCamelCase       						=      randn_tensor(_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	device=_SCREAMING_SNAKE_CASE    ,	dtype=_SCREAMING_SNAKE_CASE   )
        else:
              if latents.shape != shape:
                    raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {shape}"   )
              UpperCamelCase       						=      latents.to(_SCREAMING_SNAKE_CASE   )

        UpperCamelCase       						=      latents * scheduler.init_noise_sigma
        return latents

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE=0   )						->   str:



        """simple docstring"""






        if is_accelerate_available():
              from accelerate import cpu_offload
        else:
              raise ImportError("""Please install accelerate via `pip install accelerate`"""   )

        UpperCamelCase       						=      torch.device(F"cuda:{gpu_id}"   )

        UpperCamelCase       						=      [
            self.unet,
            self.movq,
        ]
        for cpu_offloaded_model in models:
              if cpu_offloaded_model is not None:
                    cpu_offload(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE=0   )						->   Tuple:



        """simple docstring"""






        if is_accelerate_available() and is_accelerate_version(""">="""    ,	"""0.17.0.dev0"""   ):
              from accelerate import cpu_offload_with_hook
        else:
              raise ImportError("""`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."""   )

        UpperCamelCase       						=      torch.device(F"cuda:{gpu_id}"   )

        if self.device.type != "cpu":
              self.to("""cpu"""    ,	silence_dtype_warnings=_SCREAMING_SNAKE_CASE   )
              torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

        UpperCamelCase       						=      None
        for cpu_offloaded_model in [self.unet, self.movq]:
              UpperCamelCase						,UpperCamelCase       						=      cpu_offload_with_hook(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	prev_module_hook=_SCREAMING_SNAKE_CASE   )

        # We'll offload the last model manually.
        UpperCamelCase       						=      hook

  @property
  # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
  def 						A__		(   self   )						->   str:



        """simple docstring"""






        if not hasattr(self.unet    ,	"""_hf_hook"""   ):
              return self.device
        for module in self.unet.modules():
              if (
                  hasattr(_SCREAMING_SNAKE_CASE    ,	"""_hf_hook"""   )
                  and hasattr(module._hf_hook    ,	"""execution_device"""   )
                  and module._hf_hook.execution_device is not None
              ):
                    return torch.device(module._hf_hook.execution_device   )
        return self.device


  @torch.no_grad()
  @replace_example_docstring(_SCREAMING_SNAKE_CASE   )
  def __call__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 100    ,	_SCREAMING_SNAKE_CASE = 4.0    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	)						->   Optional[int]:



        """simple docstring"""






        UpperCamelCase       						=      self._execution_device

        UpperCamelCase       						=      guidance_scale > 1.0

        if isinstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      torch.cat(_SCREAMING_SNAKE_CASE    ,	dim=0   )
        UpperCamelCase       						=      image_embeds.shape[0] * num_images_per_prompt
        if isinstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      torch.cat(_SCREAMING_SNAKE_CASE    ,	dim=0   )

        if do_classifier_free_guidance:
              UpperCamelCase       						=      image_embeds.repeat_interleave(_SCREAMING_SNAKE_CASE    ,	dim=0   )
              UpperCamelCase       						=      negative_image_embeds.repeat_interleave(_SCREAMING_SNAKE_CASE    ,	dim=0   )

        UpperCamelCase       						=      torch.cat([negative_image_embeds, image_embeds]    ,	dim=0   ).to(dtype=self.unet.dtype    ,	device=_SCREAMING_SNAKE_CASE   )

        self.scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    ,	device=_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      self.scheduler.timesteps

        UpperCamelCase       						=      self.unet.config.in_channels

        UpperCamelCase						,UpperCamelCase       						=      downscale_height_and_width(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	self.movq_scale_factor   )

        # create initial latent
        UpperCamelCase       						=      self.prepare_latents(
            (batch_size, num_channels_latents, height, width)    ,	image_embeds.dtype    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	self.scheduler    ,	)

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

              UpperCamelCase       						=      {"""image_embeds""": image_embeds}
              UpperCamelCase       						=      self.unet(
                  sample=_SCREAMING_SNAKE_CASE    ,	timestep=_SCREAMING_SNAKE_CASE    ,	encoder_hidden_states=_SCREAMING_SNAKE_CASE    ,	added_cond_kwargs=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	)[0]

              if do_classifier_free_guidance:
                    UpperCamelCase						,UpperCamelCase       						=      noise_pred.split(latents.shape[1]    ,	dim=1   )
                    UpperCamelCase						,UpperCamelCase       						=      noise_pred.chunk(2   )
                    UpperCamelCase						,UpperCamelCase       						=      variance_pred.chunk(2   )
                    UpperCamelCase       						=      noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
                    UpperCamelCase       						=      torch.cat([noise_pred, variance_pred_text]    ,	dim=1   )

              if not (
                  hasattr(self.scheduler.config    ,	"""variance_type"""   )
                  and self.scheduler.config.variance_type in ["learned", "learned_range"]
              ):
                    UpperCamelCase						,UpperCamelCase       						=      noise_pred.split(latents.shape[1]    ,	dim=1   )

              # compute the previous noisy sample x_t -> x_t-1
              UpperCamelCase       						=      self.scheduler.step(
                  _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	)[0]
        # post-processing
        UpperCamelCase       						=      self.movq.decode(_SCREAMING_SNAKE_CASE    ,	force_not_quantize=_SCREAMING_SNAKE_CASE   )["""sample"""]

        if output_type not in ["pt", "np", "pil"]:
              raise ValueError(F"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"   )

        if output_type in ["np", "pil"]:
              UpperCamelCase       						=      image * 0.5 + 0.5
              UpperCamelCase       						=      image.clamp(0    ,	1   )
              UpperCamelCase       						=      image.cpu().permute(0    ,	2    ,	3    ,	1   ).float().numpy()

        if output_type == "pil":
              UpperCamelCase       						=      self.numpy_to_pil(_SCREAMING_SNAKE_CASE   )

        if not return_dict:
              return (image,)

        return ImagePipelineOutput(images=_SCREAMING_SNAKE_CASE   )








'''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


SCREAMING_SNAKE_CASE__											=     'CompVis/stable-diffusion-v1-1'
SCREAMING_SNAKE_CASE__											=     'CompVis/stable-diffusion-v1-2'
SCREAMING_SNAKE_CASE__											=     'CompVis/stable-diffusion-v1-3'
SCREAMING_SNAKE_CASE__											=     'CompVis/stable-diffusion-v1-4'






class        a_		(    lowerCamelCase       ):

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = True    ,	)						->   Any:



        """simple docstring"""






        super()._init_()

        UpperCamelCase       						=      StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      StableDiffusionPipeline(
            vae=_SCREAMING_SNAKE_CASE    ,	text_encoder=_SCREAMING_SNAKE_CASE    ,	tokenizer=_SCREAMING_SNAKE_CASE    ,	unet=_SCREAMING_SNAKE_CASE    ,	scheduler=_SCREAMING_SNAKE_CASE    ,	safety_checker=_SCREAMING_SNAKE_CASE    ,	feature_extractor=_SCREAMING_SNAKE_CASE    ,	requires_safety_checker=_SCREAMING_SNAKE_CASE    ,	)

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

  @property
  def 						A__		(   self   )						->   Dict[str, Any]:



        """simple docstring"""






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

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE = "auto"   )						->   Optional[Any]:



        """simple docstring"""






        if slice_size == "auto":
              # half the attention head size is usually a good trade-off between
              # speed and memory
              UpperCamelCase       						=      self.unet.config.attention_head_dim // 2
        self.unet.set_attention_slice(_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   Tuple:



        """simple docstring"""






        self.enable_attention_slicing(_SCREAMING_SNAKE_CASE   )

  @torch.no_grad()
  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 50    ,	_SCREAMING_SNAKE_CASE = 7.5    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = 0.0    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   List[Any]:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)

  @torch.no_grad()
  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 50    ,	_SCREAMING_SNAKE_CASE = 7.5    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = 0.0    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   List[Any]:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)

  @torch.no_grad()
  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 50    ,	_SCREAMING_SNAKE_CASE = 7.5    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = 0.0    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   Dict:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)

  @torch.no_grad()
  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 50    ,	_SCREAMING_SNAKE_CASE = 7.5    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = 0.0    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   str:



        """simple docstring"""






        return self.pipea(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)


  @torch.no_grad()
  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 512    ,	_SCREAMING_SNAKE_CASE = 50    ,	_SCREAMING_SNAKE_CASE = 7.5    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = 0.0    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = "pil"    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = 1    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      """cuda""" if torch.cuda.is_available() else """cpu"""
        self.to(_SCREAMING_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
        UpperCamelCase       						=      self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE    ,	)

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

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

        # Get first result from Stable Diffusion Checkpoint v1.4
        UpperCamelCase       						=      self.textaimg_sda_a(
            prompt=_SCREAMING_SNAKE_CASE    ,	height=_SCREAMING_SNAKE_CASE    ,	width=_SCREAMING_SNAKE_CASE    ,	num_inference_steps=_SCREAMING_SNAKE_CASE    ,	guidance_scale=_SCREAMING_SNAKE_CASE    ,	negative_prompt=_SCREAMING_SNAKE_CASE    ,	num_images_per_prompt=_SCREAMING_SNAKE_CASE    ,	eta=_SCREAMING_SNAKE_CASE    ,	generator=_SCREAMING_SNAKE_CASE    ,	latents=_SCREAMING_SNAKE_CASE    ,	output_type=_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	callback=_SCREAMING_SNAKE_CASE    ,	callback_steps=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_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]]   )
