

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    (				_lowercase    ,							unittest.TestCase							):


  """simple docstring"""




  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 		A__					(				self):
   torch.manual_seed(0)
   _UpperCamelCase   :		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	,       )
   _UpperCamelCase   :		List[str]			=						DDIMScheduler(
       beta_start=0.0_0_0_8_5	,       beta_end=0.0_1_2	,       beta_schedule='scaled_linear'	,       clip_sample=__snake_case	,       set_alpha_to_one=__snake_case	,       )
   torch.manual_seed(0)
   _UpperCamelCase   :		Dict			=						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   :		Dict			=						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   :		Any			=						CLIPTextModel(__snake_case)
   _UpperCamelCase   :		List[Any]			=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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


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

   _UpperCamelCase   :		Any			=						self.get_dummy_inputs(__snake_case)
   _UpperCamelCase   :		Dict			=						'np'
   _UpperCamelCase   :		List[Any]			=						sd_pipe(**__snake_case).frames
   _UpperCamelCase   :		Any			=						frames[0][-3:, -3:, -1]

   assert frames[0].shape == (64, 64, 3)
   _UpperCamelCase   :		Dict			=						np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0])

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


  def 		A__					(				self):
   self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__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 		A__					(				self):
   self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__snake_case	,       expected_max_diff=1e-2)


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


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


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






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







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


  """simple docstring"""




  def 		A__					(				self):
   _UpperCamelCase   :		List[Any]			=						load_numpy(
       'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy')

   _UpperCamelCase   :		Any			=						TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
   _UpperCamelCase   :		Tuple			=						DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
   _UpperCamelCase   :		Optional[int]			=						pipe.to('cuda')

   _UpperCamelCase   :		List[str]			=						'Spiderman is surfing'
   _UpperCamelCase   :		str			=						torch.Generator(device='cpu').manual_seed(0)

   _UpperCamelCase   :		Any			=						pipe(__snake_case	,       generator=__snake_case	,       num_inference_steps=25	,       output_type='pt').frames
   _UpperCamelCase   :		Union[str, Any]			=						video_frames.cpu().numpy()

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






  def 		A__					(				self):
   _UpperCamelCase   :		List[Any]			=						load_numpy(
       'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy')

   _UpperCamelCase   :		List[str]			=						TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b')
   _UpperCamelCase   :		List[str]			=						pipe.to('cuda')

   _UpperCamelCase   :		List[Any]			=						'Spiderman is surfing'
   _UpperCamelCase   :		Tuple			=						torch.Generator(device='cpu').manual_seed(0)

   _UpperCamelCase   :		int			=						pipe(__snake_case	,       generator=__snake_case	,       num_inference_steps=2	,       output_type='pt').frames
   _UpperCamelCase   :		int			=						video_frames.cpu().numpy()

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







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase__								=		logging.get_logger(__name__)

lowerCAmelCase__								=		{
    """bert-base-uncased""": """https://huggingface.co/bert-base-uncased/resolve/main/config.json""",
    """bert-large-uncased""": """https://huggingface.co/bert-large-uncased/resolve/main/config.json""",
    """bert-base-cased""": """https://huggingface.co/bert-base-cased/resolve/main/config.json""",
    """bert-large-cased""": """https://huggingface.co/bert-large-cased/resolve/main/config.json""",
    """bert-base-multilingual-uncased""": """https://huggingface.co/bert-base-multilingual-uncased/resolve/main/config.json""",
    """bert-base-multilingual-cased""": """https://huggingface.co/bert-base-multilingual-cased/resolve/main/config.json""",
    """bert-base-chinese""": """https://huggingface.co/bert-base-chinese/resolve/main/config.json""",
    """bert-base-german-cased""": """https://huggingface.co/bert-base-german-cased/resolve/main/config.json""",
    """bert-large-uncased-whole-word-masking""": (
        """https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/config.json"""
    ),
    """bert-large-cased-whole-word-masking""": (
        """https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/config.json"""
    ),
    """bert-large-uncased-whole-word-masking-finetuned-squad""": (
        """https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/config.json"""
    ),
    """bert-large-cased-whole-word-masking-finetuned-squad""": (
        """https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/config.json"""
    ),
    """bert-base-cased-finetuned-mrpc""": """https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/config.json""",
    """bert-base-german-dbmdz-cased""": """https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/config.json""",
    """bert-base-german-dbmdz-uncased""": """https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/config.json""",
    """cl-tohoku/bert-base-japanese""": """https://huggingface.co/cl-tohoku/bert-base-japanese/resolve/main/config.json""",
    """cl-tohoku/bert-base-japanese-whole-word-masking""": (
        """https://huggingface.co/cl-tohoku/bert-base-japanese-whole-word-masking/resolve/main/config.json"""
    ),
    """cl-tohoku/bert-base-japanese-char""": (
        """https://huggingface.co/cl-tohoku/bert-base-japanese-char/resolve/main/config.json"""
    ),
    """cl-tohoku/bert-base-japanese-char-whole-word-masking""": (
        """https://huggingface.co/cl-tohoku/bert-base-japanese-char-whole-word-masking/resolve/main/config.json"""
    ),
    """TurkuNLP/bert-base-finnish-cased-v1""": (
        """https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/config.json"""
    ),
    """TurkuNLP/bert-base-finnish-uncased-v1""": (
        """https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/config.json"""
    ),
    """wietsedv/bert-base-dutch-cased""": """https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/config.json""",
    # See all BERT models at https://huggingface.co/models?filter=bert
}







class 	lowercase    (				_lowercase							):


		"""simple docstring"""




		a__					       =  "bert"


		def __init__(				self	,       __snake_case=3_05_22	,       __snake_case=7_68	,       __snake_case=12	,       __snake_case=12	,       __snake_case=30_72	,       __snake_case="gelu"	,       __snake_case=0.1	,       __snake_case=0.1	,       __snake_case=5_12	,       __snake_case=2	,       __snake_case=0.0_2	,       __snake_case=1e-12	,       __snake_case=0	,       __snake_case="absolute"	,       __snake_case=True	,       __snake_case=None	,       **__snake_case	,       ):
			super().__init__(pad_token_id=__snake_case	,       **__snake_case)

			_UpperCamelCase   :		int			=						vocab_size
			_UpperCamelCase   :		Optional[Any]			=						hidden_size
			_UpperCamelCase   :		Optional[Any]			=						num_hidden_layers
			_UpperCamelCase   :		List[str]			=						num_attention_heads
			_UpperCamelCase   :		int			=						hidden_act
			_UpperCamelCase   :		Optional[Any]			=						intermediate_size
			_UpperCamelCase   :		Union[str, Any]			=						hidden_dropout_prob
			_UpperCamelCase   :		Tuple			=						attention_probs_dropout_prob
			_UpperCamelCase   :		Optional[int]			=						max_position_embeddings
			_UpperCamelCase   :		str			=						type_vocab_size
			_UpperCamelCase   :		Optional[Any]			=						initializer_range
			_UpperCamelCase   :		List[str]			=						layer_norm_eps
			_UpperCamelCase   :		Any			=						position_embedding_type
			_UpperCamelCase   :		Any			=						use_cache
			_UpperCamelCase   :		Any			=						classifier_dropout







class 	lowercase    (				_lowercase							):


		"""simple docstring"""




		@property
		def 		A__					(				self):
			if self.task == "multiple-choice":
				_UpperCamelCase   :		Union[str, Any]			=						{0: 'batch', 1: 'choice', 2: 'sequence'}
			else:
				_UpperCamelCase   :		Optional[Any]			=						{0: 'batch', 1: 'sequence'}
			return OrderedDict(
			    [
			        ('input_ids', dynamic_axis),
			        ('attention_mask', dynamic_axis),
			        ('token_type_ids', dynamic_axis),
			    ])




