




"""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       lowerCAmelCase__       :


										"""simple docstring"""





										@staticmethod
										def       snake_case    (     *lowercase__					:	Dict    ,   **lowercase__					:	Tuple						):
												pass

def 						snake_case__       (					_lowerCamelCase				)			->Optional[int]:






		"""simple docstring"""


		__lowercase				:		List[str]												=				hashlib.mda(image.tobytes()				)
		return m.hexdigest()[:10]

def 						snake_case__       (					_lowerCamelCase				)			->Optional[Any]:






		"""simple docstring"""


		__lowercase				:		int												=				np.array(_lowerCamelCase				)
		__lowercase				:		Optional[Any]												=				npimg.shape
		return {"hash": hashimage(_lowerCamelCase				), "shape": shape}





@is_pipeline_test
@require_vision
@require_torch
class       lowerCAmelCase__       (			unittest.TestCase    ):


				"""simple docstring"""





				__UpperCAmelCase :     Tuple       =      dict(
				    (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()    ) if MODEL_FOR_MASK_GENERATION_MAPPING else [])    )
				__UpperCAmelCase :     Tuple       =      dict(
				    (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()    ) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])    )



				def       snake_case    (     self					:	Union[str, Any]    ,   lowercase__					:	str    ,   lowercase__					:	str    ,   lowercase__					:	List[str]						):
						__lowercase				:		int												=				MaskGenerationPipeline(model=UpperCamelCase__    ,   image_processor=UpperCamelCase__						)
						return image_segmenter, [
						    "./tests/fixtures/tests_samples/COCO/000000039769.png",
						    "./tests/fixtures/tests_samples/COCO/000000039769.png",
						]



				def       snake_case    (     self					:	Tuple    ,   lowercase__					:	int    ,   lowercase__					:	List[str]						):
						pass



				@require_tf
				@unittest.skip("Image segmentation not implemented in TF"						)
				def       snake_case    (     self					:	str						):
						pass



				@slow
				@require_torch
				def       snake_case    (     self					:	int						):
						__lowercase				:		int												=				pipeline("mask-generation"    ,   model="facebook/sam-vit-huge"						)

						__lowercase				:		Any												=				image_segmenter("http://images.cocodataset.org/val2017/000000039769.jpg"    ,   points_per_batch=2_5_6						)

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

						# fmt: off
						self.assertEqual(
						    nested_simplify(UpperCamelCase__    ,   decimals=4						)    ,   [
						        {"mask": {"hash": "115ad19f5f", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_4_4_4},
						        {"mask": {"hash": "6affa964c6", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_2_1},
						        {"mask": {"hash": "dfe28a0388", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_1_6_7},
						        {"mask": {"hash": "c0a5f4a318", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_1_3_2},
						        {"mask": {"hash": "fe8065c197", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_0_5_3},
						        {"mask": {"hash": "e2d0b7a0b7", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_9_6_7},
						        {"mask": {"hash": "453c7844bd", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_9_3},
						        {"mask": {"hash": "3d44f2926d", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_9_0_9},
						        {"mask": {"hash": "64033ddc3f", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_8_7_9},
						        {"mask": {"hash": "801064ff79", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_8_3_4},
						        {"mask": {"hash": "6172f276ef", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_7_1_6},
						        {"mask": {"hash": "b49e60e084", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_6_1_2},
						        {"mask": {"hash": "a811e775fd", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_5_9_9},
						        {"mask": {"hash": "a6a8ebcf4b", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_5_5_2},
						        {"mask": {"hash": "9d8257e080", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_5_3_2},
						        {"mask": {"hash": "32de6454a8", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_5_1_6},
						        {"mask": {"hash": "af3d4af2c8", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_9_9},
						        {"mask": {"hash": "3c6db475fb", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_8_3},
						        {"mask": {"hash": "c290813fb9", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_6_4},
						        {"mask": {"hash": "b6f0b8f606", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_3},
						        {"mask": {"hash": "92ce16bfdf", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_3},
						        {"mask": {"hash": "c749b25868", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_4_0_8},
						        {"mask": {"hash": "efb6cab859", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_3_3_5},
						        {"mask": {"hash": "1ff2eafb30", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_3_2_6},
						        {"mask": {"hash": "788b798e24", "shape": (4_8_0, 6_4_0)}, "scores": 0.9_2_6_2},
						        {"mask": {"hash": "abea804f0e", "shape": (4_8_0, 6_4_0)}, "scores": 0.8_9_9_9},
						        {"mask": {"hash": "7b9e8ddb73", "shape": (4_8_0, 6_4_0)}, "scores": 0.8_9_8_6},
						        {"mask": {"hash": "cd24047c8a", "shape": (4_8_0, 6_4_0)}, "scores": 0.8_9_8_4},
						        {"mask": {"hash": "6943e6bcbd", "shape": (4_8_0, 6_4_0)}, "scores": 0.8_8_7_3},
						        {"mask": {"hash": "b5f47c9191", "shape": (4_8_0, 6_4_0)}, "scores": 0.8_8_7_1}
						    ]    ,   )
						# fmt: on



				@require_torch
				@slow
				def       snake_case    (     self					:	Optional[Any]						):
						__lowercase				:		List[Any]												=				"facebook/sam-vit-huge"
						__lowercase				:		Any												=				pipeline("mask-generation"    ,   model=UpperCamelCase__						)

						__lowercase				:		List[str]												=				image_segmenter(
						    "http://images.cocodataset.org/val2017/000000039769.jpg"    ,   pred_iou_thresh=1    ,   points_per_batch=2_5_6						)

						# Shortening by hashing
						__lowercase				:		Optional[int]												=				[]
						for i, o in enumerate(outputs["masks"]						):
								new_outupt += [{"mask": mask_to_test_readable(UpperCamelCase__						), "scores": outputs["scores"][i]}]

						self.assertEqual(
						    nested_simplify(UpperCamelCase__    ,   decimals=4						)    ,   [
						        {"mask": {"hash": "115ad19f5f", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_4_4_4},
						        {"mask": {"hash": "6affa964c6", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_2_1_0},
						        {"mask": {"hash": "dfe28a0388", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_1_6_7},
						        {"mask": {"hash": "c0a5f4a318", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_1_3_2},
						        {"mask": {"hash": "fe8065c197", "shape": (4_8_0, 6_4_0)}, "scores": 1.0_0_5_3},
						    ]    ,   )






"""simple docstring"""







from collections import deque

from .hash_table import HashTable




class       lowerCAmelCase__       (			lowerCAmelCase_    ):


				"""simple docstring"""





				def __init__(     self					:	Optional[int]    ,   *lowercase__					:	Any    ,   **lowercase__					:	Union[str, Any]						):
						super().__init__(*lowercase__    ,   **lowercase__						)



				def       snake_case    (     self					:	Any    ,   lowercase__					:	Dict    ,   lowercase__					:	Dict						):
						__lowercase				:		Dict												=				deque([]						) if self.values[key] is None else self.values[key]
						self.values[key].appendleft(lowercase__						)
						__lowercase				:		Union[str, Any]												=				self.values[key]



				def       snake_case    (     self					:	str						):
						return (
						    sum(self.charge_factor - len(lowercase__						) for slot in self.values						)
						    / self.size_table
						    * self.charge_factor
						)



				def       snake_case    (     self					:	Union[str, Any]    ,   lowercase__					:	List[str]    ,   lowercase__					:	str=None						):
						if not (
						    len(self.values[key]						) == self.charge_factor and self.values.count(lowercase__						) == 0
						):
								return key
						return super()._collision_resolution(lowercase__    ,   lowercase__						)
