




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							:    str					=    IFPipeline
						_a							:    List[Any]					=    TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
						_a							:    Any					=    TEXT_TO_IMAGE_BATCH_PARAMS
						_a							:    Dict					=    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(_A			).startswith("mps"			):
																__lowerCAmelCase				   =       torch.manual_seed(_A			)
											else:
																__lowerCAmelCase				   =       torch.Generator(device=_A			).manual_seed(_A			)

											__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=_A		,			tokenizer=_A			)

											# 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(_A		,			_A		,			_A		,			_A			)

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

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






						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=_A		,			negative_prompt_embeds=_A		,			num_inference_steps=2		,			generator=_A		,			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(_A		,			_A			)

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

											__lowerCAmelCase				   =       pipe_a(
											    prompt_embeds=_A		,			negative_prompt_embeds=_A		,			image=_A		,			generator=_A		,			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(_A		,			_A			)






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

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

											__lowerCAmelCase				   =       pipe_a(
											    prompt_embeds=_A		,			negative_prompt_embeds=_A		,			image=_A		,			num_inference_steps=2		,			generator=_A		,			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(_A		,			_A			)

											# 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(_A			)
											__lowerCAmelCase				   =       floats_tensor((1, 3, 6_4, 6_4)		,			rng=random.Random(0			)			).to(_A			)

											__lowerCAmelCase				   =       pipe_a(
											    prompt_embeds=_A		,			negative_prompt_embeds=_A		,			image=_A		,			original_image=_A		,			generator=_A		,			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(_A		,			_A			)






						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(_A			)
											__lowerCAmelCase				   =       floats_tensor((1, 3, 6_4, 6_4)		,			rng=random.Random(1			)			).to(_A			)

											__lowerCAmelCase				   =       torch.Generator(device="cpu"			).manual_seed(0			)
											__lowerCAmelCase				   =       pipe_a(
											    prompt_embeds=_A		,			negative_prompt_embeds=_A		,			image=_A		,			mask_image=_A		,			num_inference_steps=2		,			generator=_A		,			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(_A		,			_A			)

											# 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(_A			)
											__lowerCAmelCase				   =       floats_tensor((1, 3, 2_5_6, 2_5_6)		,			rng=random.Random(0			)			).to(_A			)
											__lowerCAmelCase				   =       floats_tensor((1, 3, 2_5_6, 2_5_6)		,			rng=random.Random(1			)			).to(_A			)

											__lowerCAmelCase				   =       pipe_a(
											    prompt_embeds=_A		,			negative_prompt_embeds=_A		,			image=_A		,			mask_image=_A		,			original_image=_A		,			generator=_A		,			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(_A		,			_A			)







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










from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels




