


"""simple docstring"""







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__				:							Dict						=     logging.get_logger(__name__)




@add_end_docstrings(UpperCamelCase)
class  UpperCamelCase_	( UpperCamelCase):

	"""simple docstring"""





	def __init__( self			:				int			,			**UpperCAmelCase__			:				str   )       ->	Optional[Any]:
						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   UpperCAmelCase_      ( self			:				Any			,			**UpperCAmelCase__			:				str   )       ->	Optional[int]:
						__SCREAMING_SNAKE_CASE						   =				{}
						__SCREAMING_SNAKE_CASE						   =				{}
						__SCREAMING_SNAKE_CASE						   =				{}
						# preprocess args
						if "points_per_batch" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["points_per_batch"]
						if "points_per_crop" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["points_per_crop"]
						if "crops_n_layers" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["crops_n_layers"]
						if "crop_overlap_ratio" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["crop_overlap_ratio"]
						if "crop_n_points_downscale_factor" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["crop_n_points_downscale_factor"]
						# postprocess args
						if "pred_iou_thresh" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["pred_iou_thresh"]
						if "stability_score_offset" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["stability_score_offset"]
						if "mask_threshold" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["mask_threshold"]
						if "stability_score_thresh" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["stability_score_thresh"]
						if "crops_nms_thresh" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["crops_nms_thresh"]
						if "output_rle_mask" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["output_rle_mask"]
						if "output_bboxes_mask" in kwargs:
											__SCREAMING_SNAKE_CASE						   =				kwargs["output_bboxes_mask"]
						return preprocess_kwargs, forward_params, postprocess_kwargs




	def __call__( self			:				Optional[int]			,			UpperCAmelCase__			:				List[Any]			,			*UpperCAmelCase__			:				Optional[Any]			,			UpperCAmelCase__			:				List[str]=None			,			UpperCAmelCase__			:				List[str]=None			,			**UpperCAmelCase__			:				Tuple   )       ->	Union[str, Any]:
						return super().__call__(UpperCAmelCase__			,			*UpperCAmelCase__			,			num_workers=UpperCAmelCase__			,			batch_size=UpperCAmelCase__			,			**UpperCAmelCase__   )




	def   UpperCAmelCase_      ( self			:				Any			,			UpperCAmelCase__			:				str			,			UpperCAmelCase__			:				List[str]=6_4			,			UpperCAmelCase__			:				int = 0			,			UpperCAmelCase__			:				float = 5_1_2 / 1_5_0_0			,			UpperCAmelCase__			:				Optional[int] = 3_2			,			UpperCAmelCase__			:				Optional[int] = 1			,			)       ->	Tuple:
						__SCREAMING_SNAKE_CASE						   =				load_image(UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE						   =				self.image_processor.size["longest_edge"]
						__SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE						   =				self.image_processor.generate_crop_boxes(
						    UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE						   =				self.image_processor(images=UpperCAmelCase__			,			return_tensors="pt"   )

						with self.device_placement():
											if self.framework == "pt":
																__SCREAMING_SNAKE_CASE						   =				self.get_inference_context()
																with inference_context():
																					__SCREAMING_SNAKE_CASE						   =				self._ensure_tensor_on_device(UpperCAmelCase__			,			device=self.device   )
																					__SCREAMING_SNAKE_CASE						   =				self.model.get_image_embeddings(model_inputs.pop("pixel_values"   )   )
																					__SCREAMING_SNAKE_CASE						   =				image_embeddings

						__SCREAMING_SNAKE_CASE						   =				grid_points.shape[1]
						__SCREAMING_SNAKE_CASE						   =				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						   =				grid_points[:, i : i + points_per_batch, :, :]
											__SCREAMING_SNAKE_CASE						   =				input_labels[:, i : i + points_per_batch]
											__SCREAMING_SNAKE_CASE						   =				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   UpperCAmelCase_      ( self			:				Dict			,			UpperCAmelCase__			:				Tuple			,			UpperCAmelCase__			:				List[Any]=0.88			,			UpperCAmelCase__			:				str=0.95			,			UpperCAmelCase__			:				str=0			,			UpperCAmelCase__			:				List[str]=1			,			)       ->	List[Any]:
						__SCREAMING_SNAKE_CASE						   =				model_inputs.pop("input_boxes"   )
						__SCREAMING_SNAKE_CASE						   =				model_inputs.pop("is_last"   )
						__SCREAMING_SNAKE_CASE						   =				model_inputs.pop("original_sizes"   ).tolist()
						__SCREAMING_SNAKE_CASE						   =				model_inputs.pop("reshaped_input_sizes"   ).tolist()

						__SCREAMING_SNAKE_CASE						   =				self.model(**UpperCAmelCase__   )

						# post processing happens here in order to avoid CPU GPU copies of ALL the masks
						__SCREAMING_SNAKE_CASE						   =				model_outputs["pred_masks"]
						__SCREAMING_SNAKE_CASE						   =				self.image_processor.post_process_masks(
						    UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			binarize=UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE						   =				model_outputs["iou_scores"]
						__SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE						   =				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   UpperCAmelCase_      ( self			:				Any			,			UpperCAmelCase__			:				Optional[Any]			,			UpperCAmelCase__			:				int=False			,			UpperCAmelCase__			:				Union[str, Any]=False			,			UpperCAmelCase__			:				Any=0.7			,			)       ->	Optional[int]:
						__SCREAMING_SNAKE_CASE						   =				[]
						__SCREAMING_SNAKE_CASE						   =				[]
						__SCREAMING_SNAKE_CASE						   =				[]
						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						   =				torch.cat(UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE						   =				torch.cat(UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE						   =				self.image_processor.post_process_for_mask_generation(
						    UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__			,			UpperCAmelCase__   )

						__SCREAMING_SNAKE_CASE						   =				defaultdict(UpperCAmelCase__   )
						for output in model_outputs:
											for k, v in output.items():
																extra[k].append(UpperCAmelCase__   )

						__SCREAMING_SNAKE_CASE						   =				{}
						if output_rle_mask:
											__SCREAMING_SNAKE_CASE						   =				rle_mask

						if output_bboxes_mask:
											__SCREAMING_SNAKE_CASE						   =				bounding_boxes

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




"""simple docstring"""







def    UpperCAmelCase__       (lowerCAmelCase_   ):




					'''simple docstring'''


					if upper_limit < 0:
										raise ValueError("Limit for the Catalan sequence must be ≥ 0"   )

					__SCREAMING_SNAKE_CASE						   =				[0] * (upper_limit + 1)

					# Base case: C(0) = C(1) = 1
					__SCREAMING_SNAKE_CASE						   =				1
					if upper_limit > 0:
										__SCREAMING_SNAKE_CASE						   =				1

					# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
					for i in range(2  ,						upper_limit + 1   ):
										for j in range(lowerCAmelCase_   ):
															catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

					return catalan_list


if __name__ == "__main__":
		print('''\n********* Catalan Numbers Using Dynamic Programming ************\n''')
		print('''\n*** Enter -1 at any time to quit ***''')
		print('''\nEnter the upper limit (≥ 0) for the Catalan number sequence: ''', end='''''')
		try:
				while True:
						a__				:							List[str]						=     int(input().strip())
						if N < 0:
								print('''\n********* Goodbye!! ************''')
								break
						else:
								print(F"The Catalan numbers from 0 through {N} are:")
								print(catalan_numbers(N))
								print('''Try another upper limit for the sequence: ''', end='''''')
		except (NameError, ValueError):
				print('''\n********* Invalid input, goodbye! ************\n''')

		import doctest

		doctest.testmod()
