code: 
  '''simple docstring'''
  
  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 			UpperCAmelCase				(					lowerCamelCase_  ,		unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   Optional[Any]          =    RePaintPipeline
  		A__  :   List[Any]          =    IMAGE_INPAINTING_PARAMS - {"""width""", """height""", """guidance_scale"""}
  		A__  :   List[Any]          =    PipelineTesterMixin.required_optional_params - {
  		    """latents""",
  		    """num_images_per_prompt""",
  		    """callback""",
  		    """callback_steps""",
  		}
  		A__  :   List[Any]          =    IMAGE_INPAINTING_BATCH_PARAMS
  		A__  :   List[str]          =    False
  		def _lowercase  (    self     )				->    str:
  				torch.manual_seed(0     )
  				torch.manual_seed(0     )
  				_UpperCamelCase       : Union[str, Any]    =      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       : Union[str, Any]    =      RePaintScheduler()
  				_UpperCamelCase       : Optional[Any]    =      {"unet": unet, "scheduler": scheduler}
  				return components
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case=0     )				->    Tuple:
  
  
  
  
  
  
  
  				if str(_snake_case     ).startswith('''mps'''     ):
  						_UpperCamelCase       : str    =      torch.manual_seed(_snake_case     )
  				else:
  						_UpperCamelCase       : List[Any]    =      torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )
  				_UpperCamelCase       : Any    =      np.random.RandomState(_snake_case     ).standard_normal((1, 3, 32, 32)     )
  				_UpperCamelCase       : Any    =      torch.from_numpy(_snake_case     ).to(device=_snake_case  ,					dtype=torch.floataa     )
  				_UpperCamelCase       : List[str]    =      (image > 0).to(device=_snake_case  ,					dtype=torch.floataa     )
  				_UpperCamelCase       : int    =      {
  				    "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     )				->    Optional[int]:
  				_UpperCamelCase       : List[Any]    =      "cpu"  # ensure determinism for the device-dependent torch.Generator
  				_UpperCamelCase       : Any    =      self.get_dummy_components()
  				_UpperCamelCase       : Optional[int]    =      RePaintPipeline(**_snake_case     )
  				_UpperCamelCase       : Optional[Any]    =      sd_pipe.to(_snake_case     )
  				sd_pipe.set_progress_bar_config(disable=_snake_case     )
  
  				_UpperCamelCase       : Any    =      self.get_dummy_inputs(_snake_case     )
  				_UpperCamelCase       : Dict    =      sd_pipe(**_snake_case     ).images
  				_UpperCamelCase       : Optional[int]    =      image[0, -3:, -3:, -1]
  
  				assert image.shape == (1, 32, 32, 3)
  				_UpperCamelCase       : 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 _lowercase  (    self     )				->    List[Any]:
  				return super().test_save_load_local()
  		@unittest.skip('''non-deterministic pipeline'''     )
  		def _lowercase  (    self     )				->    Union[str, Any]:
  				return super().test_inference_batch_single_identical()
  		@skip_mps
  		def _lowercase  (    self     )				->    List[Any]:
  				return super().test_dict_tuple_outputs_equivalent()
  		@skip_mps
  		def _lowercase  (    self     )				->    Optional[Any]:
  				return super().test_save_load_optional_components()
  
  
  
  
  		@skip_mps
  		def _lowercase  (    self     )				->    Optional[int]:
  				return super().test_attention_slicing_forward_pass()
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class 			UpperCAmelCase				(					unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		def _lowercase  (    self     )				->    List[Any]:
  				super().tearDown()
  				gc.collect()
  				torch.cuda.empty_cache()
  
  
  
  
  		def _lowercase  (    self     )				->    Tuple:
  				_UpperCamelCase       : Optional[int]    =      load_image(
  				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
  				    '''repaint/celeba_hq_256.png'''     )
  				_UpperCamelCase       : Any    =      load_image(
  				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png'''     )
  				_UpperCamelCase       : List[Any]    =      load_numpy(
  				    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/'''
  				    '''repaint/celeba_hq_256_result.npy'''     )
  
  				_UpperCamelCase       : str    =      "google/ddpm-ema-celebahq-256"
  				_UpperCamelCase       : Optional[Any]    =      UNetaDModel.from_pretrained(_snake_case     )
  				_UpperCamelCase       : Optional[int]    =      RePaintScheduler.from_pretrained(_snake_case     )
  
  				_UpperCamelCase       : str    =      RePaintPipeline(unet=_snake_case  ,					scheduler=_snake_case     ).to(_snake_case     )
  				repaint.set_progress_bar_config(disable=_snake_case     )
  				repaint.enable_attention_slicing()
  
  				_UpperCamelCase       : Union[str, Any]    =      torch.manual_seed(0     )
  				_UpperCamelCase       : int    =      repaint(
  				    _snake_case  ,					_snake_case  ,					num_inference_steps=250  ,					eta=0.0  ,					jump_length=10  ,					jump_n_sample=10  ,					generator=_snake_case  ,					output_type='''np'''  ,					)
  				_UpperCamelCase       : List[Any]    =      output.images[0]
  
  				assert image.shape == (256, 256, 3)
  				assert np.abs(expected_image - image     ).mean() < 1E-2
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  import unittest
  
  from transformers.image_processing_utils import get_size_dict
  
  class 			UpperCAmelCase				(					unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		def _lowercase  (    self     )				->    Dict:
  				# Test a dict with the wrong keys raises an error
  				_UpperCamelCase       : List[Any]    =      {'''wrong_key''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : Dict    =      {'''height''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : str    =      {'''width''': 224, '''shortest_edge''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				# Test a dict with the correct keys is returned as is
  				_UpperCamelCase       : Any    =      {'''height''': 224, '''width''': 224}
  				_UpperCamelCase       : Optional[int]    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					_snake_case     )
  
  				_UpperCamelCase       : Optional[Any]    =      {'''shortest_edge''': 224}
  				_UpperCamelCase       : int    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				_UpperCamelCase       : int    =      {'''longest_edge''': 224, '''shortest_edge''': 224}
  				_UpperCamelCase       : Tuple    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''longest_edge''': 224, '''shortest_edge''': 224}     )
  
  				# Test a single int value which  represents (size, size)
  				_UpperCamelCase       : Any    =      get_size_dict(224     )
  				self.assertEqual(_snake_case  ,					{'''height''': 224, '''width''': 224}     )
  
  				# Test a single int value which represents the shortest edge
  				_UpperCamelCase       : List[Any]    =      get_size_dict(224  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				# Test a tuple of ints which represents (height, width)
  				_UpperCamelCase       : Any    =      get_size_dict((150, 200)     )
  				self.assertEqual(_snake_case  ,					{'''height''': 150, '''width''': 200}     )
  
  				# Test a tuple of ints which represents (width, height)
  				_UpperCamelCase       : List[str]    =      get_size_dict((150, 200)  ,					height_width_order=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''height''': 200, '''width''': 150}     )
  
  				# Test an int representing the shortest edge and max_size which represents the longest edge
  				_UpperCamelCase       : Any    =      get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224, '''longest_edge''': 256}     )
  
  				# Test int with default_to_square=True and max_size fails
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  
  
  
  
  
  