






'''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


__A							:							Tuple  							=		logging.get_logger(__name__)  # pylint: disable=invalid-name
class 				lowercase       (							_lowerCamelCase      ):


    '''simple docstring'''

    def __init__(					self     :     Tuple				,     __lowerCamelCase     :     AutoencoderKL				,     __lowerCamelCase     :     CLIPTextModel				,     __lowerCamelCase     :     CLIPTokenizer				,     __lowerCamelCase     :     UNetaDConditionModel				,     __lowerCamelCase     :     Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]				,     __lowerCamelCase     :     StableDiffusionSafetyChecker				,     __lowerCamelCase     :     CLIPImageProcessor				,     )							->							List[Any]:

     '''simple docstring'''




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

    def    a__				(					self     :     Optional[int]				,     __lowerCamelCase     :     Optional[Union[str, int]] = "auto"     )							->							List[str]:

     '''simple docstring'''




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

    def    a__				(					self     :     str     )							->							Optional[int]:

     '''simple docstring'''




     self.enable_attention_slicing(__lowerCamelCase     )




    @torch.no_grad()
    def __call__(					self     :     str				,     __lowerCamelCase     :     Union[str, List[str]]				,     __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     :     Optional[torch.FloatTensor] = None				,     **__lowerCamelCase     :     Dict				,     )							->							List[str]:

     '''simple docstring'''




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

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

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

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

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

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

     # 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
     lowerCamelCase__  =     self.scheduler.timesteps.to(self.device     )

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

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

      # predict the noise residual
      lowerCamelCase__  =     self.unet(__lowerCamelCase				,     __lowerCamelCase				,     encoder_hidden_states=__lowerCamelCase     ).sample

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

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

     lowerCamelCase__  =     1 / 0.1_8_2_1_5 * latents
     lowerCamelCase__  =     self.vae.decode(__lowerCamelCase     ).sample

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

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

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

     if output_type == "pil":
      lowerCamelCase__  =     self.numpy_to_pil(__lowerCamelCase     )

     if not return_dict:
      return (image, has_nsfw_concept)

     return StableDiffusionPipelineOutput(images=__lowerCamelCase				,     nsfw_content_detected=__lowerCamelCase     )









'''simple docstring'''





from decimal import Decimal, getcontext
from math import ceil, factorial






def    lowerCamelCase_     (    lowercase__):

 if not isinstance(lowercase__				,     lowercase__):
  raise TypeError("Undefined for non-integers")
 elif precision < 1:
  raise ValueError("Undefined for non-natural numbers")

 lowerCamelCase__  =     precision
 lowerCamelCase__  =     ceil(precision / 14)
 lowerCamelCase__  =     426880 * Decimal(10005).sqrt()
 lowerCamelCase__  =     1
 lowerCamelCase__  =     13591409
 lowerCamelCase__  =     Decimal(lowercase__)
 for k in range(1				,     lowercase__):
  lowerCamelCase__  =     factorial(6 * k) // (factorial(3 * k) * factorial(lowercase__) ** 3)
  linear_term += 545140134
  exponential_term *= -262537412640768000
  partial_sum += Decimal(multinomial_term * linear_term) / exponential_term
 return str(constant_term / partial_sum)[:-1]


if __name__ == "__main__":
 __A							:							Dict  							=		50
 print(F"""The first {n} digits of pi is: {pi(n)}""")

