




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






			'''simple docstring'''



			lowerCamelCase__   =    StableDiffusionLDMaDPipeline
			lowerCamelCase__   =    TEXT_TO_IMAGE_PARAMS
			lowerCamelCase__   =    TEXT_TO_IMAGE_BATCH_PARAMS
			lowerCamelCase__   =    TEXT_TO_IMAGE_IMAGE_PARAMS
			def       A_					(						self						):
							torch.manual_seed(0						)
							_lowerCamelCase  :    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						,   )
							_lowerCamelCase  :    str					=					DDIMScheduler(
							    beta_start=0.0_00_85						,   beta_end=0.0_12						,   beta_schedule='scaled_linear'						,   clip_sample=lowercase						,   set_alpha_to_one=lowercase						,   )
							torch.manual_seed(0						)
							_lowerCamelCase  :    Union[str, 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						)
							_lowerCamelCase  :    int					=					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						,   )
							_lowerCamelCase  :    Optional[int]					=					CLIPTextModel(lowercase						)
							_lowerCamelCase  :    str					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

							_lowerCamelCase  :    Any					=					{
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							    'safety_checker': None,
							    'feature_extractor': None,
							}
							return components
			def       A_					(						self						,   lowercase						,   lowercase=0						):
							if str(lowercase						).startswith('mps'						):
											_lowerCamelCase  :    str					=					torch.manual_seed(lowercase						)
							else:
											_lowerCamelCase  :    Tuple					=					torch.Generator(device=lowercase						).manual_seed(lowercase						)
							_lowerCamelCase  :    Union[str, 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       A_					(						self						):
							_lowerCamelCase  :    str					=					'cpu'  # ensure determinism for the device-dependent torch.Generator

							_lowerCamelCase  :    int					=					self.get_dummy_components()
							_lowerCamelCase  :    Tuple					=					StableDiffusionLDMaDPipeline(**lowercase						)
							_lowerCamelCase  :    Optional[int]					=					ldmad_pipe.to(lowercase						)
							ldmad_pipe.set_progress_bar_config(disable=lowercase						)

							_lowerCamelCase  :    Optional[int]					=					self.get_dummy_inputs(lowercase						)
							_lowerCamelCase  :    Optional[Any]					=					ldmad_pipe(**lowercase						)
							_lowerCamelCase,				_lowerCamelCase  :    str					=					output.rgb, output.depth

							_lowerCamelCase  :    Any					=					rgb[0, -3:, -3:, -1]
							_lowerCamelCase  :    Union[str, Any]					=					depth[0, -3:, -1]

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

							_lowerCamelCase  :    Any					=					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]						)
							_lowerCamelCase  :    Optional[Any]					=					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       A_					(						self						):
							_lowerCamelCase  :    str					=					self.get_dummy_components()
							_lowerCamelCase  :    Optional[int]					=					StableDiffusionLDMaDPipeline(**lowercase						)
							_lowerCamelCase  :    Dict					=					ldmad_pipe.to(lowercase						)
							ldmad_pipe.set_progress_bar_config(disable=lowercase						)

							_lowerCamelCase  :    List[str]					=					self.get_dummy_inputs(lowercase						)
							_lowerCamelCase  :    List[str]					=					3 * [inputs['prompt']]

							# forward
							_lowerCamelCase  :    List[str]					=					ldmad_pipe(**lowercase						)
							_lowerCamelCase,				_lowerCamelCase  :    int					=					output.rgb, output.depth
							_lowerCamelCase  :    Union[str, Any]					=					rgb_slice_a[0, -3:, -3:, -1]
							_lowerCamelCase  :    Any					=					depth_slice_a[0, -3:, -1]

							_lowerCamelCase  :    Optional[Any]					=					self.get_dummy_inputs(lowercase						)
							_lowerCamelCase  :    List[str]					=					3 * [inputs.pop('prompt'						)]

							_lowerCamelCase  :    int					=					ldmad_pipe.tokenizer(
							    lowercase						,   padding='max_length'						,   max_length=ldmad_pipe.tokenizer.model_max_length						,   truncation=lowercase						,   return_tensors='pt'						,   )
							_lowerCamelCase  :    Optional[int]					=					text_inputs['input_ids'].to(lowercase						)

							_lowerCamelCase  :    Optional[Any]					=					ldmad_pipe.text_encoder(lowercase						)[0]

							_lowerCamelCase  :    List[Any]					=					prompt_embeds

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

							_lowerCamelCase  :    List[str]					=					self.get_dummy_inputs(lowercase						)
							_lowerCamelCase  :    int					=					'french fries'
							_lowerCamelCase  :    List[str]					=					ldmad_pipe(**lowercase						,   negative_prompt=lowercase						)

							_lowerCamelCase,				_lowerCamelCase  :    Optional[Any]					=					output.rgb, output.depth
							_lowerCamelCase  :    Dict					=					rgb[0, -3:, -3:, -1]
							_lowerCamelCase  :    Optional[Any]					=					depth[0, -3:, -1]

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

							_lowerCamelCase  :    Tuple					=					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]						)
							_lowerCamelCase  :    Union[str, Any]					=					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 lowerCAmelCase__			(  unittest.TestCase		):






			'''simple docstring'''



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

							_lowerCamelCase  :    Union[str, Any]					=					self.get_inputs(lowercase						)
							_lowerCamelCase  :    Any					=					ldmad_pipe(**lowercase						)
							_lowerCamelCase,				_lowerCamelCase  :    Optional[int]					=					output.rgb, output.depth
							_lowerCamelCase  :    Tuple					=					rgb[0, -3:, -3:, -1].flatten()
							_lowerCamelCase  :    Any					=					rgb[0, -3:, -1].flatten()

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

							_lowerCamelCase  :    Tuple					=					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]						)
							_lowerCamelCase  :    List[Any]					=					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 lowerCAmelCase__			(  unittest.TestCase		):






			'''simple docstring'''



			def       A_					(						self						):
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
			def       A_					(						self						,   lowercase						,   lowercase="cpu"						,   lowercase=torch.floataa						,   lowercase=0						):
							_lowerCamelCase  :    List[Any]					=					torch.Generator(device=lowercase						).manual_seed(lowercase						)
							_lowerCamelCase  :    Optional[Any]					=					np.random.RandomState(lowercase						).standard_normal((1, 4, 64, 64)						)
							_lowerCamelCase  :    Dict					=					torch.from_numpy(lowercase						).to(device=lowercase						,   dtype=lowercase						)
							_lowerCamelCase  :    Optional[int]					=					{
							    '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       A_					(						self						):
							_lowerCamelCase  :    Union[str, Any]					=					StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'						).to(lowercase						)
							ldmad_pipe.set_progress_bar_config(disable=lowercase						)

							_lowerCamelCase  :    str					=					self.get_inputs(lowercase						)
							_lowerCamelCase  :    Union[str, Any]					=					ldmad_pipe(**lowercase						)
							_lowerCamelCase,				_lowerCamelCase  :    Any					=					output.rgb, output.depth

							_lowerCamelCase  :    Any					=					0.49_55_86
							_lowerCamelCase  :    Optional[Any]					=					0.33_79_55_15
							_lowerCamelCase  :    str					=					1_12.4_85_18
							_lowerCamelCase  :    Union[str, Any]					=					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       A_					(						self						):
							_lowerCamelCase  :    Any					=					StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d-4c'						).to(lowercase						)
							ldmad_pipe.set_progress_bar_config(disable=lowercase						)

							_lowerCamelCase  :    Any					=					self.get_inputs(lowercase						)
							_lowerCamelCase  :    Dict					=					ldmad_pipe(**lowercase						)
							_lowerCamelCase,				_lowerCamelCase  :    List[Any]					=					output.rgb, output.depth

							_lowerCamelCase  :    str					=					0.4_19_41_27
							_lowerCamelCase  :    Optional[Any]					=					0.35_37_55_86
							_lowerCamelCase  :    int					=					0.5_63_85_02
							_lowerCamelCase  :    List[Any]					=					0.34_68_61_03

							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 dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available






@dataclass
class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    42


try:
			if not (is_transformers_available() and is_torch_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
			from .pipeline_text_to_video_synth import TextToVideoSDPipeline
			from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
			from .pipeline_text_to_video_zero import TextToVideoZeroPipeline