





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 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







    lowerCamelCase__    :		Any				=	VideoToVideoSDPipeline
    lowerCamelCase__    :		List[Any]				=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""}    ) - {"""image""", """width""", """height"""}
    lowerCamelCase__    :		List[str]				=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""}    ) - {"""image"""}
    lowerCamelCase__    :		List[str]				=	PipelineTesterMixin.required_optional_params - {"""latents"""}
    lowerCamelCase__    :		int				=	False

    # No `output_type`.
    lowerCamelCase__    :		List[Any]				=	frozenset(
        [
            """num_inference_steps""",
            """generator""",
            """latents""",
            """return_dict""",
            """callback""",
            """callback_steps""",
        ]    )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        torch.manual_seed(0     )
        SCREAMING_SNAKE_CASE__											=			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__											=			DDIMScheduler(
            beta_start=0.00085   ,				beta_end=0.012   ,				beta_schedule='''scaled_linear'''   ,				clip_sample=A_   ,				set_alpha_to_one=A_   ,				)
        torch.manual_seed(0     )
        SCREAMING_SNAKE_CASE__											=			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=1_28   ,				)
        torch.manual_seed(0     )
        SCREAMING_SNAKE_CASE__											=			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=10_00   ,				hidden_act='''gelu'''   ,				projection_dim=5_12   ,				)
        SCREAMING_SNAKE_CASE__											=			CLIPTextModel(A_     )
        SCREAMING_SNAKE_CASE__											=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     )

        SCREAMING_SNAKE_CASE__											=			{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
        }
        return components



    def  lowercase_					(       self   ,				A_   ,				A_=0     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			floats_tensor((1, 3, 3, 32, 32)   ,				rng=random.Random(A_     )     ).to(A_     )

        if str(A_     ).startswith('''mps'''     ):
            SCREAMING_SNAKE_CASE__											=			torch.manual_seed(A_     )
        else:
            SCREAMING_SNAKE_CASE__											=			torch.Generator(device=A_     ).manual_seed(A_     )
        SCREAMING_SNAKE_CASE__											=			{
            '''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  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        SCREAMING_SNAKE_CASE__											=			self.get_dummy_components()
        SCREAMING_SNAKE_CASE__											=			VideoToVideoSDPipeline(**A_     )
        SCREAMING_SNAKE_CASE__											=			sd_pipe.to(A_     )
        sd_pipe.set_progress_bar_config(disable=A_     )

        SCREAMING_SNAKE_CASE__											=			self.get_dummy_inputs(A_     )
        SCREAMING_SNAKE_CASE__											=			'''np'''
        SCREAMING_SNAKE_CASE__											=			sd_pipe(**A_     ).frames
        SCREAMING_SNAKE_CASE__											=			frames[0][-3:, -3:, -1]

        assert frames[0].shape == (32, 32, 3)
        SCREAMING_SNAKE_CASE__											=			np.array([1_06, 1_17, 1_13, 1_74, 1_37, 1_12, 1_48, 1_51, 1_31]     )

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





        '''simple docstring'''

        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A_   ,				expected_max_diff=5E-3     )



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





        '''simple docstring'''

        pass



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





        '''simple docstring'''

        pass



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





        '''simple docstring'''

        pass




    def  lowercase_					(       self     ):





        '''simple docstring'''

        return super().test_progress_bar()





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


    '''simple docstring'''







    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			VideoToVideoSDPipeline.from_pretrained('''cerspense/zeroscope_v2_XL'''   ,				torch_dtype=torch.floataa     )
        pipe.enable_model_cpu_offload()

        # 10 frames
        SCREAMING_SNAKE_CASE__											=			torch.Generator(device='''cpu'''     ).manual_seed(0     )
        SCREAMING_SNAKE_CASE__											=			torch.randn((1, 10, 3, 10_24, 5_76)   ,				generator=A_     )
        SCREAMING_SNAKE_CASE__											=			video.to('''cuda'''     )

        SCREAMING_SNAKE_CASE__											=			'''Spiderman is surfing'''

        SCREAMING_SNAKE_CASE__											=			pipe(A_   ,				video=A_   ,				generator=A_   ,				num_inference_steps=3   ,				output_type='''pt'''     ).frames

        SCREAMING_SNAKE_CASE__											=			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'''

def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 1000   )      -> int:
							SCREAMING_SNAKE_CASE_				=				2**power
							SCREAMING_SNAKE_CASE_				=				str(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				list(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				0

							for i in list_num:
														sum_of_num += int(lowerCAmelCase__   )

							return sum_of_num


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE							:				Tuple     	=			int(input("Enter the power of 2: ").strip())
							print("2 ^ ", power, " = ", 2**power)
							SCREAMING_SNAKE_CASE							:				str     	=			solution(power)
							print("Sum of the digits is: ", result)





