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   __lowerCamelCase (_a							,			unittest.TestCase	):
         _lowercase       							=    PaintByExamplePipeline
         _lowercase       							=    IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
         _lowercase       							=    IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
         _lowercase       							=    frozenset([]	)  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              torch.manual_seed(0				)
              __UpperCamelCase   = 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,)
              __UpperCamelCase   = PNDMScheduler(skip_prk_steps=A_				)
              torch.manual_seed(0				)
              __UpperCamelCase   = 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				)
              __UpperCamelCase   = 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,)
              __UpperCamelCase   = PaintByExampleImageEncoder(A_,proj_size=32				)
              __UpperCamelCase   = CLIPImageProcessor(crop_size=32,size=32				)
  
              __UpperCamelCase   = {
                  'unet': unet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'image_encoder': image_encoder,
                  'safety_checker': None,
                  'feature_extractor': feature_extractor,
              }
              return components
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str],A_:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = np.array(image.convert('RGB'				)				)
              __UpperCamelCase   = image[None].transpose(0,3,1,2				)
              __UpperCamelCase   = torch.from_numpy(A_				).to(dtype=torch.floataa				) / 1_2_7.5 - 1.0
              return image
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any],A_:   int="cpu",A_:   Dict=0				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = floats_tensor((1, 3, 32, 32),rng=random.Random(A_				)				).to(A_				)
              __UpperCamelCase   = image.cpu().permute(0,2,3,1				)[0]
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				).resize((64, 64)				)
              __UpperCamelCase   = Image.fromarray(np.uinta(image + 4				)				).convert('RGB'				).resize((64, 64)				)
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				).resize((32, 32)				)
  
              if str(A_				).startswith('mps'				):
                   __UpperCamelCase   = torch.manual_seed(A_				)
              else:
                   __UpperCamelCase   = torch.Generator(device=A_				).manual_seed(A_				)
              __UpperCamelCase   = {
                  '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 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_dummy_components()
  
              # make sure here that pndm scheduler skips prk
              __UpperCamelCase   = PaintByExamplePipeline(**A_				)
              __UpperCamelCase   = pipe.to('cpu'				)
              pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = self.get_dummy_inputs()
              __UpperCamelCase   = pipe(**A_				)
              __UpperCamelCase   = output.images
  
              __UpperCamelCase   = image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
              __UpperCamelCase   = np.array([0.4_6_8_6, 0.5_6_8_7, 0.4_0_0_7, 0.5_2_1_8, 0.5_7_4_1, 0.4_4_8_2, 0.4_9_4_0, 0.4_6_2_9, 0.4_5_0_3]				)
  
              assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   int				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = 'cpu'
              __UpperCamelCase   = self.get_dummy_inputs()
              inputs.pop('mask_image'				)
              __UpperCamelCase   = self.convert_to_pt(inputs.pop('image'				)				)
              __UpperCamelCase   = image.clamp(0,1				) / 2
  
              # make sure here that pndm scheduler skips prk
              __UpperCamelCase   = PaintByExamplePipeline(**self.get_dummy_components()				)
              __UpperCamelCase   = pipe.to(A_				)
              pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = pipe(image=A_,mask_image=mask_image[:, 0],**A_				)
              __UpperCamelCase   = output.images
  
              __UpperCamelCase   = image.cpu().permute(0,2,3,1				)[0]
              __UpperCamelCase   = mask_image.cpu().permute(0,2,3,1				)[0]
  
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				)
              __UpperCamelCase   = Image.fromarray(np.uinta(A_				)				).convert('RGB'				)
  
              __UpperCamelCase   = pipe(**self.get_dummy_inputs()				)
              __UpperCamelCase   = output.images
  
              assert out_a.shape == (1, 64, 64, 3)
              assert np.abs(out_a.flatten() - out_a.flatten()				).max() < 5E-2
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().test_inference_batch_single_identical(expected_max_diff=3E-3				)
  
  
  
  @slow
  @require_torch_gpu
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                  '/paint_by_example/dog_in_bucket.png'				)
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                  '/paint_by_example/mask.png'				)
              __UpperCamelCase   = load_image(
                  'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                  '/paint_by_example/panda.jpg'				)
  
              __UpperCamelCase   = PaintByExamplePipeline.from_pretrained('Fantasy-Studio/Paint-by-Example'				)
              __UpperCamelCase   = pipe.to(A_				)
              pipe.set_progress_bar_config(disable=A_				)
  
              __UpperCamelCase   = torch.manual_seed(321				)
              __UpperCamelCase   = pipe(
                  image=A_,mask_image=A_,example_image=A_,generator=A_,guidance_scale=5.0,num_inference_steps=50,output_type='np',)
  
              __UpperCamelCase   = output.images
  
              __UpperCamelCase   = image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 512, 512, 3)
              __UpperCamelCase   = np.array([0.4_8_3_4, 0.4_8_1_1, 0.4_8_7_4, 0.5_1_2_2, 0.5_0_8_1, 0.5_1_4_4, 0.5_2_9_1, 0.5_2_9_0, 0.5_3_7_4]				)
  
              assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
  
  
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   int | float:
  
  
       """simple docstring"""
  
  
       if len(_lowercase   ) == 0:
            raise ValueError('find_max() arg is an empty sequence'   )
       __UpperCamelCase   = nums[0]
       for x in nums:
            if x > max_num:
                 __UpperCamelCase   = x
       return max_num
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod(verbose=True)
  
  
  