



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__( lowerCamelCase__		,			lowerCamelCase__		,			unittest.TestCase     ):
    lowercase__			=   StableDiffusionSAGPipeline
    lowercase__			=   TEXT_TO_IMAGE_PARAMS
    lowercase__			=   TEXT_TO_IMAGE_BATCH_PARAMS
    lowercase__			=   TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase__			=   TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase__			=   False







    def       lowercase_	(				self			:  Union[str, Any]     ):
      torch.manual_seed(0     )
      a						: 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						,      )
      a						: Optional[int]					       =					DDIMScheduler(
          beta_start=0.00085						,      beta_end=0.012						,      beta_schedule='scaled_linear'						,      clip_sample=__snake_case						,      set_alpha_to_one=__snake_case						,      )
      torch.manual_seed(0     )
      a						: List[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     )
      a						: 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=10_00						,      )
      a						: int					       =					CLIPTextModel(__snake_case     )
      a						: Optional[Any]					       =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

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







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  str						,      __snake_case			:  Tuple=0     ):




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







    def       lowercase_	(				self			:  Any     ):
      super().test_inference_batch_single_identical(expected_max_diff=3e-3     )

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







    def       lowercase_	(				self			:  Union[str, Any]     ):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







    def       lowercase_	(				self			:  Union[str, Any]     ):
      a						: Tuple					       =					StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'     )
      a						: Any					       =					sag_pipe.to(__snake_case     )
      sag_pipe.set_progress_bar_config(disable=__snake_case     )

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

      a						: Dict					       =					output.images

      a						: Optional[Any]					       =					image[0, -3:, -3:, -1]

      assert image.shape == (1, 5_12, 5_12, 3)
      a						: Optional[int]					       =					np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]     )

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







    def       lowercase_	(				self			:  int     ):
      a						: str					       =					StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'     )
      a						: List[Any]					       =					sag_pipe.to(__snake_case     )
      sag_pipe.set_progress_bar_config(disable=__snake_case     )

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

      a						: Any					       =					output.images

      a						: List[Any]					       =					image[0, -3:, -3:, -1]

      assert image.shape == (1, 5_12, 5_12, 3)
      a						: Optional[int]					       =					np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]     )

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







    def       lowercase_	(				self			:  Optional[Any]     ):
      a						: List[Any]					       =					StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'     )
      a						: Optional[int]					       =					sag_pipe.to(__snake_case     )
      sag_pipe.set_progress_bar_config(disable=__snake_case     )

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

      a						: List[str]					       =					output.images

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




'''simple docstring'''






import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase: Any							=						logging.get_logger(__name__)

class 							a__( lowerCamelCase__     ):
    lowercase__			=   """encoder-decoder"""
    lowercase__			=   True







    def __init__(				self			:  Dict						,      **__snake_case			:  Union[str, Any]     ):
      super().__init__(**__snake_case     )
      assert (
          "encoder" in kwargs and "decoder" in kwargs
      ), "Config has to be initialized with encoder and decoder config"
      a						: List[str]					       =					kwargs.pop('encoder'     )
      a						: Optional[Any]					       =					encoder_config.pop('model_type'     )
      a						: Tuple					       =					kwargs.pop('decoder'     )
      a						: Optional[int]					       =					decoder_config.pop('model_type'     )

      from ..auto.configuration_auto import AutoConfig

      a						: Any					       =					AutoConfig.for_model(__snake_case						,      **__snake_case     )
      a						: Optional[int]					       =					AutoConfig.for_model(__snake_case						,      **__snake_case     )
      a						: Tuple					       =					True







    @classmethod
    def       lowercase_	(				cls			:  int						,      __snake_case			:  PretrainedConfig						,      __snake_case			:  PretrainedConfig						,      **__snake_case			:  Union[str, Any]     ):
      logger.info('Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'     )
      a						: List[Any]					       =					True
      a						: Tuple					       =					True

      return cls(encoder=encoder_config.to_dict()						,      decoder=decoder_config.to_dict()						,      **__snake_case     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: int					       =					copy.deepcopy(self.__dict__     )
      a						: List[str]					       =					self.encoder.to_dict()
      a						: Optional[int]					       =					self.decoder.to_dict()
      a						: Optional[Any]					       =					self.__class__.model_type
      return output