


'''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 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					unittest.TestCase	):



     """simple docstring"""






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

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







     def a	( self   ):

            '''simple docstring'''

            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    :							Dict   			=       DDIMScheduler(
                beta_start=0.0_0085      ,	beta_end=0.012      ,	beta_schedule='scaled_linear'      ,	clip_sample=snake_case__      ,	set_alpha_to_one=snake_case__      ,	)
            torch.manual_seed(0   )
            _lowerCAmelCase    :							Tuple   			=       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    :							int   			=       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    :							str   			=       CLIPTextModel(snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

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







     def a	( self      ,	snake_case__      ,	snake_case__=0   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       floats_tensor((1, 3, 3, 32, 32)      ,	rng=random.Random(snake_case__   )   ).to(snake_case__   )

            if str(snake_case__   ).startswith('mps'   ):
                   _lowerCAmelCase    :							Union[str, Any]   			=       torch.manual_seed(snake_case__   )
            else:
                   _lowerCAmelCase    :							Dict   			=       torch.Generator(device=snake_case__   ).manual_seed(snake_case__   )
            _lowerCAmelCase    :							int   			=       {
                '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   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       'cpu'  # ensure determinism for the device-dependent torch.Generator
            _lowerCAmelCase    :							str   			=       self.get_dummy_components()
            _lowerCAmelCase    :							Dict   			=       VideoToVideoSDPipeline(**snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       sd_pipe.to(snake_case__   )
            sd_pipe.set_progress_bar_config(disable=snake_case__   )

            _lowerCAmelCase    :							Any   			=       self.get_dummy_inputs(snake_case__   )
            _lowerCAmelCase    :							Dict   			=       'np'
            _lowerCAmelCase    :							List[str]   			=       sd_pipe(**snake_case__   ).frames
            _lowerCAmelCase    :							Dict   			=       frames[0][-3:, -3:, -1]

            assert frames[0].shape == (32, 32, 3)
            _lowerCAmelCase    :							Tuple   			=       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   ):

            '''simple docstring'''

            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 a	( self   ):

            '''simple docstring'''

            pass







     @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'   )
     def a	( self   ):

            '''simple docstring'''

            pass







     def a	( self   ):

            '''simple docstring'''

            return super().test_progress_bar()
@slow
@skip_mps
class 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Union[str, Any]   			=       VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'      ,	torch_dtype=torch.floataa   )
            pipe.enable_model_cpu_offload()

            # 10 frames
            _lowerCAmelCase    :							str   			=       torch.Generator(device='cpu'   ).manual_seed(0   )
            _lowerCAmelCase    :							str   			=       torch.randn((1, 10, 3, 1024, 576)      ,	generator=snake_case__   )
            _lowerCAmelCase    :							List[Any]   			=       video.to('cuda'   )

            _lowerCAmelCase    :							Optional[int]   			=       'Spiderman is surfing'

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

            _lowerCAmelCase    :							Any   			=       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'''







lowerCAmelCase    :     Optional[int]					=						[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_00_00)]






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							str   			=       0
       while number:
              # Increased Speed Slightly by checking every 5 digits together.
              sum_of_digits_squared += DIGITS_SQUARED[number % 1_0_0_0_0_0]
              number //= 1_0_0_0_0_0

       return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
lowerCAmelCase    :     list[bool | None]					=						[None] * 10_00_00_00
lowerCAmelCase    :     List[str]					=						True
lowerCAmelCase    :     Union[str, Any]					=						False






def 			lowercase				(_A					):







       """simple docstring"""







       if CHAINS[number - 1] is not None:
              return CHAINS[number - 1]  # type: ignore

       _lowerCAmelCase    :							Any   			=       chain(next_number(_A					)					)
       _lowerCAmelCase    :							List[str]   			=       number_chain

       while number < 1_0_0_0_0_0_0_0:
              _lowerCAmelCase    :							Tuple   			=       number_chain
              number *= 1_0

       return number_chain






def 			lowercase				(_A = 1_0_0_0_0_0_0_0					):







       """simple docstring"""







       for i in range(1   ,						_A					):
              if CHAINS[i] is None:
                     chain(i + 1					)

       return CHAINS[:number].count(_A					)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       print(F'''{solution() = }''')

