






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


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


     def 					_A							(					self							:						str   ):
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   Optional[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       ,			)
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     DDIMScheduler(
           beta_start=0.00_085       ,			beta_end=0.012       ,			beta_schedule="scaled_linear"       ,			clip_sample=UpperCAmelCase_       ,			set_alpha_to_one=UpperCAmelCase_       ,			)
       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							:   str						    =     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							:   Any						    =     CLIPTextModel(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Union[str, 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							:						Tuple       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						Optional[int]=0   ):
       if str(UpperCAmelCase_   ).startswith("mps"   ):
         SCREAMING_SNAKE_CASE							:   int						    =     torch.manual_seed(UpperCAmelCase_   )
       else:
         SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     torch.Generator(device=UpperCAmelCase_   ).manual_seed(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     {
           "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 					_A							(					self							:						int   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     "cpu"  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE							:   List[str]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     TextToVideoSDPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[str]						    =     sd_pipe.to(UpperCAmelCase_   )
       sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   str						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     "np"
       SCREAMING_SNAKE_CASE							:   Any						    =     sd_pipe(**UpperCAmelCase_   ).frames
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     frames[0][-3:, -3:, -1]

       assert frames[0].shape == (64, 64, 3)
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     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 					_A							(					self							:						List[str]   ):
       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 					_A							(					self							:						List[Any]   ):
       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 					_A							(					self							:						Dict   ):
       pass


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


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






     def 					_A							(					self							:						Any   ):
       return super().test_progress_bar()





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


     def 					_A							(					self							:						int   ):
       SCREAMING_SNAKE_CASE							:   Any						    =     load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"   )

       SCREAMING_SNAKE_CASE							:   Dict						    =     TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"   )
       SCREAMING_SNAKE_CASE							:   str						    =     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config   )
       SCREAMING_SNAKE_CASE							:   Any						    =     pipe.to("cuda"   )

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     "Spiderman is surfing"
       SCREAMING_SNAKE_CASE							:   Dict						    =     torch.Generator(device="cpu"   ).manual_seed(0   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     pipe(UpperCAmelCase_       ,			generator=UpperCAmelCase_       ,			num_inference_steps=25       ,			output_type="pt"   ).frames
       SCREAMING_SNAKE_CASE							:   Any						    =     video_frames.cpu().numpy()

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






     def 					_A							(					self							:						List[str]   ):
       SCREAMING_SNAKE_CASE							:   str						    =     load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"   )

       SCREAMING_SNAKE_CASE							:   int						    =     TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"   )
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     pipe.to("cuda"   )

       SCREAMING_SNAKE_CASE							:   Tuple						    =     "Spiderman is surfing"
       SCREAMING_SNAKE_CASE							:   Tuple						    =     torch.Generator(device="cpu"   ).manual_seed(0   )

       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     pipe(UpperCAmelCase_       ,			generator=UpperCAmelCase_       ,			num_inference_steps=2       ,			output_type="pt"   ).frames
       SCREAMING_SNAKE_CASE							:   str						    =     video_frames.cpu().numpy()

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













def  __magic_name__  (				lowercase				)				-> list:

							"""simple docstring"""



							if n_term == "":
														return []
							lowercase_	:   list  				=     []
							for temp in range(int(lowercase				)				):
														series.append(f"""1/{temp + 1}""" if series else """1"""				)
							return series


if __name__ == "__main__":
							UpperCAmelCase_							=				input("""Enter the last number (nth term) of the Harmonic Series""")
							print("""Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n""")
							print(harmonic_series(nth_term))