



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







							'''simple docstring'''






							UpperCamelCase__				:      Any         =					TextToVideoSDPipeline
							UpperCamelCase__				:      Optional[int]         =					TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__				:      Union[str, Any]         =					TEXT_TO_IMAGE_BATCH_PARAMS
							# No `output_type`.
							UpperCamelCase__				:      Union[str, Any]         =					frozenset(
							    [
							        """num_inference_steps""",
							        """generator""",
							        """latents""",
							        """return_dict""",
							        """callback""",
							        """callback_steps""",
							    ])


							def _a      (							self		):
											torch.manual_seed(0		)
											a__				      =		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  ,  )
											a__				      =		DDIMScheduler(
											    beta_start=0.00_085  ,  beta_end=0.012  ,  beta_schedule="""scaled_linear"""  ,  clip_sample=a_  ,  set_alpha_to_one=a_  ,  )
											torch.manual_seed(0		)
											a__				      =		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		)
											a__				      =		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=1_000  ,  hidden_act="""gelu"""  ,  projection_dim=512  ,  )
											a__				      =		CLIPTextModel(a_		)
											a__				      =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""		)

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


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

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

											assert frames[0].shape == (64, 64, 3)
											a__				      =		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 _a      (							self		):
											self._test_attention_slicing_forward_pass(test_mean_pixel_difference=a_  ,  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=a_  ,  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  __snake_case      (   unittest.TestCase):







							'''simple docstring'''






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

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

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

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

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







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

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

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

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

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






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase							 =					{
    """configuration_xlm_roberta""": [
        """XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaConfig""",
        """XLMRobertaOnnxConfig""",
    ],
}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase							 =					["""XLMRobertaTokenizer"""]

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase							 =					["""XLMRobertaTokenizerFast"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase							 =					[
	    """XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """XLMRobertaForCausalLM""",
	    """XLMRobertaForMaskedLM""",
	    """XLMRobertaForMultipleChoice""",
	    """XLMRobertaForQuestionAnswering""",
	    """XLMRobertaForSequenceClassification""",
	    """XLMRobertaForTokenClassification""",
	    """XLMRobertaModel""",
	    """XLMRobertaPreTrainedModel""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase							 =					[
	    """TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """TFXLMRobertaForCausalLM""",
	    """TFXLMRobertaForMaskedLM""",
	    """TFXLMRobertaForMultipleChoice""",
	    """TFXLMRobertaForQuestionAnswering""",
	    """TFXLMRobertaForSequenceClassification""",
	    """TFXLMRobertaForTokenClassification""",
	    """TFXLMRobertaModel""",
	    """TFXLMRobertaPreTrainedModel""",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase							 =					[
	    """FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """FlaxXLMRobertaForMaskedLM""",
	    """FlaxXLMRobertaForCausalLM""",
	    """FlaxXLMRobertaForMultipleChoice""",
	    """FlaxXLMRobertaForQuestionAnswering""",
	    """FlaxXLMRobertaForSequenceClassification""",
	    """FlaxXLMRobertaForTokenClassification""",
	    """FlaxXLMRobertaModel""",
	    """FlaxXLMRobertaPreTrainedModel""",
	]

if TYPE_CHECKING:
	from .configuration_xlm_roberta import (
	    XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    XLMRobertaConfig,
	    XLMRobertaOnnxConfig,
	)

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlm_roberta import XLMRobertaTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_xlm_roberta import (
		    XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XLMRobertaForCausalLM,
		    XLMRobertaForMaskedLM,
		    XLMRobertaForMultipleChoice,
		    XLMRobertaForQuestionAnswering,
		    XLMRobertaForSequenceClassification,
		    XLMRobertaForTokenClassification,
		    XLMRobertaModel,
		    XLMRobertaPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_xlm_roberta import (
		    TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFXLMRobertaForCausalLM,
		    TFXLMRobertaForMaskedLM,
		    TFXLMRobertaForMultipleChoice,
		    TFXLMRobertaForQuestionAnswering,
		    TFXLMRobertaForSequenceClassification,
		    TFXLMRobertaForTokenClassification,
		    TFXLMRobertaModel,
		    TFXLMRobertaPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_xlm_roberta import (
		    FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
		    FlaxXLMRobertaForCausalLM,
		    FlaxXLMRobertaForMaskedLM,
		    FlaxXLMRobertaForMultipleChoice,
		    FlaxXLMRobertaForQuestionAnswering,
		    FlaxXLMRobertaForSequenceClassification,
		    FlaxXLMRobertaForTokenClassification,
		    FlaxXLMRobertaModel,
		    FlaxXLMRobertaPreTrainedModel,
		)

else:
	import sys

	UpperCAmelCase							 =					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

