


"""simple docstring"""




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   :						List[Any]		)						->       Union[str, Any]:




							"""simple docstring"""


							return self._get_dummy_components()

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




							"""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   :						Optional[int]		)						->       List[str]:




							"""simple docstring"""


							self._test_save_load_optional_components()

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




							"""simple docstring"""


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

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




							"""simple docstring"""


							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)

					def   lowerCamelCase__					(self   :						Dict		)						->       Dict:




							"""simple docstring"""


							self._test_save_load_local()

					def   lowerCamelCase__					(self   :						Optional[int]		)						->       Union[str, 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   :						Any		)						->       List[str]:




							"""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		)						->       Any:




							"""simple docstring"""


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

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




							"""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   :						Tuple				, _UpperCAmelCase   :						int				, _UpperCAmelCase   :						Dict				, _UpperCAmelCase   :						Optional[int]				, _UpperCAmelCase   :						Optional[int]		)						->       int:




							"""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   :						Any				, _UpperCAmelCase   :						Any				, _UpperCAmelCase   :						List[Any]				, _UpperCAmelCase   :						Optional[Any]				, _UpperCAmelCase   :						List[str]		)						->       Dict:




							"""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   :						Optional[int]				, _UpperCAmelCase   :						Optional[int]				, _UpperCAmelCase   :						Tuple				, _UpperCAmelCase   :						List[str]				, _UpperCAmelCase   :						List[Any]		)						->       List[Any]:




							"""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 (     )       ->  Optional[Any]:
		"""simple docstring"""




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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A	:		Dict    =       {'configuration_glpn': ['GLPN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GLPNConfig']}

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A	:		Tuple    =       ['GLPNFeatureExtractor']
	A	:		List[str]    =       ['GLPNImageProcessor']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A	:		Optional[int]    =       [
	    'GLPN_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GLPNForDepthEstimation',
	    'GLPNLayer',
	    'GLPNModel',
	    'GLPNPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_glpn import GLPN_PRETRAINED_CONFIG_ARCHIVE_MAP, GLPNConfig

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_glpn import GLPNFeatureExtractor
		from .image_processing_glpn import GLPNImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_glpn import (
		    GLPN_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GLPNForDepthEstimation,
		    GLPNLayer,
		    GLPNModel,
		    GLPNPreTrainedModel,
		)


else:
	import sys

	A	:		Tuple    =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

