




"""simple docstring"""




# This model implementation is heavily based on:

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,
    StableDiffusionControlNetInpaintPipeline,
    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 (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()
class 							lowerCamelCase						(       _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase		,     unittest.TestCase ):
   lowercase				:     str            = StableDiffusionControlNetInpaintPipeline
   lowercase				:     Union[str, Any]            = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowercase				:     Dict            = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowercase				:     List[Any]            = frozenset({'control_image'} )  # skip `image` and `mask` for now, only test for control_image
   lowercase				:     Union[str, Any]            = TEXT_TO_IMAGE_IMAGE_PARAMS







   def 					a_							(							self       ):
       torch.manual_seed(0       )
       UpperCamelCase :      List[Any]      				=							UNetaDConditionModel(
           block_out_channels=(32, 64)			,					layers_per_block=2			,					sample_size=32			,					in_channels=9			,					out_channels=4			,					down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,					up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,					cross_attention_dim=32			,					)
       torch.manual_seed(0       )
       UpperCamelCase :      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)			,					)
       torch.manual_seed(0       )
       UpperCamelCase :      Any      				=							DDIMScheduler(
           beta_start=0.00085			,					beta_end=0.012			,					beta_schedule="""scaled_linear"""			,					clip_sample=__A			,					set_alpha_to_one=__A			,					)
       torch.manual_seed(0       )
       UpperCamelCase :      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       )
       UpperCamelCase :      str      				=							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=1000			,					)
       UpperCamelCase :      Dict      				=							CLIPTextModel(__A       )
       UpperCamelCase :      int      				=							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

       UpperCamelCase :      Optional[int]      				=							{
           """unet""": unet,
           """controlnet""": controlnet,
           """scheduler""": scheduler,
           """vae""": vae,
           """text_encoder""": text_encoder,
           """tokenizer""": tokenizer,
           """safety_checker""": None,
           """feature_extractor""": None,
       }
       return components







   def 					a_							(							self			,					SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_=0       ):
       if str(__A       ).startswith("""mps"""       ):
           UpperCamelCase :      Optional[Any]      				=							torch.manual_seed(__A       )
       else:
           UpperCamelCase :      Optional[Any]      				=							torch.Generator(device=__A       ).manual_seed(__A       )

       UpperCamelCase :      Optional[int]      				=							2
       UpperCamelCase :      Optional[Any]      				=							randn_tensor(
           (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)			,					generator=__A			,					device=torch.device(__A       )			,					)
       UpperCamelCase :      int      				=							floats_tensor((1, 3, 32, 32)			,					rng=random.Random(__A       )       ).to(__A       )
       UpperCamelCase :      Optional[Any]      				=							init_image.cpu().permute(0			,					2			,					3			,					1       )[0]

       UpperCamelCase :      Optional[int]      				=							Image.fromarray(np.uinta(__A       )       ).convert("""RGB"""       ).resize((64, 64)       )
       UpperCamelCase :      int      				=							Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

       UpperCamelCase :      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,
           """mask_image""": mask_image,
           """control_image""": control_image,
       }

       return inputs







   def 					a_							(							self       ):
       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 					a_							(							self       ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )







   def 					a_							(							self       ):
       self._test_inference_batch_single_identical(expected_max_diff=2e-3       )







class 							lowerCamelCase						(       _UpperCAmelCase ):
   lowercase				:     str            = StableDiffusionControlNetInpaintPipeline
   lowercase				:     Optional[int]            = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowercase				:     List[str]            = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowercase				:     Union[str, Any]            = frozenset([] )







   def 					a_							(							self       ):
       torch.manual_seed(0       )
       UpperCamelCase :      Optional[int]      				=							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       )
       UpperCamelCase :      Optional[int]      				=							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       )
       UpperCamelCase :      List[str]      				=							DDIMScheduler(
           beta_start=0.00085			,					beta_end=0.012			,					beta_schedule="""scaled_linear"""			,					clip_sample=__A			,					set_alpha_to_one=__A			,					)
       torch.manual_seed(0       )
       UpperCamelCase :      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       )
       UpperCamelCase :      str      				=							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=1000			,					)
       UpperCamelCase :      Optional[Any]      				=							CLIPTextModel(__A       )
       UpperCamelCase :      Dict      				=							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

       UpperCamelCase :      List[str]      				=							{
           """unet""": unet,
           """controlnet""": controlnet,
           """scheduler""": scheduler,
           """vae""": vae,
           """text_encoder""": text_encoder,
           """tokenizer""": tokenizer,
           """safety_checker""": None,
           """feature_extractor""": None,
       }
       return components







class 							lowerCamelCase						(       _UpperCAmelCase		,     _UpperCAmelCase		,     unittest.TestCase ):
   lowercase				:     Dict            = StableDiffusionControlNetInpaintPipeline
   lowercase				:     Tuple            = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowercase				:     Optional[int]            = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS







   def 					a_							(							self       ):
       torch.manual_seed(0       )
       UpperCamelCase :      str      				=							UNetaDConditionModel(
           block_out_channels=(32, 64)			,					layers_per_block=2			,					sample_size=32			,					in_channels=9			,					out_channels=4			,					down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,					up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,					cross_attention_dim=32			,					)
       torch.manual_seed(0       )

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

       UpperCamelCase :      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       )
       UpperCamelCase :      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)			,					)
       controlneta.controlnet_down_blocks.apply(__A       )

       torch.manual_seed(0       )
       UpperCamelCase :      Optional[int]      				=							DDIMScheduler(
           beta_start=0.00085			,					beta_end=0.012			,					beta_schedule="""scaled_linear"""			,					clip_sample=__A			,					set_alpha_to_one=__A			,					)
       torch.manual_seed(0       )
       UpperCamelCase :      Dict      				=							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       )
       UpperCamelCase :      int      				=							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=1000			,					)
       UpperCamelCase :      Optional[Any]      				=							CLIPTextModel(__A       )
       UpperCamelCase :      List[Any]      				=							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

       UpperCamelCase :      Dict      				=							MultiControlNetModel([controlneta, controlneta]       )

       UpperCamelCase :      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 					a_							(							self			,					SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_=0       ):
       if str(__A       ).startswith("""mps"""       ):
           UpperCamelCase :      str      				=							torch.manual_seed(__A       )
       else:
           UpperCamelCase :      List[str]      				=							torch.Generator(device=__A       ).manual_seed(__A       )

       UpperCamelCase :      List[str]      				=							2

       UpperCamelCase :      List[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       )			,					),
       ]
       UpperCamelCase :      Tuple      				=							floats_tensor((1, 3, 32, 32)			,					rng=random.Random(__A       )       ).to(__A       )
       UpperCamelCase :      Optional[Any]      				=							init_image.cpu().permute(0			,					2			,					3			,					1       )[0]

       UpperCamelCase :      Optional[Any]      				=							Image.fromarray(np.uinta(__A       )       ).convert("""RGB"""       ).resize((64, 64)       )
       UpperCamelCase :      str      				=							Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

       UpperCamelCase :      Dict      				=							{
           """prompt""": """A painting of a squirrel eating a burger""",
           """generator""": generator,
           """num_inference_steps""": 2,
           """guidance_scale""": 6.0,
           """output_type""": """numpy""",
           """image""": image,
           """mask_image""": mask_image,
           """control_image""": control_image,
       }

       return inputs







   def 					a_							(							self       ):
       UpperCamelCase :      Union[str, Any]      				=							self.get_dummy_components()
       UpperCamelCase :      Union[str, Any]      				=							self.pipeline_class(**__A       )
       pipe.to(__A       )

       UpperCamelCase :      int      				=							10.0
       UpperCamelCase :      List[Any]      				=							4

       UpperCamelCase :      Optional[int]      				=							self.get_dummy_inputs(__A       )
       UpperCamelCase :      str      				=							steps
       UpperCamelCase :      int      				=							scale
       UpperCamelCase :      Optional[Any]      				=							pipe(**__A       )[0]

       UpperCamelCase :      Optional[Any]      				=							self.get_dummy_inputs(__A       )
       UpperCamelCase :      int      				=							steps
       UpperCamelCase :      List[Any]      				=							scale
       UpperCamelCase :      int      				=							pipe(**__A			,					control_guidance_start=0.1			,					control_guidance_end=0.2       )[0]

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

       UpperCamelCase :      Tuple      				=							self.get_dummy_inputs(__A       )
       UpperCamelCase :      Any      				=							steps
       UpperCamelCase :      List[Any]      				=							scale
       UpperCamelCase :      Dict      				=							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 					a_							(							self       ):
       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 					a_							(							self       ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )







   def 					a_							(							self       ):
       self._test_inference_batch_single_identical(expected_max_diff=2e-3       )







   def 					a_							(							self       ):
       UpperCamelCase :      List[str]      				=							self.get_dummy_components()
       UpperCamelCase :      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 							lowerCamelCase						(       unittest.TestCase ):







   def 					a_							(							self       ):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







   def 					a_							(							self       ):
       UpperCamelCase :      List[Any]      				=							ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""       )

       UpperCamelCase :      Optional[int]      				=							StableDiffusionControlNetInpaintPipeline.from_pretrained(
           """runwayml/stable-diffusion-inpainting"""			,					safety_checker=__A			,					controlnet=__A       )
       pipe.enable_model_cpu_offload()
       pipe.set_progress_bar_config(disable=__A       )

       UpperCamelCase :      Tuple      				=							torch.Generator(device="""cpu"""       ).manual_seed(0       )
       UpperCamelCase :      Union[str, Any]      				=							load_image(
           """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""       ).resize((512, 512)       )

       UpperCamelCase :      Tuple      				=							load_image(
           """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
           """/stable_diffusion_inpaint/input_bench_mask.png"""       ).resize((512, 512)       )

       UpperCamelCase :      Union[str, Any]      				=							"""pitch black hole"""

       UpperCamelCase :      Optional[Any]      				=							load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""       ).resize((512, 512)       )

       UpperCamelCase :      Any      				=							pipe(
           __A			,					image=__A			,					mask_image=__A			,					control_image=__A			,					generator=__A			,					output_type="""np"""			,					num_inference_steps=3			,					)

       UpperCamelCase :      Union[str, Any]      				=							output.images[0]

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

       UpperCamelCase :      Dict      				=							load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"""       )

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







   def 					a_							(							self       ):
       UpperCamelCase :      Optional[Any]      				=							ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""       )

       UpperCamelCase :      Optional[int]      				=							StableDiffusionControlNetInpaintPipeline.from_pretrained(
           """runwayml/stable-diffusion-v1-5"""			,					safety_checker=__A			,					controlnet=__A       )
       UpperCamelCase :      List[Any]      				=							DDIMScheduler.from_config(pipe.scheduler.config       )
       pipe.enable_model_cpu_offload()
       pipe.set_progress_bar_config(disable=__A       )

       UpperCamelCase :      Union[str, Any]      				=							torch.Generator(device="""cpu"""       ).manual_seed(33       )

       UpperCamelCase :      Tuple      				=							load_image(
           """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""       )
       UpperCamelCase :      Optional[Any]      				=							init_image.resize((512, 512)       )

       UpperCamelCase :      str      				=							load_image(
           """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""       )
       UpperCamelCase :      List[Any]      				=							mask_image.resize((512, 512)       )

       UpperCamelCase :      List[Any]      				=							"""a handsome man with ray-ban sunglasses"""

       def make_inpaint_condition(SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_       ):
           UpperCamelCase :      Dict      				=							np.array(image.convert("""RGB"""       )       ).astype(np.floataa       ) / 255.0
           UpperCamelCase :      Tuple      				=							np.array(image_mask.convert("""L"""       )       ).astype(np.floataa       ) / 255.0

           assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
           UpperCamelCase :      int      				=							-1.0  # set as masked pixel
           UpperCamelCase :      Union[str, Any]      				=							np.expand_dims(__A			,					0       ).transpose(0			,					3			,					1			,					2       )
           UpperCamelCase :      Optional[int]      				=							torch.from_numpy(__A       )
           return image

       UpperCamelCase :      Optional[Any]      				=							make_inpaint_condition(__A			,					__A       )

       UpperCamelCase :      str      				=							pipe(
           __A			,					image=__A			,					mask_image=__A			,					control_image=__A			,					guidance_scale=9.0			,					eta=1.0			,					generator=__A			,					num_inference_steps=20			,					output_type="""np"""			,					)
       UpperCamelCase :      Any      				=							output.images[0]

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

       UpperCamelCase :      Optional[int]      				=							load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"""       )

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












from math import factorial




def    __A    (   _lowercase    ,	_lowercase       ):

					'''simple docstring'''







					return factorial(_lowercase       ) / (factorial(_lowercase       ) * factorial(n - r       ))




def    __A    (   ):

					'''simple docstring'''







					_A									=       0

					for i in range(1    ,	1_01       ):
										for j in range(1    ,	i + 1       ):
															if combinations(_lowercase    ,	_lowercase       ) > 1e6:
																				total += 1
					return total


if __name__ == "__main__":
				print(solution())



