





"""simple docstring"""




import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


a		:				List[Any]  			=    get_tests_dir('''fixtures/spiece.model''')


@require_sentencepiece
@require_tokenizers
class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      int         =DebertaVaTokenizer
							lowerCamelCase     :      List[str]         =DebertaVaTokenizerFast
							lowerCamelCase     :      Tuple         =True
							lowerCamelCase     :      Any         =True






							def 					__a     (     self   )			->				List[str]:
								super().setUp()

								# We have a SentencePiece fixture for testing
								a   :	List[str]			=       DebertaVaTokenizer(lowerCAmelCase__   ,      unk_token="<unk>"   )
								tokenizer.save_pretrained(self.tmpdirname   )






							def 					__a     (     self   ,      lowerCAmelCase__   )			->				Tuple:
								a   :	Tuple			=       "this is a test"
								a   :	int			=       "this is a test"
								return input_text, output_text






							def 					__a     (     self   )			->				int:
								a   :	Any			=       "<pad>"
								a   :	Dict			=       0

								self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCAmelCase__   )   ,      lowerCAmelCase__   )
								self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCAmelCase__   )   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				List[str]:
								a   :	Any			=       list(self.get_tokenizer().get_vocab().keys()   )
								self.assertEqual(vocab_keys[0]   ,      "<pad>"   )
								self.assertEqual(vocab_keys[1]   ,      "<unk>"   )
								self.assertEqual(vocab_keys[-1]   ,      "[PAD]"   )
								self.assertEqual(len(lowerCAmelCase__   )   ,      3_0001   )






							def 					__a     (     self   )			->				List[Any]:
								self.assertEqual(self.get_tokenizer().vocab_size   ,      3_0000   )






							def 					__a     (     self   )			->				List[Any]:
								# fmt: off
								a   :	Tuple			=       " \tHeLLo!how  \n Are yoU?  "
								a   :	Union[str, Any]			=       ["▁hello", "!", "how", "▁are", "▁you", "?"]
								# fmt: on

								a   :	List[str]			=       DebertaVaTokenizer(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   )
								a   :	int			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	List[str]			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   )
								a   :	str			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							@unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."   )
							def 					__a     (     self   )			->				List[Any]:
								pass






							@unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."   )
							def 					__a     (     self   )			->				List[str]:
								pass






							def 					__a     (     self   )			->				Any:
								# fmt: off
								a   :	Union[str, Any]			=       "I was born in 92000, and this is falsé."
								a   :	str			=       ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
								# fmt: on

								a   :	Tuple			=       DebertaVaTokenizer(lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	Any			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	Dict			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	Union[str, Any]			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Any:
								# fmt: off
								a   :	Any			=       "I was born in 92000, and this is falsé."
								a   :	Any			=       ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
								# fmt: on

								a   :	Optional[int]			=       DebertaVaTokenizer(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	Optional[int]			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	List[Any]			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	List[str]			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Union[str, Any]:
								# fmt: off
								a   :	Optional[int]			=       "I was born in 92000, and this is falsé."
								a   :	Dict			=       ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
								# fmt: on

								a   :	Tuple			=       DebertaVaTokenizer(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	int			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	Dict			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	str			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Union[str, Any]:
								# fmt: off
								a   :	Dict			=       "I was born in 92000, and this is falsé."
								a   :	str			=       ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
								# fmt: on

								a   :	Optional[Any]			=       DebertaVaTokenizer(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	Union[str, Any]			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	str			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	List[Any]			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Dict:
								# fmt: off
								a   :	Dict			=       " \tHeLLo!how  \n Are yoU?  "
								a   :	Optional[Any]			=       ["▁", "<unk>", "e", "<unk>", "o", "!", "how", "▁", "<unk>", "re", "▁yo", "<unk>", "?"]
								# fmt: on

								a   :	List[Any]			=       DebertaVaTokenizer(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	str			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	List[str]			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      do_lower_case=lowerCAmelCase__   ,      split_by_punct=lowerCAmelCase__   )
								a   :	int			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )

								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				List[str]:
								a   :	List[str]			=       self.get_tokenizer()
								a   :	Optional[Any]			=       self.get_rust_tokenizer()

								a   :	Union[str, Any]			=       "I was born in 92000, and this is falsé."

								a   :	Union[str, Any]			=       tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )
								a   :	List[str]			=       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	Tuple			=       tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								a   :	Optional[Any]			=       rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	Any			=       self.get_rust_tokenizer()
								a   :	Dict			=       tokenizer.encode(lowerCAmelCase__   )
								a   :	Optional[int]			=       rust_tokenizer.encode(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Dict:
								a   :	Tuple			=       "This is a test"
								a   :	Optional[int]			=       [13, 1, 4398, 25, 21, 1289]
								a   :	Tuple			=       ["▁", "T", "his", "▁is", "▁a", "▁test"]
								a   :	Optional[Any]			=       ["▁", "<unk>", "his", "▁is", "▁a", "▁test"]

								a   :	int			=       DebertaVaTokenizer(lowerCAmelCase__   ,      keep_accents=lowerCAmelCase__   )
								a   :	Union[str, Any]			=       DebertaVaTokenizerFast(lowerCAmelCase__   ,      keep_accents=lowerCAmelCase__   )

								a   :	Optional[Any]			=       tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	List[Any]			=       tokenizer.tokenize(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	Union[str, Any]			=       tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	int			=       rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	List[str]			=       rust_tokenizer.tokenize(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	List[str]			=       rust_tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								# fmt: off
								a   :	Dict			=       "I was born in 92000, and this is falsé."
								a   :	Optional[Any]			=       [13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
								a   :	Optional[int]			=       ["▁", "I", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "é", ".", ]
								a   :	int			=       ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
								# fmt: on

								a   :	Optional[int]			=       tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	int			=       tokenizer.tokenize(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	Any			=       tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )

								a   :	Tuple			=       rust_tokenizer.encode(lowerCAmelCase__   ,      add_special_tokens=lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	List[Any]			=       rust_tokenizer.tokenize(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
								a   :	str			=       rust_tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
								self.assertListEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )






							def 					__a     (     self   )			->				Tuple:
								a   :	Optional[int]			=       DebertaVaTokenizer(lowerCAmelCase__   )

								a   :	Optional[Any]			=       tokenizer.encode("sequence builders"   )
								a   :	int			=       tokenizer.encode("multi-sequence build"   )

								a   :	Tuple			=       tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__   )
								a   :	Dict			=       tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__   ,      lowerCAmelCase__   )

								self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]   ,      lowerCAmelCase__   )
								self.assertEqual(
								    [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]   ,      lowerCAmelCase__   ,      )






							@slow
							def 					__a     (     self   )			->				List[str]:
								# fmt: off
								a   :	Any			=       {"input_ids": [[1, 3_9867, 36, 1_9390, 486, 27, 3_5052, 8_1436, 18, 6_0685, 1225, 7, 3_5052, 8_1436, 18, 9367, 1_6899, 18, 1_5937, 53, 594, 773, 18, 1_6287, 3_0465, 36, 1_5937, 6, 4_1139, 38, 3_6979, 6_0763, 191, 6, 3_4132, 99, 6, 5_0538, 390, 4_3230, 6, 3_4132, 2779, 2_0850, 14, 699, 1072, 1194, 36, 382, 1_0901, 53, 7, 699, 1072, 2084, 36, 2_0422, 630, 53, 19, 105, 3049, 1896, 1053, 1_6899, 1506, 11, 3_7978, 4243, 7, 1237, 3_1869, 200, 1_6566, 654, 6, 3_5052, 8_1436, 7, 5_5630, 1_3593, 4, 2], [1, 26, 1_5011, 13, 667, 8, 1053, 18, 2_3611, 1237, 7_2356, 1_2820, 34, 10_4134, 1209, 35, 1_3313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1232, 2864, 1_5785, 1_4951, 105, 5, 8581, 1250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
								# fmt: on

								self.tokenizer_integration_test_util(
								    expected_encoding=lowerCAmelCase__   ,      model_name="microsoft/deberta-v2-xlarge"   ,      revision="ad6e42c1532ddf3a15c39246b63f5559d558b670"   ,      )









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


