





"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class 	__snake_case      (	SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							unittest.TestCase  ):





 """simple docstring"""


 _lowerCamelCase				 =  StableDiffusionImageVariationPipeline
 _lowerCamelCase				 =  IMAGE_VARIATION_PARAMS
 _lowerCamelCase				 =  IMAGE_VARIATION_BATCH_PARAMS
 _lowerCamelCase				 =  frozenset([]  )
 # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
 _lowerCamelCase				 =  frozenset([]  )

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     torch.manual_seed(0						)
     __A					:		int						=  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      ,		)
     __A					:		Any						=  PNDMScheduler(skip_prk_steps=__lowerCamelCase						)
     torch.manual_seed(0						)
     __A					:		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						)
     __A					:		List[Any]						=  CLIPVisionConfig(
         hidden_size=32      ,		projection_dim=32      ,		intermediate_size=37      ,		layer_norm_eps=1e-0_5      ,		num_attention_heads=4      ,		num_hidden_layers=5      ,		image_size=32      ,		patch_size=4      ,		)
     __A					:		List[Any]						=  CLIPVisionModelWithProjection(__lowerCamelCase						)
     __A					:		Union[str, Any]						=  CLIPImageProcessor(crop_size=32      ,		size=32						)

     __A					:		Any						=  {
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''vae''': vae,
         '''image_encoder''': image_encoder,
         '''feature_extractor''': feature_extractor,
         '''safety_checker''': None,
     }
     return components

 def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase=0						):



     '''simple docstring'''




     __A					:		List[Any]						=  floats_tensor((1, 3, 32, 32)      ,		rng=random.Random(__lowerCamelCase						)						)
     __A					:		Any						=  image.cpu().permute(0      ,		2      ,		3      ,		1						)[0]
     __A					:		Union[str, Any]						=  Image.fromarray(np.uinta(__lowerCamelCase						)						).convert('''RGB'''						).resize((32, 32)						)
     if str(__lowerCamelCase						).startswith('''mps'''						):
         __A					:		Dict						=  torch.manual_seed(__lowerCamelCase						)
     else:
         __A					:		List[str]						=  torch.Generator(device=__lowerCamelCase						).manual_seed(__lowerCamelCase						)
     __A					:		List[str]						=  {
         '''image''': image,
         '''generator''': generator,
         '''num_inference_steps''': 2,
         '''guidance_scale''': 6.0,
         '''output_type''': '''numpy''',
     }
     return inputs

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Optional[Any]						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
     __A					:		str						=  self.get_dummy_components()
     __A					:		Tuple						=  StableDiffusionImageVariationPipeline(**__lowerCamelCase						)
     __A					:		List[str]						=  sd_pipe.to(__lowerCamelCase						)
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase						)

     __A					:		int						=  self.get_dummy_inputs(__lowerCamelCase						)
     __A					:		Any						=  sd_pipe(**__lowerCamelCase						).images
     __A					:		Optional[int]						=  image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     __A					:		Tuple						=  np.array([0.5_2_3_9, 0.5_7_2_3, 0.4_7_9_6, 0.5_0_4_9, 0.5_5_5_0, 0.4_6_8_5, 0.5_3_2_9, 0.4_8_9_1, 0.4_9_2_1]						)

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

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Optional[Any]						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
     __A					:		int						=  self.get_dummy_components()
     __A					:		Any						=  StableDiffusionImageVariationPipeline(**__lowerCamelCase						)
     __A					:		Any						=  sd_pipe.to(__lowerCamelCase						)
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase						)

     __A					:		Optional[int]						=  self.get_dummy_inputs(__lowerCamelCase						)
     __A					:		Tuple						=  2 * [inputs['''image''']]
     __A					:		List[str]						=  sd_pipe(**__lowerCamelCase						)

     __A					:		str						=  output.images

     __A					:		List[Any]						=  image[-1, -3:, -3:, -1]

     assert image.shape == (2, 64, 64, 3)
     __A					:		int						=  np.array([0.6_8_9_2, 0.5_6_3_7, 0.5_8_3_6, 0.5_7_7_1, 0.6_2_5_4, 0.6_4_0_9, 0.5_5_8_0, 0.5_5_6_9, 0.5_2_8_9]						)

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







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     super().test_inference_batch_single_identical(expected_max_diff=3e-3						)






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





 """simple docstring"""


 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()

 def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase="cpu"      ,		__lowerCamelCase=torch.floataa      ,		__lowerCamelCase=0						):



     '''simple docstring'''




     __A					:		List[str]						=  torch.Generator(device=__lowerCamelCase						).manual_seed(__lowerCamelCase						)
     __A					:		Union[str, Any]						=  load_image(
         '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
         '''/stable_diffusion_imgvar/input_image_vermeer.png'''						)
     __A					:		Dict						=  np.random.RandomState(__lowerCamelCase						).standard_normal((1, 4, 64, 64)						)
     __A					:		Dict						=  torch.from_numpy(__lowerCamelCase						).to(device=__lowerCamelCase      ,		dtype=__lowerCamelCase						)
     __A					:		str						=  {
         '''image''': init_image,
         '''latents''': latents,
         '''generator''': generator,
         '''num_inference_steps''': 3,
         '''guidance_scale''': 7.5,
         '''output_type''': '''numpy''',
     }
     return inputs

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Union[str, Any]						=  StableDiffusionImageVariationPipeline.from_pretrained(
         '''lambdalabs/sd-image-variations-diffusers'''      ,		safety_checker=__lowerCamelCase						)
     __A					:		str						=  sd_pipe.to(__lowerCamelCase						)
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase						)

     __A					:		Dict						=  self.get_inputs(__lowerCamelCase						)
     __A					:		Any						=  sd_pipe(**__lowerCamelCase						).images
     __A					:		List[str]						=  image[0, -3:, -3:, -1].flatten()

     assert image.shape == (1, 512, 512, 3)
     __A					:		int						=  np.array([0.8_4_4_9_1, 0.9_0_7_8_9, 0.7_5_7_0_8, 0.7_8_7_3_4, 0.8_3_4_8_5, 0.7_0_0_9_9, 0.6_6_9_3_8, 0.6_8_7_2_7, 0.6_1_3_7_9]						)
     assert np.abs(image_slice - expected_slice						).max() < 6e-3

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Any						=  0

     def callback_fn(__lowerCamelCase      ,		__lowerCamelCase      ,		__lowerCamelCase						) -> None:
         __A					:		int						=  True
         nonlocal number_of_steps
         number_of_steps += 1
         if step == 1:
             __A					:		str						=  latents.detach().cpu().numpy()
             assert latents.shape == (1, 4, 64, 64)
             __A					:		Tuple						=  latents[0, -3:, -3:, -1]
             __A					:		Tuple						=  np.array(
                 [-0.1_6_2_1, 0.2_8_3_7, -0.7_9_7_9, -0.1_2_2_1, -1.3_0_5_7, 0.7_6_8_1, -2.1_1_9_1, 0.0_4_6_4, 1.6_3_0_9]						)

             assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5e-2
         elif step == 2:
             __A					:		List[Any]						=  latents.detach().cpu().numpy()
             assert latents.shape == (1, 4, 64, 64)
             __A					:		str						=  latents[0, -3:, -3:, -1]
             __A					:		List[str]						=  np.array([0.6_2_9_9, 1.7_5_0_0, 1.1_9_9_2, -2.1_5_8_2, -1.8_9_9_4, 0.7_3_3_4, -0.7_0_9_0, 1.0_1_3_7, 1.5_2_7_3]						)

             assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5e-2

     __A					:		Any						=  False

     __A					:		Tuple						=  StableDiffusionImageVariationPipeline.from_pretrained(
         '''fusing/sd-image-variations-diffusers'''      ,		safety_checker=__lowerCamelCase      ,		torch_dtype=torch.floataa      ,		)
     pipe.to(__lowerCamelCase						)
     pipe.set_progress_bar_config(disable=__lowerCamelCase						)
     pipe.enable_attention_slicing()

     __A					:		Dict						=  self.get_inputs(__lowerCamelCase      ,		dtype=torch.floataa						)
     pipe(**__lowerCamelCase      ,		callback=__lowerCamelCase      ,		callback_steps=1						)
     assert callback_fn.has_been_called
     assert number_of_steps == inputs["num_inference_steps"]







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     torch.cuda.empty_cache()
     torch.cuda.reset_max_memory_allocated()
     torch.cuda.reset_peak_memory_stats()

     __A					:		Any						=  '''fusing/sd-image-variations-diffusers'''
     __A					:		str						=  StableDiffusionImageVariationPipeline.from_pretrained(
         __lowerCamelCase      ,		safety_checker=__lowerCamelCase      ,		torch_dtype=torch.floataa						)
     __A					:		int						=  pipe.to(__lowerCamelCase						)
     pipe.set_progress_bar_config(disable=__lowerCamelCase						)
     pipe.enable_attention_slicing(1						)
     pipe.enable_sequential_cpu_offload()

     __A					:		List[Any]						=  self.get_inputs(__lowerCamelCase      ,		dtype=torch.floataa						)
     __A					:		str						=  pipe(**__lowerCamelCase						)

     __A					:		int						=  torch.cuda.max_memory_allocated()
     # make sure that less than 2.6 GB is allocated
     assert mem_bytes < 2.6 * 10**9






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





 """simple docstring"""


 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()

 def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase="cpu"      ,		__lowerCamelCase=torch.floataa      ,		__lowerCamelCase=0						):



     '''simple docstring'''




     __A					:		Optional[Any]						=  torch.Generator(device=__lowerCamelCase						).manual_seed(__lowerCamelCase						)
     __A					:		List[Any]						=  load_image(
         '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
         '''/stable_diffusion_imgvar/input_image_vermeer.png'''						)
     __A					:		Tuple						=  np.random.RandomState(__lowerCamelCase						).standard_normal((1, 4, 64, 64)						)
     __A					:		Any						=  torch.from_numpy(__lowerCamelCase						).to(device=__lowerCamelCase      ,		dtype=__lowerCamelCase						)
     __A					:		Dict						=  {
         '''image''': init_image,
         '''latents''': latents,
         '''generator''': generator,
         '''num_inference_steps''': 50,
         '''guidance_scale''': 7.5,
         '''output_type''': '''numpy''',
     }
     return inputs

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		List[str]						=  StableDiffusionImageVariationPipeline.from_pretrained('''fusing/sd-image-variations-diffusers'''						)
     sd_pipe.to(__lowerCamelCase						)
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase						)

     __A					:		Union[str, Any]						=  self.get_inputs(__lowerCamelCase						)
     __A					:		int						=  sd_pipe(**__lowerCamelCase						).images[0]

     __A					:		List[Any]						=  load_numpy(
         '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
         '''/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'''						)
     __A					:		Dict						=  np.abs(expected_image - image						).max()
     assert max_diff < 1e-3







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		int						=  StableDiffusionImageVariationPipeline.from_pretrained('''fusing/sd-image-variations-diffusers'''						)
     __A					:		str						=  DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config						)
     sd_pipe.to(__lowerCamelCase						)
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase						)

     __A					:		List[str]						=  self.get_inputs(__lowerCamelCase						)
     __A					:		Optional[Any]						=  25
     __A					:		Dict						=  sd_pipe(**__lowerCamelCase						).images[0]

     __A					:		Tuple						=  load_numpy(
         '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
         '''/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'''						)
     __A					:		Tuple						=  np.abs(expected_image - image						).max()
     assert max_diff < 1e-3











"""simple docstring"""



def 	__lowercase  (     snake_case_						:						list		)     ->list:



    '''simple docstring'''







    for insert_index, insert_value in enumerate(collection[1:]		):
        __A					:		Any						=  insert_index
        while insert_index >= 0 and insert_value < collection[insert_index]:
            __A					:		List[Any]						=  collection[insert_index]
            insert_index -= 1
        if insert_index != temp_index:
            __A					:		str						=  insert_value
    return collection


if __name__ == "__main__":
       from doctest import testmod

       testmod()

       a_				=    input("""Enter numbers separated by a comma:\n""").strip()
       a_				=    [int(item) for item in user_input.split(""",""")]
       print(f'''{insertion_sort(unsorted) = }''')




