





"""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     (    _UpperCamelCase		,	_UpperCamelCase		,	unittest.TestCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Optional[int]						  =       StableDiffusionSAGPipeline
  SCREAMING_SNAKE_CASE__				:Any						  =       TEXT_TO_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE__				:List[Any]						  =       TEXT_TO_IMAGE_BATCH_PARAMS
  SCREAMING_SNAKE_CASE__				:Any						  =       TEXT_TO_IMAGE_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE__				:int						  =       TEXT_TO_IMAGE_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE__				:str						  =       False

  def  __SCREAMING_SNAKE_CASE					(		self :							int						)		->					int:
        torch.manual_seed(0						)
        _UpperCamelCase   :						Union[str, Any]    =							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       , )
        _UpperCamelCase   :						Optional[int]    =							DDIMScheduler(
            beta_start=0.0_00_85       , beta_end=0.0_12       , beta_schedule="scaled_linear"       , clip_sample=__a       , set_alpha_to_one=__a       , )
        torch.manual_seed(0						)
        _UpperCamelCase   :						Optional[int]    =							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						)
        _UpperCamelCase   :						Union[str, Any]    =							CLIPTextConfig(
            bos_token_id=0       , eos_token_id=2       , hidden_size=32       , intermediate_size=37       , layer_norm_eps=1e-0_5       , num_attention_heads=4       , num_hidden_layers=5       , pad_token_id=1       , vocab_size=1000       , )
        _UpperCamelCase   :						Optional[Any]    =							CLIPTextModel(__a						)
        _UpperCamelCase   :						List[str]    =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

        _UpperCamelCase   :						Dict    =							{
            "unet": unet,
            "scheduler": scheduler,
            "vae": vae,
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "safety_checker": None,
            "feature_extractor": None,
        }
        return components

  def  __SCREAMING_SNAKE_CASE					(		self :							int       , __a :							str       , __a :							str=0						)		->					List[str]:
        if str(__a						).startswith("mps"						):
              _UpperCamelCase   :						Optional[int]    =							torch.manual_seed(__a						)
        else:
              _UpperCamelCase   :						Tuple    =							torch.Generator(device=__a						).manual_seed(__a						)
        _UpperCamelCase   :						int    =							{
            "prompt": ".",
            "generator": generator,
            "num_inference_steps": 2,
            "guidance_scale": 1.0,
            "sag_scale": 1.0,
            "output_type": "numpy",
        }
        return inputs


  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple						)		->					Union[str, Any]:
        super().test_inference_batch_single_identical(expected_max_diff=3e-3						)





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







  '''simple docstring'''


  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					Dict:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					Tuple:
        _UpperCamelCase   :						Tuple    =							StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"						)
        _UpperCamelCase   :						Union[str, Any]    =							sag_pipe.to(__a						)
        sag_pipe.set_progress_bar_config(disable=__a						)

        _UpperCamelCase   :						Tuple    =							"."
        _UpperCamelCase   :						Any    =							torch.manual_seed(0						)
        _UpperCamelCase   :						Optional[Any]    =							sag_pipe(
            [prompt]       , generator=__a       , guidance_scale=7.5       , sag_scale=1.0       , num_inference_steps=20       , output_type="np"						)

        _UpperCamelCase   :						List[str]    =							output.images

        _UpperCamelCase   :						int    =							image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        _UpperCamelCase   :						Any    =							np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49]						)

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

  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]						)		->					Optional[int]:
        _UpperCamelCase   :						Union[str, Any]    =							StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"						)
        _UpperCamelCase   :						Dict    =							sag_pipe.to(__a						)
        sag_pipe.set_progress_bar_config(disable=__a						)

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

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

        _UpperCamelCase   :						str    =							image[0, -3:, -3:, -1]

        assert image.shape == (1, 512, 512, 3)
        _UpperCamelCase   :						List[Any]    =							np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71]						)

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


  def  __SCREAMING_SNAKE_CASE					(		self :							Union[str, Any]						)		->					Union[str, Any]:
        _UpperCamelCase   :						Optional[Any]    =							StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"						)
        _UpperCamelCase   :						Optional[int]    =							sag_pipe.to(__a						)
        sag_pipe.set_progress_bar_config(disable=__a						)

        _UpperCamelCase   :						Tuple    =							"."
        _UpperCamelCase   :						Union[str, Any]    =							torch.manual_seed(0						)
        _UpperCamelCase   :						Optional[int]    =							sag_pipe(
            [prompt]       , width=768       , height=512       , generator=__a       , guidance_scale=7.5       , sag_scale=1.0       , num_inference_steps=20       , output_type="np"       , )

        _UpperCamelCase   :						str    =							output.images

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







"""simple docstring"""


def        lowercase__     (       lowercase_      )       ->		list:




      """simple docstring"""

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

      _UpperCamelCase   :						Optional[Any]    =							[]

      def generate(lowercase_		,lowercase_      ):
            if k == 1:
                  res.append(tuple(arr[:]      )      )
                  return

            generate(k - 1		,lowercase_      )

            for i in range(k - 1      ):
                  if k % 2 == 0:  # k is even
                        _UpperCamelCase,	_UpperCamelCase   :						List[str]    =							arr[k - 1], arr[i]
                  else:  # k is odd
                        _UpperCamelCase,	_UpperCamelCase   :						int    =							arr[k - 1], arr[0]
                  generate(k - 1		,lowercase_      )

      generate(len(lowercase_      )		,lowercase_      )
      return res


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