




'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class        _a    (						__lowerCAmelCase , unittest.TestCase							):
     SCREAMING_SNAKE_CASE_							:   Optional[Any]       =						KandinskyVaaControlnetPipeline
     SCREAMING_SNAKE_CASE_							:   List[Any]       =						["""image_embeds""", """negative_image_embeds""", """hint"""]
     SCREAMING_SNAKE_CASE_							:   Any       =						["""image_embeds""", """negative_image_embeds""", """hint"""]
     SCREAMING_SNAKE_CASE_							:   Optional[int]       =						[
         """generator""",
         """height""",
         """width""",
         """latents""",
         """guidance_scale""",
         """num_inference_steps""",
         """return_dict""",
         """guidance_scale""",
         """num_images_per_prompt""",
         """output_type""",
         """return_dict""",
     ]
     SCREAMING_SNAKE_CASE_							:   Union[str, Any]       =						False






     @property
     def     _lowercase     (			self   )							->      Dict:
          return 32






     @property
     def     _lowercase     (			self   )							->      Union[str, Any]:
          return 32






     @property
     def     _lowercase     (			self   )							->      int:
          return self.time_input_dim






     @property
     def     _lowercase     (			self   )							->      Optional[int]:
          return self.time_input_dim * 4






     @property
     def     _lowercase     (			self   )							->      Tuple:
          return 100






     @property
     def     _lowercase     (			self   )							->      int:
          torch.manual_seed(0   )

          _snake_case							=				{
              "in_channels": 8,
              # Out channels is double in channels because predicts mean and variance
              "out_channels": 8,
              "addition_embed_type": "image_hint",
              "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
              "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
              "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
              "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
              "layers_per_block": 1,
              "encoder_hid_dim": self.text_embedder_hidden_size,
              "encoder_hid_dim_type": "image_proj",
              "cross_attention_dim": self.cross_attention_dim,
              "attention_head_dim": 4,
              "resnet_time_scale_shift": "scale_shift",
              "class_embed_type": None,
          }

          _snake_case							=				UNetaDConditionModel(**_SCREAMING_SNAKE_CASE   )
          return model






     @property
     def     _lowercase     (			self   )							->      Any:
          return {
              "block_out_channels": [32, 32, 64, 64],
              "down_block_types": [
                  "DownEncoderBlock2D",
                  "DownEncoderBlock2D",
                  "DownEncoderBlock2D",
                  "AttnDownEncoderBlock2D",
              ],
              "in_channels": 3,
              "latent_channels": 4,
              "layers_per_block": 1,
              "norm_num_groups": 8,
              "norm_type": "spatial",
              "num_vq_embeddings": 12,
              "out_channels": 3,
              "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
              "vq_embed_dim": 4,
          }






     @property
     def     _lowercase     (			self   )							->      Any:
          torch.manual_seed(0   )
          _snake_case							=				VQModel(**self.dummy_movq_kwargs   )
          return model






     def     _lowercase     (			self   )							->      Optional[Any]:
          _snake_case							=				self.dummy_unet
          _snake_case							=				self.dummy_movq

          _snake_case							=				DDIMScheduler(
              num_train_timesteps=1_000 ,beta_schedule="linear" ,beta_start=0.0_0_0_8_5 ,beta_end=0.0_1_2 ,clip_sample=_SCREAMING_SNAKE_CASE ,set_alpha_to_one=_SCREAMING_SNAKE_CASE ,steps_offset=1 ,prediction_type="epsilon" ,thresholding=_SCREAMING_SNAKE_CASE ,)

          _snake_case							=				{
              "unet": unet,
              "scheduler": scheduler,
              "movq": movq,
          }
          return components






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=0   )							->      List[Any]:
          _snake_case							=				floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(_SCREAMING_SNAKE_CASE   )   ).to(_SCREAMING_SNAKE_CASE   )
          _snake_case							=				floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(seed + 1   )   ).to(
              _SCREAMING_SNAKE_CASE   )

          # create hint
          _snake_case							=				floats_tensor((1, 3, 64, 64) ,rng=random.Random(_SCREAMING_SNAKE_CASE   )   ).to(_SCREAMING_SNAKE_CASE   )

          if str(_SCREAMING_SNAKE_CASE   ).startswith("mps"   ):
               _snake_case							=				torch.manual_seed(_SCREAMING_SNAKE_CASE   )
          else:
               _snake_case							=				torch.Generator(device=_SCREAMING_SNAKE_CASE   ).manual_seed(_SCREAMING_SNAKE_CASE   )
          _snake_case							=				{
              "image_embeds": image_embeds,
              "negative_image_embeds": negative_image_embeds,
              "hint": hint,
              "generator": generator,
              "height": 64,
              "width": 64,
              "guidance_scale": 4.0,
              "num_inference_steps": 2,
              "output_type": "np",
          }
          return inputs






     def     _lowercase     (			self   )							->      str:
          _snake_case							=				"cpu"

          _snake_case							=				self.get_dummy_components()

          _snake_case							=				self.pipeline_class(**_SCREAMING_SNAKE_CASE   )
          _snake_case							=				pipe.to(_SCREAMING_SNAKE_CASE   )

          pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

          _snake_case							=				pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE   )   )
          _snake_case							=				output.images

          _snake_case							=				pipe(
              **self.get_dummy_inputs(_SCREAMING_SNAKE_CASE   ) ,return_dict=_SCREAMING_SNAKE_CASE ,)[0]

          _snake_case							=				image[0, -3:, -3:, -1]
          _snake_case							=				image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)

          _snake_case							=				np.array(
              [0.6_9_5_9_8_2_6, 0.8_6_8_2_7_9, 0.7_5_5_8_0_9_2, 0.6_8_7_6_9_4_6_7, 0.8_5_8_0_5_8_0_4, 0.6_5_9_7_7_4_9_6, 0.4_4_8_8_5_3_0_2, 0.5_9_5_9_1_1_1, 0.4_2_5_1_5_9_5]   )

          assert (
              np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2
          ), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""

          assert (
              np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < 1e-2
          ), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""







@slow
@require_torch_gpu
class        _a    (						unittest.TestCase							):






     def     _lowercase     (			self   )							->      int:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()






     def     _lowercase     (			self   )							->      Tuple:
          _snake_case							=				load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy"   )

          _snake_case							=				load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/kandinskyv22/hint_image_cat.png"   )
          _snake_case							=				torch.from_numpy(np.array(_SCREAMING_SNAKE_CASE   )   ).float() / 2_5_5.0
          _snake_case							=				hint.permute(2 ,0 ,1   ).unsqueeze(0   )

          _snake_case							=				KandinskyVaaPriorPipeline.from_pretrained(
              "kandinsky-community/kandinsky-2-2-prior" ,torch_dtype=torch.floataa   )
          pipe_prior.to(_SCREAMING_SNAKE_CASE   )

          _snake_case							=				KandinskyVaaControlnetPipeline.from_pretrained(
              "kandinsky-community/kandinsky-2-2-controlnet-depth" ,torch_dtype=torch.floataa   )
          _snake_case							=				pipeline.to(_SCREAMING_SNAKE_CASE   )
          pipeline.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE   )

          _snake_case							=				"A robot, 4k photo"

          _snake_case							=				torch.Generator(device="cuda"   ).manual_seed(0   )
          _snake_case							, _snake_case							=				pipe_prior(
              _SCREAMING_SNAKE_CASE ,generator=_SCREAMING_SNAKE_CASE ,num_inference_steps=5 ,negative_prompt="" ,).to_tuple()

          _snake_case							=				torch.Generator(device="cuda"   ).manual_seed(0   )
          _snake_case							=				pipeline(
              image_embeds=_SCREAMING_SNAKE_CASE ,negative_image_embeds=_SCREAMING_SNAKE_CASE ,hint=_SCREAMING_SNAKE_CASE ,generator=_SCREAMING_SNAKE_CASE ,num_inference_steps=100 ,output_type="np" ,)

          _snake_case							=				output.images[0]

          assert image.shape == (512, 512, 3)

          assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )








'''simple docstring'''





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





def      __a     (       _UpperCamelCase:   int   )						->			str:

     """simple docstring"""




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

     _snake_case							=				precision
     _snake_case							=				ceil(precision / 14   )
     _snake_case							=				426_880 * Decimal(10_005   ).sqrt()
     _snake_case							=				1
     _snake_case							=				13_591_409
     _snake_case							=				Decimal(_UpperCamelCase   )
     for k in range(1 ,						_UpperCamelCase   ):
          _snake_case							=				factorial(6 * k   ) // (factorial(3 * k   ) * factorial(_UpperCamelCase   ) ** 3)
          linear_term += 545_140_134
          exponential_term *= -262_537_412_640_768_000
          partial_sum += Decimal(multinomial_term * linear_term   ) / exponential_term
     return str(constant_term / partial_sum   )[:-1]


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


