

"""simple docstring"""




import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 		_A       (			__a				,       unittest.TestCase					):
      __a								=	RobertaTokenizer
      __a								=	RobertaTokenizerFast
      __a								=	True
      __a								=	{'cls_token': '<s>'}





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         super().setUp()

         # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
         lowerCamelCase__						=			[
             "l",
             "o",
             "w",
             "e",
             "r",
             "s",
             "t",
             "i",
             "d",
             "n",
             "\u0120",
             "\u0120l",
             "\u0120n",
             "\u0120lo",
             "\u0120low",
             "er",
             "\u0120lowest",
             "\u0120newer",
             "\u0120wider",
             "<unk>",
         ]
         lowerCamelCase__						=			dict(zip(SCREAMING_SNAKE_CASE__    ,						range(len(SCREAMING_SNAKE_CASE__		)		)		)		)
         lowerCamelCase__						=			["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
         lowerCamelCase__						=			{"unk_token": "<unk>"}

         lowerCamelCase__						=			os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["vocab_file"]		)
         lowerCamelCase__						=			os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["merges_file"]		)
         with open(self.vocab_file    ,						"w"    ,						encoding="utf-8"		) as fp:
            fp.write(json.dumps(SCREAMING_SNAKE_CASE__		) + "\n"		)
         with open(self.merges_file    ,						"w"    ,						encoding="utf-8"		) as fp:
            fp.write("\n".join(SCREAMING_SNAKE_CASE__		)		)





      def 					_lowerCamelCase  (  self    ,						**SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         kwargs.update(self.special_tokens_map		)
         return self.tokenizer_class.from_pretrained(self.tmpdirname    ,						**SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						**SCREAMING_SNAKE_CASE__		)   ->					Union[str, Any]:
         kwargs.update(self.special_tokens_map		)
         return RobertaTokenizerFast.from_pretrained(self.tmpdirname    ,						**SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__		)   ->					Optional[Any]:
         lowerCamelCase__						=			"lower newer"
         lowerCamelCase__						=			"lower newer"
         return input_text, output_text





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			self.tokenizer_class(self.vocab_file    ,						self.merges_file    ,						**self.special_tokens_map		)
         lowerCamelCase__						=			"lower newer"
         lowerCamelCase__						=			["l", "o", "w", "er", "\u0120", "n", "e", "w", "er"]
         lowerCamelCase__						=			tokenizer.tokenize(SCREAMING_SNAKE_CASE__		)  # , add_prefix_space=True)
         self.assertListEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokens + [tokenizer.unk_token]
         lowerCamelCase__						=			[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__		)    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			self.get_tokenizer()

         self.assertListEqual(tokenizer.encode("Hello world!"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)    ,						[0, 31414, 232, 328, 2]		)
         self.assertListEqual(
             tokenizer.encode("Hello world! cécé herlolip 418"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)    ,						[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]    ,						)





      @slow
      def 					_lowerCamelCase  (  self		)   ->					Any:
         lowerCamelCase__						=			self.tokenizer_class.from_pretrained("roberta-base"		)

         lowerCamelCase__						=			tokenizer.encode("sequence builders"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.encode("multi-sequence build"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokenizer.encode(
             "sequence builders"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.encode(
             "sequence builders"    ,						"multi-sequence build"    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         assert encoded_sentence == encoded_text_from_decode
         assert encoded_pair == encoded_pair_from_decode





      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			self.get_tokenizer()

         lowerCamelCase__						=			"Encode this sequence."
         lowerCamelCase__						=			tokenizer.byte_encoder[" ".encode("utf-8"		)[0]]

         # Testing encoder arguments
         lowerCamelCase__						=			tokenizer.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.convert_ids_to_tokens(encoded[0]		)[0]
         self.assertNotEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokenizer.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.convert_ids_to_tokens(encoded[0]		)[0]
         self.assertEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         tokenizer.add_special_tokens({"bos_token": "<s>"}		)
         lowerCamelCase__						=			tokenizer.encode(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.convert_ids_to_tokens(encoded[1]		)[0]
         self.assertNotEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # Testing spaces after special tokens
         lowerCamelCase__						=			"<mask>"
         tokenizer.add_special_tokens(
             {"mask_token": AddedToken(SCREAMING_SNAKE_CASE__    ,						lstrip=SCREAMING_SNAKE_CASE__    ,						rstrip=SCREAMING_SNAKE_CASE__		)}		)  # mask token has a left space
         lowerCamelCase__						=			tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			"Encode <mask> sequence"
         lowerCamelCase__						=			"Encode <mask>sequence"

         lowerCamelCase__						=			tokenizer.encode(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			encoded.index(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]		)[0]
         self.assertEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			tokenizer.encode(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			encoded.index(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]		)[0]
         self.assertNotEqual(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self		)   ->					str:
         pass





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__    ,						**SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			"A, <mask> AllenNLP sentence."
               lowerCamelCase__						=			tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						return_token_type_ids=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_p.encode_plus(SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__    ,						return_token_type_ids=SCREAMING_SNAKE_CASE__		)

               # token_type_ids should put 0 everywhere
               self.assertEqual(sum(tokens_r["token_type_ids"]		)    ,						sum(tokens_p["token_type_ids"]		)		)

               # attention_mask should put 1 everywhere, so sum over length should be 1
               self.assertEqual(
                   sum(tokens_r["attention_mask"]		) / len(tokens_r["attention_mask"]		)    ,						sum(tokens_p["attention_mask"]		) / len(tokens_p["attention_mask"]		)    ,						)

               lowerCamelCase__						=			tokenizer_r.convert_ids_to_tokens(tokens_r["input_ids"]		)
               lowerCamelCase__						=			tokenizer_p.convert_ids_to_tokens(tokens_p["input_ids"]		)

               # Rust correctly handles the space before the mask while python doesnt
               self.assertSequenceEqual(tokens_p["input_ids"]    ,						[0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]		)
               self.assertSequenceEqual(tokens_r["input_ids"]    ,						[0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]		)

               self.assertSequenceEqual(
                   SCREAMING_SNAKE_CASE__    ,						["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]		)
               self.assertSequenceEqual(
                   SCREAMING_SNAKE_CASE__    ,						["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]		)





      def 					_lowerCamelCase  (  self		)   ->					int:
         for trim_offsets, add_prefix_space in itertools.product([True, False]    ,						repeat=2		):
            lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                self.tmpdirname    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)

            lowerCamelCase__						=			json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()		)
            lowerCamelCase__						=			json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()		)

            self.assertEqual(pre_tokenizer_state["add_prefix_space"]    ,						SCREAMING_SNAKE_CASE__		)

            self.assertEqual(post_processor_state["add_prefix_space"]    ,						SCREAMING_SNAKE_CASE__		)
            self.assertEqual(post_processor_state["trim_offsets"]    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
         # `trim_offsets`
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
               lowerCamelCase__						=			"hello"  # `hello` is a token in the vocabulary of `pretrained_name`
               lowerCamelCase__						=			f'{text_of_1_token} {text_of_1_token}'

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(len(SCREAMING_SNAKE_CASE__		) + 1, len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(len(SCREAMING_SNAKE_CASE__		) + 1, len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(len(SCREAMING_SNAKE_CASE__		), len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(len(SCREAMING_SNAKE_CASE__		), len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			f' {text}'

               # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
               #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
               # )
               # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
               # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
               # self.assertEqual(
               #     encoding.offset_mapping[1],
               #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
               # )

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(1, 1 + len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(1 + len(SCREAMING_SNAKE_CASE__		) + 1, 1 + len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, 1 + len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(1 + len(SCREAMING_SNAKE_CASE__		), 1 + len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)

               lowerCamelCase__						=			self.rust_tokenizer_class.from_pretrained(
                   SCREAMING_SNAKE_CASE__    ,						use_fast=SCREAMING_SNAKE_CASE__    ,						add_prefix_space=SCREAMING_SNAKE_CASE__    ,						trim_offsets=SCREAMING_SNAKE_CASE__		)
               lowerCamelCase__						=			tokenizer_r(SCREAMING_SNAKE_CASE__    ,						return_offsets_mapping=SCREAMING_SNAKE_CASE__    ,						add_special_tokens=SCREAMING_SNAKE_CASE__		)
               self.assertEqual(encoding.offset_mapping[0]    ,						(0, 1 + len(SCREAMING_SNAKE_CASE__		))		)
               self.assertEqual(
                   encoding.offset_mapping[1]    ,						(1 + len(SCREAMING_SNAKE_CASE__		), 1 + len(SCREAMING_SNAKE_CASE__		) + 1 + len(SCREAMING_SNAKE_CASE__		))    ,						)







"""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 		_A       (			__a				,       __a				,       unittest.TestCase					):
      __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		)   ->					Tuple:
         return self._get_dummy_components()





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=0		)   ->					Union[str, Any]:
         if str(SCREAMING_SNAKE_CASE__		).startswith("mps"		):
            lowerCamelCase__						=			torch.manual_seed(SCREAMING_SNAKE_CASE__		)
         else:
            lowerCamelCase__						=			torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)

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

         return inputs





      def 					_lowerCamelCase  (  self		)   ->					str:
         self._test_save_load_optional_components()





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





      def 					_lowerCamelCase  (  self		)   ->					int:
         self._test_save_load_local()





      def 					_lowerCamelCase  (  self		)   ->					List[Any]:
         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		)   ->					List[str]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3		)






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





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





      def 					_lowerCamelCase  (  self		)   ->					str:
         # if

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

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

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

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					int:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

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

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Tuple:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

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

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

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

         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"		)
         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         # pipeline 2

         _start_torch_memory_measurement()

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

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         lowerCamelCase__						=			torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 10**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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)






def 	UpperCAmelCase__   (				)      ->      Union[str, Any]:




   """simple docstring"""
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()




