





'''simple docstring'''


# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()


class 		UpperCamelCase__     (       a	,	a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






      _snake_case           =				StableDiffusionControlNetInpaintPipeline
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      _snake_case           =				frozenset({'''control_image'''}							)  # skip `image` and `mask` for now, only test for control_image
      _snake_case           =				TEXT_TO_IMAGE_IMAGE_PARAMS




      def 	snake_case  (     self )				->  Optional[Any]:
        torch.manual_seed(0 )
        __lowerCAmelCase		:    int			     =  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     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Union[str, Any]			     =  ControlNetModel(
            block_out_channels=(32, 64)     , layers_per_block=2     , in_channels=4     , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     , cross_attention_dim=32     , conditioning_embedding_out_channels=(16, 32)     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Union[str, Any]			     =  DDIMScheduler(
            beta_start=0.0_0_0_8_5     , beta_end=0.0_1_2     , beta_schedule='scaled_linear'     , clip_sample=SCREAMING_SNAKE_CASE     , set_alpha_to_one=SCREAMING_SNAKE_CASE     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    List[Any]			     =  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 )
        __lowerCAmelCase		:    Optional[Any]			     =  CLIPTextConfig(
            bos_token_id=0     , eos_token_id=2     , hidden_size=32     , intermediate_size=37     , layer_norm_eps=1e-05     , num_attention_heads=4     , num_hidden_layers=5     , pad_token_id=1     , vocab_size=10_00     , )
        __lowerCAmelCase		:    Optional[int]			     =  CLIPTextModel(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Dict			     =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

        __lowerCAmelCase		:    Optional[int]			     =  {
            'unet': unet,
            'controlnet': controlnet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        return components




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE=0 )				->  Dict:
        if str(SCREAMING_SNAKE_CASE ).startswith('mps' ):
          __lowerCAmelCase		:    Union[str, Any]			     =  torch.manual_seed(SCREAMING_SNAKE_CASE )
        else:
          __lowerCAmelCase		:    List[str]			     =  torch.Generator(device=SCREAMING_SNAKE_CASE ).manual_seed(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Optional[Any]			     =  2
        __lowerCAmelCase		:    Dict			     =  randn_tensor(
            (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     , generator=SCREAMING_SNAKE_CASE     , device=torch.device(SCREAMING_SNAKE_CASE )     , )
        __lowerCAmelCase		:    List[str]			     =  floats_tensor((1, 3, 32, 32)     , rng=random.Random(SCREAMING_SNAKE_CASE ) ).to(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Tuple			     =  init_image.cpu().permute(0     , 2     , 3     , 1 )[0]

        __lowerCAmelCase		:    Optional[int]			     =  Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE ) ).convert('RGB' ).resize((64, 64) )
        __lowerCAmelCase		:    Dict			     =  Image.fromarray(np.uinta(init_image + 4 ) ).convert('RGB' ).resize((64, 64) )

        __lowerCAmelCase		:    Tuple			     =  {
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
            'image': image,
            'mask_image': mask_image,
            'control_image': control_image,
        }

        return inputs




      def 	snake_case  (     self )				->  str:
        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3 )




      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()     , reason='XFormers attention is only available with CUDA and `xformers` installed'     , )
      def 	snake_case  (     self )				->  Optional[Any]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )







      def 	snake_case  (     self )				->  Optional[Any]:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3 )



class 		UpperCamelCase__     (       a							):
      '''simple docstring'''






      _snake_case           =				StableDiffusionControlNetInpaintPipeline
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      _snake_case           =				frozenset([]							)




      def 	snake_case  (     self )				->  List[Any]:
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Optional[int]			     =  UNetaDConditionModel(
            block_out_channels=(32, 64)     , layers_per_block=2     , sample_size=32     , in_channels=4     , out_channels=4     , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     , cross_attention_dim=32     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    int			     =  ControlNetModel(
            block_out_channels=(32, 64)     , layers_per_block=2     , in_channels=4     , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     , cross_attention_dim=32     , conditioning_embedding_out_channels=(16, 32)     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Dict			     =  DDIMScheduler(
            beta_start=0.0_0_0_8_5     , beta_end=0.0_1_2     , beta_schedule='scaled_linear'     , clip_sample=SCREAMING_SNAKE_CASE     , set_alpha_to_one=SCREAMING_SNAKE_CASE     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    List[str]			     =  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 )
        __lowerCAmelCase		:    List[Any]			     =  CLIPTextConfig(
            bos_token_id=0     , eos_token_id=2     , hidden_size=32     , intermediate_size=37     , layer_norm_eps=1e-05     , num_attention_heads=4     , num_hidden_layers=5     , pad_token_id=1     , vocab_size=10_00     , )
        __lowerCAmelCase		:    int			     =  CLIPTextModel(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Tuple			     =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

        __lowerCAmelCase		:    List[Any]			     =  {
            'unet': unet,
            'controlnet': controlnet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        return components



class 		UpperCamelCase__     (       a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






      _snake_case           =				StableDiffusionControlNetInpaintPipeline
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      _snake_case           =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS




      def 	snake_case  (     self )				->  Optional[int]:
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Tuple			     =  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     , )
        torch.manual_seed(0 )

        def init_weights(SCREAMING_SNAKE_CASE ):
          if isinstance(SCREAMING_SNAKE_CASE     , torch.nn.Convad ):
            torch.nn.init.normal(m.weight )
            m.bias.data.fill_(1.0 )

        __lowerCAmelCase		:    int			     =  ControlNetModel(
            block_out_channels=(32, 64)     , layers_per_block=2     , in_channels=4     , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     , cross_attention_dim=32     , conditioning_embedding_out_channels=(16, 32)     , )
        controlneta.controlnet_down_blocks.apply(SCREAMING_SNAKE_CASE )

        torch.manual_seed(0 )
        __lowerCAmelCase		:    Optional[int]			     =  ControlNetModel(
            block_out_channels=(32, 64)     , layers_per_block=2     , in_channels=4     , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     , cross_attention_dim=32     , conditioning_embedding_out_channels=(16, 32)     , )
        controlneta.controlnet_down_blocks.apply(SCREAMING_SNAKE_CASE )

        torch.manual_seed(0 )
        __lowerCAmelCase		:    Optional[int]			     =  DDIMScheduler(
            beta_start=0.0_0_0_8_5     , beta_end=0.0_1_2     , beta_schedule='scaled_linear'     , clip_sample=SCREAMING_SNAKE_CASE     , set_alpha_to_one=SCREAMING_SNAKE_CASE     , )
        torch.manual_seed(0 )
        __lowerCAmelCase		:    Optional[int]			     =  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 )
        __lowerCAmelCase		:    Tuple			     =  CLIPTextConfig(
            bos_token_id=0     , eos_token_id=2     , hidden_size=32     , intermediate_size=37     , layer_norm_eps=1e-05     , num_attention_heads=4     , num_hidden_layers=5     , pad_token_id=1     , vocab_size=10_00     , )
        __lowerCAmelCase		:    Any			     =  CLIPTextModel(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Any			     =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

        __lowerCAmelCase		:    str			     =  MultiControlNetModel([controlneta, controlneta] )

        __lowerCAmelCase		:    Union[str, Any]			     =  {
            'unet': unet,
            'controlnet': controlnet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }
        return components




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE=0 )				->  Tuple:
        if str(SCREAMING_SNAKE_CASE ).startswith('mps' ):
          __lowerCAmelCase		:    int			     =  torch.manual_seed(SCREAMING_SNAKE_CASE )
        else:
          __lowerCAmelCase		:    Tuple			     =  torch.Generator(device=SCREAMING_SNAKE_CASE ).manual_seed(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Optional[Any]			     =  2

        __lowerCAmelCase		:    Optional[int]			     =  [
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     , generator=SCREAMING_SNAKE_CASE     , device=torch.device(SCREAMING_SNAKE_CASE )     , ),
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     , generator=SCREAMING_SNAKE_CASE     , device=torch.device(SCREAMING_SNAKE_CASE )     , ),
        ]
        __lowerCAmelCase		:    Optional[int]			     =  floats_tensor((1, 3, 32, 32)     , rng=random.Random(SCREAMING_SNAKE_CASE ) ).to(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Any			     =  init_image.cpu().permute(0     , 2     , 3     , 1 )[0]

        __lowerCAmelCase		:    Optional[int]			     =  Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE ) ).convert('RGB' ).resize((64, 64) )
        __lowerCAmelCase		:    Dict			     =  Image.fromarray(np.uinta(init_image + 4 ) ).convert('RGB' ).resize((64, 64) )

        __lowerCAmelCase		:    List[str]			     =  {
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
            'image': image,
            'mask_image': mask_image,
            'control_image': control_image,
        }

        return inputs




      def 	snake_case  (     self )				->  List[str]:
        __lowerCAmelCase		:    Optional[Any]			     =  self.get_dummy_components()
        __lowerCAmelCase		:    Any			     =  self.pipeline_class(**SCREAMING_SNAKE_CASE )
        pipe.to(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Union[str, Any]			     =  1_0.0
        __lowerCAmelCase		:    int			     =  4

        __lowerCAmelCase		:    Tuple			     =  self.get_dummy_inputs(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Any			     =  steps
        __lowerCAmelCase		:    Union[str, Any]			     =  scale
        __lowerCAmelCase		:    List[Any]			     =  pipe(**SCREAMING_SNAKE_CASE )[0]

        __lowerCAmelCase		:    Dict			     =  self.get_dummy_inputs(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Tuple			     =  steps
        __lowerCAmelCase		:    Optional[Any]			     =  scale
        __lowerCAmelCase		:    Dict			     =  pipe(**SCREAMING_SNAKE_CASE     , control_guidance_start=0.1     , control_guidance_end=0.2 )[0]

        __lowerCAmelCase		:    Any			     =  self.get_dummy_inputs(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    int			     =  steps
        __lowerCAmelCase		:    List[str]			     =  scale
        __lowerCAmelCase		:    List[str]			     =  pipe(**SCREAMING_SNAKE_CASE     , control_guidance_start=[0.1, 0.3]     , control_guidance_end=[0.2, 0.7] )[0]

        __lowerCAmelCase		:    Any			     =  self.get_dummy_inputs(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    List[str]			     =  steps
        __lowerCAmelCase		:    str			     =  scale
        __lowerCAmelCase		:    int			     =  pipe(**SCREAMING_SNAKE_CASE     , control_guidance_start=0.4     , control_guidance_end=[0.5, 0.8] )[0]

        # make sure that all outputs are different
        assert np.sum(np.abs(output_a - output_a ) ) > 1e-3
        assert np.sum(np.abs(output_a - output_a ) ) > 1e-3
        assert np.sum(np.abs(output_a - output_a ) ) > 1e-3




      def 	snake_case  (     self )				->  Optional[int]:
        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3 )




      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()     , reason='XFormers attention is only available with CUDA and `xformers` installed'     , )
      def 	snake_case  (     self )				->  Optional[Any]:
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )




      def 	snake_case  (     self )				->  Union[str, Any]:
        self._test_inference_batch_single_identical(expected_max_diff=2e-3 )







      def 	snake_case  (     self )				->  List[str]:
        __lowerCAmelCase		:    Union[str, Any]			     =  self.get_dummy_components()
        __lowerCAmelCase		:    Optional[int]			     =  self.pipeline_class(**SCREAMING_SNAKE_CASE )
        pipe.to(SCREAMING_SNAKE_CASE )
        pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE )
        with tempfile.TemporaryDirectory() as tmpdir:
          try:
            # save_pretrained is not implemented for Multi-ControlNet
            pipe.save_pretrained(SCREAMING_SNAKE_CASE )
          except NotImplementedError:
            pass



@slow
@require_torch_gpu
class 		UpperCamelCase__     (       unittest.TestCase							):
      '''simple docstring'''






      def 	snake_case  (     self )				->  List[Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()




      def 	snake_case  (     self )				->  Union[str, Any]:
        __lowerCAmelCase		:    Tuple			     =  ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny' )

        __lowerCAmelCase		:    List[Any]			     =  StableDiffusionControlNetInpaintPipeline.from_pretrained(
            'runwayml/stable-diffusion-inpainting'     , safety_checker=SCREAMING_SNAKE_CASE     , controlnet=SCREAMING_SNAKE_CASE )
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    List[Any]			     =  torch.Generator(device='cpu' ).manual_seed(0 )
        __lowerCAmelCase		:    Union[str, Any]			     =  load_image(
            'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png' ).resize((5_12, 5_12) )

        __lowerCAmelCase		:    List[Any]			     =  load_image(
            'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
            '/stable_diffusion_inpaint/input_bench_mask.png' ).resize((5_12, 5_12) )

        __lowerCAmelCase		:    Dict			     =  'pitch black hole'

        __lowerCAmelCase		:    Tuple			     =  load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png' ).resize((5_12, 5_12) )

        __lowerCAmelCase		:    Union[str, Any]			     =  pipe(
            SCREAMING_SNAKE_CASE     , image=SCREAMING_SNAKE_CASE     , mask_image=SCREAMING_SNAKE_CASE     , control_image=SCREAMING_SNAKE_CASE     , generator=SCREAMING_SNAKE_CASE     , output_type='np'     , num_inference_steps=3     , )

        __lowerCAmelCase		:    List[str]			     =  output.images[0]

        assert image.shape == (5_12, 5_12, 3)

        __lowerCAmelCase		:    List[Any]			     =  load_numpy(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy' )

        assert np.abs(expected_image - image ).max() < 9e-2







      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    Optional[Any]			     =  ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint' )

        __lowerCAmelCase		:    Any			     =  StableDiffusionControlNetInpaintPipeline.from_pretrained(
            'runwayml/stable-diffusion-v1-5'     , safety_checker=SCREAMING_SNAKE_CASE     , controlnet=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Dict			     =  DDIMScheduler.from_config(pipe.scheduler.config )
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    List[Any]			     =  torch.Generator(device='cpu' ).manual_seed(33 )

        __lowerCAmelCase		:    Dict			     =  load_image(
            'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png' )
        __lowerCAmelCase		:    Optional[Any]			     =  init_image.resize((5_12, 5_12) )

        __lowerCAmelCase		:    int			     =  load_image(
            'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png' )
        __lowerCAmelCase		:    Optional[int]			     =  mask_image.resize((5_12, 5_12) )

        __lowerCAmelCase		:    Optional[Any]			     =  'a handsome man with ray-ban sunglasses'

        def make_inpaint_condition(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ):
          __lowerCAmelCase		:    Any			     =  np.array(image.convert('RGB' ) ).astype(np.floataa ) / 2_5_5.0
          __lowerCAmelCase		:    int			     =  np.array(image_mask.convert('L' ) ).astype(np.floataa ) / 2_5_5.0

          assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
          __lowerCAmelCase		:    Optional[Any]			     =  -1.0  # set as masked pixel
          __lowerCAmelCase		:    List[Any]			     =  np.expand_dims(SCREAMING_SNAKE_CASE     , 0 ).transpose(0     , 3     , 1     , 2 )
          __lowerCAmelCase		:    List[Any]			     =  torch.from_numpy(SCREAMING_SNAKE_CASE )
          return image

        __lowerCAmelCase		:    List[Any]			     =  make_inpaint_condition(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    List[str]			     =  pipe(
            SCREAMING_SNAKE_CASE     , image=SCREAMING_SNAKE_CASE     , mask_image=SCREAMING_SNAKE_CASE     , control_image=SCREAMING_SNAKE_CASE     , guidance_scale=9.0     , eta=1.0     , generator=SCREAMING_SNAKE_CASE     , num_inference_steps=20     , output_type='np'     , )
        __lowerCAmelCase		:    int			     =  output.images[0]

        assert image.shape == (5_12, 5_12, 3)

        __lowerCAmelCase		:    int			     =  load_numpy(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy' )

        assert np.abs(expected_image - image ).max() < 9e-2












'''simple docstring'''


from typing import Callable




def       A							(      _UpperCAmelCase   :				Callable					)  ->				Dict:


  '''simple docstring'''




  def wrapper(_UpperCAmelCase   :				Optional[Any]					):
    __lowerCAmelCase		:    List[Any]			     =  function_with_docstring.__doc__
    return target_function

  return wrapper





