




"""simple docstring"""

import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device




def    snake_case__						(							lowerCAmelCase :		nn.Module		):
					__snake_case        =						{}
					for name in unet.attn_processors.keys():
										__snake_case        =						None if name.endswith("""attn1.processor"""		) else unet.config.cross_attention_dim
										if name.startswith("""mid_block"""		):
															__snake_case        =						unet.config.block_out_channels[-1]
										elif name.startswith("""up_blocks"""		):
															__snake_case        =						int(name[len("""up_blocks."""		)]		)
															__snake_case        =						list(reversed(unet.config.block_out_channels		)		)[block_id]
										elif name.startswith("""down_blocks"""		):
															__snake_case        =						int(name[len("""down_blocks."""		)]		)
															__snake_case        =						unet.config.block_out_channels[block_id]
										__snake_case        =						(
										    LoRAAttnProcessor2_0 if hasattr(_UpperCAmelCase					,       """scaled_dot_product_attention"""		) else LoRAAttnProcessor
										)
										__snake_case        =						lora_attn_processor_class(
										    hidden_size=_UpperCAmelCase					,       cross_attention_dim=_UpperCAmelCase		)
					__snake_case        =						AttnProcsLayers(_UpperCAmelCase		)
					return lora_attn_procs, unet_lora_layers




def    snake_case__						(							lowerCAmelCase :		nn.Module		):
					__snake_case        =						{}
					__snake_case        =						(
					    LoRAAttnProcessor2_0 if hasattr(_UpperCAmelCase					,       """scaled_dot_product_attention"""		) else LoRAAttnProcessor
					)
					for name, module in text_encoder.named_modules():
										if name.endswith(_UpperCAmelCase		):
															__snake_case        =						lora_attn_processor_class(
															    hidden_size=module.out_proj.out_features					,       cross_attention_dim=_UpperCAmelCase		)
					return text_lora_attn_procs




def    snake_case__						(							lowerCAmelCase :		nn.Module		):
					__snake_case        =						create_text_encoder_lora_attn_procs(_UpperCAmelCase		)
					__snake_case        =						AttnProcsLayers(_UpperCAmelCase		)
					return text_encoder_lora_layers




def    snake_case__						(							lowerCAmelCase :		Tuple					,       lowerCAmelCase :		str=False		):
					for _, attn_proc in text_lora_attn_procs.items():
										# set up.weights
										for layer_name, layer_module in attn_proc.named_modules():
															if layer_name.endswith("""_lora"""		):
																				__snake_case        =						(
																				    torch.randn_like(layer_module.up.weight		)
																				    if randn_weight
																				    else torch.zeros_like(layer_module.up.weight		)
																				)
																				__snake_case        =						torch.nn.Parameter(_UpperCAmelCase		)

class      A__   (   unittest.TestCase  ):




	def 				a_		( self	:						Dict						)       ->			Optional[int]:
						torch.manual_seed(0						)
						__snake_case        =						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   ,     )
						__snake_case        =						DDIMScheduler(
						    beta_start=0.0_00_85   ,     beta_end=0.0_12   ,     beta_schedule="""scaled_linear"""   ,     clip_sample=lowercase   ,     set_alpha_to_one=lowercase   ,     steps_offset=1   ,     )
						torch.manual_seed(0						)
						__snake_case        =						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   ,     )
						__snake_case        =						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=1_000   ,     )
						__snake_case        =						CLIPTextModel(lowercase						)
						__snake_case        =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

						__snake_case   ,   __snake_case        =						create_unet_lora_layers(lowercase						)
						__snake_case        =						create_text_encoder_lora_layers(lowercase						)

						__snake_case        =						{
						    """unet""": unet,
						    """scheduler""": scheduler,
						    """vae""": vae,
						    """text_encoder""": text_encoder,
						    """tokenizer""": tokenizer,
						    """safety_checker""": None,
						    """feature_extractor""": None,
						}
						__snake_case        =						{
						    """unet_lora_layers""": unet_lora_layers,
						    """text_encoder_lora_layers""": text_encoder_lora_layers,
						    """unet_lora_attn_procs""": unet_lora_attn_procs,
						}
						return pipeline_components, lora_components




	def 				a_		( self	:						Dict						)       ->			Union[str, Any]:
						__snake_case        =						1
						__snake_case        =						10
						__snake_case        =						4
						__snake_case        =						(32, 32)

						__snake_case        =						torch.manual_seed(0						)
						__snake_case        =						floats_tensor((batch_size, num_channels) + sizes						)
						__snake_case        =						torch.randint(1   ,     lowercase   ,     size=(batch_size, sequence_length)   ,     generator=lowercase						)

						__snake_case        =						{
						    """prompt""": """A painting of a squirrel eating a burger""",
						    """generator""": generator,
						    """num_inference_steps""": 2,
						    """guidance_scale""": 6.0,
						    """output_type""": """numpy""",
						}

						return noise, input_ids, pipeline_inputs

						# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb




	def 				a_		( self	:						Union[str, Any]						)       ->			List[str]:
						__snake_case        =						77

						__snake_case        =						torch.randint(2   ,     56   ,     size=(1, max_seq_length)   ,     generator=torch.manual_seed(0						)						)

						__snake_case        =						{}
						__snake_case        =						inputs
						return prepared_inputs




	def 				a_		( self	:						Tuple   ,     lowercase	:						Union[str, Any]						)       ->			Optional[Any]:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						LoraLoaderMixin.save_lora_weights(
						    save_directory=lowercase   ,     unet_lora_layers=lora_components["""unet_lora_layers"""]   ,     text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]   ,     )
						self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.bin"""						)						)						)




	def 				a_		( self	:						List[Any]						)       ->			int:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)
						__snake_case        =						sd_pipe.to(lowercase						)
						sd_pipe.set_progress_bar_config(disable=lowercase						)

						__snake_case   ,   __snake_case   ,   __snake_case        =						self.get_dummy_inputs()

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
											LoraLoaderMixin.save_lora_weights(
											    save_directory=lowercase   ,     unet_lora_layers=lora_components["""unet_lora_layers"""]   ,     text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]   ,     )
											self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.bin"""						)						)						)
											sd_pipe.load_lora_weights(lowercase						)

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(lowercase						)   ,     torch.from_numpy(lowercase						)						)						)




	def 				a_		( self	:						Union[str, Any]						)       ->			Tuple:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)
						__snake_case        =						sd_pipe.to(lowercase						)
						sd_pipe.set_progress_bar_config(disable=lowercase						)

						__snake_case   ,   __snake_case   ,   __snake_case        =						self.get_dummy_inputs()

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
											LoraLoaderMixin.save_lora_weights(
											    save_directory=lowercase   ,     unet_lora_layers=lora_components["""unet_lora_layers"""]   ,     text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]   ,     safe_serialization=lowercase   ,     )
											self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.safetensors"""						)						)						)
											sd_pipe.load_lora_weights(lowercase						)

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(lowercase						)   ,     torch.from_numpy(lowercase						)						)						)




	def 				a_		( self	:						Tuple						)       ->			str:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						lora_components["""unet_lora_attn_procs"""]
						__snake_case        =						StableDiffusionPipeline(**lowercase						)
						__snake_case        =						sd_pipe.to(lowercase						)
						sd_pipe.set_progress_bar_config(disable=lowercase						)

						__snake_case   ,   __snake_case   ,   __snake_case        =						self.get_dummy_inputs()

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
											__snake_case        =						sd_pipe.unet
											unet.set_attn_processor(lowercase						)
											unet.save_attn_procs(lowercase						)
											self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.bin"""						)						)						)
											sd_pipe.load_lora_weights(lowercase						)

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(lowercase						)   ,     torch.from_numpy(lowercase						)						)						)




	def 				a_		( self	:						List[Any]						)       ->			Union[str, Any]:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)

						__snake_case        =						self.get_dummy_tokens()

						# inference without lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_without_lora.shape == (1, 77, 32)

						# create lora_attn_procs with zeroed out up.weights
						__snake_case        =						create_text_encoder_lora_attn_procs(pipe.text_encoder						)
						set_lora_up_weights(lowercase   ,     randn_weight=lowercase						)

						# monkey patch
						pipe._modify_text_encoder(lowercase						)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_with_lora.shape == (1, 77, 32)

						assert torch.allclose(
						    lowercase   ,     lowercase						), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

						# create lora_attn_procs with randn up.weights
						__snake_case        =						create_text_encoder_lora_attn_procs(pipe.text_encoder						)
						set_lora_up_weights(lowercase   ,     randn_weight=lowercase						)

						# monkey patch
						pipe._modify_text_encoder(lowercase						)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_with_lora.shape == (1, 77, 32)

						assert not torch.allclose(
						    lowercase   ,     lowercase						), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"




	def 				a_		( self	:						Optional[int]						)       ->			Optional[int]:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)

						__snake_case        =						self.get_dummy_tokens()

						# inference without lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_without_lora.shape == (1, 77, 32)

						# create lora_attn_procs with randn up.weights
						__snake_case        =						create_text_encoder_lora_attn_procs(pipe.text_encoder						)
						set_lora_up_weights(lowercase   ,     randn_weight=lowercase						)

						# monkey patch
						pipe._modify_text_encoder(lowercase						)

						# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
						del text_attn_procs
						gc.collect()

						# inference with lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_with_lora.shape == (1, 77, 32)

						assert not torch.allclose(
						    lowercase   ,     lowercase						), "lora outputs should be different to without lora outputs"

						# remove monkey patch
						pipe._remove_text_encoder_monkey_patch()

						# inference with removed lora
						__snake_case        =						pipe.text_encoder(**lowercase						)[0]
						assert outputs_without_lora_removed.shape == (1, 77, 32)

						assert torch.allclose(
						    lowercase   ,     lowercase						), "remove lora monkey patch should restore the original outputs"




	def 				a_		( self	:						Optional[Any]						)       ->			List[Any]:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)
						__snake_case        =						sd_pipe.to(lowercase						)
						sd_pipe.set_progress_bar_config(disable=lowercase						)

						__snake_case   ,   __snake_case   ,   __snake_case        =						self.get_dummy_inputs()

						with tempfile.TemporaryDirectory() as tmpdirname:
											LoraLoaderMixin.save_lora_weights(
											    save_directory=lowercase   ,     unet_lora_layers=lora_components["""unet_lora_layers"""]   ,     text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]   ,     )
											self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.bin"""						)						)						)
											sd_pipe.load_lora_weights(lowercase						)

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						lora_images[0, -3:, -3:, -1]

						__snake_case        =						sd_pipe(**lowercase   ,     cross_attention_kwargs={"""scale""": 0.5}						).images
						__snake_case        =						lora_images_with_scale[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(
						    torch.allclose(torch.from_numpy(lowercase						)   ,     torch.from_numpy(lowercase						)						)						)




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






						with tempfile.TemporaryDirectory() as tmpdirname:
											self.create_lora_weight_file(lowercase						)

											__snake_case   ,   __snake_case        =						self.get_dummy_components()
											__snake_case        =						StableDiffusionPipeline(**lowercase						)
											__snake_case        =						sd_pipe.to(lowercase						)
											sd_pipe.set_progress_bar_config(disable=lowercase						)

											# check if vanilla attention processors are used
											for _, module in sd_pipe.unet.named_modules():
																if isinstance(lowercase   ,     lowercase						):
																					self.assertIsInstance(module.processor   ,     (AttnProcessor, AttnProcessor2_0)						)

            # load LoRA weight file
											sd_pipe.load_lora_weights(lowercase						)

											# check if lora attention processors are used
											for _, module in sd_pipe.unet.named_modules():
																if isinstance(lowercase   ,     lowercase						):
																					__snake_case        =						(
																					    LoRAAttnProcessor2_0 if hasattr(lowercase   ,     """scaled_dot_product_attention"""						) else LoRAAttnProcessor
																					)
																					self.assertIsInstance(module.processor   ,     lowercase						)




	@unittest.skipIf(torch_device != """cuda"""   ,     """This test is supposed to run on GPU"""						)
	def 				a_		( self	:						Union[str, Any]						)       ->			Any:






						with tempfile.TemporaryDirectory() as tmpdirname:
											self.create_lora_weight_file(lowercase						)

											__snake_case   ,   __snake_case        =						self.get_dummy_components()
											__snake_case        =						StableDiffusionPipeline(**lowercase						)
											__snake_case        =						sd_pipe.to(lowercase						)
											sd_pipe.set_progress_bar_config(disable=lowercase						)

											# enable XFormers
											sd_pipe.enable_xformers_memory_efficient_attention()

											# check if xFormers attention processors are used
											for _, module in sd_pipe.unet.named_modules():
																if isinstance(lowercase   ,     lowercase						):
																					self.assertIsInstance(module.processor   ,     lowercase						)

            # load LoRA weight file
											sd_pipe.load_lora_weights(lowercase						)

											# check if lora attention processors are used
											for _, module in sd_pipe.unet.named_modules():
																if isinstance(lowercase   ,     lowercase						):
																					self.assertIsInstance(module.processor   ,     lowercase						)




	@unittest.skipIf(torch_device != """cuda"""   ,     """This test is supposed to run on GPU"""						)
	def 				a_		( self	:						Dict						)       ->			int:
						__snake_case   ,   __snake_case        =						self.get_dummy_components()
						__snake_case        =						StableDiffusionPipeline(**lowercase						)
						__snake_case        =						sd_pipe.to(lowercase						)
						sd_pipe.set_progress_bar_config(disable=lowercase						)

						__snake_case   ,   __snake_case   ,   __snake_case        =						self.get_dummy_inputs()

						# enable XFormers
						sd_pipe.enable_xformers_memory_efficient_attention()

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						original_images[0, -3:, -3:, -1]

						with tempfile.TemporaryDirectory() as tmpdirname:
											LoraLoaderMixin.save_lora_weights(
											    save_directory=lowercase   ,     unet_lora_layers=lora_components["""unet_lora_layers"""]   ,     text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]   ,     )
											self.assertTrue(os.path.isfile(os.path.join(lowercase   ,     """pytorch_lora_weights.bin"""						)						)						)
											sd_pipe.load_lora_weights(lowercase						)

						__snake_case        =						sd_pipe(**lowercase						).images
						__snake_case        =						lora_images[0, -3:, -3:, -1]

						# Outputs shouldn't match.
						self.assertFalse(torch.allclose(torch.from_numpy(lowercase						)   ,     torch.from_numpy(lowercase						)						)						)







def 				A      (	_UpperCAmelCase							:  List[Any]       )							->					List[Any]:







			'''simple docstring'''
			_UpperCAmelCase									=  len(_UpperCAmelCase       )
			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									=  lst[j + 1]
												_UpperCAmelCase									=  lst[j]
												_UpperCAmelCase									=  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									=  lst[no_of_elements - 1 - j]
												_UpperCAmelCase									=  lst[no_of_elements - 2 - j]
												_UpperCAmelCase									=  temp
			return lst


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