




'''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 			_a  (	__a							,							unittest.TestCase ):
       __a				:     List[Any]   				=					VideoToVideoSDPipeline
       __a				:     Optional[Any]   				=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""} ) - {"""image""", """width""", """height"""}
       __a				:     Tuple   				=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""} ) - {"""image"""}
       __a				:     Union[str, Any]   				=					PipelineTesterMixin.required_optional_params - {"""latents"""}
       __a				:     str   				=					False

       # No `output_type`.
       __a				:     Dict   				=					frozenset(
           [
               """num_inference_steps""",
               """generator""",
               """latents""",
               """return_dict""",
               """callback""",
               """callback_steps""",
           ] )
       def     A      (	self						:	Optional[int]				):



           '''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_0085   ,				beta_end=0.012   ,				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=1_000   ,				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						:	Optional[Any]   ,				lowercase						:	Optional[Any]   ,				lowercase						:	int=0				):



           '''simple docstring'''

           UpperCAmelCase			       =		floats_tensor((1, 3, 3, 32, 32)   ,				rng=random.Random(lowercase				)				).to(lowercase				)

           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''',
               '''video''': video,
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 6.0,
               '''output_type''': '''pt''',
           }
           return inputs
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
           UpperCAmelCase			       =		self.get_dummy_components()
           UpperCAmelCase			       =		VideoToVideoSDPipeline(**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 == (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     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           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						:	Tuple				):



           '''simple docstring'''

           pass
       @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''				)
       def     A      (	self						:	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						:	List[Any]				):



           '''simple docstring'''

           return super().test_progress_bar()






@slow
@skip_mps
class 			_a  (	unittest.TestCase ):
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           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, 1_024, 576)   ,				generator=lowercase				)
           UpperCAmelCase			       =		video.to('''cuda'''				)

           UpperCAmelCase			       =		'''Spiderman is surfing'''

           UpperCAmelCase			       =		pipe(lowercase   ,				video=lowercase   ,				generator=lowercase   ,				num_inference_steps=3   ,				output_type='''pt'''				).frames

           UpperCAmelCase			       =		np.array([-1.045_8984, -1.127_9297, -0.966_3086, -0.9150_3906, -0.7509_7656]				)
           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_							(_a	:							Dict    ,   _a	:							str    ,   _a	:							Optional[Any]    ,   _a	:							List[str]     ):  # noqa: E741
    while r - l > 1:
        UpperCAmelCase			       =		(l + r) // 2
        if v[m] >= key:
            UpperCAmelCase			       =		m
        else:
            UpperCAmelCase			       =		m  # noqa: E741
    return r





def 						snake_case_							(_a	:							list[int]     ):
    if len(_a     ) == 0:
        return 0

    UpperCAmelCase			       =		[0] * len(_a     )
    UpperCAmelCase			       =		1

    UpperCAmelCase			       =		v[0]

    for i in range(1    ,   len(_a     )     ):
        if v[i] < tail[0]:
            UpperCAmelCase			       =		v[i]
        elif v[i] > tail[length - 1]:
            UpperCAmelCase			       =		v[i]
            length += 1
        else:
            UpperCAmelCase			       =		v[i]

    return length


if __name__ == "__main__":
   import doctest

   doctest.testmod()




