






'''simple docstring'''







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 						SCREAMING_SNAKE_CASE       (       SCREAMING_SNAKE_CASE_						, unittest.TestCase							):
			snake_case__	=					TextToVideoSDPipeline
			snake_case__	=					TEXT_TO_IMAGE_PARAMS
			snake_case__	=					TEXT_TO_IMAGE_BATCH_PARAMS
			# No `output_type`.
			snake_case__	=					frozenset(
			    [
			        "num_inference_steps",
			        "generator",
			        "latents",
			        "return_dict",
			        "callback",
			        "callback_steps",
			    ]							)






			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      Optional[Any]:
							torch.manual_seed(0       )
							a_		:	List[str]									=   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	,    )
							a_		:	Optional[Any]									=   DDIMScheduler(
							    beta_start=0.0_0085	,    beta_end=0.012	,    beta_schedule='''scaled_linear'''	,    clip_sample=__SCREAMING_SNAKE_CASE	,    set_alpha_to_one=__SCREAMING_SNAKE_CASE	,    )
							torch.manual_seed(0       )
							a_		:	Tuple									=   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=128	,    )
							torch.manual_seed(0       )
							a_		:	List[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	,    hidden_act='''gelu'''	,    projection_dim=512	,    )
							a_		:	List[Any]									=   CLIPTextModel(__SCREAMING_SNAKE_CASE       )
							a_		:	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,
							}
							return components






			def       SCREAMING_SNAKE_CASE   (			self   :      Any	,    __SCREAMING_SNAKE_CASE   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Dict=0       )      ->      Dict:
							if str(__SCREAMING_SNAKE_CASE       ).startswith('''mps'''       ):
											a_		:	List[str]									=   torch.manual_seed(__SCREAMING_SNAKE_CASE       )
							else:
											a_		:	Optional[int]									=   torch.Generator(device=__SCREAMING_SNAKE_CASE       ).manual_seed(__SCREAMING_SNAKE_CASE       )
							a_		:	Optional[int]									=   {
							    '''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       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      List[Any]:
							a_		:	Union[str, Any]									=   '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							a_		:	int									=   self.get_dummy_components()
							a_		:	Any									=   TextToVideoSDPipeline(**__SCREAMING_SNAKE_CASE       )
							a_		:	Tuple									=   sd_pipe.to(__SCREAMING_SNAKE_CASE       )
							sd_pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE       )

							a_		:	int									=   self.get_dummy_inputs(__SCREAMING_SNAKE_CASE       )
							a_		:	Tuple									=   '''np'''
							a_		:	Dict									=   sd_pipe(**__SCREAMING_SNAKE_CASE       ).frames
							a_		:	Tuple									=   frames[0][-3:, -3:, -1]

							assert frames[0].shape == (64, 64, 3)
							a_		:	Optional[Any]									=   np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]       )

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






			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      List[Any]:
							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__SCREAMING_SNAKE_CASE	,    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       SCREAMING_SNAKE_CASE   (			self   :      Tuple       )      ->      List[str]:
							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__SCREAMING_SNAKE_CASE	,    expected_max_diff=1e-2       )






			@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''       )
			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      Union[str, Any]:
							pass






			@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''       )
			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      Tuple:
							pass






			@unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''       )
			def       SCREAMING_SNAKE_CASE   (			self   :      Any       )      ->      int:
							pass







			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      List[Any]:
							return super().test_progress_bar()





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






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      List[str]:
							a_		:	str									=   load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''       )

							a_		:	Optional[Any]									=   TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''       )
							a_		:	Optional[Any]									=   DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
							a_		:	str									=   pipe.to('''cuda'''       )

							a_		:	Any									=   '''Spiderman is surfing'''
							a_		:	Tuple									=   torch.Generator(device='''cpu'''       ).manual_seed(0       )

							a_		:	Optional[Any]									=   pipe(__SCREAMING_SNAKE_CASE	,    generator=__SCREAMING_SNAKE_CASE	,    num_inference_steps=25	,    output_type='''pt'''       ).frames
							a_		:	List[str]									=   video_frames.cpu().numpy()

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







			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      Dict:
							a_		:	Dict									=   load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''       )

							a_		:	Optional[Any]									=   TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''       )
							a_		:	List[str]									=   pipe.to('''cuda'''       )

							a_		:	str									=   '''Spiderman is surfing'''
							a_		:	Union[str, Any]									=   torch.Generator(device='''cpu'''       ).manual_seed(0       )

							a_		:	Optional[Any]									=   pipe(__SCREAMING_SNAKE_CASE	,    generator=__SCREAMING_SNAKE_CASE	,    num_inference_steps=2	,    output_type='''pt'''       ).frames
							a_		:	List[Any]									=   video_frames.cpu().numpy()

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












'''simple docstring'''







from typing import TYPE_CHECKING

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


__lowerCAmelCase									=   {'configuration_deit': ['DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeiTConfig', 'DeiTOnnxConfig']}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCAmelCase									=   ['DeiTFeatureExtractor']
		__lowerCAmelCase									=   ['DeiTImageProcessor']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCAmelCase									=   [
		    'DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'DeiTForImageClassification',
		    'DeiTForImageClassificationWithTeacher',
		    'DeiTForMaskedImageModeling',
		    'DeiTModel',
		    'DeiTPreTrainedModel',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCAmelCase									=   [
		    'TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TFDeiTForImageClassification',
		    'TFDeiTForImageClassificationWithTeacher',
		    'TFDeiTForMaskedImageModeling',
		    'TFDeiTModel',
		    'TFDeiTPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_deit import DeiTFeatureExtractor
				from .image_processing_deit import DeiTImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_deit import (
				    DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    DeiTForImageClassification,
				    DeiTForImageClassificationWithTeacher,
				    DeiTForMaskedImageModeling,
				    DeiTModel,
				    DeiTPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_deit import (
				    TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFDeiTForImageClassification,
				    TFDeiTForImageClassificationWithTeacher,
				    TFDeiTForMaskedImageModeling,
				    TFDeiTModel,
				    TFDeiTPreTrainedModel,
				)


else:
		import sys

		__lowerCAmelCase									=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




