






import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



@skip_mps
class   lowerCamelCase      (_snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Tuple       						=  VideoToVideoSDPipeline
		_snake_case    :    List[str]       						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}			) - {'''image''', '''width''', '''height'''}
		_snake_case    :    Optional[Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}			) - {'''image'''}
		_snake_case    :    str       						=  PipelineTesterMixin.required_optional_params - {'''latents'''}
		_snake_case    :    Any       						=  False

		# No `output_type`.
		_snake_case    :    List[str]       						=  frozenset(
		    [
		        '''num_inference_steps''',
		        '''generator''',
		        '''latents''',
		        '''return_dict''',
		        '''callback''',
		        '''callback_steps''',
		    ]			)



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							torch.manual_seed(0   )
							UpperCAmelCase_    :      str            =						UNetaDConditionModel(
							    block_out_channels=(3_2, 6_4, 6_4, 6_4)				,		layers_per_block=2				,		sample_size=3_2				,		in_channels=4				,		out_channels=4				,		down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D')				,		up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D')				,		cross_attention_dim=3_2				,		attention_head_dim=4				,		)
							UpperCAmelCase_    :      List[Any]            =						DDIMScheduler(
							    beta_start=0.0_00_85				,		beta_end=0.0_12				,		beta_schedule='scaled_linear'				,		clip_sample=_UpperCamelCase				,		set_alpha_to_one=_UpperCamelCase				,		)
							torch.manual_seed(0   )
							UpperCAmelCase_    :      Tuple            =						AutoencoderKL(
							    block_out_channels=[3_2, 6_4]				,		in_channels=3				,		out_channels=3				,		down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']				,		up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']				,		latent_channels=4				,		sample_size=1_2_8				,		)
							torch.manual_seed(0   )
							UpperCAmelCase_    :      Any            =						CLIPTextConfig(
							    bos_token_id=0				,		eos_token_id=2				,		hidden_size=3_2				,		intermediate_size=3_7				,		layer_norm_eps=1E-05				,		num_attention_heads=4				,		num_hidden_layers=5				,		pad_token_id=1				,		vocab_size=1_0_0_0				,		hidden_act='gelu'				,		projection_dim=5_1_2				,		)
							UpperCAmelCase_    :      Optional[Any]            =						CLIPTextModel(_UpperCamelCase   )
							UpperCAmelCase_    :      Dict            =						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

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



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase=0   )	->							Optional[int]:
							# 3 frames
							UpperCAmelCase_    :      Any            =						floats_tensor((1, 3, 3, 3_2, 3_2)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

							if str(_UpperCamelCase   ).startswith('mps'   ):
												UpperCAmelCase_    :      Optional[Any]            =						torch.manual_seed(_UpperCamelCase   )
							else:
												UpperCAmelCase_    :      Union[str, Any]            =						torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						{
							    'prompt': 'A painting of a squirrel eating a burger',
							    'video': video,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'guidance_scale': 6.0,
							    'output_type': 'pt',
							}
							return inputs



		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							UpperCAmelCase_    :      int            =						'cpu'  # ensure determinism for the device-dependent torch.Generator
							UpperCAmelCase_    :      str            =						self.get_dummy_components()
							UpperCAmelCase_    :      Optional[Any]            =						VideoToVideoSDPipeline(**_UpperCamelCase   )
							UpperCAmelCase_    :      List[Any]            =						sd_pipe.to(_UpperCamelCase   )
							sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

							UpperCAmelCase_    :      List[str]            =						self.get_dummy_inputs(_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						'np'
							UpperCAmelCase_    :      List[Any]            =						sd_pipe(**_UpperCamelCase   ).frames
							UpperCAmelCase_    :      Union[str, Any]            =						frames[0][-3:, -3:, -1]

							assert frames[0].shape == (3_2, 3_2, 3)
							UpperCAmelCase_    :      int            =						np.array([1_0_6, 1_1_7, 1_1_3, 1_7_4, 1_3_7, 1_1_2, 1_4_8, 1_5_1, 1_3_1]   )

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



		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()				,		reason='XFormers attention is only available with CUDA and `xformers` installed'				,		)
		def 					__UpperCAmelCase			(							self   )	->							int:
							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_UpperCamelCase				,		expected_max_diff=5E-3   )



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



		@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'   )
		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							pass



		@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'   )
		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							pass



		def 					__UpperCAmelCase			(							self   )	->							int:
							return super().test_progress_bar()





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







		'''simple docstring'''



		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							UpperCAmelCase_    :      Tuple            =						VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'				,		torch_dtype=torch.floataa   )
							pipe.enable_model_cpu_offload()

							# 10 frames
							UpperCAmelCase_    :      Dict            =						torch.Generator(device='cpu'   ).manual_seed(0   )
							UpperCAmelCase_    :      Any            =						torch.randn((1, 1_0, 3, 1_0_2_4, 5_7_6)				,		generator=_UpperCamelCase   )
							UpperCAmelCase_    :      Optional[int]            =						video.to('cuda'   )

							UpperCAmelCase_    :      List[Any]            =						'Spiderman is surfing'

							UpperCAmelCase_    :      List[str]            =						pipe(_UpperCamelCase				,		video=_UpperCamelCase				,		generator=_UpperCamelCase				,		num_inference_steps=3				,		output_type='pt'   ).frames

							UpperCAmelCase_    :      List[Any]            =						np.array([-1.0_45_89_84, -1.1_27_92_97, -0.9_66_30_86, -0.91_50_39_06, -0.75_09_76_56]   )
							assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array   ).sum() < 1E-2














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase								=						{'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCAmelCase								=						[
		    'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'ViTMSNModel',
		    'ViTMSNForImageClassification',
		    'ViTMSNPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vit_msn import (
				    VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViTMSNForImageClassification,
				    ViTMSNModel,
				    ViTMSNPreTrainedModel,
				)

else:
		import sys

		__UpperCAmelCase								=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






