



'''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 				lowercase			(    _lowerCamelCase   ,   _lowerCamelCase   ,   _lowerCamelCase   ,   unittest.TestCase							):


 """simple docstring"""


 UpperCAmelCase		      =    StableDiffusionControlNetInpaintPipeline
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 UpperCAmelCase		      =    frozenset({"""control_image"""}							)  # skip `image` and `mask` for now, only test for control_image
 UpperCAmelCase		      =    TEXT_TO_IMAGE_IMAGE_PARAMS







 def _snake_case					(				self				)						->  List[Any]:
        torch.manual_seed(0				)
        _UpperCAmelCase    :		List[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				)
        _UpperCAmelCase    :		Union[str, 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    :		Optional[Any]     	=					DDIMScheduler(
            beta_start=0.0_0085    ,beta_end=0.012    ,beta_schedule="""scaled_linear"""    ,clip_sample=a_    ,set_alpha_to_one=a_    ,)
        torch.manual_seed(0				)
        _UpperCAmelCase    :		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-0_5    ,num_attention_heads=4    ,num_hidden_layers=5    ,pad_token_id=1    ,vocab_size=1_000    ,)
        _UpperCAmelCase    :		str     	=					CLIPTextModel(a_				)
        _UpperCAmelCase    :		Optional[Any]     	=					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 _snake_case					(				self    ,a_    ,a_=0				)						->  Any:
        if str(a_				).startswith("""mps"""				):
               _UpperCAmelCase    :		int     	=					torch.manual_seed(a_				)
        else:
               _UpperCAmelCase    :		List[Any]     	=					torch.Generator(device=a_				).manual_seed(a_				)

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

        _UpperCAmelCase    :		Any     	=					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 _snake_case					(				self				)						->  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 _snake_case					(				self				)						->  List[str]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)







 def _snake_case					(				self				)						->  str:
        self._test_inference_batch_single_identical(expected_max_diff=2E-3				)







class 				lowercase			(    _lowerCamelCase							):


 """simple docstring"""


 UpperCAmelCase		      =    StableDiffusionControlNetInpaintPipeline
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 UpperCAmelCase		      =    frozenset([]							)







 def _snake_case					(				self				)						->  List[Any]:
        torch.manual_seed(0				)
        _UpperCAmelCase    :		str     	=					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    :		Dict     	=					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    :		Union[str, Any]     	=					DDIMScheduler(
            beta_start=0.0_0085    ,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    :		Tuple     	=					CLIPTextConfig(
            bos_token_id=0    ,eos_token_id=2    ,hidden_size=32    ,intermediate_size=37    ,layer_norm_eps=1E-0_5    ,num_attention_heads=4    ,num_hidden_layers=5    ,pad_token_id=1    ,vocab_size=1_000    ,)
        _UpperCAmelCase    :		Dict     	=					CLIPTextModel(a_				)
        _UpperCAmelCase    :		Any     	=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

        _UpperCAmelCase    :		Tuple     	=					{
            """unet""": unet,
            """controlnet""": controlnet,
            """scheduler""": scheduler,
            """vae""": vae,
            """text_encoder""": text_encoder,
            """tokenizer""": tokenizer,
            """safety_checker""": None,
            """feature_extractor""": None,
        }
        return components







class 				lowercase			(    _lowerCamelCase   ,   _lowerCamelCase   ,   unittest.TestCase							):


 """simple docstring"""


 UpperCAmelCase		      =    StableDiffusionControlNetInpaintPipeline
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 UpperCAmelCase		      =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS







 def _snake_case					(				self				)						->  str:
        torch.manual_seed(0				)
        _UpperCAmelCase    :		List[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(a_				):
               if isinstance(a_    ,torch.nn.Convad				):
                      torch.nn.init.normal(m.weight				)
                      m.bias.data.fill_(1.0				)

        _UpperCAmelCase    :		Union[str, 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    :		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    :		Optional[int]     	=					DDIMScheduler(
            beta_start=0.0_0085    ,beta_end=0.012    ,beta_schedule="""scaled_linear"""    ,clip_sample=a_    ,set_alpha_to_one=a_    ,)
        torch.manual_seed(0				)
        _UpperCAmelCase    :		Optional[int]     	=					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    :		Tuple     	=					CLIPTextConfig(
            bos_token_id=0    ,eos_token_id=2    ,hidden_size=32    ,intermediate_size=37    ,layer_norm_eps=1E-0_5    ,num_attention_heads=4    ,num_hidden_layers=5    ,pad_token_id=1    ,vocab_size=1_000    ,)
        _UpperCAmelCase    :		Tuple     	=					CLIPTextModel(a_				)
        _UpperCAmelCase    :		Tuple     	=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

        _UpperCAmelCase    :		str     	=					MultiControlNetModel([controlneta, controlneta]				)

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







 def _snake_case					(				self    ,a_    ,a_=0				)						->  Optional[Any]:
        if str(a_				).startswith("""mps"""				):
               _UpperCAmelCase    :		Optional[int]     	=					torch.manual_seed(a_				)
        else:
               _UpperCAmelCase    :		List[Any]     	=					torch.Generator(device=a_				).manual_seed(a_				)

        _UpperCAmelCase    :		List[str]     	=					2

        _UpperCAmelCase    :		List[str]     	=					[
            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    :		Dict     	=					floats_tensor((1, 3, 32, 32)    ,rng=random.Random(a_				)				).to(a_				)
        _UpperCAmelCase    :		Dict     	=					init_image.cpu().permute(0    ,2    ,3    ,1				)[0]

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

        _UpperCAmelCase    :		List[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,
            """mask_image""": mask_image,
            """control_image""": control_image,
        }

        return inputs







 def _snake_case					(				self				)						->  Optional[int]:
        _UpperCAmelCase    :		Optional[Any]     	=					self.get_dummy_components()
        _UpperCAmelCase    :		Optional[Any]     	=					self.pipeline_class(**a_				)
        pipe.to(a_				)

        _UpperCAmelCase    :		Optional[int]     	=					10.0
        _UpperCAmelCase    :		Dict     	=					4

        _UpperCAmelCase    :		List[Any]     	=					self.get_dummy_inputs(a_				)
        _UpperCAmelCase    :		Optional[int]     	=					steps
        _UpperCAmelCase    :		List[str]     	=					scale
        _UpperCAmelCase    :		Dict     	=					pipe(**a_				)[0]

        _UpperCAmelCase    :		Tuple     	=					self.get_dummy_inputs(a_				)
        _UpperCAmelCase    :		Any     	=					steps
        _UpperCAmelCase    :		str     	=					scale
        _UpperCAmelCase    :		Optional[int]     	=					pipe(**a_    ,control_guidance_start=0.1    ,control_guidance_end=0.2				)[0]

        _UpperCAmelCase    :		List[Any]     	=					self.get_dummy_inputs(a_				)
        _UpperCAmelCase    :		Dict     	=					steps
        _UpperCAmelCase    :		Dict     	=					scale
        _UpperCAmelCase    :		int     	=					pipe(**a_    ,control_guidance_start=[0.1, 0.3]    ,control_guidance_end=[0.2, 0.7]				)[0]

        _UpperCAmelCase    :		Dict     	=					self.get_dummy_inputs(a_				)
        _UpperCAmelCase    :		Optional[Any]     	=					steps
        _UpperCAmelCase    :		List[Any]     	=					scale
        _UpperCAmelCase    :		Tuple     	=					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 _snake_case					(				self				)						->  Tuple:
        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 _snake_case					(				self				)						->  List[str]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)







 def _snake_case					(				self				)						->  str:
        self._test_inference_batch_single_identical(expected_max_diff=2E-3				)







 def _snake_case					(				self				)						->  Any:
        _UpperCAmelCase    :		Any     	=					self.get_dummy_components()
        _UpperCAmelCase    :		List[Any]     	=					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 				lowercase			(    unittest.TestCase							):


 """simple docstring"""


 def _snake_case					(				self				)						->  Union[str, Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







 def _snake_case					(				self				)						->  Dict:
        _UpperCAmelCase    :		int     	=					ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""				)

        _UpperCAmelCase    :		str     	=					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    :		List[str]     	=					torch.Generator(device="""cpu"""				).manual_seed(0				)
        _UpperCAmelCase    :		Tuple     	=					load_image(
            """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""				).resize((512, 512)				)

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

        _UpperCAmelCase    :		int     	=					"""pitch black hole"""

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

        _UpperCAmelCase    :		int     	=					pipe(
            a_    ,image=a_    ,mask_image=a_    ,control_image=a_    ,generator=a_    ,output_type="""np"""    ,num_inference_steps=3    ,)

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

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

        _UpperCAmelCase    :		str     	=					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 _snake_case					(				self				)						->  List[str]:
        _UpperCAmelCase    :		Optional[int]     	=					ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""				)

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

        _UpperCAmelCase    :		Dict     	=					torch.Generator(device="""cpu"""				).manual_seed(33				)

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

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

        _UpperCAmelCase    :		Tuple     	=					"""a handsome man with ray-ban sunglasses"""

        def make_inpaint_condition(a_    ,a_				):
               _UpperCAmelCase    :		Union[str, Any]     	=					np.array(image.convert("""RGB"""				)				).astype(np.floataa				) / 255.0
               _UpperCAmelCase    :		List[str]     	=					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    :		str     	=					-1.0  # set as masked pixel
               _UpperCAmelCase    :		str     	=					np.expand_dims(a_    ,0				).transpose(0    ,3    ,1    ,2				)
               _UpperCAmelCase    :		int     	=					torch.from_numpy(a_				)
               return image

        _UpperCAmelCase    :		Union[str, Any]     	=					make_inpaint_condition(a_    ,a_				)

        _UpperCAmelCase    :		List[Any]     	=					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    :		int     	=					output.images[0]

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

        _UpperCAmelCase    :		Any     	=					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








'''simple docstring'''






import itertools




def        snake_case_   (	lowerCAmelCase_						)->						Dict:





       '''simple docstring'''


       return (
           int("""""".join(combination[0:2]						)						) * int("""""".join(combination[2:5]						)						)
           == int("""""".join(combination[5:9]						)						)
       ) or (
           int("""""".join(combination[0]						)						) * int("""""".join(combination[1:5]						)						)
           == int("""""".join(combination[5:9]						)						)
       )




def        snake_case_   (	)->						str:





       '''simple docstring'''


       return sum(
           {
               int("""""".join(pandigital[5:9]						)						)
               for pandigital in itertools.permutations("""123456789"""						)
               if is_combination_valid(lowerCAmelCase_						)
           }						)


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



