


'''simple docstring'''
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        lowerCAmelCase_  (     UpperCAmelCase      ,							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   UpperCamelCase						( self   )->      Optional[int]:
            return 32






       @property
       def   UpperCamelCase						( self   )->      Optional[Any]:
            return 32






       @property
       def   UpperCamelCase						( self   )->      str:
            return self.time_input_dim * 4






       @property
       def   UpperCamelCase						( self   )->      Any:
            return 8






       @property
       def   UpperCamelCase						( self   )->      str:
            torch.manual_seed(0   )
            _A				=							CLIPVisionConfig(
                hidden_size=self.text_embedder_hidden_size			,     image_size=64			,     projection_dim=self.text_embedder_hidden_size			,     intermediate_size=37			,     num_attention_heads=4			,     num_channels=3			,     num_hidden_layers=5			,     patch_size=1			,     )

            _A				=							CLIPVisionModel(_UpperCamelCase   )
            return model






       @property
       def   UpperCamelCase						( self   )->      Union[str, Any]:
            _A				=							CLIPImageProcessor(
                crop_size=224			,     do_center_crop=_UpperCamelCase			,     do_normalize=_UpperCamelCase			,     do_resize=_UpperCamelCase			,     image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]			,     image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]			,     resample=3			,     size=224			,     )

            return image_processor






       @property
       def   UpperCamelCase						( self   )->      Dict:
            torch.manual_seed(0   )

            _A				=							{
                'num_attention_heads': 2,
                'attention_head_dim': 16,
                'embedding_dim': self.time_input_dim,
                'num_embeddings': 32,
                '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,
            }

            _A				=							PriorTransformer(**_UpperCamelCase   )
            return model






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

            _A				=							{
                'param_shapes': (
                    (self.renderer_dim, 93),
                    (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': 12,
                'background': (
                    0.1,
                    0.1,
                    0.1,
                ),
            }
            _A				=							ShapERenderer(**_UpperCamelCase   )
            return model






       def   UpperCamelCase						( self   )->      List[Any]:
            _A				=							self.dummy_prior
            _A				=							self.dummy_image_encoder
            _A				=							self.dummy_image_processor
            _A				=							self.dummy_renderer

            _A				=							HeunDiscreteScheduler(
                beta_schedule='exp'			,     num_train_timesteps=1024			,     prediction_type='sample'			,     use_karras_sigmas=_UpperCamelCase			,     clip_sample=_UpperCamelCase			,     clip_sample_range=1.0			,     )
            _A				=							{
                'prior': prior,
                'image_encoder': image_encoder,
                'image_processor': image_processor,
                'renderer': renderer,
                'scheduler': scheduler,
            }

            return components






       def   UpperCamelCase						( self			,     _UpperCamelCase			,     _UpperCamelCase=0   )->      Any:
            _A				=							floats_tensor((1, 3, 64, 64)			,     rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

            if str(_UpperCamelCase   ).startswith('mps'   ):
                 _A				=							torch.manual_seed(_UpperCamelCase   )
            else:
                 _A				=							torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )
            _A				=							{
                'image': input_image,
                'generator': generator,
                'num_inference_steps': 1,
                'frame_size': 32,
                'output_type': 'np',
            }
            return inputs






       def   UpperCamelCase						( self   )->      str:
            _A				=							'cpu'

            _A				=							self.get_dummy_components()

            _A				=							self.pipeline_class(**_UpperCamelCase   )
            _A				=							pipe.to(_UpperCamelCase   )

            pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            _A				=							pipe(**self.get_dummy_inputs(_UpperCamelCase   )   )
            _A				=							output.images[0]
            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (20, 32, 32, 3)

            _A				=							np.array(
                [
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                    0.0003_9216,
                ]   )

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






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






       def   UpperCamelCase						( self   )->      str:
            _A				=							torch_device == 'cpu'
            _A				=							True
            self._test_inference_batch_single_identical(
                batch_size=2			,     test_max_difference=_UpperCamelCase			,     relax_max_difference=_UpperCamelCase			,     )






       def   UpperCamelCase						( self   )->      Any:
            _A				=							self.get_dummy_components()
            _A				=							self.pipeline_class(**_UpperCamelCase   )
            _A				=							pipe.to(_UpperCamelCase   )
            pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            _A				=							1
            _A				=							2

            _A				=							self.get_dummy_inputs(_UpperCamelCase   )

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

            _A				=							pipe(**_UpperCamelCase			,     num_images_per_prompt=_UpperCamelCase   )[0]

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






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






       def   UpperCamelCase						( self   )->      Union[str, Any]:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()






       def   UpperCamelCase						( self   )->      Tuple:
            _A				=							load_image(
                'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png'   )
            _A				=							load_numpy(
                'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                '/shap_e/test_shap_e_img2img_out.npy'   )
            _A				=							ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img'   )
            _A				=							pipe.to(_UpperCamelCase   )
            pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            _A				=							torch.Generator(device=_UpperCamelCase   ).manual_seed(0   )

            _A				=							pipe(
                _UpperCamelCase			,     generator=_UpperCamelCase			,     guidance_scale=3.0			,     num_inference_steps=64			,     frame_size=64			,     output_type='np'			,     ).images[0]

            assert images.shape == (20, 64, 64, 3)

            assert_mean_pixel_difference(_UpperCamelCase			,     _UpperCamelCase   )









'''simple docstring'''
def 					lowerCamelCase_ ( __UpperCamelCase					:       int		)					->	list:







     """simple docstring"""
     _A				=							int(__UpperCamelCase		)
     if n_element < 1:
          _A				=							ValueError('a should be a positive number'		)
          raise my_error

     _A				=							[1]
     _A		,				_A		,				_A				=							(0, 0, 0)
     _A				=							1
     while index < n_element:
          while hamming_list[i] * 2 <= hamming_list[-1]:
               i += 1
          while hamming_list[j] * 3 <= hamming_list[-1]:
               j += 1
          while hamming_list[k] * 5 <= hamming_list[-1]:
               k += 1
          hamming_list.append(
              min(hamming_list[i] * 2							,    hamming_list[j] * 3							,    hamming_list[k] * 5		)		)
          index += 1
     return hamming_list


if __name__ == "__main__":
    lowerCAmelCase						=					input("""Enter the last number (nth term) of the Hamming Number Series: """)
    print("""Formula of Hamming Number Series => 2^i * 3^j * 5^k""")
    lowerCAmelCase						=					hamming(int(n))
    print("""-----------------------------------------------------""")
    print(F'The list with nth numbers is: {hamming_numbers}')
    print("""-----------------------------------------------------""")





