


'''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 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__		,      SCREAMING_SNAKE_CASE__		,      unittest.TestCase):
 _lowerCamelCase			:       Union[str, Any]            =       StableDiffusionXLPipeline
 _lowerCamelCase			:       Tuple            =       TEXT_TO_IMAGE_PARAMS
 _lowerCamelCase			:       List[Any]            =       TEXT_TO_IMAGE_BATCH_PARAMS
 _lowerCamelCase			:       str            =       TEXT_TO_IMAGE_IMAGE_PARAMS
 _lowerCamelCase			:       Optional[Any]            =       TEXT_TO_IMAGE_IMAGE_PARAMS

 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    torch.manual_seed(0       )
    UpperCamelCase__			    =    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,       )
    UpperCamelCase__			    =    EulerDiscreteScheduler(
        beta_start=0.00_085,       beta_end=0.012,       steps_offset=1,       beta_schedule="scaled_linear",       timestep_spacing="leading",       )
    torch.manual_seed(0       )
    UpperCamelCase__			    =    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=128,       )
    torch.manual_seed(0       )
    UpperCamelCase__			    =    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=1000,       hidden_act="gelu",       projection_dim=32,       )
    UpperCamelCase__			    =    CLIPTextModel(a_       )
    UpperCamelCase__			    =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip",       local_files_only=a_       )

    UpperCamelCase__			    =    CLIPTextModelWithProjection(a_       )
    UpperCamelCase__			    =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip",       local_files_only=a_       )

    UpperCamelCase__			    =    {
        "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 		lowercase_    (			self			:						Optional[int],       a_			:						int,       a_			:						Union[str, Any]=0       ):





    """simple docstring"""



    if str(a_       ).startswith("mps"       ):
       UpperCamelCase__			    =    torch.manual_seed(a_       )
    else:
       UpperCamelCase__			    =    torch.Generator(device=a_       ).manual_seed(a_       )
    UpperCamelCase__			    =    {
        "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 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    "cpu"  # ensure determinism for the device-dependent torch.Generator
    UpperCamelCase__			    =    self.get_dummy_components()
    UpperCamelCase__			    =    StableDiffusionXLPipeline(**a_       )
    UpperCamelCase__			    =    sd_pipe.to(a_       )
    sd_pipe.set_progress_bar_config(disable=a_       )

    UpperCamelCase__			    =    self.get_dummy_inputs(a_       )
    UpperCamelCase__			    =    sd_pipe(**a_       ).images
    UpperCamelCase__			    =    image[0, -3:, -3:, -1]

    assert image.shape == (1, 64, 64, 3)
    UpperCamelCase__			    =    np.array([0.5_873, 0.6_128, 0.4_797, 0.5_122, 0.5_674, 0.4_639, 0.5_227, 0.5_149, 0.4_747]       )

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

 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_dummy_components()
    UpperCamelCase__			    =    StableDiffusionXLPipeline(**a_       )
    UpperCamelCase__			    =    sd_pipe.to(a_       )
    UpperCamelCase__			    =    sd_pipe.to(a_       )
    sd_pipe.set_progress_bar_config(disable=a_       )

    # forward without prompt embeds
    UpperCamelCase__			    =    self.get_dummy_inputs(a_       )
    UpperCamelCase__			    =    3 * ["this is a negative prompt"]
    UpperCamelCase__			    =    negative_prompt
    UpperCamelCase__			    =    3 * [inputs["prompt"]]

    UpperCamelCase__			    =    sd_pipe(**a_       )
    UpperCamelCase__			    =    output.images[0, -3:, -3:, -1]

    # forward with prompt embeds
    UpperCamelCase__			    =    self.get_dummy_inputs(a_       )
    UpperCamelCase__			    =    3 * ["this is a negative prompt"]
    UpperCamelCase__			    =    3 * [inputs.pop("prompt"       )]

    (
        (
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		
    )			    =    sd_pipe.encode_prompt(a_,       negative_prompt=a_       )

    UpperCamelCase__			    =    sd_pipe(
        **a_,       prompt_embeds=a_,       negative_prompt_embeds=a_,       pooled_prompt_embeds=a_,       negative_pooled_prompt_embeds=a_,       )
    UpperCamelCase__			    =    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 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



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

 def 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



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







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

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



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

 def 		lowercase_    (			self			:						Tuple,       a_			:						Optional[Any],       a_			:						Optional[Any]="cpu",       a_			:						Dict=torch.floataa,       a_			:						Union[str, Any]=0       ):





    """simple docstring"""



    UpperCamelCase__			    =    torch.Generator(device=a_       ).manual_seed(a_       )
    UpperCamelCase__			    =    np.random.RandomState(a_       ).standard_normal((1, 4, 64, 64)       )
    UpperCamelCase__			    =    torch.from_numpy(a_       ).to(device=a_,       dtype=a_       )
    UpperCamelCase__			    =    {
        "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 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



    UpperCamelCase__			    =    DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-base"       )
    pipe.to(a_       )
    pipe.set_progress_bar_config(disable=a_       )

    UpperCamelCase__			    =    self.get_inputs(a_       )
    UpperCamelCase__			    =    pipe(**a_       ).images
    UpperCamelCase__			    =    image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 512, 512, 3)
    UpperCamelCase__			    =    np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]       )
    assert np.abs(image_slice - expected_slice       ).max() < 7e-3





'''simple docstring'''







def 		snake_case_				(_a      :				float       ,  _a      :				float       ,  _a      :				float	):
    if hue < 0 or hue > 3_6_0:
        raise Exception('''hue should be between 0 and 360'''	)

    if saturation < 0 or saturation > 1:
        raise Exception('''saturation should be between 0 and 1'''	)

    if value < 0 or value > 1:
        raise Exception('''value should be between 0 and 1'''	)

    UpperCAmelCase     			=						value * saturation
    UpperCAmelCase     			=						hue / 6_0
    UpperCAmelCase     			=						chroma * (1 - abs(hue_section % 2 - 1	))
    UpperCAmelCase     			=						value - chroma

    if hue_section >= 0 and hue_section <= 1:
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
    elif hue_section > 1 and hue_section <= 2:
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
    elif hue_section > 2 and hue_section <= 3:
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
    elif hue_section > 3 and hue_section <= 4:
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
    elif hue_section > 4 and hue_section <= 5:
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
    else:
        UpperCAmelCase     			=						round(2_5_5 * (chroma + match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (match_value)	)
        UpperCAmelCase     			=						round(2_5_5 * (second_largest_component + match_value)	)

    return [red, green, blue]





def 		snake_case_				(_a      :				int       ,  _a      :				int       ,  _a      :				int	):
    if red < 0 or red > 2_5_5:
        raise Exception('''red should be between 0 and 255'''	)

    if green < 0 or green > 2_5_5:
        raise Exception('''green should be between 0 and 255'''	)

    if blue < 0 or blue > 2_5_5:
        raise Exception('''blue should be between 0 and 255'''	)

    UpperCAmelCase     			=						red / 2_5_5
    UpperCAmelCase     			=						green / 2_5_5
    UpperCAmelCase     			=						blue / 2_5_5
    UpperCAmelCase     			=						max(_a       ,  _a       ,  _a	)
    UpperCAmelCase     			=						value - min(_a       ,  _a       ,  _a	)
    UpperCAmelCase     			=						0 if value == 0 else chroma / value

    if chroma == 0:
        UpperCAmelCase     			=						0.0
    elif value == float_red:
        UpperCAmelCase     			=						6_0 * (0 + (float_green - float_blue) / chroma)
    elif value == float_green:
        UpperCAmelCase     			=						6_0 * (2 + (float_blue - float_red) / chroma)
    else:
        UpperCAmelCase     			=						6_0 * (4 + (float_red - float_green) / chroma)

    UpperCAmelCase     			=						(hue + 3_6_0) % 3_6_0

    return [hue, saturation, value]







def 		snake_case_				(_a      :				list[float]       ,  _a      :				list[float]	):
    UpperCAmelCase     			=						abs(hsv_a[0] - hsv_a[0]	) < 0.2
    UpperCAmelCase     			=						abs(hsv_a[1] - hsv_a[1]	) < 0.002
    UpperCAmelCase     			=						abs(hsv_a[2] - hsv_a[2]	) < 0.002

    return check_hue and check_saturation and check_value




