

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





       """simple docstring"""


       __UpperCamelCase					:      int    =						TextToVideoSDPipeline
       __UpperCamelCase					:      Union[str, Any]    =						TEXT_TO_IMAGE_PARAMS
       __UpperCamelCase					:      Optional[int]    =						TEXT_TO_IMAGE_BATCH_PARAMS
       # No `output_type`.
       __UpperCamelCase					:      int    =						frozenset(
           [
               'num_inference_steps',
               'generator',
               'latents',
               'return_dict',
               'callback',
               'callback_steps',
           ]       )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        torch.manual_seed(0   )
        lowerCAmelCase__   :				List[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			,					)
        lowerCAmelCase__   :				Dict 			=				DDIMScheduler(
            beta_start=0.00_085			,					beta_end=0.012			,					beta_schedule="scaled_linear"			,					clip_sample=lowercase__			,					set_alpha_to_one=lowercase__			,					)
        torch.manual_seed(0   )
        lowerCAmelCase__   :				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   )
        lowerCAmelCase__   :				str 			=				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			,					)
        lowerCAmelCase__   :				Tuple 			=				CLIPTextModel(lowercase__   )
        lowerCAmelCase__   :				Union[str, Any] 			=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )

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






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case=0   ):





        """simple docstring"""

        if str(lowercase__   ).startswith("mps"   ):
         lowerCAmelCase__   :				Tuple 			=				torch.manual_seed(lowercase__   )
        else:
         lowerCAmelCase__   :				str 			=				torch.Generator(device=lowercase__   ).manual_seed(lowercase__   )
        lowerCAmelCase__   :				Optional[Any] 			=				{
            """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 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator
        lowerCAmelCase__   :				Union[str, Any] 			=				self.get_dummy_components()
        lowerCAmelCase__   :				List[Any] 			=				TextToVideoSDPipeline(**lowercase__   )
        lowerCAmelCase__   :				List[str] 			=				sd_pipe.to(lowercase__   )
        sd_pipe.set_progress_bar_config(disable=lowercase__   )

        lowerCAmelCase__   :				Optional[int] 			=				self.get_dummy_inputs(lowercase__   )
        lowerCAmelCase__   :				Dict 			=				"""np"""
        lowerCAmelCase__   :				Optional[int] 			=				sd_pipe(**lowercase__   ).frames
        lowerCAmelCase__   :				List[str] 			=				frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        lowerCAmelCase__   :				Optional[int] 			=				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 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowercase__			,					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 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase__			,					expected_max_diff=1e-2   )






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





        """simple docstring"""

        pass






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





        """simple docstring"""

        pass






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





        """simple docstring"""

        pass






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        return super().test_progress_bar()






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





       """simple docstring"""


       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

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

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

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

        lowerCAmelCase__   :				Any 			=				pipe(lowercase__			,					generator=lowercase__			,					num_inference_steps=25			,					output_type="pt"   ).frames
        lowerCAmelCase__   :				List[Any] 			=				video_frames.cpu().numpy()

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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

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

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

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

        lowerCAmelCase__   :				Dict 			=				pipe(lowercase__			,					generator=lowercase__			,					num_inference_steps=2			,					output_type="pt"   ).frames
        lowerCAmelCase__   :				int 			=				video_frames.cpu().numpy()

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












'''simple docstring'''


from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
lowerCAmelCase_      :  List[Any]				     =  2_9979_2458

# Symbols
lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_      :  Tuple				     =  symbols('ct x y z')



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					float				):




     """simple docstring"""


     if velocity > c:
          raise ValueError("""Speed must not exceed light speed 299,792,458 [m/s]!"""				)
     elif velocity < 1:
          # Usually the speed should be much higher than 1 (c order of magnitude)
          raise ValueError("""Speed must be greater than or equal to 1!"""				)

     return velocity / c



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					float				):




     """simple docstring"""


     return 1 / sqrt(1 - beta(UpperCamelCase__				) ** 2				)



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					float				):




     """simple docstring"""


     return np.array(
         [
             [gamma(UpperCamelCase__				), -gamma(UpperCamelCase__				) * beta(UpperCamelCase__				), 0, 0],
             [-gamma(UpperCamelCase__				) * beta(UpperCamelCase__				), gamma(UpperCamelCase__				), 0, 0],
             [0, 0, 1, 0],
             [0, 0, 0, 1],
         ]				)



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					float ,    UpperCamelCase__    :					np.ndarray | None = None				):




     """simple docstring"""


     if event is None:
          a_     :							str     						=  np.array([ct, x, y, z]				)  # Symbolic four vector
     else:
          event[0] *= c  # x0 is ct (speed of light * time)

     return transformation_matrix(UpperCamelCase__				) @ event


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 # Example of symbolic vector:
 lowerCAmelCase_      :  Union[str, Any]				     =  transform(2997_9245)
 print('Example of four vector: ')
 print(f"ct' = {four_vector[0]}")
 print(f"x' = {four_vector[1]}")
 print(f"y' = {four_vector[2]}")
 print(f"z' = {four_vector[3]}")

 # Substitute symbols with numerical values
 lowerCAmelCase_      :  Tuple				     =  {ct: c, x: 1, y: 1, z: 1}
 lowerCAmelCase_      :  Optional[int]				     =  [four_vector[i].subs(sub_dict) for i in range(4)]

 print(f"\n{numerical_vector}")
