





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


lowercase_					     =	logging.get_logger(__name__)  # pylint: disable=invalid-name
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase   ):


   def __init__(					self    :       List[Any]    ,  a    :       List[str]    ,  a    :       List[Any]    ,  a    :       Tuple    ,  a    :       str    ,  a    :       Optional[int]    ,  a    :       str    ,  a    :       List[Any]    ,  )->     List[str]:





     """simple docstring"""







     super().__init__()
     self.register_modules(
         vae=a    ,  text_encoder=a    ,  tokenizer=a    ,  unet=a    ,  scheduler=a    ,  safety_checker=a    ,  feature_extractor=a    ,  )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str]    ,  a    :       str = "auto" )->     Any:





     """simple docstring"""







     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(a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Optional[Any]:





     """simple docstring"""







     self.enable_attention_slicing(a )


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





     """simple docstring"""







     if isinstance(a    ,  a ):
       lowercase__			    =						1
     elif isinstance(a    ,  a ):
       lowercase__			    =						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
     lowercase__			    =						self.tokenizer(
         a    ,  padding='max_length'    ,  max_length=self.tokenizer.model_max_length    ,  return_tensors='pt'    ,  )
     lowercase__			    =						text_inputs.input_ids

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

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

     # duplicate text embeddings for each generation per prompt, using mps friendly method
     lowercase__    ,					lowercase__    ,					lowercase__			    =						text_embeddings.shape
     lowercase__			    =						text_embeddings.repeat(1    ,  a    ,  1 )
     lowercase__			    =						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.
     lowercase__			    =						guidance_scale > 1.0
     # get unconditional embeddings for classifier free guidance
     if do_classifier_free_guidance:
       lowercase__			    =						42
       if negative_prompt is None:
         lowercase__			    =						['']
       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 ):
         lowercase__			    =						[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:
         lowercase__			    =						negative_prompt

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

       # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
       lowercase__			    =						uncond_embeddings.shape[1]
       lowercase__			    =						uncond_embeddings.repeat(a    ,  a    ,  1 )
       lowercase__			    =						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
       lowercase__			    =						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`.
     lowercase__			    =						(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
     lowercase__			    =						(batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
     lowercase__			    =						text_embeddings.dtype
     if latents is None:
       if self.device.type == "mps":
         # randn does not exist on mps
         lowercase__			    =						torch.randn(
             a    ,  generator=a    ,  device='cpu'    ,  dtype=a ).to(self.device )
         lowercase__			    =						torch.randn(a    ,  generator=a    ,  device='cpu'    ,  dtype=a ).to(
             self.device )
       else:
         lowercase__			    =						torch.randn(
             a    ,  generator=a    ,  device=self.device    ,  dtype=a )
         lowercase__			    =						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}""" )
       lowercase__			    =						latents_reference.to(self.device )
       lowercase__			    =						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
     lowercase__			    =						(latents_shape[3] - latents_shape_reference[3]) // 2
     lowercase__			    =						(latents_shape[2] - latents_shape_reference[2]) // 2
     lowercase__			    =						latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
     lowercase__			    =						latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
     lowercase__			    =						0 if dx < 0 else dx
     lowercase__			    =						0 if dy < 0 else dy
     lowercase__			    =						max(-dx    ,  0 )
     lowercase__			    =						max(-dy    ,  0 )
     # import pdb
     # pdb.set_trace()
     lowercase__			    =						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
     lowercase__			    =						self.scheduler.timesteps.to(self.device )

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

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

       # predict the noise residual
       lowercase__			    =						self.unet(a    ,  a    ,  encoder_hidden_states=a ).sample

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

       # compute the previous noisy sample x_t -> x_t-1
       lowercase__			    =						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 )

     lowercase__			    =						1 / 0.18215 * latents
     lowercase__			    =						self.vae.decode(a ).sample

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

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

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

     if output_type == "pil":
       lowercase__			    =						self.numpy_to_pil(a )

     if not return_dict:
       return (image, has_nsfw_concept)

     return StableDiffusionPipelineOutput(images=a    ,  nsfw_content_detected=a )









from string import ascii_uppercase

lowercase_					     =	{str(ord(c) - 55): c for c in ascii_uppercase}




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     str:
  if isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    raise TypeError('int() can\'t convert non-string with explicit base'	)
  if num < 0:
    raise ValueError('parameter must be positive int'	)
  if isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    raise TypeError('\'str\' object cannot be interpreted as an integer'	)
  if isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    raise TypeError('\'float\' object cannot be interpreted as an integer'	)
  if base in (0, 1):
    raise ValueError('base must be >= 2'	)
  if base > 36:
    raise ValueError('base must be <= 36'	)
  lowercase__			    =						''
  lowercase__			    =						0
  lowercase__			    =						0
  while div != 1:
    lowercase__    ,					lowercase__			    =						divmod(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)
    if base >= 11 and 9 < mod < 36:
      lowercase__			    =						ALPHABET_VALUES[str(_SCREAMING_SNAKE_CASE	)]
    else:
      lowercase__			    =						str(_SCREAMING_SNAKE_CASE	)
    new_value += actual_value
    lowercase__			    =						num // base
    lowercase__			    =						div
    if div == 0:
      return str(new_value[::-1]	)
    elif div == 1:
      new_value += str(_SCREAMING_SNAKE_CASE	)
      return str(new_value[::-1]	)

  return new_value[::-1]


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      for base in range(2, 37):
            for num in range(1_000):
                  assert int(decimal_to_any(num, base), base) == num, (
                      num,
                      base,
                      decimal_to_any(num, base),
                      int(decimal_to_any(num, base), base),
                  )


