





import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextModel,
    CLIPTokenizer,
    WhisperForConditionalGeneration,
    WhisperProcessor,
)

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import logging


A__:    List[Any]  	=	logging.get_logger(__name__)  # pylint: disable=invalid-name




class        _a    (    UpperCamelCase__):

      """simple docstring"""


      def __init__(		self:			int	,    __lowerCamelCase:			WhisperForConditionalGeneration	,    __lowerCamelCase:			WhisperProcessor	,    __lowerCamelCase:			AutoencoderKL	,    __lowerCamelCase:			CLIPTextModel	,    __lowerCamelCase:			CLIPTokenizer	,    __lowerCamelCase:			UNetaDConditionModel	,    __lowerCamelCase:			Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]	,    __lowerCamelCase:			StableDiffusionSafetyChecker	,    __lowerCamelCase:			CLIPImageProcessor	,    ):
          '''simple docstring'''


          super().__init__()

          if safety_checker is None:
              logger.warning(
                  F"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
                  " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
                  " results in services or applications open to the public. Both the diffusers team and Hugging Face"
                  " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
                  " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
                  " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."					)

          self.register_modules(
              speech_model=__lowerCamelCase	,    speech_processor=__lowerCamelCase	,    vae=__lowerCamelCase	,    text_encoder=__lowerCamelCase	,    tokenizer=__lowerCamelCase	,    unet=__lowerCamelCase	,    scheduler=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    )






      def 			UpperCAmelCase_       (		self:			int	,    __lowerCamelCase:			Optional[Union[str, int]] = "auto"					):
          '''simple docstring'''


          if slice_size == "auto":
              UpperCamelCase__:	int					=     self.unet.config.attention_head_dim // 2
          self.unet.set_attention_slice(__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          self.enable_attention_slicing(__lowerCamelCase					)






      @torch.no_grad()
      def __call__(		self:			List[Any]	,    __lowerCamelCase:			List[str]	,    __lowerCamelCase:			Optional[Any]=1_6000	,    __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:			str	,    ):
          '''simple docstring'''


          UpperCamelCase__:	Any					=     self.speech_processor.feature_extractor(
              __lowerCamelCase	,    return_tensors="pt"	,    sampling_rate=__lowerCamelCase					).input_features.to(self.device					)
          UpperCamelCase__:	Optional[int]					=     self.speech_model.generate(__lowerCamelCase	,    max_length=48_0000					)

          UpperCamelCase__:	Tuple					=     self.speech_processor.tokenizer.batch_decode(__lowerCamelCase	,    skip_special_tokens=__lowerCamelCase	,    normalize=__lowerCamelCase					)[
              0
          ]

          if isinstance(__lowerCamelCase	,    __lowerCamelCase					):
              UpperCamelCase__:	List[Any]					=     1
          elif isinstance(__lowerCamelCase	,    __lowerCamelCase					):
              UpperCamelCase__:	int					=     len(__lowerCamelCase					)
          else:
              raise ValueError(F"`prompt` has to be of type `str` or `list` but is {type(__lowerCamelCase					)}"					)

          if height % 8 != 0 or width % 8 != 0:
              raise ValueError(F"`height` and `width` have to be divisible by 8 but are {height} and {width}."					)

          if (callback_steps is None) or (
              callback_steps is not None and (not isinstance(__lowerCamelCase	,    __lowerCamelCase					) or callback_steps <= 0)
          ):
              raise ValueError(
                  F"`callback_steps` has to be a positive integer but is {callback_steps} of type"
                  F" {type(__lowerCamelCase					)}."					)

          # get prompt text embeddings
          UpperCamelCase__:	int					=     self.tokenizer(
              __lowerCamelCase	,    padding="max_length"	,    max_length=self.tokenizer.model_max_length	,    return_tensors="pt"	,    )
          UpperCamelCase__:	str					=     text_inputs.input_ids

          if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
              UpperCamelCase__:	Any					=     self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]					)
              logger.warning(
                  "The following part of your input was truncated because CLIP can only handle sequences up to"
                  F" {self.tokenizer.model_max_length} tokens: {removed_text}"					)
              UpperCamelCase__:	str					=     text_input_ids[:, : self.tokenizer.model_max_length]
          UpperCamelCase__:	int					=     self.text_encoder(text_input_ids.to(self.device					)					)[0]

          # duplicate text embeddings for each generation per prompt, using mps friendly method
          UpperCamelCase__				, UpperCamelCase__				, UpperCamelCase__:	Union[str, Any]					=     text_embeddings.shape
          UpperCamelCase__:	Optional[int]					=     text_embeddings.repeat(1	,    __lowerCamelCase	,    1					)
          UpperCamelCase__:	int					=     text_embeddings.view(bs_embed * num_images_per_prompt	,    __lowerCamelCase	,    -1					)

          # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
          # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
          # corresponds to doing no classifier free guidance.
          UpperCamelCase__:	Optional[Any]					=     guidance_scale > 1.0
          # get unconditional embeddings for classifier free guidance
          if do_classifier_free_guidance:
              UpperCamelCase__:	List[str]
              if negative_prompt is None:
                  UpperCamelCase__:	Optional[int]					=     [""] * batch_size
              elif type(__lowerCamelCase					) is not type(__lowerCamelCase					):
                  raise TypeError(
                      F"`negative_prompt` should be the same type to `prompt`, but got {type(__lowerCamelCase					)} !="
                      F" {type(__lowerCamelCase					)}."					)
              elif isinstance(__lowerCamelCase	,    __lowerCamelCase					):
                  UpperCamelCase__:	Optional[Any]					=     [negative_prompt]
              elif batch_size != len(__lowerCamelCase					):
                  raise ValueError(
                      F"`negative_prompt`: {negative_prompt} has batch size {len(__lowerCamelCase					)}, but `prompt`:"
                      F" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
                      " the batch size of `prompt`."					)
              else:
                  UpperCamelCase__:	Any					=     negative_prompt

              UpperCamelCase__:	List[str]					=     text_input_ids.shape[-1]
              UpperCamelCase__:	List[Any]					=     self.tokenizer(
                  __lowerCamelCase	,    padding="max_length"	,    max_length=__lowerCamelCase	,    truncation=__lowerCamelCase	,    return_tensors="pt"	,    )
              UpperCamelCase__:	List[Any]					=     self.text_encoder(uncond_input.input_ids.to(self.device					)					)[0]

              # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
              UpperCamelCase__:	List[Any]					=     uncond_embeddings.shape[1]
              UpperCamelCase__:	List[str]					=     uncond_embeddings.repeat(1	,    __lowerCamelCase	,    1					)
              UpperCamelCase__:	List[str]					=     uncond_embeddings.view(batch_size * num_images_per_prompt	,    __lowerCamelCase	,    -1					)

              # For classifier free guidance, we need to do two forward passes.
              # Here we concatenate the unconditional and text embeddings into a single batch
              # to avoid doing two forward passes
              UpperCamelCase__:	List[Any]					=     torch.cat([uncond_embeddings, text_embeddings]					)

          # get the initial random noise unless the user supplied it

          # Unlike in other pipelines, latents need to be generated in the target device
          # for 1-to-1 results reproducibility with the CompVis implementation.
          # However this currently doesn't work in `mps`.
          UpperCamelCase__:	str					=     (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
          UpperCamelCase__:	str					=     text_embeddings.dtype
          if latents is None:
              if self.device.type == "mps":
                  # randn does not exist on mps
                  UpperCamelCase__:	Tuple					=     torch.randn(__lowerCamelCase	,    generator=__lowerCamelCase	,    device="cpu"	,    dtype=__lowerCamelCase					).to(
                      self.device					)
              else:
                  UpperCamelCase__:	str					=     torch.randn(__lowerCamelCase	,    generator=__lowerCamelCase	,    device=self.device	,    dtype=__lowerCamelCase					)
          else:
              if latents.shape != latents_shape:
                  raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {latents_shape}"					)
              UpperCamelCase__:	Dict					=     latents.to(self.device					)

          # set timesteps
          self.scheduler.set_timesteps(__lowerCamelCase					)

          # Some schedulers like PNDM have timesteps as arrays
          # It's more optimized to move all timesteps to correct device beforehand
          UpperCamelCase__:	Dict					=     self.scheduler.timesteps.to(self.device					)

          # scale the initial noise by the standard deviation required by the scheduler
          UpperCamelCase__:	Optional[Any]					=     latents * self.scheduler.init_noise_sigma

          # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
          # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
          # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
          # and should be between [0, 1]
          UpperCamelCase__:	List[str]					=     "eta" in set(inspect.signature(self.scheduler.step					).parameters.keys()					)
          UpperCamelCase__:	str					=     {}
          if accepts_eta:
              UpperCamelCase__:	Optional[Any]					=     eta

          for i, t in enumerate(self.progress_bar(__lowerCamelCase					)					):
              # expand the latents if we are doing classifier free guidance
              UpperCamelCase__:	List[Any]					=     torch.cat([latents] * 2					) if do_classifier_free_guidance else latents
              UpperCamelCase__:	Dict					=     self.scheduler.scale_model_input(__lowerCamelCase	,    __lowerCamelCase					)

              # predict the noise residual
              UpperCamelCase__:	Optional[int]					=     self.unet(__lowerCamelCase	,    __lowerCamelCase	,    encoder_hidden_states=__lowerCamelCase					).sample

              # perform guidance
              if do_classifier_free_guidance:
                  UpperCamelCase__				, UpperCamelCase__:	Dict					=     noise_pred.chunk(2					)
                  UpperCamelCase__:	Union[str, Any]					=     noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

              # compute the previous noisy sample x_t -> x_t-1
              UpperCamelCase__:	List[Any]					=     self.scheduler.step(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    **__lowerCamelCase					).prev_sample

              # call the callback, if provided
              if callback is not None and i % callback_steps == 0:
                  callback(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)

          UpperCamelCase__:	str					=     1 / 0.18_215 * latents
          UpperCamelCase__:	str					=     self.vae.decode(__lowerCamelCase					).sample

          UpperCamelCase__:	Tuple					=     (image / 2 + 0.5).clamp(0	,    1					)

          # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
          UpperCamelCase__:	List[str]					=     image.cpu().permute(0	,    2	,    3	,    1					).float().numpy()

          if output_type == "pil":
              UpperCamelCase__:	List[str]					=     self.numpy_to_pil(__lowerCamelCase					)

          if not return_dict:
              return image

          return StableDiffusionPipelineOutput(images=__lowerCamelCase	,    nsfw_content_detected=__lowerCamelCase					)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


A__:    Optional[Any]  	=	{
    '''configuration_roberta_prelayernorm''': [
        '''ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''RobertaPreLayerNormConfig''',
        '''RobertaPreLayerNormOnnxConfig''',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    Optional[Any]  	=	[
       '''ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''RobertaPreLayerNormForCausalLM''',
       '''RobertaPreLayerNormForMaskedLM''',
       '''RobertaPreLayerNormForMultipleChoice''',
       '''RobertaPreLayerNormForQuestionAnswering''',
       '''RobertaPreLayerNormForSequenceClassification''',
       '''RobertaPreLayerNormForTokenClassification''',
       '''RobertaPreLayerNormModel''',
       '''RobertaPreLayerNormPreTrainedModel''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    Tuple  	=	[
       '''TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''TFRobertaPreLayerNormForCausalLM''',
       '''TFRobertaPreLayerNormForMaskedLM''',
       '''TFRobertaPreLayerNormForMultipleChoice''',
       '''TFRobertaPreLayerNormForQuestionAnswering''',
       '''TFRobertaPreLayerNormForSequenceClassification''',
       '''TFRobertaPreLayerNormForTokenClassification''',
       '''TFRobertaPreLayerNormMainLayer''',
       '''TFRobertaPreLayerNormModel''',
       '''TFRobertaPreLayerNormPreTrainedModel''',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    Dict  	=	[
       '''FlaxRobertaPreLayerNormForCausalLM''',
       '''FlaxRobertaPreLayerNormForMaskedLM''',
       '''FlaxRobertaPreLayerNormForMultipleChoice''',
       '''FlaxRobertaPreLayerNormForQuestionAnswering''',
       '''FlaxRobertaPreLayerNormForSequenceClassification''',
       '''FlaxRobertaPreLayerNormForTokenClassification''',
       '''FlaxRobertaPreLayerNormModel''',
       '''FlaxRobertaPreLayerNormPreTrainedModel''',
   ]


if TYPE_CHECKING:
   from .configuration_roberta_prelayernorm import (
       ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP,
       RobertaPreLayerNormConfig,
       RobertaPreLayerNormOnnxConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_roberta_prelayernorm import (
          ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
          RobertaPreLayerNormForCausalLM,
          RobertaPreLayerNormForMaskedLM,
          RobertaPreLayerNormForMultipleChoice,
          RobertaPreLayerNormForQuestionAnswering,
          RobertaPreLayerNormForSequenceClassification,
          RobertaPreLayerNormForTokenClassification,
          RobertaPreLayerNormModel,
          RobertaPreLayerNormPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_roberta_prelayernorm import (
          TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFRobertaPreLayerNormForCausalLM,
          TFRobertaPreLayerNormForMaskedLM,
          TFRobertaPreLayerNormForMultipleChoice,
          TFRobertaPreLayerNormForQuestionAnswering,
          TFRobertaPreLayerNormForSequenceClassification,
          TFRobertaPreLayerNormForTokenClassification,
          TFRobertaPreLayerNormMainLayer,
          TFRobertaPreLayerNormModel,
          TFRobertaPreLayerNormPreTrainedModel,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_roberta_prelayernorm import (
          FlaxRobertaPreLayerNormForCausalLM,
          FlaxRobertaPreLayerNormForMaskedLM,
          FlaxRobertaPreLayerNormForMultipleChoice,
          FlaxRobertaPreLayerNormForQuestionAnswering,
          FlaxRobertaPreLayerNormForSequenceClassification,
          FlaxRobertaPreLayerNormForTokenClassification,
          FlaxRobertaPreLayerNormModel,
          FlaxRobertaPreLayerNormPreTrainedModel,
      )

else:
   import sys

   A__:    Union[str, Any]  	=	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

