

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


_a:    str 							=			logging.get_logger(__name__)

class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     ['pixel_values']




	def __init__(		self	:						Dict		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Dict[str, int]] = None		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BILINEAR		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Union[int, float] = 1 / 255		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	**lowerCAmelCase	:						Optional[Any]		,	):


		'''simple docstring'''







		super().__init__(**lowerCAmelCase							)
		UpperCAmelCase_       				=			size if size is not None else {"shortest_edge": 256}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			crop_size if crop_size is not None else {"height": 224, "width": 224}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase							)
		UpperCAmelCase_       				=			do_resize
		UpperCAmelCase_       				=			size
		UpperCAmelCase_       				=			resample
		UpperCAmelCase_       				=			do_center_crop
		UpperCAmelCase_       				=			crop_size
		UpperCAmelCase_       				=			do_rescale
		UpperCAmelCase_       				=			rescale_factor
		UpperCAmelCase_       				=			do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
		UpperCAmelCase_       				=			image_std if image_std is not None else IMAGENET_STANDARD_STD




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BICUBIC		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Any		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		if "shortest_edge" not in size:
			raise ValueError(F"The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"							)
		UpperCAmelCase_       				=			get_resize_output_image_size(lowerCAmelCase		,	size=size["shortest_edge"]		,	default_to_square=lowerCAmelCase							)
		return resize(lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						str		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Optional[Any]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase							)
		return center_crop(lowerCAmelCase		,	size=(size["height"], size["width"])		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						float		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Any							):


		'''simple docstring'''







		return rescale(lowerCAmelCase		,	scale=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Optional[Any]		,	):


		'''simple docstring'''







		return normalize(lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						Optional[bool] = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						Optional[bool] = None		,	lowerCAmelCase	:						Optional[float] = None		,	lowerCAmelCase	:						Optional[bool] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[str, TensorType]] = None		,	lowerCAmelCase	:						Union[str, ChannelDimension] = ChannelDimension.FIRST		,	**lowerCAmelCase	:						List[Any]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			do_resize if do_resize is not None else self.do_resize
		UpperCAmelCase_       				=			size if size is not None else self.size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			resample if resample is not None else self.resample
		UpperCAmelCase_       				=			do_center_crop if do_center_crop is not None else self.do_center_crop
		UpperCAmelCase_       				=			crop_size if crop_size is not None else self.crop_size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase							)
		UpperCAmelCase_       				=			do_rescale if do_rescale is not None else self.do_rescale
		UpperCAmelCase_       				=			rescale_factor if rescale_factor is not None else self.rescale_factor
		UpperCAmelCase_       				=			do_normalize if do_normalize is not None else self.do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else self.image_mean
		UpperCAmelCase_       				=			image_std if image_std is not None else self.image_std

		UpperCAmelCase_       				=			make_list_of_images(lowerCAmelCase							)

		if not valid_images(lowerCAmelCase							):
			raise ValueError(
			    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
			    "torch.Tensor, tf.Tensor or jax.ndarray."							)

		if do_resize and size is None:
			raise ValueError("Size must be specified if do_resize is True."							)

		if do_center_crop and crop_size is None:
			raise ValueError("Crop size must be specified if do_center_crop is True."							)

		if do_rescale and rescale_factor is None:
			raise ValueError("Rescale factor must be specified if do_rescale is True."							)

		if do_normalize and (image_mean is None or image_std is None):
			raise ValueError("Image mean and std must be specified if do_normalize is True."							)

		# All transformations expect numpy arrays.
		UpperCAmelCase_       				=			[to_numpy_array(lowerCAmelCase							) for image in images]

		if do_resize:
			UpperCAmelCase_       				=			[self.resize(image=lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase							) for image in images]

		if do_center_crop:
			UpperCAmelCase_       				=			[self.center_crop(image=lowerCAmelCase		,	size=lowerCAmelCase							) for image in images]

		if do_rescale:
			UpperCAmelCase_       				=			[self.rescale(image=lowerCAmelCase		,	scale=lowerCAmelCase							) for image in images]

		if do_normalize:
			UpperCAmelCase_       				=			[self.normalize(image=lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase							) for image in images]

		UpperCAmelCase_       				=			[to_channel_dimension_format(lowerCAmelCase		,	lowerCAmelCase							) for image in images]

		UpperCAmelCase_       				=			{"pixel_values": images}
		return BatchFeature(data=lowerCAmelCase		,	tensor_type=lowerCAmelCase							)


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:    Optional[int] 							=			"""CompVis/stable-diffusion-v1-1"""
_a:    Dict 							=			"""CompVis/stable-diffusion-v1-2"""
_a:    Optional[Any] 							=			"""CompVis/stable-diffusion-v1-3"""
_a:    str 							=			"""CompVis/stable-diffusion-v1-4"""

class 						__UpperCamelCase    (					lowercase						):




	def __init__(		self	:						Union[str, Any]		,	lowerCAmelCase	:						AutoencoderKL		,	lowerCAmelCase	:						CLIPTextModel		,	lowerCAmelCase	:						CLIPTokenizer		,	lowerCAmelCase	:						UNetaDConditionModel		,	lowerCAmelCase	:						Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]		,	lowerCAmelCase	:						StableDiffusionSafetyChecker		,	lowerCAmelCase	:						CLIPImageProcessor		,	lowerCAmelCase	:						bool = True		,	):


		'''simple docstring'''







		super()._init_()

		UpperCAmelCase_       				=			StableDiffusionPipeline.from_pretrained(lowerCAmelCase							)
		UpperCAmelCase_       				=			StableDiffusionPipeline.from_pretrained(lowerCAmelCase							)
		UpperCAmelCase_       				=			StableDiffusionPipeline.from_pretrained(lowerCAmelCase							)
		UpperCAmelCase_       				=			StableDiffusionPipeline(
		    vae=lowerCAmelCase		,	text_encoder=lowerCAmelCase		,	tokenizer=lowerCAmelCase		,	unet=lowerCAmelCase		,	scheduler=lowerCAmelCase		,	safety_checker=lowerCAmelCase		,	feature_extractor=lowerCAmelCase		,	requires_safety_checker=lowerCAmelCase		,	)

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




	@property
	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







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




	def       __A					(		self	:						Dict		,	lowerCAmelCase	:						Optional[Union[str, int]] = "auto"							):


		'''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(lowerCAmelCase							)




	def       __A					(		self	:						int							):


		'''simple docstring'''







		self.enable_attention_slicing(lowerCAmelCase							)




	@torch.no_grad()
	def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						Union[str, List[str]]		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 50		,	lowerCAmelCase	:						float = 7.5		,	lowerCAmelCase	:						Optional[Union[str, List[str]]] = None		,	lowerCAmelCase	:						Optional[int] = 1		,	lowerCAmelCase	:						float = 0.0		,	lowerCAmelCase	:						Optional[torch.Generator] = None		,	lowerCAmelCase	:						Optional[torch.FloatTensor] = None		,	lowerCAmelCase	:						Optional[str] = "pil"		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None		,	lowerCAmelCase	:						int = 1		,	**lowerCAmelCase	:						Tuple		,	):


		'''simple docstring'''







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




	@torch.no_grad()
	def       __A					(		self	:						Dict		,	lowerCAmelCase	:						Union[str, List[str]]		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 50		,	lowerCAmelCase	:						float = 7.5		,	lowerCAmelCase	:						Optional[Union[str, List[str]]] = None		,	lowerCAmelCase	:						Optional[int] = 1		,	lowerCAmelCase	:						float = 0.0		,	lowerCAmelCase	:						Optional[torch.Generator] = None		,	lowerCAmelCase	:						Optional[torch.FloatTensor] = None		,	lowerCAmelCase	:						Optional[str] = "pil"		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None		,	lowerCAmelCase	:						int = 1		,	**lowerCAmelCase	:						List[Any]		,	):


		'''simple docstring'''







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




	@torch.no_grad()
	def       __A					(		self	:						List[str]		,	lowerCAmelCase	:						Union[str, List[str]]		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 50		,	lowerCAmelCase	:						float = 7.5		,	lowerCAmelCase	:						Optional[Union[str, List[str]]] = None		,	lowerCAmelCase	:						Optional[int] = 1		,	lowerCAmelCase	:						float = 0.0		,	lowerCAmelCase	:						Optional[torch.Generator] = None		,	lowerCAmelCase	:						Optional[torch.FloatTensor] = None		,	lowerCAmelCase	:						Optional[str] = "pil"		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None		,	lowerCAmelCase	:						int = 1		,	**lowerCAmelCase	:						Union[str, Any]		,	):


		'''simple docstring'''







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




	@torch.no_grad()
	def       __A					(		self	:						Dict		,	lowerCAmelCase	:						Union[str, List[str]]		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 50		,	lowerCAmelCase	:						float = 7.5		,	lowerCAmelCase	:						Optional[Union[str, List[str]]] = None		,	lowerCAmelCase	:						Optional[int] = 1		,	lowerCAmelCase	:						float = 0.0		,	lowerCAmelCase	:						Optional[torch.Generator] = None		,	lowerCAmelCase	:						Optional[torch.FloatTensor] = None		,	lowerCAmelCase	:						Optional[str] = "pil"		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None		,	lowerCAmelCase	:						int = 1		,	**lowerCAmelCase	:						Optional[Any]		,	):


		'''simple docstring'''







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




	@torch.no_grad()
	def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						Union[str, List[str]]		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 512		,	lowerCAmelCase	:						int = 50		,	lowerCAmelCase	:						float = 7.5		,	lowerCAmelCase	:						Optional[Union[str, List[str]]] = None		,	lowerCAmelCase	:						Optional[int] = 1		,	lowerCAmelCase	:						float = 0.0		,	lowerCAmelCase	:						Optional[torch.Generator] = None		,	lowerCAmelCase	:						Optional[torch.FloatTensor] = None		,	lowerCAmelCase	:						Optional[str] = "pil"		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None		,	lowerCAmelCase	:						int = 1		,	**lowerCAmelCase	:						Union[str, Any]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			"cuda" if torch.cuda.is_available() else "cpu"
		self.to(lowerCAmelCase							)

		# 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=lowerCAmelCase		,	height=lowerCAmelCase		,	width=lowerCAmelCase		,	num_inference_steps=lowerCAmelCase		,	guidance_scale=lowerCAmelCase		,	negative_prompt=lowerCAmelCase		,	num_images_per_prompt=lowerCAmelCase		,	eta=lowerCAmelCase		,	generator=lowerCAmelCase		,	latents=lowerCAmelCase		,	output_type=lowerCAmelCase		,	return_dict=lowerCAmelCase		,	callback=lowerCAmelCase		,	callback_steps=lowerCAmelCase		,	**lowerCAmelCase		,	)

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

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

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

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