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        lowercase_				( __UpperCAmelCase			,unittest.TestCase):
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         snake_case_        =		PaintByExamplePipeline
         snake_case_        =		IMAGE_GUIDED_IMAGE_INPAINTING_PARAMS
         snake_case_        =		IMAGE_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
         snake_case_        =		frozenset([])  # TO_DO: update the image_prams once refactored VaeImageProcessor.preprocess
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               torch.manual_seed(0		)
               a_					=		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			,    )
               a_					=		PNDMScheduler(skip_prk_steps=lowerCamelCase__		)
               torch.manual_seed(0		)
               a_					=		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		)
               a_					=		CLIPVisionConfig(
                   hidden_size=32			,    projection_dim=32			,    intermediate_size=37			,    layer_norm_eps=1e-0_5			,    num_attention_heads=4			,    num_hidden_layers=5			,    image_size=32			,    patch_size=4			,    )
               a_					=		PaintByExampleImageEncoder(lowerCamelCase__			,    proj_size=32		)
               a_					=		CLIPImageProcessor(crop_size=32			,    size=32		)
  
               a_					=		{
                   """unet""": unet,
                   """scheduler""": scheduler,
                   """vae""": vae,
                   """image_encoder""": image_encoder,
                   """safety_checker""": None,
                   """feature_extractor""": feature_extractor,
               }
               return components
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		np.array(image.convert("""RGB"""		)		)
               a_					=		image[None].transpose(0			,    3			,    1			,    2		)
               a_					=		torch.from_numpy(lowerCamelCase__		).to(dtype=torch.floataa		) / 127.5 - 1.0
               return image
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase="cpu"			,    _UpperCAmelCase=0		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		floats_tensor((1, 3, 32, 32)			,    rng=random.Random(lowerCamelCase__		)		).to(lowerCamelCase__		)
               a_					=		image.cpu().permute(0			,    2			,    3			,    1		)[0]
               a_					=		Image.fromarray(np.uinta(lowerCamelCase__		)		).convert("""RGB"""		).resize((64, 64)		)
               a_					=		Image.fromarray(np.uinta(image + 4		)		).convert("""RGB"""		).resize((64, 64)		)
               a_					=		Image.fromarray(np.uinta(lowerCamelCase__		)		).convert("""RGB"""		).resize((32, 32)		)
  
               if str(lowerCamelCase__		).startswith("""mps"""		):
                     a_					=		torch.manual_seed(lowerCamelCase__		)
               else:
                     a_					=		torch.Generator(device=lowerCamelCase__		).manual_seed(lowerCamelCase__		)
               a_					=		{
                   """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		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.get_dummy_components()
  
               # make sure here that pndm scheduler skips prk
               a_					=		PaintByExamplePipeline(**lowerCamelCase__		)
               a_					=		pipe.to("""cpu"""		)
               pipe.set_progress_bar_config(disable=lowerCamelCase__		)
  
               a_					=		self.get_dummy_inputs()
               a_					=		pipe(**lowerCamelCase__		)
               a_					=		output.images
  
               a_					=		image[0, -3:, -3:, -1]
  
               assert image.shape == (1, 64, 64, 3)
               a_					=		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 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		"""cpu"""
               a_					=		self.get_dummy_inputs()
               inputs.pop("""mask_image"""		)
               a_					=		self.convert_to_pt(inputs.pop("""image"""		)		)
               a_					=		image.clamp(0			,    1		) / 2
  
               # make sure here that pndm scheduler skips prk
               a_					=		PaintByExamplePipeline(**self.get_dummy_components()		)
               a_					=		pipe.to(lowerCamelCase__		)
               pipe.set_progress_bar_config(disable=lowerCamelCase__		)
  
               a_					=		pipe(image=lowerCamelCase__			,    mask_image=mask_image[:, 0]			,    **lowerCamelCase__		)
               a_					=		output.images
  
               a_					=		image.cpu().permute(0			,    2			,    3			,    1		)[0]
               a_					=		mask_image.cpu().permute(0			,    2			,    3			,    1		)[0]
  
               a_					=		Image.fromarray(np.uinta(lowerCamelCase__		)		).convert("""RGB"""		)
               a_					=		Image.fromarray(np.uinta(lowerCamelCase__		)		).convert("""RGB"""		)
  
               a_					=		pipe(**self.get_dummy_inputs()		)
               a_					=		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		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               super().test_inference_batch_single_identical(expected_max_diff=3e-3		)
  
  
  
  
  
  @slow
  @require_torch_gpu
  class        lowercase_				( unittest.TestCase):
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               super().tearDown()
               gc.collect()
               torch.cuda.empty_cache()
  
  
  
  
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		load_image(
                   """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                   """/paint_by_example/dog_in_bucket.png"""		)
               a_					=		load_image(
                   """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                   """/paint_by_example/mask.png"""		)
               a_					=		load_image(
                   """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                   """/paint_by_example/panda.jpg"""		)
  
               a_					=		PaintByExamplePipeline.from_pretrained("""Fantasy-Studio/Paint-by-Example"""		)
               a_					=		pipe.to(lowerCamelCase__		)
               pipe.set_progress_bar_config(disable=lowerCamelCase__		)
  
               a_					=		torch.manual_seed(321		)
               a_					=		pipe(
                   image=lowerCamelCase__			,    mask_image=lowerCamelCase__			,    example_image=lowerCamelCase__			,    generator=lowerCamelCase__			,    guidance_scale=5.0			,    num_inference_steps=50			,    output_type="""np"""			,    )
  
               a_					=		output.images
  
               a_					=		image[0, -3:, -3:, -1]
  
               assert image.shape == (1, 512, 512, 3)
               a_					=		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 collections.abc import Callable
  
  A_    :					Any             =Callable[[float], float]  # type alias for a real -> real function
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__       ,    UpperCAmelCase__       ,    ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		float(UpperCAmelCase__      )
  						while True:
  												try:
  																		a_					=		prev_guess - function(UpperCAmelCase__      ) / derivative(UpperCAmelCase__      )
  												except ZeroDivisionError:
  																		raise ZeroDivisionError("""Could not find root"""      ) from None
  												if abs(prev_guess - next_guess      ) < 10**-5:
  																		return next_guess
  												a_					=		next_guess
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						return (x**3) - (2 * x) - 5
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						return 3 * (x**2) - 2
  
  
  if __name__ == "__main__":
  	print(newton(f, fa, 3))