



"""simple docstring"""





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import 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 				lowercase__       (   __lowercase    , unittest.TestCase				):







     '''simple docstring'''


     UpperCamelCase						=					ShapEPipeline
     UpperCamelCase						=					["prompt"]
     UpperCamelCase						=					["prompt"]
     UpperCamelCase						=					[
         "num_images_per_prompt",
         "num_inference_steps",
         "generator",
         "latents",
         "guidance_scale",
         "frame_size",
         "output_type",
         "return_dict",
     ]
     UpperCamelCase						=					False



     @property
     def 					lowercase__    (							self      :  Optional[Any]   )			->						Union[str, Any]:


           '''simple docstring'''




           return 32



     @property
     def 					lowercase__    (							self      :  Dict   )			->						List[Any]:


           '''simple docstring'''




           return 32



     @property
     def 					lowercase__    (							self      :  Union[str, Any]   )			->						Union[str, Any]:


           '''simple docstring'''




           return self.time_input_dim * 4



     @property
     def 					lowercase__    (							self      :  Dict   )			->						Any:


           '''simple docstring'''




           return 8



     @property
     def 					lowercase__    (							self      :  List[str]   )			->						str:


           '''simple docstring'''




           UpperCAmelCase_      			=							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )
           return tokenizer



     @property
     def 					lowercase__    (							self      :  Dict   )			->						Optional[int]:


           '''simple docstring'''




           torch.manual_seed(0   )
           UpperCAmelCase_      			=							CLIPTextConfig(
               bos_token_id=0		,    eos_token_id=2		,    hidden_size=self.text_embedder_hidden_size		,    projection_dim=self.text_embedder_hidden_size		,    intermediate_size=37		,    layer_norm_eps=1e-05		,    num_attention_heads=4		,    num_hidden_layers=5		,    pad_token_id=1		,    vocab_size=1000		,    )
           return CLIPTextModelWithProjection(snake_case_   )



     @property
     def 					lowercase__    (							self      :  List[Any]   )			->						str:


           '''simple docstring'''




           torch.manual_seed(0   )

           UpperCAmelCase_      			=							{
               '''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''',
               '''encoder_hid_proj_type''': None,
               '''added_emb_type''': None,
           }

           UpperCAmelCase_      			=							PriorTransformer(**snake_case_   )
           return model



     @property
     def 					lowercase__    (							self      :  Tuple   )			->						int:


           '''simple docstring'''




           torch.manual_seed(0   )

           UpperCAmelCase_      			=							{
               '''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_      			=							ShapERenderer(**snake_case_   )
           return model



     def 					lowercase__    (							self      :  Any   )			->						Any:


           '''simple docstring'''




           UpperCAmelCase_      			=							self.dummy_prior
           UpperCAmelCase_      			=							self.dummy_text_encoder
           UpperCAmelCase_      			=							self.dummy_tokenizer
           UpperCAmelCase_      			=							self.dummy_renderer

           UpperCAmelCase_      			=							HeunDiscreteScheduler(
               beta_schedule="exp"		,    num_train_timesteps=1024		,    prediction_type="sample"		,    use_karras_sigmas=snake_case_		,    clip_sample=snake_case_		,    clip_sample_range=1.0		,    )
           UpperCAmelCase_      			=							{
               '''prior''': prior,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''renderer''': renderer,
               '''scheduler''': scheduler,
           }

           return components



     def 					lowercase__    (							self      :  str		,    _UpperCAmelCase      :  Dict		,    _UpperCAmelCase      :  Optional[int]=0   )			->						Any:


           '''simple docstring'''




           if str(snake_case_   ).startswith("mps"   ):
                 UpperCAmelCase_      			=							torch.manual_seed(snake_case_   )
           else:
                 UpperCAmelCase_      			=							torch.Generator(device=snake_case_   ).manual_seed(snake_case_   )
           UpperCAmelCase_      			=							{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''num_inference_steps''': 1,
               '''frame_size''': 32,
               '''output_type''': '''np''',
           }
           return inputs



     def 					lowercase__    (							self      :  int   )			->						int:


           '''simple docstring'''




           UpperCAmelCase_      			=							'''cpu'''

           UpperCAmelCase_      			=							self.get_dummy_components()

           UpperCAmelCase_      			=							self.pipeline_class(**snake_case_   )
           UpperCAmelCase_      			=							pipe.to(snake_case_   )

           pipe.set_progress_bar_config(disable=snake_case_   )

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

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

           UpperCAmelCase_      			=							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 					lowercase__    (							self      :  Any   )			->						Any:


           '''simple docstring'''




           self._test_inference_batch_consistent(batch_sizes=[1, 2]   )



     def 					lowercase__    (							self      :  Tuple   )			->						str:


           '''simple docstring'''




           UpperCAmelCase_      			=							torch_device == '''cpu'''
           UpperCAmelCase_      			=							True

           self._test_inference_batch_single_identical(
               batch_size=2		,    test_max_difference=snake_case_		,    relax_max_difference=snake_case_		,    )







     def 					lowercase__    (							self      :  Tuple   )			->						Tuple:


           '''simple docstring'''




           UpperCAmelCase_      			=							self.get_dummy_components()
           UpperCAmelCase_      			=							self.pipeline_class(**snake_case_   )
           UpperCAmelCase_      			=							pipe.to(snake_case_   )
           pipe.set_progress_bar_config(disable=snake_case_   )

           UpperCAmelCase_      			=							1
           UpperCAmelCase_      			=							2

           UpperCAmelCase_      			=							self.get_dummy_inputs(snake_case_   )

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

           UpperCAmelCase_      			=							pipe(**snake_case_		,    num_images_per_prompt=snake_case_   )[0]

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



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







     '''simple docstring'''


     def 					lowercase__    (							self      :  Dict   )			->						int:


           '''simple docstring'''




           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()







     def 					lowercase__    (							self      :  str   )			->						Tuple:


           '''simple docstring'''




           UpperCAmelCase_      			=							load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/shap_e/test_shap_e_np_out.npy"   )
           UpperCAmelCase_      			=							ShapEPipeline.from_pretrained("openai/shap-e"   )
           UpperCAmelCase_      			=							pipe.to(snake_case_   )
           pipe.set_progress_bar_config(disable=snake_case_   )

           UpperCAmelCase_      			=							torch.Generator(device=snake_case_   ).manual_seed(0   )

           UpperCAmelCase_      			=							pipe(
               "a shark"		,    generator=snake_case_		,    guidance_scale=15.0		,    num_inference_steps=64		,    frame_size=64		,    output_type="np"		,    ).images[0]

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

           assert_mean_pixel_difference(snake_case_		,    snake_case_   )









"""simple docstring"""





from maths.prime_check import is_prime
def        a__     (				lowerCAmelCase__				):
      if not isinstance(lowerCAmelCase__     ,      lowerCAmelCase__				):
            UpperCAmelCase_      			=							f"""Input value of [number={number}] must be an integer"""
            raise TypeError(lowerCAmelCase__				)
      if is_prime(lowerCAmelCase__				) and is_prime(number + 2				):
            return number + 2
      else:
            return -1


if __name__ == "__main__":
  import doctest

  doctest.testmod()




