




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     __a(	_a							,		unittest.TestCase  ):






    """simple docstring"""





    lowerCAmelCase         = ShapEImgaImgPipeline
    lowerCAmelCase         = ['''image''']
    lowerCAmelCase         = ['''image''']
    lowerCAmelCase         = [
        '''num_images_per_prompt''',
        '''num_inference_steps''',
        '''generator''',
        '''latents''',
        '''guidance_scale''',
        '''frame_size''',
        '''output_type''',
        '''return_dict''',
    ]
    lowerCAmelCase         = False





    @property
    def 				a__ ( self    )					->						Optional[int]:
         return 32





    @property
    def 				a__ ( self    )					->						str:
         return 32





    @property
    def 				a__ ( self    )					->						Any:
         return self.time_input_dim * 4





    @property
    def 				a__ ( self    )					->						Tuple:
         return 8





    @property
    def 				a__ ( self    )					->						Any:
         torch.manual_seed(0    )
         UpperCAmelCase_     :				List[Any]  =     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  ,)

         UpperCAmelCase_     :				str  =     CLIPVisionModel(_SCREAMING_SNAKE_CASE    )
         return model





    @property
    def 				a__ ( self    )					->						Tuple:
         UpperCAmelCase_     :				List[Any]  =     CLIPImageProcessor(
             crop_size=224  ,do_center_crop=_SCREAMING_SNAKE_CASE  ,do_normalize=_SCREAMING_SNAKE_CASE  ,do_resize=_SCREAMING_SNAKE_CASE  ,image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]  ,image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]  ,resample=3  ,size=224  ,)

         return image_processor





    @property
    def 				a__ ( self    )					->						Optional[Any]:
         torch.manual_seed(0    )

         UpperCAmelCase_     :				Optional[Any]  =     {
             '''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,
         }

         UpperCAmelCase_     :				str  =     PriorTransformer(**_SCREAMING_SNAKE_CASE    )
         return model





    @property
    def 				a__ ( self    )					->						Optional[int]:
         torch.manual_seed(0    )

         UpperCAmelCase_     :				List[str]  =     {
             '''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,
             ),
         }
         UpperCAmelCase_     :				List[str]  =     ShapERenderer(**_SCREAMING_SNAKE_CASE    )
         return model





    def 				a__ ( self    )					->						Optional[Any]:
         UpperCAmelCase_     :				str  =     self.dummy_prior
         UpperCAmelCase_     :				str  =     self.dummy_image_encoder
         UpperCAmelCase_     :				Union[str, Any]  =     self.dummy_image_processor
         UpperCAmelCase_     :				Tuple  =     self.dummy_renderer

         UpperCAmelCase_     :				Optional[Any]  =     HeunDiscreteScheduler(
             beta_schedule='''exp'''  ,num_train_timesteps=1_024  ,prediction_type='''sample'''  ,use_karras_sigmas=_SCREAMING_SNAKE_CASE  ,clip_sample=_SCREAMING_SNAKE_CASE  ,clip_sample_range=1.0  ,)
         UpperCAmelCase_     :				Optional[int]  =     {
             '''prior''': prior,
             '''image_encoder''': image_encoder,
             '''image_processor''': image_processor,
             '''renderer''': renderer,
             '''scheduler''': scheduler,
         }

         return components





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE=0    )					->						Any:
         UpperCAmelCase_     :				List[Any]  =     floats_tensor((1, 3, 64, 64)  ,rng=random.Random(_SCREAMING_SNAKE_CASE    )    ).to(_SCREAMING_SNAKE_CASE    )

         if str(_SCREAMING_SNAKE_CASE    ).startswith('''mps'''    ):
              UpperCAmelCase_     :				int  =     torch.manual_seed(_SCREAMING_SNAKE_CASE    )
         else:
              UpperCAmelCase_     :				List[str]  =     torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				int  =     {
             '''image''': input_image,
             '''generator''': generator,
             '''num_inference_steps''': 1,
             '''frame_size''': 32,
             '''output_type''': '''np''',
         }
         return inputs





    def 				a__ ( self    )					->						Tuple:
         UpperCAmelCase_     :				List[str]  =     '''cpu'''

         UpperCAmelCase_     :				int  =     self.get_dummy_components()

         UpperCAmelCase_     :				Union[str, Any]  =     self.pipeline_class(**_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				List[Any]  =     pipe.to(_SCREAMING_SNAKE_CASE    )

         pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				Tuple  =     pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE    )    )
         UpperCAmelCase_     :				Optional[Any]  =     output.images[0]
         UpperCAmelCase_     :				Tuple  =     image[0, -3:, -3:, -1]

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

         UpperCAmelCase_     :				Dict  =     np.array(
             [
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
                 0.00_03_92_16,
             ]    )

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





    def 				a__ ( 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 				a__ ( self    )					->						Optional[Any]:
         UpperCAmelCase_     :				List[Any]  =     torch_device == '''cpu'''
         UpperCAmelCase_     :				List[str]  =     True
         self._test_inference_batch_single_identical(
             batch_size=2  ,test_max_difference=_SCREAMING_SNAKE_CASE  ,relax_max_difference=_SCREAMING_SNAKE_CASE  ,)





    def 				a__ ( self    )					->						str:
         UpperCAmelCase_     :				List[str]  =     self.get_dummy_components()
         UpperCAmelCase_     :				Any  =     self.pipeline_class(**_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				List[Any]  =     pipe.to(_SCREAMING_SNAKE_CASE    )
         pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				Any  =     1
         UpperCAmelCase_     :				Union[str, Any]  =     2

         UpperCAmelCase_     :				Optional[int]  =     self.get_dummy_inputs(_SCREAMING_SNAKE_CASE    )

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

         UpperCAmelCase_     :				int  =     pipe(**_SCREAMING_SNAKE_CASE  ,num_images_per_prompt=_SCREAMING_SNAKE_CASE    )[0]

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


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






    """simple docstring"""





    def 				a__ ( self    )					->						int:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





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

         UpperCAmelCase_     :				Any  =     torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(0    )

         UpperCAmelCase_     :				str  =     pipe(
             _SCREAMING_SNAKE_CASE  ,generator=_SCREAMING_SNAKE_CASE  ,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(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )

def  __lowerCamelCase					( _lowercase = 50000000			)       ->      int:
     UpperCamelCase						    =					set()
     UpperCamelCase						    =					int((limit - 24) ** (1 / 2)			)

     UpperCamelCase						    =					set(range(3						,     prime_square_limit + 1						,     2			)			)
     primes.add(2			)
     for p in range(3						,     prime_square_limit + 1						,     2			):
          if p not in primes:
               continue
          primes.difference_update(set(range(p * p						,     prime_square_limit + 1						,     _lowercase			)			)			)

     for primea in primes:
          UpperCamelCase						    =					primea * primea
          for primea in primes:
               UpperCamelCase						    =					primea * primea * primea
               if square + cube >= limit - 16:
                    break
               for primea in primes:
                    UpperCamelCase						    =					primea * primea * primea * primea
                    UpperCamelCase						    =					square + cube + tetr
                    if total >= limit:
                         break
                    ret.add(_lowercase			)

     return len(_lowercase			)


if __name__ == "__main__":
 print(F"{solution() = }")


