

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_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.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







import logging

from transformers.configuration_utils import PretrainedConfig


lowerCAmelCase__								=		logging.getLogger(__name__)







class 	lowercase    (				_lowercase							):


		"""simple docstring"""




		a__					       =  "masked_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="topK"	,       __snake_case="constant"	,       __snake_case=0.0	,       **__snake_case	,       ):
			super().__init__(pad_token_id=__snake_case	,       **__snake_case)

			_UpperCamelCase   :		List[Any]			=						vocab_size
			_UpperCamelCase   :		Union[str, Any]			=						hidden_size
			_UpperCamelCase   :		Optional[int]			=						num_hidden_layers
			_UpperCamelCase   :		Any			=						num_attention_heads
			_UpperCamelCase   :		int			=						hidden_act
			_UpperCamelCase   :		str			=						intermediate_size
			_UpperCamelCase   :		str			=						hidden_dropout_prob
			_UpperCamelCase   :		Any			=						attention_probs_dropout_prob
			_UpperCamelCase   :		Tuple			=						max_position_embeddings
			_UpperCamelCase   :		Dict			=						type_vocab_size
			_UpperCamelCase   :		str			=						initializer_range
			_UpperCamelCase   :		List[Any]			=						layer_norm_eps
			_UpperCamelCase   :		Tuple			=						pruning_method
			_UpperCamelCase   :		Tuple			=						mask_init
			_UpperCamelCase   :		Dict			=						mask_scale




