
"""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						(       lowerCAmelCase_	,   unittest.TestCase				):


     '''simple docstring'''





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



     @property
     def  lowerCAmelCase__       (      self  )->					List[str]:
          return 32



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



     @property
     def  lowerCAmelCase__       (      self  )->					Optional[Any]:
          return self.time_input_dim * 4



     @property
     def  lowerCAmelCase__       (      self  )->					Optional[Any]:
          return 8



     @property
     def  lowerCAmelCase__       (      self  )->					List[str]:
          UpperCAmelCase__							: Any 							=						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )
          return tokenizer



     @property
     def  lowerCAmelCase__       (      self  )->					List[str]:
          torch.manual_seed(0  )
          UpperCAmelCase__							: str 							=						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  lowerCAmelCase__       (      self  )->					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",
              "encoder_hid_proj_type": None,
              "added_emb_type": None,
          }

          UpperCAmelCase__							: int 							=						PriorTransformer(**__UpperCamelCase  )
          return model



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

          UpperCAmelCase__							: Tuple 							=						{
              "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__							: Union[str, Any] 							=						ShapERenderer(**__UpperCamelCase  )
          return model



     def  lowerCAmelCase__       (      self  )->					Any:
          UpperCAmelCase__							: Optional[Any] 							=						self.dummy_prior
          UpperCAmelCase__							: Optional[Any] 							=						self.dummy_text_encoder
          UpperCAmelCase__							: List[Any] 							=						self.dummy_tokenizer
          UpperCAmelCase__							: Dict 							=						self.dummy_renderer

          UpperCAmelCase__							: 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 ,			)
          UpperCAmelCase__							: List[Any] 							=						{
              "prior": prior,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "renderer": renderer,
              "scheduler": scheduler,
          }

          return components



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



     def  lowerCAmelCase__       (      self  )->					str:
          UpperCAmelCase__							: Optional[Any] 							=						"cpu"

          UpperCAmelCase__							: List[str] 							=						self.get_dummy_components()

          UpperCAmelCase__							: List[str] 							=						self.pipeline_class(**__UpperCamelCase  )
          UpperCAmelCase__							: int 							=						pipe.to(__UpperCamelCase  )

          pipe.set_progress_bar_config(disable=__UpperCamelCase  )

          UpperCAmelCase__							: Any 							=						pipe(**self.get_dummy_inputs(__UpperCamelCase  )  )
          UpperCAmelCase__							: int 							=						output.images[0]
          UpperCAmelCase__							: Dict 							=						image[0, -3:, -3:, -1]

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

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

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



     def  lowerCAmelCase__       (      self  )->					int:
          UpperCAmelCase__							: List[Any] 							=						self.get_dummy_components()
          UpperCAmelCase__							: Union[str, Any] 							=						self.pipeline_class(**__UpperCamelCase  )
          UpperCAmelCase__							: Any 							=						pipe.to(__UpperCamelCase  )
          pipe.set_progress_bar_config(disable=__UpperCamelCase  )

          UpperCAmelCase__							: Tuple 							=						1
          UpperCAmelCase__							: Tuple 							=						2

          UpperCAmelCase__							: Tuple 							=						self.get_dummy_inputs(__UpperCamelCase  )

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

          UpperCAmelCase__							: Optional[int] 							=						pipe(**__UpperCamelCase ,			num_images_per_prompt=__UpperCamelCase  )[0]

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







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


     '''simple docstring'''





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



     def  lowerCAmelCase__       (      self  )->					Dict:
          UpperCAmelCase__							: Tuple 							=						load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/shap_e/test_shap_e_np_out.npy"  )
          UpperCAmelCase__							: Optional[Any] 							=						ShapEPipeline.from_pretrained("openai/shap-e"  )
          UpperCAmelCase__							: Optional[Any] 							=						pipe.to(__UpperCamelCase  )
          pipe.set_progress_bar_config(disable=__UpperCamelCase  )

          UpperCAmelCase__							: Tuple 							=						torch.Generator(device=__UpperCamelCase  ).manual_seed(0  )

          UpperCAmelCase__							: Dict 							=						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"""




def 							a__ (				lowerCAmelCase	:       int		):






     '''simple docstring'''
     if a < 0:
          raise ValueError("Input value must be a positive integer"		)
     elif isinstance(lowerCAmelCase       ,    lowerCAmelCase		):
          raise TypeError("Input value must be a 'int' type"		)
     return bin(lowerCAmelCase		).count("1"		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()



