






import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
					    MODEL_MAPPING,
					    LevitForImageClassification,
					    LevitForImageClassificationWithTeacher,
					    LevitModel,
					)
					from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import LevitImageProcessor


class       __SCREAMING_SNAKE_CASE   (				__lowercase):






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.config_class(**self.inputs_dict				)
												self.parent.assertTrue(hasattr(_UpperCamelCase       ,  'hidden_sizes'				)				)
												self.parent.assertTrue(hasattr(_UpperCamelCase       ,  'num_attention_heads'				)				)




class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=13       ,  _UpperCamelCase=64       ,  _UpperCamelCase=3       ,  _UpperCamelCase=3       ,  _UpperCamelCase=2       ,  _UpperCamelCase=1       ,  _UpperCamelCase=16       ,  _UpperCamelCase=[1_28, 2_56, 3_84]       ,  _UpperCamelCase=[4, 6, 8]       ,  _UpperCamelCase=[2, 3, 4]       ,  _UpperCamelCase=[16, 16, 16]       ,  _UpperCamelCase=0       ,  _UpperCamelCase=[2, 2, 2]       ,  _UpperCamelCase=[2, 2, 2]       ,  _UpperCamelCase=0.02       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=2       ,  ):






												"""simple docstring"""
												lowerCAmelCase__        =  parent
												lowerCAmelCase__        =  batch_size
												lowerCAmelCase__        =  image_size
												lowerCAmelCase__        =  num_channels
												lowerCAmelCase__        =  kernel_size
												lowerCAmelCase__        =  stride
												lowerCAmelCase__        =  padding
												lowerCAmelCase__        =  hidden_sizes
												lowerCAmelCase__        =  num_attention_heads
												lowerCAmelCase__        =  depths
												lowerCAmelCase__        =  key_dim
												lowerCAmelCase__        =  drop_path_rate
												lowerCAmelCase__        =  patch_size
												lowerCAmelCase__        =  attention_ratio
												lowerCAmelCase__        =  mlp_ratio
												lowerCAmelCase__        =  initializer_range
												lowerCAmelCase__        =  [
												    ['Subsample', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
												    ['Subsample', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
												]
												lowerCAmelCase__        =  is_training
												lowerCAmelCase__        =  use_labels
												lowerCAmelCase__        =  num_labels
												lowerCAmelCase__        =  initializer_range






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

												lowerCAmelCase__        =  None
												if self.use_labels:
																		lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.num_labels				)

												lowerCAmelCase__        =  self.get_config()
												return config, pixel_values, labels






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return LevitConfig(
												    image_size=self.image_size       ,  num_channels=self.num_channels       ,  kernel_size=self.kernel_size       ,  stride=self.stride       ,  padding=self.padding       ,  patch_size=self.patch_size       ,  hidden_sizes=self.hidden_sizes       ,  num_attention_heads=self.num_attention_heads       ,  depths=self.depths       ,  key_dim=self.key_dim       ,  drop_path_rate=self.drop_path_rate       ,  mlp_ratio=self.mlp_ratio       ,  attention_ratio=self.attention_ratio       ,  initializer_range=self.initializer_range       ,  down_ops=self.down_ops       ,  )






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  LevitModel(config=_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()
												lowerCAmelCase__        =  model(_UpperCamelCase				)
												lowerCAmelCase__        =  (self.image_size, self.image_size)
												lowerCAmelCase__  ,    lowerCAmelCase__        =  image_size[0], image_size[1]
												for _ in range(4				):
																		lowerCAmelCase__        =  floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1				)
																		lowerCAmelCase__        =  floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1				)
												self.parent.assertEqual(
												    result.last_hidden_state.shape       ,  (self.batch_size, ceil(height / 4				) * ceil(width / 4				), self.hidden_sizes[-1])       ,  )






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.num_labels
												lowerCAmelCase__        =  LevitForImageClassification(_UpperCamelCase				)
												model.to(_UpperCamelCase				)
												model.eval()
												lowerCAmelCase__        =  model(_UpperCamelCase       ,  labels=_UpperCamelCase				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels)				)







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.prepare_config_and_inputs()
												lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__        =  config_and_inputs
												lowerCAmelCase__        =  {'pixel_values': pixel_values}
												return config, inputs_dict




@require_torch
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   __lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    Any						=   (
						    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
						    if is_torch_available()
						    else ()
						)
						_SCREAMING_SNAKE_CASE		:    str						=   (
						    {
						        '''feature-extraction''': LevitModel,
						        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
						    }
						    if is_torch_available()
						    else {}
						)

						_SCREAMING_SNAKE_CASE		:    Optional[Any]						=   False
						_SCREAMING_SNAKE_CASE		:    List[str]						=   False
						_SCREAMING_SNAKE_CASE		:    str						=   False
						_SCREAMING_SNAKE_CASE		:    Union[str, Any]						=   False
						_SCREAMING_SNAKE_CASE		:    int						=   False






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  LevitModelTester(self				)
												lowerCAmelCase__        =  ConfigTester(self       ,  config_class=_UpperCamelCase       ,  has_text_modality=_UpperCamelCase       ,  hidden_size=37				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return






						@unittest.skip(reason='Levit does not use inputs_embeds'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						@unittest.skip(reason='Levit does not support input and output embeddings'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						@unittest.skip(reason='Levit does not output attentions'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__        =  model_class(_UpperCamelCase				)
																		lowerCAmelCase__        =  inspect.signature(model.forward				)
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		lowerCAmelCase__        =  [*signature.parameters.keys()]

																		lowerCAmelCase__        =  ['pixel_values']
																		self.assertListEqual(arg_names[:1]       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												def check_hidden_states_output(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):
																		lowerCAmelCase__        =  model_class(_UpperCamelCase				)
																		model.to(_UpperCamelCase				)
																		model.eval()

																		with torch.no_grad():
																								lowerCAmelCase__        =  model(**self._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase				)				)

																		lowerCAmelCase__        =  outputs.hidden_states

																		lowerCAmelCase__        =  len(self.model_tester.depths				) + 1
																		self.assertEqual(len(_UpperCamelCase				)       ,  _UpperCamelCase				)

																		lowerCAmelCase__        =  (self.model_tester.image_size, self.model_tester.image_size)
																		lowerCAmelCase__  ,    lowerCAmelCase__        =  image_size[0], image_size[1]
																		for _ in range(4				):
																								lowerCAmelCase__        =  floor(
																								    (
																								        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																								        / self.model_tester.stride
																								    )
																								    + 1				)
																								lowerCAmelCase__        =  floor(
																								    (
																								        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																								        / self.model_tester.stride
																								    )
																								    + 1				)
																		# verify the first hidden states (first block)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:]				)       ,  [
																		        height * width,
																		        self.model_tester.hidden_sizes[0],
																		    ]       ,  )

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__        =  True
																		check_hidden_states_output(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		lowerCAmelCase__        =  True

																		check_hidden_states_output(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				)






						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase=False				):






												"""simple docstring"""
												lowerCAmelCase__        =  super()._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase       ,  return_labels=_UpperCamelCase				)

												if return_labels:
																		if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																								del inputs_dict["labels"]

												return inputs_dict






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if not self.model_tester.is_training:
																		return

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs_for_common()
												lowerCAmelCase__        =  True

												for model_class in self.all_model_classes:
																		# LevitForImageClassificationWithTeacher supports inference-only
																		if (
																		    model_class in get_values(_UpperCamelCase				)
																		    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																		):
																								continue
																		lowerCAmelCase__        =  model_class(_UpperCamelCase				)
																		model.to(_UpperCamelCase				)
																		model.train()
																		lowerCAmelCase__        =  self._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase       ,  return_labels=_UpperCamelCase				)
																		lowerCAmelCase__        =  model(**_UpperCamelCase				).loss
																		loss.backward()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs_for_common()
												if not self.model_tester.is_training:
																		return

												lowerCAmelCase__        =  False
												lowerCAmelCase__        =  True

												for model_class in self.all_model_classes:
																		if model_class in get_values(_UpperCamelCase				) or not model_class.supports_gradient_checkpointing:
																								continue
																		# LevitForImageClassificationWithTeacher supports inference-only
																		if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																								continue
																		lowerCAmelCase__        =  model_class(_UpperCamelCase				)
																		model.gradient_checkpointing_enable()
																		model.to(_UpperCamelCase				)
																		model.train()
																		lowerCAmelCase__        =  self._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase       ,  return_labels=_UpperCamelCase				)
																		lowerCAmelCase__        =  model(**_UpperCamelCase				).loss
																		loss.backward()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs_for_common()

												lowerCAmelCase__        =  [
												    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
												    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
												    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
												]

												for model_class in self.all_model_classes:
																		if (
																		    model_class
																		    not in [
																		        *get_values(_UpperCamelCase				),
																		    ]
																		    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																		):
																								continue

																		for problem_type in problem_types:
																								with self.subTest(msg=F"Testing {model_class} with {problem_type['title']}"				):
																														lowerCAmelCase__        =  problem_type['title']
																														lowerCAmelCase__        =  problem_type['num_labels']

																														lowerCAmelCase__        =  model_class(_UpperCamelCase				)
																														model.to(_UpperCamelCase				)
																														model.train()

																														lowerCAmelCase__        =  self._prepare_for_class(_UpperCamelCase       ,  _UpperCamelCase       ,  return_labels=_UpperCamelCase				)

																														if problem_type["num_labels"] > 1:
																																				lowerCAmelCase__        =  inputs['labels'].unsqueeze(1				).repeat(1       ,  problem_type['num_labels']				)

																														lowerCAmelCase__        =  inputs['labels'].to(problem_type['dtype']				)

																														# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																														# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																														# they have the same size." which is a symptom something in wrong for the regression problem.
																														# See https://github.com/huggingface/transformers/issues/11780
																														with warnings.catch_warnings(record=_UpperCamelCase				) as warning_list:
																																				lowerCAmelCase__        =  model(**_UpperCamelCase				).loss
																														for w in warning_list:
																																				if "Using a target size that is different to the input size" in str(w.message				):
																																										raise ValueError(
																																										    F"Something is going wrong in the regression problem: intercepted {w.message}"				)

																														loss.backward()







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__        =  LevitModel.from_pretrained(_UpperCamelCase				)
																		self.assertIsNotNone(_UpperCamelCase				)







def 		_UpperCamelCase				(      )					->				Dict:

						"""simple docstring"""



						lowerCAmelCase__        =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
						return image


@require_torch
@require_vision
class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						@cached_property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]				).to(
												    _UpperCamelCase				)

												lowerCAmelCase__        =  self.default_image_processor
												lowerCAmelCase__        =  prepare_img()
												lowerCAmelCase__        =  image_processor(images=_UpperCamelCase       ,  return_tensors='pt'				).to(_UpperCamelCase				)

												# forward pass
												with torch.no_grad():
																		lowerCAmelCase__        =  model(**_UpperCamelCase				)

												# verify the logits
												lowerCAmelCase__        =  torch.Size((1, 10_00)				)
												self.assertEqual(outputs.logits.shape       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.tensor([1.04_48, -0.37_45, -1.83_17]				).to(_UpperCamelCase				)

												self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,  _UpperCamelCase       ,  atol=1E-4				)				)













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






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												torch.manual_seed(0				)
												lowerCAmelCase__        =  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       ,  )
												lowerCAmelCase__        =  DDIMScheduler(
												    beta_start=0.0_00_85       ,  beta_end=0.0_12       ,  beta_schedule='scaled_linear'       ,  clip_sample=_UpperCamelCase       ,  set_alpha_to_one=_UpperCamelCase       ,  )
												torch.manual_seed(0				)
												lowerCAmelCase__        =  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				)
												lowerCAmelCase__        =  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       ,  )
												lowerCAmelCase__        =  CLIPTextModel(_UpperCamelCase				)
												lowerCAmelCase__        =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

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






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase=0				):






												"""simple docstring"""
												if str(_UpperCamelCase				).startswith('mps'				):
																		lowerCAmelCase__        =  torch.manual_seed(_UpperCamelCase				)
												else:
																		lowerCAmelCase__        =  torch.Generator(device=_UpperCamelCase				).manual_seed(_UpperCamelCase				)
												lowerCAmelCase__        =  {
												    '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				):






												"""simple docstring"""
												lowerCAmelCase__        =  'cpu'  # ensure determinism for the device-dependent torch.Generator
												lowerCAmelCase__        =  self.get_dummy_components()
												lowerCAmelCase__        =  TextToVideoSDPipeline(**_UpperCamelCase				)
												lowerCAmelCase__        =  sd_pipe.to(_UpperCamelCase				)
												sd_pipe.set_progress_bar_config(disable=_UpperCamelCase				)

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

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






												"""simple docstring"""
												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				):






												"""simple docstring"""
												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				):






												"""simple docstring"""
												pass






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






												"""simple docstring"""
												pass






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






												"""simple docstring"""
												pass







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return super().test_progress_bar()




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






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  load_numpy(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'				)

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

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

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

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







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  load_numpy(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'				)

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

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

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

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





