

import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
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


enable_full_determinism()

class 				a  (	unittest.TestCase				):


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


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


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Optional[Any] 		=    1
										_UpperCAmelCase       :		Optional[Any] 		=    3
										_UpperCAmelCase       :		Any 		=    (32, 32)

										_UpperCAmelCase       :		Tuple 		=    floats_tensor((batch_size, num_channels) + sizes						,					rng=random.Random(0	)	).to(lowerCAmelCase_	)
										return image


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)
										_UpperCAmelCase       :		str 		=    UNetaDConditionModel(
										    block_out_channels=(32, 32, 64)						,					layers_per_block=2						,					sample_size=32						,					in_channels=7						,					out_channels=4						,					down_block_types=("DownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D")						,					up_block_types=("CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "UpBlock2D")						,					cross_attention_dim=32						,					attention_head_dim=8						,					use_linear_projection=lowerCAmelCase_						,					only_cross_attention=(True, True, False)						,					num_class_embeds=100						,					)
										return model


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)
										_UpperCAmelCase       :		List[Any] 		=    AutoencoderKL(
										    block_out_channels=[32, 32, 64]						,					in_channels=3						,					out_channels=3						,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D", "DownEncoderBlock2D"]						,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]						,					latent_channels=4						,					)
										return model


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)
										_UpperCAmelCase       :		Dict 		=    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=512						,					)
										return CLIPTextModel(lowerCAmelCase_	)


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		List[str] 		=    "cpu"  # ensure determinism for the device-dependent torch.Generator
										_UpperCAmelCase       :		int 		=    self.dummy_cond_unet_upscale
										_UpperCAmelCase       :		Tuple 		=    DDPMScheduler()
										_UpperCAmelCase       :		Tuple 		=    DDIMScheduler(prediction_type="v_prediction"	)
										_UpperCAmelCase       :		Any 		=    self.dummy_vae
										_UpperCAmelCase       :		Dict 		=    self.dummy_text_encoder
										_UpperCAmelCase       :		Any 		=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

										_UpperCAmelCase       :		int 		=    self.dummy_image.cpu().permute(0						,					2						,					3						,					1	)[0]
										_UpperCAmelCase       :		List[Any] 		=    Image.fromarray(np.uinta(lowerCAmelCase_	)	).convert("RGB"	).resize((64, 64)	)

										# make sure here that pndm scheduler skips prk
										_UpperCAmelCase       :		Optional[int] 		=    StableDiffusionUpscalePipeline(
										    unet=lowerCAmelCase_						,					low_res_scheduler=lowerCAmelCase_						,					scheduler=lowerCAmelCase_						,					vae=lowerCAmelCase_						,					text_encoder=lowerCAmelCase_						,					tokenizer=lowerCAmelCase_						,					max_noise_level=350						,					)
										_UpperCAmelCase       :		Any 		=    sd_pipe.to(lowerCAmelCase_	)
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

										_UpperCAmelCase       :		List[str] 		=    "A painting of a squirrel eating a burger"
										_UpperCAmelCase       :		List[Any] 		=    torch.Generator(device=lowerCAmelCase_	).manual_seed(0	)
										_UpperCAmelCase       :		Union[str, Any] 		=    sd_pipe(
										    [prompt]						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="np"						,					)

										_UpperCAmelCase       :		Tuple 		=    output.images

										_UpperCAmelCase       :		Optional[Any] 		=    torch.Generator(device=lowerCAmelCase_	).manual_seed(0	)
										_UpperCAmelCase       :		Any 		=    sd_pipe(
										    [prompt]						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="np"						,					return_dict=lowerCAmelCase_						,					)[0]

										_UpperCAmelCase       :		Union[str, Any] 		=    image[0, -3:, -3:, -1]
										_UpperCAmelCase       :		Dict 		=    image_from_tuple[0, -3:, -3:, -1]

										_UpperCAmelCase       :		int 		=    low_res_image.size[0] * 4
										assert image.shape == (1, expected_height_width, expected_height_width, 3)
										_UpperCAmelCase       :		Dict 		=    np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61]	)

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


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Dict 		=    "cpu"  # ensure determinism for the device-dependent torch.Generator
										_UpperCAmelCase       :		str 		=    self.dummy_cond_unet_upscale
										_UpperCAmelCase       :		Tuple 		=    DDPMScheduler()
										_UpperCAmelCase       :		str 		=    DDIMScheduler(prediction_type="v_prediction"	)
										_UpperCAmelCase       :		int 		=    self.dummy_vae
										_UpperCAmelCase       :		Dict 		=    self.dummy_text_encoder
										_UpperCAmelCase       :		str 		=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

										_UpperCAmelCase       :		Dict 		=    self.dummy_image.cpu().permute(0						,					2						,					3						,					1	)[0]
										_UpperCAmelCase       :		Union[str, Any] 		=    Image.fromarray(np.uinta(lowerCAmelCase_	)	).convert("RGB"	).resize((64, 64)	)

										# make sure here that pndm scheduler skips prk
										_UpperCAmelCase       :		Tuple 		=    StableDiffusionUpscalePipeline(
										    unet=lowerCAmelCase_						,					low_res_scheduler=lowerCAmelCase_						,					scheduler=lowerCAmelCase_						,					vae=lowerCAmelCase_						,					text_encoder=lowerCAmelCase_						,					tokenizer=lowerCAmelCase_						,					max_noise_level=350						,					)
										_UpperCAmelCase       :		Optional[Any] 		=    sd_pipe.to(lowerCAmelCase_	)
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

										_UpperCAmelCase       :		List[Any] 		=    "A painting of a squirrel eating a burger"
										_UpperCAmelCase       :		List[Any] 		=    sd_pipe(
										    2 * [prompt]						,					image=2 * [low_res_image]						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="np"						,					)
										_UpperCAmelCase       :		Tuple 		=    output.images
										assert image.shape[0] == 2

										_UpperCAmelCase       :		Optional[Any] 		=    torch.Generator(device=lowerCAmelCase_	).manual_seed(0	)
										_UpperCAmelCase       :		Optional[Any] 		=    sd_pipe(
										    [prompt]						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					num_images_per_prompt=2						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="np"						,					)
										_UpperCAmelCase       :		Tuple 		=    output.images
										assert image.shape[0] == 2





						@unittest.skipIf(torch_device != "cuda"						,					"This test requires a GPU"	)
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Any 		=    self.dummy_cond_unet_upscale
										_UpperCAmelCase       :		Union[str, Any] 		=    DDPMScheduler()
										_UpperCAmelCase       :		List[Any] 		=    DDIMScheduler(prediction_type="v_prediction"	)
										_UpperCAmelCase       :		Optional[int] 		=    self.dummy_vae
										_UpperCAmelCase       :		Dict 		=    self.dummy_text_encoder
										_UpperCAmelCase       :		Dict 		=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

										_UpperCAmelCase       :		Optional[Any] 		=    self.dummy_image.cpu().permute(0						,					2						,					3						,					1	)[0]
										_UpperCAmelCase       :		Dict 		=    Image.fromarray(np.uinta(lowerCAmelCase_	)	).convert("RGB"	).resize((64, 64)	)

										# put models in fp16, except vae as it overflows in fp16
										_UpperCAmelCase       :		List[Any] 		=    unet.half()
										_UpperCAmelCase       :		List[Any] 		=    text_encoder.half()

										# make sure here that pndm scheduler skips prk
										_UpperCAmelCase       :		List[str] 		=    StableDiffusionUpscalePipeline(
										    unet=lowerCAmelCase_						,					low_res_scheduler=lowerCAmelCase_						,					scheduler=lowerCAmelCase_						,					vae=lowerCAmelCase_						,					text_encoder=lowerCAmelCase_						,					tokenizer=lowerCAmelCase_						,					max_noise_level=350						,					)
										_UpperCAmelCase       :		Tuple 		=    sd_pipe.to(lowerCAmelCase_	)
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

										_UpperCAmelCase       :		int 		=    "A painting of a squirrel eating a burger"
										_UpperCAmelCase       :		List[str] 		=    torch.manual_seed(0	)
										_UpperCAmelCase       :		Union[str, Any] 		=    sd_pipe(
										    [prompt]						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					num_inference_steps=2						,					output_type="np"						,					).images

										_UpperCAmelCase       :		Tuple 		=    low_res_image.size[0] * 4
										assert image.shape == (1, expected_height_width, expected_height_width, 3)







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


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


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


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Dict 		=    load_image(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/sd2-upscale/low_res_cat.png"	)
										_UpperCAmelCase       :		Dict 		=    load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
										    "/upsampled_cat.npy"	)

										_UpperCAmelCase       :		Any 		=    "stabilityai/stable-diffusion-x4-upscaler"
										_UpperCAmelCase       :		Dict 		=    StableDiffusionUpscalePipeline.from_pretrained(lowerCAmelCase_	)
										pipe.to(lowerCAmelCase_	)
										pipe.set_progress_bar_config(disable=lowerCAmelCase_	)
										pipe.enable_attention_slicing()

										_UpperCAmelCase       :		List[Any] 		=    "a cat sitting on a park bench"

										_UpperCAmelCase       :		Union[str, Any] 		=    torch.manual_seed(0	)
										_UpperCAmelCase       :		Any 		=    pipe(
										    prompt=lowerCAmelCase_						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					output_type="np"						,					)
										_UpperCAmelCase       :		Optional[int] 		=    output.images[0]

										assert image.shape == (512, 512, 3)
										assert np.abs(expected_image - image	).max() < 1e-3


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		int 		=    load_image(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/sd2-upscale/low_res_cat.png"	)
										_UpperCAmelCase       :		Optional[int] 		=    load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
										    "/upsampled_cat_fp16.npy"	)

										_UpperCAmelCase       :		int 		=    "stabilityai/stable-diffusion-x4-upscaler"
										_UpperCAmelCase       :		List[Any] 		=    StableDiffusionUpscalePipeline.from_pretrained(
										    lowerCAmelCase_						,					torch_dtype=torch.floataa						,					)
										pipe.to(lowerCAmelCase_	)
										pipe.set_progress_bar_config(disable=lowerCAmelCase_	)
										pipe.enable_attention_slicing()

										_UpperCAmelCase       :		str 		=    "a cat sitting on a park bench"

										_UpperCAmelCase       :		Any 		=    torch.manual_seed(0	)
										_UpperCAmelCase       :		Optional[int] 		=    pipe(
										    prompt=lowerCAmelCase_						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					output_type="np"						,					)
										_UpperCAmelCase       :		Optional[int] 		=    output.images[0]

										assert image.shape == (512, 512, 3)
										assert np.abs(expected_image - image	).max() < 5e-1





						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.cuda.empty_cache()
										torch.cuda.reset_max_memory_allocated()
										torch.cuda.reset_peak_memory_stats()

										_UpperCAmelCase       :		List[str] 		=    load_image(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/sd2-upscale/low_res_cat.png"	)

										_UpperCAmelCase       :		int 		=    "stabilityai/stable-diffusion-x4-upscaler"
										_UpperCAmelCase       :		str 		=    StableDiffusionUpscalePipeline.from_pretrained(
										    lowerCAmelCase_						,					torch_dtype=torch.floataa						,					)
										pipe.to(lowerCAmelCase_	)
										pipe.set_progress_bar_config(disable=lowerCAmelCase_	)
										pipe.enable_attention_slicing(1	)
										pipe.enable_sequential_cpu_offload()

										_UpperCAmelCase       :		Tuple 		=    "a cat sitting on a park bench"

										_UpperCAmelCase       :		List[Any] 		=    torch.manual_seed(0	)
										_UpperCAmelCase       :		Optional[Any] 		=    pipe(
										    prompt=lowerCAmelCase_						,					image=lowerCAmelCase_						,					generator=lowerCAmelCase_						,					num_inference_steps=5						,					output_type="np"						,					)

										_UpperCAmelCase       :		str 		=    torch.cuda.max_memory_allocated()
										# make sure that less than 2.9 GB is allocated
										assert mem_bytes < 2.9 * 10**9





from __future__ import annotations

from collections.abc import Callable

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  Callable[[int | float], int | float]  ,      lowerCAmelCase:  int | float  ,      lowerCAmelCase:  int | float  ,      lowerCAmelCase:  int = 100  ,      )   ->       float:
				_UpperCAmelCase       :		str 		=    x_start
				_UpperCAmelCase       :		Union[str, Any] 		=    fnc(lowerCAmelCase )
				_UpperCAmelCase       :		Tuple 		=    0.0
				for _ in range(lowerCAmelCase ):
								# Approximates small segments of curve as linear and solve
								# for trapezoidal area
								_UpperCAmelCase       :		Union[str, Any] 		=    (x_end - x_start) / steps + xa
								_UpperCAmelCase       :		Optional[Any] 		=    fnc(lowerCAmelCase )
								area += abs(fxa + fxa ) * (xa - xa) / 2
								# Increment step
								_UpperCAmelCase       :		Any 		=    xa
								_UpperCAmelCase       :		Optional[Any] 		=    fxa
				return area


if __name__ == "__main__":

					def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  List[str] )   ->       List[Any]:
									return x**3 + x**2

					print('f(x) = x^3 + x^2')
					print('The area between the curve, x = -5, x = 5 and the x axis is:')
					SCREAMING_SNAKE_CASE_        =      10
					while i <= 100000:
										print(F'''with {i} steps: {trapezoidal_area(f, -5, 5, i)}''')
										i *= 10


