






import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu



class 							SCREAMING_SNAKE_CASE__		(       unittest.TestCase		):





					"""simple docstring"""






					def  _lowercase  (      self  :						str ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()



					@property
					def  _lowercase  (      self  :						int ):
						snake_case__				:   Any     =						1
						snake_case__				:   Dict     =						3
						snake_case__				:   Union[str, Any]     =						(3_2, 3_2)

						snake_case__				:   Union[str, Any]     =						floats_tensor((batch_size, num_channels) + sizes							,	rng=random.Random(0 ) ).to(__A )
						return image



					@property
					def  _lowercase  (      self  :						List[str] ):
						torch.manual_seed(0 )
						snake_case__				:   List[Any]     =						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							,	)
						return model



					@property
					def  _lowercase  (      self  :						str ):
						torch.manual_seed(0 )
						snake_case__				:   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							,	)
						return model



					@property
					def  _lowercase  (      self  :						Optional[Any] ):
						torch.manual_seed(0 )
						snake_case__				:   List[str]     =						CLIPTextConfig(
						    bos_token_id=0							,	eos_token_id=2							,	hidden_size=3_2							,	intermediate_size=3_7							,	layer_norm_eps=1e-0_5							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1_0_0_0							,	)
						return CLIPTextModel(__A )



					@property
					def  _lowercase  (      self  :						int ):
						def extract(*__A  :						str							,	**__A  :						List[str] ):



							class 							SCREAMING_SNAKE_CASE__		:





												"""simple docstring"""






												def __init__(      self  :						Optional[Any] ):
													snake_case__				:   str     =						torch.ones([0] )






												def  _lowercase  (      self  :						Any							,	__A  :						str ):
													self.pixel_values.to(__A )
													return self
							return Out()

						return extract



					def  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Optional[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
						snake_case__				:   Optional[Any]     =						self.dummy_cond_unet
						snake_case__				:   Optional[Any]     =						DDIMScheduler(
						    beta_start=0.0_0_0_8_5							,	beta_end=0.0_1_2							,	beta_schedule="scaled_linear"							,	clip_sample=__A							,	set_alpha_to_one=__A							,	)

						snake_case__				:   Dict     =						self.dummy_vae
						snake_case__				:   Union[str, Any]     =						self.dummy_text_encoder
						snake_case__				:   Dict     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   Any     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   str     =						"A painting of a squirrel eating a burger"

						snake_case__				:   Optional[int]     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   Optional[Any]     =						sd_pipe([prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np" )
						snake_case__				:   int     =						output.images

						snake_case__				:   Dict     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   int     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np"							,	return_dict=__A							,	)[0]

						snake_case__				:   Tuple     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[Any]     =						image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)
						snake_case__				:   int     =						np.array([0.5_7_5_6, 0.6_1_1_8, 0.5_0_0_5, 0.5_0_4_1, 0.5_4_7_1, 0.4_7_2_6, 0.4_9_7_6, 0.4_8_6_5, 0.4_8_6_4] )

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						Dict ):
						snake_case__				:   List[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
						snake_case__				:   Any     =						self.dummy_cond_unet
						snake_case__				:   List[Any]     =						PNDMScheduler(skip_prk_steps=__A )
						snake_case__				:   List[Any]     =						self.dummy_vae
						snake_case__				:   Tuple     =						self.dummy_text_encoder
						snake_case__				:   Optional[Any]     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   List[str]     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   List[str]     =						"A painting of a squirrel eating a burger"
						snake_case__				:   Union[str, Any]     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   Optional[int]     =						sd_pipe([prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np" )

						snake_case__				:   Tuple     =						output.images

						snake_case__				:   int     =						torch.Generator(device=__A ).manual_seed(0 )
						snake_case__				:   str     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=6.0							,	num_inference_steps=2							,	output_type="np"							,	return_dict=__A							,	)[0]

						snake_case__				:   List[str]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[int]     =						image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)
						snake_case__				:   Dict     =						np.array([0.5_1_2_5, 0.5_7_1_6, 0.4_8_2_8, 0.5_0_6_0, 0.5_6_5_0, 0.4_7_6_8, 0.5_1_8_5, 0.4_8_9_5, 0.4_9_9_3] )

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						str ):
						snake_case__				:   Dict     =						StableDiffusionPipeline.from_pretrained(
						    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"							,	safety_checker=__A )
						assert isinstance(__A							,	__A )
						assert isinstance(pipe.scheduler							,	__A )
						assert pipe.safety_checker is None

						snake_case__				:   List[str]     =						pipe("example prompt"							,	num_inference_steps=2 ).images[0]
						assert image is not None

						# check that there's no error when saving a pipeline with one of the models being None
						with tempfile.TemporaryDirectory() as tmpdirname:
							pipe.save_pretrained(__A )
							snake_case__				:   Optional[int]     =						StableDiffusionPipeline.from_pretrained(__A )

						# sanity check that the pipeline still works
						assert pipe.safety_checker is None
						snake_case__				:   Dict     =						pipe("example prompt"							,	num_inference_steps=2 ).images[0]
						assert image is not None






					@unittest.skipIf(torch_device != "cuda"							,	"This test requires a GPU" )
					def  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Any     =						self.dummy_cond_unet
						snake_case__				:   List[str]     =						PNDMScheduler(skip_prk_steps=__A )
						snake_case__				:   List[Any]     =						self.dummy_vae
						snake_case__				:   Union[str, Any]     =						self.dummy_text_encoder
						snake_case__				:   str     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

						# put models in fp16
						snake_case__				:   List[Any]     =						unet.half()
						snake_case__				:   Dict     =						vae.half()
						snake_case__				:   str     =						bert.half()

						# make sure here that pndm scheduler skips prk
						snake_case__				:   Dict     =						StableDiffusionPipeline(
						    unet=__A							,	scheduler=__A							,	vae=__A							,	text_encoder=__A							,	tokenizer=__A							,	safety_checker=__A							,	feature_extractor=self.dummy_extractor							,	)
						snake_case__				:   Tuple     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   List[str]     =						"A painting of a squirrel eating a burger"
						snake_case__				:   Optional[Any]     =						sd_pipe([prompt]							,	num_inference_steps=2							,	output_type="np" ).images

						assert image.shape == (1, 6_4, 6_4, 3)



@nightly
@require_torch_gpu
class 							SCREAMING_SNAKE_CASE__		(       unittest.TestCase		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Union[str, Any] ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()



					def  _lowercase  (      self  :						List[Any] ):
						snake_case__				:   Dict     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"							,	safety_checker=__A )
						snake_case__				:   Union[str, Any]     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
						snake_case__				:   Dict     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Optional[int]     =						(
						    "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
						    " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
						    " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
						    " children from bahnhof zoo, detailed "
						)
						snake_case__				:   Optional[int]     =						4_0_0_3_6_6_0_3_4_6
						snake_case__				:   Tuple     =						7

						# without safety guidance (sld_guidance_scale = 0)
						snake_case__				:   Optional[Any]     =						torch.manual_seed(__A )
						snake_case__				:   Optional[int]     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   Dict     =						output.images
						snake_case__				:   List[Any]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Tuple     =						[0.2_2_7_8, 0.2_2_3_1, 0.2_2_4_9, 0.2_3_3_3, 0.2_3_0_3, 0.1_8_8_5, 0.2_2_7_3, 0.2_1_4_4, 0.2_1_7_6]

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

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2

						# without safety guidance (strong configuration)
						snake_case__				:   Any     =						torch.manual_seed(__A )
						snake_case__				:   Dict     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   List[str]     =						output.images
						snake_case__				:   Any     =						image[0, -3:, -3:, -1]
						snake_case__				:   str     =						[0.2_3_8_3, 0.2_2_7_6, 0.2_3_6, 0.2_1_9_2, 0.2_1_8_6, 0.2_0_5_3, 0.1_9_7_1, 0.1_9_0_1, 0.1_7_1_9]

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

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2



					def  _lowercase  (      self  :						Tuple ):
						snake_case__				:   Any     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"							,	safety_checker=__A )
						snake_case__				:   Any     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
						snake_case__				:   List[str]     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Optional[Any]     =						"padme amidala taking a bath artwork, safe for work, no nudity"
						snake_case__				:   Any     =						2_7_3_4_9_7_1_7_5_5
						snake_case__				:   List[Any]     =						7

						snake_case__				:   int     =						torch.manual_seed(__A )
						snake_case__				:   Any     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   List[Any]     =						output.images
						snake_case__				:   Optional[int]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Optional[Any]     =						[0.3_5_0_2, 0.3_6_2_2, 0.3_3_9_6, 0.3_6_4_2, 0.3_4_7_8, 0.3_3_1_8, 0.3_5, 0.3_3_4_8, 0.3_2_9_7]

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

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2

						snake_case__				:   Dict     =						torch.manual_seed(__A )
						snake_case__				:   str     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   Optional[int]     =						output.images
						snake_case__				:   Dict     =						image[0, -3:, -3:, -1]
						snake_case__				:   Any     =						[0.5_5_3_1, 0.5_2_0_6, 0.4_8_9_5, 0.5_1_5_6, 0.5_1_8_2, 0.4_7_5_1, 0.4_8_0_2, 0.4_8_0_3, 0.4_4_4_3]

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

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2






					def  _lowercase  (      self  :						int ):
						snake_case__				:   str     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5" )
						snake_case__				:   Any     =						sd_pipe.to(__A )
						sd_pipe.set_progress_bar_config(disable=__A )

						snake_case__				:   Union[str, Any]     =						(
						    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
						    " leyendecker"
						)
						snake_case__				:   Any     =						1_0_4_4_3_5_5_2_3_4
						snake_case__				:   List[str]     =						1_2

						snake_case__				:   Dict     =						torch.manual_seed(__A )
						snake_case__				:   List[str]     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=0							,	)

						snake_case__				:   List[Any]     =						output.images
						snake_case__				:   Any     =						image[0, -3:, -3:, -1]
						snake_case__				:   str     =						np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] )

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

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-7

						snake_case__				:   Tuple     =						torch.manual_seed(__A )
						snake_case__				:   Any     =						sd_pipe(
						    [prompt]							,	generator=__A							,	guidance_scale=__A							,	num_inference_steps=5_0							,	output_type="np"							,	width=5_1_2							,	height=5_1_2							,	sld_guidance_scale=2_0_0_0							,	sld_warmup_steps=7							,	sld_threshold=0.0_2_5							,	sld_momentum_scale=0.5							,	sld_mom_beta=0.7							,	)

						snake_case__				:   Optional[Any]     =						output.images
						snake_case__				:   Union[str, Any]     =						image[0, -3:, -3:, -1]
						snake_case__				:   Any     =						np.array([0.5_8_1_8, 0.6_2_8_5, 0.6_8_3_5, 0.6_0_1_9, 0.6_2_5, 0.6_7_5_4, 0.6_0_9_6, 0.6_3_3_4, 0.6_5_6_1] )
						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2











def   SCREAMING_SNAKE_CASE       (				snake_case_      :							list     ):
	if len(snake_case_     ) <= 1:
		return lst

	snake_case__				:   List[Any]     =						1

	while i < len(snake_case_     ):
		if lst[i - 1] <= lst[i]:
			i += 1
		else:
			snake_case__,		snake_case__				:   Tuple     =						lst[i], lst[i - 1]
			i -= 1
			if i == 0:
				snake_case__				:   Union[str, Any]     =						1

	return lst


if __name__ == "__main__":
	__lowerCamelCase      :    Dict   		=   input("""Enter numbers separated by a comma:\n""").strip()
	__lowerCamelCase      :    Tuple   		=   [int(item) for item in user_input.split(""",""")]
	print(gnome_sort(unsorted))



