

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







	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							torch.manual_seed(0						)
							lowercase        =							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 ,				)
							lowercase        =							DDIMScheduler(
							    beta_start=0.0_0085 ,				beta_end=0.012 ,				beta_schedule="""scaled_linear""" ,				clip_sample=_lowercase ,				set_alpha_to_one=_lowercase ,				)
							torch.manual_seed(0						)
							lowercase        =							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						)
							lowercase        =							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 ,				)
							lowercase        =							CLIPTextModel(_lowercase						)
							lowercase        =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

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







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=0						)    ->    int:
							'''simple docstring'''






							if str(_lowercase						).startswith("""mps"""						):
													lowercase        =							torch.manual_seed(_lowercase						)
							else:
													lowercase        =							torch.Generator(device=_lowercase						).manual_seed(_lowercase						)
							lowercase        =							{
							    '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						)    ->    Optional[Any]:
							'''simple docstring'''






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

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

							assert frames[0].shape == (64, 64, 3)
							lowercase        =							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   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_lowercase ,				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						)    ->    Any:
							'''simple docstring'''






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







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






							pass







	@unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""						)
	def   _a   (    self						)    ->    Optional[Any]:
							'''simple docstring'''






							pass







	@unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""						)
	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							pass







	def   _a   (    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							return super().test_progress_bar()




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







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






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

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

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

							lowercase        =							pipe(_lowercase ,				generator=_lowercase ,				num_inference_steps=25 ,				output_type="""pt"""						).frames
							lowercase        =							video_frames.cpu().numpy()

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







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






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

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

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

							lowercase        =							pipe(_lowercase ,				generator=_lowercase ,				num_inference_steps=2 ,				output_type="""pt"""						).frames
							lowercase        =							video_frames.cpu().numpy()

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







'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase_      :				Any   					=    logging.get_logger(__name__)

lowercase_      :				str   					=    {
    '''sayakpaul/vit-msn-base''': '''https://huggingface.co/sayakpaul/vit-msn-base/resolve/main/config.json''',
    # See all ViT MSN models at https://huggingface.co/models?filter=vit_msn
}




class      __UpperCamelCase       (_UpperCAmelCase			):
	__A			  =					'''vit_msn'''







	def __init__(    self ,				_lowerCAmelCase=768 ,				_lowerCAmelCase=12 ,				_lowerCAmelCase=12 ,				_lowerCAmelCase=3072 ,				_lowerCAmelCase="gelu" ,				_lowerCAmelCase=0.0 ,				_lowerCAmelCase=0.0 ,				_lowerCAmelCase=0.02 ,				_lowerCAmelCase=1E-06 ,				_lowerCAmelCase=224 ,				_lowerCAmelCase=16 ,				_lowerCAmelCase=3 ,				_lowerCAmelCase=True ,				**_lowerCAmelCase ,				)    ->    List[Any]:
							'''simple docstring'''






							super().__init__(**_lowerCAmelCase						)

							lowercase        =							hidden_size
							lowercase        =							num_hidden_layers
							lowercase        =							num_attention_heads
							lowercase        =							intermediate_size
							lowercase        =							hidden_act
							lowercase        =							hidden_dropout_prob
							lowercase        =							attention_probs_dropout_prob
							lowercase        =							initializer_range
							lowercase        =							layer_norm_eps
							lowercase        =							image_size
							lowercase        =							patch_size
							lowercase        =							num_channels
							lowercase        =							qkv_bias


