





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   ):

  """simple docstring"""


  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     lowercase		(    self			:		Any					)							->						int:
     torch.manual_seed(0					)
     __lowerCAmelCase							     =     UNetaDConditionModel(
         block_out_channels=(3_2, 6_4, 6_4, 6_4) ,  layers_per_block=2 ,  sample_size=3_2 ,  in_channels=4 ,  out_channels=4 ,  down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D') ,  up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D') ,  cross_attention_dim=3_2 ,  attention_head_dim=4 ,  )
     __lowerCAmelCase							     =     DDIMScheduler(
         beta_start=0.0_00_85 ,  beta_end=0.0_12 ,  beta_schedule='scaled_linear' ,  clip_sample=lowerCAmelCase_ ,  set_alpha_to_one=lowerCAmelCase_ ,  )
     torch.manual_seed(0					)
     __lowerCAmelCase							     =     AutoencoderKL(
         block_out_channels=[3_2, 6_4] ,  in_channels=3 ,  out_channels=3 ,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] ,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] ,  latent_channels=4 ,  sample_size=1_2_8 ,  )
     torch.manual_seed(0					)
     __lowerCAmelCase							     =     CLIPTextConfig(
         bos_token_id=0 ,  eos_token_id=2 ,  hidden_size=3_2 ,  intermediate_size=3_7 ,  layer_norm_eps=1e-05 ,  num_attention_heads=4 ,  num_hidden_layers=5 ,  pad_token_id=1 ,  vocab_size=1_0_0_0 ,  hidden_act='gelu' ,  projection_dim=5_1_2 ,  )
     __lowerCAmelCase							     =     CLIPTextModel(lowerCAmelCase_					)
     __lowerCAmelCase							     =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

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






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

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

     assert frames[0].shape == (6_4, 6_4, 3)
     __lowerCAmelCase							     =     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     lowercase		(    self			:		Union[str, Any]					)							->						Optional[Any]:
     self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCAmelCase_ ,  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     lowercase		(    self			:		Union[str, Any]					)							->						Any:
     self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase_ ,  expected_max_diff=1e-2					)






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






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






  @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'					)
  def     lowercase		(    self			:		Union[str, Any]					)							->						Union[str, Any]:
     pass






  def     lowercase		(    self			:		List[Any]					)							->						Dict:
     return super().test_progress_bar()





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

  """simple docstring"""


  def     lowercase		(    self			:		Union[str, Any]					)							->						Dict:
     __lowerCAmelCase							     =     load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'					)

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

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

     __lowerCAmelCase							     =     pipe(lowerCAmelCase_ ,  generator=lowerCAmelCase_ ,  num_inference_steps=2_5 ,  output_type='pt'					).frames
     __lowerCAmelCase							     =     video_frames.cpu().numpy()

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






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

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

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

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

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








from functools import lru_cache

@lru_cache
def   a_   (			lowerCAmelCase_				:      int     ):
   if num < 0:
      raise ValueError('Number should not be negative.'     )

   return 1 if num in (0, 1) else num * factorial(num - 1     )


if __name__ == "__main__":
     import doctest

     doctest.testmod()

