




import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class     lowerCamelCase__(					__lowerCamelCase ,     unittest.TestCase):
      UpperCAmelCase__      :	str    		=   CLIPTokenizer
      UpperCAmelCase__      :	Any    		=   CLIPTokenizerFast
      UpperCAmelCase__      :	List[str]    		=   True
      UpperCAmelCase__      :	Dict    		=   {}
      UpperCAmelCase__      :	Dict    		=   False
      def 			lowerCAmelCase__						(				self: int   ):
             super().setUp()

             # fmt: off
             __lowerCamelCase   =						["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
             # fmt: on
             __lowerCamelCase   =						dict(zip(UpperCamelCase_    ,       range(len(UpperCamelCase_   )   )   )   )
             __lowerCamelCase   =						["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>"""]
             __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(UpperCamelCase_   ) + """\n"""   )
             with open(self.merges_file    ,       """w"""    ,       encoding="""utf-8"""   ) as fp:
                    fp.write("""\n""".join(UpperCamelCase_   )   )
      def 			lowerCAmelCase__						(				self: Dict    ,       **UpperCamelCase_: List[Any]   ):
             kwargs.update(self.special_tokens_map   )
             return CLIPTokenizer.from_pretrained(self.tmpdirname    ,       **UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Any    ,       **UpperCamelCase_: str   ):
             kwargs.update(self.special_tokens_map   )
             return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,       **UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Dict    ,       UpperCamelCase_: Any   ):
             __lowerCamelCase   =						"""lower newer"""
             __lowerCamelCase   =						"""lower newer"""
             return input_text, output_text
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             __lowerCamelCase   =						CLIPTokenizer(self.vocab_file    ,       self.merges_file    ,       **self.special_tokens_map   )
             __lowerCamelCase   =						"""lower newer"""
             __lowerCamelCase   =						["""lo""", """w""", """er</w>""", """n""", """e""", """w""", """er</w>"""]
             __lowerCamelCase   =						tokenizer.tokenize(UpperCamelCase_   )
             self.assertListEqual(UpperCamelCase_    ,       UpperCamelCase_   )

             __lowerCamelCase   =						tokens + [tokenizer.unk_token]
             __lowerCamelCase   =						[10, 2, 16, 9, 3, 2, 16, 20]
             self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase_   )    ,       UpperCamelCase_   )
      @require_ftfy
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'   ):
                           __lowerCamelCase   =						self.tokenizer_class.from_pretrained(UpperCamelCase_    ,       **UpperCamelCase_   )
                           __lowerCamelCase   =						self.rust_tokenizer_class.from_pretrained(UpperCamelCase_    ,       **UpperCamelCase_   )

                           __lowerCamelCase   =						"""A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."""
                           __lowerCamelCase   =						tokenizer_s.tokenize(UpperCamelCase_   )
                           __lowerCamelCase   =						tokenizer_r.tokenize(UpperCamelCase_   )

                           self.assertListEqual(UpperCamelCase_    ,       UpperCamelCase_   )

                           # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
                           # with Tilde) encoded in 2 different ways
                           __lowerCamelCase   =						"""xa\u0303y""" + """ """ + """x\xe3y"""
                           __lowerCamelCase   =						tokenizer_s.tokenize(UpperCamelCase_   )
                           __lowerCamelCase   =						tokenizer_r.tokenize(UpperCamelCase_   )

                           self.assertListEqual(UpperCamelCase_    ,       UpperCamelCase_   )

                           # Test that the tokenization is identical on unicode of space type
                           __lowerCamelCase   =						[
                               """\u0009""",  # (horizontal tab, '\t')
                               """\u000B""",  # (vertical tab)
                               """\u000C""",  # (form feed)
                               """\u0020""",  # (space, ' ')
                               """\u200E""",  # (left-to-right mark):w
                               """\u200F""",  # (right-to-left mark)
                           ]
                           for unicode_seq in spaces_unicodes:
                                  __lowerCamelCase   =						tokenizer_s.tokenize(UpperCamelCase_   )
                                  __lowerCamelCase   =						tokenizer_r.tokenize(UpperCamelCase_   )

                                  self.assertListEqual(UpperCamelCase_    ,       UpperCamelCase_   )

                           # Test that the tokenization is identical on unicode of line break type
                           __lowerCamelCase   =						[
                               """\u000A""",  # (line feed, '\n')
                               """\r\n""",  # (carriage return and line feed, '\r\n')
                               """\u000D""",  # (carriage return, '\r')
                               """\r""",  # (carriage return, '\r')
                               """\u000D""",  # (carriage return, '\r')
                               """\u2028""",  # (line separator)
                               """\u2029""",  # (paragraph separator)
                               # "\u0085", # (next line)
                           ]

                           # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
                           # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
                           # space (and thus into an empty list).

                           for unicode_seq in line_break_unicodes:
                                  __lowerCamelCase   =						tokenizer_s.tokenize(UpperCamelCase_   )
                                  __lowerCamelCase   =						tokenizer_r.tokenize(UpperCamelCase_   )

                                  self.assertListEqual(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
             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(
                               UpperCamelCase_    ,       use_fast=UpperCamelCase_    ,       )
                           __lowerCamelCase   =						tokenizer_r(UpperCamelCase_    ,       return_offsets_mapping=UpperCamelCase_    ,       add_special_tokens=UpperCamelCase_   )
                           self.assertEqual(encoding.offset_mapping[0]    ,       (0, len(UpperCamelCase_   ))   )
                           self.assertEqual(
                               encoding.offset_mapping[1]    ,       (len(UpperCamelCase_   ) + 1, len(UpperCamelCase_   ) + 1 + len(UpperCamelCase_   ))    ,       )

                           __lowerCamelCase   =						F' {text}'

                           __lowerCamelCase   =						self.rust_tokenizer_class.from_pretrained(
                               UpperCamelCase_    ,       use_fast=UpperCamelCase_    ,       )
                           __lowerCamelCase   =						tokenizer_r(UpperCamelCase_    ,       return_offsets_mapping=UpperCamelCase_    ,       add_special_tokens=UpperCamelCase_   )
                           self.assertEqual(encoding.offset_mapping[0]    ,       (1, 1 + len(UpperCamelCase_   ))   )
                           self.assertEqual(
                               encoding.offset_mapping[1]    ,       (1 + len(UpperCamelCase_   ) + 1, 1 + len(UpperCamelCase_   ) + 1 + len(UpperCamelCase_   ))    ,       )
      def 			lowerCAmelCase__						(				self: int   ):
             # Test related to the breaking change introduced in transformers v4.17.0
             # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
             with self.assertRaises(UpperCamelCase_   ) as context:
                    self.rust_tokenizer_class.from_pretrained("""robot-test/old-clip-tokenizer"""   )

             self.assertTrue(
                 context.exception.args[0].startswith(
                     """The `backend_tokenizer` provided does not match the expected format."""   )   )
      @require_ftfy
      def 			lowerCAmelCase__						(				self: Tuple   ):
             super().test_tokenization_python_rust_equals()




      def 			lowerCAmelCase__						(				self: Any   ):
             # CLIP always lower cases letters
             pass







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, PNDMScheduler, StableDiffusionInpaintPipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class     lowerCamelCase__(					__lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase ,     unittest.TestCase):
      UpperCAmelCase__      :	Union[str, Any]    		=   StableDiffusionInpaintPipeline
      UpperCAmelCase__      :	Dict    		=   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
      UpperCAmelCase__      :	str    		=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
      UpperCAmelCase__      :	int    		=   frozenset(
          [])  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
      UpperCAmelCase__      :	Union[str, Any]    		=   frozenset([])
      def 			lowerCAmelCase__						(				self: str   ):
             torch.manual_seed(0   )
             __lowerCamelCase   =						UNetaDConditionModel(
                 block_out_channels=(32, 64)    ,       layers_per_block=2    ,       sample_size=32    ,       in_channels=9    ,       out_channels=4    ,       down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")    ,       up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")    ,       cross_attention_dim=32    ,       attention_head_dim=(2, 4)    ,       use_linear_projection=UpperCamelCase_    ,       )
             __lowerCamelCase   =						PNDMScheduler(skip_prk_steps=UpperCamelCase_   )
             torch.manual_seed(0   )
             __lowerCamelCase   =						AutoencoderKL(
                 block_out_channels=[32, 64]    ,       in_channels=3    ,       out_channels=3    ,       down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]    ,       up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]    ,       latent_channels=4    ,       sample_size=1_28    ,       )
             torch.manual_seed(0   )
             __lowerCamelCase   =						CLIPTextConfig(
                 bos_token_id=0    ,       eos_token_id=2    ,       hidden_size=32    ,       intermediate_size=37    ,       layer_norm_eps=1E-05    ,       num_attention_heads=4    ,       num_hidden_layers=5    ,       pad_token_id=1    ,       vocab_size=10_00    ,       hidden_act="""gelu"""    ,       projection_dim=5_12    ,       )
             __lowerCamelCase   =						CLIPTextModel(UpperCamelCase_   )
             __lowerCamelCase   =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   )

             __lowerCamelCase   =						{
                 """unet""": unet,
                 """scheduler""": scheduler,
                 """vae""": vae,
                 """text_encoder""": text_encoder,
                 """tokenizer""": tokenizer,
                 """safety_checker""": None,
                 """feature_extractor""": None,
             }
             return components
      def 			lowerCAmelCase__						(				self: List[Any]    ,       UpperCamelCase_: Any    ,       UpperCamelCase_: List[Any]=0   ):
             # TODO: use tensor inputs instead of PIL, this is here just to leave the old expected_slices untouched
             __lowerCamelCase   =						floats_tensor((1, 3, 32, 32)    ,       rng=random.Random(UpperCamelCase_   )   ).to(UpperCamelCase_   )
             __lowerCamelCase   =						image.cpu().permute(0    ,       2    ,       3    ,       1   )[0]
             __lowerCamelCase   =						Image.fromarray(np.uinta(UpperCamelCase_   )   ).convert("""RGB"""   ).resize((64, 64)   )
             __lowerCamelCase   =						Image.fromarray(np.uinta(image + 4   )   ).convert("""RGB"""   ).resize((64, 64)   )
             if str(UpperCamelCase_   ).startswith("""mps"""   ):
                    __lowerCamelCase   =						torch.manual_seed(UpperCamelCase_   )
             else:
                    __lowerCamelCase   =						torch.Generator(device=UpperCamelCase_   ).manual_seed(UpperCamelCase_   )
             __lowerCamelCase   =						{
                 """prompt""": """A painting of a squirrel eating a burger""",
                 """image""": init_image,
                 """mask_image""": mask_image,
                 """generator""": generator,
                 """num_inference_steps""": 2,
                 """guidance_scale""": 6.0,
                 """output_type""": """numpy""",
             }
             return inputs
      def 			lowerCAmelCase__						(				self: str   ):
             __lowerCamelCase   =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
             __lowerCamelCase   =						self.get_dummy_components()
             __lowerCamelCase   =						StableDiffusionInpaintPipeline(**UpperCamelCase_   )
             __lowerCamelCase   =						sd_pipe.to(UpperCamelCase_   )
             sd_pipe.set_progress_bar_config(disable=UpperCamelCase_   )

             __lowerCamelCase   =						self.get_dummy_inputs(UpperCamelCase_   )
             __lowerCamelCase   =						sd_pipe(**UpperCamelCase_   ).images
             __lowerCamelCase   =						image[0, -3:, -3:, -1]

             assert image.shape == (1, 64, 64, 3)
             __lowerCamelCase   =						np.array([0.4727, 0.5735, 0.3941, 0.5446, 0.5926, 0.4394, 0.5062, 0.4654, 0.4476]   )

             assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2




      def 			lowerCAmelCase__						(				self: int   ):
             super().test_inference_batch_single_identical(expected_max_diff=3E-3   )





@slow
@require_torch_gpu
class     lowerCamelCase__(					unittest.TestCase):
      def 			lowerCAmelCase__						(				self: str   ):
             # clean up the VRAM after each test
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                 """/sd2-inpaint/init_image.png"""   )
             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"""   )
             __lowerCamelCase   =						load_numpy(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"""
                 """/yellow_cat_sitting_on_a_park_bench.npy"""   )

             __lowerCamelCase   =						"""stabilityai/stable-diffusion-2-inpainting"""
             __lowerCamelCase   =						StableDiffusionInpaintPipeline.from_pretrained(UpperCamelCase_    ,       safety_checker=UpperCamelCase_   )
             pipe.to(UpperCamelCase_   )
             pipe.set_progress_bar_config(disable=UpperCamelCase_   )
             pipe.enable_attention_slicing()

             __lowerCamelCase   =						"""Face of a yellow cat, high resolution, sitting on a park bench"""

             __lowerCamelCase   =						torch.manual_seed(0   )
             __lowerCamelCase   =						pipe(
                 prompt=UpperCamelCase_    ,       image=UpperCamelCase_    ,       mask_image=UpperCamelCase_    ,       generator=UpperCamelCase_    ,       output_type="""np"""    ,       )
             __lowerCamelCase   =						output.images[0]

             assert image.shape == (5_12, 5_12, 3)
             assert np.abs(expected_image - image   ).max() < 9E-3
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                 """/sd2-inpaint/init_image.png"""   )
             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"""   )
             __lowerCamelCase   =						load_numpy(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"""
                 """/yellow_cat_sitting_on_a_park_bench_fp16.npy"""   )

             __lowerCamelCase   =						"""stabilityai/stable-diffusion-2-inpainting"""
             __lowerCamelCase   =						StableDiffusionInpaintPipeline.from_pretrained(
                 UpperCamelCase_    ,       torch_dtype=torch.floataa    ,       safety_checker=UpperCamelCase_    ,       )
             pipe.to(UpperCamelCase_   )
             pipe.set_progress_bar_config(disable=UpperCamelCase_   )
             pipe.enable_attention_slicing()

             __lowerCamelCase   =						"""Face of a yellow cat, high resolution, sitting on a park bench"""

             __lowerCamelCase   =						torch.manual_seed(0   )
             __lowerCamelCase   =						pipe(
                 prompt=UpperCamelCase_    ,       image=UpperCamelCase_    ,       mask_image=UpperCamelCase_    ,       generator=UpperCamelCase_    ,       output_type="""np"""    ,       )
             __lowerCamelCase   =						output.images[0]

             assert image.shape == (5_12, 5_12, 3)
             assert np.abs(expected_image - image   ).max() < 5E-1




      def 			lowerCAmelCase__						(				self: int   ):
             torch.cuda.empty_cache()
             torch.cuda.reset_max_memory_allocated()
             torch.cuda.reset_peak_memory_stats()

             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                 """/sd2-inpaint/init_image.png"""   )
             __lowerCamelCase   =						load_image(
                 """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"""   )

             __lowerCamelCase   =						"""stabilityai/stable-diffusion-2-inpainting"""
             __lowerCamelCase   =						PNDMScheduler.from_pretrained(UpperCamelCase_    ,       subfolder="""scheduler"""   )
             __lowerCamelCase   =						StableDiffusionInpaintPipeline.from_pretrained(
                 UpperCamelCase_    ,       safety_checker=UpperCamelCase_    ,       scheduler=UpperCamelCase_    ,       torch_dtype=torch.floataa    ,       )
             pipe.to(UpperCamelCase_   )
             pipe.set_progress_bar_config(disable=UpperCamelCase_   )
             pipe.enable_attention_slicing(1   )
             pipe.enable_sequential_cpu_offload()

             __lowerCamelCase   =						"""Face of a yellow cat, high resolution, sitting on a park bench"""

             __lowerCamelCase   =						torch.manual_seed(0   )
             __lowerCamelCase   =						pipe(
                 prompt=UpperCamelCase_    ,       image=UpperCamelCase_    ,       mask_image=UpperCamelCase_    ,       generator=UpperCamelCase_    ,       num_inference_steps=2    ,       output_type="""np"""    ,       )

             __lowerCamelCase   =						torch.cuda.max_memory_allocated()
             # make sure that less than 2.65 GB is allocated
             assert mem_bytes < 2.65 * 10**9

