"""simple docstring"""
import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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   __snake_case			(	A_			, A_			, unittest.TestCase							):
      a__								=						StableDiffusionXLPipeline
      a__								=						TEXT_TO_IMAGE_PARAMS
      a__								=						TEXT_TO_IMAGE_BATCH_PARAMS
      a__								=						TEXT_TO_IMAGE_IMAGE_PARAMS
      a__								=						TEXT_TO_IMAGE_IMAGE_PARAMS



      def     lowerCamelCase_  (		self)      ->     Dict:





        '''simple docstring'''





        torch.manual_seed(0)
        a__:	Union[str, Any]     				=      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')       ,     attention_head_dim=(2, 4)       ,     use_linear_projection=A_       ,     addition_embed_type='text_time'       ,     addition_time_embed_dim=8       ,     transformer_layers_per_block=(1, 2)       ,     projection_class_embeddings_input_dim=80       ,     cross_attention_dim=64       ,     )
        a__:	List[str]     				=      EulerDiscreteScheduler(
            beta_start=0.00085       ,     beta_end=0.012       ,     steps_offset=1       ,     beta_schedule='scaled_linear'       ,     timestep_spacing='leading'       ,     )
        torch.manual_seed(0)
        a__:	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       ,     sample_size=1_28       ,     )
        torch.manual_seed(0)
        a__:	Tuple     				=      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=10_00       ,     hidden_act='gelu'       ,     projection_dim=32       ,     )
        a__:	Union[str, Any]     				=      CLIPTextModel(A_)
        a__:	Optional[int]     				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       ,     local_files_only=A_)

        a__:	int     				=      CLIPTextModelWithProjection(A_)
        a__:	Optional[Any]     				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       ,     local_files_only=A_)

        a__:	Dict     				=      {
            'unet': unet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'text_encoder_2': text_encoder_a,
            'tokenizer_2': tokenizer_a,
            # "safety_checker": None,
            # "feature_extractor": None,
        }
        return components



      def     lowerCamelCase_  (		self       ,     lowercase       ,     lowercase=0)      ->     List[Any]:





        '''simple docstring'''





        if str(A_).startswith('mps'):
          a__:	str     				=      torch.manual_seed(A_)
        else:
          a__:	Dict     				=      torch.Generator(device=A_).manual_seed(A_)
        a__:	List[str]     				=      {
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 5.0,
            'output_type': 'numpy',
        }
        return inputs



      def     lowerCamelCase_  (		self)      ->     Any:





        '''simple docstring'''





        a__:	int     				=      'cpu'  # ensure determinism for the device-dependent torch.Generator
        a__:	Union[str, Any]     				=      self.get_dummy_components()
        a__:	List[Any]     				=      StableDiffusionXLPipeline(**A_)
        a__:	Union[str, Any]     				=      sd_pipe.to(A_)
        sd_pipe.set_progress_bar_config(disable=A_)

        a__:	str     				=      self.get_dummy_inputs(A_)
        a__:	Dict     				=      sd_pipe(**A_).images
        a__:	Dict     				=      image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        a__:	Optional[int]     				=      np.array([0.5873, 0.6128, 0.4797, 0.5122, 0.5674, 0.4639, 0.5227, 0.5149, 0.4747])

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



      def     lowerCamelCase_  (		self)      ->     Optional[Any]:





        '''simple docstring'''





        a__:	List[Any]     				=      self.get_dummy_components()
        a__:	List[Any]     				=      StableDiffusionXLPipeline(**A_)
        a__:	int     				=      sd_pipe.to(A_)
        a__:	List[Any]     				=      sd_pipe.to(A_)
        sd_pipe.set_progress_bar_config(disable=A_)

        # forward without prompt embeds
        a__:	Union[str, Any]     				=      self.get_dummy_inputs(A_)
        a__:	Tuple     				=      3 * ['this is a negative prompt']
        a__:	List[Any]     				=      negative_prompt
        a__:	Dict     				=      3 * [inputs['prompt']]

        a__:	Optional[Any]     				=      sd_pipe(**A_)
        a__:	Tuple     				=      output.images[0, -3:, -3:, -1]

        # forward with prompt embeds
        a__:	List[Any]     				=      self.get_dummy_inputs(A_)
        a__:	Optional[int]     				=      3 * ['this is a negative prompt']
        a__:	Optional[int]     				=      3 * [inputs.pop('prompt')]

        (
            (
            a__ 
        )				,       (
            a__ 
        )				,       (
            a__ 
        )				,       (
            a__ 
        )				,        
        ):	Union[str, Any]     				=      sd_pipe.encode_prompt(A_       ,     negative_prompt=A_)

        a__:	str     				=      sd_pipe(
            **A_       ,     prompt_embeds=A_       ,     negative_prompt_embeds=A_       ,     pooled_prompt_embeds=A_       ,     negative_pooled_prompt_embeds=A_       ,     )
        a__:	Union[str, Any]     				=      output.images[0, -3:, -3:, -1]

        # make sure that it's equal
        assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1e-4



      def     lowerCamelCase_  (		self)      ->     List[Any]:





        '''simple docstring'''





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



      def     lowerCamelCase_  (		self)      ->     str:





        '''simple docstring'''





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







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



      def     lowerCamelCase_  (		self)      ->     Optional[int]:





        '''simple docstring'''





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



      def     lowerCamelCase_  (		self       ,     lowercase       ,     lowercase="cpu"       ,     lowercase=torch.floataa       ,     lowercase=0)      ->     Optional[int]:





        '''simple docstring'''





        a__:	List[str]     				=      torch.Generator(device=A_).manual_seed(A_)
        a__:	List[str]     				=      np.random.RandomState(A_).standard_normal((1, 4, 64, 64))
        a__:	List[str]     				=      torch.from_numpy(A_).to(device=A_       ,     dtype=A_)
        a__:	Any     				=      {
            'prompt': 'a photograph of an astronaut riding a horse',
            'latents': latents,
            'generator': generator,
            'num_inference_steps': 3,
            'guidance_scale': 7.5,
            'output_type': 'numpy',
        }
        return inputs



      def     lowerCamelCase_  (		self)      ->     List[str]:





        '''simple docstring'''





        a__:	Optional[int]     				=      DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base')
        pipe.to(A_)
        pipe.set_progress_bar_config(disable=A_)

        a__:	str     				=      self.get_inputs(A_)
        a__:	Optional[int]     				=      pipe(**A_).images
        a__:	int     				=      image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 5_12, 5_12, 3)
        a__:	Optional[int]     				=      np.array([0.49493, 0.47896, 0.40798, 0.54214, 0.53212, 0.48202, 0.47656, 0.46329, 0.48506])
        assert np.abs(image_slice - expected_slice).max() < 7e-3






def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   list     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int							):
     __UpperCamelCase       				=int((lower_bound + upper_bound) // 2							)
     if array[r] == value:
          return r
     if lower_bound >= upper_bound:
          return -1
     if array[r] < value:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	r + 1     ,	SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__							)
     else:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	r - 1     ,	SCREAMING_SNAKE_CASE__							)

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   list							):
     __UpperCamelCase       				=0
     if matrix[index][0] == value:
          return [index, 0]
     while index < len(SCREAMING_SNAKE_CASE__							) and matrix[index][0] < value:
          __UpperCamelCase       				=binary_search(matrix[index]     ,	0     ,	len(matrix[index]							) - 1     ,	SCREAMING_SNAKE_CASE__							)
          if r != -1:
               return [index, r]
          index += 1
     return [-1, -1]


if __name__ == "__main__":
   import doctest

   doctest.testmod()





