"""simple docstring"""






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




					"""simple docstring"""

					snake_case__       					=				TextToVideoSDPipeline
					snake_case__       					=				TEXT_TO_IMAGE_PARAMS
					snake_case__       					=				TEXT_TO_IMAGE_BATCH_PARAMS
					# No `output_type`.
					snake_case__       					=				frozenset(
					    [
					        "num_inference_steps",
					        "generator",
					        "latents",
					        "return_dict",
					        "callback",
					        "callback_steps",
					    ]       )







					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									torch.manual_seed(0    )
									UpperCAmelCase__    =							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__    =							DDIMScheduler(
									    beta_start=0.0_0_0_8_5					,beta_end=0.0_1_2					,beta_schedule='scaled_linear'					,clip_sample=lowerCamelCase__					,set_alpha_to_one=lowerCamelCase__					,)
									torch.manual_seed(0    )
									UpperCAmelCase__    =							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    )
									UpperCAmelCase__    =							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=1_000					,hidden_act='gelu'					,projection_dim=512					,)
									UpperCAmelCase__    =							CLIPTextModel(lowerCamelCase__    )
									UpperCAmelCase__    =							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

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







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

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

									assert frames[0].shape == (64, 64, 3)
									UpperCAmelCase__    =							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 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase__					,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    ):
									self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase__					,expected_max_diff=1e-2    )







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







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







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







					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									return super().test_progress_bar()






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




					"""simple docstring"""

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

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

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

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

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







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

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

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

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

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




"""simple docstring"""






import re



def 						a_		(      lowerCamelCase ):
				return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]'      ,    str_ )]



def 						a_		(      lowerCamelCase ):
				UpperCAmelCase__    =							split_input(str_ )
				return "".join(
				    [''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )



def 						a_		(      lowerCamelCase      ,    lowerCamelCase      ,    lowerCamelCase ):
				try:
								UpperCAmelCase__    =							split_input(lowerCamelCase )
								if upper:
												UpperCAmelCase__    =							''.join(
												    [
												        separator.join([char.upper() for char in sub_str] )
												        for sub_str in string_split
												    ] )
								else:
												UpperCAmelCase__    =							''.join(
												    [
												        separator.join([char.lower() for char in sub_str] )
												        for sub_str in string_split
												    ] )
								return res_str
				except IndexError:
								return "not valid string"



def 						a_		(      lowerCamelCase ):
				return to_simple_case(lowerCamelCase )



def 						a_		(      lowerCamelCase ):
				try:
								UpperCAmelCase__    =							to_simple_case(lowerCamelCase )
								return res_str[0].lower() + res_str[1:]
				except IndexError:
								return "not valid string"



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return to_complex_case(lowerCamelCase      ,    lowerCamelCase      ,    '_' )



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return to_complex_case(lowerCamelCase      ,    lowerCamelCase      ,    '-' )


if __name__ == "__main__":
						__import__('doctest').testmod()



