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    SCREAMING_SNAKE_CASE__      (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    snake_case_       (   self):
  									torch.manual_seed(0)
  									torch.manual_seed(0)
  									lowercase__					:     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')		,     )
  									lowercase__					:     str   = RePaintScheduler()
  									lowercase__					:     Union[str, Any]   = {"unet": unet, "scheduler": scheduler}
  									return components
  
  
  
  
  
  				def    snake_case_       (   self		,     a		,     a=0):
  
  
  
  
  
  
  									if str(a).startswith('mps'):
  														lowercase__					:     Optional[Any]   = torch.manual_seed(a)
  									else:
  														lowercase__					:     Tuple   = torch.Generator(device=a).manual_seed(a)
  									lowercase__					:     Optional[Any]   = np.random.RandomState(a).standard_normal((1, 3, 32, 32))
  									lowercase__					:     Union[str, Any]   = torch.from_numpy(a).to(device=a		,     dtype=torch.floataa)
  									lowercase__					:     str   = (image > 0).to(device=a		,     dtype=torch.floataa)
  									lowercase__					:     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    snake_case_       (   self):
  									lowercase__					:     Union[str, Any]   = "cpu"  # ensure determinism for the device-dependent torch.Generator
  									lowercase__					:     Optional[Any]   = self.get_dummy_components()
  									lowercase__					:     Optional[int]   = RePaintPipeline(**a)
  									lowercase__					:     Optional[Any]   = sd_pipe.to(a)
  									sd_pipe.set_progress_bar_config(disable=a)
  
  									lowercase__					:     Tuple   = self.get_dummy_inputs(a)
  									lowercase__					:     Optional[Any]   = sd_pipe(**a).images
  									lowercase__					:     List[Any]   = image[0, -3:, -3:, -1]
  
  									assert image.shape == (1, 32, 32, 3)
  									lowercase__					:     List[str]   = np.array([1.0_000, 0.5_426, 0.5_497, 0.2_200, 1.0_000, 1.0_000, 0.5_623, 1.0_000, 0.6_274])
  
  									assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3
  
  
  
  
  
  				@skip_mps
  				def    snake_case_       (   self):
  									return super().test_save_load_local()
  
  
  
  
  
  				@unittest.skip('non-deterministic pipeline')
  				def    snake_case_       (   self):
  									return super().test_inference_batch_single_identical()
  
  
  
  
  
  				@skip_mps
  				def    snake_case_       (   self):
  									return super().test_dict_tuple_outputs_equivalent()
  
  
  
  
  
  				@skip_mps
  				def    snake_case_       (   self):
  									return super().test_save_load_optional_components()
  
  
  
  
  
  				@skip_mps
  				def    snake_case_       (   self):
  									return super().test_attention_slicing_forward_pass()
  
  
  
  @nightly
  @require_torch_gpu
  class    SCREAMING_SNAKE_CASE__      (unittest.TestCase  ):
  
  
  
  
  
  				def    snake_case_       (   self):
  									super().tearDown()
  									gc.collect()
  									torch.cuda.empty_cache()
  
  
  
  
  
  				def    snake_case_       (   self):
  									lowercase__					:     Optional[Any]   = load_image(
  									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'
  									    'repaint/celeba_hq_256.png')
  									lowercase__					:     List[Any]   = load_image(
  									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png')
  									lowercase__					:     int   = load_numpy(
  									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'
  									    'repaint/celeba_hq_256_result.npy')
  
  									lowercase__					:     Tuple   = "google/ddpm-ema-celebahq-256"
  									lowercase__					:     str   = UNetaDModel.from_pretrained(a)
  									lowercase__					:     Optional[int]   = RePaintScheduler.from_pretrained(a)
  
  									lowercase__					:     Optional[int]   = RePaintPipeline(unet=a		,     scheduler=a).to(a)
  									repaint.set_progress_bar_config(disable=a)
  									repaint.enable_attention_slicing()
  
  									lowercase__					:     List[Any]   = torch.manual_seed(0)
  									lowercase__					:     Optional[int]   = repaint(
  									    a		,     a		,     num_inference_steps=250		,     eta=0.0		,     jump_length=10		,     jump_n_sample=10		,     generator=a		,     output_type='np'		,     )
  									lowercase__					:     Tuple   = output.images[0]
  
  									assert image.shape == (256, 256, 3)
  									assert np.abs(expected_image - image).mean() < 1e-2
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  snake_case_    						=				{'''configuration_gptj''': ['''GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTJConfig''', '''GPTJOnnxConfig''']}
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''GPTJForCausalLM''',
             '''GPTJForQuestionAnswering''',
             '''GPTJForSequenceClassification''',
             '''GPTJModel''',
             '''GPTJPreTrainedModel''',
         ]
  
  try:
         if not is_tf_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''TFGPTJForCausalLM''',
             '''TFGPTJForQuestionAnswering''',
             '''TFGPTJForSequenceClassification''',
             '''TFGPTJModel''',
             '''TFGPTJPreTrainedModel''',
         ]
  
  try:
         if not is_flax_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''FlaxGPTJForCausalLM''',
             '''FlaxGPTJModel''',
             '''FlaxGPTJPreTrainedModel''',
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_gptj import (
                    GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
                    GPTJForCausalLM,
                    GPTJForQuestionAnswering,
                    GPTJForSequenceClassification,
                    GPTJModel,
                    GPTJPreTrainedModel,
                )
  
         try:
                if not is_tf_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_tf_gptj import (
                    TFGPTJForCausalLM,
                    TFGPTJForQuestionAnswering,
                    TFGPTJForSequenceClassification,
                    TFGPTJModel,
                    TFGPTJPreTrainedModel,
                )
  
         try:
                if not is_flax_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel
  
  else:
         import sys
  
         snake_case_    						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  