
"""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 						a__		( snake_case__,     unittest.TestCase		):
   __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      __magic_name__     (     self							):
          torch.manual_seed(0							)
          lowercase       :							Tuple									=				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       :							Dict									=				DDIMScheduler(
              beta_start=0.0_0_0_8_5      ,       beta_end=0.0_1_2      ,       beta_schedule="scaled_linear"      ,       clip_sample=__snake_case      ,       set_alpha_to_one=__snake_case      ,       )
          torch.manual_seed(0							)
          lowercase       :							Optional[int]									=				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       :							Dict									=				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=1_000      ,       hidden_act="gelu"      ,       projection_dim=512      ,       )
          lowercase       :							str									=				CLIPTextModel(__snake_case							)
          lowercase       :							Optional[Any]									=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)

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

          lowercase       :							List[Any]									=				self.get_dummy_inputs(__snake_case							)
          lowercase       :							Any									=				"np"
          lowercase       :							Tuple									=				sd_pipe(**__snake_case							).frames
          lowercase       :							List[str]									=				frames[0][-3:, -3:, -1]

          assert frames[0].shape == (64, 64, 3)
          lowercase       :							Tuple									=				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      __magic_name__     (     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      __magic_name__     (     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      __magic_name__     (     self							):
          pass
   @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."							)
   def      __magic_name__     (     self							):
          pass
   @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."							)
   def      __magic_name__     (     self							):
          pass

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


@slow
@skip_mps
class 						a__		( unittest.TestCase		):
   def      __magic_name__     (     self							):
          lowercase       :							str									=				load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"							)

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

          lowercase       :							Dict									=				"Spiderman is surfing"
          lowercase       :							List[str]									=				torch.Generator(device="cpu"							).manual_seed(0							)

          lowercase       :							Union[str, Any]									=				pipe(__snake_case      ,       generator=__snake_case      ,       num_inference_steps=25      ,       output_type="pt"							).frames
          lowercase       :							Tuple									=				video_frames.cpu().numpy()

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

   def      __magic_name__     (     self							):
          lowercase       :							Union[str, Any]									=				load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"							)

          lowercase       :							Optional[int]									=				TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"							)
          lowercase       :							str									=				pipe.to("cuda"							)

          lowercase       :							Tuple									=				"Spiderman is surfing"
          lowercase       :							List[Any]									=				torch.Generator(device="cpu"							).manual_seed(0							)

          lowercase       :							Optional[Any]									=				pipe(__snake_case      ,       generator=__snake_case      ,       num_inference_steps=2      ,       output_type="pt"							).frames
          lowercase       :							List[Any]									=				video_frames.cpu().numpy()

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






def      UpperCAmelCase__		(UpperCamelCase_ = 10_00							):



     """simple docstring"""






     return sum(2 * a * ((a - 1) // 2) for a in range(3				,n + 1							)							)


if __name__ == "__main__":
 print(solution())




