



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    (							SCREAMING_SNAKE_CASE_      ,    unittest.TestCase):
						'''simple docstring'''


						UpperCAmelCase			:		List[str]		=		TextToVideoSDPipeline
						UpperCAmelCase			:		Dict		=		TEXT_TO_IMAGE_PARAMS
						UpperCAmelCase			:		List[Any]		=		TEXT_TO_IMAGE_BATCH_PARAMS
						# No `output_type`.
						UpperCAmelCase			:		Tuple		=		frozenset(
						    [
						        'num_inference_steps',
						        'generator',
						        'latents',
						        'return_dict',
						        'callback',
						        'callback_steps',
						    ])







						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											torch.manual_seed(0	)
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				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       ,	)
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				DDIMScheduler(
											    beta_start=0.00085       ,	beta_end=0.012       ,	beta_schedule='scaled_linear'       ,	clip_sample=snake_case       ,	set_alpha_to_one=snake_case       ,	)
											torch.manual_seed(0	)
											SCREAMING_SNAKE_CASE							:     List[Any]						=				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	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				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=1000       ,	hidden_act='gelu'       ,	projection_dim=512       ,	)
											SCREAMING_SNAKE_CASE							:     str						=				CLIPTextModel(snake_case	)
											SCREAMING_SNAKE_CASE							:     str						=				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				{
											    'unet': unet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											}
											return components







						def       lowerCamelCase_				(  self    :				Tuple       ,	snake_case    :				Optional[int]       ,	snake_case    :				List[str]=0	):



											'''simple docstring'''


											if str(snake_case	).startswith('mps'	):
																SCREAMING_SNAKE_CASE							:     List[str]						=				torch.manual_seed(snake_case	)
											else:
																SCREAMING_SNAKE_CASE							:     Optional[Any]						=				torch.Generator(device=snake_case	).manual_seed(snake_case	)
											SCREAMING_SNAKE_CASE							:     Tuple						=				{
											    '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    :				List[Any]	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				'cpu'  # ensure determinism for the device-dependent torch.Generator
											SCREAMING_SNAKE_CASE							:     Tuple						=				self.get_dummy_components()
											SCREAMING_SNAKE_CASE							:     List[str]						=				TextToVideoSDPipeline(**snake_case	)
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				sd_pipe.to(snake_case	)
											sd_pipe.set_progress_bar_config(disable=snake_case	)

											SCREAMING_SNAKE_CASE							:     List[str]						=				self.get_dummy_inputs(snake_case	)
											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				'np'
											SCREAMING_SNAKE_CASE							:     int						=				sd_pipe(**snake_case	).frames
											SCREAMING_SNAKE_CASE							:     int						=				frames[0][-3:, -3:, -1]

											assert frames[0].shape == (64, 64, 3)
											SCREAMING_SNAKE_CASE							:     str						=				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    :				List[Any]	):



											'''simple docstring'''


											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       lowerCamelCase_				(  self    :				Dict	):



											'''simple docstring'''


											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       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											pass







						@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'	)
						def       lowerCamelCase_				(  self    :				List[Any]	):



											'''simple docstring'''


											pass







						@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'	)
						def       lowerCamelCase_				(  self    :				Optional[Any]	):



											'''simple docstring'''


											pass







						def       lowerCamelCase_				(  self    :				List[str]	):



											'''simple docstring'''


											return super().test_progress_bar()


@slow
@skip_mps
class 						lowercase    (							unittest.TestCase):
						'''simple docstring'''


						def       lowerCamelCase_				(  self    :				str	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Any						=				load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'	)

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

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

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

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







						def       lowerCamelCase_				(  self    :				Dict	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'	)

											SCREAMING_SNAKE_CASE							:     Optional[int]						=				TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'	)
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				pipe.to('cuda'	)

											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				'Spiderman is surfing'
											SCREAMING_SNAKE_CASE							:     Dict						=				torch.Generator(device='cpu'	).manual_seed(0	)

											SCREAMING_SNAKE_CASE							:     str						=				pipe(snake_case       ,	generator=snake_case       ,	num_inference_steps=2       ,	output_type='pt'	).frames
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				video_frames.cpu().numpy()

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




from __future__ import annotations

import numpy as np

def        __a			(   __lowerCAmelCase   )     ->     Optional[Any]:
					return np.maximum(0      ,	__lowerCAmelCase   )


if __name__ == "__main__":
			print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]