

"""simple docstring"""





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        SCREAMING_SNAKE_CASE      (	lowerCamelCase_					,							lowerCamelCase_					,							lowerCamelCase_					,							unittest.TestCase ):






					"""simple docstring"""



					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  __lowerCAmelCase				( self    :       Union[str, Any]	):
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		Optional[Any]						       =			DDIMScheduler(
						    beta_start=0.0_0085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=lowercase_     ,set_alpha_to_one=lowercase_     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		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     ,)
						lowerCAmelCase__			:		int						       =			CLIPTextModel(lowercase_	)
						lowerCAmelCase__			:		Optional[int]						       =			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







					def  __lowerCAmelCase				( self    :       int     ,lowercase_    :       Optional[int]     ,lowercase_    :       Union[str, Any]=0	):







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

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

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

						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  __lowerCAmelCase				( self    :       Optional[Any]	):
						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  __lowerCAmelCase				( self    :       Any	):
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3	)







					def  __lowerCAmelCase				( self    :       int	):
						self._test_inference_batch_single_identical(expected_max_diff=2E-3	)







class        SCREAMING_SNAKE_CASE      (	lowerCamelCase_ ):






					"""simple docstring"""



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







					def  __lowerCAmelCase				( self    :       List[Any]	):
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		Optional[int]						       =			DDIMScheduler(
						    beta_start=0.0_0085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=lowercase_     ,set_alpha_to_one=lowercase_     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		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     ,)
						lowerCAmelCase__			:		Any						       =			CLIPTextModel(lowercase_	)
						lowerCAmelCase__			:		str						       =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

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







class        SCREAMING_SNAKE_CASE      (	lowerCamelCase_					,							lowerCamelCase_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= StableDiffusionControlNetInpaintPipeline
					lowercase__       				= TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
					lowercase__       				= TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS







					def  __lowerCAmelCase				( self    :       Tuple	):
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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(lowercase_    :       Union[str, Any]	):
							if isinstance(lowercase_     ,torch.nn.Convad	):
								torch.nn.init.normal(m.weight	)
								m.bias.data.fill_(1.0	)

						lowerCAmelCase__			:		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(lowercase_	)

						torch.manual_seed(0	)
						lowerCAmelCase__			:		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(lowercase_	)

						torch.manual_seed(0	)
						lowerCAmelCase__			:		str						       =			DDIMScheduler(
						    beta_start=0.0_0085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=lowercase_     ,set_alpha_to_one=lowercase_     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		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	)
						lowerCAmelCase__			:		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     ,)
						lowerCAmelCase__			:		List[Any]						       =			CLIPTextModel(lowercase_	)
						lowerCAmelCase__			:		int						       =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

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

						lowerCAmelCase__			:		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  __lowerCAmelCase				( self    :       str     ,lowercase_    :       str     ,lowercase_    :       Union[str, Any]=0	):







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

						lowerCAmelCase__			:		Optional[Any]						       =			2

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

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

						lowerCAmelCase__			:		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  __lowerCAmelCase				( self    :       str	):
						lowerCAmelCase__			:		Optional[Any]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		int						       =			self.pipeline_class(**lowercase_	)
						pipe.to(lowercase_	)

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

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

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

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

						lowerCAmelCase__			:		Union[str, Any]						       =			self.get_dummy_inputs(lowercase_	)
						lowerCAmelCase__			:		Dict						       =			steps
						lowerCAmelCase__			:		Optional[int]						       =			scale
						lowerCAmelCase__			:		Union[str, Any]						       =			pipe(**lowercase_     ,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  __lowerCAmelCase				( self    :       Optional[Any]	):
						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  __lowerCAmelCase				( self    :       List[str]	):
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3	)







					def  __lowerCAmelCase				( self    :       Any	):
						self._test_inference_batch_single_identical(expected_max_diff=2E-3	)







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







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






					"""simple docstring"""



					def  __lowerCAmelCase				( self    :       Optional[int]	):
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()







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

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

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

						lowerCAmelCase__			:		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)	)

						lowerCAmelCase__			:		Tuple						       =			"pitch black hole"

						lowerCAmelCase__			:		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)	)

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

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

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

						lowerCAmelCase__			:		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  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__			:		int						       =			ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''	)

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

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

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

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

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

						def make_inpaint_condition(lowercase_    :       int     ,lowercase_    :       Optional[Any]	):
							lowerCAmelCase__			:		Optional[int]						       =			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__			:		Union[str, Any]						       =			-1.0  # set as masked pixel
							lowerCAmelCase__			:		List[str]						       =			np.expand_dims(lowercase_     ,0	).transpose(0     ,3     ,1     ,2	)
							lowerCAmelCase__			:		Optional[Any]						       =			torch.from_numpy(lowercase_	)
							return image

						lowerCAmelCase__			:		Any						       =			make_inpaint_condition(lowercase_     ,lowercase_	)

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

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

						lowerCAmelCase__			:		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







"""simple docstring"""





def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		List[Any]						       =			53_81
	for x in s:
		lowerCAmelCase__			:		Tuple						       =			((hash_value << 5) + hash_value) + ord(A_				)
	return hash_value & 0Xf_f_f_f_f_f_f_f




