

"""simple docstring"""






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class       _UpperCAmelCase     (						__a      ,       __a      ,       unittest.TestCase):
			__a	:    Dict			   =							StableDiffusionParadigmsPipeline
			__a	:    str			   =							TEXT_TO_IMAGE_PARAMS
			__a	:    List[str]			   =							TEXT_TO_IMAGE_BATCH_PARAMS
			__a	:    Optional[Any]			   =							TEXT_TO_IMAGE_IMAGE_PARAMS
			__a	:    str			   =							TEXT_TO_IMAGE_IMAGE_PARAMS
			def 							__snake_case	(						self       )      ->      Optional[int]:






					'''simple docstring'''







					torch.manual_seed(0       )
					_UpperCAmelCase      :							str       =   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 ,						attention_head_dim=(2, 4) ,						use_linear_projection=_A ,						)
					_UpperCAmelCase      :							List[Any]       =   DDIMParallelScheduler(
					    beta_start=0.00085 ,						beta_end=0.012 ,						beta_schedule="""scaled_linear""" ,						clip_sample=_A ,						set_alpha_to_one=_A ,						)
					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 ,						sample_size=1_28 ,						)
					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 ,						hidden_act="""gelu""" ,						projection_dim=5_12 ,						)
					_UpperCAmelCase      :							str       =   CLIPTextModel(_A       )
					_UpperCAmelCase      :							Optional[Any]       =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

					_UpperCAmelCase      :							int       =   {
					    """unet""": unet,
					    """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(_A       ).startswith("""mps"""       ):
							_UpperCAmelCase      :							str       =   torch.manual_seed(_A       )
					else:
							_UpperCAmelCase      :							Any       =   torch.Generator(device=_A       ).manual_seed(_A       )
					_UpperCAmelCase      :							Union[str, Any]       =   {
					    """prompt""": """a photograph of an astronaut riding a horse""",
					    """generator""": generator,
					    """num_inference_steps""": 10,
					    """guidance_scale""": 6.0,
					    """output_type""": """numpy""",
					    """parallel""": 3,
					    """debug""": True,
					}
					return inputs
			def 							__snake_case	(						self       )      ->      Any:






					'''simple docstring'''







					_UpperCAmelCase      :							str       =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
					_UpperCAmelCase      :							Optional[Any]       =   self.get_dummy_components()
					_UpperCAmelCase      :							int       =   StableDiffusionParadigmsPipeline(**_A       )
					_UpperCAmelCase      :							Tuple       =   sd_pipe.to(_A       )
					sd_pipe.set_progress_bar_config(disable=_A       )

					_UpperCAmelCase      :							List[str]       =   self.get_dummy_inputs(_A       )
					_UpperCAmelCase      :							int       =   sd_pipe(**_A       ).images
					_UpperCAmelCase      :							List[Any]       =   image[0, -3:, -3:, -1]
					assert image.shape == (1, 64, 64, 3)

					_UpperCAmelCase      :							Dict       =   np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]       )

					assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
			def 							__snake_case	(						self       )      ->      List[Any]:






					'''simple docstring'''







					_UpperCAmelCase      :							Any       =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
					_UpperCAmelCase      :							List[Any]       =   self.get_dummy_components()
					torch.manual_seed(0       )
					_UpperCAmelCase      :							List[Any]       =   DDPMParallelScheduler()
					torch.manual_seed(0       )
					_UpperCAmelCase      :							Dict       =   StableDiffusionParadigmsPipeline(**_A       )
					_UpperCAmelCase      :							Union[str, Any]       =   sd_pipe.to(_A       )
					sd_pipe.set_progress_bar_config(disable=_A       )

					_UpperCAmelCase      :							str       =   self.get_dummy_inputs(_A       )
					_UpperCAmelCase      :							Any       =   sd_pipe(**_A       ).images
					_UpperCAmelCase      :							List[str]       =   image[0, -3:, -3:, -1]
					assert image.shape == (1, 64, 64, 3)

					_UpperCAmelCase      :							Any       =   np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]       )

					assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
			def 							__snake_case	(						self       )      ->      Tuple:






					'''simple docstring'''







					super().test_inference_batch_consistent(batch_sizes=[1, 2]       )
			def 							__snake_case	(						self       )      ->      Optional[Any]:






					'''simple docstring'''







					super().test_inference_batch_single_identical(batch_size=2 ,						expected_max_diff=3e-3       )
			def 							__snake_case	(						self       )      ->      Any:






					'''simple docstring'''







					_UpperCAmelCase      :							str       =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
					_UpperCAmelCase      :							Union[str, Any]       =   self.get_dummy_components()
					_UpperCAmelCase      :							str       =   StableDiffusionParadigmsPipeline(**_A       )
					_UpperCAmelCase      :							Dict       =   sd_pipe.to(_A       )
					sd_pipe.set_progress_bar_config(disable=_A       )

					_UpperCAmelCase      :							Union[str, Any]       =   self.get_dummy_inputs(_A       )
					_UpperCAmelCase      :							Dict       =   """french fries"""
					_UpperCAmelCase      :							List[Any]       =   sd_pipe(**_A ,						negative_prompt=_A       )
					_UpperCAmelCase      :							str       =   output.images
					_UpperCAmelCase      :							List[str]       =   image[0, -3:, -3:, -1]

					assert image.shape == (1, 64, 64, 3)

					_UpperCAmelCase      :							Any       =   np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]       )

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






@slow
@require_torch_gpu
class       _UpperCAmelCase     (						unittest.TestCase):
			def 							__snake_case	(						self       )      ->      Optional[int]:






					'''simple docstring'''







					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()
			def 							__snake_case	(						self ,						_A=0       )      ->      str:






					'''simple docstring'''







					_UpperCAmelCase      :							List[Any]       =   torch.Generator(device=_A       ).manual_seed(_A       )
					_UpperCAmelCase      :							Union[str, Any]       =   {
					    """prompt""": """a photograph of an astronaut riding a horse""",
					    """generator""": generator,
					    """num_inference_steps""": 10,
					    """guidance_scale""": 7.5,
					    """output_type""": """numpy""",
					    """parallel""": 3,
					    """debug""": True,
					}
					return inputs
			def 							__snake_case	(						self       )      ->      List[str]:






					'''simple docstring'''







					_UpperCAmelCase      :							Tuple       =   """stabilityai/stable-diffusion-2-base"""
					_UpperCAmelCase      :							List[Any]       =   DDIMParallelScheduler.from_pretrained(_A ,						subfolder="""scheduler"""       )
					_UpperCAmelCase      :							Tuple       =   StableDiffusionParadigmsPipeline.from_pretrained(_A ,						scheduler=_A ,						safety_checker=_A       )
					pipe.to(_A       )
					pipe.set_progress_bar_config(disable=_A       )
					pipe.enable_attention_slicing()

					_UpperCAmelCase      :							Optional[int]       =   self.get_inputs()
					_UpperCAmelCase      :							int       =   pipe(**_A       ).images
					_UpperCAmelCase      :							Any       =   image[0, -3:, -3:, -1].flatten()

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

					_UpperCAmelCase      :							List[Any]       =   np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]       )

					assert np.abs(expected_slice - image_slice       ).max() < 1e-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)





