





"""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 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  StableDiffusionLDMaDPipeline
					__lowerCAmelCase  =  TEXT_TO_IMAGE_PARAMS
					__lowerCAmelCase  =  TEXT_TO_IMAGE_BATCH_PARAMS
					__lowerCAmelCase  =  TEXT_TO_IMAGE_IMAGE_PARAMS







					def  _lowerCamelCase		(						self     ):
									torch.manual_seed(0     )
									__a :						Dict			       =  UNetaDConditionModel(
									    block_out_channels=(32, 64)	,			layers_per_block=2	,			sample_size=32	,			in_channels=4	,			out_channels=4	,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')	,			cross_attention_dim=32	,			)
									__a :						Dict			       =  DDIMScheduler(
									    beta_start=0.0_0_0_8_5	,			beta_end=0.0_1_2	,			beta_schedule='''scaled_linear'''	,			clip_sample=_UpperCAmelCase	,			set_alpha_to_one=_UpperCAmelCase	,			)
									torch.manual_seed(0     )
									__a :						Optional[Any]			       =  AutoencoderKL(
									    block_out_channels=[32, 64]	,			in_channels=6	,			out_channels=6	,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']	,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']	,			latent_channels=4	,			)
									torch.manual_seed(0     )
									__a :						Union[str, Any]			       =  CLIPTextConfig(
									    bos_token_id=0	,			eos_token_id=2	,			hidden_size=32	,			intermediate_size=37	,			layer_norm_eps=1e-0_5	,			num_attention_heads=4	,			num_hidden_layers=5	,			pad_token_id=1	,			vocab_size=1000	,			)
									__a :						Dict			       =  CLIPTextModel(_UpperCAmelCase     )
									__a :						Optional[Any]			       =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     )

									__a :						List[str]			       =  {
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase=0     ):
									if str(_UpperCAmelCase     ).startswith('''mps'''     ):
													__a :						List[Any]			       =  torch.manual_seed(_UpperCAmelCase     )
									else:
													__a :						Tuple			       =  torch.Generator(device=_UpperCAmelCase     ).manual_seed(_UpperCAmelCase     )
									__a :						Any			       =  {
									    '''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  _lowerCamelCase		(						self     ):
									__a :						Dict			       =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator

									__a :						Union[str, Any]			       =  self.get_dummy_components()
									__a :						Tuple			       =  StableDiffusionLDMaDPipeline(**_UpperCAmelCase     )
									__a :						int			       =  ldmad_pipe.to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						str			       =  self.get_dummy_inputs(_UpperCAmelCase     )
									__a :						Tuple			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						Any			       =  output.rgb, output.depth

									__a :						List[str]			       =  rgb[0, -3:, -3:, -1]
									__a :						Any			       =  depth[0, -3:, -1]

									assert rgb.shape == (1, 64, 64, 3)
									assert depth.shape == (1, 64, 64)

									__a :						Optional[Any]			       =  np.array(
									    [0.3_7_3_3_8_1_7_6, 0.7_0_2_4_7, 0.7_4_2_0_3_1_9_3, 0.5_1_6_4_3_6_0_4, 0.5_8_2_5_6_7_9_3, 0.6_0_9_3_2_1_3_6, 0.4_1_8_1_0_9_5, 0.4_8_3_5_5_8_7_7, 0.4_6_5_3_5_2_6_2]     )
									__a :						Union[str, Any]			       =  np.array([1_0_3.4_6_7_2_7, 8_5.8_1_2_0_0_4, 8_7.8_4_9_2_3_6]     )

									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  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  self.get_dummy_components()
									__a :						int			       =  StableDiffusionLDMaDPipeline(**_UpperCAmelCase     )
									__a :						Optional[Any]			       =  ldmad_pipe.to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						Optional[int]			       =  self.get_dummy_inputs(_UpperCAmelCase     )
									__a :						Dict			       =  3 * [inputs['''prompt''']]

									# forward
									__a :						List[Any]			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						Optional[Any]			       =  output.rgb, output.depth
									__a :						Optional[Any]			       =  rgb_slice_a[0, -3:, -3:, -1]
									__a :						Tuple			       =  depth_slice_a[0, -3:, -1]

									__a :						Any			       =  self.get_dummy_inputs(_UpperCAmelCase     )
									__a :						List[Any]			       =  3 * [inputs.pop('''prompt'''     )]

									__a :						Union[str, Any]			       =  ldmad_pipe.tokenizer(
									    _UpperCAmelCase	,			padding='''max_length'''	,			max_length=ldmad_pipe.tokenizer.model_max_length	,			truncation=_UpperCAmelCase	,			return_tensors='''pt'''	,			)
									__a :						List[Any]			       =  text_inputs['''input_ids'''].to(_UpperCAmelCase     )

									__a :						List[str]			       =  ldmad_pipe.text_encoder(_UpperCAmelCase     )[0]

									__a :						Optional[Any]			       =  prompt_embeds

									# forward
									__a :						List[Any]			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						Union[str, Any]			       =  output.rgb, output.depth
									__a :						List[str]			       =  rgb_slice_a[0, -3:, -3:, -1]
									__a :						Tuple			       =  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  _lowerCamelCase		(						self     ):
									__a :						Any			       =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
									__a :						List[Any]			       =  self.get_dummy_components()
									__a :						Tuple			       =  PNDMScheduler(skip_prk_steps=_UpperCAmelCase     )
									__a :						Optional[int]			       =  StableDiffusionLDMaDPipeline(**_UpperCAmelCase     )
									__a :						Dict			       =  ldmad_pipe.to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						Tuple			       =  self.get_dummy_inputs(_UpperCAmelCase     )
									__a :						Optional[Any]			       =  '''french fries'''
									__a :						Optional[Any]			       =  ldmad_pipe(**_UpperCAmelCase	,			negative_prompt=_UpperCAmelCase     )

									__a       ,						__a :						Any			       =  output.rgb, output.depth
									__a :						Optional[Any]			       =  rgb[0, -3:, -3:, -1]
									__a :						List[str]			       =  depth[0, -3:, -1]

									assert rgb.shape == (1, 64, 64, 3)
									assert depth.shape == (1, 64, 64)

									__a :						str			       =  np.array(
									    [0.3_7_0_4_4, 0.7_1_8_1_1_5_0_3, 0.7_2_2_3_2_5_1, 0.4_8_6_0_3_6_7_5, 0.5_6_3_8_3_9_1, 0.6_3_6_4_9_4_8, 0.4_2_8_3_3_7_0_4, 0.4_9_0_1_3_1_5, 0.4_7_9_2_6_2_1_7]     )
									__a :						Union[str, Any]			       =  np.array([1_0_7.8_4_7_3_8, 8_4.6_2_8_0_2, 8_9.9_6_2_1_3_5]     )
									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 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




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







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase="cpu"	,			_UpperCAmelCase=torch.floataa	,			_UpperCAmelCase=0     ):
									__a :						List[Any]			       =  torch.Generator(device=_UpperCAmelCase     ).manual_seed(_UpperCAmelCase     )
									__a :						Tuple			       =  np.random.RandomState(_UpperCAmelCase     ).standard_normal((1, 4, 64, 64)     )
									__a :						int			       =  torch.from_numpy(_UpperCAmelCase     ).to(device=_UpperCAmelCase	,			dtype=_UpperCAmelCase     )
									__a :						str			       =  {
									    '''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  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''     )
									__a :						Tuple			       =  ldmad_pipe.to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						Any			       =  self.get_inputs(_UpperCAmelCase     )
									__a :						Optional[Any]			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						List[str]			       =  output.rgb, output.depth
									__a :						List[str]			       =  rgb[0, -3:, -3:, -1].flatten()
									__a :						str			       =  rgb[0, -3:, -1].flatten()

									assert rgb.shape == (1, 512, 512, 3)
									assert depth.shape == (1, 512, 512)

									__a :						Dict			       =  np.array(
									    [0.5_3_8_0_5_4_6_5, 0.5_6_7_0_7_3_0_5, 0.5_4_8_6_5_1_5, 0.5_7_0_1_2_2_3_6, 0.5_8_1_4_5_1_1, 0.5_6_2_5_3_4_8_7, 0.5_4_8_4_3_0_1_4, 0.5_5_0_9_2_2_6_3, 0.6_4_5_9_7_0_6]     )
									__a :						List[str]			       =  np.array(
									    [0.9_2_6_3_7_8_1, 0.6_6_7_8_6_7_2, 0.5_4_8_6_5_1_5, 0.9_2_2_0_2_1_4_5, 0.6_7_8_3_1_1_3_5, 0.5_6_2_5_3_4_8_7, 0.9_2_4_1_6_9_4, 0.7_5_5_1_4_7_8, 0.6_4_5_9_7_0_6]     )
									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 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




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







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase="cpu"	,			_UpperCAmelCase=torch.floataa	,			_UpperCAmelCase=0     ):
									__a :						Tuple			       =  torch.Generator(device=_UpperCAmelCase     ).manual_seed(_UpperCAmelCase     )
									__a :						List[Any]			       =  np.random.RandomState(_UpperCAmelCase     ).standard_normal((1, 4, 64, 64)     )
									__a :						List[str]			       =  torch.from_numpy(_UpperCAmelCase     ).to(device=_UpperCAmelCase	,			dtype=_UpperCAmelCase     )
									__a :						Union[str, Any]			       =  {
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''latents''': latents,
									    '''generator''': generator,
									    '''num_inference_steps''': 50,
									    '''guidance_scale''': 7.5,
									    '''output_type''': '''numpy''',
									}
									return inputs







					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''     ).to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						str			       =  self.get_inputs(_UpperCAmelCase     )
									__a :						Optional[int]			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						Tuple			       =  output.rgb, output.depth

									__a :						Dict			       =  0.4_9_5_5_8_6
									__a :						Union[str, Any]			       =  0.3_3_7_9_5_5_1_5
									__a :						int			       =  1_1_2.4_8_5_1_8
									__a :						int			       =  9_8.4_8_9_7_4_6
									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  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d-4c'''     ).to(_UpperCAmelCase     )
									ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase     )

									__a :						List[str]			       =  self.get_inputs(_UpperCAmelCase     )
									__a :						int			       =  ldmad_pipe(**_UpperCAmelCase     )
									__a       ,						__a :						str			       =  output.rgb, output.depth

									__a :						Union[str, Any]			       =  0.4_1_9_4_1_2_7
									__a :						Union[str, Any]			       =  0.3_5_3_7_5_5_8_6
									__a :						List[str]			       =  0.5_6_3_8_5_0_2
									__a :						Dict			       =  0.3_4_6_8_6_1_0_3

									assert rgb.shape == (1, 512, 512, 3)
									assert depth.shape == (1, 512, 512, 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 __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass




@dataclass
class 				__lowercase			:







					'''simple docstring'''




					__lowerCAmelCase  =  42
					__lowerCAmelCase  =  42






class 				__lowercase			:







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase     ):
									__a :						list[list[Edge]]			       =  [[] for _ in range(_UpperCAmelCase     )]
									__a :						Dict			       =  size







					def __getitem__(						self	,			_UpperCAmelCase     ):
									return iter(self._graph[vertex]     )







					@property
					def  _lowerCamelCase		(						self     ):
									return self._size







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									if weight not in (0, 1):
													raise ValueError('''Edge weight must be either 0 or 1.'''     )

									if to_vertex < 0 or to_vertex >= self.size:
													raise ValueError('''Vertex indexes must be in [0; size).'''     )

									self._graph[from_vertex].append(Edge(_UpperCAmelCase	,			_UpperCAmelCase     )     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						List[str]			       =  deque([start_vertex]     )
									__a :						list[int | None]			       =  [None] * self.size
									__a :						int			       =  0

									while queue:
													__a :						Any			       =  queue.popleft()
													__a :						Tuple			       =  distances[current_vertex]
													if current_distance is None:
																	continue

													for edge in self[current_vertex]:
																	__a :						List[str]			       =  current_distance + edge.weight
																	__a :						str			       =  distances[edge.destination_vertex]
																	if (
																	    isinstance(_UpperCAmelCase	,			_UpperCAmelCase     )
																	    and new_distance >= dest_vertex_distance
																	):
																					continue
																	__a :						str			       =  new_distance
																	if edge.weight == 0:
																					queue.appendleft(edge.destination_vertex     )
																	else:
																					queue.append(edge.destination_vertex     )

									if distances[finish_vertex] is None:
													raise ValueError('''No path from start_vertex to finish_vertex.'''     )

									return distances[finish_vertex]


if __name__ == "__main__":
		import doctest

		doctest.testmod()