



"""simple docstring"""







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	(       UpperCAmelCase_   ,			UpperCAmelCase_   ,			unittest.TestCase					):





     """simple docstring"""






     _lowerCamelCase       :			Dict					 =StableDiffusionXLImgaImgPipeline
     _lowerCamelCase       :			List[str]					 =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
     _lowerCamelCase       :			List[str]					 =PipelineTesterMixin.required_optional_params - {"latents"}
     _lowerCamelCase       :			Union[str, Any]					 =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     _lowerCamelCase       :			List[str]					 =IMAGE_TO_IMAGE_IMAGE_PARAMS
     _lowerCamelCase       :			Optional[int]					 =IMAGE_TO_IMAGE_IMAGE_PARAMS





     def     A__	(       self			:				Tuple			):
          torch.manual_seed(0			)
          A__      						= UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)						,   layers_per_block=2						,   sample_size=3_2						,   in_channels=4						,   out_channels=4						,   down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')						,   up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')						,   attention_head_dim=(2, 4)						,   use_linear_projection=__lowerCamelCase						,   addition_embed_type='''text_time'''						,   addition_time_embed_dim=8						,   transformer_layers_per_block=(1, 2)						,   projection_class_embeddings_input_dim=8_0						,   cross_attention_dim=6_4						,   )
          A__      						= EulerDiscreteScheduler(
              beta_start=0.00_085						,   beta_end=0.012						,   steps_offset=1						,   beta_schedule='''scaled_linear'''						,   timestep_spacing='''leading'''						,   )
          torch.manual_seed(0			)
          A__      						= AutoencoderKL(
              block_out_channels=[3_2, 6_4]						,   in_channels=3						,   out_channels=3						,   down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']						,   up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']						,   latent_channels=4						,   sample_size=1_2_8						,   )
          torch.manual_seed(0			)
          A__      						= CLIPTextConfig(
              bos_token_id=0						,   eos_token_id=2						,   hidden_size=3_2						,   intermediate_size=3_7						,   layer_norm_eps=1E-05						,   num_attention_heads=4						,   num_hidden_layers=5						,   pad_token_id=1						,   vocab_size=1_0_0_0						,   hidden_act='''gelu'''						,   projection_dim=3_2						,   )
          A__      						= CLIPTextModel(__lowerCamelCase			)
          A__      						= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						,   local_files_only=__lowerCamelCase			)

          A__      						= CLIPTextModelWithProjection(__lowerCamelCase			)
          A__      						= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						,   local_files_only=__lowerCamelCase			)

          A__      						= {
              '''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     A__	(       self			:				Union[str, Any]						,   _lowerCamelCase			:				str						,   _lowerCamelCase			:				str=0			):
          A__      						= floats_tensor((1, 3, 3_2, 3_2)						,   rng=random.Random(__lowerCamelCase			)			).to(__lowerCamelCase			)
          A__      						= image / 2 + 0.5
          if str(__lowerCamelCase			).startswith('''mps'''			):
               A__      						= torch.manual_seed(__lowerCamelCase			)
          else:
               A__      						= torch.Generator(device=__lowerCamelCase			).manual_seed(__lowerCamelCase			)
          A__      						= {
              '''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     A__	(       self			:				str			):
          A__      						= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          A__      						= self.get_dummy_components()
          A__      						= StableDiffusionXLImgaImgPipeline(**__lowerCamelCase			)
          A__      						= sd_pipe.to(__lowerCamelCase			)
          sd_pipe.set_progress_bar_config(disable=__lowerCamelCase			)

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

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

          A__      						= np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165]			)

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





     def     A__	(       self			:				List[str]			):
          super().test_attention_slicing_forward_pass(expected_max_diff=3E-3			)





     def     A__	(       self			:				Optional[int]			):
          super().test_inference_batch_single_identical(expected_max_diff=3E-3			)





     def     A__	(       self			:				Tuple			):
          pass





     def     A__	(       self			:				str			):
          A__      						= self.get_dummy_components()
          A__      						= StableDiffusionXLImgaImgPipeline(**__lowerCamelCase			)
          A__      						= sd_pipe.to(__lowerCamelCase			)
          A__      						= sd_pipe.to(__lowerCamelCase			)
          sd_pipe.set_progress_bar_config(disable=__lowerCamelCase			)

          # forward without prompt embeds
          A__      						= self.get_dummy_inputs(__lowerCamelCase			)
          A__      						= 3 * ['''this is a negative prompt''']
          A__      						= negative_prompt
          A__      						= 3 * [inputs['''prompt''']]

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

          # forward with prompt embeds
          A__      						= self.get_dummy_inputs(__lowerCamelCase			)
          A__      						= 3 * ['''this is a negative prompt''']
          A__      						= 3 * [inputs.pop('''prompt'''			)]

          (
              (
              A__      
          )						,  (
              A__      
          )						,  (
              A__      
          )						,  (
              A__      
          )						,        
          )      						= sd_pipe.encode_prompt(__lowerCamelCase						,   negative_prompt=__lowerCamelCase			)

          A__      						= sd_pipe(
              **__lowerCamelCase						,   prompt_embeds=__lowerCamelCase						,   negative_prompt_embeds=__lowerCamelCase						,   pooled_prompt_embeds=__lowerCamelCase						,   negative_pooled_prompt_embeds=__lowerCamelCase						,   )
          A__      						= 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     A__	(       self			:				str			):
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()





     def     A__	(       self			:				Any						,   _lowerCamelCase			:				Optional[int]						,   _lowerCamelCase			:				Optional[int]="cpu"						,   _lowerCamelCase			:				List[str]=torch.floataa						,   _lowerCamelCase			:				Optional[int]=0			):
          A__      						= torch.Generator(device=__lowerCamelCase			).manual_seed(__lowerCamelCase			)
          A__      						= np.random.RandomState(__lowerCamelCase			).standard_normal((1, 4, 6_4, 6_4)			)
          A__      						= torch.from_numpy(__lowerCamelCase			).to(device=__lowerCamelCase						,   dtype=__lowerCamelCase			)
          A__      						= {
              '''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     A__	(       self			:				str			):
          A__      						= DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''			)
          pipe.to(__lowerCamelCase			)
          pipe.set_progress_bar_config(disable=__lowerCamelCase			)

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

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          A__      						= 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










SCREAMING_SNAKE_CASE_   :      dict[str, float]			=   {
    "joule": 1.0,
    "kilojoule": 1000,
    "megajoule": 100_0000,
    "gigajoule": 10_0000_0000,
    "wattsecond": 1.0,
    "watthour": 3600,
    "kilowatthour": 360_0000,
    "newtonmeter": 1.0,
    "calorie_nutr": 4186.8,
    "kilocalorie_nutr": 418_6800.00,
    "electronvolt": 1.6_0_2_1_7_6_6_3_4e-1_9,
    "britishthermalunit_it": 1055.0_5585,
    "footpound": 1.35_5818,
}



def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case						,   snake_case							)		->    float:
		if to_type not in ENERGY_CONVERSION or from_type not in ENERGY_CONVERSION:
				__lowercase											=     (
				    F"Incorrect 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"
				    F"Valid values are: {', '.join(snake_case							)}"
				)
				raise ValueError(snake_case							)
		return value * ENERGY_CONVERSION[from_type] / ENERGY_CONVERSION[to_type]


if __name__ == "__main__":
		import doctest

		doctest.testmod()




