
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 	A_ (							snake_case							:   Optional[Any] )      ->    Tuple:



						'''simple docstring'''

						__UpperCamelCase       =			[tensor.shape for tensor in tensor_list]
						return all(shape == shapes[0] for shape in shapes[1:] )






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

							"""simple docstring"""






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

							_snake_case     		=  True



							@property
							def     A__		(  self			)->   str:





													'''simple docstring'''






													__UpperCamelCase       =			1
													__UpperCamelCase       =			4
													__UpperCamelCase       =			(16, 16)

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



							def     A__		(  self			)->   int:





													'''simple docstring'''






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

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

													return components



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=0			)->   Union[str, Any]:





													'''simple docstring'''






													if str(SCREAMING_SNAKE_CASE_			).startswith('''mps'''			):
																			__UpperCamelCase       =			torch.manual_seed(SCREAMING_SNAKE_CASE_			)
													else:
																			__UpperCamelCase       =			torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			{
													    '''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     A__		(  self			)->   Tuple:





													'''simple docstring'''






													__UpperCamelCase       =			'''cpu'''

													__UpperCamelCase       =			self.get_dummy_components()
													__UpperCamelCase       =			self.pipeline_class(**SCREAMING_SNAKE_CASE_			)
													pipe.to(SCREAMING_SNAKE_CASE_			)
													pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

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

													self.assertEqual(image.shape     ,	(1, 256, 256, 3)			)
													__UpperCamelCase       =			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]			)
													__UpperCamelCase       =			np.abs(image_slice.flatten() - expected_slice			).max()
													self.assertLessEqual(SCREAMING_SNAKE_CASE_     ,	1E-3			)



							def     A__		(  self			)->   int:





													'''simple docstring'''






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



							def     A__		(  self			)->   Any:





													'''simple docstring'''






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



							def     A__		(  self			)->   List[Any]:





													'''simple docstring'''






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



							def     A__		(  self			)->   List[str]:





													'''simple docstring'''






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



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





													'''simple docstring'''






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



							def     A__		(  self			)->   str:





													'''simple docstring'''






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



							def     A__		(  self			)->   Optional[Any]:





													'''simple docstring'''






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



							def     A__		(  self			)->   List[str]:





													'''simple docstring'''






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

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

													pipe.to(SCREAMING_SNAKE_CASE_			)
													pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			2

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

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

													assert check_same_shape(SCREAMING_SNAKE_CASE_			)






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

							"""simple docstring"""






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





													'''simple docstring'''






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



							def     A__		(  self			)->   Dict:





													'''simple docstring'''






													__UpperCamelCase       =			torch.manual_seed(33			)

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

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

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

													__UpperCamelCase       =			pipe(SCREAMING_SNAKE_CASE_     ,	generator=SCREAMING_SNAKE_CASE_     ,	output_type='''latent'''			).images

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

													__UpperCamelCase       =			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     A__		(  self			)->   int:





													'''simple docstring'''






													__UpperCamelCase       =			torch.manual_seed(33			)

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

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

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

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

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






def 	A_ (							snake_case							:   int = 10 ,      snake_case							:   int = 1000 ,      snake_case							:   bool = True )      ->    int:



						'''simple docstring'''

						assert (
						    isinstance(snake_case ,      snake_case )
						    and isinstance(snake_case ,      snake_case )
						    and isinstance(snake_case ,      snake_case )
						), "Invalid type of value(s) specified to function!"

						if min_val > max_val:
												raise ValueError('''Invalid value for min_val or max_val (min_value < max_value)''' )
						return min_val if option else max_val




def 	A_ (							snake_case							:   int ,      snake_case							:   int )      ->    int:



						'''simple docstring'''

						return int((number_a + number_a) / 2 )




def 	A_ (							snake_case							:   int ,      snake_case							:   int ,      snake_case							:   int )      ->    None:



						'''simple docstring'''

						assert (
						    isinstance(snake_case ,      snake_case ) and isinstance(snake_case ,      snake_case ) and isinstance(snake_case ,      snake_case )
						), 'argument values must be type of "int"'

						if lower > higher:
												raise ValueError('''argument value for lower and higher must be(lower > higher)''' )

						if not lower < to_guess < higher:
												raise ValueError(
												    '''guess value must be within the range of lower and higher value''' )

						def answer(snake_case							:   int ) -> str:
												if number > to_guess:
																		return "high"
												elif number < to_guess:
																		return "low"
												else:
																		return "same"

						print('''started...''' )

						__UpperCamelCase       =			lower
						__UpperCamelCase       =			higher

						__UpperCamelCase       =			[]

						while True:
												__UpperCamelCase       =			get_avg(snake_case ,      snake_case )
												last_numbers.append(snake_case )

												if answer(snake_case ) == "low":
																		__UpperCamelCase       =			number
												elif answer(snake_case ) == "high":
																		__UpperCamelCase       =			number
												else:
																		break

						print(f"guess the number : {last_numbers[-1]}" )
						print(f"details : {last_numbers!s}" )




def 	A_ (							)      ->    None:



						'''simple docstring'''

						__UpperCamelCase       =			int(input('''Enter lower value : ''' ).strip() )
						__UpperCamelCase       =			int(input('''Enter high value : ''' ).strip() )
						__UpperCamelCase       =			int(input('''Enter value to guess : ''' ).strip() )
						guess_the_number(snake_case ,      snake_case ,      snake_case )


if __name__ == "__main__":
				main()




