

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							(							__A							,	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 							__UpperCamelCase (			self							: Dict	)							->       Dict:

				"""simple docstring"""

				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      int				     =       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      ,      )
				SCREAMING_SNAKE_CASE   :      List[str]				     =       DDIMScheduler(
				    beta_start=0.0_0085      ,      beta_end=0.012      ,      beta_schedule="scaled_linear"      ,      clip_sample=a      ,      set_alpha_to_one=a      ,      )
				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      List[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	)
				SCREAMING_SNAKE_CASE   :      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      ,      )
				SCREAMING_SNAKE_CASE   :      List[str]				     =       CLIPTextModel(a	)
				SCREAMING_SNAKE_CASE   :      Dict				     =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       {
				    "unet": unet,
				    "scheduler": scheduler,
				    "vae": vae,
				    "text_encoder": text_encoder,
				    "tokenizer": tokenizer,
				}
				return components
			def 							__UpperCamelCase (			self							: List[Any]      ,      a							: List[Any]      ,      a							: Optional[int]=0	)							->       List[str]:

				"""simple docstring"""

				if str(a	).startswith("mps"	):
					SCREAMING_SNAKE_CASE   :      List[str]				     =       torch.manual_seed(a	)
				else:
					SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       torch.Generator(device=a	).manual_seed(a	)
				SCREAMING_SNAKE_CASE   :      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 							__UpperCamelCase (			self							: Tuple	)							->       str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      List[str]				     =       "cpu"  # ensure determinism for the device-dependent torch.Generator
				SCREAMING_SNAKE_CASE   :      int				     =       self.get_dummy_components()
				SCREAMING_SNAKE_CASE   :      int				     =       TextToVideoSDPipeline(**a	)
				SCREAMING_SNAKE_CASE   :      Tuple				     =       sd_pipe.to(a	)
				sd_pipe.set_progress_bar_config(disable=a	)

				SCREAMING_SNAKE_CASE   :      Any				     =       self.get_dummy_inputs(a	)
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       "np"
				SCREAMING_SNAKE_CASE   :      Dict				     =       sd_pipe(**a	).frames
				SCREAMING_SNAKE_CASE   :      str				     =       frames[0][-3:, -3:, -1]

				assert frames[0].shape == (64, 64, 3)
				SCREAMING_SNAKE_CASE   :      List[str]				     =       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 							__UpperCamelCase (			self							: Dict	)							->       List[Any]:

				"""simple docstring"""

				self._test_attention_slicing_forward_pass(test_mean_pixel_difference=a      ,      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 							__UpperCamelCase (			self							: Optional[Any]	)							->       Optional[int]:

				"""simple docstring"""

				self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=a      ,      expected_max_diff=1e-2	)
			@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."	)
			def 							__UpperCamelCase (			self							: List[str]	)							->       Optional[Any]:

				"""simple docstring"""

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

				"""simple docstring"""

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

				"""simple docstring"""

				pass






			def 							__UpperCamelCase (			self							: List[Any]	)							->       Optional[int]:

				"""simple docstring"""

				return super().test_progress_bar()






@slow
@skip_mps
class _UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			def 							__UpperCamelCase (			self							: List[Any]	)							->       Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"	)

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

				SCREAMING_SNAKE_CASE   :      int				     =       "Spiderman is surfing"
				SCREAMING_SNAKE_CASE   :      Tuple				     =       torch.Generator(device="cpu"	).manual_seed(0	)

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       pipe(a      ,      generator=a      ,      num_inference_steps=25      ,      output_type="pt"	).frames
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       video_frames.cpu().numpy()

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






			def 							__UpperCamelCase (			self							: Optional[int]	)							->       Optional[Any]:

				"""simple docstring"""

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

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

				SCREAMING_SNAKE_CASE   :      str				     =       "Spiderman is surfing"
				SCREAMING_SNAKE_CASE   :      int				     =       torch.Generator(device="cpu"	).manual_seed(0	)

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       pipe(a      ,      generator=a      ,      num_inference_steps=2      ,      output_type="pt"	).frames
				SCREAMING_SNAKE_CASE   :      Tuple				     =       video_frames.cpu().numpy()

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


def  lowerCamelCase__ (					_a = 50):
	SCREAMING_SNAKE_CASE   :      int				     =       [1] * (length + 1)

	for row_length in range(length + 1):
		for tile_length in range(2							,			5):
			for tile_start in range(row_length - tile_length + 1):
				ways_number[row_length] += ways_number[
				    row_length - tile_start - tile_length
				]

	return ways_number[length]


if __name__ == "__main__":
			print(F'''{solution() = }''')