sentinelhub 3.11.0__py3-none-any.whl → 3.11.2__py3-none-any.whl

sentinelhub/api/batch/process_v2.py

@@ -1,325 +1,14 @@
 """
-Module implementing an interface with
-`Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__.
+Deprecated module for Batch Processing v2 API. The contents have been moved to `sentinelhub.api.batch.process`.
 """
 
-# 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 typing import Any, Dict, Iterator, Optional, Union
+import warnings
 
-from dataclasses_json import CatchAll, LetterCase, Undefined, dataclass_json
-from dataclasses_json import config as dataclass_config
-from typing_extensions import Literal
+from sentinelhub.api.batch.process import *  # noqa: F403 # pylint: disable=unused-wildcard-import, wildcard-import
+from sentinelhub.exceptions import SHDeprecationWarning
 
-from ...constants import RequestType
-from ...types import Json, JsonDict
-from ..base import SentinelHubFeatureIterator
-from ..process import SentinelHubRequest
-from ..utils import AccessSpecification, datetime_config, enum_config, remove_undefined, s3_specification
-from .base import BaseBatchClient, BaseBatchRequest, BatchRequestStatus, BatchUserAction, StoppedStatusReason
-
-LOGGER = logging.getLogger(__name__)
-
-BatchRequestType = Union[str, dict, "BatchProcessRequest"]
-
-
-class BatchProcessClient(BaseBatchClient):
-    """An interface class for Sentinel Hub Batch API version 2.
-
-    `Batch Process API <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-    """
-
-    s3_specification = staticmethod(s3_specification)
-
-    # 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/v2/batch"
-
-    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 create(
-        self,
-        process_request: Union[SentinelHubRequest, JsonDict],
-        input: Dict[str, Any],  # noqa: A002  #pylint: disable=redefined-builtin
-        output: Dict[str, Any],
-        instance_type: Literal["normal", "large"] = "normal",
-        description: Optional[str] = None,
-        **kwargs: Any,
-    ) -> "BatchProcessRequest":
-        """Create a new batch request
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :param process_request: An instance of SentinelHubRequest class containing all request parameters.
-            Alternatively, it can also be just a payload dictionary for Process API request
-        :param input: A dictionary with input parameters. It can be built with `tiling_grid_input` or `geopackage_input`
-            methods.
-        :param output: A dictionary with output parameters. It can be built with `raster_output` or `zarr_output`
-            methods.
-        :param instance_type": Specifies which size of instances to use for the request.
-        :param description: A description of a batch request
-        :param kwargs: Any other arguments to be added to a dictionary of parameters.
-        """
-
-        if isinstance(process_request, SentinelHubRequest):
-            request_dict = process_request.download_list[0].post_values
-        else:
-            request_dict = process_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 = remove_undefined(
-            {
-                "processRequest": request_dict,
-                "input": input,
-                "output": output,
-                "instance_type": instance_type,
-                "description": description,
-                **kwargs,
-            }
-        )
-
-        request_info = self.client.get_json_dict(self._get_processing_url(), post_values=payload, use_session=True)
-
-        return BatchProcessRequest.from_dict(request_info)
-
-    @staticmethod
-    def geopackage_input(geopackage_specification: AccessSpecification) -> JsonDict:
-        """A helper method to build a suitable dictionary for the `input` field.
-
-        :param geopackage_specification: A specification of the S3 path for the Geopackage. Can be built using the
-            `s3_specification` helper method.
-        """
-        return {"type": "geopackage", "features": geopackage_specification}
-
-    @staticmethod
-    def tiling_grid_input(
-        grid_id: int, resolution: float, buffer_x: Optional[int] = None, buffer_y: Optional[int] = None, **kwargs: Any
-    ) -> JsonDict:
-        """A helper method to build a dictionary with tiling grid parameters for the `input` field.
-
-        :param grid_id: An ID of a tiling grid
-        :param resolution: A grid resolution
-        :param buffer_x: Will expand each output tile horizontally (left and right) by specified number of pixels.
-        :param buffer_y: Will expand each output tile vertically (up and down) by specified number of pixels.
-        :param kwargs: Any other arguments to be added to a dictionary of parameters
-        """
-        return remove_undefined(
-            {
-                "type": "tiling-grid",
-                "id": grid_id,
-                "resolution": resolution,
-                "bufferX": buffer_x,
-                "bufferY": buffer_y,
-                **kwargs,
-            }
-        )
-
-    @staticmethod
-    def raster_output(
-        delivery: AccessSpecification,
-        *,
-        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,
-        **kwargs: Any,
-    ) -> Dict[str, Any]:
-        """A helper method to build a dictionary specifying raster output
-
-        :param delivery: An S3 access specification containing a path or a template on an s3 bucket where to store
-            results. You can use the `s3_specification` method for construction. For more information on templates see
-            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. See documentation for more info.
-        :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 kwargs: Any other arguments to be added to a dictionary of parameters
-        """
-        return remove_undefined(
-            {
-                "type": "raster",
-                "delivery": delivery,
-                "overwrite": overwrite,
-                "skipExisting": skip_existing,
-                "cogOutput": cog_output,
-                "cogParameters": cog_parameters,
-                "createCollection": create_collection,
-                "collectionId": collection_id,
-                **kwargs,
-            }
-        )
-
-    @staticmethod
-    def zarr_output(
-        delivery: AccessSpecification,
-        *,
-        group: Optional[Dict[str, Any]] = None,
-        array_parameters: Optional[Dict[str, Any]] = None,
-        array_overrides: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> JsonDict:
-        """A helper method to build a dictionary specifying Zarr output. See documentation for more information on
-        each parameter.
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :param delivery: An S3 access specification containing a path or a template on an s3 bucket where to store
-            results. You can use the `s3_specification` method for construction. For more information on templates see
-            documentation.
-        :param group: Zarr group level parameters
-        :param array_parameters: Parameters that will be used for all output arrays, except where overriden with
-            `array_overrides`. Required unless `array_overrides` includes all required fields for all output arrays.
-        :param array_overrides: Overrides the values of `array_arameters` for individual arrays.
-        :param kwargs: Any other arguments to be added to a dictionary of parameters
-        """
-        return remove_undefined(
-            {
-                "type": "zarr",
-                "delivery": delivery,
-                "group": group,
-                "arrayParameter": array_parameters,
-                "arrayOverrides": array_overrides,
-                **kwargs,
-            }
-        )
-
-    def iter_requests(
-        self, user_id: Optional[str] = None, search: Optional[str] = None, sort: Optional[str] = None, **kwargs: Any
-    ) -> Iterator["BatchProcessRequest"]:
-        """Iterate existing batch requests
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :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 BatchProcessRequest.from_dict(request_info)
-
-    def get_request(self, batch_request: BatchRequestType) -> "BatchProcessRequest":
-        """Collects information about a single batch request.
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-        """
-        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 BatchProcessRequest.from_dict(request_info)
-
-    def update_request(self, batch_request: BatchRequestType, description: str) -> Json:
-        """Update certain batch job request parameters. Can only update requests that are not currently being processed.
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :param batch_request: Batch request ID, a dictionary containing an "ID" field, or a BatchProcessRequest.
-        :param description: A description of a batch request to be updated.
-        """
-        request_id = self._parse_request_id(batch_request)
-
-        return self.client.get_json(
-            url=self._get_processing_url(request_id),
-            post_values={"description": description},
-            request_type=RequestType.PUT,
-            use_session=True,
-        )
-
-    def start_analysis(self, batch_request: BatchRequestType) -> Json:
-        """Starts analysis of a batch job request
-
-        :param batch_request: Batch request ID, a dictionary containing an "ID" field, or a BatchProcessRequest.
-        """
-        return self._call_job(batch_request, "analyse")
-
-    def start_job(self, batch_request: BatchRequestType) -> Json:
-        """Starts running a batch job
-
-        :param batch_request: Batch request ID, a dictionary containing an "ID" field, or a BatchProcessRequest.
-        """
-        return self._call_job(batch_request, "start")
-
-    def stop_job(self, batch_request: BatchRequestType) -> Json:
-        """Stops a batch job
-
-        :param batch_request: Batch request ID, a dictionary containing an "ID" field, or a BatchProcessRequest.
-        """
-        return self._call_job(batch_request, "stop")
-
-    def iter_tiling_grids(self, **kwargs: Any) -> SentinelHubFeatureIterator:
-        """An iterator over tiling grids
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :param kwargs: Any other request query parameters
-        :return: An iterator over tiling grid definitions
-        """
-        return SentinelHubFeatureIterator(
-            client=self.client,
-            url=f"{self.service_url}/tilinggrids",
-            params=remove_undefined(kwargs),
-            exception_message="Failed to obtain information about available tiling grids",
-        )
-
-    def get_tiling_grid(self, grid_id: int) -> JsonDict:
-        """Provides a single tiling grid
-
-        `Batch Process V2 <https://docs.sentinel-hub.com/api/latest/api/batchv2/>`__
-
-        :param grid_id: An ID of a requested tiling grid
-        :return: A tiling grid definition
-        """
-        url = f"{self.service_url}/tilinggrids/{grid_id}"
-        return self.client.get_json_dict(url=url, use_session=True)
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
-@dataclass(repr=False)
-class BatchProcessRequest(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=invalid-name
-
-    request_id: str = field(metadata=dataclass_config(field_name="id"))
-    request: dict
-    domain_account_id: str
-    status: BatchRequestStatus = field(metadata=enum_config(BatchRequestStatus))
-    error: Optional[str] = None
-    user_action: Optional[BatchUserAction] = field(metadata=enum_config(BatchUserAction), default=None)
-    user_action_updated: Optional[dt.datetime] = field(metadata=datetime_config, default=None)
-    created: Optional[dt.datetime] = field(metadata=datetime_config, default=None)
-    completion_percentage: float = 0
-    last_updated: Optional[dt.datetime] = field(metadata=datetime_config, default=None)
-    cost_PU: Optional[float] = field(metadata=dataclass_config(field_name="costPU"), default=None)  # noqa: N815
-    stopped_status_reason: Optional[StoppedStatusReason] = field(
-        metadata=enum_config(StoppedStatusReason), default=None
-    )
-
-    other_data: CatchAll = field(default_factory=dict)
-
-    _REPR_PARAM_NAMES = ("request_id", "created", "status", "completion_percentage", "user_action", "cost_PU")
+warnings.warn(
+    "The module sentinelhub.api.batch.process_v2 has been renamed, please use sentinelhub.api.batch.process instead.",
+    SHDeprecationWarning,
+    stacklevel=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/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/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.0.dist-info → sentinelhub-3.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sentinelhub
-Version: 3.11.0
+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
@@ -50,7 +50,7 @@ Requires-Python: >=3.8
 Requires-Dist: aenum>=2.1.4
 Requires-Dist: click
 Requires-Dist: dataclasses-json
-Requires-Dist: numpy<2
+Requires-Dist: numpy
 Requires-Dist: oauthlib
 Requires-Dist: pillow>=9.2.0
 Requires-Dist: pyproj>=2.2.0
@@ -68,7 +68,6 @@ Provides-Extra: aws
 Requires-Dist: boto3; extra == 'aws'
 Requires-Dist: botocore; extra == 'aws'
 Provides-Extra: dev
-Requires-Dist: basemap; extra == 'dev'
 Requires-Dist: boto3-stubs>=1.20.0; extra == 'dev'
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: click>=8.0.0; extra == 'dev'
@@ -160,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