

'''simple docstring'''




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

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


_lowerCAmelCase            =		logging.get_logger(__name__)  # pylint: disable=invalid-name






class     _SCREAMING_SNAKE_CASE       (       __a      ):



 def __init__(       self						:       int					, a__						:       Union[str, Any]					, a__						:       Union[str, Any]					, a__						:       str					, a__						:       List[str]					, a__						:       List[str]					, a__						:       Dict					, a__						:       str					, ):
      super().__init__()
      self.register_modules(
          vae=a__					, text_encoder=a__					, tokenizer=a__					, unet=a__					, scheduler=a__					, safety_checker=a__					, feature_extractor=a__					, )



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



 def 					snake_case__    (       self						:       Optional[Any]     ):
      self.enable_attention_slicing(a__     )



 @torch.no_grad()
 def __call__(       self						:       List[str]					, a__						:       Union[str, Any]					, a__						:       Dict = 512					, a__						:       List[Any] = 512					, a__						:       Dict = 50					, a__						:       Optional[Any] = 7.5					, a__						:       List[Any] = None					, a__						:       Dict = 1					, a__						:       List[Any] = 0.0					, a__						:       Dict = None					, a__						:       Optional[int] = None					, a__						:       Dict = "pil"					, a__						:       int = True					, a__						:       List[str] = None					, a__						:       Optional[Any] = 1					, a__						:       List[str] = None					, **a__						:       Tuple					, ):

      if isinstance(a__					, a__     ):
           __magic_name__		  =							1
      elif isinstance(a__					, a__     ):
           __magic_name__		  =							len(a__     )
      else:
           raise ValueError(F'''`prompt` has to be of type `str` or `list` but is {type(a__     )}'''     )

      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(a__					, a__     ) or callback_steps <= 0)
      ):
           raise ValueError(
               F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
               F''' {type(a__     )}.'''     )

      # get prompt text embeddings
      __magic_name__		  =							self.tokenizer(
          a__					, padding='''max_length'''					, max_length=self.tokenizer.model_max_length					, return_tensors='''pt'''					, )
      __magic_name__		  =							text_inputs.input_ids

      if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
           __magic_name__		  =							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}'''     )
           __magic_name__		  =							text_input_ids[:, : self.tokenizer.model_max_length]

      if text_embeddings is None:
           __magic_name__		  =							self.text_encoder(text_input_ids.to(self.device     )     )[0]

      # duplicate text embeddings for each generation per prompt, using mps friendly method
      __magic_name__		  =							text_embeddings.shape
      __magic_name__		  =							text_embeddings.repeat(1					, a__					, 1     )
      __magic_name__		  =							text_embeddings.view(bs_embed * num_images_per_prompt					, a__					, -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.
      __magic_name__		  =							guidance_scale > 1.0
      # get unconditional embeddings for classifier free guidance
      if do_classifier_free_guidance:
           __magic_name__		  =							42
           if negative_prompt is None:
                __magic_name__		  =							['']
           elif type(a__     ) is not type(a__     ):
                raise TypeError(
                    F'''`negative_prompt` should be the same type to `prompt`, but got {type(a__     )} !='''
                    F''' {type(a__     )}.'''     )
           elif isinstance(a__					, a__     ):
                __magic_name__		  =							[negative_prompt]
           elif batch_size != len(a__     ):
                raise ValueError(
                    F'''`negative_prompt`: {negative_prompt} has batch size {len(a__     )}, but `prompt`:'''
                    F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
                    ''' the batch size of `prompt`.'''     )
           else:
                __magic_name__		  =							negative_prompt

           __magic_name__		  =							text_input_ids.shape[-1]
           __magic_name__		  =							self.tokenizer(
               a__					, padding='''max_length'''					, max_length=a__					, truncation=a__					, return_tensors='''pt'''					, )
           __magic_name__		  =							self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]

           # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
           __magic_name__		  =							uncond_embeddings.shape[1]
           __magic_name__		  =							uncond_embeddings.repeat(a__					, a__					, 1     )
           __magic_name__		  =							uncond_embeddings.view(batch_size * num_images_per_prompt					, a__					, -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
           __magic_name__		  =							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`.
      __magic_name__		  =							(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
      __magic_name__		  =							(batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
      __magic_name__		  =							text_embeddings.dtype
      if latents is None:
           if self.device.type == "mps":
                # randn does not exist on mps
                __magic_name__		  =							torch.randn(
                    a__					, generator=a__					, device='''cpu'''					, dtype=a__     ).to(self.device     )
                __magic_name__		  =							torch.randn(a__					, generator=a__					, device='''cpu'''					, dtype=a__     ).to(
                    self.device     )
           else:
                __magic_name__		  =							torch.randn(
                    a__					, generator=a__					, device=self.device					, dtype=a__     )
                __magic_name__		  =							torch.randn(a__					, generator=a__					, device=self.device					, dtype=a__     )
      else:
           if latents_reference.shape != latents_shape:
                raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''     )
           __magic_name__		  =							latents_reference.to(self.device     )
           __magic_name__		  =							latents.to(self.device     )

      # This is the key part of the pipeline where we
      # try to ensure that the generated images w/ the same seed
      # but different sizes actually result in similar images
      __magic_name__		  =							(latents_shape[3] - latents_shape_reference[3]) // 2
      __magic_name__		  =							(latents_shape[2] - latents_shape_reference[2]) // 2
      __magic_name__		  =							latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
      __magic_name__		  =							latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
      __magic_name__		  =							0 if dx < 0 else dx
      __magic_name__		  =							0 if dy < 0 else dy
      __magic_name__		  =							max(-dx					, 0     )
      __magic_name__		  =							max(-dy					, 0     )
      # import pdb
      # pdb.set_trace()
      __magic_name__		  =							latents_reference[:, :, dy : dy + h, dx : dx + w]

      # set timesteps
      self.scheduler.set_timesteps(a__     )

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

      # scale the initial noise by the standard deviation required by the scheduler
      __magic_name__		  =							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]
      __magic_name__		  =							'eta' in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
      __magic_name__		  =							{}
      if accepts_eta:
           __magic_name__		  =							eta

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

           # predict the noise residual
           __magic_name__		  =							self.unet(a__					, a__					, encoder_hidden_states=a__     ).sample

           # perform guidance
           if do_classifier_free_guidance:
                __magic_name__		  =							noise_pred.chunk(2     )
                __magic_name__		  =							noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

           # compute the previous noisy sample x_t -> x_t-1
           __magic_name__		  =							self.scheduler.step(a__					, a__					, a__					, **a__     ).prev_sample

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

      __magic_name__		  =							1 / 0.18_215 * latents
      __magic_name__		  =							self.vae.decode(a__     ).sample

      __magic_name__		  =							(image / 2 + 0.5).clamp(0					, 1     )

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

      if self.safety_checker is not None:
           __magic_name__		  =							self.feature_extractor(self.numpy_to_pil(a__     )					, return_tensors='''pt'''     ).to(
               self.device     )
           __magic_name__		  =							self.safety_checker(
               images=a__					, clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype     )     )
      else:
           __magic_name__		  =							None

      if output_type == "pil":
           __magic_name__		  =							self.numpy_to_pil(a__     )

      if not return_dict:
           return (image, has_nsfw_concept)

      return StableDiffusionPipelineOutput(images=a__					, nsfw_content_detected=a__     )










'''simple docstring'''






def lowerCamelCase__     (		__lowerCamelCase			:				str = "The quick brown fox jumps over the lazy dog"			,       ):







   '''simple docstring'''




   _UpperCAmelCase  :  Optional[Any]				       =set()

   # Replace all the whitespace in our sentence
   _UpperCAmelCase  :  Dict				       =input_str.replace(' '			,       ''				)
   for alpha in input_str:
      if "a" <= alpha.lower() <= "z":
         frequency.add(alpha.lower()				)
   return len(__lowerCamelCase				) == 2_6





def lowerCamelCase__     (		__lowerCamelCase			:				str = "The quick brown fox jumps over the lazy dog"			,       ):







   '''simple docstring'''




   _UpperCAmelCase  :  Tuple				       =[False] * 2_6
   for char in input_str:
      if char.islower():
         _UpperCAmelCase  :  Dict				       =True
      elif char.isupper():
         _UpperCAmelCase  :  List[str]				       =True
   return all(__lowerCamelCase				)





def lowerCamelCase__     (		__lowerCamelCase			:				str = "The quick brown fox jumps over the lazy dog"			,       ):







   '''simple docstring'''




   return len({char for char in input_str.lower() if char.isalpha()}				) == 2_6





def lowerCamelCase__     (		):







   '''simple docstring'''




   from timeit import timeit

   _UpperCAmelCase  :  List[Any]				       ='from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest'
   print(timeit('is_pangram()'			,       setup=__lowerCamelCase				)				)
   print(timeit('is_pangram_faster()'			,       setup=__lowerCamelCase				)				)
   print(timeit('is_pangram_fastest()'			,       setup=__lowerCamelCase				)				)
   # 5.348480500048026, 2.6477354579837993, 1.8470395830227062
   # 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()

