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 	_lowercase		(      lowerCamelCase_		,   lowerCamelCase_		,   lowerCamelCase_		,   unittest.TestCase ):
 lowercase         =     StableDiffusionControlNetInpaintPipeline
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 lowercase         =     frozenset({'control_image'} )  # skip `image` and `mask` for now, only test for control_image
 lowercase         =     TEXT_TO_IMAGE_IMAGE_PARAMS

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Union[str, Any]    )     ->		Optional[Any]:

  """simple docstring"""





  torch.manual_seed(0    )
  UpperCamelCase_      :		int				=      UNetaDConditionModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   sample_size=3_2     ,   in_channels=9     ,   out_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     ,   cross_attention_dim=3_2     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Union[str, Any]				=      ControlNetModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   in_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   cross_attention_dim=3_2     ,   conditioning_embedding_out_channels=(1_6, 3_2)     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[Any]				=      DDIMScheduler(
      beta_start=0.00085     ,   beta_end=0.012     ,   beta_schedule='scaled_linear'     ,   clip_sample=snake_case     ,   set_alpha_to_one=snake_case     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[int]				=      AutoencoderKL(
      block_out_channels=[3_2, 6_4]     ,   in_channels=3     ,   out_channels=3     ,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']     ,   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']     ,   latent_channels=4     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[Any]				=      CLIPTextConfig(
      bos_token_id=0     ,   eos_token_id=2     ,   hidden_size=3_2     ,   intermediate_size=3_7     ,   layer_norm_eps=1e-05     ,   num_attention_heads=4     ,   num_hidden_layers=5     ,   pad_token_id=1     ,   vocab_size=1_0_0_0     ,   )
  UpperCamelCase_      :		int				=      CLIPTextModel(snake_case    )
  UpperCamelCase_      :		Optional[int]				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

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

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Union[str, Any]     ,   snake_case			:							int     ,   snake_case			:							int=0    )     ->		int:

  """simple docstring"""





  if str(snake_case    ).startswith('mps'    ):
   UpperCamelCase_      :		Optional[int]				=      torch.manual_seed(snake_case    )
  else:
   UpperCamelCase_      :		str				=      torch.Generator(device=snake_case    ).manual_seed(snake_case    )

  UpperCamelCase_      :		Dict				=      2
  UpperCamelCase_      :		List[Any]				=      randn_tensor(
      (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)     ,   generator=snake_case     ,   device=torch.device(snake_case    )     ,   )
  UpperCamelCase_      :		Optional[int]				=      floats_tensor((1, 3, 3_2, 3_2)     ,   rng=random.Random(snake_case    )    ).to(snake_case    )
  UpperCamelCase_      :		str				=      init_image.cpu().permute(0     ,   2     ,   3     ,   1    )[0]

  UpperCamelCase_      :		Union[str, Any]				=      Image.fromarray(np.uinta(snake_case    )    ).convert('RGB'    ).resize((6_4, 6_4)    )
  UpperCamelCase_      :		Union[str, Any]				=      Image.fromarray(np.uinta(init_image + 4    )    ).convert('RGB'    ).resize((6_4, 6_4)    )

  UpperCamelCase_      :		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 		SCREAMING_SNAKE_CASE__     (				self			:							int    )     ->		Optional[Any]:

  """simple docstring"""





  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 		SCREAMING_SNAKE_CASE__     (				self			:							str    )     ->		Optional[int]:

  """simple docstring"""





  self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3    )


 def 		SCREAMING_SNAKE_CASE__     (				self			:							Optional[Any]    )     ->		List[str]:

  """simple docstring"""





  self._test_inference_batch_single_identical(expected_max_diff=2e-3    )





class 	_lowercase		(      lowerCamelCase_ ):
 lowercase         =     StableDiffusionControlNetInpaintPipeline
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 lowercase         =     frozenset([] )

 def 		SCREAMING_SNAKE_CASE__     (				self			:							str    )     ->		List[str]:

  """simple docstring"""





  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[int]				=      UNetaDConditionModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   sample_size=3_2     ,   in_channels=4     ,   out_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     ,   cross_attention_dim=3_2     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[int]				=      ControlNetModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   in_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   cross_attention_dim=3_2     ,   conditioning_embedding_out_channels=(1_6, 3_2)     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[int]				=      DDIMScheduler(
      beta_start=0.00085     ,   beta_end=0.012     ,   beta_schedule='scaled_linear'     ,   clip_sample=snake_case     ,   set_alpha_to_one=snake_case     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Dict				=      AutoencoderKL(
      block_out_channels=[3_2, 6_4]     ,   in_channels=3     ,   out_channels=3     ,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']     ,   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']     ,   latent_channels=4     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		int				=      CLIPTextConfig(
      bos_token_id=0     ,   eos_token_id=2     ,   hidden_size=3_2     ,   intermediate_size=3_7     ,   layer_norm_eps=1e-05     ,   num_attention_heads=4     ,   num_hidden_layers=5     ,   pad_token_id=1     ,   vocab_size=1_0_0_0     ,   )
  UpperCamelCase_      :		Any				=      CLIPTextModel(snake_case    )
  UpperCamelCase_      :		str				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

  UpperCamelCase_      :		int				=      {
      "unet": unet,
      "controlnet": controlnet,
      "scheduler": scheduler,
      "vae": vae,
      "text_encoder": text_encoder,
      "tokenizer": tokenizer,
      "safety_checker": None,
      "feature_extractor": None,
  }
  return components





class 	_lowercase		(      lowerCamelCase_		,   lowerCamelCase_		,   unittest.TestCase ):
 lowercase         =     StableDiffusionControlNetInpaintPipeline
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
 lowercase         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS

 def 		SCREAMING_SNAKE_CASE__     (				self			:							List[str]    )     ->		Any:

  """simple docstring"""





  torch.manual_seed(0    )
  UpperCamelCase_      :		Any				=      UNetaDConditionModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   sample_size=3_2     ,   in_channels=9     ,   out_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     ,   cross_attention_dim=3_2     ,   )
  torch.manual_seed(0    )

  def init_weights(snake_case			:							Union[str, Any]    ):
   if isinstance(snake_case     ,   torch.nn.Convad    ):
    torch.nn.init.normal(m.weight    )
    m.bias.data.fill_(1.0    )

  UpperCamelCase_      :		Tuple				=      ControlNetModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   in_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   cross_attention_dim=3_2     ,   conditioning_embedding_out_channels=(1_6, 3_2)     ,   )
  controlneta.controlnet_down_blocks.apply(snake_case    )

  torch.manual_seed(0    )
  UpperCamelCase_      :		Any				=      ControlNetModel(
      block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   in_channels=4     ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,   cross_attention_dim=3_2     ,   conditioning_embedding_out_channels=(1_6, 3_2)     ,   )
  controlneta.controlnet_down_blocks.apply(snake_case    )

  torch.manual_seed(0    )
  UpperCamelCase_      :		str				=      DDIMScheduler(
      beta_start=0.00085     ,   beta_end=0.012     ,   beta_schedule='scaled_linear'     ,   clip_sample=snake_case     ,   set_alpha_to_one=snake_case     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		int				=      AutoencoderKL(
      block_out_channels=[3_2, 6_4]     ,   in_channels=3     ,   out_channels=3     ,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']     ,   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']     ,   latent_channels=4     ,   )
  torch.manual_seed(0    )
  UpperCamelCase_      :		Optional[Any]				=      CLIPTextConfig(
      bos_token_id=0     ,   eos_token_id=2     ,   hidden_size=3_2     ,   intermediate_size=3_7     ,   layer_norm_eps=1e-05     ,   num_attention_heads=4     ,   num_hidden_layers=5     ,   pad_token_id=1     ,   vocab_size=1_0_0_0     ,   )
  UpperCamelCase_      :		List[Any]				=      CLIPTextModel(snake_case    )
  UpperCamelCase_      :		int				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

  UpperCamelCase_      :		Tuple				=      MultiControlNetModel([controlneta, controlneta]    )

  UpperCamelCase_      :		List[str]				=      {
      "unet": unet,
      "controlnet": controlnet,
      "scheduler": scheduler,
      "vae": vae,
      "text_encoder": text_encoder,
      "tokenizer": tokenizer,
      "safety_checker": None,
      "feature_extractor": None,
  }
  return components

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Dict     ,   snake_case			:							Union[str, Any]     ,   snake_case			:							Union[str, Any]=0    )     ->		Tuple:

  """simple docstring"""





  if str(snake_case    ).startswith('mps'    ):
   UpperCamelCase_      :		int				=      torch.manual_seed(snake_case    )
  else:
   UpperCamelCase_      :		List[str]				=      torch.Generator(device=snake_case    ).manual_seed(snake_case    )

  UpperCamelCase_      :		Optional[Any]				=      2

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

  UpperCamelCase_      :		List[Any]				=      Image.fromarray(np.uinta(snake_case    )    ).convert('RGB'    ).resize((6_4, 6_4)    )
  UpperCamelCase_      :		str				=      Image.fromarray(np.uinta(init_image + 4    )    ).convert('RGB'    ).resize((6_4, 6_4)    )

  UpperCamelCase_      :		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 		SCREAMING_SNAKE_CASE__     (				self			:							Any    )     ->		Any:

  """simple docstring"""





  UpperCamelCase_      :		Optional[Any]				=      self.get_dummy_components()
  UpperCamelCase_      :		int				=      self.pipeline_class(**snake_case    )
  pipe.to(snake_case    )

  UpperCamelCase_      :		List[Any]				=      10.0
  UpperCamelCase_      :		str				=      4

  UpperCamelCase_      :		Tuple				=      self.get_dummy_inputs(snake_case    )
  UpperCamelCase_      :		Optional[int]				=      steps
  UpperCamelCase_      :		Any				=      scale
  UpperCamelCase_      :		Union[str, Any]				=      pipe(**snake_case    )[0]

  UpperCamelCase_      :		str				=      self.get_dummy_inputs(snake_case    )
  UpperCamelCase_      :		Optional[Any]				=      steps
  UpperCamelCase_      :		Optional[Any]				=      scale
  UpperCamelCase_      :		Dict				=      pipe(**snake_case     ,   control_guidance_start=0.1     ,   control_guidance_end=0.2    )[0]

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

  UpperCamelCase_      :		Union[str, Any]				=      self.get_dummy_inputs(snake_case    )
  UpperCamelCase_      :		Dict				=      steps
  UpperCamelCase_      :		Optional[int]				=      scale
  UpperCamelCase_      :		Union[str, Any]				=      pipe(**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 		SCREAMING_SNAKE_CASE__     (				self			:							Union[str, Any]    )     ->		Optional[int]:

  """simple docstring"""





  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 		SCREAMING_SNAKE_CASE__     (				self			:							Optional[int]    )     ->		Optional[Any]:

  """simple docstring"""





  self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3    )

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Union[str, Any]    )     ->		Optional[int]:

  """simple docstring"""





  self._test_inference_batch_single_identical(expected_max_diff=2e-3    )


 def 		SCREAMING_SNAKE_CASE__     (				self			:							int    )     ->		Optional[Any]:

  """simple docstring"""





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





@slow
@require_torch_gpu
class 	_lowercase		(      unittest.TestCase ):

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		Any:

  """simple docstring"""





  super().tearDown()
  gc.collect()
  torch.cuda.empty_cache()

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		Optional[int]:

  """simple docstring"""





  UpperCamelCase_      :		Union[str, Any]				=      ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'    )

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

  UpperCamelCase_      :		Optional[int]				=      torch.Generator(device='cpu'    ).manual_seed(0    )
  UpperCamelCase_      :		int				=      load_image(
      'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'    ).resize((5_1_2, 5_1_2)    )

  UpperCamelCase_      :		int				=      load_image(
      'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
      '/stable_diffusion_inpaint/input_bench_mask.png'    ).resize((5_1_2, 5_1_2)    )

  UpperCamelCase_      :		Tuple				=      "pitch black hole"

  UpperCamelCase_      :		Optional[int]				=      load_image(
      'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'    ).resize((5_1_2, 5_1_2)    )

  UpperCamelCase_      :		Optional[Any]				=      pipe(
      snake_case     ,   image=snake_case     ,   mask_image=snake_case     ,   control_image=snake_case     ,   generator=snake_case     ,   output_type='np'     ,   num_inference_steps=3     ,   )

  UpperCamelCase_      :		Optional[Any]				=      output.images[0]

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

  UpperCamelCase_      :		Union[str, 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 		SCREAMING_SNAKE_CASE__     (				self			:							Any    )     ->		Dict:

  """simple docstring"""





  UpperCamelCase_      :		int				=      ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint'    )

  UpperCamelCase_      :		Tuple				=      StableDiffusionControlNetInpaintPipeline.from_pretrained(
      'runwayml/stable-diffusion-v1-5'     ,   safety_checker=snake_case     ,   controlnet=snake_case    )
  UpperCamelCase_      :		Tuple				=      DDIMScheduler.from_config(pipe.scheduler.config    )
  pipe.enable_model_cpu_offload()
  pipe.set_progress_bar_config(disable=snake_case    )

  UpperCamelCase_      :		List[str]				=      torch.Generator(device='cpu'    ).manual_seed(3_3    )

  UpperCamelCase_      :		Any				=      load_image(
      'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'    )
  UpperCamelCase_      :		List[str]				=      init_image.resize((5_1_2, 5_1_2)    )

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

  UpperCamelCase_      :		int				=      "a handsome man with ray-ban sunglasses"

  def make_inpaint_condition(snake_case			:							Union[str, Any]     ,   snake_case			:							List[Any]    ):
   UpperCamelCase_      :		Optional[int]				=      np.array(image.convert('RGB'    )    ).astype(np.floataa    ) / 2_5_5.0
   UpperCamelCase_      :		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"
   UpperCamelCase_      :		Union[str, Any]				=      -1.0  # set as masked pixel
   UpperCamelCase_      :		List[str]				=      np.expand_dims(snake_case     ,   0    ).transpose(0     ,   3     ,   1     ,   2    )
   UpperCamelCase_      :		Optional[Any]				=      torch.from_numpy(snake_case    )
   return image

  UpperCamelCase_      :		Any				=      make_inpaint_condition(snake_case     ,   snake_case    )

  UpperCamelCase_      :		List[Any]				=      pipe(
      snake_case     ,   image=snake_case     ,   mask_image=snake_case     ,   control_image=snake_case     ,   guidance_scale=9.0     ,   eta=1.0     ,   generator=snake_case     ,   num_inference_steps=2_0     ,   output_type='np'     ,   )
  UpperCamelCase_      :		Optional[Any]				=      output.images[0]

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

  UpperCamelCase_      :		Tuple				=      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




from __future__ import annotations

from collections import deque
from queue import Queue
from timeit import timeit

a_					      = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E'],
}





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Tuple				=      {start}
 UpperCamelCase_      :		Optional[Any]				=      [start]
 UpperCamelCase_      :		Queue				=      Queue()
 queue.put(lowerCamelCase			)
 while not queue.empty():
  UpperCamelCase_      :		Union[str, Any]				=      queue.get()
  for w in graph[v]:
   if w not in explored:
    explored.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.put(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Dict				=      {start}
 UpperCamelCase_      :		Optional[int]				=      [start]
 UpperCamelCase_      :		Union[str, Any]				=      deque([start]			)
 while queue:
  UpperCamelCase_      :		Optional[int]				=      queue.popleft()
  for child in graph[v]:
   if child not in visited:
    visited.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.append(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  str			):
 UpperCamelCase_      :		str				=      F"from __main__ import G, {name}"
 UpperCamelCase_      :		int				=      10000
 UpperCamelCase_      :		Optional[Any]				=      timeit(F"{name}(G, 'A')"						,						setup=lowerCamelCase						,						number=lowerCamelCase			)
 print(F"{name:<35} finished {number} runs in {res:.5f} seconds"			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   benchmark_function('breadth_first_search')
   benchmark_function('breadth_first_search_with_deque')
   # breadth_first_search                finished 10000 runs in 0.20999 seconds
   # breadth_first_search_with_deque     finished 10000 runs in 0.01421 seconds



