


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






			"""simple docstring"""






			_UpperCamelCase		:					Optional[int]    =		TextToVideoSDPipeline
			_UpperCamelCase		:					Optional[int]    =		TEXT_TO_IMAGE_PARAMS
			_UpperCamelCase		:					Dict    =		TEXT_TO_IMAGE_BATCH_PARAMS
			# No `output_type`.
			_UpperCamelCase		:					Optional[Any]    =		frozenset(
			    [
			        'num_inference_steps',
			        'generator',
			        'latents',
			        'return_dict',
			        'callback',
			        'callback_steps',
			    ]      )




			def 				snake_case__				(							self     ):

						'''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.00085      ,						beta_end=0.012      ,						beta_schedule="scaled_linear"      ,						clip_sample=snake_case      ,						set_alpha_to_one=snake_case      ,						)
						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-0_5      ,						num_attention_heads=4      ,						num_hidden_layers=5      ,						pad_token_id=1      ,						vocab_size=1000      ,						hidden_act="gelu"      ,						projection_dim=512      ,						)
						UpperCamelCase__					=       CLIPTextModel(snake_case     )
						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 				snake_case__				(							self      ,						snake_case      ,						snake_case=0     ):

						'''simple docstring'''


						if str(snake_case     ).startswith("mps"     ):
									UpperCamelCase__					=       torch.manual_seed(snake_case     )
						else:
									UpperCamelCase__					=       torch.Generator(device=snake_case     ).manual_seed(snake_case     )
						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 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       "cpu"  # ensure determinism for the device-dependent torch.Generator
						UpperCamelCase__					=       self.get_dummy_components()
						UpperCamelCase__					=       TextToVideoSDPipeline(**snake_case     )
						UpperCamelCase__					=       sd_pipe.to(snake_case     )
						sd_pipe.set_progress_bar_config(disable=snake_case     )

						UpperCamelCase__					=       self.get_dummy_inputs(snake_case     )
						UpperCamelCase__					=       "np"
						UpperCamelCase__					=       sd_pipe(**snake_case     ).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, 93.0, 113.0]     )

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




			def 				snake_case__				(							self     ):

						'''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 				snake_case__				(							self     ):

						'''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 				snake_case__				(							self     ):

						'''simple docstring'''


						pass




			@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						pass




			@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						pass







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return super().test_progress_bar()







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






			"""simple docstring"""






			def 				snake_case__				(							self     ):

						'''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(snake_case      ,						generator=snake_case      ,						num_inference_steps=25      ,						output_type="pt"     ).frames
						UpperCamelCase__					=       video_frames.cpu().numpy()

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







			def 				snake_case__				(							self     ):

						'''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(snake_case      ,						generator=snake_case      ,						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_flax_available,
    is_tf_available,
    is_torch_available,
)


__UpperCamelCase    		=       {
    'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig']
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase    		=       [
						    'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'ResNetForImageClassification',
						    'ResNetModel',
						    'ResNetPreTrainedModel',
						    'ResNetBackbone',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase    		=       [
						    'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TFResNetForImageClassification',
						    'TFResNetModel',
						    'TFResNetPreTrainedModel',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase    		=       [
						    'FlaxResNetForImageClassification',
						    'FlaxResNetModel',
						    'FlaxResNetPreTrainedModel',
						]

if TYPE_CHECKING:
						from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_resnet import (
												    RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ResNetBackbone,
												    ResNetForImageClassification,
												    ResNetModel,
												    ResNetPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_resnet import (
												    TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFResNetForImageClassification,
												    TFResNetModel,
												    TFResNetPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel


else:
						import sys

						__UpperCamelCase    		=       _LazyModule(__name__, globals()['__file__'], _import_structure)


