




"""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 lowerCAmelCase__      (	lowercase,      unittest.TestCase		):






			'''simple docstring'''



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

			# No `output_type`.
			lowerCamelCase__ =     frozenset(
			    [
			        """num_inference_steps""",
			        """generator""",
			        """latents""",
			        """return_dict""",
			        """callback""",
			        """callback_steps""",
			    ]		)
			def    A_       (    self    ):
							torch.manual_seed(0    )
							_lowerCamelCase	:     int       =       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    , )
							_lowerCamelCase	:     Optional[int]       =       DDIMScheduler(
							    beta_start=0.0_00_85    , beta_end=0.0_12    , beta_schedule='scaled_linear'    , clip_sample=lowercase    , set_alpha_to_one=lowercase    , )
							torch.manual_seed(0    )
							_lowerCamelCase	:     Dict       =       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    )
							_lowerCamelCase	:     str       =       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    , )
							_lowerCamelCase	:     int       =       CLIPTextModel(lowercase    )
							_lowerCamelCase	:     str       =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

							_lowerCamelCase	:     Union[str, Any]       =       {
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							}
							return components
			def    A_       (    self    , lowercase    , lowercase=0    ):
							# 3 frames
							_lowerCamelCase	:     Optional[Any]       =       floats_tensor((1, 3, 3, 32, 32)    , rng=random.Random(lowercase    )    ).to(lowercase    )

							if str(lowercase    ).startswith('mps'    ):
											_lowerCamelCase	:     List[str]       =       torch.manual_seed(lowercase    )
							else:
											_lowerCamelCase	:     List[str]       =       torch.Generator(device=lowercase    ).manual_seed(lowercase    )
							_lowerCamelCase	:     List[Any]       =       {
							    '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    A_       (    self    ):
							_lowerCamelCase	:     Optional[Any]       =       'cpu'  # ensure determinism for the device-dependent torch.Generator
							_lowerCamelCase	:     Any       =       self.get_dummy_components()
							_lowerCamelCase	:     List[Any]       =       VideoToVideoSDPipeline(**lowercase    )
							_lowerCamelCase	:     Tuple       =       sd_pipe.to(lowercase    )
							sd_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     Any       =       self.get_dummy_inputs(lowercase    )
							_lowerCamelCase	:     Optional[int]       =       'np'
							_lowerCamelCase	:     int       =       sd_pipe(**lowercase    ).frames
							_lowerCamelCase	:     List[Any]       =       frames[0][-3:, -3:, -1]

							assert frames[0].shape == (32, 32, 3)
							_lowerCamelCase	:     Optional[int]       =       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    A_       (    self    ):
							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase    , expected_max_diff=5E-3    )
			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'    )
			def    A_       (    self    ):
							pass
			@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'    )
			def    A_       (    self    ):
							pass
			@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'    )
			def    A_       (    self    ):
							pass






			def    A_       (    self    ):
							return super().test_progress_bar()






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






			'''simple docstring'''



			def    A_       (    self    ):
							_lowerCamelCase	:     Any       =       VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'    , torch_dtype=torch.floataa    )
							pipe.enable_model_cpu_offload()

							# 10 frames
							_lowerCamelCase	:     int       =       torch.Generator(device='cpu'    ).manual_seed(0    )
							_lowerCamelCase	:     Any       =       torch.randn((1, 10, 3, 1024, 576)    , generator=lowercase    )
							_lowerCamelCase	:     Dict       =       video.to('cuda'    )

							_lowerCamelCase	:     Union[str, Any]       =       'Spiderman is surfing'

							_lowerCamelCase	:     List[Any]       =       pipe(lowercase    , video=lowercase    , generator=lowercase    , num_inference_steps=3    , output_type='pt'    ).frames

							_lowerCamelCase	:     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





"""simple docstring"""






from __future__ import annotations







def 	_snake_case     (							lowercase__						):
				_lowerCamelCase	:     int       =       len(lowercase__						)
				# We need to create solution object to save path.
				_lowerCamelCase	:     Tuple       =       [[0 for _ in range(lowercase__						)] for _ in range(lowercase__						)]
				_lowerCamelCase	:     Optional[Any]       =       run_maze(lowercase__				,       0				,       0				,       lowercase__						)
				if solved:
								print('\n'.join(str(lowercase__						) for row in solutions						)						)
				else:
								print('No solution exists!'						)
				return solved







def 	_snake_case     (							lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						):
				_lowerCamelCase	:     Optional[int]       =       len(lowercase__						)
				# Final check point.
				if i == j == (size - 1):
								_lowerCamelCase	:     Optional[Any]       =       1
								return True

				_lowerCamelCase	:     List[str]       =       (not i < 0) and (not j < 0)  # Check lower bounds
				_lowerCamelCase	:     List[str]       =       (i < size) and (j < size)  # Check upper bounds

				if lower_flag and upper_flag:
								# check for already visited and block points.
								_lowerCamelCase	:     List[Any]       =       (not solutions[i][j]) and (not maze[i][j])
								if block_flag:
												# check visited
												_lowerCamelCase	:     Union[str, Any]       =       1

												# check for directions
												if (
												    run_maze(lowercase__				,       i + 1				,       lowercase__				,       lowercase__						)
												    or run_maze(lowercase__				,       lowercase__				,       j + 1				,       lowercase__						)
												    or run_maze(lowercase__				,       i - 1				,       lowercase__				,       lowercase__						)
												    or run_maze(lowercase__				,       lowercase__				,       j - 1				,       lowercase__						)
												):
																return True

												_lowerCamelCase	:     Dict       =       0
												return False
				return False


if __name__ == "__main__":
			import doctest

			doctest.testmod()