

def       a__					(		UpperCAmelCase							:      int      )  ->						bool:
		return sum(i for i in range(1    ,			number // 2 + 1      ) if number % i == 0      ) == number


if __name__ == "__main__":
					print("Program to check whether a number is a Perfect number or not...")
					_lowerCamelCase    :       Any        =							int(input("Enter number: ").strip())
					print(f"""{number} is {"" if perfect(number) else "not "}a Perfect Number.""")








import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference





class  __UpperCAmelCase					(	lowerCamelCase__      ,  unittest.TestCase						):
   UpperCamelCase       					=					ShapEImgaImgPipeline
   UpperCamelCase       					=					["""image"""]
   UpperCamelCase       					=					["""image"""]
   UpperCamelCase       					=					[
       """num_images_per_prompt""",
       """num_inference_steps""",
       """generator""",
       """latents""",
       """guidance_scale""",
       """frame_size""",
       """output_type""",
       """return_dict""",
   ]
   UpperCamelCase       					=					False



   @property
   def 	__magic_name__   (							self							:					Optional[Any]						):
     return 3_2



   @property
   def 	__magic_name__   (							self							:					Optional[int]						):
     return 3_2



   @property
   def 	__magic_name__   (							self							:					Union[str, Any]						):
     return self.time_input_dim * 4



   @property
   def 	__magic_name__   (							self							:					Any						):
     return 8



   @property
   def 	__magic_name__   (							self							:					List[str]						):
     torch.manual_seed(0						)
     UpperCAmelCase	:							str						=			CLIPVisionConfig(
         hidden_size=self.text_embedder_hidden_size,		image_size=6_4,		projection_dim=self.text_embedder_hidden_size,		intermediate_size=3_7,		num_attention_heads=4,		num_channels=3,		num_hidden_layers=5,		patch_size=1,		)

     UpperCAmelCase	:							Any						=			CLIPVisionModel(__A						)
     return model



   @property
   def 	__magic_name__   (							self							:					int						):
     UpperCAmelCase	:							Optional[int]						=			CLIPImageProcessor(
         crop_size=2_2_4,		do_center_crop=__A,		do_normalize=__A,		do_resize=__A,		image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],		image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],		resample=3,		size=2_2_4,		)

     return image_processor



   @property
   def 	__magic_name__   (							self							:					Dict						):
     torch.manual_seed(0						)

     UpperCAmelCase	:							Any						=			{
         '''num_attention_heads''': 2,
         '''attention_head_dim''': 1_6,
         '''embedding_dim''': self.time_input_dim,
         '''num_embeddings''': 3_2,
         '''embedding_proj_dim''': self.text_embedder_hidden_size,
         '''time_embed_dim''': self.time_embed_dim,
         '''num_layers''': 1,
         '''clip_embed_dim''': self.time_input_dim * 2,
         '''additional_embeddings''': 0,
         '''time_embed_act_fn''': '''gelu''',
         '''norm_in_type''': '''layer''',
         '''embedding_proj_norm_type''': '''layer''',
         '''encoder_hid_proj_type''': None,
         '''added_emb_type''': None,
     }

     UpperCAmelCase	:							List[Any]						=			PriorTransformer(**__A						)
     return model



   @property
   def 	__magic_name__   (							self							:					Union[str, Any]						):
     torch.manual_seed(0						)

     UpperCAmelCase	:							List[Any]						=			{
         '''param_shapes''': (
             (self.renderer_dim, 9_3),
             (self.renderer_dim, 8),
             (self.renderer_dim, 8),
             (self.renderer_dim, 8),
         ),
         '''d_latent''': self.time_input_dim,
         '''d_hidden''': self.renderer_dim,
         '''n_output''': 1_2,
         '''background''': (
             0.1,
             0.1,
             0.1,
         ),
     }
     UpperCAmelCase	:							List[str]						=			ShapERenderer(**__A						)
     return model



   def 	__magic_name__   (							self							:					List[Any]						):
     UpperCAmelCase	:							str						=			self.dummy_prior
     UpperCAmelCase	:							List[str]						=			self.dummy_image_encoder
     UpperCAmelCase	:							List[Any]						=			self.dummy_image_processor
     UpperCAmelCase	:							Dict						=			self.dummy_renderer

     UpperCAmelCase	:							int						=			HeunDiscreteScheduler(
         beta_schedule='''exp''',		num_train_timesteps=1_0_2_4,		prediction_type='''sample''',		use_karras_sigmas=__A,		clip_sample=__A,		clip_sample_range=1.0,		)
     UpperCAmelCase	:							List[str]						=			{
         '''prior''': prior,
         '''image_encoder''': image_encoder,
         '''image_processor''': image_processor,
         '''renderer''': renderer,
         '''scheduler''': scheduler,
     }

     return components



   def 	__magic_name__   (							self							:					List[Any],		__A							:					Dict,		__A							:					List[Any]=0						):
     UpperCAmelCase	:							int						=			floats_tensor((1, 3, 6_4, 6_4),		rng=random.Random(__A						)						).to(__A						)

     if str(__A						).startswith('''mps'''						):
       UpperCAmelCase	:							List[str]						=			torch.manual_seed(__A						)
     else:
       UpperCAmelCase	:							Optional[Any]						=			torch.Generator(device=__A						).manual_seed(__A						)
     UpperCAmelCase	:							Dict						=			{
         '''image''': input_image,
         '''generator''': generator,
         '''num_inference_steps''': 1,
         '''frame_size''': 3_2,
         '''output_type''': '''np''',
     }
     return inputs



   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							Dict						=			'''cpu'''

     UpperCAmelCase	:							Any						=			self.get_dummy_components()

     UpperCAmelCase	:							Tuple						=			self.pipeline_class(**__A						)
     UpperCAmelCase	:							Dict						=			pipe.to(__A						)

     pipe.set_progress_bar_config(disable=__A						)

     UpperCAmelCase	:							List[Any]						=			pipe(**self.get_dummy_inputs(__A						)						)
     UpperCAmelCase	:							Any						=			output.images[0]
     UpperCAmelCase	:							List[str]						=			image[0, -3:, -3:, -1]

     assert image.shape == (2_0, 3_2, 3_2, 3)

     UpperCAmelCase	:							Optional[int]						=			np.array(
         [
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
         ]						)

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



   def 	__magic_name__   (							self							:					Dict						):
     # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
     self._test_inference_batch_consistent(batch_sizes=[1, 2]						)



   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							Tuple						=			torch_device == '''cpu'''
     UpperCAmelCase	:							List[Any]						=			True
     self._test_inference_batch_single_identical(
         batch_size=2,		test_max_difference=__A,		relax_max_difference=__A,		)





   def 	__magic_name__   (							self							:					Dict						):
     UpperCAmelCase	:							Dict						=			self.get_dummy_components()
     UpperCAmelCase	:							Union[str, Any]						=			self.pipeline_class(**__A						)
     UpperCAmelCase	:							List[str]						=			pipe.to(__A						)
     pipe.set_progress_bar_config(disable=__A						)

     UpperCAmelCase	:							Any						=			1
     UpperCAmelCase	:							Any						=			2

     UpperCAmelCase	:							Optional[int]						=			self.get_dummy_inputs(__A						)

     for key in inputs.keys():
       if key in self.batch_params:
         UpperCAmelCase	:							Any						=			batch_size * [inputs[key]]

     UpperCAmelCase	:							int						=			pipe(**__A,		num_images_per_prompt=__A						)[0]

     assert images.shape[0] == batch_size * num_images_per_prompt






@slow
@require_torch_gpu
class  __UpperCAmelCase					(	unittest.TestCase						):



   def 	__magic_name__   (							self							:					List[Any]						):
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()





   def 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							List[str]						=			load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''						)
     UpperCAmelCase	:							Dict						=			load_numpy(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/shap_e/test_shap_e_img2img_out.npy'''						)
     UpperCAmelCase	:							Union[str, Any]						=			ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''						)
     UpperCAmelCase	:							int						=			pipe.to(__A						)
     pipe.set_progress_bar_config(disable=__A						)

     UpperCAmelCase	:							Dict						=			torch.Generator(device=__A						).manual_seed(0						)

     UpperCAmelCase	:							List[str]						=			pipe(
         __A,		generator=__A,		guidance_scale=3.0,		num_inference_steps=6_4,		frame_size=6_4,		output_type='''np''',		).images[0]

     assert images.shape == (2_0, 6_4, 6_4, 3)

     assert_mean_pixel_difference(__A,		__A						)





