

import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()



@skip_mps
class 		a_	(							lowerCamelCase_			,      lowerCamelCase_			,      lowerCamelCase_			,      unittest.TestCase					):



      """simple docstring"""







      __UpperCAmelCase      		=				StableDiffusionModelEditingPipeline
      __UpperCAmelCase      		=				TEXT_TO_IMAGE_PARAMS
      __UpperCAmelCase      		=				TEXT_TO_IMAGE_BATCH_PARAMS
      __UpperCAmelCase      		=				TEXT_TO_IMAGE_IMAGE_PARAMS
      __UpperCAmelCase      		=				TEXT_TO_IMAGE_IMAGE_PARAMS
      def 	_lowerCAmelCase					(				self					:							Tuple    ):
           torch.manual_seed(0    )
           SCREAMING_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      ,)
           SCREAMING_SNAKE_CASE										=DDIMScheduler()
           torch.manual_seed(0    )
           SCREAMING_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      ,)
           torch.manual_seed(0    )
           SCREAMING_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=1000      ,)
           SCREAMING_SNAKE_CASE										=CLIPTextModel(snake_case    )
           SCREAMING_SNAKE_CASE										=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

           SCREAMING_SNAKE_CASE										={
               'unet': unet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'safety_checker': None,
               'feature_extractor': None,
           }
           return components
      def 	_lowerCAmelCase					(				self					:							Optional[Any]      ,snake_case					:							List[Any]      ,snake_case					:							List[str]=0    ):
           SCREAMING_SNAKE_CASE										=torch.manual_seed(snake_case    )
           SCREAMING_SNAKE_CASE										={
               'prompt': 'A field of roses',
               'generator': generator,
               # Setting height and width to None to prevent OOMs on CPU.
               'height': None,
               'width': None,
               'num_inference_steps': 2,
               'guidance_scale': 6.0,
               'output_type': 'numpy',
           }
           return inputs
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										='cpu'  # ensure determinism for the device-dependent torch.Generator
           SCREAMING_SNAKE_CASE										=self.get_dummy_components()
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline(**snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe.to(snake_case    )
           sd_pipe.set_progress_bar_config(disable=snake_case    )

           SCREAMING_SNAKE_CASE										=self.get_dummy_inputs(snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe(**snake_case    ).images
           SCREAMING_SNAKE_CASE										=image[0, -3:, -3:, -1]
           assert image.shape == (1, 64, 64, 3)

           SCREAMING_SNAKE_CASE										=np.array([0.4_755, 0.5_132, 0.4_976, 0.3_904, 0.3_554, 0.4_765, 0.5_139, 0.5_158, 0.4_889]    )

           assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
      def 	_lowerCAmelCase					(				self					:							List[Any]    ):
           SCREAMING_SNAKE_CASE										='cpu'  # ensure determinism for the device-dependent torch.Generator
           SCREAMING_SNAKE_CASE										=self.get_dummy_components()
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline(**snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe.to(snake_case    )
           sd_pipe.set_progress_bar_config(disable=snake_case    )

           SCREAMING_SNAKE_CASE										=self.get_dummy_inputs(snake_case    )
           SCREAMING_SNAKE_CASE										='french fries'
           SCREAMING_SNAKE_CASE										=sd_pipe(**snake_case      ,negative_prompt=snake_case    )
           SCREAMING_SNAKE_CASE										=output.images
           SCREAMING_SNAKE_CASE										=image[0, -3:, -3:, -1]

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

           SCREAMING_SNAKE_CASE										=np.array([0.4_992, 0.5_101, 0.5_004, 0.3_949, 0.3_604, 0.4_735, 0.5_216, 0.5_204, 0.4_913]    )

           assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
      def 	_lowerCAmelCase					(				self					:							int    ):
           SCREAMING_SNAKE_CASE										='cpu'  # ensure determinism for the device-dependent torch.Generator
           SCREAMING_SNAKE_CASE										=self.get_dummy_components()
           SCREAMING_SNAKE_CASE										=EulerAncestralDiscreteScheduler(
               beta_start=0.00_085      ,beta_end=0.012      ,beta_schedule='scaled_linear'    )
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline(**snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe.to(snake_case    )
           sd_pipe.set_progress_bar_config(disable=snake_case    )

           SCREAMING_SNAKE_CASE										=self.get_dummy_inputs(snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe(**snake_case    ).images
           SCREAMING_SNAKE_CASE										=image[0, -3:, -3:, -1]

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

           SCREAMING_SNAKE_CASE										=np.array([0.4_747, 0.5_372, 0.4_779, 0.4_982, 0.5_543, 0.4_816, 0.5_238, 0.4_904, 0.5_027]    )

           assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           SCREAMING_SNAKE_CASE										='cpu'  # ensure determinism for the device-dependent torch.Generator
           SCREAMING_SNAKE_CASE										=self.get_dummy_components()
           SCREAMING_SNAKE_CASE										=PNDMScheduler()
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline(**snake_case    )
           SCREAMING_SNAKE_CASE										=sd_pipe.to(snake_case    )
           sd_pipe.set_progress_bar_config(disable=snake_case    )

           SCREAMING_SNAKE_CASE										=self.get_dummy_inputs(snake_case    )
           # the pipeline does not expect pndm so test if it raises error.
           with self.assertRaises(snake_case    ):
                SCREAMING_SNAKE_CASE										=sd_pipe(**snake_case    ).images
      def 	_lowerCAmelCase					(				self					:							Optional[int]    ):
           super().test_inference_batch_single_identical(expected_max_diff=5e-3    )


      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           super().test_attention_slicing_forward_pass(expected_max_diff=5e-3    )







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



      """simple docstring"""







      def 	_lowerCAmelCase					(				self					:							Dict    ):
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
      def 	_lowerCAmelCase					(				self					:							Dict      ,snake_case					:							Optional[Any]=0    ):
           SCREAMING_SNAKE_CASE										=torch.manual_seed(snake_case    )
           SCREAMING_SNAKE_CASE										={
               'prompt': 'A field of roses',
               'generator': generator,
               'num_inference_steps': 3,
               'guidance_scale': 7.5,
               'output_type': 'numpy',
           }
           return inputs
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										='CompVis/stable-diffusion-v1-4'
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline.from_pretrained(snake_case      ,safety_checker=snake_case    )
           pipe.to(snake_case    )
           pipe.set_progress_bar_config(disable=snake_case    )
           pipe.enable_attention_slicing()

           SCREAMING_SNAKE_CASE										=self.get_inputs()
           SCREAMING_SNAKE_CASE										=pipe(**snake_case    ).images
           SCREAMING_SNAKE_CASE										=image[0, -3:, -3:, -1].flatten()

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

           SCREAMING_SNAKE_CASE										=np.array(
               [0.6_749_496, 0.6_386_453, 0.51_443_267, 0.66_094_905, 0.61_921_215, 0.5_491_332, 0.5_744_417, 0.58_075_106, 0.5_174_658]    )

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

           # make sure image changes after editing
           pipe.edit_model('A pack of roses'      ,'A pack of blue roses'    )

           SCREAMING_SNAKE_CASE										=pipe(**snake_case    ).images
           SCREAMING_SNAKE_CASE										=image[0, -3:, -3:, -1].flatten()

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

           assert np.abs(expected_slice - image_slice    ).max() > 1e-1


      def 	_lowerCAmelCase					(				self					:							Tuple    ):
           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           SCREAMING_SNAKE_CASE										='CompVis/stable-diffusion-v1-4'
           SCREAMING_SNAKE_CASE										=DDIMScheduler.from_pretrained(snake_case      ,subfolder='scheduler'    )
           SCREAMING_SNAKE_CASE										=StableDiffusionModelEditingPipeline.from_pretrained(
               snake_case      ,scheduler=snake_case      ,safety_checker=snake_case    )
           SCREAMING_SNAKE_CASE										=pipe.to(snake_case    )
           pipe.set_progress_bar_config(disable=snake_case    )
           pipe.enable_attention_slicing(1    )
           pipe.enable_sequential_cpu_offload()

           SCREAMING_SNAKE_CASE										=self.get_inputs()
           SCREAMING_SNAKE_CASE										=pipe(**snake_case    )

           SCREAMING_SNAKE_CASE										=torch.cuda.max_memory_allocated()
           # make sure that less than 4.4 GB is allocated
           assert mem_bytes < 4.4 * 10**9




def       snake_case__    (       lowerCAmelCase_      ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE										=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)
                    SCREAMING_SNAKE_CASE										=lst[j + 1]
                    SCREAMING_SNAKE_CASE										=lst[j]
                    SCREAMING_SNAKE_CASE										=temp
               if (
                   lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
               ):  # applying bubble sort algorithm from right to left (or backwards)
                    SCREAMING_SNAKE_CASE										=lst[no_of_elements - 1 - j]
                    SCREAMING_SNAKE_CASE										=lst[no_of_elements - 2 - j]
                    SCREAMING_SNAKE_CASE										=temp
     return lst


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

