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

  """simple docstring"""
  SCREAMING_SNAKE_CASE__         =      TextToVideoSDPipeline
  SCREAMING_SNAKE_CASE__         =      TEXT_TO_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE__         =      TEXT_TO_IMAGE_BATCH_PARAMS
  # No `output_type`.
  SCREAMING_SNAKE_CASE__         =      frozenset(
      [
          """num_inference_steps""",
          """generator""",
          """latents""",
          """return_dict""",
          """callback""",
          """callback_steps""",
      ]			)







  def 	UpperCAmelCase_ (self						):
       torch.manual_seed(0						)
       UpperCamelCase__				=    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__				=    DDIMScheduler(
           beta_start=0.0_0085	,      beta_end=0.012	,      beta_schedule="""scaled_linear"""	,      clip_sample=SCREAMING_SNAKE_CASE_	,      set_alpha_to_one=SCREAMING_SNAKE_CASE_	,      )
       torch.manual_seed(0						)
       UpperCamelCase__				=    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						)
       UpperCamelCase__				=    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	,      )
       UpperCamelCase__				=    CLIPTextModel(SCREAMING_SNAKE_CASE_						)
       UpperCamelCase__				=    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

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







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

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

       assert frames[0].shape == (64, 64, 3)
       UpperCamelCase__				=    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						):
       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 	UpperCAmelCase_ (self						):
       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 	UpperCAmelCase_ (self						):
       pass







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







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







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






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

  """simple docstring"""







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

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

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

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

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







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

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

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

       UpperCamelCase__				=    pipe(SCREAMING_SNAKE_CASE_	,      generator=SCREAMING_SNAKE_CASE_	,      num_inference_steps=2	,      output_type="""pt"""						).frames
       UpperCamelCase__				=    video_frames.cpu().numpy()

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







from __future__ import annotations






def 						__magic_name__			(   __a      :	list[list[int]]						):



     '''simple docstring'''




     for i in range(1	,		len(matrix[0]						)						):
          matrix[0][i] += matrix[0][i - 1]

     # preprocessing the first column
     for i in range(1	,		len(__a						)						):
          matrix[i][0] += matrix[i - 1][0]

     # updating the path cost for current position
     for i in range(1	,		len(__a						)						):
          for j in range(1	,		len(matrix[0]						)						):
               matrix[i][j] += min(matrix[i - 1][j]	,		matrix[i][j - 1]						)

     return matrix[-1][-1]


if __name__ == "__main__":
    import doctest

    doctest.testmod()





