
import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class        UpperCAmelCase_			( _a  ,       _a  ,       unittest.TestCase     ):


  '''simple docstring'''







  a__           =		StableDiffusionXLImgaImgPipeline
  a__           =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
  a__           =		PipelineTesterMixin.required_optional_params - {"""latents"""}
  a__           =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  a__           =		IMAGE_TO_IMAGE_IMAGE_PARAMS
  a__           =		IMAGE_TO_IMAGE_IMAGE_PARAMS
  def 							_lowercase							( self			: List[Any]    )			->	str:







    """simple docstring"""






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

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

    __magic_name__				     =       {
        """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			: Dict			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Tuple=0    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       floats_tensor((1, 3, 32, 32)			,							rng=random.Random(snake_case_    )    ).to(snake_case_    )
    __magic_name__				     =       image / 2 + 0.5
    if str(snake_case_    ).startswith("""mps"""    ):
      __magic_name__				     =       torch.manual_seed(snake_case_    )
    else:
      __magic_name__				     =       torch.Generator(device=snake_case_    ).manual_seed(snake_case_    )
    __magic_name__				     =       {
        """prompt""": """A painting of a squirrel eating a burger""",
        """image""": image,
        """generator""": generator,
        """num_inference_steps""": 2,
        """guidance_scale""": 5.0,
        """output_type""": """numpy""",
        """strength""": 0.75,
    }
    return inputs
  def 							_lowercase							( self			: Dict    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       """cpu"""  # ensure determinism for the device-dependent torch.Generator
    __magic_name__				     =       self.get_dummy_components()
    __magic_name__				     =       StableDiffusionXLImgaImgPipeline(**snake_case_    )
    __magic_name__				     =       sd_pipe.to(snake_case_    )
    sd_pipe.set_progress_bar_config(disable=snake_case_    )

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

    assert image.shape == (1, 32, 32, 3)

    __magic_name__				     =       np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165]    )

    assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
  def 							_lowercase							( self			: Union[str, Any]    )			->	Optional[int]:







    """simple docstring"""






    super().test_attention_slicing_forward_pass(expected_max_diff=3E-3    )
  def 							_lowercase							( self			: Any    )			->	str:







    """simple docstring"""






    super().test_inference_batch_single_identical(expected_max_diff=3E-3    )
  def 							_lowercase							( self			: Any    )			->	List[Any]:







    """simple docstring"""






    pass





  def 							_lowercase							( self			: List[str]    )			->	int:







    """simple docstring"""






    __magic_name__				     =       self.get_dummy_components()
    __magic_name__				     =       StableDiffusionXLImgaImgPipeline(**snake_case_    )
    __magic_name__				     =       sd_pipe.to(snake_case_    )
    __magic_name__				     =       sd_pipe.to(snake_case_    )
    sd_pipe.set_progress_bar_config(disable=snake_case_    )

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

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

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

    (
        __magic_name__				
    )				     =       sd_pipe.encode_prompt(snake_case_			,							negative_prompt=snake_case_    )

    __magic_name__				     =       sd_pipe(
        **snake_case_			,							prompt_embeds=snake_case_			,							negative_prompt_embeds=snake_case_			,							pooled_prompt_embeds=snake_case_			,							negative_pooled_prompt_embeds=snake_case_			,							)
    __magic_name__				     =       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







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


  '''simple docstring'''







  def 							_lowercase							( self			: Union[str, Any]    )			->	List[Any]:







    """simple docstring"""






    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()
  def 							_lowercase							( self			: Optional[Any]			,							UpperCamelCase__			: Optional[int]			,							UpperCamelCase__			: Optional[int]="cpu"			,							UpperCamelCase__			: Dict=torch.floataa			,							UpperCamelCase__			: Optional[int]=0    )			->	Optional[int]:







    """simple docstring"""






    __magic_name__				     =       torch.Generator(device=snake_case_    ).manual_seed(snake_case_    )
    __magic_name__				     =       np.random.RandomState(snake_case_    ).standard_normal((1, 4, 64, 64)    )
    __magic_name__				     =       torch.from_numpy(snake_case_    ).to(device=snake_case_			,							dtype=snake_case_    )
    __magic_name__				     =       {
        """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			: List[Any]    )			->	int:







    """simple docstring"""






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

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

    assert image.shape == (1, 512, 512, 3)
    __magic_name__				     =       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






'''simple docstring'''





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


__a          =		logging.get_logger(__name__)

__a          =		{
    "vinvino02/glpn-kitti": "https://huggingface.co/vinvino02/glpn-kitti/resolve/main/config.json",
    # See all GLPN models at https://huggingface.co/models?filter=glpn
}







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    lowercase					=		"glpn"




    def __init__(    self					:     Optional[Any] ,     snake_case_					:     List[str]=3 ,     snake_case_					:     Dict=4 ,     snake_case_					:     List[Any]=[2, 2, 2, 2] ,     snake_case_					:     int=[8, 4, 2, 1] ,     snake_case_					:     List[str]=[32, 64, 160, 256] ,     snake_case_					:     Tuple=[7, 3, 3, 3] ,     snake_case_					:     List[Any]=[4, 2, 2, 2] ,     snake_case_					:     Tuple=[1, 2, 5, 8] ,     snake_case_					:     List[str]=[4, 4, 4, 4] ,     snake_case_					:     Optional[int]="gelu" ,     snake_case_					:     Dict=0.0 ,     snake_case_					:     Union[str, Any]=0.0 ,     snake_case_					:     List[Any]=0.02 ,     snake_case_					:     Tuple=0.1 ,     snake_case_					:     Any=1E-6 ,     snake_case_					:     Dict=64 ,     snake_case_					:     Tuple=10 ,     snake_case_					:     List[Any]=-1 ,     **snake_case_					:     Optional[Any] ,     ):
          super().__init__(**snake_case_						)

          snake_case__  :    Optional[Any]    						=      num_channels
          snake_case__  :    Dict    						=      num_encoder_blocks
          snake_case__  :    Tuple    						=      depths
          snake_case__  :    Union[str, Any]    						=      sr_ratios
          snake_case__  :    Tuple    						=      hidden_sizes
          snake_case__  :    Optional[Any]    						=      patch_sizes
          snake_case__  :    int    						=      strides
          snake_case__  :    List[Any]    						=      mlp_ratios
          snake_case__  :    Optional[int]    						=      num_attention_heads
          snake_case__  :    Dict    						=      hidden_act
          snake_case__  :    int    						=      hidden_dropout_prob
          snake_case__  :    Optional[Any]    						=      attention_probs_dropout_prob
          snake_case__  :    str    						=      initializer_range
          snake_case__  :    List[str]    						=      drop_path_rate
          snake_case__  :    int    						=      layer_norm_eps
          snake_case__  :    Tuple    						=      decoder_hidden_size
          snake_case__  :    List[Any]    						=      max_depth
          snake_case__  :    Dict    						=      head_in_index
