



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,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class        UpperCAmelCase_  (       _UpperCAmelCase   ,   _UpperCAmelCase   ,   unittest.TestCase	):

      '''simple docstring'''




      UpperCamelCase__      :			List[str]      =  StableDiffusionDiffEditPipeline
      UpperCamelCase__      :			List[Any]      =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'height', 'width', 'image'} | {'image_latents'}
      UpperCamelCase__      :			str      =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'image'} | {'image_latents'}
      UpperCamelCase__      :			List[Any]      =  frozenset(
          []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
      UpperCamelCase__      :			Union[str, Any]      =  frozenset([]	)






      def 	_A     (   self		):







             '''simple docstring'''

             torch.manual_seed(0		)
             __SCREAMING_SNAKE_CASE									= 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				,							attention_head_dim=(2, 4)				,							use_linear_projection=SCREAMING_SNAKE_CASE_				,							)
             __SCREAMING_SNAKE_CASE									= DDIMScheduler(
                 beta_start=0.0_0_0_8_5				,							beta_end=0.0_1_2				,							beta_schedule='scaled_linear'				,							clip_sample=SCREAMING_SNAKE_CASE_				,							set_alpha_to_one=SCREAMING_SNAKE_CASE_				,							)
             __SCREAMING_SNAKE_CASE									= DDIMInverseScheduler(
                 beta_start=0.0_0_0_8_5				,							beta_end=0.0_1_2				,							beta_schedule='scaled_linear'				,							clip_sample=SCREAMING_SNAKE_CASE_				,							set_alpha_to_zero=SCREAMING_SNAKE_CASE_				,							)
             torch.manual_seed(0		)
             __SCREAMING_SNAKE_CASE									= 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				,							sample_size=128				,							)
             torch.manual_seed(0		)
             __SCREAMING_SNAKE_CASE									= 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				,							hidden_act='gelu'				,							projection_dim=512				,							)
             __SCREAMING_SNAKE_CASE									= CLIPTextModel(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

             __SCREAMING_SNAKE_CASE									= {
                 """unet""": unet,
                 """scheduler""": scheduler,
                 """inverse_scheduler""": inverse_scheduler,
                 """vae""": vae,
                 """text_encoder""": text_encoder,
                 """tokenizer""": tokenizer,
                 """safety_checker""": None,
                 """feature_extractor""": None,
             }

             return components






      def 	_A     (   self				,							_A				,							_A=0		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= floats_tensor((1, 16, 16)				,							rng=random.Random(SCREAMING_SNAKE_CASE_		)		).to(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= floats_tensor((1, 2, 4, 16, 16)				,							rng=random.Random(SCREAMING_SNAKE_CASE_		)		).to(SCREAMING_SNAKE_CASE_		)
             if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
                    __SCREAMING_SNAKE_CASE									= torch.manual_seed(SCREAMING_SNAKE_CASE_		)
             else:
                    __SCREAMING_SNAKE_CASE									= torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= {
                 """prompt""": """a dog and a newt""",
                 """mask_image""": mask,
                 """image_latents""": latents,
                 """generator""": generator,
                 """num_inference_steps""": 2,
                 """inpaint_strength""": 1.0,
                 """guidance_scale""": 6.0,
                 """output_type""": """numpy""",
             }

             return inputs






      def 	_A     (   self				,							_A				,							_A=0		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= floats_tensor((1, 3, 32, 32)				,							rng=random.Random(SCREAMING_SNAKE_CASE_		)		).to(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= image.cpu().permute(0				,							2				,							3				,							1		)[0]
             __SCREAMING_SNAKE_CASE									= Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_		)		).convert('RGB'		)
             if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
                    __SCREAMING_SNAKE_CASE									= torch.manual_seed(SCREAMING_SNAKE_CASE_		)
             else:
                    __SCREAMING_SNAKE_CASE									= torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= {
                 """image""": image,
                 """source_prompt""": """a cat and a frog""",
                 """target_prompt""": """a dog and a newt""",
                 """generator""": generator,
                 """num_inference_steps""": 2,
                 """num_maps_per_mask""": 2,
                 """mask_encode_strength""": 1.0,
                 """guidance_scale""": 6.0,
                 """output_type""": """numpy""",
             }

             return inputs






      def 	_A     (   self				,							_A				,							_A=0		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= floats_tensor((1, 3, 32, 32)				,							rng=random.Random(SCREAMING_SNAKE_CASE_		)		).to(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= image.cpu().permute(0				,							2				,							3				,							1		)[0]
             __SCREAMING_SNAKE_CASE									= Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_		)		).convert('RGB'		)
             if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
                    __SCREAMING_SNAKE_CASE									= torch.manual_seed(SCREAMING_SNAKE_CASE_		)
             else:
                    __SCREAMING_SNAKE_CASE									= torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= {
                 """image""": image,
                 """prompt""": """a cat and a frog""",
                 """generator""": generator,
                 """num_inference_steps""": 2,
                 """inpaint_strength""": 1.0,
                 """guidance_scale""": 6.0,
                 """decode_latents""": True,
                 """output_type""": """numpy""",
             }
             return inputs






      def 	_A     (   self		):







             '''simple docstring'''

             if not hasattr(self.pipeline_class				,							'_optional_components'		):
                    return

             __SCREAMING_SNAKE_CASE									= self.get_dummy_components()
             __SCREAMING_SNAKE_CASE									= self.pipeline_class(**SCREAMING_SNAKE_CASE_		)
             pipe.to(SCREAMING_SNAKE_CASE_		)
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             # set all optional components to None and update pipeline config accordingly
             for optional_component in pipe._optional_components:
                    setattr(SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_		)
             pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}		)

             __SCREAMING_SNAKE_CASE									= self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= pipe(**SCREAMING_SNAKE_CASE_		)[0]

             with tempfile.TemporaryDirectory() as tmpdir:
                    pipe.save_pretrained(SCREAMING_SNAKE_CASE_		)
                    __SCREAMING_SNAKE_CASE									= self.pipeline_class.from_pretrained(SCREAMING_SNAKE_CASE_		)
                    pipe_loaded.to(SCREAMING_SNAKE_CASE_		)
                    pipe_loaded.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             for optional_component in pipe._optional_components:
                    self.assertTrue(
                        getattr(SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_		) is None				,							f"""`{optional_component}` did not stay set to None after loading."""				,							)

             __SCREAMING_SNAKE_CASE									= self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= pipe_loaded(**SCREAMING_SNAKE_CASE_		)[0]

             __SCREAMING_SNAKE_CASE									= np.abs(output - output_loaded		).max()
             self.assertLess(SCREAMING_SNAKE_CASE_				,							1e-4		)






      def 	_A     (   self		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= """cpu"""

             __SCREAMING_SNAKE_CASE									= self.get_dummy_components()
             __SCREAMING_SNAKE_CASE									= self.pipeline_class(**SCREAMING_SNAKE_CASE_		)
             pipe.to(SCREAMING_SNAKE_CASE_		)
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= self.get_dummy_mask_inputs(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= pipe.generate_mask(**SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= mask[0, -3:, -3:]

             self.assertEqual(mask.shape				,							(1, 16, 16)		)
             __SCREAMING_SNAKE_CASE									= np.array([0] * 9		)
             __SCREAMING_SNAKE_CASE									= np.abs(mask_slice.flatten() - expected_slice		).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE_				,							1e-3		)
             self.assertEqual(mask[0, -3, -4]				,							0		)






      def 	_A     (   self		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= """cpu"""

             __SCREAMING_SNAKE_CASE									= self.get_dummy_components()
             __SCREAMING_SNAKE_CASE									= self.pipeline_class(**SCREAMING_SNAKE_CASE_		)
             pipe.to(SCREAMING_SNAKE_CASE_		)
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= self.get_dummy_inversion_inputs(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= pipe.invert(**SCREAMING_SNAKE_CASE_		).images
             __SCREAMING_SNAKE_CASE									= image[0, -1, -3:, -3:]

             self.assertEqual(image.shape				,							(2, 32, 32, 3)		)
             __SCREAMING_SNAKE_CASE									= np.array(
                 [0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9]				,							)
             __SCREAMING_SNAKE_CASE									= np.abs(image_slice.flatten() - expected_slice		).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE_				,							1e-3		)






      def 	_A     (   self		):







             '''simple docstring'''

             super().test_inference_batch_single_identical(expected_max_diff=5e-3		)






      def 	_A     (   self		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= """cpu"""

             __SCREAMING_SNAKE_CASE									= self.get_dummy_components()

             __SCREAMING_SNAKE_CASE									= {"""beta_start""": 0.0_0_0_8_5, """beta_end""": 0.0_1_2, """beta_schedule""": """scaled_linear"""}
             __SCREAMING_SNAKE_CASE									= DPMSolverMultistepScheduler(**SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= DPMSolverMultistepInverseScheduler(**SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= self.pipeline_class(**SCREAMING_SNAKE_CASE_		)
             pipe.to(SCREAMING_SNAKE_CASE_		)
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= self.get_dummy_inversion_inputs(SCREAMING_SNAKE_CASE_		)
             __SCREAMING_SNAKE_CASE									= pipe.invert(**SCREAMING_SNAKE_CASE_		).images
             __SCREAMING_SNAKE_CASE									= image[0, -1, -3:, -3:]

             self.assertEqual(image.shape				,							(2, 32, 32, 3)		)
             __SCREAMING_SNAKE_CASE									= np.array(
                 [0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9]				,							)
             __SCREAMING_SNAKE_CASE									= np.abs(image_slice.flatten() - expected_slice		).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE_				,							1e-3		)







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

      '''simple docstring'''




      def 	_A     (   self		):







             '''simple docstring'''

             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()






      @classmethod
      def 	_A     (   cls		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= load_image(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'		)

             __SCREAMING_SNAKE_CASE									= raw_image.convert('RGB'		).resize((768, 768)		)

             __SCREAMING_SNAKE_CASE									= raw_image






      def 	_A     (   self		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= torch.manual_seed(0		)

             __SCREAMING_SNAKE_CASE									= StableDiffusionDiffEditPipeline.from_pretrained(
                 'stabilityai/stable-diffusion-2-1'				,							safety_checker=SCREAMING_SNAKE_CASE_				,							torch_dtype=torch.floataa		)
             __SCREAMING_SNAKE_CASE									= DDIMScheduler.from_config(pipe.scheduler.config		)
             __SCREAMING_SNAKE_CASE									= DDIMInverseScheduler.from_config(pipe.scheduler.config		)
             pipe.enable_model_cpu_offload()
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= """a bowl of fruit"""
             __SCREAMING_SNAKE_CASE									= """a bowl of pears"""

             __SCREAMING_SNAKE_CASE									= pipe.generate_mask(
                 image=self.raw_image				,							source_prompt=SCREAMING_SNAKE_CASE_				,							target_prompt=SCREAMING_SNAKE_CASE_				,							generator=SCREAMING_SNAKE_CASE_				,							)

             __SCREAMING_SNAKE_CASE									= pipe.invert(
                 prompt=SCREAMING_SNAKE_CASE_				,							image=self.raw_image				,							inpaint_strength=0.7				,							generator=SCREAMING_SNAKE_CASE_		).latents

             __SCREAMING_SNAKE_CASE									= pipe(
                 prompt=SCREAMING_SNAKE_CASE_				,							mask_image=SCREAMING_SNAKE_CASE_				,							image_latents=SCREAMING_SNAKE_CASE_				,							generator=SCREAMING_SNAKE_CASE_				,							negative_prompt=SCREAMING_SNAKE_CASE_				,							inpaint_strength=0.7				,							output_type='numpy'				,							).images[0]

             __SCREAMING_SNAKE_CASE									= (
                 np.array(
                     load_image(
                         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                         '/diffedit/pears.png'		).resize((768, 768)		)		)
                 / 255
             )
             assert np.abs((expected_image - image).max()		) < 5e-1






      def 	_A     (   self		):







             '''simple docstring'''

             __SCREAMING_SNAKE_CASE									= torch.manual_seed(0		)

             __SCREAMING_SNAKE_CASE									= StableDiffusionDiffEditPipeline.from_pretrained(
                 'stabilityai/stable-diffusion-2-1'				,							safety_checker=SCREAMING_SNAKE_CASE_				,							torch_dtype=torch.floataa		)
             __SCREAMING_SNAKE_CASE									= DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
             __SCREAMING_SNAKE_CASE									= DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config		)
             pipe.enable_model_cpu_offload()
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

             __SCREAMING_SNAKE_CASE									= """a bowl of fruit"""
             __SCREAMING_SNAKE_CASE									= """a bowl of pears"""

             __SCREAMING_SNAKE_CASE									= pipe.generate_mask(
                 image=self.raw_image				,							source_prompt=SCREAMING_SNAKE_CASE_				,							target_prompt=SCREAMING_SNAKE_CASE_				,							generator=SCREAMING_SNAKE_CASE_				,							)

             __SCREAMING_SNAKE_CASE									= pipe.invert(
                 prompt=SCREAMING_SNAKE_CASE_				,							image=self.raw_image				,							inpaint_strength=0.7				,							generator=SCREAMING_SNAKE_CASE_				,							num_inference_steps=25				,							).latents

             __SCREAMING_SNAKE_CASE									= pipe(
                 prompt=SCREAMING_SNAKE_CASE_				,							mask_image=SCREAMING_SNAKE_CASE_				,							image_latents=SCREAMING_SNAKE_CASE_				,							generator=SCREAMING_SNAKE_CASE_				,							negative_prompt=SCREAMING_SNAKE_CASE_				,							inpaint_strength=0.7				,							num_inference_steps=25				,							output_type='numpy'				,							).images[0]

             __SCREAMING_SNAKE_CASE									= (
                 np.array(
                     load_image(
                         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                         '/diffedit/pears.png'		).resize((768, 768)		)		)
                 / 255
             )
             assert np.abs((expected_image - image).max()		) < 5e-1











def      __lowercase       (			a__       )    ->			int:
							__SCREAMING_SNAKE_CASE									= [[0 for _ in range(a__       )] for _ in range(m + 1       )]
							for i in range(m + 1       ):
														__SCREAMING_SNAKE_CASE									= 1

							for n in range(m + 1       ):
														for k in range(1							,       a__       ):
																					memo[n][k] += memo[n][k - 1]
																					if n - k > 0:
																												memo[n][k] += memo[n - k - 1][k]

							return memo[m][m - 1]


if __name__ == "__main__":
			import sys

			if len(sys.argv) == 1:
						try:
									lowerCAmelCase__		:					Optional[Any]							=int(input('''Enter a number: ''').strip())
									print(partition(n))
						except ValueError:
									print('''Please enter a number.''')
			else:
						try:
									lowerCAmelCase__		:					str							=int(sys.argv[1])
									print(partition(n))
						except ValueError:
									print('''Please pass a number.''')






