



"""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     a		(     _a		,					_a		,					unittest.TestCase				):
  UpperCamelCase		: Dict     =    StableDiffusionSAGPipeline
  UpperCamelCase		: List[Any]     =    TEXT_TO_IMAGE_PARAMS
  UpperCamelCase		: List[Any]     =    TEXT_TO_IMAGE_BATCH_PARAMS
  UpperCamelCase		: Any     =    TEXT_TO_IMAGE_IMAGE_PARAMS
  UpperCamelCase		: Optional[Any]     =    TEXT_TO_IMAGE_IMAGE_PARAMS
  UpperCamelCase		: List[str]     =    False



  def 		lowerCamelCase__				(  self       :    Optional[Any]						)   ->    Dict:


     '''simple docstring'''




     torch.manual_seed(0						)
     SCREAMING_SNAKE_CASE_:       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				,						)
     SCREAMING_SNAKE_CASE_:       Tuple   	=DDIMScheduler(
         beta_start=0.0_0_0_8_5				,						beta_end=0.0_1_2				,						beta_schedule="""scaled_linear"""				,						clip_sample=lowerCAmelCase				,						set_alpha_to_one=lowerCAmelCase				,						)
     torch.manual_seed(0						)
     SCREAMING_SNAKE_CASE_:       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						)
     SCREAMING_SNAKE_CASE_:       List[str]   	=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_:       Dict   	=CLIPTextModel(lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:       Optional[int]   	=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

     SCREAMING_SNAKE_CASE_:       Optional[Any]   	={
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'safety_checker': None,
         'feature_extractor': None,
     }
     return components



  def 		lowerCamelCase__				(  self       :    List[Any]				,						lowerCAmelCase       :    Optional[int]				,						lowerCAmelCase       :    List[Any]=0						)   ->    Dict:


     '''simple docstring'''




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





  def 		lowerCamelCase__				(  self       :    List[Any]						)   ->    List[str]:


     '''simple docstring'''




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







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



  def 		lowerCamelCase__				(  self       :    Any						)   ->    Dict:


     '''simple docstring'''




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



  def 		lowerCamelCase__				(  self       :    Dict						)   ->    Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Dict   	=StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""						)
     SCREAMING_SNAKE_CASE_:       Optional[Any]   	=sag_pipe.to(lowerCAmelCase						)
     sag_pipe.set_progress_bar_config(disable=lowerCAmelCase						)

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

     SCREAMING_SNAKE_CASE_:       Tuple   	=output.images

     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	=image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE_:       Tuple   	=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 		lowerCamelCase__				(  self       :    List[Any]						)   ->    Union[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       List[Any]   	=StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""						)
     SCREAMING_SNAKE_CASE_:       Dict   	=sag_pipe.to(lowerCAmelCase						)
     sag_pipe.set_progress_bar_config(disable=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	='.'
     SCREAMING_SNAKE_CASE_:       str   	=torch.manual_seed(0						)
     SCREAMING_SNAKE_CASE_:       Any   	=sag_pipe(
         [prompt]				,						generator=lowerCAmelCase				,						guidance_scale=7.5				,						sag_scale=1.0				,						num_inference_steps=20				,						output_type="""np"""						)

     SCREAMING_SNAKE_CASE_:       List[str]   	=output.images

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

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE_:       int   	=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 		lowerCamelCase__				(  self       :    str						)   ->    Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:       Optional[Any]   	=StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""						)
     SCREAMING_SNAKE_CASE_:       List[str]   	=sag_pipe.to(lowerCAmelCase						)
     sag_pipe.set_progress_bar_config(disable=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:       Union[str, Any]   	='.'
     SCREAMING_SNAKE_CASE_:       Tuple   	=torch.manual_seed(0						)
     SCREAMING_SNAKE_CASE_:       List[Any]   	=sag_pipe(
         [prompt]				,						width=768				,						height=512				,						generator=lowerCAmelCase				,						guidance_scale=7.5				,						sag_scale=1.0				,						num_inference_steps=20				,						output_type="""np"""				,						)

     SCREAMING_SNAKE_CASE_:       Tuple   	=output.images

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







from __future__ import annotations



def 				UpperCamelCase_(      lowerCamelCase_ )    ->						bool:
    if len(lowerCamelCase_ ) < 2:
        raise ValueError('Monogons and Digons are not polygons in the Euclidean space' )
    if any(i <= 0 for i in nums ):
        raise ValueError('All values must be greater than 0' )
    _lowercase       :							Tuple      		=		nums.copy()
    copy_nums.sort()
    return copy_nums[-1] < sum(copy_nums[:-1] )


if __name__ == "__main__":
 import doctest

 doctest.testmod()


