





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     ):
      _UpperCAmelCase      :List[str]		       =  TextToVideoSDPipeline
      _UpperCAmelCase      :Tuple		       =  TEXT_TO_IMAGE_PARAMS
      _UpperCAmelCase      :Optional[Any]		       =  TEXT_TO_IMAGE_BATCH_PARAMS
      # No `output_type`.
      _UpperCAmelCase      :int		       =  frozenset(
          [
              'num_inference_steps',
              'generator',
              'latents',
              'return_dict',
              'callback',
              'callback_steps',
          ]     )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       torch.manual_seed(0  )
       UpperCamelCase      :   Optional[Any]			      =  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			,				)
       UpperCamelCase      :   Optional[int]			      =  DDIMScheduler(
           beta_start=0.0_00_85			,				beta_end=0.0_12			,				beta_schedule="scaled_linear"			,				clip_sample=A_			,				set_alpha_to_one=A_			,				)
       torch.manual_seed(0  )
       UpperCamelCase      :   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  )
       UpperCamelCase      :   Union[str, 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			,				)
       UpperCamelCase      :   List[str]			      =  CLIPTextModel(A_  )
       UpperCamelCase      :   Tuple			      =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )

       UpperCamelCase      :   List[str]			      =  {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
       }
       return components





      def 			__UpperCamelCase(					self			,				A_			,				A_=0  ):
       '''simple docstring'''




       if str(A_  ).startswith("mps"  ):
        UpperCamelCase      :   Any			      =  torch.manual_seed(A_  )
       else:
        UpperCamelCase      :   int			      =  torch.Generator(device=A_  ).manual_seed(A_  )
       UpperCamelCase      :   List[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 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Dict			      =  "cpu"  # ensure determinism for the device-dependent torch.Generator
       UpperCamelCase      :   List[Any]			      =  self.get_dummy_components()
       UpperCamelCase      :   Dict			      =  TextToVideoSDPipeline(**A_  )
       UpperCamelCase      :   int			      =  sd_pipe.to(A_  )
       sd_pipe.set_progress_bar_config(disable=A_  )

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

       assert frames[0].shape == (64, 64, 3)
       UpperCamelCase      :   List[Any]			      =  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 			__UpperCamelCase(					self  ):
       '''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  ):
       '''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  ):
       '''simple docstring'''




       pass





      @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return super().test_progress_bar()



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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




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

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

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

       UpperCamelCase      :   Tuple			      =  pipe(A_			,				generator=A_			,				num_inference_steps=25			,				output_type="pt"  ).frames
       UpperCamelCase      :   str			      =  video_frames.cpu().numpy()

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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




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

       UpperCamelCase      :   List[str]			      =  TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"  )
       UpperCamelCase      :   Any			      =  pipe.to("cuda"  )

       UpperCamelCase      :   str			      =  "Spiderman is surfing"
       UpperCamelCase      :   Optional[int]			      =  torch.Generator(device="cpu"  ).manual_seed(0  )

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

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







def 						A_							(	_lowerCAmelCase = 1000	)		->					int:
 UpperCamelCase      :   Optional[int]			      =  -1
 UpperCamelCase      :   int			      =  0
 for a in range(1				,  n // 3	):
  # Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c
  UpperCamelCase      :   Optional[Any]			      =  (n * n - 2 * a * n) // (2 * n - 2 * a)
  UpperCamelCase      :   List[str]			      =  n - a - b
  if c * c == (a * a + b * b):
   UpperCamelCase      :   Union[str, Any]			      =  a * b * c
   if candidate >= product:
    UpperCamelCase      :   Tuple			      =  candidate
 return product


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