






'''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   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  _a  : Optional[int]      			=     ['''image_processor''']
  _a  : Any      			=     '''SamImageProcessor'''







  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         super().__init__(UpperCamelCase__	)
         a_						     =			self.image_processor
         a_						     =			-10
         a_						     =			self.image_processor.size['longest_edge']







  def __call__(			self   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__ = None   ,	**UpperCamelCase__   ,	):






         """simple docstring"""


         a_						     =			self.image_processor(
             UpperCamelCase__   ,	return_tensors=UpperCamelCase__   ,	**UpperCamelCase__   ,	)

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

         if hasattr(UpperCamelCase__   ,	'numpy'	):  # Checks if Torch or TF tensor
                a_						     =			original_sizes.numpy()

         a_     ,	a_     ,	a_						     =			self._check_and_preprocess_points(
             input_points=UpperCamelCase__   ,	input_labels=UpperCamelCase__   ,	input_boxes=UpperCamelCase__   ,	)

         a_						     =			self._normalize_and_convert(
             UpperCamelCase__   ,	UpperCamelCase__   ,	input_points=UpperCamelCase__   ,	input_labels=UpperCamelCase__   ,	input_boxes=UpperCamelCase__   ,	return_tensors=UpperCamelCase__   ,	)

         return encoding_image_processor







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__="pt"   ,	):






         """simple docstring"""


         if input_points is not None:
                if len(UpperCamelCase__	) != len(UpperCamelCase__	):
                       a_						     =			[
                           self._normalize_coordinates(self.target_size   ,	UpperCamelCase__   ,	original_sizes[0]	) for point in input_points
                       ]
                else:
                       a_						     =			[
                           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:
                              a_     ,	a_						     =			self._pad_points_and_labels(UpperCamelCase__   ,	UpperCamelCase__	)

                a_						     =			np.array(UpperCamelCase__	)

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

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

         if input_boxes is not None:
                if return_tensors == "pt":
                       a_						     =			torch.from_numpy(UpperCamelCase__	)
                       # boxes batch size of 1 by default
                       a_						     =			input_boxes.unsqueeze(1	) if len(input_boxes.shape	) != 3 else input_boxes
                elif return_tensors == "tf":
                       a_						     =			tf.convert_to_tensor(UpperCamelCase__	)
                       # boxes batch size of 1 by default
                       a_						     =			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":
                       a_						     =			torch.from_numpy(UpperCamelCase__	)
                       # point batch size of 1 by default
                       a_						     =			input_points.unsqueeze(1	) if len(input_points.shape	) != 4 else input_points
                elif return_tensors == "tf":
                       a_						     =			tf.convert_to_tensor(UpperCamelCase__	)
                       # point batch size of 1 by default
                       a_						     =			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":
                       a_						     =			torch.from_numpy(UpperCamelCase__	)
                       # point batch size of 1 by default
                       a_						     =			input_labels.unsqueeze(1	) if len(input_labels.shape	) != 3 else input_labels
                elif return_tensors == "tf":
                       a_						     =			tf.convert_to_tensor(UpperCamelCase__	)
                       # point batch size of 1 by default
                       a_						     =			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    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__=False	):






         """simple docstring"""


         a_     ,	a_						     =			original_size
         a_     ,	a_						     =			self.image_processor._get_preprocess_shape(UpperCamelCase__   ,	longest_edge=UpperCamelCase__	)
         a_						     =			deepcopy(UpperCamelCase__	).astype(UpperCamelCase__	)

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

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

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

         return coords







  def    _a       (			self   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	):






         """simple docstring"""


         if input_points is not None:
                if hasattr(UpperCamelCase__   ,	'numpy'	):  # Checks for TF or Torch tensor
                       a_						     =			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.'	)
                a_						     =			[np.array(UpperCamelCase__	) for input_point in input_points]
         else:
                a_						     =			None

         if input_labels is not None:
                if hasattr(UpperCamelCase__   ,	'numpy'	):
                       a_						     =			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.'	)
                a_						     =			[np.array(UpperCamelCase__	) for label in input_labels]
         else:
                a_						     =			None

         if input_boxes is not None:
                if hasattr(UpperCamelCase__   ,	'numpy'	):
                       a_						     =			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.'	)
                a_						     =			[np.array(UpperCamelCase__	).astype(np.floataa	) for box in input_boxes]
         else:
                a_						     =			None

         return input_points, input_labels, input_boxes







  @property
  def    _a       (			self	):






         """simple docstring"""


         a_						     =			self.image_processor.model_input_names
         return list(dict.fromkeys(UpperCamelCase__	)	)







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         return self.image_processor.post_process_masks(*UpperCamelCase__   ,	**UpperCamelCase__	)












'''simple docstring'''







import multiprocessing
import os
from typing import BinaryIO, Optional, Union

import fsspec

from .. import Dataset, Features, NamedSplit, config
from ..formatting import query_table
from ..packaged_modules.json.json import Json
from ..utils import logging
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader




class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = False   ,	UpperCamelCase__ = False   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	**UpperCamelCase__   ,	):






         """simple docstring"""


         super().__init__(
             UpperCamelCase__   ,	split=UpperCamelCase__   ,	features=UpperCamelCase__   ,	cache_dir=UpperCamelCase__   ,	keep_in_memory=UpperCamelCase__   ,	streaming=UpperCamelCase__   ,	num_proc=UpperCamelCase__   ,	**UpperCamelCase__   ,	)
         a_						     =			field
         a_						     =			path_or_paths if isinstance(UpperCamelCase__   ,	UpperCamelCase__	) else {self.split: path_or_paths}
         a_						     =			Json(
             cache_dir=UpperCamelCase__   ,	data_files=UpperCamelCase__   ,	features=UpperCamelCase__   ,	field=UpperCamelCase__   ,	**UpperCamelCase__   ,	)







  def    _a       (			self	):






         """simple docstring"""


         if self.streaming:
                a_						     =			self.builder.as_streaming_dataset(split=self.split	)
         # Build regular (map-style) dataset
         else:
                a_						     =			None
                a_						     =			None
                a_						     =			None
                a_						     =			None

                self.builder.download_and_prepare(
                    download_config=UpperCamelCase__   ,	download_mode=UpperCamelCase__   ,	verification_mode=UpperCamelCase__   ,	base_path=UpperCamelCase__   ,	num_proc=self.num_proc   ,	)
                a_						     =			self.builder.as_dataset(
                    split=self.split   ,	verification_mode=UpperCamelCase__   ,	in_memory=self.keep_in_memory	)
         return dataset





class   __SCREAMING_SNAKE_CASE       :


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__ = None   ,	UpperCamelCase__ = None   ,	**UpperCamelCase__   ,	):






         """simple docstring"""


         if num_proc is not None and num_proc <= 0:
                raise ValueError(f'num_proc {num_proc} must be an integer > 0.'	)

         a_						     =			dataset
         a_						     =			path_or_buf
         a_						     =			batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
         a_						     =			num_proc
         a_						     =			'utf-8'
         a_						     =			to_json_kwargs







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			self.to_json_kwargs.pop('path_or_buf'   ,	UpperCamelCase__	)
         a_						     =			self.to_json_kwargs.pop('orient'   ,	'records'	)
         a_						     =			self.to_json_kwargs.pop('lines'   ,	True if orient == 'records' else False	)
         a_						     =			self.to_json_kwargs.pop('index'   ,	False if orient in ['split', 'table'] else True	)
         a_						     =			self.to_json_kwargs.pop('compression'   ,	UpperCamelCase__	)

         if compression not in [None, "infer", "gzip", "bz2", "xz"]:
                raise NotImplementedError(f'`datasets` currently does not support {compression} compression'	)

         if isinstance(self.path_or_buf   ,	(str, bytes, os.PathLike)	):
                with fsspec.open(self.path_or_buf   ,	'wb'   ,	compression=UpperCamelCase__	) as buffer:
                       a_						     =			self._write(file_obj=UpperCamelCase__   ,	orient=UpperCamelCase__   ,	lines=UpperCamelCase__   ,	index=UpperCamelCase__   ,	**self.to_json_kwargs	)
         else:
                if compression:
                       raise NotImplementedError(
                           f'The compression parameter is not supported when writing to a buffer, but compression={compression}'
                           ' was passed. Please provide a local path instead.'	)
                a_						     =			self._write(
                    file_obj=self.path_or_buf   ,	orient=UpperCamelCase__   ,	lines=UpperCamelCase__   ,	index=UpperCamelCase__   ,	**self.to_json_kwargs	)
         return written







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_     ,	a_     ,	a_     ,	a_     ,	a_						     =			args

         a_						     =			query_table(
             table=self.dataset.data   ,	key=slice(UpperCamelCase__   ,	offset + self.batch_size	)   ,	indices=self.dataset._indices   ,	)
         a_						     =			batch.to_pandas().to_json(
             path_or_buf=UpperCamelCase__   ,	orient=UpperCamelCase__   ,	lines=UpperCamelCase__   ,	index=UpperCamelCase__   ,	**UpperCamelCase__	)
         if not json_str.endswith('\n'	):
                json_str += "\n"
         return json_str.encode(self.encoding	)







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	**UpperCamelCase__   ,	):






         """simple docstring"""


         a_						     =			0

         if self.num_proc is None or self.num_proc == 1:
                for offset in logging.tqdm(
                    range(0   ,	len(self.dataset	)   ,	self.batch_size	)   ,	unit='ba'   ,	disable=not logging.is_progress_bar_enabled()   ,	desc='Creating json from Arrow format'   ,	):
                       a_						     =			self._batch_json((offset, orient, lines, index, to_json_kwargs)	)
                       written += file_obj.write(UpperCamelCase__	)
         else:
                a_     ,	a_						     =			len(self.dataset	), self.batch_size
                with multiprocessing.Pool(self.num_proc	) as pool:
                       for json_str in logging.tqdm(
                           pool.imap(
                               self._batch_json   ,	[(offset, orient, lines, index, to_json_kwargs) for offset in range(0   ,	UpperCamelCase__   ,	UpperCamelCase__	)]   ,	)   ,	total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size   ,	unit='ba'   ,	disable=not logging.is_progress_bar_enabled()   ,	desc='Creating json from Arrow format'   ,	):
                              written += file_obj.write(UpperCamelCase__	)

         return written




