import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class 		a__						(					unittest.TestCase					):

					@property
					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    UNetaDModel(
							    block_out_channels=(32, 64),layers_per_block=2,sample_size=32,in_channels=3,out_channels=3,down_block_types=("DownBlock2D", "AttnDownBlock2D"),up_block_types=("AttnUpBlock2D", "UpBlock2D"),)
							return model

					@property
					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		int				      =    VQModel(
							    block_out_channels=[32, 64],in_channels=3,out_channels=3,down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],latent_channels=3,)
							return model

					@property
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    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,)
							return CLIPTextModel(_A    )






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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.dummy_uncond_unet
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    DDIMScheduler()
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self.dummy_vq_model

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    LDMPipeline(unet=_A,vqvae=_A,scheduler=_A    )
							ldm.to(_A    )
							ldm.set_progress_bar_config(disable=_A    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		str				      =    ldm(generator=_A,num_inference_steps=2,output_type="numpy"    ).images

							SCREAMING_SNAKE_CASE_  :		int				      =    torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    ldm(generator=_A,num_inference_steps=2,output_type="numpy",return_dict=_A    )[0]

							SCREAMING_SNAKE_CASE_  :		Any				      =    image[0, -3:, -3:, -1]
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]    )
							SCREAMING_SNAKE_CASE_  :		int				      =    1E-2 if torch_device != "mps" else 3E-2

							assert np.abs(image_slice.flatten() - expected_slice    ).max() < tolerance
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < tolerance







@slow
@require_torch
class 		a__						(					unittest.TestCase					):

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256"    )
							ldm.to(_A    )
							ldm.set_progress_bar_config(disable=_A    )

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    torch.manual_seed(0    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    ldm(generator=_A,num_inference_steps=5,output_type="numpy"    ).images

							SCREAMING_SNAKE_CASE_  :		int				      =    image[0, -3:, -3:, -1]

							assert image.shape == (1, 256, 256, 3)
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447]    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    1E-2 if torch_device != "mps" else 3E-2

							assert np.abs(image_slice.flatten() - expected_slice    ).max() < tolerance






"""simple docstring"""






def      _snake_case			(				lowercase__							,    lowercase__		):
				# "extended trapezoidal rule"
				# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
				_lowerCamelCase     :			List[Any]    =    (boundary[1] - boundary[0]) / steps
				_lowerCamelCase     :			Tuple    =    boundary[0]
				_lowerCamelCase     :			Dict    =    boundary[1]
				_lowerCamelCase     :			List[Any]    =    make_points(lowercase__							,    lowercase__							,    lowercase__		)
				_lowerCamelCase     :			List[Any]    =    0.0
				y += (h / 2.0) * f(lowercase__		)
				for i in x_i:
								# print(i)
								y += h * f(lowercase__		)
				y += (h / 2.0) * f(lowercase__		)
				return y







def      _snake_case			(				lowercase__							,    lowercase__							,    lowercase__		):
				_lowerCamelCase     :			str    =    a + h
				while x < (b - h):
								yield x
								_lowerCamelCase     :			int    =    x + h







def      _snake_case			(				lowercase__		):  # enter your function here
				_lowerCamelCase     :			Optional[Any]    =    (x - 0) * (x - 0)
				return y







def      _snake_case			(				):
				_lowerCamelCase     :			int    =    0.0  # Lower bound of integration
				_lowerCamelCase     :			Optional[int]    =    1.0  # Upper bound of integration
				_lowerCamelCase     :			List[str]    =    1_0.0  # define number of steps or resolution
				_lowerCamelCase     :			List[Any]    =    [a, b]  # define boundary of integration
				_lowerCamelCase     :			Optional[Any]    =    method_a(lowercase__							,    lowercase__		)
				print(f'''y = {y}'''		)


if __name__ == "__main__":
			main()