sentinelhub 3.11.1__tar.gz → 3.11.2__tar.gz

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sentinelhub
-Version: 3.11.1
+Version: 3.11.2
 Summary: Python API for Sentinel Hub
 Project-URL: Homepage, https://github.com/sentinel-hub/sentinelhub-py
 Project-URL: Documentation, https://sentinelhub-py.readthedocs.io
@@ -159,7 +159,6 @@ A high-level overview of the main functionalities:
   * [BYOC API](https://docs.sentinel-hub.com/api/latest/api/byoc/),
   * [Statistical API](https://docs.sentinel-hub.com/api/latest/api/statistical/),
   * [OGC services (WMS/WCS/WFS)](https://docs.sentinel-hub.com/api/latest/api/ogc/),
-  * [FIS](https://www.sentinel-hub.com/develop/api/ogc/fis-request/),
   * authentication and rate-limit handling,
 
 - geospatial utilities

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/README.md

@@ -60,7 +60,6 @@ A high-level overview of the main functionalities:
   * [BYOC API](https://docs.sentinel-hub.com/api/latest/api/byoc/),
   * [Statistical API](https://docs.sentinel-hub.com/api/latest/api/statistical/),
   * [OGC services (WMS/WCS/WFS)](https://docs.sentinel-hub.com/api/latest/api/ogc/),
-  * [FIS](https://www.sentinel-hub.com/develop/api/ogc/fis-request/),
   * authentication and rate-limit handling,
 
 - geospatial utilities

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/pyproject.toml

@@ -63,7 +63,7 @@ docs = [
     "matplotlib",
     "nbsphinx",
     "sphinx==7.1.2",
-    "sphinx_mdinclude==0.5.4",  # version fixed because 0.6.0 didnt work at release time of 3.10.2
+    "sphinx_mdinclude==0.5.4", # version fixed because 0.6.0 didnt work at release time of 3.10.2
     "sphinx_rtd_theme==1.3.0",
 ]
 dev = [
@@ -199,6 +199,7 @@ max-args = 10
 max-attributes = 21
 max-locals = 20
 min-public-methods = 0
+max-positional-arguments = 10
 
 [tool.pylint.similarities]
 min-similarity-lines = 5
@@ -232,6 +233,7 @@ disallow_untyped_decorators = true
 warn_unreachable = true
 strict_equality = true
 pretty = true
+files=["sentinelhub"]
 
 [tool.nbqa.addopts]
 ruff = ["--extend-ignore=E402,T201,B015,B018,NPY002,UP,FA"]

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/__init__.py

@@ -5,20 +5,16 @@ This module lists all externally useful classes and functions
 from ._version import __version__
 from .api import (
     AsyncProcessRequest,
-    BatchCollection,
     BatchProcessClient,
     BatchProcessRequest,
-    BatchRequest,
     BatchRequestStatus,
     BatchStatisticalRequest,
-    BatchTileStatus,
     BatchUserAction,
     ByocCollection,
     ByocCollectionAdditionalData,
     ByocCollectionBand,
     ByocTile,
     FisRequest,
-    SentinelHubBatch,
     SentinelHubBatchStatistical,
     SentinelHubBYOC,
     SentinelHubCatalog,
@@ -28,8 +24,6 @@ from .api import (
     WebFeatureService,
     WmsRequest,
     get_async_running_status,
-    monitor_batch_analysis,
-    monitor_batch_job,
     monitor_batch_process_analysis,
     monitor_batch_process_job,
     monitor_batch_statistical_analysis,
@@ -40,7 +34,6 @@ from .api.fis import HistogramType
 from .api.ogc import CustomUrlParam
 from .api.opensearch import get_area_dates, get_area_info, get_tile_info, get_tile_info_id
 from .areas import (
-    BatchSplitter,
     BBoxSplitter,
     CustomGridSplitter,
     OsmSplitter,

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/_version.py

@@ -1,3 +1,3 @@
 """Version of the sentinelhub package."""
 
-__version__ = "3.11.1"
+__version__ = "3.11.2"

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/api/__init__.py

@@ -3,18 +3,12 @@ The part of the package that implements interface with Sentinel Hub services.
 """
 
 from .batch import (
-    BatchCollection,
     BatchProcessClient,
     BatchProcessRequest,
-    BatchRequest,
     BatchRequestStatus,
     BatchStatisticalRequest,
-    BatchTileStatus,
     BatchUserAction,
-    SentinelHubBatch,
     SentinelHubBatchStatistical,
-    monitor_batch_analysis,
-    monitor_batch_job,
     monitor_batch_process_analysis,
     monitor_batch_process_job,
     monitor_batch_statistical_analysis,

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/api/batch/__init__.py

@@ -3,12 +3,9 @@ The part of the package that implements interface with Sentinel Hub services.
 """
 
 from .base import BatchRequestStatus, BatchUserAction
-from .process import BatchCollection, BatchRequest, BatchTileStatus, SentinelHubBatch
-from .process_v2 import BatchProcessClient, BatchProcessRequest
+from .process import BatchProcessClient, BatchProcessRequest
 from .statistical import BatchStatisticalRequest, SentinelHubBatchStatistical
 from .utils import (
-    monitor_batch_analysis,
-    monitor_batch_job,
     monitor_batch_process_analysis,
     monitor_batch_process_job,
     monitor_batch_statistical_analysis,

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/api/batch/base.py

@@ -26,8 +26,6 @@ class BatchRequestStatus(Enum):
     PROCESSING = "PROCESSING"
     DONE = "DONE"
     FAILED = "FAILED"
-    PARTIAL = "PARTIAL"
-    CANCELED = "CANCELED"
     STOPPED = "STOPPED"
 
 
@@ -36,9 +34,8 @@ class BatchUserAction(Enum):
 
     START = "START"
     ANALYSE = "ANALYSE"
-    NONE = "NONE"
-    CANCEL = "CANCEL"
     STOP = "STOP"
+    NONE = "NONE"
 
 
 class StoppedStatusReason(Enum):

sentinelhub-3.11.2/sentinelhub/api/batch/process_v2.py

@@ -0,0 +1,14 @@
+"""
+Deprecated module for Batch Processing v2 API. The contents have been moved to `sentinelhub.api.batch.process`.
+"""
+
+import warnings
+
+from sentinelhub.api.batch.process import *  # noqa: F403 # pylint: disable=unused-wildcard-import, wildcard-import
+from sentinelhub.exceptions import SHDeprecationWarning
+
+warnings.warn(
+    "The module sentinelhub.api.batch.process_v2 has been renamed, please use sentinelhub.api.batch.process instead.",
+    SHDeprecationWarning,
+    stacklevel=2,
+)

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/api/batch/utils.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 
 import logging
 import time
-from collections import defaultdict
 from typing import Union
 
 from tqdm.auto import tqdm
@@ -14,13 +13,11 @@ from tqdm.auto import tqdm
 from ...config import SHConfig
 from ...types import JsonDict
 from .base import BatchRequestStatus
-from .process import BatchRequest, BatchTileStatus, SentinelHubBatch
-from .process_v2 import BatchProcessClient, BatchProcessRequest
+from .process import BatchProcessClient, BatchProcessRequest
 from .statistical import BatchStatisticalRequest, SentinelHubBatchStatistical
 
 LOGGER = logging.getLogger(__name__)
 
-BatchProcessRequestSpec = Union[str, dict, BatchRequest]
 BatchStatisticalRequestSpec = Union[str, dict, BatchStatisticalRequest]
 
 
@@ -32,81 +29,6 @@ _MIN_ANALYSIS_SLEEP_TIME = 5
 _DEFAULT_ANALYSIS_SLEEP_TIME = 10
 
 
-def monitor_batch_job(
-    batch_request: BatchProcessRequestSpec,
-    config: SHConfig | None = None,
-    sleep_time: int = _DEFAULT_SLEEP_TIME,
-    analysis_sleep_time: int = _DEFAULT_ANALYSIS_SLEEP_TIME,
-) -> defaultdict[BatchTileStatus, list[dict]]:
-    """A utility function that keeps checking for number of processed tiles until the given batch request finishes.
-    During the process it shows a progress bar and at the end it reports information about finished and failed tiles.
-
-    Notes:
-
-      - Before calling this function make sure to start a batch job by calling `SentinelHubBatch.start_job` method. In
-        case a batch job is still being analysed this function will wait until the analysis ends.
-      - This function will be continuously collecting tile information from Sentinel Hub service. To avoid making too
-        many requests please make sure to adjust `sleep_time` parameter according to the size of your job. Larger jobs
-        don't need very frequent tile status updates.
-      - Some information about the progress of this function is reported to logging level INFO.
-
-    :param batch_request: An object with information about a batch request. Alternatively, it could only be a batch
-        request id or a payload.
-    :param config: A configuration object with required parameters `sh_client_id`, `sh_client_secret`, and
-        `sh_auth_base_url` which is used for authentication and `sh_base_url` which defines the service deployment
-        where Batch API will be called.
-    :param sleep_time: Number of seconds to sleep between consecutive progress bar updates.
-    :param analysis_sleep_time: Number of seconds between consecutive status updates during analysis phase.
-    :return: A dictionary mapping a tile status to a list of tile payloads.
-    """
-    if sleep_time < _MIN_SLEEP_TIME:
-        raise ValueError(f"To avoid making too many service requests please set sleep_time>={_MIN_SLEEP_TIME}")
-
-    batch_request = monitor_batch_analysis(batch_request, config=config, sleep_time=analysis_sleep_time)
-    if batch_request.status is BatchRequestStatus.PROCESSING:
-        LOGGER.info("Batch job is running")
-
-    batch_client = SentinelHubBatch(config=config)
-
-    tiles_per_status = _get_batch_tiles_per_status(batch_request, batch_client)
-    success_count = len(tiles_per_status[BatchTileStatus.PROCESSED])
-    finished_count = success_count + len(tiles_per_status[BatchTileStatus.FAILED])
-
-    progress_bar = tqdm(total=batch_request.tile_count, initial=finished_count, desc="Progress rate")
-    success_bar = tqdm(total=finished_count, initial=success_count, desc="Success rate")
-
-    monitoring_status = [BatchRequestStatus.ANALYSIS_DONE, BatchRequestStatus.PROCESSING]
-    with progress_bar, success_bar:
-        while finished_count < batch_request.tile_count and batch_request.status in monitoring_status:
-            time.sleep(sleep_time)
-            batch_request = batch_client.get_request(batch_request)
-
-            tiles_per_status = _get_batch_tiles_per_status(batch_request, batch_client)
-            new_success_count = len(tiles_per_status[BatchTileStatus.PROCESSED])
-            new_finished_count = new_success_count + len(tiles_per_status[BatchTileStatus.FAILED])
-
-            progress_bar.update(new_finished_count - finished_count)
-            if new_finished_count != finished_count:
-                success_bar.total = new_finished_count
-                success_bar.refresh()
-            success_bar.update(new_success_count - success_count)
-
-            finished_count = new_finished_count
-            success_count = new_success_count
-
-    failed_tiles_num = finished_count - success_count
-    if failed_tiles_num:
-        LOGGER.info("Batch job failed for %d tiles", failed_tiles_num)
-
-    while batch_request.status is BatchRequestStatus.PROCESSING:
-        LOGGER.info("Waiting on batch job status update.")
-        time.sleep(sleep_time)
-        batch_request = batch_client.get_request(batch_request)
-
-    LOGGER.info("Batch job finished with status %s", batch_request.status.value)
-    return tiles_per_status
-
-
 def monitor_batch_process_job(
     request: BatchProcessRequest,
     client: BatchProcessClient,
@@ -155,23 +77,6 @@ def monitor_batch_process_job(
     return batch_request
 
 
-def _get_batch_tiles_per_status(
-    batch_request: BatchRequest, batch_client: SentinelHubBatch
-) -> defaultdict[BatchTileStatus, list[dict]]:
-    """A helper function that queries information about batch tiles and returns information about tiles, grouped by
-    tile status.
-
-    :return: A dictionary mapping a tile status to a list of tile payloads.
-    """
-    tiles_per_status = defaultdict(list)
-
-    for tile in batch_client.iter_tiles(batch_request):
-        status = BatchTileStatus(tile["status"])
-        tiles_per_status[status].append(tile)
-
-    return tiles_per_status
-
-
 def monitor_batch_statistical_job(
     batch_request: BatchStatisticalRequestSpec,
     config: SHConfig | None = None,
@@ -217,38 +122,6 @@ def monitor_batch_statistical_job(
     return request_status
 
 
-def monitor_batch_analysis(
-    batch_request: BatchProcessRequestSpec,
-    config: SHConfig | None = None,
-    sleep_time: int = _DEFAULT_ANALYSIS_SLEEP_TIME,
-) -> BatchRequest:
-    """A utility function that is waiting until analysis phase of a batch job finishes and regularly checks its status.
-    In case analysis phase failed it raises an error at the end.
-
-    :param batch_request: An object with information about a batch request. Alternatively, it could only be a batch
-        request id or a payload.
-    :param config: A configuration object with required parameters `sh_client_id`, `sh_client_secret`, and
-        `sh_auth_base_url` which is used for authentication and `sh_base_url` which defines the service deployment
-        where Batch API will be called.
-    :param sleep_time: Number of seconds between consecutive status updates during analysis phase.
-    :return: Batch request info
-    """
-    if sleep_time < _MIN_ANALYSIS_SLEEP_TIME:
-        raise ValueError(
-            f"To avoid making too many service requests please set analysis sleep time >={_MIN_ANALYSIS_SLEEP_TIME}"
-        )
-
-    batch_client = SentinelHubBatch(config=config)
-    batch_request = batch_client.get_request(batch_request)
-    while batch_request.status in [BatchRequestStatus.CREATED, BatchRequestStatus.ANALYSING]:
-        LOGGER.info("Batch job has a status %s, sleeping for %d seconds", batch_request.status.value, sleep_time)
-        time.sleep(sleep_time)
-        batch_request = batch_client.get_request(batch_request)
-
-    batch_request.raise_for_status(status=[BatchRequestStatus.FAILED, BatchRequestStatus.CANCELED])
-    return batch_request
-
-
 def monitor_batch_process_analysis(
     request: BatchProcessRequest,
     client: BatchProcessClient,
@@ -272,7 +145,7 @@ def monitor_batch_process_analysis(
         time.sleep(sleep_time)
         batch_request = client.get_request(batch_request)
 
-    batch_request.raise_for_status(status=[BatchRequestStatus.FAILED, BatchRequestStatus.CANCELED])
+    batch_request.raise_for_status(status=[BatchRequestStatus.FAILED, BatchRequestStatus.STOPPED])
     return batch_request
 
 
@@ -305,5 +178,5 @@ def monitor_batch_statistical_analysis(
         request_status = BatchRequestStatus(batch_client.get_status(batch_request)["status"])
 
     batch_request = batch_client.get_request(batch_request)
-    batch_request.raise_for_status(status=[BatchRequestStatus.FAILED, BatchRequestStatus.CANCELED])
+    batch_request.raise_for_status(status=[BatchRequestStatus.FAILED, BatchRequestStatus.STOPPED])
     return batch_request

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/areas.py

@@ -17,13 +17,12 @@ import shapely.ops
 from shapely.geometry import GeometryCollection, MultiPolygon, Polygon
 from shapely.geometry.base import BaseGeometry
 
-from .api import BatchRequest, SentinelHubBatch, SentinelHubCatalog
+from .api import SentinelHubCatalog
 from .config import SHConfig
 from .constants import CRS
 from .data_collections import DataCollection
 from .geo_utils import transform_point
 from .geometry import BBox, Geometry, _BaseGeometry
-from .types import JsonDict
 
 T = TypeVar("T", float, int)
 
@@ -534,7 +533,7 @@ class BaseUtmSplitter(AreaSplitter, metaclass=ABCMeta):
                     geo_object for geo_object in intersection if isinstance(geo_object, (Polygon, MultiPolygon))
                 )
 
-            if not intersection.is_empty:
+            if intersection.area > 0:
                 intersection = Geometry(intersection, CRS.WGS84).transform(utm_crs)
 
                 bbox_partition = self._align_bbox_to_size(intersection.bbox).get_partition(size_x=size_x, size_y=size_y)
@@ -624,81 +623,6 @@ class UtmZoneSplitter(BaseUtmSplitter):
         return list(zip(utm_geom_list, utm_prop_list))
 
 
-class BatchSplitter(AreaSplitter):
-    """A splitter that obtains split bounding boxes from Sentinel Hub Batch API"""
-
-    def __init__(
-        self,
-        *,
-        request_id: str | None = None,
-        batch_request: BatchRequest | None = None,
-        config: SHConfig | None = None,
-    ):
-        """
-        :param request_id: An ID of a batch request
-        :param batch_request: A batch request object. It is an alternative to the `request_id` parameter
-        :param config: A configuration object with credentials and information about which service deployment to
-            use.
-        """
-        self.batch_client = SentinelHubBatch(config=config)
-
-        if batch_request is None:
-            if request_id is None:
-                raise ValueError("One of the parameters request_id and batch_request has to be given")
-            batch_request = self.batch_client.get_request(request_id)
-
-        self.batch_request = batch_request
-        self.tile_size = self._get_tile_size()
-        self.tile_buffer = self._get_tile_buffer()
-
-        batch_geometry: _BaseGeometry | None = batch_request.geometry or batch_request.bbox
-        if batch_geometry is None:
-            raise ValueError("Batch request has both `bbox` and `geometry` set to `None`, which is invalid.")
-
-        super().__init__([batch_geometry.geometry], batch_geometry.crs)
-
-    def _get_tile_size(self) -> tuple[float, float]:
-        """Collects a tile size from the tiling grid info in units of the grid CRS."""
-        tiling_grid_id = self.batch_request.tiling_grid["id"]
-        grid_info = self.batch_client.get_tiling_grid(tiling_grid_id)
-
-        return grid_info["properties"]["tileWidth"], grid_info["properties"]["tileHeight"]
-
-    def _get_tile_buffer(self) -> tuple[float, float]:
-        """Calculates tile buffer in units of the grid CRS."""
-        grid_info = self.batch_request.tiling_grid
-        resolution = grid_info["resolution"]
-        return grid_info.get("bufferX", 0) * resolution, grid_info.get("bufferY", 0) * resolution
-
-    def _make_split(self) -> tuple[list[BBox], list[dict[str, object]]]:
-        """This method actually loads bounding boxes from the service and prepares the lists"""
-        tile_info_list = list(self.batch_client.iter_tiles(self.batch_request))
-
-        bbox_list = [self._reconstruct_bbox(tile_info) for tile_info in tile_info_list]
-        info_list = [
-            {key: value for key, value in tile_info.items() if key != "geometry"} for tile_info in tile_info_list
-        ]
-
-        return bbox_list, info_list
-
-    def _reconstruct_bbox(self, tile_info: JsonDict) -> BBox:
-        """Reconstructs a bounding box from tile and grid properties."""
-        tile_crs = CRS(tile_info["origin"]["crs"]["properties"]["name"])
-
-        upper_left_corner = tile_info["origin"]["coordinates"]
-        width, height = self.tile_size
-
-        return BBox(
-            (
-                upper_left_corner[0] - self.tile_buffer[0],
-                upper_left_corner[1] - height - self.tile_buffer[1],
-                upper_left_corner[0] + width + self.tile_buffer[0],
-                upper_left_corner[1] + self.tile_buffer[1],
-            ),
-            tile_crs,
-        )
-
-
 def _parse_to_pair(parameter: T | tuple[T, T], allowed_types: tuple[type, ...], param_name: str = "") -> tuple[T, T]:
     """Parses the parameters defining the splitting of the BBox."""
 

{sentinelhub-3.11.1 → sentinelhub-3.11.2}/sentinelhub/config.py

@@ -216,5 +216,5 @@ class SHConfig(_SHConfig):
     @classmethod
     def get_config_location(cls) -> str:
         """Returns the default location of the user configuration file on disk."""
-        user_folder = os.path.expanduser("~")
-        return os.path.join(user_folder, ".config", "sentinelhub", "config.toml")
+        config_folder = os.getenv("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
+        return os.path.join(config_folder, "sentinelhub", "config.toml")

sentinelhub-3.11.1/sentinelhub/api/batch/process.py

@@ -1,576 +0,0 @@
-"""
-Module implementing an interface with
-`Sentinel Hub Batch Processing API <https://docs.sentinel-hub.com/api/latest/api/batch/>`__.
-"""
-
-# ruff: noqa: FA100
-# do not use `from __future__ import annotations`, it clashes with `dataclass_json`
-import datetime as dt
-import logging
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
-
-from dataclasses_json import CatchAll, LetterCase, Undefined, dataclass_json
-from dataclasses_json import config as dataclass_config
-
-from ...constants import RequestType
-from ...data_collections import DataCollection
-from ...geometry import CRS, BBox, Geometry
-from ...types import Json, JsonDict
-from ..base import BaseCollection, SentinelHubFeatureIterator
-from ..process import SentinelHubRequest
-from ..utils import datetime_config, enum_config, remove_undefined
-from .base import BaseBatchClient, BaseBatchRequest, BatchRequestStatus, BatchUserAction
-
-LOGGER = logging.getLogger(__name__)
-
-BatchRequestType = Union[str, dict, "BatchRequest"]
-BatchCollectionType = Union[str, dict, "BatchCollection"]
-
-
-class BatchTileStatus(Enum):
-    """An enum class with all possible batch tile statuses"""
-
-    PENDING = "PENDING"
-    SCHEDULED = "SCHEDULED"
-    QUEUED = "QUEUED"
-    PROCESSING = "PROCESSING"
-    PROCESSED = "PROCESSED"
-    FAILED = "FAILED"
-
-
-class SentinelHubBatch(BaseBatchClient):
-    """An interface class for Sentinel Hub Batch API
-
-    For more info check `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#tag/batch_process>`__.
-    """
-
-    # pylint: disable=too-many-public-methods
-    @staticmethod
-    def _get_service_url(base_url: str) -> str:
-        """Provides URL to Catalog API"""
-        return f"{base_url}/api/v1/batch"
-
-    def create(
-        self,
-        sentinelhub_request: Union[SentinelHubRequest, JsonDict],
-        tiling_grid: Dict[str, Any],
-        output: Optional[Dict[str, Any]] = None,
-        bucket_name: Optional[str] = None,
-        description: Optional[str] = None,
-        **kwargs: Any,
-    ) -> "BatchRequest":
-        """Create a new batch request
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/createNewBatchProcessingRequest>`__
-
-        :param sentinelhub_request: An instance of SentinelHubRequest class containing all request parameters.
-            Alternatively, it can also be just a payload dictionary for Process API request
-        :param tiling_grid: A dictionary with tiling grid parameters. It can be built with `tiling_grid` method
-        :param output: A dictionary with output parameters. It can be built with `output` method. Alternatively, one
-            can set `bucket_name` parameter instead.
-        :param bucket_name: A name of an S3 bucket where to save data. Alternatively, one can set `output` parameter
-            to specify more output parameters.
-        :param description: A description of a batch request
-        :param kwargs: Any other arguments to be added to a dictionary of parameters.
-        :return: An instance of `SentinelHubBatch` object that represents a newly created batch request.
-        """
-
-        if isinstance(sentinelhub_request, SentinelHubRequest):
-            request_dict = sentinelhub_request.download_list[0].post_values
-        else:
-            request_dict = sentinelhub_request
-
-        if not isinstance(request_dict, dict):
-            raise ValueError(
-                "Parameter sentinelhub_request should be an instance of SentinelHubRequest or a "
-                "dictionary with a request payload"
-            )
-
-        payload = {
-            "processRequest": request_dict,
-            "tilingGrid": tiling_grid,
-            "output": output,
-            "bucketName": bucket_name,
-            "description": description,
-            **kwargs,
-        }
-        payload = remove_undefined(payload)
-
-        url = self._get_processing_url()
-        request_info = self.client.get_json_dict(url, post_values=payload, use_session=True)
-
-        return BatchRequest.from_dict(request_info)
-
-    @staticmethod
-    def tiling_grid(
-        grid_id: int, resolution: float, buffer: Optional[Tuple[int, int]] = None, **kwargs: Any
-    ) -> JsonDict:
-        """A helper method to build a dictionary with tiling grid parameters
-
-        :param grid_id: An ID of a tiling grid
-        :param resolution: A grid resolution
-        :param buffer: Optionally, a buffer around each tile can be defined. It can be defined with a tuple of integers
-            `(buffer_x, buffer_y)`, which specifies a number of buffer pixels in horizontal and vertical directions.
-        :param kwargs: Any other arguments to be added to a dictionary of parameters
-        :return: A dictionary with parameters
-        """
-        payload = {"id": grid_id, "resolution": resolution, **kwargs}
-        if buffer:
-            payload = {**payload, "bufferX": buffer[0], "bufferY": buffer[1]}
-        return payload
-
-    @staticmethod
-    def output(
-        *,
-        default_tile_path: Optional[str] = None,
-        overwrite: Optional[bool] = None,
-        skip_existing: Optional[bool] = None,
-        cog_output: Optional[bool] = None,
-        cog_parameters: Optional[Dict[str, Any]] = None,
-        create_collection: Optional[bool] = None,
-        collection_id: Optional[str] = None,
-        responses: Optional[List[str]] = None,
-        **kwargs: Any,
-    ) -> Dict[str, Any]:
-        """A helper method to build a dictionary with tiling grid parameters
-
-        :param default_tile_path: A path or a template on an s3 bucket where to store results. More info at Batch API
-            documentation
-        :param overwrite: A flag specifying if a request should overwrite existing outputs without failing
-        :param skip_existing: A flag specifying if existing outputs should be overwritten
-        :param cog_output: A flag specifying if outputs should be written in COGs (cloud-optimized GeoTIFFs )or
-            normal GeoTIFFs
-        :param cog_parameters: A dictionary specifying COG creation parameters
-        :param create_collection: If True the results will be written in COGs and a batch collection will be created
-        :param collection_id: If True results will be added to an existing collection
-        :param responses: Specification of path template for individual outputs/responses
-        :param kwargs: Any other arguments to be added to a dictionary of parameters
-        :return: A dictionary of output parameters
-        """
-        return remove_undefined(
-            {
-                "defaultTilePath": default_tile_path,
-                "overwrite": overwrite,
-                "skipExisting": skip_existing,
-                "cogOutput": cog_output,
-                "cogParameters": cog_parameters,
-                "createCollection": create_collection,
-                "collectionId": collection_id,
-                "responses": responses,
-                **kwargs,
-            }
-        )
-
-    def iter_tiling_grids(self, **kwargs: Any) -> SentinelHubFeatureIterator:
-        """An iterator over tiling grids
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/getBatchTilingGridsProperties>`__
-
-        :param kwargs: Any other request query parameters
-        :return: An iterator over tiling grid definitions
-        """
-        return SentinelHubFeatureIterator(
-            client=self.client,
-            url=self._get_tiling_grids_url(),
-            params=remove_undefined(kwargs),
-            exception_message="Failed to obtain information about available tiling grids",
-        )
-
-    def get_tiling_grid(self, grid_id: Union[int, str]) -> JsonDict:
-        """Provides a single tiling grid
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/getBatchTilingGridProperties>`__
-
-        :param grid_id: An ID of a requested tiling grid
-        :return: A tiling grid definition
-        """
-        url = self._get_tiling_grids_url(grid_id)
-        return self.client.get_json_dict(url=url, use_session=True)
-
-    def iter_requests(
-        self, user_id: Optional[str] = None, search: Optional[str] = None, sort: Optional[str] = None, **kwargs: Any
-    ) -> Iterator["BatchRequest"]:
-        """Iterate existing batch requests
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/getAllBatchProcessRequests>`__
-
-        :param user_id: Filter requests by a user id who defined a request
-        :param search: A search query to filter requests
-        :param sort: A sort query
-        :param kwargs: Any additional parameters to include in a request query
-        :return: An iterator over existing batch requests
-        """
-        params = remove_undefined({"userid": user_id, "search": search, "sort": sort, **kwargs})
-        feature_iterator = SentinelHubFeatureIterator(
-            client=self.client, url=self._get_processing_url(), params=params, exception_message="No requests found"
-        )
-        for request_info in feature_iterator:
-            yield BatchRequest.from_dict(request_info)
-
-    def get_latest_request(self) -> "BatchRequest":
-        """Provides a batch request that has been created the latest
-
-        :return: Batch request info
-        """
-        latest_request_iter = self.iter_requests(sort="created:desc", count=1)
-        try:
-            return next(latest_request_iter)
-        except StopIteration as exception:
-            raise ValueError("No batch request is available") from exception
-
-    def get_request(self, batch_request: BatchRequestType) -> "BatchRequest":
-        """Collects information about a single batch request
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/getSingleBatchProcessRequestById>`__
-
-        :return: Batch request info
-        """
-        request_id = self._parse_request_id(batch_request)
-        request_info = self.client.get_json_dict(url=self._get_processing_url(request_id), use_session=True)
-        return BatchRequest.from_dict(request_info)
-
-    def update_request(
-        self,
-        batch_request: BatchRequestType,
-        output: Optional[Dict[str, Any]] = None,
-        description: Optional[str] = None,
-        **kwargs: Any,
-    ) -> Json:
-        """Update batch job request parameters
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/updateBatchProcessRequest>`__
-
-        Similarly to `update_info` method, this method also updates local information in the current instance of
-        `SentinelHubBatch`.
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        :param output: A dictionary with output parameters to be updated.
-        :param description: A description of a batch request to be updated.
-        :param kwargs: Any other arguments to be added to a dictionary of parameters.
-        """
-        request_id = self._parse_request_id(batch_request)
-        payload = remove_undefined({"output": output, "description": description, **kwargs})
-        return self.client.get_json(
-            url=self._get_processing_url(request_id),
-            post_values=payload,
-            request_type=RequestType.PUT,
-            use_session=True,
-        )
-
-    def delete_request(self, batch_request: BatchRequestType) -> Json:
-        """Delete a batch job request
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/deleteBatchProcessRequest>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        """
-        request_id = self._parse_request_id(batch_request)
-        return self.client.get_json(
-            url=self._get_processing_url(request_id), request_type=RequestType.DELETE, use_session=True
-        )
-
-    def start_analysis(self, batch_request: BatchRequestType) -> Json:
-        """Starts analysis of a batch job request
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/batchAnalyse>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        """
-        return self._call_job(batch_request, "analyse")
-
-    def start_job(self, batch_request: BatchRequestType) -> Json:
-        """Starts running a batch job
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/batchStartProcessRequest>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        """
-        return self._call_job(batch_request, "start")
-
-    def cancel_job(self, batch_request: BatchRequestType) -> Json:
-        """Cancels a batch job
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/batchCancelProcessRequest>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        """
-        return self._call_job(batch_request, "cancel")
-
-    def restart_job(self, batch_request: BatchRequestType) -> Json:
-        """Restarts only those parts of a job that failed
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/batchRestartPartialProcessRequest>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        """
-        return self._call_job(batch_request, "restartpartial")
-
-    def iter_tiles(
-        self, batch_request: BatchRequestType, status: Union[None, "BatchTileStatus", str] = None, **kwargs: Any
-    ) -> SentinelHubFeatureIterator:
-        """Iterate over info about batch request tiles
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/getAllBatchProcessTiles>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        :param status: A filter to obtain only tiles with a certain status
-        :param kwargs: Any additional parameters to include in a request query
-        :return: An iterator over information about each tile
-        """
-        request_id = self._parse_request_id(batch_request)
-        if isinstance(status, BatchTileStatus):
-            status = status.value
-
-        return SentinelHubFeatureIterator(
-            client=self.client,
-            url=self._get_tiles_url(request_id),
-            params={"status": status, **kwargs},
-            exception_message="No tiles found, please run analysis on batch request before calling this method",
-        )
-
-    def get_tile(self, batch_request: BatchRequestType, tile_id: Optional[int]) -> JsonDict:
-        """Provides information about a single batch request tile
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/getBatchTileById>`__
-
-        :param batch_request: It could be a batch request object, a raw batch request payload or only a batch
-            request ID.
-        :param tile_id: An ID of a tile
-        :return: Information about a tile
-        """
-        request_id = self._parse_request_id(batch_request)
-        url = self._get_tiles_url(request_id, tile_id=tile_id)
-        return self.client.get_json_dict(url, use_session=True)
-
-    def iter_collections(self, search: Optional[str] = None, **kwargs: Any) -> SentinelHubFeatureIterator:
-        """Iterate over batch collections
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/getAllBatchCollections>`__
-
-        :param search: A search query to filter collections
-        :param kwargs: Any additional parameters to include in a request query
-        :return: An iterator over existing batch collections
-        """
-        return SentinelHubFeatureIterator(
-            client=self.client,
-            url=self._get_collections_url(),
-            params={"search": search, **kwargs},
-            exception_message="Failed to obtain information about available Batch collections",
-        )
-
-    def get_collection(self, collection_id: str) -> JsonDict:
-        """Get batch collection by its id
-
-        `Batch API reference
-        <https://docs.sentinel-hub.com/api/latest/reference/#operation/getSingleBatchCollectionById>`__
-
-        :param collection_id: A batch collection id
-        :return: A dictionary of the collection parameters
-        """
-        url = self._get_collections_url(collection_id)
-        return self.client.get_json_dict(url=url, use_session=True, extract_key="data")
-
-    def create_collection(self, collection: Union["BatchCollection", dict]) -> JsonDict:
-        """Create a new batch collection
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/createNewBatchCollection>`__
-
-        :param collection: Batch collection definition
-        :return: A dictionary of a newly created collection
-        """
-        collection_payload = self._parse_collection_to_dict(collection)
-        url = self._get_collections_url()
-        return self.client.get_json_dict(url=url, post_values=collection_payload, use_session=True, extract_key="data")
-
-    def update_collection(self, collection: Union["BatchCollection", dict]) -> Json:
-        """Update an existing batch collection
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/updateBatchCollection>`__
-
-        :param collection: Batch collection definition
-        """
-        collection_id = self._parse_collection_id(collection)
-        return self.client.get_json(
-            url=self._get_collections_url(collection_id),
-            post_values=self._parse_collection_to_dict(collection),
-            request_type=RequestType.PUT,
-            use_session=True,
-        )
-
-    def delete_collection(self, collection: BatchCollectionType) -> Json:
-        """Delete an existing batch collection
-
-        `Batch API reference <https://docs.sentinel-hub.com/api/latest/reference/#operation/deleteBatchCollection>`__
-
-        :param collection: Batch collection id or object
-        """
-        collection_id = self._parse_collection_id(collection)
-        return self.client.get_json(
-            url=self._get_collections_url(collection_id), request_type=RequestType.DELETE, use_session=True
-        )
-
-    def _get_processing_url(self, request_id: Optional[str] = None) -> str:
-        """Creates a URL for process endpoint"""
-        url = f"{self.service_url}/process"
-        if request_id is None:
-            return url
-        return f"{url}/{request_id}"
-
-    def _get_tiles_url(self, request_id: str, tile_id: Union[None, str, int] = None) -> str:
-        """Creates a URL for tiles endpoint"""
-        url = f"{self._get_processing_url(request_id)}/tiles"
-        if tile_id is None:
-            return url
-        return f"{url}/{tile_id}"
-
-    def _get_tiling_grids_url(self, grid_id: Union[None, str, int] = None) -> str:
-        """Creates a URL for tiling grids endpoint"""
-        url = f"{self.service_url}/tilinggrids"
-        if grid_id is None:
-            return url
-        return f"{url}/{grid_id}"
-
-    def _get_collections_url(self, collection_id: Optional[str] = None) -> str:
-        """Creates a URL for batch collections endpoint"""
-        url = f"{self.service_url}/collections"
-        if collection_id is None:
-            return url
-        return f"{url}/{collection_id}"
-
-    @staticmethod
-    def _parse_collection_id(data: BatchCollectionType) -> Optional[str]:
-        """Parses batch collection id from multiple possible inputs"""
-        if isinstance(data, (BatchCollection, DataCollection)):
-            return data.collection_id
-        if isinstance(data, dict):
-            return data["id"]
-        if isinstance(data, str):
-            return data
-        raise ValueError(f"Expected a BatchCollection dataclass, dictionary or a string, got {data}.")
-
-    @staticmethod
-    def _parse_collection_to_dict(data: Union["BatchCollection", dict]) -> dict:
-        """Constructs a dictionary from given object"""
-        if isinstance(data, BatchCollection):
-            return data.to_dict()  # type: ignore[attr-defined]
-        if isinstance(data, dict):
-            return data
-        raise ValueError(f"Expected either a BatchCollection or a dict, got {data}.")
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
-@dataclass(repr=False)
-class BatchRequest(BaseBatchRequest):  # pylint: disable=abstract-method
-    """A dataclass object that holds information about a batch request"""
-
-    # dataclass_json doesn't handle parameter inheritance correctly
-    # pylint: disable=duplicate-code
-
-    request_id: str = field(metadata=dataclass_config(field_name="id"))
-    process_request: dict
-    tile_count: int
-    status: BatchRequestStatus = field(metadata=enum_config(BatchRequestStatus))
-    user_id: Optional[str] = None
-    created: Optional[dt.datetime] = field(metadata=datetime_config, default=None)
-    tiling_grid: dict = field(default_factory=dict)
-    output: dict = field(default_factory=dict)
-    bucket_name: Optional[str] = None
-    description: Optional[str] = None
-    value_estimate: Optional[float] = None
-    tile_width_px: Optional[int] = None
-    tile_height_px: Optional[int] = None
-    user_action: Optional[BatchUserAction] = field(metadata=enum_config(BatchUserAction), default=None)
-    user_action_updated: Optional[str] = field(metadata=datetime_config, default=None)
-    error: Optional[str] = None
-    other_data: CatchAll = field(default_factory=dict)
-
-    _REPR_PARAM_NAMES = (
-        "request_id",
-        "description",
-        "bucket_name",
-        "created",
-        "status",
-        "user_action",
-        "value_estimate",
-        "tile_count",
-    )
-
-    @property
-    def evalscript(self) -> str:
-        """Provides an evalscript used by a batch request
-
-        :return: An evalscript
-        """
-        return self.process_request["evalscript"]
-
-    @property
-    def bbox(self) -> Optional[BBox]:
-        """Provides a bounding box used by a batch request
-
-        :return: An area bounding box together with CRS
-        :raises: ValueError
-        """
-        bbox, _, crs = self._parse_bounds_payload()
-        return None if bbox is None else BBox(bbox, crs)  # type: ignore[arg-type]
-
-    @property
-    def geometry(self) -> Optional[Geometry]:
-        """Provides a geometry used by a batch request
-
-        :return: An area geometry together with CRS
-        :raises: ValueError
-        """
-        _, geometry, crs = self._parse_bounds_payload()
-        return None if geometry is None else Geometry(geometry, crs)
-
-    def _parse_bounds_payload(self) -> Tuple[Optional[List[float]], Optional[list], CRS]:
-        """Parses bbox, geometry and crs from batch request payload. If bbox or geometry don't exist it returns None
-        instead.
-        """
-        bounds_definition = self.process_request["input"]["bounds"]
-        crs = CRS(bounds_definition["properties"]["crs"].rsplit("/", 1)[-1])
-
-        return bounds_definition.get("bbox"), bounds_definition.get("geometry"), crs
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
-@dataclass
-class BatchCollectionBatchData:
-    """Dataclass to hold batch collection batchData part of the payload"""
-
-    tiling_grid_id: Optional[int] = None
-    other_data: CatchAll = field(default_factory=dict)
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
-@dataclass
-class BatchCollectionAdditionalData:
-    """Dataclass to hold batch collection additionalData part of the payload"""
-
-    bands: Optional[Dict[str, Any]] = None
-    other_data: CatchAll = field(default_factory=dict)
-
-
-class BatchCollection(BaseCollection):
-    """Dataclass for batch collections"""
-
-    batch_data: Optional[BatchCollectionBatchData] = None
-    additional_data: Optional[BatchCollectionAdditionalData] = None