




'''simple docstring'''




import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english






@require_tokenizers
class      UpperCAmelCase_     (  lowerCamelCase__       ,	unittest.TestCase     ):


	"""simple docstring"""


	snake_case									=		MobileBertTokenizer
	snake_case									=		MobileBertTokenizerFast
	snake_case									=		True
	snake_case									=		True
	snake_case									=		filter_non_english
	snake_case									=		"""google/mobilebert-uncased"""







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

						snake_case_	=      [
						    '[UNK]',
						    '[CLS]',
						    '[SEP]',
						    '[PAD]',
						    '[MASK]',
						    'want',
						    '##want',
						    '##ed',
						    'wa',
						    'un',
						    'runn',
						    '##ing',
						    ',',
						    'low',
						    'lowest',
						]
						snake_case_	=      os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES["vocab_file"]				)
						with open(self.vocab_file						, "w"						, encoding="utf-8"				) as vocab_writer:
											vocab_writer.write("".join([x + "\n" for x in vocab_tokens]				)				)

						snake_case_	=      [
						    (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
						    for tokenizer_def in self.tokenizers_list
						]







	def  _lowercase    (						self						, UpperCAmelCase_				):
						snake_case_	=      'UNwant\u00E9d,running'
						snake_case_	=      'unwanted, running'
						return input_text, output_text







	def  _lowercase    (						self				):
						snake_case_	=      self.tokenizer_class(self.vocab_file				)

						snake_case_	=      tokenizer.tokenize("UNwant\u00E9d,running"				)
						self.assertListEqual(__snake_case						, ["un", "##want", "##ed", ",", "runn", "##ing"]				)
						self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case				)						, [9, 6, 7, 12, 10, 11]				)







	def  _lowercase    (						self				):
						if not self.test_rust_tokenizer:
											return

						snake_case_	=      self.get_tokenizer()
						snake_case_	=      self.get_rust_tokenizer()

						snake_case_	=      'UNwant\u00E9d,running'

						snake_case_	=      tokenizer.tokenize(__snake_case				)
						snake_case_	=      rust_tokenizer.tokenize(__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)

						snake_case_	=      tokenizer.encode(__snake_case						, add_special_tokens=__snake_case				)
						snake_case_	=      rust_tokenizer.encode(__snake_case						, add_special_tokens=__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)

						snake_case_	=      self.get_rust_tokenizer()
						snake_case_	=      tokenizer.encode(__snake_case				)
						snake_case_	=      rust_tokenizer.encode(__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)

						# With lower casing
						snake_case_	=      self.get_tokenizer(do_lower_case=__snake_case				)
						snake_case_	=      self.get_rust_tokenizer(do_lower_case=__snake_case				)

						snake_case_	=      'UNwant\u00E9d,running'

						snake_case_	=      tokenizer.tokenize(__snake_case				)
						snake_case_	=      rust_tokenizer.tokenize(__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)

						snake_case_	=      tokenizer.encode(__snake_case						, add_special_tokens=__snake_case				)
						snake_case_	=      rust_tokenizer.encode(__snake_case						, add_special_tokens=__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)

						snake_case_	=      self.get_rust_tokenizer()
						snake_case_	=      tokenizer.encode(__snake_case				)
						snake_case_	=      rust_tokenizer.encode(__snake_case				)
						self.assertListEqual(__snake_case						, __snake_case				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer()

						self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"				)						, ["ah", "\u535A", "\u63A8", "zz"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "				)						, ["hello", "!", "how", "are", "you", "?"]				)
						self.assertListEqual(tokenizer.tokenize("H\u00E9llo"				)						, ["hello"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case						, strip_accents=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "				)						, ["hällo", "!", "how", "are", "you", "?"]				)
						self.assertListEqual(tokenizer.tokenize("H\u00E9llo"				)						, ["h\u00E9llo"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case						, strip_accents=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "				)						, ["hallo", "!", "how", "are", "you", "?"]				)
						self.assertListEqual(tokenizer.tokenize("H\u00E9llo"				)						, ["hello"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "				)						, ["hallo", "!", "how", "are", "you", "?"]				)
						self.assertListEqual(tokenizer.tokenize("H\u00E9llo"				)						, ["hello"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "				)						, ["HeLLo", "!", "how", "Are", "yoU", "?"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case						, strip_accents=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "				)						, ["HäLLo", "!", "how", "Are", "yoU", "?"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case						, strip_accents=__snake_case				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "				)						, ["HaLLo", "!", "how", "Are", "yoU", "?"]				)







	def  _lowercase    (						self				):
						snake_case_	=      BasicTokenizer(do_lower_case=__snake_case						, never_split=["[UNK]"]				)

						self.assertListEqual(
						    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"				)						, ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]				)







	def  _lowercase    (						self				):
						snake_case_	=      ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

						snake_case_	=      {}
						for i, token in enumerate(__snake_case				):
											snake_case_	=      i
						snake_case_	=      WordpieceTokenizer(vocab=__snake_case						, unk_token="[UNK]"				)

						self.assertListEqual(tokenizer.tokenize(""				)						, []				)

						self.assertListEqual(tokenizer.tokenize("unwanted running"				)						, ["un", "##want", "##ed", "runn", "##ing"]				)

						self.assertListEqual(tokenizer.tokenize("unwantedX running"				)						, ["[UNK]", "runn", "##ing"]				)







	def  _lowercase    (						self				):
						self.assertTrue(_is_whitespace(" "				)				)
						self.assertTrue(_is_whitespace("\t"				)				)
						self.assertTrue(_is_whitespace("\r"				)				)
						self.assertTrue(_is_whitespace("\n"				)				)
						self.assertTrue(_is_whitespace("\u00A0"				)				)

						self.assertFalse(_is_whitespace("A"				)				)
						self.assertFalse(_is_whitespace("-"				)				)







	def  _lowercase    (						self				):
						self.assertTrue(_is_control("\u0005"				)				)

						self.assertFalse(_is_control("A"				)				)
						self.assertFalse(_is_control(" "				)				)
						self.assertFalse(_is_control("\t"				)				)
						self.assertFalse(_is_control("\r"				)				)







	def  _lowercase    (						self				):
						self.assertTrue(_is_punctuation("-"				)				)
						self.assertTrue(_is_punctuation("$"				)				)
						self.assertTrue(_is_punctuation("`"				)				)
						self.assertTrue(_is_punctuation("."				)				)

						self.assertFalse(_is_punctuation("A"				)				)
						self.assertFalse(_is_punctuation(" "				)				)







	def  _lowercase    (						self				):
						snake_case_	=      self.get_tokenizer()
						snake_case_	=      self.get_rust_tokenizer()

						# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
						self.assertListEqual([tokenizer.tokenize(__snake_case				) for t in ["Test", "\xad", "test"]]						, [["[UNK]"], [], ["[UNK]"]]				)

						self.assertListEqual(
						    [rust_tokenizer.tokenize(__snake_case				) for t in ["Test", "\xad", "test"]]						, [["[UNK]"], [], ["[UNK]"]]				)







	@slow
	def  _lowercase    (						self				):
						snake_case_	=      self.tokenizer_class.from_pretrained("google/mobilebert-uncased"				)

						snake_case_	=      tokenizer.encode("sequence builders"						, add_special_tokens=__snake_case				)
						snake_case_	=      tokenizer.encode("multi-sequence build"						, add_special_tokens=__snake_case				)

						snake_case_	=      tokenizer.build_inputs_with_special_tokens(__snake_case				)
						snake_case_	=      tokenizer.build_inputs_with_special_tokens(__snake_case						, __snake_case				)

						assert encoded_sentence == [1_01] + text + [1_02]
						assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]







	def  _lowercase    (						self				):
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
																snake_case_	=      self.rust_tokenizer_class.from_pretrained(__snake_case						, **__snake_case				)

																snake_case_	=      f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																snake_case_	=      tokenizer_r.encode_plus(
																    __snake_case						, return_attention_mask=__snake_case						, return_token_type_ids=__snake_case						, return_offsets_mapping=__snake_case						, add_special_tokens=__snake_case						, )

																snake_case_	=      tokenizer_r.do_lower_case if hasattr(__snake_case						, "do_lower_case"				) else False
																snake_case_	=      (
																    [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'A'),
																        ((1, 2), ','),
																        ((3, 5), 'na'),
																        ((5, 6), '##ï'),
																        ((6, 8), '##ve'),
																        ((9, 15), tokenizer_r.mask_token),
																        ((16, 21), 'Allen'),
																        ((21, 23), '##NL'),
																        ((23, 24), '##P'),
																        ((25, 33), 'sentence'),
																        ((33, 34), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																    if not do_lower_case
																    else [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'a'),
																        ((1, 2), ','),
																        ((3, 8), 'naive'),
																        ((9, 15), tokenizer_r.mask_token),
																        ((16, 21), 'allen'),
																        ((21, 23), '##nl'),
																        ((23, 24), '##p'),
																        ((25, 33), 'sentence'),
																        ((33, 34), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																)

																self.assertEqual(
																    [e[1] for e in expected_results]						, tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]				)				)
																self.assertEqual([e[0] for e in expected_results]						, tokens["offset_mapping"]				)







	def  _lowercase    (						self				):
						snake_case_	=      ['的', '人', '有']
						snake_case_	=      ''.join(__snake_case				)
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''				):
																snake_case_	=      True
																snake_case_	=      self.tokenizer_class.from_pretrained(__snake_case						, **__snake_case				)
																snake_case_	=      self.rust_tokenizer_class.from_pretrained(__snake_case						, **__snake_case				)

																snake_case_	=      tokenizer_p.encode(__snake_case						, add_special_tokens=__snake_case				)
																snake_case_	=      tokenizer_r.encode(__snake_case						, add_special_tokens=__snake_case				)

																snake_case_	=      tokenizer_r.convert_ids_to_tokens(__snake_case				)
																snake_case_	=      tokenizer_p.convert_ids_to_tokens(__snake_case				)

																# it is expected that each Chinese character is not preceded by "##"
																self.assertListEqual(__snake_case						, __snake_case				)
																self.assertListEqual(__snake_case						, __snake_case				)

																snake_case_	=      False
																snake_case_	=      self.rust_tokenizer_class.from_pretrained(__snake_case						, **__snake_case				)
																snake_case_	=      self.tokenizer_class.from_pretrained(__snake_case						, **__snake_case				)

																snake_case_	=      tokenizer_r.encode(__snake_case						, add_special_tokens=__snake_case				)
																snake_case_	=      tokenizer_p.encode(__snake_case						, add_special_tokens=__snake_case				)

																snake_case_	=      tokenizer_r.convert_ids_to_tokens(__snake_case				)
																snake_case_	=      tokenizer_p.convert_ids_to_tokens(__snake_case				)

																# it is expected that only the first Chinese character is not preceded by "##".
																snake_case_	=      [
																    f'''##{token}''' if idx != 0 else token for idx, token in enumerate(__snake_case				)
																]
																self.assertListEqual(__snake_case						, __snake_case				)
																self.assertListEqual(__snake_case						, __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__(   lowerCamelCase__						,					lowerCamelCase__						,					unittest.TestCase      ):
    lowercase__					=       IFPipeline
    lowercase__					=       TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
    lowercase__					=       TEXT_TO_IMAGE_BATCH_PARAMS
    lowercase__					=       PipelineTesterMixin.required_optional_params - {"""latents"""}







    def      lowercase_			( self					:    List[Any]      ):
      return self._get_dummy_components()







    def      lowercase_			( self					:    int		,     __snake_case					:    List[str]		,     __snake_case					:    List[Any]=0      ):
      if str(__snake_case      ).startswith('mps'      ):
        a		:   List[Any]	  =	torch.manual_seed(__snake_case      )
      else:
        a		:   str	  =	torch.Generator(device=__snake_case      ).manual_seed(__snake_case      )

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

      return inputs







    def      lowercase_			( self					:    Optional[Any]      ):
      self._test_save_load_optional_components()







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







    def      lowercase_			( self					:    str      ):
      self._test_save_load_local()







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

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







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







    def      lowercase_			( self					:    Tuple      ):
      # if

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

      a		:   Optional[int]	  =	IFSuperResolutionPipeline.from_pretrained(
          'DeepFloyd/IF-II-L-v1.0'		,     variant='fp16'		,     torch_dtype=torch.floataa		,     text_encoder=__snake_case		,     tokenizer=__snake_case      )

      # pre compute text embeddings and remove T5 to save memory

      pipe_a.text_encoder.to('cuda'      )

      a  ,      a		:   Optional[Any]	  =	pipe_a.encode_prompt('anime turtle'		,     device='cuda'      )

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

      a		:   List[Any]	  =	None
      a		:   Dict	  =	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(__snake_case		,     __snake_case		,     __snake_case		,     __snake_case      )

      pipe_a.remove_all_hooks()
      pipe_a.remove_all_hooks()

      # img2img

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

      pipe_a.remove_all_hooks()
      pipe_a.remove_all_hooks()

      # inpainting

      a		:   Tuple	  =	IFInpaintingPipeline(**pipe_a.components      )
      a		:   int	  =	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(__snake_case		,     __snake_case		,     __snake_case		,     __snake_case      )







    def      lowercase_			( self					:    Optional[Any]		,     __snake_case					:    Optional[int]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    Tuple		,     __snake_case					:    List[str]      ):
      # pipeline 1

      _start_torch_memory_measurement()

      a		:   int	  =	torch.Generator(device='cpu'      ).manual_seed(0      )
      a		:   int	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

      a		:   Dict	  =	output.images[0]

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

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

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

      # pipeline 2

      _start_torch_memory_measurement()

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

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

      a		:   Any	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     generator=__snake_case		,     num_inference_steps=2		,     output_type='np'		,     )

      a		:   Tuple	  =	output.images[0]

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

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

      a		:   Tuple	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )







    def      lowercase_			( self					:    List[str]		,     __snake_case					:    str		,     __snake_case					:    int		,     __snake_case					:    Any		,     __snake_case					:    Any      ):
      # pipeline 1

      _start_torch_memory_measurement()

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

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

      a		:   Any	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

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

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

      a		:   Optional[Any]	  =	torch.cuda.max_memory_allocated()
      assert mem_bytes < 10 * 10**9

      a		:   Tuple	  =	load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )

      # pipeline 2

      _start_torch_memory_measurement()

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

      a		:   str	  =	floats_tensor((1, 3, 2_56, 2_56)		,     rng=random.Random(0      )      ).to(__snake_case      )
      a		:   Any	  =	floats_tensor((1, 3, 64, 64)		,     rng=random.Random(0      )      ).to(__snake_case      )

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

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

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

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

      a		:   Dict	  =	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(__snake_case		,     __snake_case      )







    def      lowercase_			( self					:    List[Any]		,     __snake_case					:    Tuple		,     __snake_case					:    Any		,     __snake_case					:    str		,     __snake_case					:    int      ):
      # pipeline 1

      _start_torch_memory_measurement()

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

      a		:   Union[str, Any]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )
      a		:   str	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     mask_image=__snake_case		,     num_inference_steps=2		,     generator=__snake_case		,     output_type='np'		,     )

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

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

      a		:   List[str]	  =	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_inpainting.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )

      # pipeline 2

      _start_torch_memory_measurement()

      a		:   Union[str, Any]	  =	torch.Generator(device='cpu'      ).manual_seed(0      )

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

      a		:   int	  =	pipe_a(
          prompt_embeds=__snake_case		,     negative_prompt_embeds=__snake_case		,     image=__snake_case		,     mask_image=__snake_case		,     original_image=__snake_case		,     generator=__snake_case		,     num_inference_steps=2		,     output_type='np'		,     )

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

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

      a		:   Union[str, Any]	  =	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_inpainting_superresolution_stage_II.npy'      )
      assert_mean_pixel_difference(__snake_case		,     __snake_case      )
def  lowerCamelCase__			(		):
  torch.cuda.empty_cache()
  torch.cuda.reset_max_memory_allocated()
  torch.cuda.reset_peak_memory_stats()