
"""simple docstring"""
import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)






class      _UpperCAmelCase				(					unittest.TestCase):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      self.assertEqual(x.component(0     )						,    1     )
      self.assertEqual(x.component(2     )						,    3     )
      _snake_case     :						List[Any]						=   Vector()
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   Vector([0, 0, 0, 0, 0, 1]     )
      self.assertEqual(str(snake_case_     )						,    "(0,0,0,0,0,1)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 2, 3, 4]     )
      self.assertEqual(len(snake_case_     )						,    4     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2]     )
      _snake_case     :						List[str]						=   Vector([1, 2, 3, 4, 5]     )
      _snake_case     :						List[Any]						=   Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]     )
      _snake_case     :						Any						=   Vector([1, -1, 1, -1, 2, -3, 4, -5]     )
      self.assertAlmostEqual(x.euclidean_length()						,    2.236						,    3     )
      self.assertAlmostEqual(y.euclidean_length()						,    7.416						,    3     )
      self.assertEqual(z.euclidean_length()						,    0     )
      self.assertAlmostEqual(w.euclidean_length()						,    7.616						,    3     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      _snake_case     :						Any						=   Vector([1, 1, 1]     )
      self.assertEqual((x + y).component(0     )						,    2     )
      self.assertEqual((x + y).component(1     )						,    3     )
      self.assertEqual((x + y).component(2     )						,    4     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Vector([1, 2, 3]     )
      _snake_case     :						Union[str, Any]						=   Vector([1, 1, 1]     )
      self.assertEqual((x - y).component(0     )						,    0     )
      self.assertEqual((x - y).component(1     )						,    1     )
      self.assertEqual((x - y).component(2     )						,    2     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   Vector([1, 2, 3]     )
      _snake_case     :						List[Any]						=   Vector([2, -1, 4]     )  # for test of dot product
      _snake_case     :						Union[str, Any]						=   Vector([1, -2, -1]     )
      self.assertEqual(str(x * 3.0     )						,    "(3.0,6.0,9.0)"     )
      self.assertEqual((a * b)						,    0     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(zero_vector(10     )     ).count("0"     )						,    10     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(unit_basis_vector(3						,    1     )     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Vector([1, 2, 3]     )
      _snake_case     :						Optional[Any]						=   Vector([1, 0, 1]     )
      self.assertEqual(str(axpy(2						,    snake_case_						,    snake_case_     )     )						,    "(3,4,7)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Vector([1, 0, 0, 0, 0, 0]     )
      _snake_case     :						Optional[int]						=   x.copy()
      self.assertEqual(str(snake_case_     )						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 0, 0]     )
      x.change_component(0						,    0     )
      x.change_component(1						,    1     )
      self.assertEqual(str(snake_case_     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						str						=   [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
      for x in range(a.height()     ):
        for y in range(a.width()     ):
          self.assertEqual(minors[x][y]						,    a.minor(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
      for x in range(a.height()     ):
        for y in range(a.width()     ):
          self.assertEqual(cofactors[x][y]						,    a.cofactor(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(-5						,    a.determinant()     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						,    3						,    3     )
      _snake_case     :						List[str]						=   Vector([1, 2, 3]     )
      self.assertEqual("(14,32,50)"						,    str(a * x     )     )
      self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"						,    str(a * 2     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      a.change_component(0						,    2						,    5     )
      self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(7						,    a.component(2						,    1     )						,    0.01     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						int						=   Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,    3						,    3     )
      self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"						,    str(a + b     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,    3						,    3     )
      self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"						,    str(a - b     )     )


    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(
          "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"						,    str(square_zero_matrix(5     )     )						,    )


if __name__ == "__main__":
    unittest.main()



"""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				(					_snake_case		,					unittest.TestCase):
    __lowercase							: Any  =					TextToVideoSDPipeline
    __lowercase							: str  =					TEXT_TO_IMAGE_PARAMS
    __lowercase							: int  =					TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    __lowercase							: Optional[int]  =					frozenset(
        [
            """num_inference_steps""",
            """generator""",
            """latents""",
            """return_dict""",
            """callback""",
            """callback_steps""",
        ])
    def 					lowerCamelCase__	(    self     ):
      torch.manual_seed(0     )
      _snake_case     :						str						=   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						,    )
      _snake_case     :						List[Any]						=   DDIMScheduler(
          beta_start=0.00085						,    beta_end=0.012						,    beta_schedule="scaled_linear"						,    clip_sample=snake_case_						,    set_alpha_to_one=snake_case_						,    )
      torch.manual_seed(0     )
      _snake_case     :						Union[str, 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=1_28						,    )
      torch.manual_seed(0     )
      _snake_case     :						Optional[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=10_00						,    hidden_act="gelu"						,    projection_dim=5_12						,    )
      _snake_case     :						Tuple						=   CLIPTextModel(snake_case_     )
      _snake_case     :						Optional[int]						=   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

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

      _snake_case     :						int						=   self.get_dummy_inputs(snake_case_     )
      _snake_case     :						Union[str, Any]						=   "np"
      _snake_case     :						Dict						=   sd_pipe(**snake_case_     ).frames
      _snake_case     :						Any						=   frames[0][-3:, -3:, -1]

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


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






@slow
@skip_mps
class      _UpperCAmelCase				(					unittest.TestCase):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"     )

      _snake_case     :						int						=   TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"     )
      _snake_case     :						str						=   DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
      _snake_case     :						Tuple						=   pipe.to("cuda"     )

      _snake_case     :						List[Any]						=   "Spiderman is surfing"
      _snake_case     :						Optional[int]						=   torch.Generator(device="cpu"     ).manual_seed(0     )

      _snake_case     :						int						=   pipe(snake_case_						,    generator=snake_case_						,    num_inference_steps=25						,    output_type="pt"     ).frames
      _snake_case     :						int						=   video_frames.cpu().numpy()

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


    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   load_numpy(
          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"     )

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

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

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

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

