






from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
				import torch

				from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

A        =			logging.get_logger(__name__)


@add_end_docstrings(__A						)
class 							__a							(  __A						):





		'''simple docstring'''



		def __init__(						self ,    **UpperCamelCase__       ):
						super().__init__(**UpperCamelCase__       )
						requires_backends(self ,    'vision'       )
						requires_backends(self ,    'torch'       )

						if self.framework != "pt":
										raise ValueError(F'''The {self.__class__} is only available in PyTorch.'''       )

						self.check_model_type(UpperCamelCase__       )


		def   __snake_case			(						self ,    **UpperCamelCase__       ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   {}
						SCREAMING_SNAKE_CASE_   :	Any													=   {}
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   {}
						# preprocess args
						if "points_per_batch" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Dict													=   kwargs['points_per_batch']
						if "points_per_crop" in kwargs:
										SCREAMING_SNAKE_CASE_   :	int													=   kwargs['points_per_crop']
						if "crops_n_layers" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Optional[int]													=   kwargs['crops_n_layers']
						if "crop_overlap_ratio" in kwargs:
										SCREAMING_SNAKE_CASE_   :	List[str]													=   kwargs['crop_overlap_ratio']
						if "crop_n_points_downscale_factor" in kwargs:
										SCREAMING_SNAKE_CASE_   :	int													=   kwargs['crop_n_points_downscale_factor']
						# postprocess args
						if "pred_iou_thresh" in kwargs:
										SCREAMING_SNAKE_CASE_   :	List[str]													=   kwargs['pred_iou_thresh']
						if "stability_score_offset" in kwargs:
										SCREAMING_SNAKE_CASE_   :	List[str]													=   kwargs['stability_score_offset']
						if "mask_threshold" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Dict													=   kwargs['mask_threshold']
						if "stability_score_thresh" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   kwargs['stability_score_thresh']
						if "crops_nms_thresh" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Dict													=   kwargs['crops_nms_thresh']
						if "output_rle_mask" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   kwargs['output_rle_mask']
						if "output_bboxes_mask" in kwargs:
										SCREAMING_SNAKE_CASE_   :	Tuple													=   kwargs['output_bboxes_mask']
						return preprocess_kwargs, forward_params, postprocess_kwargs


		def __call__(						self ,    UpperCamelCase__ ,    *UpperCamelCase__ ,    UpperCamelCase__=None ,    UpperCamelCase__=None ,    **UpperCamelCase__       ):
						return super().__call__(UpperCamelCase__ ,    *UpperCamelCase__ ,    num_workers=UpperCamelCase__ ,    batch_size=UpperCamelCase__ ,    **UpperCamelCase__       )


		def   __snake_case			(						self ,    UpperCamelCase__ ,    UpperCamelCase__=64 ,    UpperCamelCase__ = 0 ,    UpperCamelCase__ = 512 / 1500 ,    UpperCamelCase__ = 32 ,    UpperCamelCase__ = 1 ,    ):
						SCREAMING_SNAKE_CASE_   :	Dict													=   load_image(UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	Any													=   self.image_processor.size['longest_edge']
						SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_   :	Any													=   self.image_processor.generate_crop_boxes(
						    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	List[str]													=   self.image_processor(images=UpperCamelCase__ ,    return_tensors='pt'       )

						with self.device_placement():
										if self.framework == "pt":
														SCREAMING_SNAKE_CASE_   :	str													=   self.get_inference_context()
														with inference_context():
																		SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   self._ensure_tensor_on_device(UpperCamelCase__ ,    device=self.device       )
																		SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   self.model.get_image_embeddings(model_inputs.pop('pixel_values'       )       )
																		SCREAMING_SNAKE_CASE_   :	int													=   image_embeddings

						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   grid_points.shape[1]
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   points_per_batch if points_per_batch is not None else n_points

						if points_per_batch <= 0:
										raise ValueError(
										    'Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. '
										    'To return all points at once, set points_per_batch to None'       )

						for i in range(0 ,    UpperCamelCase__ ,    UpperCamelCase__       ):
										SCREAMING_SNAKE_CASE_   :	Tuple													=   grid_points[:, i : i + points_per_batch, :, :]
										SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   input_labels[:, i : i + points_per_batch]
										SCREAMING_SNAKE_CASE_   :	Optional[int]													=   i == n_points - points_per_batch
										yield {
										    "input_points": batched_points,
										    "input_labels": labels,
										    "input_boxes": crop_boxes,
										    "is_last": is_last,
										    **model_inputs,
										}


		def   __snake_case			(						self ,    UpperCamelCase__ ,    UpperCamelCase__=0.88 ,    UpperCamelCase__=0.95 ,    UpperCamelCase__=0 ,    UpperCamelCase__=1 ,    ):
						SCREAMING_SNAKE_CASE_   :	Any													=   model_inputs.pop('input_boxes'       )
						SCREAMING_SNAKE_CASE_   :	int													=   model_inputs.pop('is_last'       )
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   model_inputs.pop('original_sizes'       ).tolist()
						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   model_inputs.pop('reshaped_input_sizes'       ).tolist()

						SCREAMING_SNAKE_CASE_   :	List[Any]													=   self.model(**UpperCamelCase__       )

						# post processing happens here in order to avoid CPU GPU copies of ALL the masks
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   model_outputs['pred_masks']
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   self.image_processor.post_process_masks(
						    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    binarize=UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   model_outputs['iou_scores']
						SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_   :	int													=   self.image_processor.filter_masks(
						    masks[0] ,    iou_scores[0] ,    original_sizes[0] ,    input_boxes[0] ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    )
						return {
						    "masks": masks,
						    "is_last": is_last,
						    "boxes": boxes,
						    "iou_scores": iou_scores,
						}






		def   __snake_case			(						self ,    UpperCamelCase__ ,    UpperCamelCase__=False ,    UpperCamelCase__=False ,    UpperCamelCase__=0.7 ,    ):
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   []
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   []
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   []
						for model_output in model_outputs:
										all_scores.append(model_output.pop('iou_scores'       )       )
										all_masks.extend(model_output.pop('masks'       )       )
										all_boxes.append(model_output.pop('boxes'       )       )

						SCREAMING_SNAKE_CASE_   :	List[str]													=   torch.cat(UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	Tuple													=   torch.cat(UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_   :	str													=   self.image_processor.post_process_for_mask_generation(
						    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__       )

						SCREAMING_SNAKE_CASE_   :	Any													=   defaultdict(UpperCamelCase__       )
						for output in model_outputs:
										for k, v in output.items():
														extra[k].append(UpperCamelCase__       )

						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   {}
						if output_rle_mask:
										SCREAMING_SNAKE_CASE_   :	Tuple													=   rle_mask

						if output_bboxes_mask:
										SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   bounding_boxes

						return {"masks": output_masks, "scores": iou_scores, **optional, **extra}







import importlib
import inspect
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
A        =			'src/transformers'


# This is to make sure the transformers module imported is the one in the repo.
A        =			importlib.util.spec_from_file_location(
    'transformers',
    os.path.join(PATH_TO_TRANSFORMERS, '__init__.py'),
    submodule_search_locations=[PATH_TO_TRANSFORMERS],
)
A        =			spec.loader.load_module()

A        =			transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
A        =			re.compile('\[(.+?)\]\((https://huggingface\.co/.+?)\)')


A        =			{
    'CLIPConfigMixin',
    'DecisionTransformerConfigMixin',
    'EncoderDecoderConfigMixin',
    'RagConfigMixin',
    'SpeechEncoderDecoderConfigMixin',
    'VisionEncoderDecoderConfigMixin',
    'VisionTextDualEncoderConfigMixin',
}



def 					_lowerCamelCase(			):





				'''simple docstring'''







				SCREAMING_SNAKE_CASE_   :	Optional[int]													=   []

				for config_class in list(CONFIG_MAPPING.values()      ):
								SCREAMING_SNAKE_CASE_   :	int													=   False

								# source code of `config_class`
								SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   inspect.getsource(lowerCAmelCase__      )
								SCREAMING_SNAKE_CASE_   :	List[Any]													=   _re_checkpoint.findall(lowerCAmelCase__      )

								for checkpoint in checkpoints:
												# Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
												# For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
												SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_   :	Tuple													=   checkpoint

												# verify the checkpoint name corresponds to the checkpoint link
												SCREAMING_SNAKE_CASE_   :	List[str]													=   F'''https://huggingface.co/{ckpt_name}'''
												if ckpt_link == ckpt_link_from_name:
																SCREAMING_SNAKE_CASE_   :	Optional[int]													=   True
																break

								SCREAMING_SNAKE_CASE_   :	Tuple													=   config_class.__name__
								if not checkpoint_found and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
												configs_without_checkpoint.append(lowerCAmelCase__      )

				if len(lowerCAmelCase__      ) > 0:
								SCREAMING_SNAKE_CASE_   :	str													=   '\n'.join(sorted(lowerCAmelCase__      )      )
								raise ValueError(F'''The following configurations don\'t contain any valid checkpoint:\n{message}'''      )


if __name__ == "__main__":
				check_config_docstrings_have_checkpoints()