
'''simple docstring'''







_snake_case				:   Tuple     =				{
    """Pillow""": """Pillow<10.0.0""",
    """accelerate""": """accelerate>=0.20.3""",
    """av""": """av==9.2.0""",
    """beautifulsoup4""": """beautifulsoup4""",
    """black""": """black~=23.1""",
    """codecarbon""": """codecarbon==1.2.0""",
    """cookiecutter""": """cookiecutter==1.7.3""",
    """dataclasses""": """dataclasses""",
    """datasets""": """datasets!=2.5.0""",
    """decord""": """decord==0.6.0""",
    """deepspeed""": """deepspeed>=0.9.3""",
    """diffusers""": """diffusers""",
    """dill""": """dill<0.3.5""",
    """evaluate""": """evaluate>=0.2.0""",
    """fairscale""": """fairscale>0.3""",
    """faiss-cpu""": """faiss-cpu""",
    """fastapi""": """fastapi""",
    """filelock""": """filelock""",
    """flax""": """flax>=0.4.1,<=0.7.0""",
    """ftfy""": """ftfy""",
    """fugashi""": """fugashi>=1.0""",
    """GitPython""": """GitPython<3.1.19""",
    """hf-doc-builder""": """hf-doc-builder>=0.3.0""",
    """huggingface-hub""": """huggingface-hub>=0.14.1,<1.0""",
    """importlib_metadata""": """importlib_metadata""",
    """ipadic""": """ipadic>=1.0.0,<2.0""",
    """isort""": """isort>=5.5.4""",
    """jax""": """jax>=0.2.8,!=0.3.2,<=0.4.13""",
    """jaxlib""": """jaxlib>=0.1.65,<=0.4.13""",
    """jieba""": """jieba""",
    """kenlm""": """kenlm""",
    """keras-nlp""": """keras-nlp>=0.3.1""",
    """librosa""": """librosa""",
    """nltk""": """nltk""",
    """natten""": """natten>=0.14.6""",
    """numpy""": """numpy>=1.17""",
    """onnxconverter-common""": """onnxconverter-common""",
    """onnxruntime-tools""": """onnxruntime-tools>=1.4.2""",
    """onnxruntime""": """onnxruntime>=1.4.0""",
    """opencv-python""": """opencv-python""",
    """optuna""": """optuna""",
    """optax""": """optax>=0.0.8,<=0.1.4""",
    """packaging""": """packaging>=20.0""",
    """parameterized""": """parameterized""",
    """phonemizer""": """phonemizer""",
    """protobuf""": """protobuf""",
    """psutil""": """psutil""",
    """pyyaml""": """pyyaml>=5.1""",
    """pydantic""": """pydantic<2""",
    """pytest""": """pytest>=7.2.0""",
    """pytest-timeout""": """pytest-timeout""",
    """pytest-xdist""": """pytest-xdist""",
    """python""": """python>=3.8.0""",
    """ray[tune]""": """ray[tune]""",
    """regex""": """regex!=2019.12.17""",
    """requests""": """requests""",
    """rhoknp""": """rhoknp>=1.1.0,<1.3.1""",
    """rjieba""": """rjieba""",
    """rouge-score""": """rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1""",
    """ruff""": """ruff>=0.0.241,<=0.0.259""",
    """sacrebleu""": """sacrebleu>=1.4.12,<2.0.0""",
    """sacremoses""": """sacremoses""",
    """safetensors""": """safetensors>=0.3.1""",
    """sagemaker""": """sagemaker>=2.31.0""",
    """scikit-learn""": """scikit-learn""",
    """sentencepiece""": """sentencepiece>=0.1.91,!=0.1.92""",
    """sigopt""": """sigopt""",
    """starlette""": """starlette""",
    """sudachipy""": """sudachipy>=0.6.6""",
    """sudachidict_core""": """sudachidict_core>=20220729""",
    """tensorflow-cpu""": """tensorflow-cpu>=2.6,<2.14""",
    """tensorflow""": """tensorflow>=2.6,<2.14""",
    """tensorflow-text""": """tensorflow-text<2.14""",
    """tf2onnx""": """tf2onnx""",
    """timeout-decorator""": """timeout-decorator""",
    """timm""": """timm""",
    """tokenizers""": """tokenizers>=0.11.1,!=0.11.3,<0.14""",
    """torch""": """torch>=1.9,!=1.12.0""",
    """torchaudio""": """torchaudio""",
    """torchvision""": """torchvision""",
    """pyctcdecode""": """pyctcdecode>=0.4.0""",
    """tqdm""": """tqdm>=4.27""",
    """unidic""": """unidic>=1.0.2""",
    """unidic_lite""": """unidic_lite>=1.0.7""",
    """urllib3""": """urllib3<2.0.0""",
    """uvicorn""": """uvicorn""",
}

'''simple docstring'''







from copy import deepcopy
from typing import Optional, Union

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_tf_available, is_torch_available


if is_torch_available():
						import torch

if is_tf_available():
						import tensorflow as tf


class 			lowerCAmelCase (				__UpperCAmelCase			):
		a							:					Optional[int]       =					["""image_processor"""]
		a							:					Tuple       =					"""SamImageProcessor"""




		def __init__(				self					,						UpperCamelCase      ):
								super().__init__(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= self.image_processor
								_SCREAMING_SNAKE_CASE				= -10
								_SCREAMING_SNAKE_CASE				= self.image_processor.size["longest_edge"]




		def __call__(				self					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase = None					,						**UpperCamelCase					,						):
								_SCREAMING_SNAKE_CASE				= self.image_processor(
								    UpperCamelCase					,						return_tensors=UpperCamelCase					,						**UpperCamelCase					,						)

								# pop arguments that are not used in the foward but used nevertheless
								_SCREAMING_SNAKE_CASE				= encoding_image_processor["original_sizes"]

								if hasattr(UpperCamelCase					,						"numpy"      ):  # Checks if Torch or TF tensor
														_SCREAMING_SNAKE_CASE				= original_sizes.numpy()

								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self._check_and_preprocess_points(
								    input_points=UpperCamelCase					,						input_labels=UpperCamelCase					,						input_boxes=UpperCamelCase					,						)

								_SCREAMING_SNAKE_CASE				= self._normalize_and_convert(
								    UpperCamelCase					,						UpperCamelCase					,						input_points=UpperCamelCase					,						input_labels=UpperCamelCase					,						input_boxes=UpperCamelCase					,						return_tensors=UpperCamelCase					,						)

								return encoding_image_processor




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase="pt"					,						):
								if input_points is not None:
														if len(UpperCamelCase      ) != len(UpperCamelCase      ):
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						original_sizes[0]      ) for point in input_points
																				]
														else:
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						UpperCamelCase      )
																				    for point, original_size in zip(UpperCamelCase					,						UpperCamelCase      )
																				]
														# check that all arrays have the same shape
														if not all(point.shape == input_points[0].shape for point in input_points      ):
																				if input_labels is not None:
																										_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self._pad_points_and_labels(UpperCamelCase					,						UpperCamelCase      )

														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_labels is not None:
														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_boxes is not None:
														if len(UpperCamelCase      ) != len(UpperCamelCase      ):
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						original_sizes[0]					,						is_bounding_box=UpperCamelCase      )
																				    for box in input_boxes
																				]
														else:
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						UpperCamelCase					,						is_bounding_box=UpperCamelCase      )
																				    for box, original_size in zip(UpperCamelCase					,						UpperCamelCase      )
																				]
														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_boxes is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# boxes batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_boxes.unsqueeze(1      ) if len(input_boxes.shape      ) != 3 else input_boxes
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# boxes batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_boxes.shape      ) != 3 else input_boxes
														encoding_image_processor.update({"input_boxes": input_boxes}      )
								if input_points is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_points.unsqueeze(1      ) if len(input_points.shape      ) != 4 else input_points
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_points.shape      ) != 4 else input_points
														encoding_image_processor.update({"input_points": input_points}      )
								if input_labels is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_labels.unsqueeze(1      ) if len(input_labels.shape      ) != 3 else input_labels
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_labels.shape      ) != 3 else input_labels
														encoding_image_processor.update({"input_labels": input_labels}      )

								return encoding_image_processor




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= max([point.shape[0] for point in input_points]      )
								_SCREAMING_SNAKE_CASE				= []
								for i, point in enumerate(UpperCamelCase      ):
														if point.shape[0] != expected_nb_points:
																				_SCREAMING_SNAKE_CASE				= np.concatenate(
																				    [point, np.zeros((expected_nb_points - point.shape[0], 2)      ) + self.point_pad_value]					,						axis=0      )
																				_SCREAMING_SNAKE_CASE				= np.append(input_labels[i]					,						[self.point_pad_value]      )
														processed_input_points.append(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= processed_input_points
								return input_points, input_labels




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=False      ):
								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= original_size
								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self.image_processor._get_preprocess_shape(UpperCamelCase					,						longest_edge=UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= deepcopy(UpperCamelCase      ).astype(UpperCamelCase      )

								if is_bounding_box:
														_SCREAMING_SNAKE_CASE				= coords.reshape(-1					,						2					,						2      )

								_SCREAMING_SNAKE_CASE				= coords[..., 0] * (new_w / old_w)
								_SCREAMING_SNAKE_CASE				= coords[..., 1] * (new_h / old_h)

								if is_bounding_box:
														_SCREAMING_SNAKE_CASE				= coords.reshape(-1					,						4      )

								return coords




		def     lowercase       (				self					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						):
								if input_points is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):  # Checks for TF or Torch tensor
																				_SCREAMING_SNAKE_CASE				= input_points.numpy().tolist()

														if not isinstance(UpperCamelCase					,						UpperCamelCase      ) or not isinstance(input_points[0]					,						UpperCamelCase      ):
																				raise ValueError("Input points must be a list of list of floating points."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ) for input_point in input_points]
								else:
														_SCREAMING_SNAKE_CASE				= None

								if input_labels is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):
																				_SCREAMING_SNAKE_CASE				= input_labels.numpy().tolist()

														if not isinstance(UpperCamelCase					,						UpperCamelCase      ) or not isinstance(input_labels[0]					,						UpperCamelCase      ):
																				raise ValueError("Input labels must be a list of list integers."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ) for label in input_labels]
								else:
														_SCREAMING_SNAKE_CASE				= None

								if input_boxes is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):
																				_SCREAMING_SNAKE_CASE				= input_boxes.numpy().tolist()

														if (
														    not isinstance(UpperCamelCase					,						UpperCamelCase      )
														    or not isinstance(input_boxes[0]					,						UpperCamelCase      )
														    or not isinstance(input_boxes[0][0]					,						UpperCamelCase      )
														):
																				raise ValueError("Input boxes must be a list of list of list of floating points."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ).astype(np.floataa      ) for box in input_boxes]
								else:
														_SCREAMING_SNAKE_CASE				= None

								return input_points, input_labels, input_boxes




		@property
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.image_processor.model_input_names
								return list(dict.fromkeys(UpperCamelCase      )      )




		def     lowercase       (				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								return self.image_processor.post_process_masks(*UpperCamelCase					,						**UpperCamelCase      )