code: 
  
  
  
  
  
  
  import gc
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers import RePaintPipeline, RePaintScheduler, UNetaDModel
  from diffusers.utils.testing_utils import (
      enable_full_determinism,
      load_image,
      load_numpy,
      nightly,
      require_torch_gpu,
      skip_mps,
      torch_device,
  )
  
  from ..pipeline_params import IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_INPAINTING_PARAMS
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  
  
  
  class     __a						(					A__ ,     unittest.TestCase ):
   _lowerCAmelCase : Any 				=				RePaintPipeline
   _lowerCAmelCase : List[Any] 				=				IMAGE_INPAINTING_PARAMS - {'''width''', '''height''', '''guidance_scale'''}
   _lowerCAmelCase : List[Any] 				=				PipelineTesterMixin.required_optional_params - {
       '''latents''',
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   _lowerCAmelCase : Optional[int] 				=				IMAGE_INPAINTING_BATCH_PARAMS
   _lowerCAmelCase : str 				=				False
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[str]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        torch.manual_seed(0		)
        torch.manual_seed(0		)
        UpperCamelCase__    :     List[str]        =						UNetaDModel(
            block_out_channels=(32, 64)							,     layers_per_block=2							,     sample_size=32							,     in_channels=3							,     out_channels=3							,     down_block_types=("DownBlock2D", "AttnDownBlock2D")							,     up_block_types=("AttnUpBlock2D", "UpBlock2D")							,     )
        UpperCamelCase__    :     str        =						RePaintScheduler()
        UpperCamelCase__    :     Union[str, Any]        =						{"unet": unet, "scheduler": scheduler}
        return components
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[str]							,     SCREAMING_SNAKE_CASE      :     Optional[int]							,     SCREAMING_SNAKE_CASE      :     Dict=0		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        if str(SCREAMING_SNAKE_CASE		).startswith("mps"		):
             UpperCamelCase__    :     Optional[Any]        =						torch.manual_seed(SCREAMING_SNAKE_CASE		)
        else:
             UpperCamelCase__    :     Tuple        =						torch.Generator(device=SCREAMING_SNAKE_CASE		).manual_seed(SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Optional[Any]        =						np.random.RandomState(SCREAMING_SNAKE_CASE		).standard_normal((1, 3, 32, 32)		)
        UpperCamelCase__    :     Union[str, Any]        =						torch.from_numpy(SCREAMING_SNAKE_CASE		).to(device=SCREAMING_SNAKE_CASE							,     dtype=torch.floataa		)
        UpperCamelCase__    :     str        =						(image > 0).to(device=SCREAMING_SNAKE_CASE							,     dtype=torch.floataa		)
        UpperCamelCase__    :     Union[str, Any]        =						{
            "image": image,
            "mask_image": mask,
            "generator": generator,
            "num_inference_steps": 5,
            "eta": 0.0,
            "jump_length": 2,
            "jump_n_sample": 2,
            "output_type": "numpy",
        }
        return inputs
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[str]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Union[str, Any]        =						"cpu"  # ensure determinism for the device-dependent torch.Generator
        UpperCamelCase__    :     Optional[Any]        =						self.get_dummy_components()
        UpperCamelCase__    :     Optional[int]        =						RePaintPipeline(**SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Optional[Any]        =						sd_pipe.to(SCREAMING_SNAKE_CASE		)
        sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE		)
  
        UpperCamelCase__    :     Tuple        =						self.get_dummy_inputs(SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Optional[Any]        =						sd_pipe(**SCREAMING_SNAKE_CASE		).images
        UpperCamelCase__    :     List[Any]        =						image[0, -3:, -3:, -1]
  
        assert image.shape == (1, 32, 32, 3)
        UpperCamelCase__    :     List[str]        =						np.array([1.0_0_0_0, 0.5_4_2_6, 0.5_4_9_7, 0.2_2_0_0, 1.0_0_0_0, 1.0_0_0_0, 0.5_6_2_3, 1.0_0_0_0, 0.6_2_7_4]		)
  
        assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-3
  
  
  
  
  
  
  
   @skip_mps
   def       __lowercase      (	self      :     Any		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return super().test_save_load_local()
  
  
  
  
  
  
  
   @unittest.skip("non-deterministic pipeline"		)
   def       __lowercase      (	self      :     Tuple		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return super().test_inference_batch_single_identical()
  
  
  
  
  
  
  
   @skip_mps
   def       __lowercase      (	self      :     Tuple		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return super().test_dict_tuple_outputs_equivalent()
  
  
  
  
  
  
  
   @skip_mps
   def       __lowercase      (	self      :     Optional[int]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return super().test_save_load_optional_components()
  
  
  
  
  
  
  
   @skip_mps
   def       __lowercase      (	self      :     str		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return super().test_attention_slicing_forward_pass()
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class     __a						(					unittest.TestCase ):
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Dict		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Optional[int]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Optional[Any]        =						load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
            "repaint/celeba_hq_256.png"		)
        UpperCamelCase__    :     List[Any]        =						load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"		)
        UpperCamelCase__    :     int        =						load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
            "repaint/celeba_hq_256_result.npy"		)
  
        UpperCamelCase__    :     Tuple        =						"google/ddpm-ema-celebahq-256"
        UpperCamelCase__    :     str        =						UNetaDModel.from_pretrained(SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Optional[int]        =						RePaintScheduler.from_pretrained(SCREAMING_SNAKE_CASE		)
  
        UpperCamelCase__    :     Optional[int]        =						RePaintPipeline(unet=SCREAMING_SNAKE_CASE							,     scheduler=SCREAMING_SNAKE_CASE		).to(SCREAMING_SNAKE_CASE		)
        repaint.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE		)
        repaint.enable_attention_slicing()
  
        UpperCamelCase__    :     List[Any]        =						torch.manual_seed(0		)
        UpperCamelCase__    :     Optional[int]        =						repaint(
            SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE							,     num_inference_steps=2_50							,     eta=0.0							,     jump_length=10							,     jump_n_sample=10							,     generator=SCREAMING_SNAKE_CASE							,     output_type="np"							,     )
        UpperCamelCase__    :     Tuple        =						output.images[0]
  
        assert image.shape == (2_56, 2_56, 3)
        assert np.abs(expected_image - image		).mean() < 1e-2
style_context: 
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			str:
       return "".join(chr(ord(__lowerCAmelCase    ) + 32    ) if "A" <= char <= "Z" else char for char in word    )
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod()