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      lowerCamelCase_					(       UpperCAmelCase_						,     UpperCAmelCase_						,     unittest.TestCase			):






    '''simple docstring'''






    a__     :						Tuple      =				StableDiffusionSAGPipeline
    a__     :						Tuple      =				TEXT_TO_IMAGE_PARAMS
    a__     :						Tuple      =				TEXT_TO_IMAGE_BATCH_PARAMS
    a__     :						List[Any]      =				TEXT_TO_IMAGE_IMAGE_PARAMS
    a__     :						Optional[Any]      =				TEXT_TO_IMAGE_IMAGE_PARAMS
    a__     :						List[str]      =				False







    def       UpperCamelCase__       (     self)	->     Dict:
        torch.manual_seed(0)
        __UpperCamelCase					: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			,			)
        __UpperCamelCase					:List[str]        =		DDIMScheduler(
            beta_start=0.0_00_85			,			beta_end=0.0_12			,			beta_schedule='''scaled_linear'''			,			clip_sample=__lowercase			,			set_alpha_to_one=__lowercase			,			)
        torch.manual_seed(0)
        __UpperCamelCase					:Dict        =		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					: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=1_000			,			)
        __UpperCamelCase					:Tuple        =		CLIPTextModel(__lowercase)
        __UpperCamelCase					:Optional[Any]        =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        __UpperCamelCase					:int        =		{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase=0)	->     Union[str, Any]:
        if str(__lowercase).startswith('''mps'''):
            __UpperCamelCase					:Union[str, Any]        =		torch.manual_seed(__lowercase)
        else:
            __UpperCamelCase					:Optional[Any]        =		torch.Generator(device=__lowercase).manual_seed(__lowercase)
        __UpperCamelCase					:Any        =		{
            '''prompt''': '''.''',
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 1.0,
            '''sag_scale''': 1.0,
            '''output_type''': '''numpy''',
        }
        return inputs







    def       UpperCamelCase__       (     self)	->     Optional[int]:
        super().test_inference_batch_single_identical(expected_max_diff=3E-3)


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






    '''simple docstring'''






    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







    def       UpperCamelCase__       (     self)	->     Tuple:
        __UpperCamelCase					:str        =		StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4''')
        __UpperCamelCase					:Tuple        =		sag_pipe.to(__lowercase)
        sag_pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase					:Optional[Any]        =		'''.'''
        __UpperCamelCase					:Union[str, Any]        =		torch.manual_seed(0)
        __UpperCamelCase					:List[str]        =		sag_pipe(
            [prompt]			,			generator=__lowercase			,			guidance_scale=7.5			,			sag_scale=1.0			,			num_inference_steps=20			,			output_type='''np''')

        __UpperCamelCase					:List[Any]        =		output.images

        __UpperCamelCase					:Optional[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       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase					:Optional[int]        =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''')
        __UpperCamelCase					:List[str]        =		sag_pipe.to(__lowercase)
        sag_pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase					:Dict        =		'''.'''
        __UpperCamelCase					:List[Any]        =		torch.manual_seed(0)
        __UpperCamelCase					:Union[str, Any]        =		sag_pipe(
            [prompt]			,			generator=__lowercase			,			guidance_scale=7.5			,			sag_scale=1.0			,			num_inference_steps=20			,			output_type='''np''')

        __UpperCamelCase					:List[str]        =		output.images

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

        assert image.shape == (1, 512, 512, 3)
        __UpperCamelCase					:Optional[int]        =		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       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Dict        =		StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''')
        __UpperCamelCase					:Optional[Any]        =		sag_pipe.to(__lowercase)
        sag_pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase					:Union[str, Any]        =		'''.'''
        __UpperCamelCase					:int        =		torch.manual_seed(0)
        __UpperCamelCase					:Any        =		sag_pipe(
            [prompt]			,			width=768			,			height=512			,			generator=__lowercase			,			guidance_scale=7.5			,			sag_scale=1.0			,			num_inference_steps=20			,			output_type='''np'''			,			)

        __UpperCamelCase					:Optional[int]        =		output.images

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






def lowerCamelCase  (       SCREAMING_SNAKE_CASE     ):
    '''simple docstring'''







    if not grid or not grid[0]:
        raise TypeError('''The grid does not contain the appropriate information'''     )

    for cell_n in range(1  ,      len(grid[0]     )     ):
        grid[0][cell_n] += grid[0][cell_n - 1]
    __UpperCamelCase					:Union[str, Any]        =		grid[0]

    for row_n in range(1  ,      len(SCREAMING_SNAKE_CASE     )     ):
        __UpperCamelCase					:Optional[int]        =		grid[row_n]
        __UpperCamelCase					:Dict        =		fill_row(SCREAMING_SNAKE_CASE  ,      SCREAMING_SNAKE_CASE     )
        __UpperCamelCase					:Any        =		grid[row_n]

    return grid[-1][-1]



def lowerCamelCase  (       SCREAMING_SNAKE_CASE  ,      SCREAMING_SNAKE_CASE     ):
    '''simple docstring'''







    current_row[0] += row_above[0]
    for cell_n in range(1  ,      len(SCREAMING_SNAKE_CASE     )     ):
        current_row[cell_n] += min(current_row[cell_n - 1]  ,      row_above[cell_n]     )

    return current_row


if __name__ == "__main__":
    import doctest

    doctest.testmod()





