
"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()
class 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  Any						   =		StableDiffusionLDMaDPipeline
		__lowercase							:  List[Any]						   =		TEXT_TO_IMAGE_PARAMS
		__lowercase							:  List[str]						   =		TEXT_TO_IMAGE_BATCH_PARAMS
		__lowercase							:  int						   =		TEXT_TO_IMAGE_IMAGE_PARAMS




		def 	snake_case_     (     self):
				torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = UNetaDConditionModel(
				    block_out_channels=(3_2, 6_4)							,  layers_per_block=2							,  sample_size=3_2							,  in_channels=4							,  out_channels=4							,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")							,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")							,  cross_attention_dim=3_2							,  )
				__SCREAMING_SNAKE_CASE            = DDIMScheduler(
				    beta_start=0.0_00_85							,  beta_end=0.0_12							,  beta_schedule="""scaled_linear"""							,  clip_sample=lowerCAmelCase__							,  set_alpha_to_one=lowerCAmelCase__							,  )
				torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = AutoencoderKL(
				    block_out_channels=[3_2, 6_4]							,  in_channels=6							,  out_channels=6							,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]							,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]							,  latent_channels=4							,  )
				torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = CLIPTextConfig(
				    bos_token_id=0							,  eos_token_id=2							,  hidden_size=3_2							,  intermediate_size=3_7							,  layer_norm_eps=1E-05							,  num_attention_heads=4							,  num_hidden_layers=5							,  pad_token_id=1							,  vocab_size=1_0_0_0							,  )
				__SCREAMING_SNAKE_CASE            = CLIPTextModel(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

				__SCREAMING_SNAKE_CASE            = {
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vae""": vae,
				    """text_encoder""": text_encoder,
				    """tokenizer""": tokenizer,
				    """safety_checker""": None,
				    """feature_extractor""": None,
				}
				return components




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__=0):
				if str(lowerCAmelCase__).startswith("""mps"""):
						__SCREAMING_SNAKE_CASE            = torch.manual_seed(lowerCAmelCase__)
				else:
						__SCREAMING_SNAKE_CASE            = torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = {
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """generator""": generator,
				    """num_inference_steps""": 2,
				    """guidance_scale""": 6.0,
				    """output_type""": """numpy""",
				}
				return inputs




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = """cpu"""  # ensure determinism for the device-dependent torch.Generator

				__SCREAMING_SNAKE_CASE            = self.get_dummy_components()
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe.to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_dummy_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth

				__SCREAMING_SNAKE_CASE            = rgb[0, -3:, -3:, -1]
				__SCREAMING_SNAKE_CASE            = depth[0, -3:, -1]

				assert rgb.shape == (1, 6_4, 6_4, 3)
				assert depth.shape == (1, 6_4, 6_4)

				__SCREAMING_SNAKE_CASE            = np.array(
				    [0.37_33_81_76, 0.7_02_47, 0.74_20_31_93, 0.51_64_36_04, 0.58_25_67_93, 0.60_93_21_36, 0.4_18_10_95, 0.48_35_58_77, 0.46_53_52_62])
				__SCREAMING_SNAKE_CASE            = np.array([1_03.4_67_27, 85.81_20_04, 87.84_92_36])

				assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb).max() < 1E-2
				assert np.abs(image_slice_depth.flatten() - expected_slice_depth).max() < 1E-2




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.get_dummy_components()
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe.to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_dummy_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = 3 * [inputs["""prompt"""]]

				# forward
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth
				__SCREAMING_SNAKE_CASE            = rgb_slice_a[0, -3:, -3:, -1]
				__SCREAMING_SNAKE_CASE            = depth_slice_a[0, -3:, -1]

				__SCREAMING_SNAKE_CASE            = self.get_dummy_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = 3 * [inputs.pop("""prompt""")]

				__SCREAMING_SNAKE_CASE            = ldmad_pipe.tokenizer(
				    lowerCAmelCase__							,  padding="""max_length"""							,  max_length=ldmad_pipe.tokenizer.model_max_length							,  truncation=lowerCAmelCase__							,  return_tensors="""pt"""							,  )
				__SCREAMING_SNAKE_CASE            = text_inputs["""input_ids"""].to(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = ldmad_pipe.text_encoder(lowerCAmelCase__)[0]

				__SCREAMING_SNAKE_CASE            = prompt_embeds

				# forward
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth
				__SCREAMING_SNAKE_CASE            = rgb_slice_a[0, -3:, -3:, -1]
				__SCREAMING_SNAKE_CASE            = depth_slice_a[0, -3:, -1]

				assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()).max() < 1E-4
				assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()).max() < 1E-4




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = """cpu"""  # ensure determinism for the device-dependent torch.Generator
				__SCREAMING_SNAKE_CASE            = self.get_dummy_components()
				__SCREAMING_SNAKE_CASE            = PNDMScheduler(skip_prk_steps=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe.to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_dummy_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = """french fries"""
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__							,  negative_prompt=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth
				__SCREAMING_SNAKE_CASE            = rgb[0, -3:, -3:, -1]
				__SCREAMING_SNAKE_CASE            = depth[0, -3:, -1]

				assert rgb.shape == (1, 6_4, 6_4, 3)
				assert depth.shape == (1, 6_4, 6_4)

				__SCREAMING_SNAKE_CASE            = np.array(
				    [0.3_70_44, 0.71_81_15_03, 0.7_22_32_51, 0.48_60_36_75, 0.5_63_83_91, 0.6_36_49_48, 0.42_83_37_04, 0.4_90_13_15, 0.47_92_62_17])
				__SCREAMING_SNAKE_CASE            = np.array([1_07.8_47_38, 84.6_28_02, 89.96_21_35])
				assert np.abs(rgb_slice.flatten() - expected_slice_rgb).max() < 1E-2
				assert np.abs(depth_slice.flatten() - expected_slice_depth).max() < 1E-2



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




		"""simple docstring"""





		def 	snake_case_     (     self):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__="cpu"							,  lowerCAmelCase__=torch.floataa							,  lowerCAmelCase__=0):
				__SCREAMING_SNAKE_CASE            = torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = np.random.RandomState(lowerCAmelCase__).standard_normal((1, 4, 6_4, 6_4))
				__SCREAMING_SNAKE_CASE            = torch.from_numpy(lowerCAmelCase__).to(device=lowerCAmelCase__							,  dtype=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = {
				    """prompt""": """a photograph of an astronaut riding a horse""",
				    """latents""": latents,
				    """generator""": generator,
				    """num_inference_steps""": 3,
				    """guidance_scale""": 7.5,
				    """output_type""": """numpy""",
				}
				return inputs




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d""")
				__SCREAMING_SNAKE_CASE            = ldmad_pipe.to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth
				__SCREAMING_SNAKE_CASE            = rgb[0, -3:, -3:, -1].flatten()
				__SCREAMING_SNAKE_CASE            = rgb[0, -3:, -1].flatten()

				assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
				assert depth.shape == (1, 5_1_2, 5_1_2)

				__SCREAMING_SNAKE_CASE            = np.array(
				    [0.53_80_54_65, 0.56_70_73_05, 0.5_48_65_15, 0.57_01_22_36, 0.5_81_45_11, 0.56_25_34_87, 0.54_84_30_14, 0.55_09_22_63, 0.6_45_97_06])
				__SCREAMING_SNAKE_CASE            = np.array(
				    [0.9_26_37_81, 0.6_67_86_72, 0.5_48_65_15, 0.92_20_21_45, 0.67_83_11_35, 0.56_25_34_87, 0.9_24_16_94, 0.7_55_14_78, 0.6_45_97_06])
				assert np.abs(rgb_slice - expected_slice_rgb).max() < 3E-3
				assert np.abs(depth_slice - expected_slice_depth).max() < 3E-3



@nightly
@require_torch_gpu
class 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		def 	snake_case_     (     self):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__="cpu"							,  lowerCAmelCase__=torch.floataa							,  lowerCAmelCase__=0):
				__SCREAMING_SNAKE_CASE            = torch.Generator(device=lowerCAmelCase__).manual_seed(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = np.random.RandomState(lowerCAmelCase__).standard_normal((1, 4, 6_4, 6_4))
				__SCREAMING_SNAKE_CASE            = torch.from_numpy(lowerCAmelCase__).to(device=lowerCAmelCase__							,  dtype=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = {
				    """prompt""": """a photograph of an astronaut riding a horse""",
				    """latents""": latents,
				    """generator""": generator,
				    """num_inference_steps""": 5_0,
				    """guidance_scale""": 7.5,
				    """output_type""": """numpy""",
				}
				return inputs




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d""").to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth

				__SCREAMING_SNAKE_CASE            = 0.49_55_86
				__SCREAMING_SNAKE_CASE            = 0.33_79_55_15
				__SCREAMING_SNAKE_CASE            = 1_12.4_85_18
				__SCREAMING_SNAKE_CASE            = 98.48_97_46
				assert np.abs(expected_rgb_mean - rgb.mean()) < 1E-3
				assert np.abs(expected_rgb_std - rgb.std()) < 1E-3
				assert np.abs(expected_depth_mean - depth.mean()) < 1E-3
				assert np.abs(expected_depth_std - depth.std()) < 1E-3




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d-4c""").to(lowerCAmelCase__)
				ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.get_inputs(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = ldmad_pipe(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = output.rgb, output.depth

				__SCREAMING_SNAKE_CASE            = 0.4_19_41_27
				__SCREAMING_SNAKE_CASE            = 0.35_37_55_86
				__SCREAMING_SNAKE_CASE            = 0.5_63_85_02
				__SCREAMING_SNAKE_CASE            = 0.34_68_61_03

				assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
				assert depth.shape == (1, 5_1_2, 5_1_2, 1)
				assert np.abs(expected_rgb_mean - rgb.mean()) < 1E-3
				assert np.abs(expected_rgb_std - rgb.std()) < 1E-3
				assert np.abs(expected_depth_mean - depth.mean()) < 1E-3
				assert np.abs(expected_depth_std - depth.std()) < 1E-3









"""simple docstring"""
from math import pi, sqrt, tan

def       _snake_case						(						UpperCamelCase						:		float						):
 if side_length < 0:
  raise ValueError("""surface_area_cube() only accepts non-negative values"""						)
 return 6 * side_length**2

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if length < 0 or breadth < 0 or height < 0:
  raise ValueError("""surface_area_cuboid() only accepts non-negative values"""						)
 return 2 * ((length * breadth) + (breadth * height) + (length * height))

def       _snake_case						(						UpperCamelCase						:		float						):
 if radius < 0:
  raise ValueError("""surface_area_sphere() only accepts non-negative values"""						)
 return 4 * pi * radius**2

def       _snake_case						(						UpperCamelCase						:		float						):
 if radius < 0:
  raise ValueError("""surface_area_hemisphere() only accepts non-negative values"""						)
 return 3 * pi * radius**2

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if radius < 0 or height < 0:
  raise ValueError("""surface_area_cone() only accepts non-negative values"""						)
 return pi * radius * (radius + (height**2 + radius**2) ** 0.5)

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if radius_a < 0 or radius_a < 0 or height < 0:
  raise ValueError(
      """surface_area_conical_frustum() only accepts non-negative values"""						)
 UpperCAmelCase	:					Tuple	=	(height**2 + (radius_a - radius_a) ** 2) ** 0.5
 return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if radius < 0 or height < 0:
  raise ValueError("""surface_area_cylinder() only accepts non-negative values"""						)
 return 2 * pi * radius * (height + radius)

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if torus_radius < 0 or tube_radius < 0:
  raise ValueError("""surface_area_torus() only accepts non-negative values"""						)
 if torus_radius < tube_radius:
  raise ValueError(
      """surface_area_torus() does not support spindle or self intersecting tori"""						)
 return 4 * pow(UpperCamelCase			,		2						) * torus_radius * tube_radius

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if length < 0 or width < 0:
  raise ValueError("""area_rectangle() only accepts non-negative values"""						)
 return length * width

def       _snake_case						(						UpperCamelCase						:		float						):
 if side_length < 0:
  raise ValueError("""area_square() only accepts non-negative values"""						)
 return side_length**2

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if base < 0 or height < 0:
  raise ValueError("""area_triangle() only accepts non-negative values"""						)
 return (base * height) / 2

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if sidea < 0 or sidea < 0 or sidea < 0:
  raise ValueError("""area_triangle_three_sides() only accepts non-negative values"""						)
 elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
  raise ValueError("""Given three sides do not form a triangle"""						)
 UpperCAmelCase	:					Union[str, Any]	=	(sidea + sidea + sidea) / 2
 UpperCAmelCase	:					Union[str, Any]	=	sqrt(
     semi_perimeter
     * (semi_perimeter - sidea)
     * (semi_perimeter - sidea)
     * (semi_perimeter - sidea)						)
 return area

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if base < 0 or height < 0:
  raise ValueError("""area_parallelogram() only accepts non-negative values"""						)
 return base * height

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if basea < 0 or basea < 0 or height < 0:
  raise ValueError("""area_trapezium() only accepts non-negative values"""						)
 return 1 / 2 * (basea + basea) * height

def       _snake_case						(						UpperCamelCase						:		float						):
 if radius < 0:
  raise ValueError("""area_circle() only accepts non-negative values"""						)
 return pi * radius**2

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if radius_x < 0 or radius_y < 0:
  raise ValueError("""area_ellipse() only accepts non-negative values"""						)
 return pi * radius_x * radius_y

def       _snake_case						(						UpperCamelCase						:		float			,		UpperCamelCase						:		float						):
 if diagonal_a < 0 or diagonal_a < 0:
  raise ValueError("""area_rhombus() only accepts non-negative values"""						)
 return 1 / 2 * diagonal_a * diagonal_a

def       _snake_case						(						UpperCamelCase						:		int			,		UpperCamelCase						:		float						):
 if not isinstance(UpperCamelCase			,		UpperCamelCase						) or sides < 3:
  raise ValueError(
      """area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides"""						)
 elif length < 0:
  raise ValueError(
      """area_reg_polygon() only accepts non-negative values as \
length of a side"""						)
 return (sides * length**2) / (4 * tan(pi / sides						))
 return (sides * length**2) / (4 * tan(pi / sides						))


if __name__ == "__main__":
      import doctest

      doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

      print("[DEMO] Areas of various geometric shapes: \n")
      print(f"""Rectangle: {area_rectangle(1_0, 2_0) = }""")
      print(f"""Square: {area_square(1_0) = }""")
      print(f"""Triangle: {area_triangle(1_0, 1_0) = }""")
      print(f"""Triangle: {area_triangle_three_sides(5, 1_2, 1_3) = }""")
      print(f"""Parallelogram: {area_parallelogram(1_0, 2_0) = }""")
      print(f"""Rhombus: {area_rhombus(1_0, 2_0) = }""")
      print(f"""Trapezium: {area_trapezium(1_0, 2_0, 3_0) = }""")
      print(f"""Circle: {area_circle(2_0) = }""")
      print(f"""Ellipse: {area_ellipse(1_0, 2_0) = }""")
      print("\nSurface Areas of various geometric shapes: \n")
      print(f"""Cube: {surface_area_cube(2_0) = }""")
      print(f"""Cuboid: {surface_area_cuboid(1_0, 2_0, 3_0) = }""")
      print(f"""Sphere: {surface_area_sphere(2_0) = }""")
      print(f"""Hemisphere: {surface_area_hemisphere(2_0) = }""")
      print(f"""Cone: {surface_area_cone(1_0, 2_0) = }""")
      print(f"""Conical Frustum: {surface_area_conical_frustum(1_0, 2_0, 3_0) = }""")
      print(f"""Cylinder: {surface_area_cylinder(1_0, 2_0) = }""")
      print(f"""Torus: {surface_area_torus(2_0, 1_0) = }""")
      print(f"""Equilateral Triangle: {area_reg_polygon(3, 1_0) = }""")
      print(f"""Square: {area_reg_polygon(4, 1_0) = }""")
      print(f"""Reqular Pentagon: {area_reg_polygon(5, 1_0) = }""")
