"""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        _snake_case   (    a__ ,       a__ ,       unittest.TestCase						):
						snake_case__	     =	StableDiffusionXLImgaImgPipeline
						snake_case__	     =	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
						snake_case__	     =	PipelineTesterMixin.required_optional_params - {"""latents"""}
						snake_case__	     =	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
						snake_case__	     =	IMAGE_TO_IMAGE_IMAGE_PARAMS
						snake_case__	     =	IMAGE_TO_IMAGE_IMAGE_PARAMS






						def 					lowerCamelCase__   (				self					:	Dict			):
													torch.manual_seed(0			)
													__lowerCamelCase    :						Optional[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=__UpperCAmelCase							,    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							,    )
													__lowerCamelCase    :						str						      =   EulerDiscreteScheduler(
													    beta_start=0.0_0_0_8_5							,    beta_end=0.0_1_2							,    steps_offset=1							,    beta_schedule="scaled_linear"							,    timestep_spacing="leading"							,    )
													torch.manual_seed(0			)
													__lowerCamelCase    :						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=128							,    )
													torch.manual_seed(0			)
													__lowerCamelCase    :						str						      =   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							,    )
													__lowerCamelCase    :						int						      =   CLIPTextModel(__UpperCAmelCase			)
													__lowerCamelCase    :						Tuple						      =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							,    local_files_only=__UpperCAmelCase			)

													__lowerCamelCase    :						Any						      =   CLIPTextModelWithProjection(__UpperCAmelCase			)
													__lowerCamelCase    :						Optional[Any]						      =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							,    local_files_only=__UpperCAmelCase			)

													__lowerCamelCase    :						str						      =   {
													    '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					:	Union[str, Any]							,    UpperCAmelCase					:	Dict							,    UpperCAmelCase					:	Dict=0			):
													__lowerCamelCase    :						Dict						      =   floats_tensor((1, 3, 32, 32)							,    rng=random.Random(__UpperCAmelCase			)			).to(__UpperCAmelCase			)
													__lowerCamelCase    :						Optional[int]						      =   image / 2 + 0.5
													if str(__UpperCAmelCase			).startswith("mps"			):
																				__lowerCamelCase    :						Optional[int]						      =   torch.manual_seed(__UpperCAmelCase			)
													else:
																				__lowerCamelCase    :						Optional[Any]						      =   torch.Generator(device=__UpperCAmelCase			).manual_seed(__UpperCAmelCase			)
													__lowerCamelCase    :						Dict						      =   {
													    '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.7_5,
													}
													return inputs






						def 					lowerCamelCase__   (				self					:	Tuple			):
													__lowerCamelCase    :						List[Any]						      =   'cpu'  # ensure determinism for the device-dependent torch.Generator
													__lowerCamelCase    :						int						      =   self.get_dummy_components()
													__lowerCamelCase    :						List[str]						      =   StableDiffusionXLImgaImgPipeline(**__UpperCAmelCase			)
													__lowerCamelCase    :						str						      =   sd_pipe.to(__UpperCAmelCase			)
													sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase			)

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

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

													__lowerCamelCase    :						List[str]						      =   np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5]			)

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






						def 					lowerCamelCase__   (				self					:	Optional[Any]			):
													super().test_attention_slicing_forward_pass(expected_max_diff=3E-3			)






						def 					lowerCamelCase__   (				self					:	Any			):
													super().test_inference_batch_single_identical(expected_max_diff=3E-3			)






						def 					lowerCamelCase__   (				self					:	Any			):
													pass







						def 					lowerCamelCase__   (				self					:	Optional[Any]			):
													__lowerCamelCase    :						Tuple						      =   self.get_dummy_components()
													__lowerCamelCase    :						str						      =   StableDiffusionXLImgaImgPipeline(**__UpperCAmelCase			)
													__lowerCamelCase    :						str						      =   sd_pipe.to(__UpperCAmelCase			)
													__lowerCamelCase    :						List[str]						      =   sd_pipe.to(__UpperCAmelCase			)
													sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase			)

													# forward without prompt embeds
													__lowerCamelCase    :						int						      =   self.get_dummy_inputs(__UpperCAmelCase			)
													__lowerCamelCase    :						Optional[int]						      =   3 * ['this is a negative prompt']
													__lowerCamelCase    :						Tuple						      =   negative_prompt
													__lowerCamelCase    :						str						      =   3 * [inputs['prompt']]

													__lowerCamelCase    :						Optional[Any]						      =   sd_pipe(**__UpperCAmelCase			)
													__lowerCamelCase    :						List[Any]						      =   output.images[0, -3:, -3:, -1]

													# forward with prompt embeds
													__lowerCamelCase    :						Optional[Any]						      =   self.get_dummy_inputs(__UpperCAmelCase			)
													__lowerCamelCase    :						Tuple						      =   3 * ['this is a negative prompt']
													__lowerCamelCase    :						str						      =   3 * [inputs.pop("prompt"			)]

													(
													    __lowerCamelCase				
													)    :						List[str]						      =   sd_pipe.encode_prompt(__UpperCAmelCase							,    negative_prompt=__UpperCAmelCase			)

													__lowerCamelCase    :						str						      =   sd_pipe(
													    **__UpperCAmelCase							,    prompt_embeds=__UpperCAmelCase							,    negative_prompt_embeds=__UpperCAmelCase							,    pooled_prompt_embeds=__UpperCAmelCase							,    negative_pooled_prompt_embeds=__UpperCAmelCase							,    )
													__lowerCamelCase    :						Optional[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

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






						def 					lowerCamelCase__   (				self					:	List[Any]			):
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






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

													__lowerCamelCase    :						Tuple						      =   self.get_inputs(__UpperCAmelCase			)
													__lowerCamelCase    :						int						      =   pipe(**__UpperCAmelCase			).images
													__lowerCamelCase    :						Union[str, Any]						      =   image[0, -3:, -3:, -1].flatten()

													assert image.shape == (1, 512, 512, 3)
													__lowerCamelCase    :						List[str]						      =   np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]			)
													assert np.abs(image_slice - expected_slice			).max() < 7E-3






"""simple docstring"""





def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->float:





  """simple docstring"""


  if discount_rate < 0:
    raise ValueError('Discount rate cannot be negative'			)
  if not cash_flows:
    raise ValueError('Cash flows list cannot be empty'			)
  lowerCAmelCase__			:Union[str, Any]											=							sum(
      cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(_SCREAMING_SNAKE_CASE			)			)
  return round(_SCREAMING_SNAKE_CASE     ,   ndigits=2			)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
