


import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


SCREAMING_SNAKE_CASE__					:     Optional[int]       =     '▁'

SCREAMING_SNAKE_CASE__					:     Optional[Any]       =     get_tests_dir('fixtures/test_sentencepiece.model')


@require_sentencepiece
class 		_SCREAMING_SNAKE_CASE     (						A							,	unittest.TestCase     ):
     __SCREAMING_SNAKE_CASE     					=    BertGenerationTokenizer
     __SCREAMING_SNAKE_CASE     					=    False
     __SCREAMING_SNAKE_CASE     					=    True


     def        __snake_case(  self    ):
       super().setUp()

       _UpperCAmelCase		:							Optional[int]							=     BertGenerationTokenizer(A_							,					keep_accents=A_    )
       tokenizer.save_pretrained(self.tmpdirname    )


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[int]							=     """<s>"""
       _UpperCAmelCase		:							Any							=     1

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


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[int]							=     list(self.get_tokenizer().get_vocab().keys()    )

       self.assertEqual(vocab_keys[0]							,					"""<unk>"""    )
       self.assertEqual(vocab_keys[1]							,					"""<s>"""    )
       self.assertEqual(vocab_keys[-1]							,					"""<pad>"""    )
       self.assertEqual(len(A_    )							,					10_02    )


     def        __snake_case(  self    ):
       self.assertEqual(self.get_tokenizer().vocab_size							,					10_00    )


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Union[str, Any]							=     BertGenerationTokenizer(A_							,					keep_accents=A_    )

       _UpperCAmelCase		:							List[Any]							=     tokenizer.tokenize("""This is a test"""    )
       self.assertListEqual(A_							,					["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]    )

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(A_    )							,					[2_85, 46, 10, 1_70, 3_82]							,					)

       _UpperCAmelCase		:							int							=     tokenizer.tokenize("""I was born in 92000, and this is falsé."""    )
       self.assertListEqual(
           A_							,					[
               SPIECE_UNDERLINE + """I""",
               SPIECE_UNDERLINE + """was""",
               SPIECE_UNDERLINE + """b""",
               """or""",
               """n""",
               SPIECE_UNDERLINE + """in""",
               SPIECE_UNDERLINE + """""",
               """9""",
               """2""",
               """0""",
               """0""",
               """0""",
               """,""",
               SPIECE_UNDERLINE + """and""",
               SPIECE_UNDERLINE + """this""",
               SPIECE_UNDERLINE + """is""",
               SPIECE_UNDERLINE + """f""",
               """al""",
               """s""",
               """é""",
               """.""",
           ]							,					)
       _UpperCAmelCase		:							List[str]							=     tokenizer.convert_tokens_to_ids(A_    )
       self.assertListEqual(
           A_							,					[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]							,					)

       _UpperCAmelCase		:							Tuple							=     tokenizer.convert_ids_to_tokens(A_    )
       self.assertListEqual(
           A_							,					[
               SPIECE_UNDERLINE + """I""",
               SPIECE_UNDERLINE + """was""",
               SPIECE_UNDERLINE + """b""",
               """or""",
               """n""",
               SPIECE_UNDERLINE + """in""",
               SPIECE_UNDERLINE + """""",
               """<unk>""",
               """2""",
               """0""",
               """0""",
               """0""",
               """,""",
               SPIECE_UNDERLINE + """and""",
               SPIECE_UNDERLINE + """this""",
               SPIECE_UNDERLINE + """is""",
               SPIECE_UNDERLINE + """f""",
               """al""",
               """s""",
               """<unk>""",
               """.""",
           ]							,					)


     @cached_property
     def        __snake_case(  self    ):
       return BertGenerationTokenizer.from_pretrained("""google/bert_for_seq_generation_L-24_bbc_encoder"""    )


     @slow
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[Any]							=     """Hello World!"""
       _UpperCAmelCase		:							str							=     [1_85_36, 22_60, 1_01]

       self.assertListEqual(A_							,					self.big_tokenizer.encode(A_    )    )


     @slow
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							List[str]							=     (
           """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
           """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
       )
       _UpperCAmelCase		:							List[Any]							=     [
           8_71,
           4_19,
           3_58,
           9_46,
           9_91,
           25_21,
           4_52,
           3_58,
           13_57,
           3_87,
           77_51,
           35_36,
           1_12,
           9_85,
           4_56,
           1_26,
           8_65,
           9_38,
           54_00,
           57_34,
           4_58,
           13_68,
           4_67,
           7_86,
           24_62,
           52_46,
           11_59,
           6_33,
           8_65,
           45_19,
           4_57,
           5_82,
           8_52,
           25_57,
           4_27,
           9_16,
           5_08,
           4_05,
           3_43_24,
           4_97,
           3_91,
           4_08,
           1_13_42,
           12_44,
           3_85,
           1_00,
           9_38,
           9_85,
           4_56,
           5_74,
           3_62,
           1_25_97,
           32_00,
           31_29,
           11_72,
       ]

       self.assertListEqual(A_							,					self.big_tokenizer.encode(A_    )    )


     @require_torch
     @slow
     def        __snake_case(  self    ):
       import torch

       from transformers import BertGenerationConfig, BertGenerationEncoder

       # Build sequence
       _UpperCAmelCase		:							Optional[Any]							=     list(self.big_tokenizer.get_vocab().keys()    )[:10]
       _UpperCAmelCase		:							Tuple							=     """ """.join(A_    )
       _UpperCAmelCase		:							List[Any]							=     self.big_tokenizer.encode_plus(A_							,					return_tensors="""pt"""							,					return_token_type_ids=A_    )
       _UpperCAmelCase		:							Any							=     self.big_tokenizer.batch_encode_plus(
           [sequence + """ """ + sequence]							,					return_tensors="""pt"""							,					return_token_type_ids=A_    )

       _UpperCAmelCase		:							int							=     BertGenerationConfig()
       _UpperCAmelCase		:							Dict							=     BertGenerationEncoder(A_    )

       assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

       with torch.no_grad():
         model(**A_    )
         model(**A_    )




     @slow
     def        __snake_case(  self    ):
       # fmt: off
       _UpperCAmelCase		:							Optional[int]							=     {"""input_ids""": [[3_92_86, 4_58, 3_63_35, 20_01, 4_56, 1_30_73, 1_32_66, 4_55, 1_13, 77_46, 17_41, 1_11_57, 3_91, 1_30_73, 1_32_66, 4_55, 1_13, 39_67, 3_54_12, 1_13, 49_36, 1_09, 38_70, 23_77, 1_13, 3_00_84, 4_57_20, 4_58, 1_34, 1_74_96, 1_12, 5_03, 1_16_72, 1_13, 1_18, 1_12, 56_65, 1_33_47, 3_86_87, 1_12, 14_96, 3_13_89, 1_12, 32_68, 4_72_64, 1_34, 9_62, 1_12, 1_63_77, 80_35, 2_31_30, 4_30, 1_21_69, 1_55_18, 2_85_92, 4_58, 1_46, 4_16_97, 1_09, 3_91, 1_21_69, 1_55_18, 1_66_89, 4_58, 1_46, 4_13_58, 1_09, 4_52, 7_26, 40_34, 1_11, 7_63, 3_54_12, 50_82, 3_88, 19_03, 1_11, 90_51, 3_91, 28_70, 4_89_18, 19_00, 11_23, 5_50, 9_98, 1_12, 95_86, 1_59_85, 4_55, 3_91, 4_10, 2_29_55, 3_76_36, 1_14], [4_48, 1_74_96, 4_19, 36_63, 3_85, 7_63, 1_13, 2_75_33, 28_70, 32_83, 1_30_43, 16_39, 2_47_13, 5_23, 6_56, 2_40_13, 1_85_50, 25_21, 5_17, 2_70_14, 2_12_44, 4_20, 12_12, 14_65, 3_91, 9_27, 48_33, 3_88, 5_78, 1_17_86, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4_84, 21_69, 76_87, 2_19_32, 1_81_46, 7_26, 3_63, 1_70_32, 33_91, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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], [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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
       # fmt: on

       self.tokenizer_integration_test_util(
           expected_encoding=A_							,					model_name="""google/bert_for_seq_generation_L-24_bbc_encoder"""							,					revision="""c817d1fd1be2ffa69431227a1fe320544943d4db"""							,					)









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 		_SCREAMING_SNAKE_CASE     (						A							,	A							,	unittest.TestCase     ):
     __SCREAMING_SNAKE_CASE     					=    IFPipeline
     __SCREAMING_SNAKE_CASE     					=    TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
     __SCREAMING_SNAKE_CASE     					=    TEXT_TO_IMAGE_BATCH_PARAMS
     __SCREAMING_SNAKE_CASE     					=    PipelineTesterMixin.required_optional_params - {'''latents'''}


     def        __snake_case(  self    ):
       return self._get_dummy_components()


     def        __snake_case(  self							,					A_							,					A_=0    ):
       if str(A_    ).startswith("""mps"""    ):
         _UpperCAmelCase		:							Tuple							=     torch.manual_seed(A_    )
       else:
         _UpperCAmelCase		:							Optional[Any]							=     torch.Generator(device=A_    ).manual_seed(A_    )

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

       return inputs


     def        __snake_case(  self    ):
       self._test_save_load_optional_components()


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


     def        __snake_case(  self    ):
       self._test_save_load_local()


     def        __snake_case(  self    ):
       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        __snake_case(  self    ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )


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


     def        __snake_case(  self    ):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()


     def        __snake_case(  self    ):
       # if

       _UpperCAmelCase		:							List[str]							=     IFPipeline.from_pretrained("""DeepFloyd/IF-I-XL-v1.0"""							,					variant="""fp16"""							,					torch_dtype=torch.floataa    )

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

       # pre compute text embeddings and remove T5 to save memory

       pipe_a.text_encoder.to("""cuda"""    )

       _UpperCAmelCase,_UpperCAmelCase		:							Dict							=     pipe_a.encode_prompt("""anime turtle"""							,					device="""cuda"""    )

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

       _UpperCAmelCase		:							List[Any]							=     None
       _UpperCAmelCase		:							Any							=     None

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

       self._test_if(A_							,					A_							,					A_							,					A_    )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # img2img

       _UpperCAmelCase		:							Any							=     IFImgaImgPipeline(**pipe_a.components    )
       _UpperCAmelCase		:							Union[str, 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(A_							,					A_							,					A_							,					A_    )

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # inpainting

       _UpperCAmelCase		:							Optional[int]							=     IFInpaintingPipeline(**pipe_a.components    )
       _UpperCAmelCase		:							Union[str, Any]							=     IFInpaintingSuperResolutionPipeline(**pipe_a.components    )

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

       self._test_if_inpainting(A_							,					A_							,					A_							,					A_    )


     def        __snake_case(  self							,					A_							,					A_							,					A_							,					A_    ):
       # pipeline 1

       _start_torch_memory_measurement()

       _UpperCAmelCase		:							Optional[Any]							=     torch.Generator(device="""cpu"""    ).manual_seed(0    )
       _UpperCAmelCase		:							List[str]							=     pipe_a(
           prompt_embeds=A_							,					negative_prompt_embeds=A_							,					num_inference_steps=2							,					generator=A_							,					output_type="""np"""							,					)

       _UpperCAmelCase		:							int							=     output.images[0]

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

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

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

       # pipeline 2

       _start_torch_memory_measurement()

       _UpperCAmelCase		:							List[Any]							=     torch.Generator(device="""cpu"""    ).manual_seed(0    )

       _UpperCAmelCase		:							str							=     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(A_    )

       _UpperCAmelCase		:							str							=     pipe_a(
           prompt_embeds=A_							,					negative_prompt_embeds=A_							,					image=A_							,					generator=A_							,					num_inference_steps=2							,					output_type="""np"""							,					)

       _UpperCAmelCase		:							int							=     output.images[0]

       assert image.shape == (2_56, 2_56, 3)

       _UpperCAmelCase		:							Any							=     torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _UpperCAmelCase		:							List[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(A_							,					A_    )


     def        __snake_case(  self							,					A_							,					A_							,					A_							,					A_    ):
       # pipeline 1

       _start_torch_memory_measurement()

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

       _UpperCAmelCase		:							Dict							=     torch.Generator(device="""cpu"""    ).manual_seed(0    )

       _UpperCAmelCase		:							List[str]							=     pipe_a(
           prompt_embeds=A_							,					negative_prompt_embeds=A_							,					image=A_							,					num_inference_steps=2							,					generator=A_							,					output_type="""np"""							,					)

       _UpperCAmelCase		:							int							=     output.images[0]

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

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

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

       # pipeline 2

       _start_torch_memory_measurement()

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

       _UpperCAmelCase		:							Union[str, Any]							=     floats_tensor((1, 3, 2_56, 2_56)							,					rng=random.Random(0    )    ).to(A_    )
       _UpperCAmelCase		:							Optional[int]							=     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(A_    )

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

       _UpperCAmelCase		:							Dict							=     output.images[0]

       assert image.shape == (2_56, 2_56, 3)

       _UpperCAmelCase		:							Any							=     torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _UpperCAmelCase		:							int							=     load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy"""    )
       assert_mean_pixel_difference(A_							,					A_    )




     def        __snake_case(  self							,					A_							,					A_							,					A_							,					A_    ):
       # pipeline 1

       _start_torch_memory_measurement()

       _UpperCAmelCase		:							List[Any]							=     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(A_    )
       _UpperCAmelCase		:							Dict							=     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(1    )    ).to(A_    )

       _UpperCAmelCase		:							Optional[Any]							=     torch.Generator(device="""cpu"""    ).manual_seed(0    )
       _UpperCAmelCase		:							str							=     pipe_a(
           prompt_embeds=A_							,					negative_prompt_embeds=A_							,					image=A_							,					mask_image=A_							,					num_inference_steps=2							,					generator=A_							,					output_type="""np"""							,					)

       _UpperCAmelCase		:							Optional[Any]							=     output.images[0]

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

       _UpperCAmelCase		:							List[str]							=     torch.cuda.max_memory_allocated()
       assert mem_bytes < 10 * 10**9

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

       # pipeline 2

       _start_torch_memory_measurement()

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

       _UpperCAmelCase		:							Optional[int]							=     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(A_    )
       _UpperCAmelCase		:							Tuple							=     floats_tensor((1, 3, 2_56, 2_56)							,					rng=random.Random(0    )    ).to(A_    )
       _UpperCAmelCase		:							str							=     floats_tensor((1, 3, 2_56, 2_56)							,					rng=random.Random(1    )    ).to(A_    )

       _UpperCAmelCase		:							Union[str, Any]							=     pipe_a(
           prompt_embeds=A_							,					negative_prompt_embeds=A_							,					image=A_							,					mask_image=A_							,					original_image=A_							,					generator=A_							,					num_inference_steps=2							,					output_type="""np"""							,					)

       _UpperCAmelCase		:							Any							=     output.images[0]

       assert image.shape == (2_56, 2_56, 3)

       _UpperCAmelCase		:							Optional[int]							=     torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _UpperCAmelCase		:							Tuple							=     load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy"""    )
       assert_mean_pixel_difference(A_							,					A_    )




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





