

"""simple docstring"""





import os
import tempfile
import unittest

import numpy as np

from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax, slow


if is_flax_available():
   import jax
   import jax.numpy as jnp
   from flax.jax_utils import replicate
   from flax.training.common_utils import shard

   from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline




@require_flax
class 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			Optional[int]	):
    with tempfile.TemporaryDirectory() as tmpdirname:
       # pipeline has Flax weights
       __lowercase								=						FlaxDiffusionPipeline.from_pretrained(
           "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=UpperCAmelCase__,					cache_dir=UpperCAmelCase__	)

       __lowercase								=						[t[-1] for t in os.walk(os.path.join(UpperCAmelCase__,					os.listdir(UpperCAmelCase__	)[0],					"snapshots"	)	)]
       __lowercase								=						[item for sublist in all_root_files for item in sublist]

       # None of the downloaded files should be a PyTorch file even if we have some here:
       # https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
       assert not any(f.endswith(".bin"	) for f in files	)







@slow
@require_flax
class 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			List[Any]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=UpperCAmelCase__	)

    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						4

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images

    assert images.shape == (num_samples, 1, 6_4, 6_4, 3)
    if jax.device_count() == 8:
       assert np.abs(np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa	).sum() - 4.1_514_745	) < 1E-3
       assert np.abs(np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 49_947.875	) < 5E-1

    __lowercase								=						pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]	)	)	)
    assert len(UpperCAmelCase__	) == num_samples


 def 					_lowercase (			self							:			int	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="flax",					safety_checker=UpperCAmelCase__	)

    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images

    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    if jax.device_count() == 8:
       assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa	).sum() - 0.05_652_401)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_383_808.2)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__	)

    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images

    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    if jax.device_count() == 8:
       assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa	).sum() - 0.04_003_906)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_373_516.75)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa	)

    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images

    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    if jax.device_count() == 8:
       assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa	).sum() - 0.04_003_906)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_373_516.75)	) < 5E-1


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase								=						FlaxDDIMScheduler(
        beta_start=0.00_085,					beta_end=0.012,					beta_schedule="scaled_linear",					set_alpha_to_one=UpperCAmelCase__,					steps_offset=1,					)

    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					scheduler=UpperCAmelCase__,					safety_checker=UpperCAmelCase__,					)
    __lowercase								=						scheduler.create_state()

    __lowercase								=						scheduler_state

    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.random.PRNGKey(0	)
    __lowercase								=						5_0

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)

    # shard inputs and rng
    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						jax.random.split(UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)

    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images

    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    if jax.device_count() == 8:
       assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa	).sum() - 0.045_043_945)	) < 1E-3
       assert np.abs((np.abs(UpperCAmelCase__,					dtype=np.floataa	).sum() - 2_347_693.5)	) < 5E-1



 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						(
        "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
        " field, close up, split lighting, cinematic"
    )

    __lowercase								=						jax.device_count()
    __lowercase								=						num_samples * [prompt]
    __lowercase								=						jax.random.split(jax.random.PRNGKey(0	),					UpperCAmelCase__	)

    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__,					)

    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)
    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images
    assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    __lowercase								=						images[2, 0, 2_5_6, 1_0:1_7, 1]

    # With memory efficient attention
    __lowercase		,__lowercase								=						FlaxStableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=UpperCAmelCase__,					use_memory_efficient_attention=UpperCAmelCase__,					)

    __lowercase								=						replicate(UpperCAmelCase__	)
    __lowercase								=						pipeline.prepare_inputs(UpperCAmelCase__	)
    __lowercase								=						shard(UpperCAmelCase__	)
    __lowercase								=						pipeline(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					jit=UpperCAmelCase__	).images
    assert images_eff.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
    __lowercase								=						images[2, 0, 2_5_6, 1_0:1_7, 1]

    # I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
    # over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
    assert abs(slice_eff - slice	).max() < 1E-2







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


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




class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







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

    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline(
        vae=UpperCAmelCase__,					text_encoder=UpperCAmelCase__,					tokenizer=UpperCAmelCase__,					unet=UpperCAmelCase__,					scheduler=UpperCAmelCase__,					safety_checker=UpperCAmelCase__,					feature_extractor=UpperCAmelCase__,					requires_safety_checker=UpperCAmelCase__,					)

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


 @property
 def 					_lowercase (			self							:			List[str]	):
    return {k: getattr(self,					UpperCAmelCase__	) for k in self.config.keys() if not k.startswith("_"	)}


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


 def 					_lowercase (			self							:			List[str]	):
    self.enable_attention_slicing(UpperCAmelCase__	)


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


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


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


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



 @torch.no_grad()
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			str,					):
    __lowercase								=						"cuda" if torch.cuda.is_available() else "cpu"
    self.to(UpperCAmelCase__	)

    # 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
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

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

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

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

    # 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]]	)




