






'''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    ):
	_lowerCamelCase              =  ShapEPipeline
	_lowerCamelCase              =  ['''prompt''']
	_lowerCamelCase              =  ['''prompt''']
	_lowerCamelCase              =  [
	    '''num_images_per_prompt''',
	    '''num_inference_steps''',
	    '''generator''',
	    '''latents''',
	    '''guidance_scale''',
	    '''frame_size''',
	    '''output_type''',
	    '''return_dict''',
	]
	_lowerCamelCase              =  False

	@property
	def      __UpperCamelCase							(      self   :						List[Any]):
			return 32

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

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

	@property
	def      __UpperCamelCase							(      self   :						int):
			return 8

	@property
	def      __UpperCamelCase							(      self   :						List[str]):
			UpperCamelCase__				:					Union[str, Any]					=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')
			return tokenizer

	@property
	def      __UpperCamelCase							(      self   :						List[Any]):
			torch.manual_seed(0)
			UpperCamelCase__				:					List[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=1_000  ,					)
			return CLIPTextModelWithProjection(UpperCAmelCase_)

	@property
	def      __UpperCamelCase							(      self   :						Optional[int]):
			torch.manual_seed(0)

			UpperCamelCase__				:					List[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__				:					Any					=					PriorTransformer(**UpperCAmelCase_)
			return model

	@property
	def      __UpperCamelCase							(      self   :						List[Any]):
			torch.manual_seed(0)

			UpperCamelCase__				:					Any					=					{
			    '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      __UpperCamelCase							(      self   :						Optional[int]):
			UpperCamelCase__				:					int					=					self.dummy_prior
			UpperCamelCase__				:					int					=					self.dummy_text_encoder
			UpperCamelCase__				:					Optional[int]					=					self.dummy_tokenizer
			UpperCamelCase__				:					List[str]					=					self.dummy_renderer

			UpperCamelCase__				:					int					=					HeunDiscreteScheduler(
			    beta_schedule='exp'  ,					num_train_timesteps=1_024  ,					prediction_type='sample'  ,					use_karras_sigmas=UpperCAmelCase_  ,					clip_sample=UpperCAmelCase_  ,					clip_sample_range=1.0  ,					)
			UpperCamelCase__				:					Dict					=					{
			    'prior': prior,
			    'text_encoder': text_encoder,
			    'tokenizer': tokenizer,
			    'renderer': renderer,
			    'scheduler': scheduler,
			}

			return components

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

	def      __UpperCamelCase							(      self   :						int):
			UpperCamelCase__				:					Optional[Any]					=					'cpu'

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

			UpperCamelCase__				:					List[Any]					=					self.pipeline_class(**UpperCAmelCase_)
			UpperCamelCase__				:					Dict					=					pipe.to(UpperCAmelCase_)

			pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					str					=					pipe(**self.get_dummy_inputs(UpperCAmelCase_))
			UpperCamelCase__				:					Tuple					=					output.images[0]
			UpperCamelCase__				:					List[str]					=					image[0, -3:, -3:, -1]

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

			UpperCamelCase__				:					Optional[Any]					=					np.array(
			    [
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			        0.00_03_92_16,
			    ])

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

	def      __UpperCamelCase							(      self   :						int):
			# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
			self._test_inference_batch_consistent(batch_sizes=[1, 2])

	def      __UpperCamelCase							(      self   :						List[Any]):
			UpperCamelCase__				:					List[str]					=					torch_device == 'cpu'
			UpperCamelCase__				:					Optional[Any]					=					True

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





	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					str					=					self.get_dummy_components()
			UpperCamelCase__				:					Union[str, Any]					=					self.pipeline_class(**UpperCAmelCase_)
			UpperCamelCase__				:					Optional[int]					=					pipe.to(UpperCAmelCase_)
			pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					List[str]					=					1
			UpperCamelCase__				:					Optional[Any]					=					2

			UpperCamelCase__				:					int					=					self.get_dummy_inputs(UpperCAmelCase_)

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

			UpperCamelCase__				:					List[Any]					=					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    ):

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





	def      __UpperCamelCase							(      self   :						Union[str, Any]):
			UpperCamelCase__				:					Tuple					=					load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/shap_e/test_shap_e_np_out.npy')
			UpperCamelCase__				:					List[Any]					=					ShapEPipeline.from_pretrained('openai/shap-e')
			UpperCamelCase__				:					Dict					=					pipe.to(UpperCAmelCase_)
			pipe.set_progress_bar_config(disable=UpperCAmelCase_)

			UpperCamelCase__				:					Union[str, Any]					=					torch.Generator(device=UpperCAmelCase_).manual_seed(0)

			UpperCamelCase__				:					Optional[int]					=					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'''




from math import log

from scipy.constants import Boltzmann, physical_constants

lowerCAmelCase__          =						300  # TEMPERATURE (unit = K)







def       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      )							->     float:

		if donor_conc <= 0:
				raise ValueError('Donor concentration should be positive')
		elif acceptor_conc <= 0:
				raise ValueError('Acceptor concentration should be positive')
		elif intrinsic_conc <= 0:
				raise ValueError('Intrinsic concentration should be positive')
		elif donor_conc <= intrinsic_conc:
				raise ValueError(
				    'Donor concentration should be greater than intrinsic concentration')
		elif acceptor_conc <= intrinsic_conc:
				raise ValueError(
				    'Acceptor concentration should be greater than intrinsic concentration')
		else:
				return (
				    Boltzmann
				    * T
				    * log((donor_conc * acceptor_conc) / intrinsic_conc**2)
				    / physical_constants["electron volt"][0]
				)


if __name__ == "__main__":
		import doctest

		doctest.testmod()




