




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       a__	( UpperCamelCase__       , unittest.TestCase				):
     a		:      Optional[int]		 =     ShapEPipeline
     a		:      Union[str, Any]		 =     ["""prompt"""]
     a		:      Tuple		 =     ["""prompt"""]
     a		:      Union[str, Any]		 =     [
         """num_images_per_prompt""",
         """num_inference_steps""",
         """generator""",
         """latents""",
         """guidance_scale""",
         """frame_size""",
         """output_type""",
         """return_dict""",
     ]
     a		:      Tuple		 =     False







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



          '''simple docstring'''



          return 32







     @property
     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''simple docstring'''



          return 32







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



          '''simple docstring'''



          return self.time_input_dim * 4







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



          '''simple docstring'''



          return 8







     @property
     def       lowerCAmelCase_    (     self			)  ->   str:



          '''simple docstring'''



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







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



          '''simple docstring'''



          torch.manual_seed(0			)
          a     =				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(A			)







     @property
     def       lowerCAmelCase_    (     self			)  ->   Optional[Any]:



          '''simple docstring'''



          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",
              "encoder_hid_proj_type": None,
              "added_emb_type": None,
          }

          a     =				PriorTransformer(**A			)
          return model







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



          '''simple docstring'''



          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(**A			)
          return model







     def       lowerCAmelCase_    (     self			)  ->   Union[str, Any]:



          '''simple docstring'''



          a     =				self.dummy_prior
          a     =				self.dummy_text_encoder
          a     =				self.dummy_tokenizer
          a     =				self.dummy_renderer

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

          return components







     def       lowerCAmelCase_    (     self  ,		A  ,		A=0			)  ->   int:



          '''simple docstring'''



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







     def       lowerCAmelCase_    (     self			)  ->   Dict:



          '''simple docstring'''



          a     =				"cpu"

          a     =				self.get_dummy_components()

          a     =				self.pipeline_class(**A			)
          a     =				pipe.to(A			)

          pipe.set_progress_bar_config(disable=A			)

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

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

          a     =				np.array(
              [
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
                  0.0_0_0_3_9_2_1_6,
              ]			)

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







     def       lowerCAmelCase_    (     self			)  ->   Any:



          '''simple docstring'''



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







     def       lowerCAmelCase_    (     self			)  ->   Any:



          '''simple docstring'''



          a     =				torch_device == "cpu"
          a     =				True

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







     def       lowerCAmelCase_    (     self			)  ->   List[str]:



          '''simple docstring'''



          a     =				self.get_dummy_components()
          a     =				self.pipeline_class(**A			)
          a     =				pipe.to(A			)
          pipe.set_progress_bar_config(disable=A			)

          a     =				1
          a     =				2

          a     =				self.get_dummy_inputs(A			)

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

          a     =				pipe(**A  ,		num_images_per_prompt=A			)[0]

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







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







     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''simple docstring'''



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







     def       lowerCAmelCase_    (     self			)  ->   List[str]:



          '''simple docstring'''



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

          a     =				torch.Generator(device=A			).manual_seed(0			)

          a     =				pipe(
              "a shark"  ,		generator=A  ,		guidance_scale=1_5.0  ,		num_inference_steps=64  ,		frame_size=64  ,		output_type="np"  ,		).images[0]

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

          assert_mean_pixel_difference(A  ,		A			)







import math

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					bool:

     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5		, int(math.sqrt(__UpperCamelCase) + 1)		, 6):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase = 0.1)      ->					int:
     a     =				3
     a     =				3

     while primes / (2 * j - 1) >= ratio:
          for i in range(j * j + j + 1		, (j + 2) * (j + 2)		, j + 1):
               primes += is_prime(__UpperCamelCase)
          j += 2
     return j


if __name__ == "__main__":
   import doctest

   doctest.testmod()

