

"""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     (						lowerCamelCase__      ,       lowerCamelCase__      ,       lowerCamelCase__      ,       unittest.TestCase):
			__a	:    str			   =							StableDiffusionControlNetInpaintPipeline
			__a	:    Any			   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a	:    Optional[int]			   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			__a	:    Tuple			   =							frozenset({"""control_image"""})  # skip `image` and `mask` for now, only test for control_image
			__a	:    List[str]			   =							TEXT_TO_IMAGE_IMAGE_PARAMS
			def 							__snake_case	(						self       )      ->      Any:






					'''simple docstring'''







					torch.manual_seed(0       )
					_UpperCAmelCase      :							Optional[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       )
					_UpperCAmelCase      :							Dict       =   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       )
					_UpperCAmelCase      :							int       =   DDIMScheduler(
					    beta_start=0.00085 ,						beta_end=0.012 ,						beta_schedule="""scaled_linear""" ,						clip_sample=lowercase_ ,						set_alpha_to_one=lowercase_ ,						)
					torch.manual_seed(0       )
					_UpperCAmelCase      :							Tuple       =   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      :							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 ,						)
					_UpperCAmelCase      :							List[str]       =   CLIPTextModel(lowercase_       )
					_UpperCAmelCase      :							Dict       =   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
			def 							__snake_case	(						self ,						_A ,						_A=0       )      ->      Dict:






					'''simple docstring'''







					if str(lowercase_       ).startswith("""mps"""       ):
							_UpperCAmelCase      :							Tuple       =   torch.manual_seed(lowercase_       )
					else:
							_UpperCAmelCase      :							Tuple       =   torch.Generator(device=lowercase_       ).manual_seed(lowercase_       )

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

					_UpperCAmelCase      :							List[Any]       =   Image.fromarray(np.uinta(lowercase_       )       ).convert("""RGB"""       ).resize((64, 64)       )
					_UpperCAmelCase      :							List[str]       =   Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

					_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 							__snake_case	(						self       )      ->      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 							__snake_case	(						self       )      ->      List[str]:






					'''simple docstring'''







					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )
			def 							__snake_case	(						self       )      ->      List[str]:






					'''simple docstring'''







					self._test_inference_batch_single_identical(expected_max_diff=2e-3       )






class       _UpperCAmelCase     (						lowerCamelCase__):
			__a	:    int			   =							StableDiffusionControlNetInpaintPipeline
			__a	:    str			   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a	:    Optional[int]			   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			__a	:    Optional[int]			   =							frozenset([])
			def 							__snake_case	(						self       )      ->      List[Any]:






					'''simple docstring'''







					torch.manual_seed(0       )
					_UpperCAmelCase      :							Dict       =   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       )
					_UpperCAmelCase      :							List[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       )
					_UpperCAmelCase      :							List[str]       =   DDIMScheduler(
					    beta_start=0.00085 ,						beta_end=0.012 ,						beta_schedule="""scaled_linear""" ,						clip_sample=lowercase_ ,						set_alpha_to_one=lowercase_ ,						)
					torch.manual_seed(0       )
					_UpperCAmelCase      :							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       )
					_UpperCAmelCase      :							str       =   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 ,						)
					_UpperCAmelCase      :							str       =   CLIPTextModel(lowercase_       )
					_UpperCAmelCase      :							List[str]       =   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






class       _UpperCAmelCase     (						lowerCamelCase__      ,       lowerCamelCase__      ,       unittest.TestCase):
			__a	:    Dict			   =							StableDiffusionControlNetInpaintPipeline
			__a	:    Tuple			   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			__a	:    Union[str, Any]			   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			def 							__snake_case	(						self       )      ->      Optional[Any]:






					'''simple docstring'''







					torch.manual_seed(0       )
					_UpperCAmelCase      :							Optional[Any]       =   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(_A       ):
							if isinstance(lowercase_ ,						torch.nn.Convad       ):
									torch.nn.init.normal(m.weight       )
									m.bias.data.fill_(1.0       )

					_UpperCAmelCase      :							List[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) ,						)
					controlneta.controlnet_down_blocks.apply(lowercase_       )

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

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

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

					_UpperCAmelCase      :							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 ,						_A ,						_A=0       )      ->      str:






					'''simple docstring'''







					if str(lowercase_       ).startswith("""mps"""       ):
							_UpperCAmelCase      :							int       =   torch.manual_seed(lowercase_       )
					else:
							_UpperCAmelCase      :							List[Any]       =   torch.Generator(device=lowercase_       ).manual_seed(lowercase_       )

					_UpperCAmelCase      :							Union[str, Any]       =   2

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

					_UpperCAmelCase      :							List[str]       =   Image.fromarray(np.uinta(lowercase_       )       ).convert("""RGB"""       ).resize((64, 64)       )
					_UpperCAmelCase      :							Optional[Any]       =   Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

					_UpperCAmelCase      :							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       )      ->      Optional[int]:






					'''simple docstring'''







					_UpperCAmelCase      :							Any       =   self.get_dummy_components()
					_UpperCAmelCase      :							Optional[Any]       =   self.pipeline_class(**lowercase_       )
					pipe.to(lowercase_       )

					_UpperCAmelCase      :							Dict       =   10.0
					_UpperCAmelCase      :							Any       =   4

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

					_UpperCAmelCase      :							Tuple       =   self.get_dummy_inputs(lowercase_       )
					_UpperCAmelCase      :							Optional[int]       =   steps
					_UpperCAmelCase      :							Optional[Any]       =   scale
					_UpperCAmelCase      :							int       =   pipe(**lowercase_ ,						control_guidance_start=0.1 ,						control_guidance_end=0.2       )[0]

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

					_UpperCAmelCase      :							int       =   self.get_dummy_inputs(lowercase_       )
					_UpperCAmelCase      :							Dict       =   steps
					_UpperCAmelCase      :							Optional[int]       =   scale
					_UpperCAmelCase      :							int       =   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 							__snake_case	(						self       )      ->      List[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 							__snake_case	(						self       )      ->      Dict:






					'''simple docstring'''







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






					'''simple docstring'''







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






					'''simple docstring'''







					_UpperCAmelCase      :							List[str]       =   self.get_dummy_components()
					_UpperCAmelCase      :							Optional[int]       =   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       _UpperCAmelCase     (						unittest.TestCase):
			def 							__snake_case	(						self       )      ->      Optional[Any]:






					'''simple docstring'''







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






					'''simple docstring'''







					_UpperCAmelCase      :							List[str]       =   ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""       )

					_UpperCAmelCase      :							Tuple       =   StableDiffusionControlNetInpaintPipeline.from_pretrained(
					    """runwayml/stable-diffusion-inpainting""" ,						safety_checker=lowercase_ ,						controlnet=lowercase_       )
					pipe.enable_model_cpu_offload()
					pipe.set_progress_bar_config(disable=lowercase_       )

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

					_UpperCAmelCase      :							str       =   load_image(
					    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
					    """/stable_diffusion_inpaint/input_bench_mask.png"""       ).resize((5_12, 5_12)       )

					_UpperCAmelCase      :							Union[str, Any]       =   """pitch black hole"""

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

					_UpperCAmelCase      :							Optional[int]       =   pipe(
					    lowercase_ ,						image=lowercase_ ,						mask_image=lowercase_ ,						control_image=lowercase_ ,						generator=lowercase_ ,						output_type="""np""" ,						num_inference_steps=3 ,						)

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

					assert image.shape == (5_12, 5_12, 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 							__snake_case	(						self       )      ->      List[Any]:






					'''simple docstring'''







					_UpperCAmelCase      :							Any       =   ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""       )

					_UpperCAmelCase      :							str       =   StableDiffusionControlNetInpaintPipeline.from_pretrained(
					    """runwayml/stable-diffusion-v1-5""" ,						safety_checker=lowercase_ ,						controlnet=lowercase_       )
					_UpperCAmelCase      :							Dict       =   DDIMScheduler.from_config(pipe.scheduler.config       )
					pipe.enable_model_cpu_offload()
					pipe.set_progress_bar_config(disable=lowercase_       )

					_UpperCAmelCase      :							Dict       =   torch.Generator(device="""cpu"""       ).manual_seed(33       )

					_UpperCAmelCase      :							Any       =   load_image(
					    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""       )
					_UpperCAmelCase      :							Any       =   init_image.resize((5_12, 5_12)       )

					_UpperCAmelCase      :							List[str]       =   load_image(
					    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""       )
					_UpperCAmelCase      :							Optional[Any]       =   mask_image.resize((5_12, 5_12)       )

					_UpperCAmelCase      :							Dict       =   """a handsome man with ray-ban sunglasses"""

					def make_inpaint_condition(_A ,						_A       ):
							_UpperCAmelCase      :							Dict       =   np.array(image.convert("""RGB"""       )       ).astype(np.floataa       ) / 255.0
							_UpperCAmelCase      :							Union[str, Any]       =   np.array(image_mask.convert("""L"""       )       ).astype(np.floataa       ) / 255.0

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

					_UpperCAmelCase      :							Optional[Any]       =   make_inpaint_condition(lowercase_ ,						lowercase_       )

					_UpperCAmelCase      :							Any       =   pipe(
					    lowercase_ ,						image=lowercase_ ,						mask_image=lowercase_ ,						control_image=lowercase_ ,						guidance_scale=9.0 ,						eta=1.0 ,						generator=lowercase_ ,						num_inference_steps=20 ,						output_type="""np""" ,						)
					_UpperCAmelCase      :							Optional[int]       =   output.images[0]

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

					_UpperCAmelCase      :							Any       =   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  UpperCamelCase   (     _lowerCAmelCase       :  int	)			->     str:
	_UpperCAmelCase      :							Any       =   len(_lowerCAmelCase	)
	for _ in range(
	    0,					int(((no_of_elements - 1) / 2) + 1	)	):  # we don't need to traverse to end of list as
		for j in range(0,					no_of_elements - 1	):
			if (
			    lst[j + 1] < lst[j]
			):  # applying bubble sort algorithm from left to right (or forwards)
				_UpperCAmelCase      :							List[str]       =   lst[j + 1]
				_UpperCAmelCase      :							Optional[int]       =   lst[j]
				_UpperCAmelCase      :							Optional[int]       =   temp
			if (
			    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
			):  # applying bubble sort algorithm from right to left (or backwards)
				_UpperCAmelCase      :							Any       =   lst[no_of_elements - 1 - j]
				_UpperCAmelCase      :							Optional[Any]       =   lst[no_of_elements - 2 - j]
				_UpperCAmelCase      :							Optional[Any]       =   temp
	return lst


if __name__ == "__main__":
						print('''enter the list to be sorted''')
						lowerCamelCase__			:					List[str]							  =					[int(x) for x in input().split()]  # inputing elements of the list in one line
						lowerCamelCase__			:					int							  =					double_sort(lst)
						print('''the sorted list is''')
						print(sorted_lst)





