
'''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 		A_(     A						:		Any):
							UpperCamelCase   			=     [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):
				lowerCAmelCase_     			=							StableDiffusionLatentUpscalePipeline
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
				    """height""",
				    """width""",
				    """cross_attention_kwargs""",
				    """negative_prompt_embeds""",
				    """prompt_embeds""",
				}
				lowerCAmelCase_     			=							PipelineTesterMixin.required_optional_params - {"""num_images_per_prompt"""}
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				lowerCAmelCase_     			=							frozenset(
				    [])  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				lowerCAmelCase_     			=							frozenset([])

				lowerCAmelCase_     			=							True







				@property
				def 						UpperCAmelCase_    (       self     )->		List[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     1
											UpperCamelCase   			=     4
											UpperCamelCase   			=     (16, 16)

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







				def 						UpperCAmelCase_    (       self     )->		Any:







											'''simple docstring'''






											torch.manual_seed(0     )
											UpperCamelCase   			=     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')						,				)
											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(A_     )
											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 						UpperCAmelCase_    (       self						,				A_						,				A_=0     )->		Dict:







											'''simple docstring'''






											if str(A_     ).startswith('mps'     ):
																		UpperCamelCase   			=     torch.manual_seed(A_     )
											else:
																		UpperCamelCase   			=     torch.Generator(device=A_     ).manual_seed(A_     )
											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 						UpperCAmelCase_    (       self     )->		List[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'

											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     self.pipeline_class(**A_     )
											pipe.to(A_     )
											pipe.set_progress_bar_config(disable=A_     )

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

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







				def 						UpperCAmelCase_    (       self     )->		str:







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       self     )->		str:







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       self     )->		Optional[int]:







											'''simple docstring'''






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







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







											'''simple docstring'''






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







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







											'''simple docstring'''






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







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







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






											UpperCamelCase   			=     [
											    'DDIMScheduler',
											    'DDPMScheduler',
											    'PNDMScheduler',
											    'HeunDiscreteScheduler',
											    'EulerAncestralDiscreteScheduler',
											    'KDPM2DiscreteScheduler',
											    'KDPM2AncestralDiscreteScheduler',
											    'DPMSolverSDEScheduler',
											]
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     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_     )
											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											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(A_						,				scheduler_enum.name     )
																		UpperCamelCase   			=     scheduler_cls.from_config(pipe.scheduler.config     )
																		UpperCamelCase   			=     pipe(**A_     )[0]
																		outputs.append(A_     )

											assert check_same_shape(A_     )


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







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







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       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(A_						,				generator=A_						,				output_type='latent'     ).images

											UpperCamelCase   			=     upscaler(
											    prompt=A_						,				image=A_						,				num_inference_steps=20						,				guidance_scale=0						,				generator=A_						,				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 						UpperCAmelCase_    (       self     )->		str:







											'''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=A_						,				image=A_						,				num_inference_steps=20						,				guidance_scale=0						,				generator=A_						,				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










from math import factorial, radians





def 						__A						(      __lowerCamelCase				,     __lowerCamelCase = 18				,     __lowerCamelCase = 10       ) ->			float:
	a									=				angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)

	# Converting from degrees to radians
	a									=				radians(__lowerCamelCase       )

	a									=				angle_in_radians
	a									=				3
	a									=				-1

	for _ in range(__lowerCamelCase       ):
		result += (b * (angle_in_radians**a)) / factorial(__lowerCamelCase       )

		a									=				-b  # One positive term and the next will be negative and so on...
		a += 2  # Increased by 2 for every term.

	return round(__lowerCamelCase				,     __lowerCamelCase       )


if __name__ == "__main__":
		__import__("doctest").testmod()

