


import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin







@skip_mps
class        UpperCamelCase__   (	__magic_name__							,				__magic_name__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  Tuple						=   IFPipeline
					__SCREAMING_SNAKE_CASE       :  Dict						=   TEXT_TO_IMAGE_PARAMS - {'width', 'height', 'latents'}
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   TEXT_TO_IMAGE_BATCH_PARAMS
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   PipelineTesterMixin.required_optional_params - {'latents'}

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										return self._get_dummy_components()

					def   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   Any=0       ):






										'''simple docstring'''






										if str(UpperCamelCase__       ).startswith("""mps"""       ):
															lowercase_  							=			torch.manual_seed(UpperCamelCase__       )
										else:
															lowercase_  							=			torch.Generator(device=UpperCamelCase__       ).manual_seed(UpperCamelCase__       )

										lowercase_  							=			{
										    """prompt""": """A painting of a squirrel eating a burger""",
										    """generator""": generator,
										    """num_inference_steps""": 2,
										    """output_type""": """numpy""",
										}

										return inputs

					def   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										self._test_save_load_optional_components()

					@unittest.skipIf(torch_device != """cuda"""							,					reason="""float16 requires CUDA"""       )
					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										super().test_save_load_floataa(expected_max_diff=1e-1       )

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										self._test_attention_slicing_forward_pass(expected_max_diff=1e-2       )

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										self._test_save_load_local()

					def   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






										self._test_inference_batch_single_identical(
										    expected_max_diff=1e-2							,					)







					@unittest.skipIf(
					    torch_device != """cuda""" or not is_xformers_available()							,					reason="""XFormers attention is only available with CUDA and `xformers` installed"""							,					)
					def   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3       )







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

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






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

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_  							=			IFPipeline.from_pretrained("""DeepFloyd/IF-I-XL-v1.0"""							,					variant="""fp16"""							,					torch_dtype=torch.floataa       )

										lowercase_  							=			IFSuperResolutionPipeline.from_pretrained(
										    """DeepFloyd/IF-II-L-v1.0"""							,					variant="""fp16"""							,					torch_dtype=torch.floataa							,					text_encoder=UpperCamelCase__							,					tokenizer=UpperCamelCase__       )

										# pre compute text embeddings and remove T5 to save memory

										pipe_a.text_encoder.to("""cuda"""       )

										lowercase_							,					lowercase_  							=			pipe_a.encode_prompt("""anime turtle"""							,					device="""cuda"""       )

										del pipe_a.tokenizer
										del pipe_a.text_encoder
										gc.collect()

										lowercase_  							=			None
										lowercase_  							=			None

										pipe_a.enable_model_cpu_offload()
										pipe_a.enable_model_cpu_offload()

										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

										self._test_if(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       )

										pipe_a.remove_all_hooks()
										pipe_a.remove_all_hooks()

										# img2img

										lowercase_  							=			IFImgaImgPipeline(**pipe_a.components       )
										lowercase_  							=			IFImgaImgSuperResolutionPipeline(**pipe_a.components       )

										pipe_a.enable_model_cpu_offload()
										pipe_a.enable_model_cpu_offload()

										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

										self._test_if_imgaimg(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       )

										pipe_a.remove_all_hooks()
										pipe_a.remove_all_hooks()

										# inpainting

										lowercase_  							=			IFInpaintingPipeline(**pipe_a.components       )
										lowercase_  							=			IFInpaintingSuperResolutionPipeline(**pipe_a.components       )

										pipe_a.enable_model_cpu_offload()
										pipe_a.enable_model_cpu_offload()

										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
										pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

										self._test_if_inpainting(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Union[str, Any]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   Any       ):






										'''simple docstring'''






										_start_torch_memory_measurement()

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )
										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					num_inference_steps=2							,					generator=UpperCamelCase__							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 13 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )

										# pipeline 2

										_start_torch_memory_measurement()

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )

										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )

										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					image=UpperCamelCase__							,					generator=UpperCamelCase__							,					num_inference_steps=2							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   List[Any]							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Union[str, Any]       ):






										'''simple docstring'''






										_start_torch_memory_measurement()

										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )

										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					image=UpperCamelCase__							,					num_inference_steps=2							,					generator=UpperCamelCase__							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 10 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )

										# pipeline 2

										_start_torch_memory_measurement()

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )

										lowercase_  							=			floats_tensor((1, 3, 256, 256)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )
										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )

										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					image=UpperCamelCase__							,					original_image=UpperCamelCase__							,					generator=UpperCamelCase__							,					num_inference_steps=2							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )







					def   UpperCAmelCase__       (     self       :   str							,					UpperCamelCase__       :   List[Any]							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Union[str, Any]							,					UpperCamelCase__       :   Optional[Any]       ):






										'''simple docstring'''






										_start_torch_memory_measurement()

										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )
										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(1       )       ).to(UpperCamelCase__       )

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )
										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					image=UpperCamelCase__							,					mask_image=UpperCamelCase__							,					num_inference_steps=2							,					generator=UpperCamelCase__							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 10 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )

										# pipeline 2

										_start_torch_memory_measurement()

										lowercase_  							=			torch.Generator(device="""cpu"""       ).manual_seed(0       )

										lowercase_  							=			floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )
										lowercase_  							=			floats_tensor((1, 3, 256, 256)							,					rng=random.Random(0       )       ).to(UpperCamelCase__       )
										lowercase_  							=			floats_tensor((1, 3, 256, 256)							,					rng=random.Random(1       )       ).to(UpperCamelCase__       )

										lowercase_  							=			pipe_a(
										    prompt_embeds=UpperCamelCase__							,					negative_prompt_embeds=UpperCamelCase__							,					image=UpperCamelCase__							,					mask_image=UpperCamelCase__							,					original_image=UpperCamelCase__							,					generator=UpperCamelCase__							,					num_inference_steps=2							,					output_type="""np"""							,					)

										lowercase_  							=			output.images[0]

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

										lowercase_  							=			torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 10**9

										lowercase_  							=			load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy"""       )
										assert_mean_pixel_difference(UpperCamelCase__							,					UpperCamelCase__       )



def 			UpperCAmelCase_				(      ):
					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()






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__   (	__magic_name__							,				__magic_name__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   StableDiffusionDiffEditPipeline
					__SCREAMING_SNAKE_CASE       :  Optional[Any]						=   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'height', 'width', 'image'} | {'image_latents'}
					__SCREAMING_SNAKE_CASE       :  List[str]						=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'image'} | {'image_latents'}
					__SCREAMING_SNAKE_CASE       :  int						=   frozenset(
					    []   )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
					__SCREAMING_SNAKE_CASE       :  Any						=   frozenset([]   )

					def   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






										torch.manual_seed(0       )
										lowercase_  							=			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=UpperCamelCase__							,					)
										lowercase_  							=			DDIMScheduler(
										    beta_start=0.00_085							,					beta_end=0.012							,					beta_schedule="""scaled_linear"""							,					clip_sample=UpperCamelCase__							,					set_alpha_to_one=UpperCamelCase__							,					)
										lowercase_  							=			DDIMInverseScheduler(
										    beta_start=0.00_085							,					beta_end=0.012							,					beta_schedule="""scaled_linear"""							,					clip_sample=UpperCamelCase__							,					set_alpha_to_zero=UpperCamelCase__							,					)
										torch.manual_seed(0       )
										lowercase_  							=			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       )
										lowercase_  							=			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							,					)
										lowercase_  							=			CLIPTextModel(UpperCamelCase__       )
										lowercase_  							=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

										lowercase_  							=			{
										    """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   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   Any=0       ):






										'''simple docstring'''






										lowercase_  							=			floats_tensor((1, 16, 16)							,					rng=random.Random(UpperCamelCase__       )       ).to(UpperCamelCase__       )
										lowercase_  							=			floats_tensor((1, 2, 4, 16, 16)							,					rng=random.Random(UpperCamelCase__       )       ).to(UpperCamelCase__       )
										if str(UpperCamelCase__       ).startswith("""mps"""       ):
															lowercase_  							=			torch.manual_seed(UpperCamelCase__       )
										else:
															lowercase_  							=			torch.Generator(device=UpperCamelCase__       ).manual_seed(UpperCamelCase__       )
										lowercase_  							=			{
										    """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   UpperCAmelCase__       (     self       :   Optional[int]							,					UpperCamelCase__       :   Union[str, Any]							,					UpperCamelCase__       :   str=0       ):






										'''simple docstring'''






										lowercase_  							=			floats_tensor((1, 3, 32, 32)							,					rng=random.Random(UpperCamelCase__       )       ).to(UpperCamelCase__       )
										lowercase_  							=			image.cpu().permute(0							,					2							,					3							,					1       )[0]
										lowercase_  							=			Image.fromarray(np.uinta(UpperCamelCase__       )       ).convert("""RGB"""       )
										if str(UpperCamelCase__       ).startswith("""mps"""       ):
															lowercase_  							=			torch.manual_seed(UpperCamelCase__       )
										else:
															lowercase_  							=			torch.Generator(device=UpperCamelCase__       ).manual_seed(UpperCamelCase__       )
										lowercase_  							=			{
										    """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   UpperCAmelCase__       (     self       :   List[Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Tuple=0       ):






										'''simple docstring'''






										lowercase_  							=			floats_tensor((1, 3, 32, 32)							,					rng=random.Random(UpperCamelCase__       )       ).to(UpperCamelCase__       )
										lowercase_  							=			image.cpu().permute(0							,					2							,					3							,					1       )[0]
										lowercase_  							=			Image.fromarray(np.uinta(UpperCamelCase__       )       ).convert("""RGB"""       )
										if str(UpperCamelCase__       ).startswith("""mps"""       ):
															lowercase_  							=			torch.manual_seed(UpperCamelCase__       )
										else:
															lowercase_  							=			torch.Generator(device=UpperCamelCase__       ).manual_seed(UpperCamelCase__       )
										lowercase_  							=			{
										    """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   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






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

										lowercase_  							=			self.get_dummy_components()
										lowercase_  							=			self.pipeline_class(**UpperCamelCase__       )
										pipe.to(UpperCamelCase__       )
										pipe.set_progress_bar_config(disable=UpperCamelCase__       )

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

										lowercase_  							=			self.get_dummy_inputs(UpperCamelCase__       )
										lowercase_  							=			pipe(**UpperCamelCase__       )[0]

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

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

										lowercase_  							=			self.get_dummy_inputs(UpperCamelCase__       )
										lowercase_  							=			pipe_loaded(**UpperCamelCase__       )[0]

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

					def   UpperCAmelCase__       (     self       :   Optional[int]       ):






										'''simple docstring'''






										lowercase_  							=			"""cpu"""

										lowercase_  							=			self.get_dummy_components()
										lowercase_  							=			self.pipeline_class(**UpperCamelCase__       )
										pipe.to(UpperCamelCase__       )
										pipe.set_progress_bar_config(disable=UpperCamelCase__       )

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

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

					def   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			"""cpu"""

										lowercase_  							=			self.get_dummy_components()
										lowercase_  							=			self.pipeline_class(**UpperCamelCase__       )
										pipe.to(UpperCamelCase__       )
										pipe.set_progress_bar_config(disable=UpperCamelCase__       )

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

										self.assertEqual(image.shape							,					(2, 32, 32, 3)       )
										lowercase_  							=			np.array(
										    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799]							,					)
										lowercase_  							=			np.abs(image_slice.flatten() - expected_slice       ).max()
										self.assertLessEqual(UpperCamelCase__							,					1e-3       )

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






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







					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_  							=			"""cpu"""

										lowercase_  							=			self.get_dummy_components()

										lowercase_  							=			{"""beta_start""": 0.00_085, """beta_end""": 0.012, """beta_schedule""": """scaled_linear"""}
										lowercase_  							=			DPMSolverMultistepScheduler(**UpperCamelCase__       )
										lowercase_  							=			DPMSolverMultistepInverseScheduler(**UpperCamelCase__       )

										lowercase_  							=			self.pipeline_class(**UpperCamelCase__       )
										pipe.to(UpperCamelCase__       )
										pipe.set_progress_bar_config(disable=UpperCamelCase__       )

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

										self.assertEqual(image.shape							,					(2, 32, 32, 3)       )
										lowercase_  							=			np.array(
										    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799]							,					)
										lowercase_  							=			np.abs(image_slice.flatten() - expected_slice       ).max()
										self.assertLessEqual(UpperCamelCase__							,					1e-3       )







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

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






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

					@classmethod
					def   UpperCAmelCase__       (     cls       :   Dict       ):






										'''simple docstring'''






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

										lowercase_  							=			raw_image.convert("""RGB"""       ).resize((768, 768)       )

										lowercase_  							=			raw_image

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			torch.manual_seed(0       )

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

										lowercase_  							=			"""a bowl of fruit"""
										lowercase_  							=			"""a bowl of pears"""

										lowercase_  							=			pipe.generate_mask(
										    image=self.raw_image							,					source_prompt=UpperCamelCase__							,					target_prompt=UpperCamelCase__							,					generator=UpperCamelCase__							,					)

										lowercase_  							=			pipe.invert(
										    prompt=UpperCamelCase__							,					image=self.raw_image							,					inpaint_strength=0.7							,					generator=UpperCamelCase__       ).latents

										lowercase_  							=			pipe(
										    prompt=UpperCamelCase__							,					mask_image=UpperCamelCase__							,					image_latents=UpperCamelCase__							,					generator=UpperCamelCase__							,					negative_prompt=UpperCamelCase__							,					inpaint_strength=0.7							,					output_type="""numpy"""							,					).images[0]

										lowercase_  							=			(
										    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   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			torch.manual_seed(0       )

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

										lowercase_  							=			"""a bowl of fruit"""
										lowercase_  							=			"""a bowl of pears"""

										lowercase_  							=			pipe.generate_mask(
										    image=self.raw_image							,					source_prompt=UpperCamelCase__							,					target_prompt=UpperCamelCase__							,					generator=UpperCamelCase__							,					)

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

										lowercase_  							=			pipe(
										    prompt=UpperCamelCase__							,					mask_image=UpperCamelCase__							,					image_latents=UpperCamelCase__							,					generator=UpperCamelCase__							,					negative_prompt=UpperCamelCase__							,					inpaint_strength=0.7							,					num_inference_steps=25							,					output_type="""numpy"""							,					).images[0]

										lowercase_  							=			(
										    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


