
lowerCamelCase__        =		8.3_1_4_4_6_2  # Unit - J mol-1 K-1
def    __lowerCAmelCase    (_UpperCamelCase	,  _UpperCamelCase	,  _UpperCamelCase		):
	if moles < 0 or kelvin < 0 or volume < 0:
		raise ValueError('Invalid inputs. Enter positive value.'		)
	return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume
def    __lowerCAmelCase    (_UpperCamelCase	,  _UpperCamelCase	,  _UpperCamelCase		):
	if moles < 0 or kelvin < 0 or pressure < 0:
		raise ValueError('Invalid inputs. Enter positive value.'		)
	return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


if __name__ == "__main__":
							from doctest import testmod

							testmod()

"""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 			A__	(     _lowerCamelCase	,					unittest.TestCase):
		A_						:	Optional[int]           =     ShapEPipeline
		A_						:	str           =     ['prompt']
		A_						:	Any           =     ['prompt']
		A_						:	List[Any]           =     [
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		A_						:	Optional[int]           =     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			):
			__lowerCAmelCase      :						Tuple						      =				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)
			return tokenizer

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)
			__lowerCAmelCase      :						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(_SCREAMING_SNAKE_CASE			)

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

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

			__lowerCAmelCase      :						int						      =				PriorTransformer(**_SCREAMING_SNAKE_CASE			)
			return model

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

			__lowerCAmelCase      :						Dict						      =				{
			    '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,
			    ),
			}
			__lowerCAmelCase      :						Union[str, Any]						      =				ShapERenderer(**_SCREAMING_SNAKE_CASE			)
			return model

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_prior
			__lowerCAmelCase      :						str						      =				self.dummy_text_encoder
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_tokenizer
			__lowerCAmelCase      :						str						      =				self.dummy_renderer

			__lowerCAmelCase      :						List[Any]						      =				HeunDiscreteScheduler(
			    beta_schedule='exp'	,		num_train_timesteps=10_24	,		prediction_type='sample'	,		use_karras_sigmas=_SCREAMING_SNAKE_CASE	,		clip_sample=_SCREAMING_SNAKE_CASE	,		clip_sample_range=1.0	,		)
			__lowerCAmelCase      :						int						      =				{
			    'prior': prior,
			    'text_encoder': text_encoder,
			    'tokenizer': tokenizer,
			    'renderer': renderer,
			    'scheduler': scheduler,
			}

			return components

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=0			):
			if str(_SCREAMING_SNAKE_CASE			).startswith('mps'			):
				__lowerCAmelCase      :						int						      =				torch.manual_seed(_SCREAMING_SNAKE_CASE			)
			else:
				__lowerCAmelCase      :						Dict						      =				torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Optional[Any]						      =				{
			    'prompt': 'horse',
			    'generator': generator,
			    'num_inference_steps': 1,
			    'frame_size': 32,
			    'output_type': 'np',
			}
			return inputs

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Any						      =				'cpu'

			__lowerCAmelCase      :						int						      =				self.get_dummy_components()

			__lowerCAmelCase      :						Union[str, Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Union[str, Any]						      =				pipe.to(_SCREAMING_SNAKE_CASE			)

			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Optional[int]						      =				pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)			)
			__lowerCAmelCase      :						Optional[Any]						      =				output.images[0]
			__lowerCAmelCase      :						Optional[int]						      =				image[0, -3:, -3:, -1]

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

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

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







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						str						      =				self.get_dummy_components()
			__lowerCAmelCase      :						List[Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Tuple						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						int						      =				1
			__lowerCAmelCase      :						List[Any]						      =				2

			__lowerCAmelCase      :						int						      =				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)

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

			__lowerCAmelCase      :						Any						      =				pipe(**_SCREAMING_SNAKE_CASE	,		num_images_per_prompt=_SCREAMING_SNAKE_CASE			)[0]

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




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

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







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/shap_e/test_shap_e_np_out.npy'			)
			__lowerCAmelCase      :						Dict						      =				ShapEPipeline.from_pretrained('openai/shap-e'			)
			__lowerCAmelCase      :						int						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Any						      =				torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(0			)

			__lowerCAmelCase      :						List[str]						      =				pipe(
			    'a shark'	,		generator=_SCREAMING_SNAKE_CASE	,		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(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)