





"""simple docstring"""
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    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    _SCREAMING_SNAKE_CASE(  A       ,      A       ,      unittest.TestCase    ):
       SCREAMING_SNAKE_CASE_  : Tuple      		=    StableDiffusionSAGPipeline
       SCREAMING_SNAKE_CASE_  : Dict      		=    TEXT_TO_IMAGE_PARAMS
       SCREAMING_SNAKE_CASE_  : Tuple      		=    TEXT_TO_IMAGE_BATCH_PARAMS
       SCREAMING_SNAKE_CASE_  : Optional[int]      		=    TEXT_TO_IMAGE_IMAGE_PARAMS
       SCREAMING_SNAKE_CASE_  : List[Any]      		=    TEXT_TO_IMAGE_IMAGE_PARAMS
       SCREAMING_SNAKE_CASE_  : Union[str, Any]      		=    False




       def        _UpperCamelCase	(		self				)     -> str:





             """simple docstring"""






             torch.manual_seed(0				)
             __SCREAMING_SNAKE_CASE  :Tuple													=    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  :Union[str, 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_						,)
             torch.manual_seed(0				)
             __SCREAMING_SNAKE_CASE  :Any													=    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  :Optional[int]													=    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						,)
             __SCREAMING_SNAKE_CASE  :int													=    CLIPTextModel(a_				)
             __SCREAMING_SNAKE_CASE  :str													=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

             __SCREAMING_SNAKE_CASE  :Union[str, Any]													=    {
                 "unet": unet,
                 "scheduler": scheduler,
                 "vae": vae,
                 "text_encoder": text_encoder,
                 "tokenizer": tokenizer,
                 "safety_checker": None,
                 "feature_extractor": None,
             }
             return components




       def        _UpperCamelCase	(		self						,SCREAMING_SNAKE_CASE__						,SCREAMING_SNAKE_CASE__=0				)     -> Tuple:





             """simple docstring"""






             if str(a_				).startswith('''mps'''				):
                   __SCREAMING_SNAKE_CASE  :Tuple													=    torch.manual_seed(a_				)
             else:
                   __SCREAMING_SNAKE_CASE  :List[Any]													=    torch.Generator(device=a_				).manual_seed(a_				)
             __SCREAMING_SNAKE_CASE  :int													=    {
                 "prompt": ".",
                 "generator": generator,
                 "num_inference_steps": 2,
                 "guidance_scale": 1.0,
                 "sag_scale": 1.0,
                 "output_type": "numpy",
             }
             return inputs




       def        _UpperCamelCase	(		self				)     -> List[Any]:





             """simple docstring"""






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






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




       def        _UpperCamelCase	(		self				)     -> str:





             """simple docstring"""






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




       def        _UpperCamelCase	(		self				)     -> Optional[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE  :Optional[Any]													=    StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''				)
             __SCREAMING_SNAKE_CASE  :Any													=    sag_pipe.to(a_				)
             sag_pipe.set_progress_bar_config(disable=a_				)

             __SCREAMING_SNAKE_CASE  :List[Any]													=    "."
             __SCREAMING_SNAKE_CASE  :Optional[int]													=    torch.manual_seed(0				)
             __SCREAMING_SNAKE_CASE  :int													=    sag_pipe(
                 [prompt]						,generator=a_						,guidance_scale=7.5						,sag_scale=1.0						,num_inference_steps=20						,output_type='''np'''				)

             __SCREAMING_SNAKE_CASE  :Optional[Any]													=    output.images

             __SCREAMING_SNAKE_CASE  :Dict													=    image[0, -3:, -3:, -1]

             assert image.shape == (1, 5_12, 5_12, 3)
             __SCREAMING_SNAKE_CASE  :Optional[int]													=    np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9]				)

             assert np.abs(image_slice.flatten() - expected_slice				).max() < 5E-2




       def        _UpperCamelCase	(		self				)     -> List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE  :Optional[Any]													=    StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
             __SCREAMING_SNAKE_CASE  :List[Any]													=    sag_pipe.to(a_				)
             sag_pipe.set_progress_bar_config(disable=a_				)

             __SCREAMING_SNAKE_CASE  :str													=    "."
             __SCREAMING_SNAKE_CASE  :int													=    torch.manual_seed(0				)
             __SCREAMING_SNAKE_CASE  :int													=    sag_pipe(
                 [prompt]						,generator=a_						,guidance_scale=7.5						,sag_scale=1.0						,num_inference_steps=20						,output_type='''np'''				)

             __SCREAMING_SNAKE_CASE  :str													=    output.images

             __SCREAMING_SNAKE_CASE  :List[str]													=    image[0, -3:, -3:, -1]

             assert image.shape == (1, 5_12, 5_12, 3)
             __SCREAMING_SNAKE_CASE  :str													=    np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1]				)

             assert np.abs(image_slice.flatten() - expected_slice				).max() < 5E-2




       def        _UpperCamelCase	(		self				)     -> int:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE  :List[Any]													=    StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
             __SCREAMING_SNAKE_CASE  :int													=    sag_pipe.to(a_				)
             sag_pipe.set_progress_bar_config(disable=a_				)

             __SCREAMING_SNAKE_CASE  :List[Any]													=    "."
             __SCREAMING_SNAKE_CASE  :List[Any]													=    torch.manual_seed(0				)
             __SCREAMING_SNAKE_CASE  :Dict													=    sag_pipe(
                 [prompt]						,width=7_68						,height=5_12						,generator=a_						,guidance_scale=7.5						,sag_scale=1.0						,num_inference_steps=20						,output_type='''np'''						,)

             __SCREAMING_SNAKE_CASE  :Union[str, Any]													=    output.images

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



'''simple docstring'''
def 	_A  (       A							)  ->				list:

	if len(A							) <= 1:
		return [tuple(A							)]

	lowercase						:		Dict   					=		[]

	def generate(A							,A							):
		lowercase						:		List[Any]   					=		[0] * n
		res.append(tuple(A							)							)

		lowercase						:		Tuple   					=		0
		while i < n:
			if c[i] < i:
				if i % 2 == 0:
					lowercase					,		lowercase						:		List[Any]   					=		arr[i], arr[0]
				else:
					lowercase					,		lowercase						:		Optional[Any]   					=		arr[i], arr[c[i]]
				res.append(tuple(A							)							)
				c[i] += 1
				lowercase						:		Optional[Any]   					=		0
			else:
				lowercase						:		Any   					=		0
				i += 1

	generate(len(A							)							,A							)
	return res


if __name__ == "__main__":
					lowerCAmelCase   : Any             =				input("""Enter numbers separated by a comma:\n""").strip()
					lowerCAmelCase   : List[str]             =				[int(item) for item in user_input.split(""",""")]
					print(heaps(arr))


