




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






			'''simple docstring'''



			lowerCamelCase__   =    TextToVideoSDPipeline
			lowerCamelCase__   =    TEXT_TO_IMAGE_PARAMS
			lowerCamelCase__   =    TEXT_TO_IMAGE_BATCH_PARAMS
			# No `output_type`.
			lowerCamelCase__   =    frozenset(
			    [
			        """num_inference_steps""",
			        """generator""",
			        """latents""",
			        """return_dict""",
			        """callback""",
			        """callback_steps""",
			    ]		)
			def       A_					(						self						):
							torch.manual_seed(0						)
							_lowerCamelCase  :    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						,   )
							_lowerCamelCase  :    List[Any]					=					DDIMScheduler(
							    beta_start=0.0_00_85						,   beta_end=0.0_12						,   beta_schedule='scaled_linear'						,   clip_sample=snake_case_						,   set_alpha_to_one=snake_case_						,   )
							torch.manual_seed(0						)
							_lowerCamelCase  :    Union[str, Any]					=					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						)
							_lowerCamelCase  :    Optional[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						,   )
							_lowerCamelCase  :    Tuple					=					CLIPTextModel(snake_case_						)
							_lowerCamelCase  :    Optional[int]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

							_lowerCamelCase  :    Any					=					{
							    "unet": unet,
							    "scheduler": scheduler,
							    "vae": vae,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							}
							return components
			def       A_					(						self						,   lowercase						,   lowercase=0						):
							if str(snake_case_						).startswith('mps'						):
											_lowerCamelCase  :    str					=					torch.manual_seed(snake_case_						)
							else:
											_lowerCamelCase  :    Union[str, Any]					=					torch.Generator(device=snake_case_						).manual_seed(snake_case_						)
							_lowerCamelCase  :    str					=					{
							    "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       A_					(						self						):
							_lowerCamelCase  :    int					=					"cpu"  # ensure determinism for the device-dependent torch.Generator
							_lowerCamelCase  :    Optional[Any]					=					self.get_dummy_components()
							_lowerCamelCase  :    Tuple					=					TextToVideoSDPipeline(**snake_case_						)
							_lowerCamelCase  :    List[str]					=					sd_pipe.to(snake_case_						)
							sd_pipe.set_progress_bar_config(disable=snake_case_						)

							_lowerCamelCase  :    int					=					self.get_dummy_inputs(snake_case_						)
							_lowerCamelCase  :    Union[str, Any]					=					"np"
							_lowerCamelCase  :    Dict					=					sd_pipe(**snake_case_						).frames
							_lowerCamelCase  :    Any					=					frames[0][-3:, -3:, -1]

							assert frames[0].shape == (64, 64, 3)
							_lowerCamelCase  :    Dict					=					np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0]						)

							assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-2
			def       A_					(						self						):
							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=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       A_					(						self						):
							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case_						,   expected_max_diff=1E-2						)
			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'						)
			def       A_					(						self						):
							pass






			def       A_					(						self						):
							return super().test_progress_bar()






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






			'''simple docstring'''



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

							_lowerCamelCase  :    int					=					TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'						)
							_lowerCamelCase  :    str					=					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
							_lowerCamelCase  :    Tuple					=					pipe.to('cuda'						)

							_lowerCamelCase  :    List[Any]					=					"Spiderman is surfing"
							_lowerCamelCase  :    Optional[int]					=					torch.Generator(device='cpu'						).manual_seed(0						)

							_lowerCamelCase  :    int					=					pipe(snake_case_						,   generator=snake_case_						,   num_inference_steps=25						,   output_type='pt'						).frames
							_lowerCamelCase  :    int					=					video_frames.cpu().numpy()

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






			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					load_numpy(
							    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'						)

							_lowerCamelCase  :    str					=					TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'						)
							_lowerCamelCase  :    int					=					pipe.to('cuda'						)

							_lowerCamelCase  :    Any					=					"Spiderman is surfing"
							_lowerCamelCase  :    str					=					torch.Generator(device='cpu'						).manual_seed(0						)

							_lowerCamelCase  :    Any					=					pipe(snake_case_						,   generator=snake_case_						,   num_inference_steps=2						,   output_type='pt'						).frames
							_lowerCamelCase  :    Optional[int]					=					video_frames.cpu().numpy()

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





"""simple docstring"""






from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase__  		=		logging.get_logger(__name__)

lowercase__  		=		{
    """facebook/deit-base-distilled-patch16-224""": (
        """https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json"""
    ),
    # See all DeiT models at https://huggingface.co/models?filter=deit
}






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    """deit"""
			def __init__(						self						,   lowercase=768						,   lowercase=12						,   lowercase=12						,   lowercase=3072						,   lowercase="gelu"						,   lowercase=0.0						,   lowercase=0.0						,   lowercase=0.02						,   lowercase=1E-12						,   lowercase=224						,   lowercase=16						,   lowercase=3						,   lowercase=True						,   lowercase=16						,   **lowercase						,   ):
							super().__init__(**lowercase						)

							_lowerCamelCase  :    Optional[Any]					=					hidden_size
							_lowerCamelCase  :    List[str]					=					num_hidden_layers
							_lowerCamelCase  :    Tuple					=					num_attention_heads
							_lowerCamelCase  :    Any					=					intermediate_size
							_lowerCamelCase  :    int					=					hidden_act
							_lowerCamelCase  :    Any					=					hidden_dropout_prob
							_lowerCamelCase  :    str					=					attention_probs_dropout_prob
							_lowerCamelCase  :    str					=					initializer_range
							_lowerCamelCase  :    Union[str, Any]					=					layer_norm_eps
							_lowerCamelCase  :    Optional[Any]					=					image_size
							_lowerCamelCase  :    Optional[int]					=					patch_size
							_lowerCamelCase  :    Dict					=					num_channels
							_lowerCamelCase  :    Dict					=					qkv_bias
							_lowerCamelCase  :    Dict					=					encoder_stride






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    version.parse("""1.11"""		)
			@property
			def       A_					(						self						):
							return OrderedDict(
							    [
							        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
							    ]						)






			@property
			def       A_					(						self						):
							return 1E-4