






'''simple docstring'''







import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
		from PIL import Image
else:





		class 	SCREAMING_SNAKE_CASE					:






					@staticmethod
					def 			SCREAMING_SNAKE_CASE      ( *__SCREAMING_SNAKE_CASE      :			Union[str, Any]  ,						**__SCREAMING_SNAKE_CASE      :			Any					)			->			int:
									pass





def 		_UpperCAmelCase   (							__A							:   Image      ):

				'''simple docstring'''





				a_		:  int											=      hashlib.mda(image.tobytes()      )
				return m.hexdigest()[:10]





def 		_UpperCAmelCase   (							__A							:   Image      ):

				'''simple docstring'''





				a_		:  int											=      np.array(__A      )
				a_		:  int											=      npimg.shape
				return {"hash": hashimage(__A      ), "shape": shape}





@is_pipeline_test
@require_vision
@require_torch
class 	SCREAMING_SNAKE_CASE					(					unittest.TestCase       ):
			snake_case__  =				dict(
			    (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()       ) if MODEL_FOR_MASK_GENERATION_MAPPING else [])       )
			snake_case__  =				dict(
			    (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()       ) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])       )






			def 			SCREAMING_SNAKE_CASE      ( self      :			str  ,						__SCREAMING_SNAKE_CASE      :			Tuple  ,						__SCREAMING_SNAKE_CASE      :			Dict  ,						__SCREAMING_SNAKE_CASE      :			Optional[Any]					)			->			int:
							a_		:  Dict											=      MaskGenerationPipeline(model=A__  ,						image_processor=A__					)
							return image_segmenter, [
							    "./tests/fixtures/tests_samples/COCO/000000039769.png",
							    "./tests/fixtures/tests_samples/COCO/000000039769.png",
							]






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			int  ,						__SCREAMING_SNAKE_CASE      :			Union[str, Any]					)			->			Any:
							pass






			@require_tf
			@unittest.skip('''Image segmentation not implemented in TF'''					)
			def 			SCREAMING_SNAKE_CASE      ( self      :			str					)			->			Dict:
							pass






			@slow
			@require_torch
			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]					)			->			int:
							a_		:  List[Any]											=      pipeline('''mask-generation'''  ,						model='''facebook/sam-vit-huge'''					)

							a_		:  Optional[int]											=      image_segmenter('''http://images.cocodataset.org/val2017/000000039769.jpg'''  ,						points_per_batch=256					)

							# Shortening by hashing
							a_		:  Optional[Any]											=      []
							for i, o in enumerate(outputs['''masks''']					):
											new_outupt += [{"mask": mask_to_test_readable(A__					), "scores": outputs["scores"][i]}]

							# fmt: off
							self.assertEqual(
							    nested_simplify(A__  ,						decimals=4					)  ,						[
							        {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (480, 640)}, '''scores''': 1.0444},
							        {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (480, 640)}, '''scores''': 1.021},
							        {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (480, 640)}, '''scores''': 1.0167},
							        {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (480, 640)}, '''scores''': 1.0132},
							        {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (480, 640)}, '''scores''': 1.0053},
							        {'''mask''': {'''hash''': '''e2d0b7a0b7''', '''shape''': (480, 640)}, '''scores''': 0.9967},
							        {'''mask''': {'''hash''': '''453c7844bd''', '''shape''': (480, 640)}, '''scores''': 0.993},
							        {'''mask''': {'''hash''': '''3d44f2926d''', '''shape''': (480, 640)}, '''scores''': 0.9909},
							        {'''mask''': {'''hash''': '''64033ddc3f''', '''shape''': (480, 640)}, '''scores''': 0.9879},
							        {'''mask''': {'''hash''': '''801064ff79''', '''shape''': (480, 640)}, '''scores''': 0.9834},
							        {'''mask''': {'''hash''': '''6172f276ef''', '''shape''': (480, 640)}, '''scores''': 0.9716},
							        {'''mask''': {'''hash''': '''b49e60e084''', '''shape''': (480, 640)}, '''scores''': 0.9612},
							        {'''mask''': {'''hash''': '''a811e775fd''', '''shape''': (480, 640)}, '''scores''': 0.9599},
							        {'''mask''': {'''hash''': '''a6a8ebcf4b''', '''shape''': (480, 640)}, '''scores''': 0.9552},
							        {'''mask''': {'''hash''': '''9d8257e080''', '''shape''': (480, 640)}, '''scores''': 0.9532},
							        {'''mask''': {'''hash''': '''32de6454a8''', '''shape''': (480, 640)}, '''scores''': 0.9516},
							        {'''mask''': {'''hash''': '''af3d4af2c8''', '''shape''': (480, 640)}, '''scores''': 0.9499},
							        {'''mask''': {'''hash''': '''3c6db475fb''', '''shape''': (480, 640)}, '''scores''': 0.9483},
							        {'''mask''': {'''hash''': '''c290813fb9''', '''shape''': (480, 640)}, '''scores''': 0.9464},
							        {'''mask''': {'''hash''': '''b6f0b8f606''', '''shape''': (480, 640)}, '''scores''': 0.943},
							        {'''mask''': {'''hash''': '''92ce16bfdf''', '''shape''': (480, 640)}, '''scores''': 0.943},
							        {'''mask''': {'''hash''': '''c749b25868''', '''shape''': (480, 640)}, '''scores''': 0.9408},
							        {'''mask''': {'''hash''': '''efb6cab859''', '''shape''': (480, 640)}, '''scores''': 0.9335},
							        {'''mask''': {'''hash''': '''1ff2eafb30''', '''shape''': (480, 640)}, '''scores''': 0.9326},
							        {'''mask''': {'''hash''': '''788b798e24''', '''shape''': (480, 640)}, '''scores''': 0.9262},
							        {'''mask''': {'''hash''': '''abea804f0e''', '''shape''': (480, 640)}, '''scores''': 0.8999},
							        {'''mask''': {'''hash''': '''7b9e8ddb73''', '''shape''': (480, 640)}, '''scores''': 0.8986},
							        {'''mask''': {'''hash''': '''cd24047c8a''', '''shape''': (480, 640)}, '''scores''': 0.8984},
							        {'''mask''': {'''hash''': '''6943e6bcbd''', '''shape''': (480, 640)}, '''scores''': 0.8873},
							        {'''mask''': {'''hash''': '''b5f47c9191''', '''shape''': (480, 640)}, '''scores''': 0.8871}
							    ]  ,						)
							# fmt: on







			@require_torch
			@slow
			def 			SCREAMING_SNAKE_CASE      ( self      :			Tuple					)			->			Dict:
							a_		:  int											=      '''facebook/sam-vit-huge'''
							a_		:  int											=      pipeline('''mask-generation'''  ,						model=A__					)

							a_		:  Dict											=      image_segmenter(
							    '''http://images.cocodataset.org/val2017/000000039769.jpg'''  ,						pred_iou_thresh=1  ,						points_per_batch=256					)

							# Shortening by hashing
							a_		:  Union[str, Any]											=      []
							for i, o in enumerate(outputs['''masks''']					):
											new_outupt += [{"mask": mask_to_test_readable(A__					), "scores": outputs["scores"][i]}]

							self.assertEqual(
							    nested_simplify(A__  ,						decimals=4					)  ,						[
							        {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (480, 640)}, '''scores''': 1.0444},
							        {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (480, 640)}, '''scores''': 1.0210},
							        {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (480, 640)}, '''scores''': 1.0167},
							        {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (480, 640)}, '''scores''': 1.0132},
							        {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (480, 640)}, '''scores''': 1.0053},
							    ]  ,						)












'''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  ,						)




