





"""simple docstring"""




import os
import string
import sys


a		:				Dict  			=    1 << 8

a		:				List[str]  			=    {
    '''tab''': ord('''\t'''),
    '''newline''': ord('''\r'''),
    '''esc''': 27,
    '''up''': 65 + ARROW_KEY_FLAG,
    '''down''': 66 + ARROW_KEY_FLAG,
    '''right''': 67 + ARROW_KEY_FLAG,
    '''left''': 68 + ARROW_KEY_FLAG,
    '''mod_int''': 91,
    '''undefined''': sys.maxsize,
    '''interrupt''': 3,
    '''insert''': 50,
    '''delete''': 51,
    '''pg_up''': 53,
    '''pg_down''': 54,
}

a		:				int  			=    KEYMAP['''up''']
a		:				List[str]  			=    KEYMAP['''left''']

if sys.platform == "win32":
		a		:				List[str]  			=    []
		a		:				Dict  			=    {
		    b'''\xe0H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
		    b'''\x00H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
		    b'''\xe0P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
		    b'''\x00P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
		    b'''\xe0M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
		    b'''\x00M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
		    b'''\xe0K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
		    b'''\x00K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
		}

for i in range(10):
		a		:				Any  			=    ord(str(i))






def    _SCREAMING_SNAKE_CASE	(			)				->Dict:






	'''simple docstring'''






	if os.name == "nt":
		import msvcrt

		a   :	Any			=       "mbcs"
		# Flush the keyboard buffer
		while msvcrt.kbhit():
			msvcrt.getch()
		if len(_lowercase      ) == 0:
			# Read the keystroke
			a   :	Dict			=       msvcrt.getch()

			# If it is a prefix char, get second part
			if ch in (b"\x00", b"\xe0"):
				a   :	List[Any]			=       ch + msvcrt.getch()
				# Translate actual Win chars to bullet char types
				try:
					a   :	Optional[Any]			=       chr(WIN_KEYMAP[cha]      )
					WIN_CH_BUFFER.append(chr(KEYMAP["mod_int"]      )      )
					WIN_CH_BUFFER.append(_lowercase      )
					if ord(_lowercase      ) in (
					    KEYMAP["insert"] - 1 << 9,
					    KEYMAP["delete"] - 1 << 9,
					    KEYMAP["pg_up"] - 1 << 9,
					    KEYMAP["pg_down"] - 1 << 9,
					):
						WIN_CH_BUFFER.append(chr(126      )      )
					a   :	List[str]			=       chr(KEYMAP["esc"]      )
				except KeyError:
					a   :	Any			=       cha[1]
			else:
				a   :	str			=       ch.decode(_lowercase      )
		else:
			a   :	int			=       WIN_CH_BUFFER.pop(0      )
	elif os.name == "posix":
		import termios
		import tty

		a   :	Optional[int]			=       sys.stdin.fileno()
		a   :	List[Any]			=       termios.tcgetattr(_lowercase      )
		try:
			tty.setraw(_lowercase      )
			a   :	Optional[int]			=       sys.stdin.read(1      )
		finally:
			termios.tcsetattr(_lowercase					, termios.TCSADRAIN					, _lowercase      )
	return ch







def    _SCREAMING_SNAKE_CASE	(			)				->Optional[Any]:






	'''simple docstring'''






	a   :	Tuple			=       get_raw_chars()
	if ord(_lowercase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
		return char

	elif ord(_lowercase      ) == KEYMAP["esc"]:
		a   :	Optional[int]			=       get_raw_chars()
		if ord(_lowercase      ) == KEYMAP["mod_int"]:
			a   :	Optional[Any]			=       get_raw_chars()
			if ord(_lowercase      ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(_lowercase      ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
				return chr(ord(_lowercase      ) + ARROW_KEY_FLAG      )
			else:
				return KEYMAP["undefined"]
		else:
			return get_raw_chars()

	else:
		if char in string.printable:
			return char
		else:
			return KEYMAP["undefined"]









"""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  __UpperCamelCase       (		a__	, a__	, unittest.TestCase		):
							lowerCamelCase     :      Dict         =IFPipeline
							lowerCamelCase     :      int         =TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
							lowerCamelCase     :      int         =TEXT_TO_IMAGE_BATCH_PARAMS
							lowerCamelCase     :      int         =PipelineTesterMixin.required_optional_params - {"""latents"""}






							def 					__a     (     self   )			->				List[str]:
								return self._get_dummy_components()






							def 					__a     (     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__=0   )			->				Dict:
								if str(lowerCAmelCase__   ).startswith("mps"   ):
									a   :	Tuple			=       torch.manual_seed(lowerCAmelCase__   )
								else:
									a   :	int			=       torch.Generator(device=lowerCAmelCase__   ).manual_seed(lowerCAmelCase__   )

								a   :	Optional[Any]			=       {
								    "prompt": "A painting of a squirrel eating a burger",
								    "generator": generator,
								    "num_inference_steps": 2,
								    "output_type": "numpy",
								}

								return inputs






							def 					__a     (     self   )			->				Union[str, Any]:
								self._test_save_load_optional_components()






							@unittest.skipIf(torch_device != "cuda"   ,      reason="float16 requires CUDA"   )
							def 					__a     (     self   )			->				Any:
								# 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 					__a     (     self   )			->				Union[str, Any]:
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )






							def 					__a     (     self   )			->				Optional[int]:
								self._test_save_load_local()






							def 					__a     (     self   )			->				Tuple:
								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 					__a     (     self   )			->				str:
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )


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






							def 					__a     (     self   )			->				Optional[Any]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






							def 					__a     (     self   )			->				Tuple:
								# if

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

								a   :	str			=       IFSuperResolutionPipeline.from_pretrained(
								    "DeepFloyd/IF-II-L-v1.0"   ,      variant="fp16"   ,      torch_dtype=torch.floataa   ,      text_encoder=lowerCAmelCase__   ,      tokenizer=lowerCAmelCase__   )

								# pre compute text embeddings and remove T5 to save memory

								pipe_a.text_encoder.to("cuda"   )

								a, a   :	List[str]			=       pipe_a.encode_prompt("anime turtle"   ,      device="cuda"   )

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

								a   :	Optional[int]			=       None
								a   :	Optional[int]			=       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(lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# img2img

								a   :	Union[str, Any]			=       IFImgaImgPipeline(**pipe_a.components   )
								a   :	List[Any]			=       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(lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# inpainting

								a   :	Union[str, Any]			=       IFInpaintingPipeline(**pipe_a.components   )
								a   :	List[str]			=       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(lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )			->				Dict:
								# pipeline 1

								_start_torch_memory_measurement()

								a   :	List[str]			=       torch.Generator(device="cpu"   ).manual_seed(0   )
								a   :	Dict			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      num_inference_steps=2   ,      generator=lowerCAmelCase__   ,      output_type="np"   ,      )

								a   :	List[str]			=       output.images[0]

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

								a   :	Dict			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 13 * 10**9

								a   :	Optional[Any]			=       load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"   )
								assert_mean_pixel_difference(lowerCAmelCase__   ,      lowerCAmelCase__   )

								# pipeline 2

								_start_torch_memory_measurement()

								a   :	List[str]			=       torch.Generator(device="cpu"   ).manual_seed(0   )

								a   :	Optional[int]			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )

								a   :	Union[str, Any]			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      image=lowerCAmelCase__   ,      generator=lowerCAmelCase__   ,      num_inference_steps=2   ,      output_type="np"   ,      )

								a   :	List[str]			=       output.images[0]

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

								a   :	int			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								a   :	Union[str, 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(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )			->				int:
								# pipeline 1

								_start_torch_memory_measurement()

								a   :	int			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )

								a   :	Tuple			=       torch.Generator(device="cpu"   ).manual_seed(0   )

								a   :	List[Any]			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      image=lowerCAmelCase__   ,      num_inference_steps=2   ,      generator=lowerCAmelCase__   ,      output_type="np"   ,      )

								a   :	Tuple			=       output.images[0]

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

								a   :	int			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								a   :	Optional[int]			=       load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"   )
								assert_mean_pixel_difference(lowerCAmelCase__   ,      lowerCAmelCase__   )

								# pipeline 2

								_start_torch_memory_measurement()

								a   :	Optional[int]			=       torch.Generator(device="cpu"   ).manual_seed(0   )

								a   :	List[Any]			=       floats_tensor((1, 3, 256, 256)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )
								a   :	str			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )

								a   :	Dict			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      image=lowerCAmelCase__   ,      original_image=lowerCAmelCase__   ,      generator=lowerCAmelCase__   ,      num_inference_steps=2   ,      output_type="np"   ,      )

								a   :	int			=       output.images[0]

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

								a   :	str			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								a   :	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(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )			->				Optional[int]:
								# pipeline 1

								_start_torch_memory_measurement()

								a   :	Union[str, Any]			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )
								a   :	List[Any]			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(1   )   ).to(lowerCAmelCase__   )

								a   :	Optional[int]			=       torch.Generator(device="cpu"   ).manual_seed(0   )
								a   :	List[str]			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      image=lowerCAmelCase__   ,      mask_image=lowerCAmelCase__   ,      num_inference_steps=2   ,      generator=lowerCAmelCase__   ,      output_type="np"   ,      )

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

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

								a   :	Tuple			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								a   :	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(lowerCAmelCase__   ,      lowerCAmelCase__   )

								# pipeline 2

								_start_torch_memory_measurement()

								a   :	str			=       torch.Generator(device="cpu"   ).manual_seed(0   )

								a   :	Optional[int]			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )
								a   :	int			=       floats_tensor((1, 3, 256, 256)   ,      rng=random.Random(0   )   ).to(lowerCAmelCase__   )
								a   :	Dict			=       floats_tensor((1, 3, 256, 256)   ,      rng=random.Random(1   )   ).to(lowerCAmelCase__   )

								a   :	Optional[int]			=       pipe_a(
								    prompt_embeds=lowerCAmelCase__   ,      negative_prompt_embeds=lowerCAmelCase__   ,      image=lowerCAmelCase__   ,      mask_image=lowerCAmelCase__   ,      original_image=lowerCAmelCase__   ,      generator=lowerCAmelCase__   ,      num_inference_steps=2   ,      output_type="np"   ,      )

								a   :	List[str]			=       output.images[0]

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

								a   :	Tuple			=       torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								a   :	Optional[Any]			=       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(lowerCAmelCase__   ,      lowerCAmelCase__   )






def    _SCREAMING_SNAKE_CASE	(			)				->List[str]:






	'''simple docstring'''






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


