"""simple docstring"""



from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available



@dataclass
class      _A	(						_UpperCAmelCase					):




    """simple docstring"""




    UpperCamelCase_	:					Union[List[PIL.Image.Image], np.ndarray]
    UpperCamelCase_	:					Optional[List[bool]]


if is_transformers_available() and is_torch_available():
       from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline
"""simple docstring"""



import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



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




    """simple docstring"""




    def  lowercase					(		self							:     Tuple    )    ->       str:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
    def  lowercase					(		self							:     int    )    ->       Tuple:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_euler'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe([prompt]	,      generator=A_	,      guidance_scale=9.0	,      num_inference_steps=20	,      output_type='''np'''    )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array([0.04_47, 0.04_92, 0.04_68, 0.04_08, 0.03_83, 0.04_08, 0.03_54, 0.03_80, 0.03_39]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
    def  lowercase					(		self							:     Optional[Any]    )    ->       Tuple:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_euler'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe([prompt]	,      generator=A_	,      guidance_scale=9.0	,      num_inference_steps=20	,      output_type='''np'''    )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array([0.12_37, 0.13_20, 0.14_38, 0.13_59, 0.13_90, 0.11_32, 0.12_77, 0.11_75, 0.11_12]    )

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







    def  lowercase					(		self							:     List[str]    )    ->       Optional[Any]:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_dpmpp_2m'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe(
             [prompt]	,      generator=A_	,      guidance_scale=7.5	,      num_inference_steps=15	,      output_type='''np'''	,      use_karras_sigmas=A_	,      )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array(
             [0.11_38_16_89, 0.12_11_29_21, 0.1_38_94_57, 0.12_54_96_06, 0.1_24_49_64, 0.10_83_15_17, 0.11_56_28_66, 0.10_86_78_16, 0.10_49_90_48]    )

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