
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__    (							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     A__		(  self			)->   List[str]:





								'''simple docstring'''






								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=_lowercase     ,	set_alpha_to_one=_lowercase     ,	)
								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=1000     ,	hidden_act='''gelu'''     ,	projection_dim=512     ,	)
								__UpperCamelCase       =			CLIPTextModel(_lowercase			)
								__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     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=0			)->   int:





								'''simple docstring'''






								if str(_lowercase			).startswith('''mps'''			):
									__UpperCamelCase       =			torch.manual_seed(_lowercase			)
								else:
									__UpperCamelCase       =			torch.Generator(device=_lowercase			).manual_seed(_lowercase			)
								__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     A__		(  self			)->   Optional[Any]:





								'''simple docstring'''






								__UpperCamelCase       =			'cpu'  # ensure determinism for the device-dependent torch.Generator
								__UpperCamelCase       =			self.get_dummy_components()
								__UpperCamelCase       =			TextToVideoSDPipeline(**_lowercase			)
								__UpperCamelCase       =			sd_pipe.to(_lowercase			)
								sd_pipe.set_progress_bar_config(disable=_lowercase			)

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

								assert frames[0].shape == (64, 64, 3)
								__UpperCamelCase       =			np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 9_3.0, 113.0]			)

								assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2



							def     A__		(  self			)->   Optional[int]:





								'''simple docstring'''






								self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_lowercase     ,	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			)->   Any:





								'''simple docstring'''






								self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_lowercase     ,	expected_max_diff=1E-2			)



							@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''			)
							def     A__		(  self			)->   Union[str, Any]:





								'''simple docstring'''






								pass



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





								'''simple docstring'''






								pass



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





								'''simple docstring'''






								pass



							def     A__		(  self			)->   Union[str, Any]:





								'''simple docstring'''






								return super().test_progress_bar()






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

							"""simple docstring"""






							def     A__		(  self			)->   int:





								'''simple docstring'''






								__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(_lowercase     ,	generator=_lowercase     ,	num_inference_steps=25     ,	output_type='''pt'''			).frames
								__UpperCamelCase       =			video_frames.cpu().numpy()

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



							def     A__		(  self			)->   int:





								'''simple docstring'''






								__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(_lowercase     ,	generator=_lowercase     ,	num_inference_steps=2     ,	output_type='''pt'''			).frames
								__UpperCamelCase       =			video_frames.cpu().numpy()

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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__							:							int									=			{
    "configuration_git": ["GIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "GitConfig", "GitVisionConfig"],
    "processing_git": ["GitProcessor"],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase__							:							Tuple									=			[
				    "GIT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "GitForCausalLM",
				    "GitModel",
				    "GitPreTrainedModel",
				    "GitVisionModel",
				]

if TYPE_CHECKING:
				from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
				from .processing_git import GitProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_git import (
								    GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    GitForCausalLM,
								    GitModel,
								    GitPreTrainedModel,
								    GitVisionModel,
								)

else:
				import sys

				lowercase__							:							Optional[Any]									=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




