code: 
  
  
  import gc
  import random
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPImageProcessor, CLIPVisionConfig
  
  from diffusers import AutoencoderKL, PaintByExamplePipeline, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.paint_by_example import PaintByExampleImageEncoder
  from diffusers.utils import floats_tensor, load_image, slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  
  class 						snake_case			(       lowerCAmelCase__	, unittest.TestCase	):
  			'''simple docstring'''
  
  			UpperCAmelCase       :       int       = PaintByExamplePipeline
  			UpperCAmelCase       :       Optional[int]       = IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
  			UpperCAmelCase       :       Union[str, Any]       = IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  			UpperCAmelCase       :       Optional[int]       = frozenset([]	)  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  			def _lowercase (	self     :     List[Any]					)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								torch.manual_seed(0					)
  								SCREAMING_SNAKE_CASE_	      =       UNetaDConditionModel(
  								    block_out_channels=(32, 64)							,							layers_per_block=2							,							sample_size=32							,							in_channels=9							,							out_channels=4							,							down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							,							up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							,							cross_attention_dim=32							,							)
  								SCREAMING_SNAKE_CASE_	      =       PNDMScheduler(skip_prk_steps=__lowerCamelCase					)
  								torch.manual_seed(0					)
  								SCREAMING_SNAKE_CASE_	      =       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					)
  								SCREAMING_SNAKE_CASE_	      =       CLIPVisionConfig(
  								    hidden_size=32							,							projection_dim=32							,							intermediate_size=37							,							layer_norm_eps=1e-05							,							num_attention_heads=4							,							num_hidden_layers=5							,							image_size=32							,							patch_size=4							,							)
  								SCREAMING_SNAKE_CASE_	      =       PaintByExampleImageEncoder(__lowerCamelCase							,							proj_size=32					)
  								SCREAMING_SNAKE_CASE_	      =       CLIPImageProcessor(crop_size=32							,							size=32					)
  
  								SCREAMING_SNAKE_CASE_	      =       {
  								    "unet": unet,
  								    "scheduler": scheduler,
  								    "vae": vae,
  								    "image_encoder": image_encoder,
  								    "safety_checker": None,
  								    "feature_extractor": feature_extractor,
  								}
  								return components
  
  			def _lowercase (	self     :     Optional[int]							,							lowerCAmelCase_     :     Optional[int]					)					->					Optional[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       np.array(image.convert('''RGB'''					)					)
  								SCREAMING_SNAKE_CASE_	      =       image[None].transpose(0							,							3							,							1							,							2					)
  								SCREAMING_SNAKE_CASE_	      =       torch.from_numpy(__lowerCamelCase					).to(dtype=torch.floataa					) / 127.5 - 1.0
  								return image
  
  			def _lowercase (	self     :     Union[str, Any]							,							lowerCAmelCase_     :     Optional[Any]="cpu"							,							lowerCAmelCase_     :     Optional[Any]=0					)					->					List[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       floats_tensor((1, 3, 32, 32)							,							rng=random.Random(__lowerCamelCase					)					).to(__lowerCamelCase					)
  								SCREAMING_SNAKE_CASE_	      =       image.cpu().permute(0							,							2							,							3							,							1					)[0]
  								SCREAMING_SNAKE_CASE_	      =       Image.fromarray(np.uinta(__lowerCamelCase					)					).convert('''RGB'''					).resize((64, 64)					)
  								SCREAMING_SNAKE_CASE_	      =       Image.fromarray(np.uinta(image + 4					)					).convert('''RGB'''					).resize((64, 64)					)
  								SCREAMING_SNAKE_CASE_	      =       Image.fromarray(np.uinta(__lowerCamelCase					)					).convert('''RGB'''					).resize((32, 32)					)
  
  								if str(__lowerCamelCase					).startswith('''mps'''					):
  													SCREAMING_SNAKE_CASE_	      =       torch.manual_seed(__lowerCamelCase					)
  								else:
  													SCREAMING_SNAKE_CASE_	      =       torch.Generator(device=__lowerCamelCase					).manual_seed(__lowerCamelCase					)
  								SCREAMING_SNAKE_CASE_	      =       {
  								    "example_image": example_image,
  								    "image": init_image,
  								    "mask_image": mask_image,
  								    "generator": generator,
  								    "num_inference_steps": 2,
  								    "guidance_scale": 6.0,
  								    "output_type": "numpy",
  								}
  								return inputs
  
  			def _lowercase (	self     :     Union[str, Any]					)					->					List[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_components()
  
  								# make sure here that pndm scheduler skips prk
  								SCREAMING_SNAKE_CASE_	      =       PaintByExamplePipeline(**__lowerCamelCase					)
  								SCREAMING_SNAKE_CASE_	      =       pipe.to('''cpu'''					)
  								pipe.set_progress_bar_config(disable=__lowerCamelCase					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs()
  								SCREAMING_SNAKE_CASE_	      =       pipe(**__lowerCamelCase					)
  								SCREAMING_SNAKE_CASE_	      =       output.images
  
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 64, 64, 3)
  								SCREAMING_SNAKE_CASE_	      =       np.array([0.4_686, 0.5_687, 0.4_007, 0.5_218, 0.5_741, 0.4_482, 0.4_940, 0.4_629, 0.4_503]					)
  
  								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
  
  			def _lowercase (	self     :     Union[str, Any]					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       "cpu"
  								SCREAMING_SNAKE_CASE_	      =       self.get_dummy_inputs()
  								inputs.pop('''mask_image'''					)
  								SCREAMING_SNAKE_CASE_	      =       self.convert_to_pt(inputs.pop('''image'''					)					)
  								SCREAMING_SNAKE_CASE_	      =       image.clamp(0							,							1					) / 2
  
  								# make sure here that pndm scheduler skips prk
  								SCREAMING_SNAKE_CASE_	      =       PaintByExamplePipeline(**self.get_dummy_components()					)
  								SCREAMING_SNAKE_CASE_	      =       pipe.to(__lowerCamelCase					)
  								pipe.set_progress_bar_config(disable=__lowerCamelCase					)
  
  								SCREAMING_SNAKE_CASE_	      =       pipe(image=__lowerCamelCase							,							mask_image=mask_image[:, 0]							,							**__lowerCamelCase					)
  								SCREAMING_SNAKE_CASE_	      =       output.images
  
  								SCREAMING_SNAKE_CASE_	      =       image.cpu().permute(0							,							2							,							3							,							1					)[0]
  								SCREAMING_SNAKE_CASE_	      =       mask_image.cpu().permute(0							,							2							,							3							,							1					)[0]
  
  								SCREAMING_SNAKE_CASE_	      =       Image.fromarray(np.uinta(__lowerCamelCase					)					).convert('''RGB'''					)
  								SCREAMING_SNAKE_CASE_	      =       Image.fromarray(np.uinta(__lowerCamelCase					)					).convert('''RGB'''					)
  
  								SCREAMING_SNAKE_CASE_	      =       pipe(**self.get_dummy_inputs()					)
  								SCREAMING_SNAKE_CASE_	      =       output.images
  
  								assert out_a.shape == (1, 64, 64, 3)
  								assert np.abs(out_a.flatten() - out_a.flatten()					).max() < 5e-2
  
  
  
  
  			def _lowercase (	self     :     str					)					->					Union[str, Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								super().test_inference_batch_single_identical(expected_max_diff=3e-3					)
  
  @slow
  @require_torch_gpu
  class 						snake_case			(       unittest.TestCase	):
  			'''simple docstring'''
  
  			def _lowercase (	self     :     List[Any]					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								super().tearDown()
  								gc.collect()
  								torch.cuda.empty_cache()
  
  
  
  
  			def _lowercase (	self     :     int					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       load_image(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
  								    '''/paint_by_example/dog_in_bucket.png'''					)
  								SCREAMING_SNAKE_CASE_	      =       load_image(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
  								    '''/paint_by_example/mask.png'''					)
  								SCREAMING_SNAKE_CASE_	      =       load_image(
  								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
  								    '''/paint_by_example/panda.jpg'''					)
  
  								SCREAMING_SNAKE_CASE_	      =       PaintByExamplePipeline.from_pretrained('''Fantasy-Studio/Paint-by-Example'''					)
  								SCREAMING_SNAKE_CASE_	      =       pipe.to(__lowerCamelCase					)
  								pipe.set_progress_bar_config(disable=__lowerCamelCase					)
  
  								SCREAMING_SNAKE_CASE_	      =       torch.manual_seed(321					)
  								SCREAMING_SNAKE_CASE_	      =       pipe(
  								    image=__lowerCamelCase							,							mask_image=__lowerCamelCase							,							example_image=__lowerCamelCase							,							generator=__lowerCamelCase							,							guidance_scale=5.0							,							num_inference_steps=50							,							output_type='''np'''							,							)
  
  								SCREAMING_SNAKE_CASE_	      =       output.images
  
  								SCREAMING_SNAKE_CASE_	      =       image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 512, 512, 3)
  								SCREAMING_SNAKE_CASE_	      =       np.array([0.4_834, 0.4_811, 0.4_874, 0.5_122, 0.5_081, 0.5_144, 0.5_291, 0.5_290, 0.5_374]					)
  
  								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
  
  
  
style_context: 
  
  
  def 							UpperCAmelCase				(     UpperCAmelCase      )->		bool:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					if not isinstance(UpperCAmelCase				,UpperCAmelCase      ):
  										SCREAMING_SNAKE_CASE_	      =       f'''Input value of [number={number}] must be an integer'''
  										raise TypeError(UpperCAmelCase      )
  					if number < 0 or number % 2 == 1:
  										return False
  					SCREAMING_SNAKE_CASE_	      =       int(number**0.5      )
  					return number == number_sqrt * (number_sqrt + 1)
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  