


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 __future__ import annotations

from collections import deque



class 							A   :
					'''simple docstring'''






					def __init__(self   :						Any				, _UpperCAmelCase   :						list[str]		)						->       Optional[int]:




							"""simple docstring"""


							lowercase__					      =		[]
							self.adlist.append(
							    {"""value""": """""", """next_states""": [], """fail_state""": 0, """output""": []}		)

							for keyword in keywords:
									self.add_keyword(_UpperCAmelCase		)
							self.set_fail_transitions()

					def   lowerCamelCase__					(self   :						List[str]				, _UpperCAmelCase   :						int				, _UpperCAmelCase   :						str		)						->       int | None:




							"""simple docstring"""


							for state in self.adlist[current_state]["next_states"]:
									if char == self.adlist[state]["value"]:
											return state
							return None

					def   lowerCamelCase__					(self   :						List[Any]				, _UpperCAmelCase   :						str		)						->       None:




							"""simple docstring"""


							lowercase__					      =		0
							for character in keyword:
									lowercase__					      =		self.find_next_state(_UpperCAmelCase				, _UpperCAmelCase		)
									if next_state is None:
											self.adlist.append(
											    {
											        """value""": character,
											        """next_states""": [],
											        """fail_state""": 0,
											        """output""": [],
											    }		)
											self.adlist[current_state]["next_states"].append(len(self.adlist		) - 1		)
											lowercase__					      =		len(self.adlist		) - 1
									else:
											lowercase__					      =		next_state
							self.adlist[current_state]["output"].append(_UpperCAmelCase		)

					def   lowerCamelCase__					(self   :						Any		)						->       None:




							"""simple docstring"""


							lowercase__					      =		deque()
							for node in self.adlist[0]["next_states"]:
									q.append(_UpperCAmelCase		)
									lowercase__					      =		0
							while q:
									lowercase__					      =		q.popleft()
									for child in self.adlist[r]["next_states"]:
											q.append(_UpperCAmelCase		)
											lowercase__					      =		self.adlist[r]["""fail_state"""]
											while (
											    self.find_next_state(_UpperCAmelCase				, self.adlist[child]["""value"""]		) is None
											    and state != 0
											):
													lowercase__					      =		self.adlist[state]["""fail_state"""]
											lowercase__					      =		self.find_next_state(
											    _UpperCAmelCase				, self.adlist[child]["""value"""]		)
											if self.adlist[child]["fail_state"] is None:
													lowercase__					      =		0
											lowercase__					      =		(
											    self.adlist[child]["""output"""]
											    + self.adlist[self.adlist[child]["""fail_state"""]]["""output"""]
											)


					def   lowerCamelCase__					(self   :						List[str]				, _UpperCAmelCase   :						str		)						->       dict[str, list[int]]:




							"""simple docstring"""


							lowercase__					      =		{}  # returns a dict with keywords and list of its occurrences
							lowercase__					      =		0
							for i in range(len(_UpperCAmelCase		)		):
									while (
									    self.find_next_state(_UpperCAmelCase				, string[i]		) is None
									    and current_state != 0
									):
											lowercase__					      =		self.adlist[current_state]["""fail_state"""]
									lowercase__					      =		self.find_next_state(_UpperCAmelCase				, string[i]		)
									if next_state is None:
											lowercase__					      =		0
									else:
											lowercase__					      =		next_state
											for key in self.adlist[current_state]["output"]:
													if key not in result:
															lowercase__					      =		[]
													result[key].append(i - len(_UpperCAmelCase		) + 1		)
							return result


if __name__ == "__main__":
	import doctest

	doctest.testmod()

