




"""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'''
 UpperCAmelCase       :	str     =      ShapEPipeline
 UpperCAmelCase       :	Union[str, Any]     =      ['''prompt''']
 UpperCAmelCase       :	Union[str, Any]     =      ['''prompt''']
 UpperCAmelCase       :	List[str]     =      [
     '''num_images_per_prompt''',
     '''num_inference_steps''',
     '''generator''',
     '''latents''',
     '''guidance_scale''',
     '''frame_size''',
     '''output_type''',
     '''return_dict''',
 ]
 UpperCAmelCase       :	Optional[Any]     =      False

 @property
 def      lowerCAmelCase_				(					self			:			Optional[int]						):
       return 32

 @property
 def      lowerCAmelCase_				(					self			:			Optional[Any]						):
       return 32

 @property
 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       return self.time_input_dim * 4

 @property
 def      lowerCAmelCase_				(					self			:			str						):
       return 8

 @property
 def      lowerCAmelCase_				(					self			:			Optional[Any]						):
       _A     =  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)
       return tokenizer

 @property
 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       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-0_5       ,				num_attention_heads=4       ,				num_hidden_layers=5       ,				pad_token_id=1       ,				vocab_size=1_000       ,				)
       return CLIPTextModelWithProjection(_UpperCAmelCase						)

 @property
 def      lowerCAmelCase_				(					self			:			Optional[int]						):
       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(**_UpperCAmelCase						)
       return model

 @property
 def      lowerCAmelCase_				(					self			:			List[Any]						):
       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(**_UpperCAmelCase						)
       return model

 def      lowerCAmelCase_				(					self			:			List[Any]						):
       _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=1_024       ,				prediction_type='sample'       ,				use_karras_sigmas=_UpperCAmelCase       ,				clip_sample=_UpperCAmelCase       ,				clip_sample_range=1.0       ,				)
       _A     =  {
           'prior': prior,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'renderer': renderer,
           'scheduler': scheduler,
       }

       return components

 def      lowerCAmelCase_				(					self			:			Any       ,				_UpperCAmelCase			:			List[Any]       ,				_UpperCAmelCase			:			List[Any]=0						):
       if str(_UpperCAmelCase						).startswith('mps'						):
             _A     =  torch.manual_seed(_UpperCAmelCase						)
       else:
             _A     =  torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
       _A     =  {
           'prompt': 'horse',
           'generator': generator,
           'num_inference_steps': 1,
           'frame_size': 32,
           'output_type': 'np',
       }
       return inputs

 def      lowerCAmelCase_				(					self			:			int						):
       _A     =  'cpu'

       _A     =  self.get_dummy_components()

       _A     =  self.pipeline_class(**_UpperCAmelCase						)
       _A     =  pipe.to(_UpperCAmelCase						)

       pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

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

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

       _A     =  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			:			List[Any]						):
       # 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			:			Tuple						):
       _A     =  torch_device == 'cpu'
       _A     =  True

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



 def      lowerCAmelCase_				(					self			:			str						):
       _A     =  self.get_dummy_components()
       _A     =  self.pipeline_class(**_UpperCAmelCase						)
       _A     =  pipe.to(_UpperCAmelCase						)
       pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

       _A     =  1
       _A     =  2

       _A     =  self.get_dummy_inputs(_UpperCAmelCase						)

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

       _A     =  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			:			Tuple						):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()



 def      lowerCAmelCase_				(					self			:			Tuple						):
       _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(_UpperCAmelCase						)
       pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

       _A     =  torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)

       _A     =  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"""

import math






def 		_snake_case	(   _snake_case				:   float							,    _snake_case				:   float				)       ->   float:






      '''simple docstring'''


      if (
          not isinstance(_snake_case							,    (int, float)				)
          or power_factor < -1
          or power_factor > 1
      ):
            raise ValueError('power_factor must be a valid float value between -1 and 1.'				)
      return apparent_power * power_factor






def 		_snake_case	(   _snake_case				:   float							,    _snake_case				:   float				)       ->   float:






      '''simple docstring'''


      if (
          not isinstance(_snake_case							,    (int, float)				)
          or power_factor < -1
          or power_factor > 1
      ):
            raise ValueError('power_factor must be a valid float value between -1 and 1.'				)
      return apparent_power * math.sqrt(1 - power_factor**2				)


if __name__ == "__main__":
       import doctest

       doctest.testmod()

