




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






     def 							_lowercase      (					self       )				->     Optional[Any]:
          torch.manual_seed(0       )
          _snake_case				= 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				= DDIMScheduler(
              beta_start=0.0_0_0_8_5   ,beta_end=0.0_1_2   ,beta_schedule="scaled_linear"   ,clip_sample=_SCREAMING_SNAKE_CASE   ,set_alpha_to_one=_SCREAMING_SNAKE_CASE   ,)
          torch.manual_seed(0       )
          _snake_case				= 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       )
          _snake_case				= 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   ,)
          _snake_case				= CLIPTextModel(_SCREAMING_SNAKE_CASE       )
          _snake_case				= CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

          _snake_case				= {
              "unet": unet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
          }
          return components






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

          _snake_case				= self.get_dummy_inputs(_SCREAMING_SNAKE_CASE       )
          _snake_case				= "np"
          _snake_case				= sd_pipe(**_SCREAMING_SNAKE_CASE       ).frames
          _snake_case				= frames[0][-3:, -3:, -1]

          assert frames[0].shape == (64, 64, 3)
          _snake_case				= np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0]       )

          assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2






     def 							_lowercase      (					self       )				->     Tuple:
          self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_SCREAMING_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 							_lowercase      (					self       )				->     Optional[int]:
          self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_SCREAMING_SNAKE_CASE   ,expected_max_diff=1e-2       )






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






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






     @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."       )
     def 							_lowercase      (					self       )				->     Optional[int]:
          pass






     def 							_lowercase      (					self       )				->     Optional[Any]:
          return super().test_progress_bar()







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






     def 							_lowercase      (					self       )				->     Tuple:
          _snake_case				= load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"       )

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

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

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

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






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

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

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

          _snake_case				= pipe(_SCREAMING_SNAKE_CASE   ,generator=_SCREAMING_SNAKE_CASE   ,num_inference_steps=2   ,output_type="pt"       ).frames
          _snake_case				= 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_		:     List[Any]          =		{
    '''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
    '''processing_git''': ['''GitProcessor'''],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCamelCase_		:     Optional[Any]          =		[
       '''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''GitForCausalLM''',
       '''GitModel''',
       '''GitPreTrainedModel''',
       '''GitVisionModel''',
   ]

if TYPE_CHECKING:
   from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
   from .processing_git import GitProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_git import (
          GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
          GitForCausalLM,
          GitModel,
          GitPreTrainedModel,
          GitVisionModel,
      )

else:
   import sys

   UpperCamelCase_		:     List[Any]          =		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


