






'''simple docstring'''







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
		from PIL import Image

		from transformers import CLIPSegProcessor, ViTImageProcessor





@require_vision
class 	SCREAMING_SNAKE_CASE					(					unittest.TestCase       ):






			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]					)			->			List[Any]:
							a_		:  Dict											=      tempfile.mkdtemp()

							# fmt: off
							a_		:  Tuple											=      ['''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
							a_		:  Optional[int]											=      dict(zip(A__  ,						range(len(A__					)					)					)					)
							a_		:  Optional[Any]											=      ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
							a_		:  int											=      {'''unk_token''': '''<unk>'''}

							a_		:  Any											=      os.path.join(self.tmpdirname  ,						VOCAB_FILES_NAMES['''vocab_file''']					)
							a_		:  Optional[int]											=      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(A__					) + '''\n'''					)
							with open(self.merges_file  ,						'''w'''  ,						encoding='''utf-8'''					) as fp:
											fp.write('''\n'''.join(A__					)					)

							a_		:  Any											=      {
							    '''do_resize''': True,
							    '''size''': 20,
							    '''do_center_crop''': True,
							    '''crop_size''': 18,
							    '''do_normalize''': True,
							    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
							    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
							}
							a_		:  Any											=      os.path.join(self.tmpdirname  ,						A__					)
							with open(self.image_processor_file  ,						'''w'''  ,						encoding='''utf-8'''					) as fp:
											json.dump(A__  ,						A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]  ,						**__SCREAMING_SNAKE_CASE      :			Dict					)			->			Any:
							return CLIPTokenizer.from_pretrained(self.tmpdirname  ,						**A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Dict  ,						**__SCREAMING_SNAKE_CASE      :			int					)			->			str:
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname  ,						**A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[int]  ,						**__SCREAMING_SNAKE_CASE      :			Optional[Any]					)			->			Dict:
							return ViTImageProcessor.from_pretrained(self.tmpdirname  ,						**A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]					)			->			Any:
							shutil.rmtree(self.tmpdirname					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Tuple					)			->			List[Any]:
							a_		:  List[Any]											=      [np.random.randint(255  ,						size=(3, 30, 400)  ,						dtype=np.uinta					)]

							a_		:  Optional[int]											=      [Image.fromarray(np.moveaxis(A__  ,						0  ,						-1					)					) for x in image_inputs]

							return image_inputs






			def 			SCREAMING_SNAKE_CASE      ( self      :			Any					)			->			Union[str, Any]:
							a_		:  Union[str, Any]											=      self.get_tokenizer()
							a_		:  str											=      self.get_rust_tokenizer()
							a_		:  Dict											=      self.get_image_processor()

							a_		:  Any											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)
							processor_slow.save_pretrained(self.tmpdirname					)
							a_		:  List[str]											=      CLIPSegProcessor.from_pretrained(self.tmpdirname  ,						use_fast=A__					)

							a_		:  Dict											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)
							processor_fast.save_pretrained(self.tmpdirname					)
							a_		:  List[Any]											=      CLIPSegProcessor.from_pretrained(self.tmpdirname					)

							self.assertEqual(processor_slow.tokenizer.get_vocab()  ,						tokenizer_slow.get_vocab()					)
							self.assertEqual(processor_fast.tokenizer.get_vocab()  ,						tokenizer_fast.get_vocab()					)
							self.assertEqual(tokenizer_slow.get_vocab()  ,						tokenizer_fast.get_vocab()					)
							self.assertIsInstance(processor_slow.tokenizer  ,						A__					)
							self.assertIsInstance(processor_fast.tokenizer  ,						A__					)

							self.assertEqual(processor_slow.image_processor.to_json_string()  ,						image_processor.to_json_string()					)
							self.assertEqual(processor_fast.image_processor.to_json_string()  ,						image_processor.to_json_string()					)
							self.assertIsInstance(processor_slow.image_processor  ,						A__					)
							self.assertIsInstance(processor_fast.image_processor  ,						A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Optional[Any]:
							a_		:  int											=      CLIPSegProcessor(tokenizer=self.get_tokenizer()  ,						image_processor=self.get_image_processor()					)
							processor.save_pretrained(self.tmpdirname					)

							a_		:  str											=      self.get_tokenizer(bos_token='''(BOS)'''  ,						eos_token='''(EOS)'''					)
							a_		:  Any											=      self.get_image_processor(do_normalize=A__  ,						padding_value=1.0					)

							a_		:  Union[str, Any]											=      CLIPSegProcessor.from_pretrained(
							    self.tmpdirname  ,						bos_token='''(BOS)'''  ,						eos_token='''(EOS)'''  ,						do_normalize=A__  ,						padding_value=1.0					)

							self.assertEqual(processor.tokenizer.get_vocab()  ,						tokenizer_add_kwargs.get_vocab()					)
							self.assertIsInstance(processor.tokenizer  ,						A__					)

							self.assertEqual(processor.image_processor.to_json_string()  ,						image_processor_add_kwargs.to_json_string()					)
							self.assertIsInstance(processor.image_processor  ,						A__					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]					)			->			Dict:
							a_		:  int											=      self.get_image_processor()
							a_		:  Any											=      self.get_tokenizer()

							a_		:  Optional[int]											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)

							a_		:  List[str]											=      self.prepare_image_inputs()

							a_		:  Any											=      image_processor(A__  ,						return_tensors='''np'''					)
							a_		:  Optional[Any]											=      processor(images=A__  ,						return_tensors='''np'''					)

							for key in input_feat_extract.keys():
											self.assertAlmostEqual(input_feat_extract[key].sum()  ,						input_processor[key].sum()  ,						delta=1e-2					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Tuple:
							a_		:  List[str]											=      self.get_image_processor()
							a_		:  Optional[int]											=      self.get_tokenizer()

							a_		:  List[str]											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)

							a_		:  Union[str, Any]											=      '''lower newer'''

							a_		:  Optional[int]											=      processor(text=A__					)

							a_		:  str											=      tokenizer(A__					)

							for key in encoded_tok.keys():
											self.assertListEqual(encoded_tok[key]  ,						encoded_processor[key]					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]					)			->			Any:
							a_		:  List[str]											=      self.get_image_processor()
							a_		:  List[Any]											=      self.get_tokenizer()

							a_		:  List[str]											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)

							a_		:  Optional[Any]											=      '''lower newer'''
							a_		:  Union[str, Any]											=      self.prepare_image_inputs()

							a_		:  List[str]											=      processor(text=A__  ,						images=A__					)

							self.assertListEqual(list(inputs.keys()					)  ,						['''input_ids''', '''attention_mask''', '''pixel_values''']					)

							# test if it raises when no input is passed
							with pytest.raises(A__					):
											processor()






			def 			SCREAMING_SNAKE_CASE      ( self      :			Tuple					)			->			int:
							a_		:  str											=      self.get_image_processor()
							a_		:  Dict											=      self.get_tokenizer()

							a_		:  Dict											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)

							a_		:  Optional[int]											=      self.prepare_image_inputs()
							a_		:  List[str]											=      self.prepare_image_inputs()

							a_		:  Any											=      processor(images=A__  ,						visual_prompt=A__					)

							self.assertListEqual(list(inputs.keys()					)  ,						['''pixel_values''', '''conditional_pixel_values''']					)

							# test if it raises when no input is passed
							with pytest.raises(A__					):
											processor()







			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Optional[Any]:
							a_		:  Optional[Any]											=      self.get_image_processor()
							a_		:  Optional[int]											=      self.get_tokenizer()

							a_		:  int											=      CLIPSegProcessor(tokenizer=A__  ,						image_processor=A__					)

							a_		:  Dict											=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							a_		:  Union[str, Any]											=      processor.batch_decode(A__					)
							a_		:  int											=      tokenizer.batch_decode(A__					)

							self.assertListEqual(A__  ,						A__					)












'''simple docstring'''







import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin





@skip_mps
class 	SCREAMING_SNAKE_CASE					(					SCREAMING_SNAKE_CASE_	,   SCREAMING_SNAKE_CASE_	,   unittest.TestCase       ):
			snake_case__  =				IFInpaintingSuperResolutionPipeline
			snake_case__  =				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"width", "height"}
			snake_case__  =				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"original_image"}       )
			snake_case__  =				PipelineTesterMixin.required_optional_params - {"latents"}






			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			List[str]:
							return self._get_superresolution_dummy_components()






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]  ,						__SCREAMING_SNAKE_CASE      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			Dict=0					)			->			List[Any]:
							if str(__SCREAMING_SNAKE_CASE					).startswith('''mps'''					):
											a_		:  Optional[int]											=      torch.manual_seed(__SCREAMING_SNAKE_CASE					)
							else:
											a_		:  str											=      torch.Generator(device=__SCREAMING_SNAKE_CASE					).manual_seed(__SCREAMING_SNAKE_CASE					)

							a_		:  Dict											=      floats_tensor((1, 3, 16, 16)  ,						rng=random.Random(__SCREAMING_SNAKE_CASE					)					).to(__SCREAMING_SNAKE_CASE					)
							a_		:  Union[str, Any]											=      floats_tensor((1, 3, 32, 32)  ,						rng=random.Random(__SCREAMING_SNAKE_CASE					)					).to(__SCREAMING_SNAKE_CASE					)
							a_		:  Tuple											=      floats_tensor((1, 3, 32, 32)  ,						rng=random.Random(__SCREAMING_SNAKE_CASE					)					).to(__SCREAMING_SNAKE_CASE					)

							a_		:  Union[str, Any]											=      {
							    '''prompt''': '''A painting of a squirrel eating a burger''',
							    '''image''': image,
							    '''original_image''': original_image,
							    '''mask_image''': mask_image,
							    '''generator''': generator,
							    '''num_inference_steps''': 2,
							    '''output_type''': '''numpy''',
							}

							return inputs






			@unittest.skipIf(
			    torch_device != '''cuda''' or not is_xformers_available()  ,						reason='''XFormers attention is only available with CUDA and `xformers` installed'''  ,						)
			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]					)			->			List[str]:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			int					)			->			int:
							self._test_save_load_optional_components()






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






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]					)			->			Optional[Any]:
							self._test_save_load_local()







			def 			SCREAMING_SNAKE_CASE      ( self      :			Dict					)			->			Optional[Any]:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1e-2  ,						)




