


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 						_UpperCAmelCase      (     _SCREAMING_SNAKE_CASE		,		unittest.TestCase							):
		lowerCamelCase_	:			Any       			=  ShapEPipeline
		lowerCamelCase_	:			Any       			=  ["""prompt"""]
		lowerCamelCase_	:			Optional[int]       			=  ["""prompt"""]
		lowerCamelCase_	:			List[str]       			=  [
		    """num_images_per_prompt""",
		    """num_inference_steps""",
		    """generator""",
		    """latents""",
		    """guidance_scale""",
		    """frame_size""",
		    """output_type""",
		    """return_dict""",
		]
		lowerCamelCase_	:			str       			=  False






		@property
		def _snake_case		(						self				:     Tuple):
				return 32






		@property
		def _snake_case		(						self				:     int):
				return 32






		@property
		def _snake_case		(						self				:     List[str]):
				return self.time_input_dim * 4






		@property
		def _snake_case		(						self				:     Union[str, Any]):
				return 8






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






		@property
		def _snake_case		(						self				:     int):
				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				: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(UpperCAmelCase)






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

				SCREAMING_SNAKE_CASE_				: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,
				}

				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						PriorTransformer(**UpperCAmelCase)
				return model






		@property
		def _snake_case		(						self				:     str):
				torch.manual_seed(0)

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






		def _snake_case		(						self				:     Optional[Any]):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						self.dummy_prior
				SCREAMING_SNAKE_CASE_				:Any				     =						self.dummy_text_encoder
				SCREAMING_SNAKE_CASE_				:Any				     =						self.dummy_tokenizer
				SCREAMING_SNAKE_CASE_				:List[str]				     =						self.dummy_renderer

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

				return components






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






		def _snake_case		(						self				:     List[str]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						"""cpu"""

				SCREAMING_SNAKE_CASE_				:Any				     =						self.get_dummy_components()

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

				pipe.set_progress_bar_config(disable=UpperCAmelCase)

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

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

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						np.array(
				    [
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				        0.00039216,
				    ])

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






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






		def _snake_case		(						self				:     Union[str, Any]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						torch_device == """cpu"""
				SCREAMING_SNAKE_CASE_				:Dict				     =						True

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







		def _snake_case		(						self				:     str):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.get_dummy_components()
				SCREAMING_SNAKE_CASE_				:List[str]				     =						self.pipeline_class(**UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						pipe.to(UpperCAmelCase)
				pipe.set_progress_bar_config(disable=UpperCAmelCase)

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

				SCREAMING_SNAKE_CASE_				:str				     =						self.get_dummy_inputs(UpperCAmelCase)

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

				SCREAMING_SNAKE_CASE_				:Any				     =						pipe(**UpperCAmelCase   ,  num_images_per_prompt=UpperCAmelCase)[0]

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




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






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







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

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						torch.Generator(device=UpperCAmelCase).manual_seed(0)

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










'''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()



