


'''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 UpperCAmelCase							(		UpperCAmelCase_					,			unittest.TestCase							):
    _A :			Tuple						   =       ShapEPipeline
    _A :			List[str]						   =       ["""prompt"""]
    _A :			int						   =       ["""prompt"""]
    _A :			Dict						   =       [
        """num_images_per_prompt""",
        """num_inference_steps""",
        """generator""",
        """latents""",
        """guidance_scale""",
        """frame_size""",
        """output_type""",
        """return_dict""",
    ]
    _A :			Optional[Any]						   =       False



    @property
    def 					__lowerCamelCase						(  self					):
     return 32



    @property
    def 					__lowerCamelCase						(  self					):
     return 32



    @property
    def 					__lowerCamelCase						(  self					):
     return self.time_input_dim * 4



    @property
    def 					__lowerCamelCase						(  self					):
     return 8



    @property
    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)
     return tokenizer



    @property
    def 					__lowerCamelCase						(  self					):
     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=1_000     ,			)
     return CLIPTextModelWithProjection(__A					)



    @property
    def 					__lowerCamelCase						(  self					):
     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(**__A					)
     return model



    @property
    def 					__lowerCamelCase						(  self					):
     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(**__A					)
     return model



    def 					__lowerCamelCase						(  self					):
     __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=1_024     ,			prediction_type='sample'     ,			use_karras_sigmas=__A     ,			clip_sample=__A     ,			clip_sample_range=1.0     ,			)
     __UpperCAmelCase					=   {
         'prior': prior,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'renderer': renderer,
         'scheduler': scheduler,
     }

     return components



    def 					__lowerCamelCase						(  self     ,			__A     ,			__A=0					):
     if str(__A					).startswith('mps'					):
      __UpperCAmelCase					=   torch.manual_seed(__A					)
     else:
      __UpperCAmelCase					=   torch.Generator(device=__A					).manual_seed(__A					)
     __UpperCAmelCase					=   {
         'prompt': 'horse',
         'generator': generator,
         'num_inference_steps': 1,
         'frame_size': 32,
         'output_type': 'np',
     }
     return inputs



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   'cpu'

     __UpperCAmelCase					=   self.get_dummy_components()

     __UpperCAmelCase					=   self.pipeline_class(**__A					)
     __UpperCAmelCase					=   pipe.to(__A					)

     pipe.set_progress_bar_config(disable=__A					)

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

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

     __UpperCAmelCase					=   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					):
     # 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					):
     __UpperCAmelCase					=   torch_device == 'cpu'
     __UpperCAmelCase					=   True

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




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   self.get_dummy_components()
     __UpperCAmelCase					=   self.pipeline_class(**__A					)
     __UpperCAmelCase					=   pipe.to(__A					)
     pipe.set_progress_bar_config(disable=__A					)

     __UpperCAmelCase					=   1
     __UpperCAmelCase					=   2

     __UpperCAmelCase					=   self.get_dummy_inputs(__A					)

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

     __UpperCAmelCase					=   pipe(**__A     ,			num_images_per_prompt=__A					)[0]

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






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



    def 					__lowerCamelCase						(  self					):
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()




    def 					__lowerCamelCase						(  self					):
     __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(__A					)
     pipe.set_progress_bar_config(disable=__A					)

     __UpperCAmelCase					=   torch.Generator(device=__A					).manual_seed(0					)

     __UpperCAmelCase					=   pipe(
         'a shark'     ,			generator=__A     ,			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(__A     ,			__A					)












'''simple docstring'''




from __future__ import annotations







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    )->     tuple:
 if (electron_conc, hole_conc, intrinsic_conc).count(0    ) != 1:
  raise ValueError('You cannot supply more or less than 2 values'    )
 elif electron_conc < 0:
  raise ValueError('Electron concentration cannot be negative in a semiconductor'    )
 elif hole_conc < 0:
  raise ValueError('Hole concentration cannot be negative in a semiconductor'    )
 elif intrinsic_conc < 0:
  raise ValueError(
      'Intrinsic concentration cannot be negative in a semiconductor'    )
 elif electron_conc == 0:
  return (
      "electron_conc",
      intrinsic_conc**2 / hole_conc,
  )
 elif hole_conc == 0:
  return (
      "hole_conc",
      intrinsic_conc**2 / electron_conc,
  )
 elif intrinsic_conc == 0:
  return (
      "intrinsic_conc",
      (electron_conc * hole_conc) ** 0.5,
  )
 else:
  return (-1, -1)


if __name__ == "__main__":
    import doctest

    doctest.testmod()





