



'''simple docstring'''




import functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


a   :			Tuple					  =    threading.Lock()
a   :			Any					  =    None

a   :			Union[str, Any]					  =    {
    """debug""": logging.DEBUG,
    """info""": logging.INFO,
    """warning""": logging.WARNING,
    """error""": logging.ERROR,
    """critical""": logging.CRITICAL,
}

a   :			Union[str, Any]					  =    logging.WARNING

a   :			Optional[Any]					  =    True



def       __lowerCamelCase  (					)      ->			List[str]:
							UpperCAmelCase     :		Optional[Any]							     =		os.getenv("""TRANSFORMERS_VERBOSITY"""	,				UpperCamelCase_		)
							if env_level_str:
														if env_level_str in log_levels:
																					return log_levels[env_level_str]
														else:
																					logging.getLogger().warning(
																					    F'''Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, '''
																					    F'''has to be one of: { ', '.join(log_levels.keys()		) }'''		)
							return _default_log_level



def       __lowerCamelCase  (					)      ->			str:
							return __name__.split("""."""		)[0]



def       __lowerCamelCase  (					)      ->			logging.Logger:
							return logging.getLogger(_get_library_name()		)



def       __lowerCamelCase  (					)      ->			None:
							global _default_handler

							with _lock:
														if _default_handler:
																					# This library has already configured the library root logger.
																					return
														UpperCAmelCase     :		List[Any]							     =		logging.StreamHandler()  # Set sys.stderr as stream.
														UpperCAmelCase     :		List[Any]							     =		sys.stderr.flush

														# Apply our default configuration to the library root logger.
														UpperCAmelCase     :		List[str]							     =		_get_library_root_logger()
														library_root_logger.addHandler(_default_handler		)
														library_root_logger.setLevel(_get_default_logging_level()		)
														UpperCAmelCase     :		Union[str, Any]							     =		False



def       __lowerCamelCase  (					)      ->			None:
							global _default_handler

							with _lock:
														if not _default_handler:
																					return

														UpperCAmelCase     :		int							     =		_get_library_root_logger()
														library_root_logger.removeHandler(_default_handler		)
														library_root_logger.setLevel(logging.NOTSET		)
														UpperCAmelCase     :		Optional[int]							     =		None



def       __lowerCamelCase  (					)      ->			int:
							return log_levels



def       __lowerCamelCase  (					_lowercase = None		)      ->			logging.Logger:


							if name is None:
														UpperCAmelCase     :		int							     =		_get_library_name()

							_configure_library_root_logger()
							return logging.getLogger(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			int:
							_configure_library_root_logger()
							return _get_library_root_logger().getEffectiveLevel()



def       __lowerCamelCase  (					_lowercase		)      ->			None:
							_configure_library_root_logger()
							_get_library_root_logger().setLevel(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			Union[str, Any]:
							return set_verbosity(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			Optional[Any]:
							return set_verbosity(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			Dict:
							return set_verbosity(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			List[str]:
							return set_verbosity(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			None:
							_configure_library_root_logger()

							assert _default_handler is not None
							_get_library_root_logger().removeHandler(_default_handler		)



def       __lowerCamelCase  (					)      ->			None:
							_configure_library_root_logger()

							assert _default_handler is not None
							_get_library_root_logger().addHandler(_default_handler		)



def       __lowerCamelCase  (					_lowercase		)      ->			None:
							_configure_library_root_logger()

							assert handler is not None
							_get_library_root_logger().addHandler(UpperCamelCase_		)



def       __lowerCamelCase  (					_lowercase		)      ->			None:
							_configure_library_root_logger()

							assert handler is not None and handler not in _get_library_root_logger().handlers
							_get_library_root_logger().removeHandler(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			None:
							_configure_library_root_logger()
							UpperCAmelCase     :		Optional[int]							     =		False



def       __lowerCamelCase  (					)      ->			None:
							_configure_library_root_logger()
							UpperCAmelCase     :		Any							     =		True



def       __lowerCamelCase  (					)      ->			None:
							UpperCAmelCase     :		int							     =		_get_library_root_logger().handlers

							for handler in handlers:
														UpperCAmelCase     :		Tuple							     =		logging.Formatter("""[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s"""		)
														handler.setFormatter(UpperCamelCase_		)



def       __lowerCamelCase  (					)      ->			None:
							UpperCAmelCase     :		Dict							     =		_get_library_root_logger().handlers

							for handler in handlers:
														handler.setFormatter(UpperCamelCase_		)



def       __lowerCamelCase  (					self	,				*_lowercase	,				**_lowercase		)      ->			Union[str, Any]:
							UpperCAmelCase     :		int							     =		os.getenv("""TRANSFORMERS_NO_ADVISORY_WARNINGS"""	,				UpperCamelCase_		)
							if no_advisory_warnings:
														return
							self.warning(*UpperCamelCase_	,				**UpperCamelCase_		)


a   :			Union[str, Any]					  =    warning_advice



@functools.lru_cache(UpperCamelCase_		)
def       __lowerCamelCase  (					self	,				*_lowercase	,				**_lowercase		)      ->			Any:
							self.warning(*UpperCamelCase_	,				**UpperCamelCase_		)


a   :			str					  =    warning_once

class 			UpperCamelCase_ :





	def __init__(  self		,		*A		,		**A    )			->			Tuple:  # pylint: disable=unused-argument
								UpperCAmelCase     :		Tuple							     =		args[0] if args else None





	def __iter__(  self    )			->			Any:
								return iter(self._iterator    )





	def __getattr__(  self		,		A    )			->			str:

								def empty_fn(*A		,		**A    ):  # pylint: disable=unused-argument
															return

								return empty_fn





	def __enter__(  self    )			->			Optional[int]:
								return self






	def __exit__(  self		,		A		,		A		,		A    )			->			Optional[Any]:
								return




class 			UpperCamelCase_ :





	def __call__(  self		,		*A		,		**A    )			->			Optional[Any]:
								if _tqdm_active:
															return tqdm_lib.tqdm(*UpperCAmelCase__		,		**UpperCAmelCase__    )
								else:
															return EmptyTqdm(*UpperCAmelCase__		,		**UpperCAmelCase__    )





	def  _lowercase(  self		,		*A		,		**A    )			->			Tuple:
								UpperCAmelCase     :		Optional[int]							     =		None
								if _tqdm_active:
															return tqdm_lib.tqdm.set_lock(*UpperCAmelCase__		,		**UpperCAmelCase__    )






	def  _lowercase(  self    )			->			Tuple:
								if _tqdm_active:
															return tqdm_lib.tqdm.get_lock()




a   :			List[Any]					  =    _tqdm_cls()



def       __lowerCamelCase  (					)      ->			bool:
							global _tqdm_active
							return bool(_tqdm_active		)



def       __lowerCamelCase  (					)      ->			Dict:
							global _tqdm_active
							UpperCAmelCase     :		List[Any]							     =		True
							hf_hub_utils.enable_progress_bars()



def       __lowerCamelCase  (					)      ->			Tuple:
							global _tqdm_active
							UpperCAmelCase     :		Optional[Any]							     =		False
							hf_hub_utils.disable_progress_bars()




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




