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 							_A (    lowercase__				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       List[str]   =   PaintByExamplePipeline
      lowerCamelCase  :       Optional[int]   =   IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
      lowerCamelCase  :       Union[str, Any]   =   IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      lowerCamelCase  :       Dict   =   frozenset([]							)  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
  
      def _a       (							self			:    List[str]			)			->       Any:
             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 _a       (							self			:    Any   ,    __SCREAMING_SNAKE_CASE			:    Tuple			)			->       Dict:
             __UpperCAmelCase    							=np.array(image.convert("""RGB"""			)			)
             __UpperCAmelCase    							=image[None].transpose(0   ,    3   ,    1   ,    2			)
             __UpperCAmelCase    							=torch.from_numpy(_A			).to(dtype=torch.floataa			) / 127.5 - 1.0
             return image
  
  
  
      def _a       (							self			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    List[str]="cpu"   ,    __SCREAMING_SNAKE_CASE			:    Tuple=0			)			->       List[Any]:
             # TODO: use tensor inputs instead of PIL, this is here just to leave the old expected_slices untouched
             __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 _a       (							self			:    str			)			->       Optional[Any]:
             __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_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 _a       (							self			:    List[Any]			)			->       str:
             __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 _a       (							self			:    Optional[int]			)			->       Tuple:
             super().test_inference_batch_single_identical(expected_max_diff=3e-3			)
  
  
  
  
  @slow
  @require_torch_gpu
  class 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      def _a       (							self			:    int			)			->       str:
             # clean up the VRAM after each test
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
  
  
  
      def _a       (							self			:    Optional[int]			)			->       Dict:
             # make sure here that pndm scheduler skips prk
             __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_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: 
  
  
  
  
  
  
  from collections import namedtuple
  
  __A  							=  namedtuple("from_to", "from_ to")
  
  __A  							=  {
      "millimeter": "mm",
      "centimeter": "cm",
      "meter": "m",
      "kilometer": "km",
      "inch": "in",
      "inche": "in",  # Trailing 's' has been stripped off
      "feet": "ft",
      "foot": "ft",
      "yard": "yd",
      "mile": "mi",
  }
  
  __A  							=  {
      "mm": from_to(0.001, 10_00),
      "cm": from_to(0.01, 1_00),
      "m": from_to(1, 1),
      "km": from_to(10_00, 0.001),
      "in": from_to(0.0254, 39.3701),
      "ft": from_to(0.3048, 3.2_8084),
      "yd": from_to(0.9144, 1.0_9361),
      "mi": from_to(1609.34, 0.0_0062_1371),
  }
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	float     ,			A_:	str     ,			A_:	str		)  ->							float:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=from_type.lower().rstrip("""s"""		)
         __UpperCAmelCase    							=TYPE_CONVERSION.get(A_     ,			A_		)
         __UpperCAmelCase    							=to_type.lower().rstrip("""s"""		)
         __UpperCAmelCase    							=TYPE_CONVERSION.get(A_     ,			A_		)
         if new_from not in METRIC_CONVERSION:
                __UpperCAmelCase    							=(
                    F'''Invalid \'from_type\' value: {from_type!r}.\n'''
                    F'''Conversion abbreviations are: {", ".join(A_		)}'''
                )
                raise ValueError(A_		)
         if new_to not in METRIC_CONVERSION:
                __UpperCAmelCase    							=(
                    F'''Invalid \'to_type\' value: {to_type!r}.\n'''
                    F'''Conversion abbreviations are: {", ".join(A_		)}'''
                )
                raise ValueError(A_		)
         return value * METRIC_CONVERSION[new_from].from_ * METRIC_CONVERSION[new_to].to
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
  
  
  
  