





"""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						(				_snake_case     ,    _snake_case     ,    unittest.TestCase    ):
				UpperCamelCase								=   IFPipeline
				UpperCamelCase								=   TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
				UpperCamelCase								=   TEXT_TO_IMAGE_BATCH_PARAMS
				UpperCamelCase								=   PipelineTesterMixin.required_optional_params - {'''latents'''}






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




										'''simple docstring'''



										return self._get_dummy_components()






				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   Tuple=0							)     ->				List[str]:




										'''simple docstring'''



										if str(UpperCamelCase__							).startswith('''mps'''							):
																_UpperCamelCase      : Tuple         =   torch.manual_seed(UpperCamelCase__							)
										else:
																_UpperCamelCase      : Dict         =   torch.Generator(device=UpperCamelCase__							).manual_seed(UpperCamelCase__							)

										_UpperCamelCase      : Union[str, Any]         =   {
										    '''prompt''': '''A painting of a squirrel eating a burger''',
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''output_type''': '''numpy''',
										}

										return inputs






				def     snake_case     (			self		:   Dict							)     ->				Union[str, Any]:




										'''simple docstring'''



										self._test_save_load_optional_components()






				@unittest.skipIf(torch_device != '''cuda''',			reason='''float16 requires CUDA'''							)
				def     snake_case     (			self		:   Any							)     ->				Tuple:




										'''simple docstring'''



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






				def     snake_case     (			self		:   Union[str, Any]							)     ->				int:




										'''simple docstring'''



										self._test_attention_slicing_forward_pass(expected_max_diff=1e-2							)






				def     snake_case     (			self		:   Dict							)     ->				int:




										'''simple docstring'''



										self._test_save_load_local()






				def     snake_case     (			self		:   Optional[Any]							)     ->				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     snake_case     (			self		:   str							)     ->				List[Any]:




										'''simple docstring'''



										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3							)




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






				def     snake_case     (			self		:   Any							)     ->				List[str]:




										'''simple docstring'''



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






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




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0''',			variant='''fp16''',			torch_dtype=torch.floataa							)

										_UpperCamelCase      : Any         =   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'''							)

										_UpperCamelCase       ,							_UpperCamelCase      : Dict         =   pipe_a.encode_prompt('''anime turtle''',			device='''cuda'''							)

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

										_UpperCamelCase      : Any         =   None
										_UpperCamelCase      : Any         =   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

										_UpperCamelCase      : int         =   IFImgaImgPipeline(**pipe_a.components							)
										_UpperCamelCase      : Tuple         =   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

										_UpperCamelCase      : Tuple         =   IFInpaintingPipeline(**pipe_a.components							)
										_UpperCamelCase      : Union[str, Any]         =   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     snake_case     (			self		:   Tuple,			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   Optional[Any],			lowerCAmelCase__		:   Any							)     ->				Tuple:




										'''simple docstring'''



										_start_torch_memory_measurement()

										_UpperCamelCase      : Tuple         =   torch.Generator(device='''cpu'''							).manual_seed(0							)
										_UpperCamelCase      : str         =   pipe_a(
										    prompt_embeds=UpperCamelCase__,			negative_prompt_embeds=UpperCamelCase__,			num_inference_steps=2,			generator=UpperCamelCase__,			output_type='''np''',			)

										_UpperCamelCase      : Tuple         =   output.images[0]

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

										_UpperCamelCase      : Union[str, Any]         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 1_3 * 1_0**9

										_UpperCamelCase      : int         =   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()

										_UpperCamelCase      : Optional[int]         =   torch.Generator(device='''cpu'''							).manual_seed(0							)

										_UpperCamelCase      : Tuple         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(0							)							).to(UpperCamelCase__							)

										_UpperCamelCase      : int         =   pipe_a(
										    prompt_embeds=UpperCamelCase__,			negative_prompt_embeds=UpperCamelCase__,			image=UpperCamelCase__,			generator=UpperCamelCase__,			num_inference_steps=2,			output_type='''np''',			)

										_UpperCamelCase      : List[Any]         =   output.images[0]

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

										_UpperCamelCase      : Union[str, Any]         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 1_0**9

										_UpperCamelCase      : Any         =   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     snake_case     (			self		:   int,			lowerCAmelCase__		:   Union[str, Any],			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   Union[str, Any]							)     ->				Dict:




										'''simple docstring'''



										_start_torch_memory_measurement()

										_UpperCamelCase      : Optional[Any]         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(0							)							).to(UpperCamelCase__							)

										_UpperCamelCase      : Tuple         =   torch.Generator(device='''cpu'''							).manual_seed(0							)

										_UpperCamelCase      : List[str]         =   pipe_a(
										    prompt_embeds=UpperCamelCase__,			negative_prompt_embeds=UpperCamelCase__,			image=UpperCamelCase__,			num_inference_steps=2,			generator=UpperCamelCase__,			output_type='''np''',			)

										_UpperCamelCase      : Optional[Any]         =   output.images[0]

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

										_UpperCamelCase      : Optional[int]         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 1_0 * 1_0**9

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

										_UpperCamelCase      : Optional[int]         =   torch.Generator(device='''cpu'''							).manual_seed(0							)

										_UpperCamelCase      : Optional[int]         =   floats_tensor((1, 3, 2_5_6, 2_5_6),			rng=random.Random(0							)							).to(UpperCamelCase__							)
										_UpperCamelCase      : Any         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(0							)							).to(UpperCamelCase__							)

										_UpperCamelCase      : Union[str, Any]         =   pipe_a(
										    prompt_embeds=UpperCamelCase__,			negative_prompt_embeds=UpperCamelCase__,			image=UpperCamelCase__,			original_image=UpperCamelCase__,			generator=UpperCamelCase__,			num_inference_steps=2,			output_type='''np''',			)

										_UpperCamelCase      : Dict         =   output.images[0]

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

										_UpperCamelCase      : Dict         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 1_0**9

										_UpperCamelCase      : Optional[Any]         =   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     snake_case     (			self		:   int,			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   Dict,			lowerCAmelCase__		:   Any							)     ->				List[Any]:




										'''simple docstring'''



										_start_torch_memory_measurement()

										_UpperCamelCase      : List[Any]         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(0							)							).to(UpperCamelCase__							)
										_UpperCamelCase      : List[Any]         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(1							)							).to(UpperCamelCase__							)

										_UpperCamelCase      : List[str]         =   torch.Generator(device='''cpu'''							).manual_seed(0							)
										_UpperCamelCase      : Dict         =   pipe_a(
										    prompt_embeds=UpperCamelCase__,			negative_prompt_embeds=UpperCamelCase__,			image=UpperCamelCase__,			mask_image=UpperCamelCase__,			num_inference_steps=2,			generator=UpperCamelCase__,			output_type='''np''',			)

										_UpperCamelCase      : Dict         =   output.images[0]

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

										_UpperCamelCase      : List[Any]         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 1_0 * 1_0**9

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

										_UpperCamelCase      : Union[str, Any]         =   torch.Generator(device='''cpu'''							).manual_seed(0							)

										_UpperCamelCase      : int         =   floats_tensor((1, 3, 6_4, 6_4),			rng=random.Random(0							)							).to(UpperCamelCase__							)
										_UpperCamelCase      : Optional[Any]         =   floats_tensor((1, 3, 2_5_6, 2_5_6),			rng=random.Random(0							)							).to(UpperCamelCase__							)
										_UpperCamelCase      : Optional[int]         =   floats_tensor((1, 3, 2_5_6, 2_5_6),			rng=random.Random(1							)							).to(UpperCamelCase__							)

										_UpperCamelCase      : Optional[int]         =   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''',			)

										_UpperCamelCase      : int         =   output.images[0]

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

										_UpperCamelCase      : List[str]         =   torch.cuda.max_memory_allocated()
										assert mem_bytes < 4 * 1_0**9

										_UpperCamelCase      : List[str]         =   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 	a_    (							):
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()












"""simple docstring"""




from functools import lru_cache





@lru_cache
def 	a_    (							_lowercase       ):
						if num < 0:
												raise ValueError('''Number should not be negative.'''       )

						return 1 if num in (0, 1) else num * factorial(num - 1       )


if __name__ == "__main__":
						import doctest

						doctest.testmod()



