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   :     str       =				"CompVis/stable-diffusion-v1-1"
A   :     Any       =				"CompVis/stable-diffusion-v1-2"
A   :     Tuple       =				"CompVis/stable-diffusion-v1-3"
A   :     Tuple       =				"CompVis/stable-diffusion-v1-4"


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  def __init__(							self       :				Optional[int]     ,   __magic_name__       :				AutoencoderKL     ,   __magic_name__       :				CLIPTextModel     ,   __magic_name__       :				CLIPTokenizer     ,   __magic_name__       :				UNetaDConditionModel     ,   __magic_name__       :				Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]     ,   __magic_name__       :				StableDiffusionSafetyChecker     ,   __magic_name__       :				CLIPImageProcessor     ,   __magic_name__       :				bool = True     ,   )     ->		int:
        super()._init_()

        SCREAMING_SNAKE_CASE_      =     StableDiffusionPipeline.from_pretrained(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     StableDiffusionPipeline.from_pretrained(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     StableDiffusionPipeline.from_pretrained(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     StableDiffusionPipeline(
            vae=__magic_name__     ,   text_encoder=__magic_name__     ,   tokenizer=__magic_name__     ,   unet=__magic_name__     ,   scheduler=__magic_name__     ,   safety_checker=__magic_name__     ,   feature_extractor=__magic_name__     ,   requires_safety_checker=__magic_name__     ,   )

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







  @property
  def       __A   (							self       :				Any      )     ->		Dict[str, Any]:
        return {k: getattr(self     ,   __magic_name__      ) for k in self.config.keys() if not k.startswith("_"      )}







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







  def       __A   (							self       :				Dict      )     ->		Any:
        self.enable_attention_slicing(__magic_name__      )







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







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







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







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







  @torch.no_grad()
  def       __A   (							self       :				Dict     ,   __magic_name__       :				Union[str, List[str]]     ,   __magic_name__       :				int = 512     ,   __magic_name__       :				int = 512     ,   __magic_name__       :				int = 50     ,   __magic_name__       :				float = 7.5     ,   __magic_name__       :				Optional[Union[str, List[str]]] = None     ,   __magic_name__       :				Optional[int] = 1     ,   __magic_name__       :				float = 0.0     ,   __magic_name__       :				Optional[torch.Generator] = None     ,   __magic_name__       :				Optional[torch.FloatTensor] = None     ,   __magic_name__       :				Optional[str] = "pil"     ,   __magic_name__       :				bool = True     ,   __magic_name__       :				Optional[Callable[[int, int, torch.FloatTensor], None]] = None     ,   __magic_name__       :				int = 1     ,   **__magic_name__       :				Dict     ,   )     ->		Tuple:
        SCREAMING_SNAKE_CASE_      =     "cuda" if torch.cuda.is_available() else "cpu"
        self.to(__magic_name__      )

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

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

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

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

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



from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available


@dataclass
class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  42
  lowerCamelCase__   =  42


if is_transformers_available() and is_torch_available():
      from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline


