






"""simple docstring"""







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        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  [tensor.shape for tensor in tensor_list]
					return all(shape == shapes[0] for shape in shapes[1:])







class        _SCREAMING_SNAKE_CASE						(  __snake_case       , __snake_case       , __snake_case       , unittest.TestCase							):





							"""simple docstring"""





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

							_SCREAMING_SNAKE_CASE    =True




							@property
							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

												a__          =  1
												a__          =  4
												a__          =  (16, 16)

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




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												torch.manual_seed(0    )
												a__          =  UNetaDConditionModel(
												    act_fn='''gelu'''				,		attention_head_dim=8				,		norm_num_groups=__A				,		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=__A				,		only_cross_attention=__A				,		out_channels=5				,		resnet_time_scale_shift='''scale_shift'''				,		time_embedding_type='''fourier'''				,		timestep_post_act='''gelu'''				,		up_block_types=('''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KUpBlock2D''')				,		)
												a__          =  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				,		)
												a__          =  EulerDiscreteScheduler(prediction_type='''sample'''    )
												a__          =  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				,		)
												a__          =  CLIPTextModel(__A    )
												a__          =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

												a__          =  {
												    '''unet''': model.eval(),
												    '''vae''': vae.eval(),
												    '''scheduler''': scheduler,
												    '''text_encoder''': text_encoder,
												    '''tokenizer''': tokenizer,
												}

												return components




							def  lowercase		(   self:     Tuple				,		__A:     Dict				,		__A:     List[str]=0    ):

												'''simple docstring'''

												if str(__A    ).startswith('''mps'''    ):
																	a__          =  torch.manual_seed(__A    )
												else:
																	a__          =  torch.Generator(device=__A    ).manual_seed(__A    )
												a__          =  {
												    '''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  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  '''cpu'''

												a__          =  self.get_dummy_components()
												a__          =  self.pipeline_class(**__A    )
												pipe.to(__A    )
												pipe.set_progress_bar_config(disable=__A    )

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

												self.assertEqual(image.shape				,		(1, 256, 256, 3)    )
												a__          =  np.array(
												    [0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5]    )
												a__          =  np.abs(image_slice.flatten() - expected_slice    ).max()
												self.assertLessEqual(__A				,		1e-3    )




							def  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

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




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

												'''simple docstring'''

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




							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

												super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3    )




							def  lowercase		(   self:     str    ):

												'''simple docstring'''

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




							def  lowercase		(   self:     List[Any]    ):

												'''simple docstring'''

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




							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												super().test_save_load_local(expected_max_difference=3e-3    )




							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												super().test_save_load_optional_components(expected_max_difference=3e-3    )





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

												'''simple docstring'''

												a__          =  [
												    '''DDIMScheduler''',
												    '''DDPMScheduler''',
												    '''PNDMScheduler''',
												    '''HeunDiscreteScheduler''',
												    '''EulerAncestralDiscreteScheduler''',
												    '''KDPM2DiscreteScheduler''',
												    '''KDPM2AncestralDiscreteScheduler''',
												    '''DPMSolverSDEScheduler''',
												]
												a__          =  self.get_dummy_components()
												a__          =  self.pipeline_class(**__A    )

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

												pipe.to(__A    )
												pipe.set_progress_bar_config(disable=__A    )
												a__          =  self.get_dummy_inputs(__A    )
												a__          =  2

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

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

												assert check_same_shape(__A    )







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





							"""simple docstring"""





							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

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




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

												'''simple docstring'''

												a__          =  torch.manual_seed(33    )

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

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

												a__          =  '''a photo of an astronaut high resolution, unreal engine, ultra realistic'''

												a__          =  pipe(__A				,		generator=__A				,		output_type='''latent'''    ).images

												a__          =  upscaler(
												    prompt=__A				,		image=__A				,		num_inference_steps=20				,		guidance_scale=0				,		generator=__A				,		output_type='''np'''				,		).images[0]

												a__          =  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  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  torch.manual_seed(33    )

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

												a__          =  '''the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'''

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

												a__          =  upscaler(
												    prompt=__A				,		image=__A				,		num_inference_steps=20				,		guidance_scale=0				,		generator=__A				,		output_type='''np'''				,		).images[0]

												a__          =  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










"""simple docstring"""







def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					assert column_title.isupper()
					a__          =  0
					a__          =  len(lowerCamelCase_) - 1
					a__          =  0

					while index >= 0:
										a__          =  (ord(column_title[index]) - 64) * pow(26 ,     lowerCamelCase_)
										answer += value
										power += 1
										index -= 1

					return answer


if __name__ == "__main__":
	from doctest import testmod

	testmod()


