




"""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      UpperCAmelCase_  (						a_,       a_,       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 							__magic_name__							(   self						:	int				)				->							Dict:




        '''simple docstring'''

        torch.manual_seed(0				)
        A__	=    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__	=    DDIMScheduler(
            beta_start=0.0_0085     ,			beta_end=0.012     ,			beta_schedule="scaled_linear"     ,			clip_sample=snake_case_     ,			set_alpha_to_one=snake_case_     ,			)
        torch.manual_seed(0				)
        A__	=    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__	=    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=1_000     ,			)
        A__	=    CLIPTextModel(snake_case_				)
        A__	=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

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




    def 							__magic_name__							(   self						:	Any     ,			snake_case_						:	int     ,			snake_case_						:	Tuple=0				)				->							Any:




        '''simple docstring'''

        if str(snake_case_				).startswith("mps"				):
            A__	=    torch.manual_seed(snake_case_				)
        else:
            A__	=    torch.Generator(device=snake_case_				).manual_seed(snake_case_				)
        A__	=    {
            "prompt": ".",
            "generator": generator,
            "num_inference_steps": 2,
            "guidance_scale": 1.0,
            "sag_scale": 1.0,
            "output_type": "numpy",
        }
        return inputs




    def 							__magic_name__							(   self						:	str				)				->							int:




        '''simple docstring'''

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






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




    def 							__magic_name__							(   self						:	List[Any]				)				->							Optional[int]:




        '''simple docstring'''

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




    def 							__magic_name__							(   self						:	str				)				->							Any:




        '''simple docstring'''

        A__	=    StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"				)
        A__	=    sag_pipe.to(snake_case_				)
        sag_pipe.set_progress_bar_config(disable=snake_case_				)

        A__	=    "."
        A__	=    torch.manual_seed(0				)
        A__	=    sag_pipe(
            [prompt]     ,			generator=snake_case_     ,			guidance_scale=7.5     ,			sag_scale=1.0     ,			num_inference_steps=20     ,			output_type="np"				)

        A__	=    output.images

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

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




        '''simple docstring'''

        A__	=    StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"				)
        A__	=    sag_pipe.to(snake_case_				)
        sag_pipe.set_progress_bar_config(disable=snake_case_				)

        A__	=    "."
        A__	=    torch.manual_seed(0				)
        A__	=    sag_pipe(
            [prompt]     ,			generator=snake_case_     ,			guidance_scale=7.5     ,			sag_scale=1.0     ,			num_inference_steps=20     ,			output_type="np"				)

        A__	=    output.images

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

        assert image.shape == (1, 512, 512, 3)
        A__	=    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 							__magic_name__							(   self						:	Tuple				)				->							Optional[Any]:




        '''simple docstring'''

        A__	=    StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"				)
        A__	=    sag_pipe.to(snake_case_				)
        sag_pipe.set_progress_bar_config(disable=snake_case_				)

        A__	=    "."
        A__	=    torch.manual_seed(0				)
        A__	=    sag_pipe(
            [prompt]     ,			width=768     ,			height=512     ,			generator=snake_case_     ,			guidance_scale=7.5     ,			sag_scale=1.0     ,			num_inference_steps=20     ,			output_type="np"     ,			)

        A__	=    output.images

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











"""simple docstring"""



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class      UpperCAmelCase_  (						A_							):
    lowercase__						 =				['''image_processor''', '''tokenizer''']
    lowercase__						 =				'''ViTImageProcessor'''
    lowercase__						 =				('''CLIPTokenizer''', '''CLIPTokenizerFast''')




    def __init__(   self						:	Optional[Any]     ,			snake_case_						:	Union[str, Any]=None     ,			snake_case_						:	Dict=None     ,			**snake_case_						:	Optional[Any]				)				->							List[str]:




     '''simple docstring'''

     A__	=    None
     if "feature_extractor" in kwargs:
      warnings.warn(
          "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
          " instead."     ,			snake_case_     ,			)
      A__	=    kwargs.pop("feature_extractor"				)

     A__	=    image_processor if image_processor is not None else feature_extractor
     if image_processor is None:
      raise ValueError("You need to specify an `image_processor`."				)
     if tokenizer is None:
      raise ValueError("You need to specify a `tokenizer`."				)

     super().__init__(snake_case_     ,			snake_case_				)




    def __call__(   self						:	int     ,			snake_case_						:	Union[str, Any]=None     ,			snake_case_						:	int=None     ,			snake_case_						:	Dict=None     ,			snake_case_						:	int=None     ,			**snake_case_						:	List[str]				)				->							Union[str, Any]:




     '''simple docstring'''

     if text is None and visual_prompt is None and images is None:
      raise ValueError("You have to specify either text, visual prompt or images."				)

     if text is not None and visual_prompt is not None:
      raise ValueError("You have to specify exactly one type of prompt. Either text or visual prompt."				)

     if text is not None:
      A__	=    self.tokenizer(snake_case_     ,			return_tensors=snake_case_     ,			**snake_case_				)

     if visual_prompt is not None:
      A__	=    self.image_processor(snake_case_     ,			return_tensors=snake_case_     ,			**snake_case_				)

     if images is not None:
      A__	=    self.image_processor(snake_case_     ,			return_tensors=snake_case_     ,			**snake_case_				)

     if visual_prompt is not None and images is not None:
      A__	=    {
          "pixel_values": image_features.pixel_values,
          "conditional_pixel_values": prompt_features.pixel_values,
      }
      return encoding
     elif text is not None and images is not None:
      A__	=    image_features.pixel_values
      return encoding
     elif text is not None:
      return encoding
     elif visual_prompt is not None:
      A__	=    {
          "conditional_pixel_values": prompt_features.pixel_values,
      }
      return encoding
     else:
      return BatchEncoding(data=dict(**snake_case_				)     ,			tensor_type=snake_case_				)




    def 							__magic_name__							(   self						:	Tuple     ,			*snake_case_						:	List[str]     ,			**snake_case_						:	Optional[int]				)				->							str:




     '''simple docstring'''

     return self.tokenizer.batch_decode(*snake_case_     ,			**snake_case_				)




    def 							__magic_name__							(   self						:	Optional[Any]     ,			*snake_case_						:	Any     ,			**snake_case_						:	List[Any]				)				->							List[str]:




     '''simple docstring'''

     return self.tokenizer.decode(*snake_case_     ,			**snake_case_				)




    @property
    def 							__magic_name__							(   self						:	int				)				->							Optional[int]:




     '''simple docstring'''

     warnings.warn(
         "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."     ,			snake_case_     ,			)
     return self.image_processor_class




    @property
    def 							__magic_name__							(   self						:	int				)				->							int:




     '''simple docstring'''

     warnings.warn(
         "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."     ,			snake_case_     ,			)
     return self.image_processor





