"""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   ):
    _snake_case     :  int     							=							TextToVideoSDPipeline
    _snake_case     :  Dict     							=							TEXT_TO_IMAGE_PARAMS
    _snake_case     :  Tuple     							=							TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    _snake_case     :  Dict     							=							frozenset(
        [
            'num_inference_steps',
            'generator',
            'latents',
            'return_dict',
            'callback',
            'callback_steps',
        ]   )


    def      lowerCAmelCase_  (					self	:  List[str]					):
      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.00_085   ,				beta_end=0.012   ,				beta_schedule="""scaled_linear"""   ,				clip_sample=__lowerCAmelCase   ,				set_alpha_to_one=__lowerCAmelCase   ,				)
      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=128   ,				)
      torch.manual_seed(0					)
      _UpperCAmelCase						 =      CLIPTextConfig(
          bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=32   ,				intermediate_size=37   ,				layer_norm_eps=1e-0_5   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1000   ,				hidden_act="""gelu"""   ,				projection_dim=512   ,				)
      _UpperCAmelCase						 =      CLIPTextModel(__lowerCAmelCase					)
      _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      lowerCAmelCase_  (					self	:  Tuple   ,				__lowerCAmelCase	:  Dict   ,				__lowerCAmelCase	:  Any=0					):
      if str(__lowerCAmelCase					).startswith("""mps"""					):
        _UpperCAmelCase						 =      torch.manual_seed(__lowerCAmelCase					)
      else:
        _UpperCAmelCase						 =      torch.Generator(device=__lowerCAmelCase					).manual_seed(__lowerCAmelCase					)
      _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      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      """cpu"""  # ensure determinism for the device-dependent torch.Generator
      _UpperCAmelCase						 =      self.get_dummy_components()
      _UpperCAmelCase						 =      TextToVideoSDPipeline(**__lowerCAmelCase					)
      _UpperCAmelCase						 =      sd_pipe.to(__lowerCAmelCase					)
      sd_pipe.set_progress_bar_config(disable=__lowerCAmelCase					)

      _UpperCAmelCase						 =      self.get_dummy_inputs(__lowerCAmelCase					)
      _UpperCAmelCase						 =      """np"""
      _UpperCAmelCase						 =      sd_pipe(**__lowerCAmelCase					).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      lowerCAmelCase_  (					self	:  Tuple					):
      self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowerCAmelCase   ,				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	:  Optional[int]					):
      self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowerCAmelCase   ,				expected_max_diff=1e-2					)


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


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


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


    def      lowerCAmelCase_  (					self	:  List[str]					):
      return super().test_progress_bar()



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


    def      lowerCAmelCase_  (					self	:  int					):
      _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(__lowerCAmelCase   ,				generator=__lowerCAmelCase   ,				num_inference_steps=25   ,				output_type="""pt"""					).frames
      _UpperCAmelCase						 =      video_frames.cpu().numpy()

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


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _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(__lowerCAmelCase   ,				generator=__lowerCAmelCase   ,				num_inference_steps=2   ,				output_type="""pt"""					).frames
      _UpperCAmelCase						 =      video_frames.cpu().numpy()

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

"""simple docstring"""


import datasets


UpperCAmelCase__  		=						"""\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

UpperCAmelCase__  		=						"""\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

UpperCAmelCase__  		=						"""
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""






def     __UpperCAmelCase					(			lowercase   ,lowercase		):







  """simple docstring"""
  return (preds == labels).mean()


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	,							_KWARGS_DESCRIPTION   )
class        a				(		datasets.Metric   ):


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      return datasets.MetricInfo(
          description=_DESCRIPTION   ,				citation=_CITATION   ,				inputs_description=_KWARGS_DESCRIPTION   ,				features=datasets.Features(
              {
                  """predictions""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32"""					),
                  """references""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32"""					),
              }					)   ,				codebase_urls=[]   ,				reference_urls=[]   ,				format="""numpy"""   ,				)


    def      lowerCAmelCase_  (					self	:  List[str]   ,				__lowerCAmelCase	:  int   ,				__lowerCAmelCase	:  Any					):
      return {"accuracy": simple_accuracy(__lowerCAmelCase   ,				__lowerCAmelCase					)}
