




import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


@skip_mps
class 							UpperCamelCase_       (					UpperCAmelCase__						,   unittest.TestCase	):

    '''simple docstring'''






    UpperCAmelCase__				    = TextToVideoSDPipeline
    UpperCAmelCase__				    = TEXT_TO_IMAGE_PARAMS
    UpperCAmelCase__				    = TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    UpperCAmelCase__				    = frozenset(
        [
            '''num_inference_steps''',
            '''generator''',
            '''latents''',
            '''return_dict''',
            '''callback''',
            '''callback_steps''',
        ]	)


    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->Optional[Any]:





           '''simple docstring'''

           torch.manual_seed(0)
           A__ 					=       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   ,					)
           A__ 					=       DDIMScheduler(
               beta_start=0.00085   ,					beta_end=0.012   ,					beta_schedule='''scaled_linear'''   ,					clip_sample=UpperCAmelCase__   ,					set_alpha_to_one=UpperCAmelCase__   ,					)
           torch.manual_seed(0)
           A__ 					=       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)
           A__ 					=       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   ,					)
           A__ 					=       CLIPTextModel(UpperCAmelCase__)
           A__ 					=       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

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


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any]   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      str=0)		->Any:





           '''simple docstring'''

           if str(UpperCAmelCase__).startswith('''mps'''):
                  A__ 					=       torch.manual_seed(UpperCAmelCase__)
           else:
                  A__ 					=       torch.Generator(device=UpperCAmelCase__).manual_seed(UpperCAmelCase__)
           A__ 					=       {
               '''prompt''': '''A painting of a squirrel eating a burger''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 6.0,
               '''output_type''': '''pt''',
           }
           return inputs


    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->Tuple:





           '''simple docstring'''

           A__ 					=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
           A__ 					=       self.get_dummy_components()
           A__ 					=       TextToVideoSDPipeline(**UpperCAmelCase__)
           A__ 					=       sd_pipe.to(UpperCAmelCase__)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__)

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

           assert frames[0].shape == (64, 64, 3)
           A__ 					=       np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0])

           assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2


    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->Dict:





           '''simple docstring'''

           self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCAmelCase__   ,					expected_max_diff=3e-3)


    @unittest.skipIf(
        torch_device != '''cuda''' or not is_xformers_available()   ,					reason='''XFormers attention is only available with CUDA and `xformers` installed'''   ,					)
    def 			SCREAMING_SNAKE_CASE				(     self :      List[Any])		->Optional[Any]:





           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCAmelCase__   ,					expected_max_diff=1e-2)


    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''')
    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->Tuple:





           '''simple docstring'''

           pass


    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.''')
    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->Any:





           '''simple docstring'''

           pass


    @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.''')
    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->Optional[Any]:





           '''simple docstring'''

           pass





    def 			SCREAMING_SNAKE_CASE				(     self :      List[Any])		->List[Any]:





           '''simple docstring'''

           return super().test_progress_bar()


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

    '''simple docstring'''






    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->int:





           '''simple docstring'''

           A__ 					=       load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy''')

           A__ 					=       TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
           A__ 					=       DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
           A__ 					=       pipe.to('''cuda''')

           A__ 					=       '''Spiderman is surfing'''
           A__ 					=       torch.Generator(device='''cpu''').manual_seed(0)

           A__ 					=       pipe(UpperCAmelCase__   ,					generator=UpperCAmelCase__   ,					num_inference_steps=25   ,					output_type='''pt''').frames
           A__ 					=       video_frames.cpu().numpy()

           assert np.abs(expected_video - video).mean() < 5e-2





    def 			SCREAMING_SNAKE_CASE				(     self :      str)		->Optional[Any]:





           '''simple docstring'''

           A__ 					=       load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy''')

           A__ 					=       TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b''')
           A__ 					=       pipe.to('''cuda''')

           A__ 					=       '''Spiderman is surfing'''
           A__ 					=       torch.Generator(device='''cpu''').manual_seed(0)

           A__ 					=       pipe(UpperCAmelCase__   ,					generator=UpperCAmelCase__   ,					num_inference_steps=2   ,					output_type='''pt''').frames
           A__ 					=       video_frames.cpu().numpy()

           assert np.abs(expected_video - video).mean() < 5e-2







'''simple docstring'''



from __future__ import annotations
def        UpperCAmelCase (    A	:					list[int]       ,		A	:					int					):
							if len(A					) < k or k < 0:
														raise ValueError('''Invalid Input'''					)
							SCREAMING_SNAKE_CASE       :   Dict         =      sum(array[:k]					)
							for i in range(len(A					) - k					):
														SCREAMING_SNAKE_CASE       :   Optional[Any]         =      current_sum - array[i] + array[i + k]
														SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      max(A       ,		A					)
							return max_sum


if __name__ == "__main__":
							from doctest import testmod
							from random import randint

							testmod()
							lowerCAmelCase_  :							Optional[int]             =    [randint(-1000, 1000) for i in range(100)]
							lowerCAmelCase_  :							Optional[int]             =    randint(0, 110)
							print(f'The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}')




