


'''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   __snake_case			(  _SCREAMING_SNAKE_CASE      ,unittest.TestCase):







    """simple docstring"""



    lowercase  					=   ShapEPipeline
    lowercase  					=   ['prompt']
    lowercase  					=   ['prompt']
    lowercase  					=   [
        'num_images_per_prompt',
        'num_inference_steps',
        'generator',
        'latents',
        'guidance_scale',
        'frame_size',
        'output_type',
        'return_dict',
    ]
    lowercase  					=   False

    @property
    def __lowercase  (  self       :    Tuple						)  ->    Tuple:
      return 32

    @property
    def __lowercase  (  self       :    int						)  ->    Dict:
      return 32

    @property
    def __lowercase  (  self       :    List[str]						)  ->    List[Any]:
      return self.time_input_dim * 4

    @property
    def __lowercase  (  self       :    Union[str, Any]						)  ->    List[str]:
      return 8

    @property
    def __lowercase  (  self       :    List[Any]						)  ->    Optional[Any]:
      lowerCAmelCase_     : Tuple     =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)
      return tokenizer

    @property
    def __lowercase  (  self       :    int						)  ->    List[Any]:
      torch.manual_seed(0						)
      lowerCAmelCase_     : Optional[int]     =  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=10_00       ,		)
      return CLIPTextModelWithProjection(lowerCamelCase						)

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

      lowerCAmelCase_     : Union[str, 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""",
          """encoder_hid_proj_type""": None,
          """added_emb_type""": None,
      }

      lowerCAmelCase_     : Union[str, Any]     =  PriorTransformer(**lowerCamelCase						)
      return model

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

      lowerCAmelCase_     : 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,
          ),
      }
      lowerCAmelCase_     : Optional[int]     =  ShapERenderer(**lowerCamelCase						)
      return model

    def __lowercase  (  self       :    Optional[Any]						)  ->    str:
      lowerCAmelCase_     : Union[str, Any]     =  self.dummy_prior
      lowerCAmelCase_     : Any     =  self.dummy_text_encoder
      lowerCAmelCase_     : Any     =  self.dummy_tokenizer
      lowerCAmelCase_     : List[str]     =  self.dummy_renderer

      lowerCAmelCase_     : List[Any]     =  HeunDiscreteScheduler(
          beta_schedule="""exp"""       ,		num_train_timesteps=10_24       ,		prediction_type="""sample"""       ,		use_karras_sigmas=lowerCamelCase       ,		clip_sample=lowerCamelCase       ,		clip_sample_range=1.0       ,		)
      lowerCAmelCase_     : Dict     =  {
          """prior""": prior,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """renderer""": renderer,
          """scheduler""": scheduler,
      }

      return components

    def __lowercase  (  self       :    Dict       ,		lowerCamelCase       :    List[Any]       ,		lowerCamelCase       :    Any=0						)  ->    Dict:
      if str(lowerCamelCase						).startswith("""mps"""						):
        lowerCAmelCase_     : Tuple     =  torch.manual_seed(lowerCamelCase						)
      else:
        lowerCAmelCase_     : Dict     =  torch.Generator(device=lowerCamelCase						).manual_seed(lowerCamelCase						)
      lowerCAmelCase_     : str     =  {
          """prompt""": """horse""",
          """generator""": generator,
          """num_inference_steps""": 1,
          """frame_size""": 32,
          """output_type""": """np""",
      }
      return inputs

    def __lowercase  (  self       :    List[str]						)  ->    Any:
      lowerCAmelCase_     : Optional[int]     =  """cpu"""

      lowerCAmelCase_     : Any     =  self.get_dummy_components()

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

      pipe.set_progress_bar_config(disable=lowerCamelCase						)

      lowerCAmelCase_     : List[str]     =  pipe(**self.get_dummy_inputs(lowerCamelCase						)						)
      lowerCAmelCase_     : Tuple     =  output.images[0]
      lowerCAmelCase_     : Dict     =  image[0, -3:, -3:, -1]

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

      lowerCAmelCase_     : Optional[Any]     =  np.array(
          [
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
              0.00_039_216,
          ]						)

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

    def __lowercase  (  self       :    List[str]						)  ->    Optional[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 __lowercase  (  self       :    Union[str, Any]						)  ->    str:
      lowerCAmelCase_     : Optional[Any]     =  torch_device == """cpu"""
      lowerCAmelCase_     : Dict     =  True

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





    def __lowercase  (  self       :    str						)  ->    str:
      lowerCAmelCase_     : Optional[Any]     =  self.get_dummy_components()
      lowerCAmelCase_     : List[str]     =  self.pipeline_class(**lowerCamelCase						)
      lowerCAmelCase_     : List[Any]     =  pipe.to(lowerCamelCase						)
      pipe.set_progress_bar_config(disable=lowerCamelCase						)

      lowerCAmelCase_     : Optional[int]     =  1
      lowerCAmelCase_     : Dict     =  2

      lowerCAmelCase_     : str     =  self.get_dummy_inputs(lowerCamelCase						)

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

      lowerCAmelCase_     : Any     =  pipe(**lowerCamelCase       ,		num_images_per_prompt=lowerCamelCase						)[0]

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







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







    """simple docstring"""



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





    def __lowercase  (  self       :    List[str]						)  ->    Union[str, Any]:
      lowerCAmelCase_     : Any     =  load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/shap_e/test_shap_e_np_out.npy"""						)
      lowerCAmelCase_     : List[Any]     =  ShapEPipeline.from_pretrained("""openai/shap-e"""						)
      lowerCAmelCase_     : Dict     =  pipe.to(lowerCamelCase						)
      pipe.set_progress_bar_config(disable=lowerCamelCase						)

      lowerCAmelCase_     : Optional[Any]     =  torch.Generator(device=lowerCamelCase						).manual_seed(0						)

      lowerCAmelCase_     : Union[str, Any]     =  pipe(
          """a shark"""       ,		generator=lowerCamelCase       ,		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(lowerCamelCase       ,		lowerCamelCase						)







'''simple docstring'''






from maths.is_square_free import is_square_free
from maths.prime_factors import prime_factors







def 							UpperCamelCase_     (       A__   :  int   ):
  '''simple docstring'''





  lowerCAmelCase_     : Any     =  prime_factors(A__   )
  if is_square_free(A__   ):
    return -1 if len(A__   ) % 2 else 1
  return 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()



