



import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







@skip_mps
class       __lowerCAmelCase   (      A    ,						unittest.TestCase						):
			UpperCamelCase        =					TextToVideoSDPipeline
			UpperCamelCase        =					TEXT_TO_IMAGE_PARAMS
			UpperCamelCase        =					TEXT_TO_IMAGE_BATCH_PARAMS
			# No `output_type`.
			UpperCamelCase        =					frozenset(
			    [
			        '''num_inference_steps''',
			        '''generator''',
			        '''latents''',
			        '''return_dict''',
			        '''callback''',
			        '''callback_steps''',
			    ]						)



			def    _lowerCamelCase	(						self       :  List[str])       ->   Optional[int]:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase			=       UNetaDConditionModel(
						    block_out_channels=(32, 64, 64, 64)			,		layers_per_block=2			,		sample_size=32			,		in_channels=4			,		out_channels=4			,		down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D')			,		up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D')			,		cross_attention_dim=32			,		attention_head_dim=4			,		)
						_UpperCAmelCase			=       DDIMScheduler(
						    beta_start=0.0_0_0_8_5			,		beta_end=0.0_1_2			,		beta_schedule='scaled_linear'			,		clip_sample=A			,		set_alpha_to_one=A			,		)
						torch.manual_seed(0)
						_UpperCAmelCase			=       AutoencoderKL(
						    block_out_channels=[32, 64]			,		in_channels=3			,		out_channels=3			,		down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']			,		up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']			,		latent_channels=4			,		sample_size=1_28			,		)
						torch.manual_seed(0)
						_UpperCAmelCase			=       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=10_00			,		hidden_act='gelu'			,		projection_dim=5_12			,		)
						_UpperCAmelCase			=       CLIPTextModel(A)
						_UpperCAmelCase			=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

						_UpperCAmelCase			=       {
						    'unet': unet,
						    'scheduler': scheduler,
						    'vae': vae,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						}
						return components



			def    _lowerCamelCase	(						self       :  Dict			,		A       :  Tuple			,		A       :  Optional[int]=0)       ->   Optional[Any]:



						"""simple docstring"""






						if str(A).startswith('mps'):
									_UpperCAmelCase			=       torch.manual_seed(A)
						else:
									_UpperCAmelCase			=       torch.Generator(device=A).manual_seed(A)
						_UpperCAmelCase			=       {
						    'prompt': 'A painting of a squirrel eating a burger',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'guidance_scale': 6.0,
						    'output_type': 'pt',
						}
						return inputs



			def    _lowerCamelCase	(						self       :  Union[str, Any])       ->   Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase			=       'cpu'  # ensure determinism for the device-dependent torch.Generator
						_UpperCAmelCase			=       self.get_dummy_components()
						_UpperCAmelCase			=       TextToVideoSDPipeline(**A)
						_UpperCAmelCase			=       sd_pipe.to(A)
						sd_pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase			=       self.get_dummy_inputs(A)
						_UpperCAmelCase			=       'np'
						_UpperCAmelCase			=       sd_pipe(**A).frames
						_UpperCAmelCase			=       frames[0][-3:, -3:, -1]

						assert frames[0].shape == (64, 64, 3)
						_UpperCAmelCase			=       np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0])

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



			def    _lowerCamelCase	(						self       :  List[str])       ->   Any:



						"""simple docstring"""






						self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A			,		expected_max_diff=3E-3)



			@unittest.skipIf(
			    torch_device != 'cuda' or not is_xformers_available()			,		reason='XFormers attention is only available with CUDA and `xformers` installed'			,		)
			def    _lowerCamelCase	(						self       :  List[str])       ->   List[str]:



						"""simple docstring"""






						self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A			,		expected_max_diff=1E-2)



			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.')
			def    _lowerCamelCase	(						self       :  Tuple)       ->   int:



						"""simple docstring"""






						pass



			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.')
			def    _lowerCamelCase	(						self       :  Any)       ->   Dict:



						"""simple docstring"""






						pass



			@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.')
			def    _lowerCamelCase	(						self       :  Tuple)       ->   List[Any]:



						"""simple docstring"""






						pass



			def    _lowerCamelCase	(						self       :  Dict)       ->   Optional[int]:



						"""simple docstring"""






						return super().test_progress_bar()







@slow
@skip_mps
class       __lowerCAmelCase   (      unittest.TestCase						):



			def    _lowerCamelCase	(						self       :  Any)       ->   Any:



						"""simple docstring"""






						_UpperCAmelCase			=       load_numpy(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy')

						_UpperCAmelCase			=       TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
						_UpperCAmelCase			=       DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
						_UpperCAmelCase			=       pipe.to('cuda')

						_UpperCAmelCase			=       'Spiderman is surfing'
						_UpperCAmelCase			=       torch.Generator(device='cpu').manual_seed(0)

						_UpperCAmelCase			=       pipe(A			,		generator=A			,		num_inference_steps=25			,		output_type='pt').frames
						_UpperCAmelCase			=       video_frames.cpu().numpy()

						assert np.abs(expected_video - video).mean() < 5E-2



			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   Tuple:



						"""simple docstring"""






						_UpperCAmelCase			=       load_numpy(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy')

						_UpperCAmelCase			=       TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
						_UpperCAmelCase			=       pipe.to('cuda')

						_UpperCAmelCase			=       'Spiderman is surfing'
						_UpperCAmelCase			=       torch.Generator(device='cpu').manual_seed(0)

						_UpperCAmelCase			=       pipe(A			,		generator=A			,		num_inference_steps=2			,		output_type='pt').frames
						_UpperCAmelCase			=       video_frames.cpu().numpy()

						assert np.abs(expected_video - video).mean() < 5E-2





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase__       =	{
    "configuration_clip": [
        "CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "CLIPConfig",
        "CLIPOnnxConfig",
        "CLIPTextConfig",
        "CLIPVisionConfig",
    ],
    "processing_clip": ["CLIPProcessor"],
    "tokenization_clip": ["CLIPTokenizer"],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	["CLIPTokenizerFast"]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	["CLIPFeatureExtractor"]
							UpperCAmelCase__       =	["CLIPImageProcessor"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "CLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "CLIPModel",
							    "CLIPPreTrainedModel",
							    "CLIPTextModel",
							    "CLIPTextModelWithProjection",
							    "CLIPVisionModel",
							    "CLIPVisionModelWithProjection",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "TFCLIPModel",
							    "TFCLIPPreTrainedModel",
							    "TFCLIPTextModel",
							    "TFCLIPVisionModel",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "FlaxCLIPModel",
							    "FlaxCLIPPreTrainedModel",
							    "FlaxCLIPTextModel",
							    "FlaxCLIPTextPreTrainedModel",
							    "FlaxCLIPVisionModel",
							    "FlaxCLIPVisionPreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_clip import (
							    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    CLIPConfig,
							    CLIPOnnxConfig,
							    CLIPTextConfig,
							    CLIPVisionConfig,
							)
							from .processing_clip import CLIPProcessor
							from .tokenization_clip import CLIPTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_clip_fast import CLIPTokenizerFast

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_clip import CLIPFeatureExtractor
														from .image_processing_clip import CLIPImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_clip import (
														    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    CLIPModel,
														    CLIPPreTrainedModel,
														    CLIPTextModel,
														    CLIPTextModelWithProjection,
														    CLIPVisionModel,
														    CLIPVisionModelWithProjection,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_clip import (
														    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFCLIPModel,
														    TFCLIPPreTrainedModel,
														    TFCLIPTextModel,
														    TFCLIPVisionModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_clip import (
														    FlaxCLIPModel,
														    FlaxCLIPPreTrainedModel,
														    FlaxCLIPTextModel,
														    FlaxCLIPTextPreTrainedModel,
														    FlaxCLIPVisionModel,
														    FlaxCLIPVisionPreTrainedModel,
														)


else:
							import sys

							UpperCAmelCase__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
