




'''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  __lowercase    (	__magic_name__							,				unittest.TestCase			):
   _a    						=   TextToVideoSDPipeline
   _a    						=   TEXT_TO_IMAGE_PARAMS
   _a    						=   TEXT_TO_IMAGE_BATCH_PARAMS
   # No `output_type`.
   _a    						=   frozenset(
       [
           """num_inference_steps""",
           """generator""",
           """latents""",
           """return_dict""",
           """callback""",
           """callback_steps""",
       ]			)







   def 		UpperCamelCase__      (						self   )					->     int:
     torch.manual_seed(0   )
     __a								=       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   ,				)
     __a								=       DDIMScheduler(
         beta_start=0.00_085   ,				beta_end=0.012   ,				beta_schedule='scaled_linear'   ,				clip_sample=UpperCamelCase   ,				set_alpha_to_one=UpperCamelCase   ,				)
     torch.manual_seed(0   )
     __a								=       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   )
     __a								=       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   ,				)
     __a								=       CLIPTextModel(UpperCamelCase   )
     __a								=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

     __a								=       {
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
     }
     return components







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase=0   )					->     str:
     if str(UpperCamelCase   ).startswith('mps'   ):
       __a								=       torch.manual_seed(UpperCamelCase   )
     else:
       __a								=       torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )
     __a								=       {
         '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   )					->     List[Any]:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components()
     __a								=       TextToVideoSDPipeline(**UpperCamelCase   )
     __a								=       sd_pipe.to(UpperCamelCase   )
     sd_pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     __a								=       'np'
     __a								=       sd_pipe(**UpperCamelCase   ).frames
     __a								=       frames[0][-3:, -3:, -1]

     assert frames[0].shape == (64, 64, 3)
     __a								=       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   )					->     str:
     self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCamelCase   ,				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   )					->     List[Any]:
     self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCamelCase   ,				expected_max_diff=1e-2   )







   @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'   )
   def 		UpperCamelCase__      (						self   )					->     str:
     pass







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







   @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'   )
   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     pass







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     return super().test_progress_bar()





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







   def 		UpperCamelCase__      (						self   )					->     int:
     __a								=       load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'   )

     __a								=       TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'   )
     __a								=       DPMSolverMultistepScheduler.from_config(pipe.scheduler.config   )
     __a								=       pipe.to('cuda'   )

     __a								=       'Spiderman is surfing'
     __a								=       torch.Generator(device='cpu'   ).manual_seed(0   )

     __a								=       pipe(UpperCamelCase   ,				generator=UpperCamelCase   ,				num_inference_steps=25   ,				output_type='pt'   ).frames
     __a								=       video_frames.cpu().numpy()

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







   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'   )

     __a								=       TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'   )
     __a								=       pipe.to('cuda'   )

     __a								=       'Spiderman is surfing'
     __a								=       torch.Generator(device='cpu'   ).manual_seed(0   )

     __a								=       pipe(UpperCamelCase   ,				generator=UpperCamelCase   ,				num_inference_steps=2   ,				output_type='pt'   ).frames
     __a								=       video_frames.cpu().numpy()

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









'''simple docstring'''


from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_					=   {
    "configuration_trajectory_transformer": [
        "TRAJECTORY_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "TrajectoryTransformerConfig",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_					=   [
      "TRAJECTORY_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TrajectoryTransformerModel",
      "TrajectoryTransformerPreTrainedModel",
      "load_tf_weights_in_trajectory_transformer",
  ]


if TYPE_CHECKING:
  from .configuration_trajectory_transformer import (
      TRAJECTORY_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      TrajectoryTransformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_trajectory_transformer import (
        TRAJECTORY_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        TrajectoryTransformerModel,
        TrajectoryTransformerPreTrainedModel,
        load_tf_weights_in_trajectory_transformer,
    )


else:
  import sys

  UpperCAmelCase_					=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



