



"""simple docstring"""






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 	__snake_case	(     _lowercase  ,					unittest.TestCase):
  snake_case__    :       Dict        =						TextToVideoSDPipeline
  snake_case__    :       List[Any]        =						TEXT_TO_IMAGE_PARAMS
  snake_case__    :       Union[str, Any]        =						TEXT_TO_IMAGE_BATCH_PARAMS
  # No `output_type`.
  snake_case__    :       List[Any]        =						frozenset(
      [
          "num_inference_steps",
          "generator",
          "latents",
          "return_dict",
          "callback",
          "callback_steps",
      ])




  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         torch.manual_seed(0		)
         _lowerCamelCase						:    Tuple         =			UNetaDConditionModel(
             block_out_channels=(3_2, 6_4, 6_4, 6_4)						, layers_per_block=2						, sample_size=3_2						, in_channels=4						, out_channels=4						, down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''')						, up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''')						, cross_attention_dim=3_2						, attention_head_dim=4						, )
         _lowerCamelCase						:    Tuple         =			DDIMScheduler(
             beta_start=0.0_00_85						, beta_end=0.0_12						, beta_schedule='''scaled_linear'''						, clip_sample=__lowerCAmelCase						, set_alpha_to_one=__lowerCAmelCase						, )
         torch.manual_seed(0		)
         _lowerCamelCase						:    int         =			AutoencoderKL(
             block_out_channels=[3_2, 6_4]						, in_channels=3						, out_channels=3						, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']						, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']						, latent_channels=4						, sample_size=1_2_8						, )
         torch.manual_seed(0		)
         _lowerCamelCase						:    Tuple         =			CLIPTextConfig(
             bos_token_id=0						, eos_token_id=2						, hidden_size=3_2						, intermediate_size=3_7						, layer_norm_eps=1E-05						, num_attention_heads=4						, num_hidden_layers=5						, pad_token_id=1						, vocab_size=1_0_0_0						, hidden_act='''gelu'''						, projection_dim=5_1_2						, )
         _lowerCamelCase						:    Any         =			CLIPTextModel(__lowerCAmelCase		)
         _lowerCamelCase						:    str         =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						List[Any]=0		):






         """simple docstring"""






         if str(__lowerCAmelCase		).startswith('''mps'''		):
                _lowerCamelCase						:    int         =			torch.manual_seed(__lowerCAmelCase		)
         else:
                _lowerCamelCase						:    List[Any]         =			torch.Generator(device=__lowerCAmelCase		).manual_seed(__lowerCAmelCase		)
         _lowerCamelCase						:    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 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
         _lowerCamelCase						:    int         =			self.get_dummy_components()
         _lowerCamelCase						:    Dict         =			TextToVideoSDPipeline(**__lowerCAmelCase		)
         _lowerCamelCase						:    List[Any]         =			sd_pipe.to(__lowerCAmelCase		)
         sd_pipe.set_progress_bar_config(disable=__lowerCAmelCase		)

         _lowerCamelCase						:    Optional[int]         =			self.get_dummy_inputs(__lowerCAmelCase		)
         _lowerCamelCase						:    Dict         =			'''np'''
         _lowerCamelCase						:    Optional[Any]         =			sd_pipe(**__lowerCAmelCase		).frames
         _lowerCamelCase						:    int         =			frames[0][-3:, -3:, -1]

         assert frames[0].shape == (6_4, 6_4, 3)
         _lowerCamelCase						:    List[Any]         =			np.array([1_58.0, 1_60.0, 1_53.0, 1_25.0, 1_00.0, 1_21.0, 1_11.0, 93.0, 1_13.0]		)

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






         self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__lowerCAmelCase						, 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					:						Tuple		):






         """simple docstring"""






         self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__lowerCAmelCase						, expected_max_diff=1E-2		)




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






         """simple docstring"""






         pass




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






         """simple docstring"""






         pass




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






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         return super().test_progress_bar()






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




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''		)

         _lowerCamelCase						:    List[Any]         =			TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''		)
         _lowerCamelCase						:    Tuple         =			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
         _lowerCamelCase						:    str         =			pipe.to('''cuda'''		)

         _lowerCamelCase						:    List[str]         =			'''Spiderman is surfing'''
         _lowerCamelCase						:    Tuple         =			torch.Generator(device='''cpu'''		).manual_seed(0		)

         _lowerCamelCase						:    Dict         =			pipe(__lowerCAmelCase						, generator=__lowerCAmelCase						, num_inference_steps=2_5						, output_type='''pt'''		).frames
         _lowerCamelCase						:    str         =			video_frames.cpu().numpy()

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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[int]         =			load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''		)

         _lowerCamelCase						:    Optional[int]         =			TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''		)
         _lowerCamelCase						:    str         =			pipe.to('''cuda'''		)

         _lowerCamelCase						:    List[str]         =			'''Spiderman is surfing'''
         _lowerCamelCase						:    Any         =			torch.Generator(device='''cpu'''		).manual_seed(0		)

         _lowerCamelCase						:    Any         =			pipe(__lowerCAmelCase						, generator=__lowerCAmelCase						, num_inference_steps=2						, output_type='''pt'''		).frames
         _lowerCamelCase						:    List[Any]         =			video_frames.cpu().numpy()

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







"""simple docstring"""






def 	snake_case_  (				A_ :		int						):


       '''simple docstring'''





       return 1 if digit in (0, 1) else (digit * factorial(digit - 1						))






def 	snake_case_  (				A_ :		int						):


       '''simple docstring'''





       _lowerCamelCase						:    str         =			0
       _lowerCamelCase						:    Any         =			number
       while duplicate > 0:
              _lowerCamelCase      ,   _lowerCamelCase						:    Union[str, Any]         =			divmod(A_,    10						)
              fact_sum += factorial(A_						)
       return fact_sum == number


if __name__ == "__main__":
   print('''Program to check whether a number is a Krisnamurthy Number or not.''')
   lowerCAmelCase__      =    int(input('''Enter number: ''').strip())
   print(
       F"""{number} is {"" if krishnamurthy(number) else "not "}a Krishnamurthy Number."""
   )


