






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


UpperCAmelCase__				   =		"CompVis/stable-diffusion-v1-1"
UpperCAmelCase__				   =		"CompVis/stable-diffusion-v1-2"
UpperCAmelCase__				   =		"CompVis/stable-diffusion-v1-3"
UpperCAmelCase__				   =		"CompVis/stable-diffusion-v1-4"






class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      def __init__(      self      :						Tuple ,					__UpperCAmelCase      :						AutoencoderKL ,					__UpperCAmelCase      :						CLIPTextModel ,					__UpperCAmelCase      :						CLIPTokenizer ,					__UpperCAmelCase      :						UNetaDConditionModel ,					__UpperCAmelCase      :						Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler] ,					__UpperCAmelCase      :						StableDiffusionSafetyChecker ,					__UpperCAmelCase      :						CLIPImageProcessor ,					__UpperCAmelCase      :						bool = True ,					)    ->List[str]:




       """simple docstring"""


       super()._init_()

       a		  =      StableDiffusionPipeline.from_pretrained(__UpperCAmelCase  )
       a		  =      StableDiffusionPipeline.from_pretrained(__UpperCAmelCase  )
       a		  =      StableDiffusionPipeline.from_pretrained(__UpperCAmelCase  )
       a		  =      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       __lowerCAmelCase					(      self      :						str  )    ->Dict[str, Any]:




       """simple docstring"""


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







      def       __lowerCAmelCase					(      self      :						str ,					__UpperCAmelCase      :						Optional[Union[str, int]] = "auto"  )    ->int:




       """simple docstring"""


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







      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->Tuple:




       """simple docstring"""


       self.enable_attention_slicing(__UpperCAmelCase  )







      @torch.no_grad()
      def       __lowerCAmelCase					(      self      :						Dict ,					__UpperCAmelCase      :						Union[str, List[str]] ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 50 ,					__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      :						List[str] ,					)    ->Any:




       """simple docstring"""


       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       __lowerCAmelCase					(      self      :						Optional[int] ,					__UpperCAmelCase      :						Union[str, List[str]] ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 50 ,					__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 ,					)    ->str:




       """simple docstring"""


       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       __lowerCAmelCase					(      self      :						List[str] ,					__UpperCAmelCase      :						Union[str, List[str]] ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 50 ,					__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 ,					)    ->Tuple:




       """simple docstring"""


       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       __lowerCAmelCase					(      self      :						Tuple ,					__UpperCAmelCase      :						Union[str, List[str]] ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 50 ,					__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      :						List[str] ,					)    ->Tuple:




       """simple docstring"""


       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       __lowerCAmelCase					(      self      :						List[str] ,					__UpperCAmelCase      :						Union[str, List[str]] ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 512 ,					__UpperCAmelCase      :						int = 50 ,					__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      :						int ,					)    ->Optional[int]:




       """simple docstring"""


       a		  =      '''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
       a		  =      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
       a		  =      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
       a		  =      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
       a		  =      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]]  )



'''simple docstring'''




import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__lowercase          =  logging.get_logger(__name__)






class 				a__(					lowerCAmelCase__	):


			'''simple docstring'''






			UpperCAmelCase_			:     Union[str, Any]      =       ['''input_features''']



			def __init__(   self       ,    __lowerCAmelCase=80       ,    __lowerCAmelCase=16000       ,    __lowerCAmelCase=160       ,    __lowerCAmelCase=30       ,    __lowerCAmelCase=400       ,    __lowerCAmelCase=0.0       ,    __lowerCAmelCase=False       ,    **__lowerCAmelCase       ,    ):




					"""simple docstring"""


					super().__init__(
					    feature_size=__lowerCAmelCase       ,    sampling_rate=__lowerCAmelCase       ,    padding_value=__lowerCAmelCase       ,    return_attention_mask=__lowerCAmelCase       ,    **__lowerCAmelCase       ,    )
					lowerCAmelCase   					=  n_fft
					lowerCAmelCase   					=  hop_length
					lowerCAmelCase   					=  chunk_length
					lowerCAmelCase   					=  chunk_length * sampling_rate
					lowerCAmelCase   					=  self.n_samples // hop_length
					lowerCAmelCase   					=  sampling_rate
					lowerCAmelCase   					=  mel_filter_bank(
					    num_frequency_bins=1 + n_fft // 2       ,    num_mel_filters=__lowerCAmelCase       ,    min_frequency=0.0       ,    max_frequency=8000.0       ,    sampling_rate=__lowerCAmelCase       ,    norm="""slaney"""       ,    mel_scale="""slaney"""       ,    )



			def 							a_       (   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  spectrogram(
					    __lowerCAmelCase       ,    window_function(self.n_fft       ,    """hann""")       ,    frame_length=self.n_fft       ,    hop_length=self.hop_length       ,    power=2.0       ,    mel_filters=self.mel_filters       ,    log_mel="""log10"""       ,    )
					lowerCAmelCase   					=  log_spec[:, :-1]
					lowerCAmelCase   					=  np.maximum(__lowerCAmelCase       ,    log_spec.max() - 8.0)
					lowerCAmelCase   					=  (log_spec + 4.0) / 4.0
					return log_spec



			@staticmethod
			# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
			def 							a_       (   __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase = 0.0):




					"""simple docstring"""


					if attention_mask is not None:
							lowerCAmelCase   					=  np.array(__lowerCAmelCase       ,    np.intaa)
							lowerCAmelCase   					=  []

							for vector, length in zip(__lowerCAmelCase       ,    attention_mask.sum(-1)):
									lowerCAmelCase   					=  (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7)
									if length < normed_slice.shape[0]:
											lowerCAmelCase   					=  padding_value

									normed_input_values.append(__lowerCAmelCase)
					else:
							lowerCAmelCase   					=  [(x - x.mean()) / np.sqrt(x.var() + 1E-7) for x in input_values]

					return normed_input_values



			def __call__(   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase = True       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = "max_length"       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    **__lowerCAmelCase       ,    ):




					"""simple docstring"""


					if sampling_rate is not None:
							if sampling_rate != self.sampling_rate:
									raise ValueError(
									    f"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
									    f" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
									    f" was sampled with {self.sampling_rate} and not {sampling_rate}.")
					else:
							logger.warning(
							    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
							    """Failing to do so can result in silent errors that might be hard to debug.""")

					lowerCAmelCase   					=  isinstance(__lowerCAmelCase       ,    np.ndarray) and len(raw_speech.shape) > 1
					if is_batched_numpy and len(raw_speech.shape) > 2:
							raise ValueError(f"Only mono-channel audio is supported for input to {self}")
					lowerCAmelCase   					=  is_batched_numpy or (
					    isinstance(__lowerCAmelCase       ,    (list, tuple)) and (isinstance(raw_speech[0]       ,    (np.ndarray, tuple, list)))
					)

					if is_batched:
							lowerCAmelCase   					=  [np.asarray([speech]       ,    dtype=np.floataa).T for speech in raw_speech]
					elif not is_batched and not isinstance(__lowerCAmelCase       ,    np.ndarray):
							lowerCAmelCase   					=  np.asarray(__lowerCAmelCase       ,    dtype=np.floataa)
					elif isinstance(__lowerCAmelCase       ,    np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
							lowerCAmelCase   					=  raw_speech.astype(np.floataa)

					# always return batch
					if not is_batched:
							lowerCAmelCase   					=  [np.asarray([raw_speech]).T]

					lowerCAmelCase   					=  BatchFeature({"""input_features""": raw_speech})

					# convert into correct format for padding

					lowerCAmelCase   					=  self.pad(
					    __lowerCAmelCase       ,    padding=__lowerCAmelCase       ,    max_length=max_length if max_length else self.n_samples       ,    truncation=__lowerCAmelCase       ,    pad_to_multiple_of=__lowerCAmelCase       ,    return_attention_mask=return_attention_mask or do_normalize       ,    )

					# zero-mean and unit-variance normalization
					if do_normalize:
							lowerCAmelCase   					=  self.zero_mean_unit_var_norm(
							    padded_inputs["""input_features"""]       ,    attention_mask=padded_inputs["""attention_mask"""]       ,    padding_value=self.padding_value       ,    )
							lowerCAmelCase   					=  np.stack(padded_inputs["""input_features"""]       ,    axis=0)

					# make sure list is in array format
					lowerCAmelCase   					=  padded_inputs.get("""input_features""").transpose(2       ,    0       ,    1)

					lowerCAmelCase   					=  [self._np_extract_fbank_features(__lowerCAmelCase) for waveform in input_features[0]]

					if isinstance(input_features[0]       ,    __lowerCAmelCase):
							lowerCAmelCase   					=  [np.asarray(__lowerCAmelCase       ,    dtype=np.floataa) for feature in input_features]
					else:
							lowerCAmelCase   					=  input_features

					if return_attention_mask:
							# rescale from sample (48000) to feature (3000)
							lowerCAmelCase   					=  padded_inputs["""attention_mask"""][:, :: self.hop_length]

					if return_tensors is not None:
							lowerCAmelCase   					=  padded_inputs.convert_to_tensors(__lowerCAmelCase)

					return padded_inputs







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  copy.deepcopy(self.__dict__)
					lowerCAmelCase   					=  self.__class__.__name__
					if "mel_filters" in output:
							del output["mel_filters"]
					return output




