'''simple docstring'''




import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()


class       UpperCAmelCase__  (       _snake_case					,     _snake_case					,     _snake_case					,     unittest.TestCase			):






   """simple docstring"""
   A							:       Optional[Any]     =    StableDiffusionControlNetImgaImgPipeline
   A							:       Union[str, Any]     =    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
   A							:       Union[str, Any]     =    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   A							:       List[str]     =    IMAGE_TO_IMAGE_IMAGE_PARAMS.union({'''control_image'''}			)
   A							:       Tuple     =    IMAGE_TO_IMAGE_IMAGE_PARAMS
   def 		_lowerCamelCase (self				)    ->     List[Any]:
        torch.manual_seed(0				)
        lowercase_					:       Tuple     				=					UNetaDConditionModel(
            block_out_channels=(32, 64)       ,				layers_per_block=2       ,				sample_size=32       ,				in_channels=4       ,				out_channels=4       ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')       ,				cross_attention_dim=32       ,				)
        torch.manual_seed(0				)
        lowercase_					:       List[str]     				=					ControlNetModel(
            block_out_channels=(32, 64)       ,				layers_per_block=2       ,				in_channels=4       ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,				cross_attention_dim=32       ,				conditioning_embedding_out_channels=(16, 32)       ,				)
        torch.manual_seed(0				)
        lowercase_					:       Optional[int]     				=					DDIMScheduler(
            beta_start=0.0_00_85       ,				beta_end=0.0_12       ,				beta_schedule='scaled_linear'       ,				clip_sample=_a       ,				set_alpha_to_one=_a       ,				)
        torch.manual_seed(0				)
        lowercase_					:       List[str]     				=					AutoencoderKL(
            block_out_channels=[32, 64]       ,				in_channels=3       ,				out_channels=3       ,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']       ,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']       ,				latent_channels=4       ,				)
        torch.manual_seed(0				)
        lowercase_					:       Union[str, Any]     				=					CLIPTextConfig(
            bos_token_id=0       ,				eos_token_id=2       ,				hidden_size=32       ,				intermediate_size=37       ,				layer_norm_eps=1e-05       ,				num_attention_heads=4       ,				num_hidden_layers=5       ,				pad_token_id=1       ,				vocab_size=1_000       ,				)
        lowercase_					:       str     				=					CLIPTextModel(_a				)
        lowercase_					:       Tuple     				=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

        lowercase_					:       Union[str, Any]     				=					{
            'unet': unet,
            'controlnet': controlnet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        return components
   def 		_lowerCamelCase (self       ,				_a       ,				_a=0				)    ->     Optional[Any]:
        if str(_a				).startswith('mps'				):
             lowercase_					:       Optional[int]     				=					torch.manual_seed(_a				)
        else:
             lowercase_					:       str     				=					torch.Generator(device=_a				).manual_seed(_a				)

        lowercase_					:       Dict     				=					2
        lowercase_					:       Tuple     				=					randn_tensor(
            (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,				generator=_a       ,				device=torch.device(_a				)       ,				)
        lowercase_					:       List[Any]     				=					floats_tensor(control_image.shape       ,				rng=random.Random(_a				)				).to(_a				)
        lowercase_					:       Tuple     				=					image.cpu().permute(0       ,				2       ,				3       ,				1				)[0]
        lowercase_					:       int     				=					Image.fromarray(np.uinta(_a				)				).convert('RGB'				).resize((64, 64)				)
        lowercase_					:       str     				=					{
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
            'image': image,
            'control_image': control_image,
        }

        return inputs
   def 		_lowerCamelCase (self				)    ->     List[str]:
        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3				)
   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()       ,				reason='XFormers attention is only available with CUDA and `xformers` installed'       ,				)
   def 		_lowerCamelCase (self				)    ->     Any:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3				)





   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3				)



class       UpperCAmelCase__  (       _snake_case					,     _snake_case					,     unittest.TestCase			):






   """simple docstring"""
   A							:       int     =    StableDiffusionControlNetImgaImgPipeline
   A							:       List[Any]     =    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
   A							:       Optional[Any]     =    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   A							:       Dict     =    frozenset([]			)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess
   def 		_lowerCamelCase (self				)    ->     Optional[int]:
        torch.manual_seed(0				)
        lowercase_					:       List[Any]     				=					UNetaDConditionModel(
            block_out_channels=(32, 64)       ,				layers_per_block=2       ,				sample_size=32       ,				in_channels=4       ,				out_channels=4       ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')       ,				cross_attention_dim=32       ,				)
        torch.manual_seed(0				)

        def init_weights(_a				):
             if isinstance(_a       ,				torch.nn.Convad				):
                  torch.nn.init.normal(m.weight				)
                  m.bias.data.fill_(1.0				)

        lowercase_					:       List[Any]     				=					ControlNetModel(
            block_out_channels=(32, 64)       ,				layers_per_block=2       ,				in_channels=4       ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,				cross_attention_dim=32       ,				conditioning_embedding_out_channels=(16, 32)       ,				)
        controlneta.controlnet_down_blocks.apply(_a				)

        torch.manual_seed(0				)
        lowercase_					:       Optional[Any]     				=					ControlNetModel(
            block_out_channels=(32, 64)       ,				layers_per_block=2       ,				in_channels=4       ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,				cross_attention_dim=32       ,				conditioning_embedding_out_channels=(16, 32)       ,				)
        controlneta.controlnet_down_blocks.apply(_a				)

        torch.manual_seed(0				)
        lowercase_					:       Dict     				=					DDIMScheduler(
            beta_start=0.0_00_85       ,				beta_end=0.0_12       ,				beta_schedule='scaled_linear'       ,				clip_sample=_a       ,				set_alpha_to_one=_a       ,				)
        torch.manual_seed(0				)
        lowercase_					:       List[Any]     				=					AutoencoderKL(
            block_out_channels=[32, 64]       ,				in_channels=3       ,				out_channels=3       ,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']       ,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']       ,				latent_channels=4       ,				)
        torch.manual_seed(0				)
        lowercase_					:       Dict     				=					CLIPTextConfig(
            bos_token_id=0       ,				eos_token_id=2       ,				hidden_size=32       ,				intermediate_size=37       ,				layer_norm_eps=1e-05       ,				num_attention_heads=4       ,				num_hidden_layers=5       ,				pad_token_id=1       ,				vocab_size=1_000       ,				)
        lowercase_					:       Tuple     				=					CLIPTextModel(_a				)
        lowercase_					:       List[str]     				=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

        lowercase_					:       List[str]     				=					MultiControlNetModel([controlneta, controlneta]				)

        lowercase_					:       Dict     				=					{
            'unet': unet,
            'controlnet': controlnet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        return components
   def 		_lowerCamelCase (self       ,				_a       ,				_a=0				)    ->     Tuple:
        if str(_a				).startswith('mps'				):
             lowercase_					:       str     				=					torch.manual_seed(_a				)
        else:
             lowercase_					:       Tuple     				=					torch.Generator(device=_a				).manual_seed(_a				)

        lowercase_					:       str     				=					2

        lowercase_					:       Union[str, Any]     				=					[
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,				generator=_a       ,				device=torch.device(_a				)       ,				),
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,				generator=_a       ,				device=torch.device(_a				)       ,				),
        ]

        lowercase_					:       Tuple     				=					floats_tensor(control_image[0].shape       ,				rng=random.Random(_a				)				).to(_a				)
        lowercase_					:       Union[str, Any]     				=					image.cpu().permute(0       ,				2       ,				3       ,				1				)[0]
        lowercase_					:       List[Any]     				=					Image.fromarray(np.uinta(_a				)				).convert('RGB'				).resize((64, 64)				)
        lowercase_					:       List[Any]     				=					{
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
            'image': image,
            'control_image': control_image,
        }

        return inputs
   def 		_lowerCamelCase (self				)    ->     Any:
        lowercase_					:       Tuple     				=					self.get_dummy_components()
        lowercase_					:       int     				=					self.pipeline_class(**_a				)
        pipe.to(_a				)

        lowercase_					:       Any     				=					10.0
        lowercase_					:       Dict     				=					4

        lowercase_					:       Dict     				=					self.get_dummy_inputs(_a				)
        lowercase_					:       str     				=					steps
        lowercase_					:       Tuple     				=					scale
        lowercase_					:       Optional[Any]     				=					pipe(**_a				)[0]

        lowercase_					:       str     				=					self.get_dummy_inputs(_a				)
        lowercase_					:       List[Any]     				=					steps
        lowercase_					:       Tuple     				=					scale
        lowercase_					:       Union[str, Any]     				=					pipe(**_a       ,				control_guidance_start=0.1       ,				control_guidance_end=0.2				)[0]

        lowercase_					:       Tuple     				=					self.get_dummy_inputs(_a				)
        lowercase_					:       Optional[Any]     				=					steps
        lowercase_					:       List[str]     				=					scale
        lowercase_					:       List[str]     				=					pipe(**_a       ,				control_guidance_start=[0.1, 0.3]       ,				control_guidance_end=[0.2, 0.7]				)[0]

        lowercase_					:       List[Any]     				=					self.get_dummy_inputs(_a				)
        lowercase_					:       Tuple     				=					steps
        lowercase_					:       Tuple     				=					scale
        lowercase_					:       int     				=					pipe(**_a       ,				control_guidance_start=0.4       ,				control_guidance_end=[0.5, 0.8]				)[0]

        # make sure that all outputs are different
        assert np.sum(np.abs(output_a - output_a				)				) > 1e-3
        assert np.sum(np.abs(output_a - output_a				)				) > 1e-3
        assert np.sum(np.abs(output_a - output_a				)				) > 1e-3
   def 		_lowerCamelCase (self				)    ->     Optional[int]:
        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3				)
   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()       ,				reason='XFormers attention is only available with CUDA and `xformers` installed'       ,				)
   def 		_lowerCamelCase (self				)    ->     Optional[int]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3				)
   def 		_lowerCamelCase (self				)    ->     List[str]:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3				)





   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        lowercase_					:       Optional[Any]     				=					self.get_dummy_components()
        lowercase_					:       Optional[int]     				=					self.pipeline_class(**_a				)
        pipe.to(_a				)
        pipe.set_progress_bar_config(disable=_a				)
        with tempfile.TemporaryDirectory() as tmpdir:
             try:
                  # save_pretrained is not implemented for Multi-ControlNet
                  pipe.save_pretrained(_a				)
             except NotImplementedError:
                  pass



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






   """simple docstring"""
   def 		_lowerCamelCase (self				)    ->     Dict:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()





   def 		_lowerCamelCase (self				)    ->     Union[str, Any]:
        lowercase_					:       Dict     				=					ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'				)

        lowercase_					:       List[Any]     				=					StableDiffusionControlNetImgaImgPipeline.from_pretrained(
            'runwayml/stable-diffusion-v1-5'       ,				safety_checker=_a       ,				controlnet=_a				)
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=_a				)

        lowercase_					:       List[Any]     				=					torch.Generator(device='cpu'				).manual_seed(0				)
        lowercase_					:       List[str]     				=					'evil space-punk bird'
        lowercase_					:       List[str]     				=					load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'				).resize((512, 512)				)
        lowercase_					:       Tuple     				=					load_image(
            'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'				).resize((512, 512)				)

        lowercase_					:       int     				=					pipe(
            _a       ,				_a       ,				control_image=_a       ,				generator=_a       ,				output_type='np'       ,				num_inference_steps=50       ,				strength=0.6       ,				)

        lowercase_					:       List[Any]     				=					output.images[0]

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

        lowercase_					:       int     				=					load_numpy(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy'				)

        assert np.abs(expected_image - image				).max() < 9e-2







'''simple docstring'''




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

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):

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

     lowercase_					:       str     				=					precision
     lowercase_					:       List[str]     				=					ceil(precision / 14							)
     lowercase_					:       Union[str, Any]     				=					426_880 * Decimal(10_005							).sqrt()
     lowercase_					:       List[Any]     				=					1
     lowercase_					:       Optional[int]     				=					13_591_409
     lowercase_					:       Dict     				=					Decimal(SCREAMING_SNAKE_CASE_							)
     for k in range(1  ,       SCREAMING_SNAKE_CASE_							):
          lowercase_					:       List[str]     				=					factorial(6 * k							) // (factorial(3 * k							) * factorial(SCREAMING_SNAKE_CASE_							) ** 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__":
 _A								=   5_0
 print(F"""The first {n} digits of pi is: {pi(n)}""")




