






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


     UpperCamelCase_				:		Dict								=						VideoToVideoSDPipeline
     UpperCamelCase_				:		Dict								=						TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}       ) - {'''image''', '''width''', '''height'''}
     UpperCamelCase_				:		int								=						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}       ) - {'''image'''}
     UpperCamelCase_				:		Optional[int]								=						PipelineTesterMixin.required_optional_params - {'''latents'''}
     UpperCamelCase_				:		Any								=						False

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


     def 					_A							(					self							:						int   ):
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   str						    =     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       ,			)
       SCREAMING_SNAKE_CASE							:   str						    =     DDIMScheduler(
           beta_start=0.00_085       ,			beta_end=0.012       ,			beta_schedule="scaled_linear"       ,			clip_sample=__SCREAMING_SNAKE_CASE       ,			set_alpha_to_one=__SCREAMING_SNAKE_CASE       ,			)
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   str						    =     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   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     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       ,			)
       SCREAMING_SNAKE_CASE							:   Tuple						    =     CLIPTextModel(__SCREAMING_SNAKE_CASE   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )

       SCREAMING_SNAKE_CASE							:   str						    =     {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
       }
       return components


     def 					_A							(					self							:						Optional[Any]       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						int=0   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     floats_tensor((1, 3, 3, 32, 32)       ,			rng=random.Random(__SCREAMING_SNAKE_CASE   )   ).to(__SCREAMING_SNAKE_CASE   )

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

       SCREAMING_SNAKE_CASE							:   List[str]						    =     self.get_dummy_inputs(__SCREAMING_SNAKE_CASE   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     "np"
       SCREAMING_SNAKE_CASE							:   List[str]						    =     sd_pipe(**__SCREAMING_SNAKE_CASE   ).frames
       SCREAMING_SNAKE_CASE							:   Tuple						    =     frames[0][-3:, -3:, -1]

       assert frames[0].shape == (32, 32, 3)
       SCREAMING_SNAKE_CASE							:   str						    =     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							:						List[str]   ):
       self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__SCREAMING_SNAKE_CASE       ,			expected_max_diff=5E-3   )


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


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


     @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."   )
     def 					_A							(					self							:						Optional[int]   ):
       pass






     def 					_A							(					self							:						List[str]   ):
       return super().test_progress_bar()





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


     def 					_A							(					self							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     VideoToVideoSDPipeline.from_pretrained("cerspense/zeroscope_v2_XL"       ,			torch_dtype=torch.floataa   )
       pipe.enable_model_cpu_offload()

       # 10 frames
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     torch.Generator(device="cpu"   ).manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     torch.randn((1, 10, 3, 1024, 576)       ,			generator=__SCREAMING_SNAKE_CASE   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     video.to("cuda"   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     "Spiderman is surfing"

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     pipe(__SCREAMING_SNAKE_CASE       ,			video=__SCREAMING_SNAKE_CASE       ,			generator=__SCREAMING_SNAKE_CASE       ,			num_inference_steps=3       ,			output_type="pt"   ).frames

       SCREAMING_SNAKE_CASE							:   List[str]						    =     np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]   )
       assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array   ).sum() < 1E-2












'''simple docstring'''



def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> int:




     '''simple docstring'''





     __snake_case            =	[[0 for _ in range(_lowerCamelCase						)] for _ in range(m + 1						)]
     for i in range(m + 1						):
          __snake_case            =	1

     for n in range(m + 1						):
          for k in range(1 ,						_lowerCamelCase						):
               memo[n][k] += memo[n][k - 1]
               if n - k > 0:
                    memo[n][k] += memo[n - k - 1][k]

     return memo[m][m - 1]


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          try:
               UpperCAmelCase_							:	List[str]	     =		int(input('''Enter a number: ''').strip())
               print(partition(n))
          except ValueError:
               print('''Please enter a number.''')
     else:
          try:
               UpperCAmelCase_							:	Union[str, Any]	     =		int(sys.argv[1])
               print(partition(n))
          except ValueError:
               print('''Please pass a number.''')






