





'''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  (      _A       ):
 snake_case_      =   ["image_processor"]
 snake_case_      =   "SamImageProcessor"



 def __init__(   self		,      a_	):
   super().__init__(a_	)
   lowerCAmelCase     :    Optional[Any]						=   self.image_processor
   lowerCAmelCase     :    int						=   -10
   lowerCAmelCase     :    Dict						=   self.image_processor.size["longest_edge"]



 def __call__(   self		,      a_=None		,      a_=None		,      a_=None		,      a_=None		,      a_ = None		,      **a_		,      ):
   lowerCAmelCase     :    List[str]						=   self.image_processor(
       a_		,      return_tensors=a_		,      **a_		,      )

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

   if hasattr(a_		,      "numpy"	):  # Checks if Torch or TF tensor
     lowerCAmelCase     :    Dict						=   original_sizes.numpy()

   lowerCAmelCase     :    Tuple						=   self._check_and_preprocess_points(
       input_points=a_		,      input_labels=a_		,      input_boxes=a_		,      )

   lowerCAmelCase     :    str						=   self._normalize_and_convert(
       a_		,      a_		,      input_points=a_		,      input_labels=a_		,      input_boxes=a_		,      return_tensors=a_		,      )

   return encoding_image_processor



 def   _lowerCamelCase    (   self		,      a_		,      a_		,      a_=None		,      a_=None		,      a_=None		,      a_="pt"		,      ):
   if input_points is not None:
     if len(a_	) != len(a_	):
       lowerCAmelCase     :    Optional[int]						=   [
           self._normalize_coordinates(self.target_size		,      a_		,      original_sizes[0]	) for point in input_points
       ]
     else:
       lowerCAmelCase     :    Dict						=   [
           self._normalize_coordinates(self.target_size		,      a_		,      a_	)
           for point, original_size in zip(a_		,      a_	)
       ]
     # 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:
         lowerCAmelCase     :    Tuple						=   self._pad_points_and_labels(a_		,      a_	)

     lowerCAmelCase     :    int						=   np.array(a_	)

   if input_labels is not None:
     lowerCAmelCase     :    str						=   np.array(a_	)

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

   if input_boxes is not None:
     if return_tensors == "pt":
       lowerCAmelCase     :    Tuple						=   torch.from_numpy(a_	)
       # boxes batch size of 1 by default
       lowerCAmelCase     :    Tuple						=   input_boxes.unsqueeze(1	) if len(input_boxes.shape	) != 3 else input_boxes
     elif return_tensors == "tf":
       lowerCAmelCase     :    Any						=   tf.convert_to_tensor(a_	)
       # boxes batch size of 1 by default
       lowerCAmelCase     :    int						=   tf.expand_dims(a_		,      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":
       lowerCAmelCase     :    Dict						=   torch.from_numpy(a_	)
       # point batch size of 1 by default
       lowerCAmelCase     :    Any						=   input_points.unsqueeze(1	) if len(input_points.shape	) != 4 else input_points
     elif return_tensors == "tf":
       lowerCAmelCase     :    Optional[Any]						=   tf.convert_to_tensor(a_	)
       # point batch size of 1 by default
       lowerCAmelCase     :    int						=   tf.expand_dims(a_		,      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":
       lowerCAmelCase     :    Dict						=   torch.from_numpy(a_	)
       # point batch size of 1 by default
       lowerCAmelCase     :    Any						=   input_labels.unsqueeze(1	) if len(input_labels.shape	) != 3 else input_labels
     elif return_tensors == "tf":
       lowerCAmelCase     :    List[str]						=   tf.convert_to_tensor(a_	)
       # point batch size of 1 by default
       lowerCAmelCase     :    Union[str, Any]						=   tf.expand_dims(a_		,      1	) if len(input_labels.shape	) != 3 else input_labels
     encoding_image_processor.update({"input_labels": input_labels}	)

   return encoding_image_processor



 def   _lowerCamelCase    (   self		,      a_		,      a_	):
   lowerCAmelCase     :    Tuple						=   max([point.shape[0] for point in input_points]	)
   lowerCAmelCase     :    Union[str, Any]						=   []
   for i, point in enumerate(a_	):
     if point.shape[0] != expected_nb_points:
       lowerCAmelCase     :    Optional[Any]						=   np.concatenate(
           [point, np.zeros((expected_nb_points - point.shape[0], 2)	) + self.point_pad_value]		,      axis=0	)
       lowerCAmelCase     :    Any						=   np.append(input_labels[i]		,      [self.point_pad_value]	)
     processed_input_points.append(a_	)
   lowerCAmelCase     :    Union[str, Any]						=   processed_input_points
   return input_points, input_labels



 def   _lowerCamelCase    (   self		,      a_		,      a_		,      a_		,      a_=False	):
   lowerCAmelCase     :    Any						=   original_size
   lowerCAmelCase     :    List[str]						=   self.image_processor._get_preprocess_shape(a_		,      longest_edge=a_	)
   lowerCAmelCase     :    Optional[int]						=   deepcopy(a_	).astype(a_	)

   if is_bounding_box:
     lowerCAmelCase     :    Union[str, Any]						=   coords.reshape(-1		,      2		,      2	)

   lowerCAmelCase     :    Any						=   coords[..., 0] * (new_w / old_w)
   lowerCAmelCase     :    int						=   coords[..., 1] * (new_h / old_h)

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

   return coords



 def   _lowerCamelCase    (   self		,      a_=None		,      a_=None		,      a_=None		,      ):
   if input_points is not None:
     if hasattr(a_		,      "numpy"	):  # Checks for TF or Torch tensor
       lowerCAmelCase     :    int						=   input_points.numpy().tolist()

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

   if input_labels is not None:
     if hasattr(a_		,      "numpy"	):
       lowerCAmelCase     :    Optional[int]						=   input_labels.numpy().tolist()

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

   if input_boxes is not None:
     if hasattr(a_		,      "numpy"	):
       lowerCAmelCase     :    Any						=   input_boxes.numpy().tolist()

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

   return input_points, input_labels, input_boxes



 @property
 def   _lowerCamelCase    (   self	):
   lowerCAmelCase     :    Union[str, Any]						=   self.image_processor.model_input_names
   return list(dict.fromkeys(a_	)	)





 def   _lowerCamelCase    (   self		,      *a_		,      **a_	):
   return self.image_processor.post_process_masks(*a_		,      **a_	)










'''simple docstring'''






def      __A						(							a_						:  int      ,a_						:  int	):
		return abs(a_	) if a == 0 else greatest_common_divisor(b % a      ,a_	)






def      __A						(							a_						:  int      ,a_						:  int	):
		while y:  # --> when y=0 then loop will terminate and return x as final GCD.
				lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   y, x % y
		return abs(a_	)






def      __A						(							):
		try:
				lowerCAmelCase     :    Tuple						=   input("Enter two integers separated by comma (,): "	).split(","	)
				lowerCAmelCase     :    Tuple						=   int(nums[0]	)
				lowerCAmelCase     :    Tuple						=   int(nums[1]	)
				print(
				    f'''greatest_common_divisor({num_a}, {num_a}) = '''
				    f'''{greatest_common_divisor(a_      ,a_	)}'''	)
				print(f'''By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(a_      ,a_	)}'''	)
		except (IndexError, UnboundLocalError, ValueError):
				print("Wrong input"	)


if __name__ == "__main__":
					main()



