





import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





def    __UpperCamelCase      (    a) ->int:
					lowerCamelCase__       =       [tensor.shape for tensor in tensor_list]
					return all(shape == shapes[0] for shape in shapes[1:])

class SCREAMING_SNAKE_CASE_ (					lowercase_							,       lowercase_							,       lowercase_							,       unittest.TestCase   ):





					"""simple docstring"""


					A__				 =    StableDiffusionLatentUpscalePipeline
					A__				 =    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
					    "height",
					    "width",
					    "cross_attention_kwargs",
					    "negative_prompt_embeds",
					    "prompt_embeds",
					}
					A__				 =    PipelineTesterMixin.required_optional_params - {"num_images_per_prompt"}
					A__				 =    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
					A__				 =    frozenset(
					    []   )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
					A__				 =    frozenset([]   )

					A__				 =    True





					@property
					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       1
										lowerCamelCase__       =       4
										lowerCamelCase__       =       (16, 16)

										lowerCamelCase__       =       floats_tensor((batch_size, num_channels) + sizes	,  rng=random.Random(0	)	).to(_lowerCAmelCase	)
										return image





					def 					__magic_name__ ( self	):
										torch.manual_seed(0	)
										lowerCamelCase__       =       UNetaDConditionModel(
										    act_fn="gelu"	,  attention_head_dim=8	,  norm_num_groups=_lowerCAmelCase	,  block_out_channels=[32, 32, 64, 64]	,  time_cond_proj_dim=160	,  conv_in_kernel=1	,  conv_out_kernel=1	,  cross_attention_dim=32	,  down_block_types=(
										        "KDownBlock2D",
										        "KCrossAttnDownBlock2D",
										        "KCrossAttnDownBlock2D",
										        "KCrossAttnDownBlock2D",
										    )	,  in_channels=8	,  mid_block_type=_lowerCAmelCase	,  only_cross_attention=_lowerCAmelCase	,  out_channels=5	,  resnet_time_scale_shift="scale_shift"	,  time_embedding_type="fourier"	,  timestep_post_act="gelu"	,  up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")	,  )
										lowerCamelCase__       =       AutoencoderKL(
										    block_out_channels=[32, 32, 64, 64]	,  in_channels=3	,  out_channels=3	,  down_block_types=[
										        "DownEncoderBlock2D",
										        "DownEncoderBlock2D",
										        "DownEncoderBlock2D",
										        "DownEncoderBlock2D",
										    ]	,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]	,  latent_channels=4	,  )
										lowerCamelCase__       =       EulerDiscreteScheduler(prediction_type="sample"	)
										lowerCamelCase__       =       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="quick_gelu"	,  projection_dim=512	,  )
										lowerCamelCase__       =       CLIPTextModel(_lowerCAmelCase	)
										lowerCamelCase__       =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

										lowerCamelCase__       =       {
										    "unet": model.eval(),
										    "vae": vae.eval(),
										    "scheduler": scheduler,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										}

										return components





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase=0	):
										if str(_lowerCAmelCase	).startswith("mps"	):
															lowerCamelCase__       =       torch.manual_seed(_lowerCAmelCase	)
										else:
															lowerCamelCase__       =       torch.Generator(device=_lowerCAmelCase	).manual_seed(_lowerCAmelCase	)
										lowerCamelCase__       =       {
										    "prompt": "A painting of a squirrel eating a burger",
										    "image": self.dummy_image.cpu(),
										    "generator": generator,
										    "num_inference_steps": 2,
										    "output_type": "numpy",
										}
										return inputs





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       "cpu"

										lowerCamelCase__       =       self.get_dummy_components()
										lowerCamelCase__       =       self.pipeline_class(**_lowerCAmelCase	)
										pipe.to(_lowerCAmelCase	)
										pipe.set_progress_bar_config(disable=_lowerCAmelCase	)

										lowerCamelCase__       =       self.get_dummy_inputs(_lowerCAmelCase	)
										lowerCamelCase__       =       pipe(**_lowerCAmelCase	).images
										lowerCamelCase__       =       image[0, -3:, -3:, -1]

										self.assertEqual(image.shape	,  (1, 256, 256, 3)	)
										lowerCamelCase__       =       np.array(
										    [0.47_222_412, 0.41_921_633, 0.44_717_434, 0.46_874_192, 0.42_588_258, 0.46_150_726, 0.4_677_534, 0.45_583_832, 0.48_579_055]	)
										lowerCamelCase__       =       np.abs(image_slice.flatten() - expected_slice	).max()
										self.assertLessEqual(_lowerCAmelCase	,  1E-3	)





					def 					__magic_name__ ( self	):
										super().test_attention_slicing_forward_pass(expected_max_diff=7E-3	)





					def 					__magic_name__ ( self	):
										super().test_cpu_offload_forward_pass(expected_max_diff=3E-3	)





					def 					__magic_name__ ( self	):
										super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3	)





					def 					__magic_name__ ( self	):
										super().test_inference_batch_single_identical(expected_max_diff=7E-3	)





					def 					__magic_name__ ( self	):
										super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3E-3	)





					def 					__magic_name__ ( self	):
										super().test_save_load_local(expected_max_difference=3E-3	)





					def 					__magic_name__ ( self	):
										super().test_save_load_optional_components(expected_max_difference=3E-3	)






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       [
										    "DDIMScheduler",
										    "DDPMScheduler",
										    "PNDMScheduler",
										    "HeunDiscreteScheduler",
										    "EulerAncestralDiscreteScheduler",
										    "KDPM2DiscreteScheduler",
										    "KDPM2AncestralDiscreteScheduler",
										    "DPMSolverSDEScheduler",
										]
										lowerCamelCase__       =       self.get_dummy_components()
										lowerCamelCase__       =       self.pipeline_class(**_lowerCAmelCase	)

										# make sure that PNDM does not need warm-up
										pipe.scheduler.register_to_config(skip_prk_steps=_lowerCAmelCase	)

										pipe.to(_lowerCAmelCase	)
										pipe.set_progress_bar_config(disable=_lowerCAmelCase	)
										lowerCamelCase__       =       self.get_dummy_inputs(_lowerCAmelCase	)
										lowerCamelCase__       =       2

										lowerCamelCase__       =       []
										for scheduler_enum in KarrasDiffusionSchedulers:
															if scheduler_enum.name in skip_schedulers:
																				# no sigma schedulers are not supported
																				# no schedulers
																				continue

															lowerCamelCase__       =       getattr(_lowerCAmelCase	,  scheduler_enum.name	)
															lowerCamelCase__       =       scheduler_cls.from_config(pipe.scheduler.config	)
															lowerCamelCase__       =       pipe(**_lowerCAmelCase	)[0]
															outputs.append(_lowerCAmelCase	)

										assert check_same_shape(_lowerCAmelCase	)

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





					"""simple docstring"""


					def 					__magic_name__ ( self	):
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       torch.manual_seed(33	)

										lowerCamelCase__       =       StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"	,  torch_dtype=torch.floataa	)
										pipe.to("cuda"	)

										lowerCamelCase__       =       StableDiffusionLatentUpscalePipeline.from_pretrained(
										    "stabilityai/sd-x2-latent-upscaler"	,  torch_dtype=torch.floataa	)
										upscaler.to("cuda"	)

										lowerCamelCase__       =       "a photo of an astronaut high resolution, unreal engine, ultra realistic"

										lowerCamelCase__       =       pipe(_lowerCAmelCase	,  generator=_lowerCAmelCase	,  output_type="latent"	).images

										lowerCamelCase__       =       upscaler(
										    prompt=_lowerCAmelCase	,  image=_lowerCAmelCase	,  num_inference_steps=20	,  guidance_scale=0	,  generator=_lowerCAmelCase	,  output_type="np"	,  ).images[0]

										lowerCamelCase__       =       load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy"	)
										assert np.abs((expected_image - image).mean()	) < 5E-2






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       torch.manual_seed(33	)

										lowerCamelCase__       =       StableDiffusionLatentUpscalePipeline.from_pretrained(
										    "stabilityai/sd-x2-latent-upscaler"	,  torch_dtype=torch.floataa	)
										upscaler.to("cuda"	)

										lowerCamelCase__       =       "the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas"

										lowerCamelCase__       =       load_image(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png"	)

										lowerCamelCase__       =       upscaler(
										    prompt=_lowerCAmelCase	,  image=_lowerCAmelCase	,  num_inference_steps=20	,  guidance_scale=0	,  generator=_lowerCAmelCase	,  output_type="np"	,  ).images[0]

										lowerCamelCase__       =       load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy"	)
										assert np.abs((expected_image - image).max()	) < 5E-2








A_												=     {str(digit): digit**5 for digit in range(1_0)}





def    __UpperCamelCase      (    a) ->int:
					return sum(DIGITS_FIFTH_POWER[digit] for digit in str(a))





def    __UpperCamelCase      (    ) ->int:
					return sum(
					    number
					    for number in range(1000,     1000000)
					    if number == digits_fifth_powers_sum(a))


if __name__ == "__main__":
						print(solution())

