

import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

@skip_mps
class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
 _lowercase  :   Dict       				=  StableDiffusionPanoramaPipeline
 _lowercase  :   int       				=  TEXT_TO_IMAGE_PARAMS
 _lowercase  :   int       				=  TEXT_TO_IMAGE_BATCH_PARAMS
 _lowercase  :   int       				=  TEXT_TO_IMAGE_IMAGE_PARAMS
 _lowercase  :   int       				=  TEXT_TO_IMAGE_IMAGE_PARAMS







 def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

      '''simple docstring'''





      torch.manual_seed(0      )
      __magic_name__							=    UNetaDConditionModel(
          block_out_channels=(32, 64)  , layers_per_block=1  , sample_size=32  , in_channels=4  , out_channels=4  , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')  , cross_attention_dim=32  , )
      __magic_name__							=    DDIMScheduler()
      torch.manual_seed(0      )
      __magic_name__							=    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      )
      __magic_name__							=    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=10_00  , )
      __magic_name__							=    CLIPTextModel(__UpperCamelCase      )
      __magic_name__							=    CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

      __magic_name__							=    {
          'unet': unet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }
      return components







 def 	_SCREAMING_SNAKE_CASE							(   self: int  , __UpperCamelCase: List[str]  , __UpperCamelCase: Optional[int]=0      ):

      '''simple docstring'''





      __magic_name__							=    torch.manual_seed(__UpperCamelCase      )
      __magic_name__							=    {
          'prompt': 'a photo of the dolomites',
          'generator': generator,
          # Setting height and width to None to prevent OOMs on CPU.
          'height': None,
          'width': None,
          'num_inference_steps': 1,
          'guidance_scale': 6.0,
          'output_type': 'numpy',
      }
      return inputs







 def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

      '''simple docstring'''





      __magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator
      __magic_name__							=    self.get_dummy_components()
      __magic_name__							=    StableDiffusionPanoramaPipeline(**__UpperCamelCase      )
      __magic_name__							=    sd_pipe.to(__UpperCamelCase      )
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase      )

      __magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
      __magic_name__							=    sd_pipe(**__UpperCamelCase      ).images
      __magic_name__							=    image[0, -3:, -3:, -1]
      assert image.shape == (1, 64, 64, 3)

      __magic_name__							=    np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2







 def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

      '''simple docstring'''





      super().test_inference_batch_consistent(batch_sizes=[1, 2]      )







 def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

      '''simple docstring'''





      super().test_inference_batch_single_identical(batch_size=2  , expected_max_diff=3.25E-3      )







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

      '''simple docstring'''





      __magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator
      __magic_name__							=    self.get_dummy_components()
      __magic_name__							=    StableDiffusionPanoramaPipeline(**__UpperCamelCase      )
      __magic_name__							=    sd_pipe.to(__UpperCamelCase      )
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase      )

      __magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
      __magic_name__							=    'french fries'
      __magic_name__							=    sd_pipe(**__UpperCamelCase  , negative_prompt=__UpperCamelCase      )
      __magic_name__							=    output.images
      __magic_name__							=    image[0, -3:, -3:, -1]

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

      __magic_name__							=    np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2







 def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

      '''simple docstring'''





      __magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator
      __magic_name__							=    self.get_dummy_components()
      __magic_name__							=    StableDiffusionPanoramaPipeline(**__UpperCamelCase      )
      __magic_name__							=    sd_pipe.to(__UpperCamelCase      )
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase      )

      __magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
      __magic_name__							=    sd_pipe(**__UpperCamelCase  , view_batch_size=2      )
      __magic_name__							=    output.images
      __magic_name__							=    image[0, -3:, -3:, -1]

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

      __magic_name__							=    np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2







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

      '''simple docstring'''





      __magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator
      __magic_name__							=    self.get_dummy_components()
      __magic_name__							=    EulerAncestralDiscreteScheduler(
          beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'      )
      __magic_name__							=    StableDiffusionPanoramaPipeline(**__UpperCamelCase      )
      __magic_name__							=    sd_pipe.to(__UpperCamelCase      )
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase      )

      __magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
      __magic_name__							=    sd_pipe(**__UpperCamelCase      ).images
      __magic_name__							=    image[0, -3:, -3:, -1]

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

      __magic_name__							=    np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      __magic_name__							=    'cpu'  # ensure determinism for the device-dependent torch.Generator
      __magic_name__							=    self.get_dummy_components()
      __magic_name__							=    PNDMScheduler(
          beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'  , skip_prk_steps=__UpperCamelCase      )
      __magic_name__							=    StableDiffusionPanoramaPipeline(**__UpperCamelCase      )
      __magic_name__							=    sd_pipe.to(__UpperCamelCase      )
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase      )

      __magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
      __magic_name__							=    sd_pipe(**__UpperCamelCase      ).images
      __magic_name__							=    image[0, -3:, -3:, -1]

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

      __magic_name__							=    np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]      )

      assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2




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







 def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

      '''simple docstring'''





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







 def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]  , __UpperCamelCase: Optional[Any]=0      ):

      '''simple docstring'''





      __magic_name__							=    torch.manual_seed(__UpperCamelCase      )
      __magic_name__							=    {
          'prompt': 'a photo of the dolomites',
          'generator': generator,
          'num_inference_steps': 3,
          'guidance_scale': 7.5,
          'output_type': 'numpy',
      }
      return inputs







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      __magic_name__							=    'stabilityai/stable-diffusion-2-base'
      __magic_name__							=    DDIMScheduler.from_pretrained(__UpperCamelCase  , subfolder='scheduler'      )
      __magic_name__							=    StableDiffusionPanoramaPipeline.from_pretrained(__UpperCamelCase  , scheduler=__UpperCamelCase  , safety_checker=__UpperCamelCase      )
      pipe.to(__UpperCamelCase      )
      pipe.set_progress_bar_config(disable=__UpperCamelCase      )
      pipe.enable_attention_slicing()

      __magic_name__							=    self.get_inputs()
      __magic_name__							=    pipe(**__UpperCamelCase      ).images
      __magic_name__							=    image[0, -3:, -3:, -1].flatten()

      assert image.shape == (1, 5_12, 20_48, 3)

      __magic_name__							=    np.array(
          [
              0.36968392,
              0.27025372,
              0.32446766,
              0.28379387,
              0.36363274,
              0.30733347,
              0.27100027,
              0.27054125,
              0.25536096,
          ]      )

      assert np.abs(expected_slice - image_slice      ).max() < 1E-2







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      __magic_name__							=    StableDiffusionPanoramaPipeline.from_pretrained(
          'stabilityai/stable-diffusion-2-base'  , safety_checker=__UpperCamelCase      )
      __magic_name__							=    LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
      pipe.to(__UpperCamelCase      )
      pipe.set_progress_bar_config(disable=__UpperCamelCase      )
      pipe.enable_attention_slicing()

      __magic_name__							=    self.get_inputs()
      __magic_name__							=    pipe(**__UpperCamelCase      ).images
      __magic_name__							=    image[0, -3:, -3:, -1].flatten()

      assert image.shape == (1, 5_12, 20_48, 3)

      __magic_name__							=    np.array(
          [
              [
                  0.0,
                  0.0,
                  0.0,
                  0.0,
                  0.0,
                  0.0,
                  0.0,
                  0.0,
                  0.0,
              ]
          ]      )

      assert np.abs(expected_slice - image_slice      ).max() < 1E-3







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

      '''simple docstring'''





      __magic_name__							=    0

      def callback_fn(__UpperCamelCase: int  , __UpperCamelCase: int  , __UpperCamelCase: torch.FloatTensor      ) -> None:
           __magic_name__							=    True
           nonlocal number_of_steps
           number_of_steps += 1
           if step == 1:
                __magic_name__							=    latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 64, 2_56)
                __magic_name__							=    latents[0, -3:, -3:, -1]

                __magic_name__							=    np.array(
                    [
                        0.18681869,
                        0.33907816,
                        0.5361276,
                        0.14432865,
                        -0.02856611,
                        -0.73941123,
                        0.23397987,
                        0.47322682,
                        -0.37823164,
                    ]      )
                assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5E-2
           elif step == 2:
                __magic_name__							=    latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 64, 2_56)
                __magic_name__							=    latents[0, -3:, -3:, -1]

                __magic_name__							=    np.array(
                    [
                        0.18539645,
                        0.33987248,
                        0.5378559,
                        0.14437142,
                        -0.02455261,
                        -0.7338317,
                        0.23990755,
                        0.47356272,
                        -0.3786505,
                    ]      )

                assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5E-2

      __magic_name__							=    False

      __magic_name__							=    'stabilityai/stable-diffusion-2-base'
      __magic_name__							=    DDIMScheduler.from_pretrained(__UpperCamelCase  , subfolder='scheduler'      )
      __magic_name__							=    StableDiffusionPanoramaPipeline.from_pretrained(__UpperCamelCase  , scheduler=__UpperCamelCase  , safety_checker=__UpperCamelCase      )
      __magic_name__							=    pipe.to(__UpperCamelCase      )
      pipe.set_progress_bar_config(disable=__UpperCamelCase      )
      pipe.enable_attention_slicing()

      __magic_name__							=    self.get_inputs()
      pipe(**__UpperCamelCase  , callback=__UpperCamelCase  , callback_steps=1      )
      assert callback_fn.has_been_called
      assert number_of_steps == 3







 def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

      '''simple docstring'''





      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()

      __magic_name__							=    'stabilityai/stable-diffusion-2-base'
      __magic_name__							=    DDIMScheduler.from_pretrained(__UpperCamelCase  , subfolder='scheduler'      )
      __magic_name__							=    StableDiffusionPanoramaPipeline.from_pretrained(__UpperCamelCase  , scheduler=__UpperCamelCase  , safety_checker=__UpperCamelCase      )
      __magic_name__							=    pipe.to(__UpperCamelCase      )
      pipe.set_progress_bar_config(disable=__UpperCamelCase      )
      pipe.enable_attention_slicing(1      )
      pipe.enable_sequential_cpu_offload()

      __magic_name__							=    self.get_inputs()
      __magic_name__							=    pipe(**__UpperCamelCase      )

      __magic_name__							=    torch.cuda.max_memory_allocated()
      # make sure that less than 5.2 GB is allocated
      assert mem_bytes < 5.5 * 10**9







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				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Dict       				=  StableDiffusionDiffEditPipeline
	_lowercase  :   Dict       				=  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
	_lowercase  :   Dict       				=  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
	_lowercase  :   str       				=  frozenset(
	    []			)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	_lowercase  :   int       				=  frozenset([]			)







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						torch.manual_seed(0      )
						__magic_name__							=    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  , )
						__magic_name__							=    DDIMScheduler(
						    beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'  , clip_sample=__UpperCamelCase  , set_alpha_to_one=__UpperCamelCase  , )
						__magic_name__							=    DDIMInverseScheduler(
						    beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'  , clip_sample=__UpperCamelCase  , set_alpha_to_zero=__UpperCamelCase  , )
						torch.manual_seed(0      )
						__magic_name__							=    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=1_28  , )
						torch.manual_seed(0      )
						__magic_name__							=    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=10_00  , hidden_act='gelu'  , projection_dim=5_12  , )
						__magic_name__							=    CLIPTextModel(__UpperCamelCase      )
						__magic_name__							=    CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

						__magic_name__							=    {
						    '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 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]  , __UpperCamelCase: Optional[Any]  , __UpperCamelCase: List[Any]=0      ):

						'''simple docstring'''





						__magic_name__							=    floats_tensor((1, 16, 16)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						__magic_name__							=    floats_tensor((1, 2, 4, 16, 16)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						if str(__UpperCamelCase      ).startswith('mps'      ):
											__magic_name__							=    torch.manual_seed(__UpperCamelCase      )
						else:
											__magic_name__							=    torch.Generator(device=__UpperCamelCase      ).manual_seed(__UpperCamelCase      )
						__magic_name__							=    {
						    '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 	_SCREAMING_SNAKE_CASE							(   self: str  , __UpperCamelCase: str  , __UpperCamelCase: Optional[int]=0      ):

						'''simple docstring'''





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

						'''simple docstring'''





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

						'''simple docstring'''





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

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    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}      )

						__magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe(**__UpperCamelCase      )[0]

						with tempfile.TemporaryDirectory() as tmpdir:
											pipe.save_pretrained(__UpperCamelCase      )
											__magic_name__							=    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.'  , )

						__magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe_loaded(**__UpperCamelCase      )[0]

						__magic_name__							=    np.abs(output - output_loaded      ).max()
						self.assertLess(__UpperCamelCase  , 1E-4      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

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

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







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

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

						self.assertEqual(image.shape  , (2, 32, 32, 3)      )
						__magic_name__							=    np.array(
						    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]  , )
						__magic_name__							=    np.abs(image_slice.flatten() - expected_slice      ).max()
						self.assertLessEqual(__UpperCamelCase  , 1E-3      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





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







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()

						__magic_name__							=    {'beta_start': 0.00085, 'beta_end': 0.012, 'beta_schedule': 'scaled_linear'}
						__magic_name__							=    DPMSolverMultistepScheduler(**__UpperCamelCase      )
						__magic_name__							=    DPMSolverMultistepInverseScheduler(**__UpperCamelCase      )

						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

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

						self.assertEqual(image.shape  , (2, 32, 32, 3)      )
						__magic_name__							=    np.array(
						    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]  , )
						__magic_name__							=    np.abs(image_slice.flatten() - expected_slice      ).max()
						self.assertLessEqual(__UpperCamelCase  , 1E-3      )




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







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





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







	@classmethod
	def 	_SCREAMING_SNAKE_CASE							(   cls: List[str]      ):

						'''simple docstring'''





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

						__magic_name__							=    raw_image.convert('RGB'      ).resize((7_68, 7_68)      )

						__magic_name__							=    raw_image







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						__magic_name__							=    torch.manual_seed(0      )

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

						__magic_name__							=    'a bowl of fruit'
						__magic_name__							=    'a bowl of pears'

						__magic_name__							=    pipe.generate_mask(
						    image=self.raw_image  , source_prompt=__UpperCamelCase  , target_prompt=__UpperCamelCase  , generator=__UpperCamelCase  , )

						__magic_name__							=    pipe.invert(
						    prompt=__UpperCamelCase  , image=self.raw_image  , inpaint_strength=0.7  , generator=__UpperCamelCase      ).latents

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

						__magic_name__							=    (
						    np.array(
						        load_image(
						            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
						            '/diffedit/pears.png'      ).resize((7_68, 7_68)      )      )
						    / 2_55
						)
						assert np.abs((expected_image - image).max()      ) < 5E-1







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						__magic_name__							=    torch.manual_seed(0      )

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

						__magic_name__							=    'a bowl of fruit'
						__magic_name__							=    'a bowl of pears'

						__magic_name__							=    pipe.generate_mask(
						    image=self.raw_image  , source_prompt=__UpperCamelCase  , target_prompt=__UpperCamelCase  , generator=__UpperCamelCase  , )

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

						__magic_name__							=    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]

						__magic_name__							=    (
						    np.array(
						        load_image(
						            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
						            '/diffedit/pears.png'      ).resize((7_68, 7_68)      )      )
						    / 2_55
						)
						assert np.abs((expected_image - image).max()      ) < 5E-1




