




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__   ( snake_case__			,    snake_case__			,    unittest.TestCase				):
						_a							:   Optional[int] =   IFPipeline
						_a							:   str =   TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
						_a							:   str =   TEXT_TO_IMAGE_BATCH_PARAMS
						_a							:   Tuple =   PipelineTesterMixin.required_optional_params - {'''latents'''}






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											return self._get_dummy_components()






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A=0      ):




											"""simple docstring"""



											if str(_snake_case      ).startswith("mps"      ):
																__lowerCAmelCase           =	torch.manual_seed(_snake_case      )
											else:
																__lowerCAmelCase           =	torch.Generator(device=_snake_case      ).manual_seed(_snake_case      )

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

											return inputs






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self._test_save_load_optional_components()






						@unittest.skipIf(torch_device != "cuda"		,      reason="float16 requires CUDA"      )
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self._test_save_load_local()






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""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     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )






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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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

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

											# pre compute text embeddings and remove T5 to save memory

											pipe_a.text_encoder.to("cuda"      )

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

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

											__lowerCAmelCase           =	None
											__lowerCAmelCase           =	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(_snake_case		,      _snake_case		,      _snake_case		,      _snake_case      )

											pipe_a.remove_all_hooks()
											pipe_a.remove_all_hooks()

											# img2img

											__lowerCAmelCase           =	IFImgaImgPipeline(**pipe_a.components      )
											__lowerCAmelCase           =	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(_snake_case		,      _snake_case		,      _snake_case		,      _snake_case      )

											pipe_a.remove_all_hooks()
											pipe_a.remove_all_hooks()

											# inpainting

											__lowerCAmelCase           =	IFInpaintingPipeline(**pipe_a.components      )
											__lowerCAmelCase           =	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(_snake_case		,      _snake_case		,      _snake_case		,      _snake_case      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											_start_torch_memory_measurement()

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

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (6_4, 6_4, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 1_3 * 1_0**9

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

											# pipeline 2

											_start_torch_memory_measurement()

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

											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(0      )      ).to(_snake_case      )

											__lowerCAmelCase           =	pipe_a(
											    prompt_embeds=_snake_case		,      negative_prompt_embeds=_snake_case		,      image=_snake_case		,      generator=_snake_case		,      num_inference_steps=2		,      output_type="np"		,      )

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (2_5_6, 2_5_6, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 4 * 1_0**9

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






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											_start_torch_memory_measurement()

											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(0      )      ).to(_snake_case      )

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

											__lowerCAmelCase           =	pipe_a(
											    prompt_embeds=_snake_case		,      negative_prompt_embeds=_snake_case		,      image=_snake_case		,      num_inference_steps=2		,      generator=_snake_case		,      output_type="np"		,      )

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (6_4, 6_4, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 1_0 * 1_0**9

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

											# pipeline 2

											_start_torch_memory_measurement()

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

											__lowerCAmelCase           =	floats_tensor((1, 3, 2_5_6, 2_5_6)		,      rng=random.Random(0      )      ).to(_snake_case      )
											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(0      )      ).to(_snake_case      )

											__lowerCAmelCase           =	pipe_a(
											    prompt_embeds=_snake_case		,      negative_prompt_embeds=_snake_case		,      image=_snake_case		,      original_image=_snake_case		,      generator=_snake_case		,      num_inference_steps=2		,      output_type="np"		,      )

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (2_5_6, 2_5_6, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 4 * 1_0**9

											__lowerCAmelCase           =	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(_snake_case		,      _snake_case      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											_start_torch_memory_measurement()

											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(0      )      ).to(_snake_case      )
											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(1      )      ).to(_snake_case      )

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

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (6_4, 6_4, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 1_0 * 1_0**9

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

											# pipeline 2

											_start_torch_memory_measurement()

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

											__lowerCAmelCase           =	floats_tensor((1, 3, 6_4, 6_4)		,      rng=random.Random(0      )      ).to(_snake_case      )
											__lowerCAmelCase           =	floats_tensor((1, 3, 2_5_6, 2_5_6)		,      rng=random.Random(0      )      ).to(_snake_case      )
											__lowerCAmelCase           =	floats_tensor((1, 3, 2_5_6, 2_5_6)		,      rng=random.Random(1      )      ).to(_snake_case      )

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

											__lowerCAmelCase           =	output.images[0]

											assert image.shape == (2_5_6, 2_5_6, 3)

											__lowerCAmelCase           =	torch.cuda.max_memory_allocated()
											assert mem_bytes < 4 * 1_0**9

											__lowerCAmelCase           =	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(_snake_case		,      _snake_case      )







def      _a				(						):
					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()










from __future__ import annotations







def      _a				(						SCREAMING_SNAKE_CASE_							:    float				,				SCREAMING_SNAKE_CASE_							:    float				,				SCREAMING_SNAKE_CASE_							:    float				,				):
					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()




