



"""simple docstring"""





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







							_UpperCAmelCase      				=					VideoToVideoSDPipeline
							_UpperCAmelCase      				=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}    ) - {'''image''', '''width''', '''height'''}
							_UpperCAmelCase      				=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}    ) - {'''image'''}
							_UpperCAmelCase      				=					PipelineTesterMixin.required_optional_params - {'''latents'''}
							_UpperCAmelCase      				=					False

							# No `output_type`.
							_UpperCAmelCase      				=					frozenset(
							    [
							        '''num_inference_steps''',
							        '''generator''',
							        '''latents''',
							        '''return_dict''',
							        '''callback''',
							        '''callback_steps''',
							    ]    )






							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									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-05	,       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        lowerCamelCase_   (  self	,       snake_case	,       snake_case=0						)			->							Tuple:
									# 3 frames
									_UpperCAmelCase							 =		floats_tensor((1, 3, 3, 32, 32)	,       rng=random.Random(snake_case						)						).to(snake_case						)

									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',
									    'video': video,
									    'generator': generator,
									    'num_inference_steps': 2,
									    'guidance_scale': 6.0,
									    'output_type': 'pt',
									}
									return inputs






							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		'cpu'  # ensure determinism for the device-dependent torch.Generator
									_UpperCAmelCase							 =		self.get_dummy_components()
									_UpperCAmelCase							 =		VideoToVideoSDPipeline(**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 == (32, 32, 3)
									_UpperCAmelCase							 =		np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]						)

									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        lowerCamelCase_   (  self						)			->							str:
									self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case	,       expected_max_diff=5E-3						)






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






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






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






							def        lowerCamelCase_   (  self						)			->							str:
									return super().test_progress_bar()







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







							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									_UpperCAmelCase							 =		VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'	,       torch_dtype=torch.floataa						)
									pipe.enable_model_cpu_offload()

									# 10 frames
									_UpperCAmelCase							 =		torch.Generator(device='cpu'						).manual_seed(0						)
									_UpperCAmelCase							 =		torch.randn((1, 10, 3, 1024, 576)	,       generator=snake_case						)
									_UpperCAmelCase							 =		video.to('cuda'						)

									_UpperCAmelCase							 =		'Spiderman is surfing'

									_UpperCAmelCase							 =		pipe(snake_case	,       video=snake_case	,       generator=snake_case	,       num_inference_steps=3	,       output_type='pt'						).frames

									_UpperCAmelCase							 =		np.array([-1.0458984, -1.1279297, -0.9663086, -0.91503906, -0.75097656]						)
									assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array						).sum() < 1E-2







"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase  							=					{
    '''configuration_clipseg''': [
        '''CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPSegConfig''',
        '''CLIPSegTextConfig''',
        '''CLIPSegVisionConfig''',
    ],
    '''processing_clipseg''': ['''CLIPSegProcessor'''],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					[
					    '''CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''CLIPSegModel''',
					    '''CLIPSegPreTrainedModel''',
					    '''CLIPSegTextModel''',
					    '''CLIPSegVisionModel''',
					    '''CLIPSegForImageSegmentation''',
					]

if TYPE_CHECKING:
					from .configuration_clipseg import (
					    CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    CLIPSegConfig,
					    CLIPSegTextConfig,
					    CLIPSegVisionConfig,
					)
					from .processing_clipseg import CLIPSegProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_clipseg import (
										    CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CLIPSegForImageSegmentation,
										    CLIPSegModel,
										    CLIPSegPreTrainedModel,
										    CLIPSegTextModel,
										    CLIPSegVisionModel,
										)

else:
					import sys

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


