


import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin



@skip_mps
class 				A       (			UpperCAmelCase__					,    UpperCAmelCase__					,    unittest.TestCase				):
					'''simple docstring'''






					A__     =					IFPipeline
					A__     =					TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
					A__     =					TEXT_TO_IMAGE_BATCH_PARAMS
					A__     =					PipelineTesterMixin.required_optional_params - {'''latents'''}

					def     lowerCamelCase__	(self       :		int						)		->  Optional[int]:




							"""simple docstring"""


							return self._get_dummy_components()

					def     lowerCamelCase__	(self       :		int ,   _UpperCAmelCase       :		List[Any] ,   _UpperCAmelCase       :		str=0						)		->  Optional[Any]:




							"""simple docstring"""


							if str(_UpperCAmelCase						).startswith("""mps"""						):
									lowercase__	     =						torch.manual_seed(_UpperCAmelCase						)
							else:
									lowercase__	     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)

							lowercase__	     =						{
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """output_type""": """numpy""",
							}

							return inputs

					def     lowerCamelCase__	(self       :		int						)		->  List[Any]:




							"""simple docstring"""


							self._test_save_load_optional_components()

					@unittest.skipIf(torch_device != """cuda""" ,   reason="""float16 requires CUDA"""						)
					def     lowerCamelCase__	(self       :		Dict						)		->  List[Any]:




							"""simple docstring"""


							super().test_save_load_floataa(expected_max_diff=1E-1						)

					def     lowerCamelCase__	(self       :		str						)		->  int:




							"""simple docstring"""


							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2						)

					def     lowerCamelCase__	(self       :		int						)		->  Any:




							"""simple docstring"""


							self._test_save_load_local()

					def     lowerCamelCase__	(self       :		str						)		->  Optional[Any]:




							"""simple docstring"""


							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2 ,   )


					@unittest.skipIf(
					    torch_device != """cuda""" or not is_xformers_available() ,   reason="""XFormers attention is only available with CUDA and `xformers` installed""" ,   )
					def     lowerCamelCase__	(self       :		Optional[int]						)		->  Optional[int]:




							"""simple docstring"""


							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3						)






@slow
@require_torch_gpu
class 				A       (			unittest.TestCase				):
					'''simple docstring'''






					def     lowerCamelCase__	(self       :		Tuple						)		->  str:




							"""simple docstring"""


							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()

					def     lowerCamelCase__	(self       :		Union[str, Any]						)		->  Optional[Any]:




							"""simple docstring"""


							lowercase__	     =						IFPipeline.from_pretrained("""DeepFloyd/IF-I-XL-v1.0""" ,   variant="""fp16""" ,   torch_dtype=torch.floataa						)

							lowercase__	     =						IFSuperResolutionPipeline.from_pretrained(
							    """DeepFloyd/IF-II-L-v1.0""" ,   variant="""fp16""" ,   torch_dtype=torch.floataa ,   text_encoder=_UpperCAmelCase ,   tokenizer=_UpperCAmelCase						)

							# pre compute text embeddings and remove T5 to save memory

							pipe_a.text_encoder.to("""cuda"""						)

							lowercase__     ,      lowercase__	     =						pipe_a.encode_prompt("""anime turtle""" ,   device="""cuda"""						)

							del pipe_a.tokenizer
							del pipe_a.text_encoder
							gc.collect()

							lowercase__	     =						None
							lowercase__	     =						None

							pipe_a.enable_model_cpu_offload()
							pipe_a.enable_model_cpu_offload()

							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

							self._test_if(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

							pipe_a.remove_all_hooks()
							pipe_a.remove_all_hooks()

							# img2img

							lowercase__	     =						IFImgaImgPipeline(**pipe_a.components						)
							lowercase__	     =						IFImgaImgSuperResolutionPipeline(**pipe_a.components						)

							pipe_a.enable_model_cpu_offload()
							pipe_a.enable_model_cpu_offload()

							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

							self._test_if_imgaimg(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

							pipe_a.remove_all_hooks()
							pipe_a.remove_all_hooks()

							# inpainting

							lowercase__	     =						IFInpaintingPipeline(**pipe_a.components						)
							lowercase__	     =						IFInpaintingSuperResolutionPipeline(**pipe_a.components						)

							pipe_a.enable_model_cpu_offload()
							pipe_a.enable_model_cpu_offload()

							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
							pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

							self._test_if_inpainting(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

					def     lowerCamelCase__	(self       :		Any ,   _UpperCAmelCase       :		Tuple ,   _UpperCAmelCase       :		str ,   _UpperCAmelCase       :		Dict ,   _UpperCAmelCase       :		List[str]						)		->  List[Any]:




							"""simple docstring"""


							_start_torch_memory_measurement()

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)
							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   num_inference_steps=2 ,   generator=_UpperCAmelCase ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (64, 64, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 13 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)

							# pipeline 2

							_start_torch_memory_measurement()

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)

							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)

							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   image=_UpperCAmelCase ,   generator=_UpperCAmelCase ,   num_inference_steps=2 ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (256, 256, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 4 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)

					def     lowerCamelCase__	(self       :		Union[str, Any] ,   _UpperCAmelCase       :		Optional[Any] ,   _UpperCAmelCase       :		str ,   _UpperCAmelCase       :		str ,   _UpperCAmelCase       :		Optional[int]						)		->  Any:




							"""simple docstring"""


							_start_torch_memory_measurement()

							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)

							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   image=_UpperCAmelCase ,   num_inference_steps=2 ,   generator=_UpperCAmelCase ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (64, 64, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 10 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)

							# pipeline 2

							_start_torch_memory_measurement()

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)

							lowercase__	     =						floats_tensor((1, 3, 256, 256) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)
							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)

							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   image=_UpperCAmelCase ,   original_image=_UpperCAmelCase ,   generator=_UpperCAmelCase ,   num_inference_steps=2 ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (256, 256, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 4 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)


					def     lowerCamelCase__	(self       :		Dict ,   _UpperCAmelCase       :		List[str] ,   _UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		str						)		->  Dict:




							"""simple docstring"""


							_start_torch_memory_measurement()

							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)
							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(1						)						).to(_UpperCAmelCase						)

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)
							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   image=_UpperCAmelCase ,   mask_image=_UpperCAmelCase ,   num_inference_steps=2 ,   generator=_UpperCAmelCase ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (64, 64, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 10 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)

							# pipeline 2

							_start_torch_memory_measurement()

							lowercase__	     =						torch.Generator(device="""cpu"""						).manual_seed(0						)

							lowercase__	     =						floats_tensor((1, 3, 64, 64) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)
							lowercase__	     =						floats_tensor((1, 3, 256, 256) ,   rng=random.Random(0						)						).to(_UpperCAmelCase						)
							lowercase__	     =						floats_tensor((1, 3, 256, 256) ,   rng=random.Random(1						)						).to(_UpperCAmelCase						)

							lowercase__	     =						pipe_a(
							    prompt_embeds=_UpperCAmelCase ,   negative_prompt_embeds=_UpperCAmelCase ,   image=_UpperCAmelCase ,   mask_image=_UpperCAmelCase ,   original_image=_UpperCAmelCase ,   generator=_UpperCAmelCase ,   num_inference_steps=2 ,   output_type="""np""" ,   )

							lowercase__	     =						output.images[0]

							assert image.shape == (256, 256, 3)

							lowercase__	     =						torch.cuda.max_memory_allocated()
							assert mem_bytes < 4 * 10**9

							lowercase__	     =						load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy"""						)
							assert_mean_pixel_difference(_UpperCAmelCase ,   _UpperCAmelCase						)






def 					UpperCamelCase   (      )  ->    Any:
		"""simple docstring"""




		torch.cuda.empty_cache()
		torch.cuda.reset_max_memory_allocated()
		torch.cuda.reset_peak_memory_stats()





from math import log

from scipy.constants import Boltzmann, physical_constants

A			:						Any        =  3_0_0  # TEMPERATURE (unit = K)






def 					UpperCamelCase   (      __magic_name__	:				float       ,       __magic_name__	:				float       ,       __magic_name__	:				float       ,       )  ->    float:
		"""simple docstring"""




		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()

