


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        snake_case_   (lowerCamelCase_	,						lowerCamelCase_	,						unittest.TestCase      ):
					UpperCAmelCase__					:    List[str]          =			IFPipeline
					UpperCAmelCase__					:    Optional[Any]          =			TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
					UpperCAmelCase__					:    str          =			TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCAmelCase__					:    Optional[int]          =			PipelineTesterMixin.required_optional_params - {'''latents'''}
					def  lowerCamelCase__(      self   :Dict      )					->    Union[str, Any]:
												return self._get_dummy_components()
					def  lowerCamelCase__(      self   :List[str]			,__snake_case   :Optional[int]			,__snake_case   :List[Any]=0      )					->    str:
												if str(__snake_case      ).startswith('mps'      ):
																			a__             =     torch.manual_seed(__snake_case      )
												else:
																			a__             =     torch.Generator(device=__snake_case      ).manual_seed(__snake_case      )

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

												return inputs
					def  lowerCamelCase__(      self   :Union[str, Any]      )					->    Optional[Any]:
												self._test_save_load_optional_components()
					@unittest.skipIf(torch_device != 'cuda'			,reason='float16 requires CUDA'      )
					def  lowerCamelCase__(      self   :Dict      )					->    Optional[int]:
												# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
												super().test_save_load_floataa(expected_max_diff=1E-1      )
					def  lowerCamelCase__(      self   :List[Any]      )					->    int:
												self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )
					def  lowerCamelCase__(      self   :Optional[int]      )					->    Union[str, Any]:
												self._test_save_load_local()
					def  lowerCamelCase__(      self   :Dict      )					->    Dict:
												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   :str      )					->    Dict:
												self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )







@slow
@require_torch_gpu
class        snake_case_   (unittest.TestCase      ):
					def  lowerCamelCase__(      self   :Any      )					->    Dict:
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()
					def  lowerCamelCase__(      self   :Optional[Any]      )					->    Optional[Any]:
												# if

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

												a__             =     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'      )

												a__      ,					a__             =     pipe_a.encode_prompt('anime turtle'			,device='cuda'      )

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

												a__             =     None
												a__             =     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

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

												a__             =     IFInpaintingPipeline(**pipe_a.components      )
												a__             =     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  lowerCamelCase__(      self   :Optional[Any]			,__snake_case   :Optional[Any]			,__snake_case   :List[str]			,__snake_case   :Optional[Any]			,__snake_case   :Optional[Any]      )					->    int:
												# pipeline 1

												_start_torch_memory_measurement()

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )
												a__             =     pipe_a(
												    prompt_embeds=__snake_case			,negative_prompt_embeds=__snake_case			,num_inference_steps=2			,generator=__snake_case			,output_type='np'			,)

												a__             =     output.images[0]

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

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

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

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )

												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(0      )      ).to(__snake_case      )

												a__             =     pipe_a(
												    prompt_embeds=__snake_case			,negative_prompt_embeds=__snake_case			,image=__snake_case			,generator=__snake_case			,num_inference_steps=2			,output_type='np'			,)

												a__             =     output.images[0]

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

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

												a__             =     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  lowerCamelCase__(      self   :Optional[int]			,__snake_case   :Union[str, Any]			,__snake_case   :Optional[int]			,__snake_case   :Tuple			,__snake_case   :Tuple      )					->    Any:
												# pipeline 1

												_start_torch_memory_measurement()

												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(0      )      ).to(__snake_case      )

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )

												a__             =     pipe_a(
												    prompt_embeds=__snake_case			,negative_prompt_embeds=__snake_case			,image=__snake_case			,num_inference_steps=2			,generator=__snake_case			,output_type='np'			,)

												a__             =     output.images[0]

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

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

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

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )

												a__             =     floats_tensor((1, 3, 2_56, 2_56)			,rng=random.Random(0      )      ).to(__snake_case      )
												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(0      )      ).to(__snake_case      )

												a__             =     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'			,)

												a__             =     output.images[0]

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

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

												a__             =     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  lowerCamelCase__(      self   :Optional[int]			,__snake_case   :Optional[Any]			,__snake_case   :str			,__snake_case   :Optional[int]			,__snake_case   :Dict      )					->    int:
												# pipeline 1

												_start_torch_memory_measurement()

												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(0      )      ).to(__snake_case      )
												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(1      )      ).to(__snake_case      )

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )
												a__             =     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'			,)

												a__             =     output.images[0]

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

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

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

												a__             =     torch.Generator(device='cpu'      ).manual_seed(0      )

												a__             =     floats_tensor((1, 3, 64, 64)			,rng=random.Random(0      )      ).to(__snake_case      )
												a__             =     floats_tensor((1, 3, 2_56, 2_56)			,rng=random.Random(0      )      ).to(__snake_case      )
												a__             =     floats_tensor((1, 3, 2_56, 2_56)			,rng=random.Random(1      )      ).to(__snake_case      )

												a__             =     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'			,)

												a__             =     output.images[0]

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

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

												a__             =     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 							__lowercase   ( ):
							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()








def 							__lowercase   ( __lowerCAmelCase							:				list[int]   ):
							a__             =     []
							if len(__lowerCAmelCase   ) == 1:
														return [nums.copy()]
							for _ in range(len(__lowerCAmelCase   )   ):
														a__             =     nums.pop(0   )
														a__             =     permute(__lowerCAmelCase   )
														for perm in permutations:
																					perm.append(__lowerCAmelCase   )
														result.extend(__lowerCAmelCase   )
														nums.append(__lowerCAmelCase   )
							return result






def 							__lowercase   ( __lowerCAmelCase							:				Optional[int]   ):

							def backtrack(__lowerCAmelCase							:				Any   ):
														if start == len(__lowerCAmelCase   ) - 1:
																					output.append(nums[:]   )
														else:
																					for i in range(__lowerCAmelCase					,    len(__lowerCAmelCase   )   ):
																												a__      ,					a__             =     nums[i], nums[start]
																												backtrack(start + 1   )
																												a__      ,					a__             =     nums[i], nums[start]  # backtrack

							a__             =     []
							backtrack(0   )
							return output


if __name__ == "__main__":
						import doctest

						# use res to print the data in permute2 function
						snake_case							:       Optional[Any]     			=      permutea([1, 2, 3])
						print(res)
						doctest.testmod()




