openeo-gfmap 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

openeo_gfmap/utils/__init__.py

@@ -1,8 +1,11 @@
 """This sub-module contains utilitary function and tools for OpenEO-GFMap"""
 
+import logging
+
 from openeo_gfmap.utils.build_df import load_json
 from openeo_gfmap.utils.intervals import quintad_intervals
 from openeo_gfmap.utils.netcdf import update_nc_attributes
+from openeo_gfmap.utils.split_stac import split_collection_by_epsg
 from openeo_gfmap.utils.tile_processing import (
     array_bounds,
     arrays_cosine_similarity,
@@ -11,6 +14,18 @@ from openeo_gfmap.utils.tile_processing import (
     select_sar_bands,
 )
 
+_log = logging.getLogger(__name__)
+_log.setLevel(logging.INFO)
+
+ch = logging.StreamHandler()
+ch.setLevel(logging.INFO)
+
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+ch.setFormatter(formatter)
+
+_log.addHandler(ch)
+
+
 __all__ = [
     "load_json",
     "normalize_array",
@@ -19,5 +34,6 @@ __all__ = [
     "select_sar_bands",
     "arrays_cosine_similarity",
     "quintad_intervals",
+    "split_collection_by_epsg",
     "update_nc_attributes",
 ]

openeo_gfmap/utils/catalogue.py

@@ -1,11 +1,15 @@
 """Functionalities to interract with product catalogues."""
 
+from typing import Optional
+
+import geojson
+import pandas as pd
 import requests
-from geojson import GeoJSON
 from pyproj.crs import CRS
 from rasterio.warp import transform_bounds
-from shapely import unary_union
+from requests import adapters
 from shapely.geometry import box, shape
+from shapely.ops import unary_union
 
 from openeo_gfmap import (
     Backend,
@@ -14,6 +18,21 @@ from openeo_gfmap import (
     SpatialContext,
     TemporalContext,
 )
+from openeo_gfmap.utils import _log
+
+request_sessions: Optional[requests.Session] = None
+
+
+def _request_session() -> requests.Session:
+    global request_sessions
+
+    if request_sessions is None:
+        request_sessions = requests.Session()
+        retries = adapters.Retry(
+            total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504]
+        )
+        request_sessions.mount("https://", adapters.HTTPAdapter(max_retries=retries))
+    return request_sessions
 
 
 class UncoveredS1Exception(Exception):
@@ -24,13 +43,21 @@ class UncoveredS1Exception(Exception):
 
 
 def _parse_cdse_products(response: dict):
-    """Parses the geometry of products from the CDSE catalogue."""
-    geoemetries = []
+    """Parses the geometry and timestamps of products from the CDSE catalogue."""
+    geometries = []
+    timestamps = []
     products = response["features"]
 
     for product in products:
-        geoemetries.append(shape(product["geometry"]))
-    return geoemetries
+        if "geometry" in product and "startDate" in product["properties"]:
+            geometries.append(shape(product["geometry"]))
+            timestamps.append(pd.to_datetime(product["properties"]["startDate"]))
+        else:
+            _log.warning(
+                "Cannot parse product %s does not have a geometry or timestamp.",
+                product["properties"]["id"],
+            )
+    return geometries, timestamps
 
 
 def _query_cdse_catalogue(
@@ -39,6 +66,14 @@ def _query_cdse_catalogue(
     temporal_extent: TemporalContext,
     **additional_parameters: dict,
 ) -> dict:
+    """
+    Queries the CDSE catalogue for a given collection, spatio-temporal context and additional
+    parameters.
+
+    Params
+    ------
+
+    """
     minx, miny, maxx, maxy = bounds
 
     # The date format should be YYYY-MM-DD
@@ -48,13 +83,14 @@ def _query_cdse_catalogue(
     url = (
         f"https://catalogue.dataspace.copernicus.eu/resto/api/collections/"
         f"{collection}/search.json?box={minx},{miny},{maxx},{maxy}"
-        f"&sortParam=startDate&maxRecords=100"
-        f"&dataset=ESA-DATASET&startDate={start_date}&completionDate={end_date}"
+        f"&sortParam=startDate&maxRecords=1000&dataset=ESA-DATASET"
+        f"&startDate={start_date}&completionDate={end_date}"
     )
     for key, value in additional_parameters.items():
         url += f"&{key}={value}"
 
-    response = requests.get(url)
+    session = _request_session()
+    response = session.get(url, timeout=60)
 
     if response.status_code != 200:
         raise Exception(
@@ -107,19 +143,51 @@ def _check_cdse_catalogue(
     return len(grd_tiles) > 0
 
 
-def s1_area_per_orbitstate(
+def _compute_max_gap_days(
+    temporal_extent: TemporalContext, timestamps: list[pd.DatetimeIndex]
+) -> int:
+    """Computes the maximum temporal gap in days from the timestamps parsed from the catalogue.
+    Requires the start and end date to be included in the timestamps to compute the gap before
+    and after the first and last observation.
+
+    Parameters
+    ----------
+    temporal_extent : TemporalContext
+        The temporal extent to be checked. Same as used to query the catalogue.
+    timestamps : list[pd.DatetimeIndex]
+        The list of timestamps parsed from the catalogue and to compute the gap from.
+
+    Returns
+    -------
+    days : int
+        The maximum temporal gap in days.
+    """
+    # Computes max temporal gap. Include requested start and end date so we dont miss
+    # any start or end gap before first/last observation
+    timestamps = pd.DatetimeIndex(
+        sorted(
+            [pd.to_datetime(temporal_extent.start_date, utc=True)]
+            + timestamps
+            + [pd.to_datetime(temporal_extent.end_date, utc=True)]
+        )
+    )
+    return timestamps.to_series().diff().max().days
+
+
+def s1_area_per_orbitstate_vvvh(
     backend: BackendContext,
     spatial_extent: SpatialContext,
     temporal_extent: TemporalContext,
 ) -> dict:
-    """Evaluates for both the ascending and descending state orbits the area of interesection
-    between the given spatio-temporal context and the products available in the backend's
-    catalogue.
+    """
+    Evaluates for both the ascending and descending state orbits the area of interesection and
+    maximum temporal gap for the available products with a VV&VH polarisation.
 
     Parameters
     ----------
     backend : BackendContext
-        The backend to be within, as each backend might use different catalogues.
+        The backend to be within, as each backend might use different catalogues. Only the CDSE,
+        CDSE_STAGING and FED backends are supported.
     spatial_extent : SpatialContext
         The spatial extent to be checked, it will check within its bounding box.
     temporal_extent : TemporalContext
@@ -128,13 +196,17 @@ def s1_area_per_orbitstate(
     Returns
     ------
     dict
-        Keys containing the orbit state and values containing the total area of intersection in
-        km^2
+        Keys containing the orbit state and values containing the total area of intersection and
+        in km^2 and maximum temporal gap in days.
     """
-    if isinstance(spatial_extent, GeoJSON):
+    if isinstance(spatial_extent, geojson.FeatureCollection):
         # Transform geojson into shapely geometry and compute bounds
-        bounds = shape(spatial_extent).bounds
-        epsg = 4362
+        shapely_geometries = [
+            shape(feature["geometry"]) for feature in spatial_extent["features"]
+        ]
+        geometry = unary_union(shapely_geometries)
+        bounds = geometry.bounds
+        epsg = 4326
     elif isinstance(spatial_extent, BoundingBoxExtent):
         bounds = [
             spatial_extent.west,
@@ -153,17 +225,22 @@ def s1_area_per_orbitstate(
 
     # Queries the products in the catalogues
     if backend.backend in [Backend.CDSE, Backend.CDSE_STAGING, Backend.FED]:
-        ascending_products = _parse_cdse_products(
+        ascending_products, ascending_timestamps = _parse_cdse_products(
             _query_cdse_catalogue(
-                "Sentinel1", bounds, temporal_extent, orbitDirection="ASCENDING"
+                "Sentinel1",
+                bounds,
+                temporal_extent,
+                orbitDirection="ASCENDING",
+                polarisation="VV%26VH",
             )
         )
-        descending_products = _parse_cdse_products(
+        descending_products, descending_timestamps = _parse_cdse_products(
             _query_cdse_catalogue(
                 "Sentinel1",
                 bounds,
                 temporal_extent,
                 orbitDirection="DESCENDING",
+                polarisation="VV%26VH",
             )
         )
     else:
@@ -185,6 +262,9 @@ def s1_area_per_orbitstate(
     return {
         "ASCENDING": {
             "full_overlap": ascending_covers,
+            "max_temporal_gap": _compute_max_gap_days(
+                temporal_extent, ascending_timestamps
+            ),
             "area": sum(
                 product.intersection(spatial_extent).area
                 for product in ascending_products
@@ -192,6 +272,9 @@ def s1_area_per_orbitstate(
         },
         "DESCENDING": {
             "full_overlap": descending_covers,
+            "max_temporal_gap": _compute_max_gap_days(
+                temporal_extent, descending_timestamps
+            ),
             "area": sum(
                 product.intersection(spatial_extent).area
                 for product in descending_products
@@ -200,22 +283,31 @@ def s1_area_per_orbitstate(
     }
 
 
-def select_S1_orbitstate(
+def select_s1_orbitstate_vvvh(
     backend: BackendContext,
     spatial_extent: SpatialContext,
     temporal_extent: TemporalContext,
+    max_temporal_gap: int = 60,
 ) -> str:
-    """Selects the orbit state that covers the most area of the given spatio-temporal context
-    for the Sentinel-1 collection.
+    """Selects the orbit state based on some predefined rules that
+    are checked in sequential order:
+    1. prefer an orbit with full coverage over the requested bounds
+    2. prefer an orbit with a maximum temporal gap under a
+        predefined threshold
+    3. prefer the orbit that covers the most area of intersection
+        for the available products
 
     Parameters
     ----------
     backend : BackendContext
-        The backend to be within, as each backend might use different catalogues.
+        The backend to be within, as each backend might use different catalogues. Only the CDSE,
+        CDSE_STAGING and FED backends are supported.
     spatial_extent : SpatialContext
         The spatial extent to be checked, it will check within its bounding box.
     temporal_extent : TemporalContext
         The temporal period to be checked.
+    max_temporal_gap: int, optional, default: 30
+        The maximum temporal gap in days to be considered for the orbit state.
 
     Returns
     ------
@@ -224,25 +316,64 @@ def select_S1_orbitstate(
     """
 
     # Queries the products in the catalogues
-    areas = s1_area_per_orbitstate(backend, spatial_extent, temporal_extent)
+    areas = s1_area_per_orbitstate_vvvh(backend, spatial_extent, temporal_extent)
 
     ascending_overlap = areas["ASCENDING"]["full_overlap"]
     descending_overlap = areas["DESCENDING"]["full_overlap"]
+    ascending_gap_too_large = areas["ASCENDING"]["max_temporal_gap"] > max_temporal_gap
+    descending_gap_too_large = (
+        areas["DESCENDING"]["max_temporal_gap"] > max_temporal_gap
+    )
+
+    orbit_choice = None
+
+    if not ascending_overlap and not descending_overlap:
+        raise UncoveredS1Exception(
+            "No product available to fully cover the requested area in both orbit states."
+        )
 
+    # Rule 1: Prefer an orbit with full coverage over the requested bounds
     if ascending_overlap and not descending_overlap:
-        return "ASCENDING"
+        orbit_choice = "ASCENDING"
+        reason = "Only orbit fully covering the requested area."
     elif descending_overlap and not ascending_overlap:
-        return "DESCENDING"
+        orbit_choice = "DESCENDING"
+        reason = "Only orbit fully covering the requested area."
+
+    # Rule 2: Prefer an orbit with a maximum temporal gap under a predefined threshold
+    elif ascending_gap_too_large and not descending_gap_too_large:
+        orbit_choice = "DESCENDING"
+        reason = (
+            "Only orbit with temporal gap under the threshold. "
+            f"{areas['DESCENDING']['max_temporal_gap']} days < {max_temporal_gap} days"
+        )
+    elif descending_gap_too_large and not ascending_gap_too_large:
+        orbit_choice = "ASCENDING"
+        reason = (
+            "Only orbit with temporal gap under the threshold. "
+            f"{areas['ASCENDING']['max_temporal_gap']} days < {max_temporal_gap} days"
+        )
+    # Rule 3: Prefer the orbit that covers the most area of intersection
+    # for the available products
     elif ascending_overlap and descending_overlap:
         ascending_cover_area = areas["ASCENDING"]["area"]
         descending_cover_area = areas["DESCENDING"]["area"]
 
         # Selects the orbit state that covers the most area
         if ascending_cover_area > descending_cover_area:
-            return "ASCENDING"
+            orbit_choice = "ASCENDING"
+            reason = (
+                "Orbit has more cumulative intersected area. "
+                f"{ascending_cover_area} > {descending_cover_area}"
+            )
         else:
-            return "DESCENDING"
+            reason = (
+                "Orbit has more cumulative intersected area. "
+                f"{descending_cover_area} > {ascending_cover_area}"
+            )
+            orbit_choice = "DESCENDING"
 
-    raise UncoveredS1Exception(
-        "No product available to fully cover the given spatio-temporal context."
-    )
+    if orbit_choice is not None:
+        _log.info(f"Selected orbit state: {orbit_choice}. Reason: {reason}")
+        return orbit_choice
+    raise UncoveredS1Exception("Failed to select suitable Sentinel-1 orbit.")

openeo_gfmap/utils/split_stac.py

@@ -0,0 +1,125 @@
+"""Utility function to split a STAC collection into multiple STAC collections based on CRS.
+Requires the "proj:epsg" property to be present in all the STAC items.
+"""
+
+import os
+from pathlib import Path
+from typing import Iterator, Union
+
+import pystac
+
+
+def _extract_epsg_from_stac_item(stac_item: pystac.Item) -> int:
+    """
+    Extract the EPSG code from a STAC item.
+
+    Parameters:
+    stac_item (pystac.Item): The STAC item.
+
+    Returns:
+    int: The EPSG code.
+
+    Raises:
+    KeyError: If the "proj:epsg" property is missing from the STAC item.
+    """
+
+    try:
+        epsg_code = stac_item.properties["proj:epsg"]
+        return epsg_code
+    except KeyError:
+        raise KeyError("The 'proj:epsg' property is missing from the STAC item.")
+
+
+def _get_items_by_epsg(
+    collection: pystac.Collection,
+) -> Iterator[tuple[int, pystac.Item]]:
+    """
+    Generator function that yields items grouped by their EPSG code.
+
+    Parameters:
+    collection (pystac.Collection): The STAC collection.
+
+    Yields:
+    tuple[int, pystac.Item]: EPSG code and corresponding STAC item.
+    """
+    for item in collection.get_all_items():
+        epsg = _extract_epsg_from_stac_item(item)
+        yield epsg, item
+
+
+def _create_collection_skeleton(
+    collection: pystac.Collection, epsg: int
+) -> pystac.Collection:
+    """
+    Create a skeleton for a new STAC collection with a given EPSG code.
+
+    Parameters:
+    collection (pystac.Collection): The original STAC collection.
+    epsg (int): The EPSG code.
+
+    Returns:
+    pystac.Collection: The skeleton of the new STAC collection.
+    """
+    new_collection = pystac.Collection(
+        id=f"{collection.id}_{epsg}",
+        description=f"{collection.description} Containing only items with EPSG code {epsg}",
+        extent=collection.extent.clone(),
+        summaries=collection.summaries,
+        license=collection.license,
+        stac_extensions=collection.stac_extensions,
+    )
+    if "item_assets" in collection.extra_fields:
+        item_assets_extension = pystac.extensions.item_assets.ItemAssetsExtension.ext(
+            collection
+        )
+
+        new_item_assets_extension = (
+            pystac.extensions.item_assets.ItemAssetsExtension.ext(
+                new_collection, add_if_missing=True
+            )
+        )
+
+        new_item_assets_extension.item_assets = item_assets_extension.item_assets
+    return new_collection
+
+
+def split_collection_by_epsg(
+    collection: Union[str, Path, pystac.Collection], output_dir: Union[str, Path]
+):
+    """
+    Split a STAC collection into multiple STAC collections based on EPSG code.
+
+    Parameters
+    ----------
+    collection: Union[str, Path, pystac.Collection]
+        A collection of STAC items or a path to a STAC collection.
+    output_dir: Union[str, Path]
+        The directory where the split STAC collections will be saved.
+    """
+
+    if not isinstance(collection, pystac.Collection):
+        collection = Path(collection)
+        output_dir = Path(output_dir)
+        os.makedirs(output_dir, exist_ok=True)
+
+        try:
+            collection = pystac.read_file(collection)
+        except pystac.STACError:
+            print("Please provide a path to a valid STAC collection.")
+            return
+
+    collections_by_epsg = {}
+
+    for epsg, item in _get_items_by_epsg(collection):
+        if epsg not in collections_by_epsg:
+            collections_by_epsg[epsg] = _create_collection_skeleton(collection, epsg)
+
+        # Add item to the corresponding collection
+        collections_by_epsg[epsg].add_item(item)
+
+    # Write each collection to disk
+    for epsg, new_collection in collections_by_epsg.items():
+        new_collection.update_extent_from_items()  # Update extent based on added items
+        collection_path = output_dir / f"collection-{epsg}"
+        new_collection.normalize_hrefs(str(collection_path))
+        new_collection.save()

{openeo_gfmap-0.1.0.dist-info → openeo_gfmap-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openeo_gfmap
-Version: 0.1.0
+Version: 0.2.0
 Summary: OpenEO General Framework for Mapping
 Project-URL: Homepage, https://github.com/Open-EO/openeo-gfmap
 Project-URL: Bug Tracker, https://github.com/Open-EO/openeo-gfmap/issues

{openeo_gfmap-0.1.0.dist-info → openeo_gfmap-0.2.0.dist-info}/RECORD

@@ -4,19 +4,18 @@ openeo_gfmap/metadata.py,sha256=WlJ3zy78ff1E65HDbw7kOuYamqyvfV0BCNrv_ZvXX4Y,762
 openeo_gfmap/spatial.py,sha256=y1Gk9yM1j2eod127Pthn7SKxY37EFbzvPX0znqHgnMw,1353
 openeo_gfmap/temporal.py,sha256=qhKCgSoOc0CrscPTru-d7acaxsCVhftyYrb_8UVU1S4,583
 openeo_gfmap/features/__init__.py,sha256=UtQUPnglF9uURn9FqtegnazuE4_CgQP6a2Cdx1TOuZ0,419
-openeo_gfmap/features/feature_extractor.py,sha256=kMXIkb7OqEBDdZGhTZp0gFDtq9Ip_IVwszCoE6HOqWY,14491
-openeo_gfmap/fetching/__init__.py,sha256=vuG5qdBEY6TytLjH2NWjyg_2ivHBEX9zvXOwD-MrxzQ,521
-openeo_gfmap/fetching/commons.py,sha256=6LBQry1V18jSivhd7pO5XHLzeb0msC85frHThvVnH0E,7636
+openeo_gfmap/features/feature_extractor.py,sha256=ApTCCbD1-S4VOOSEZh9i-Gqxso87xwe_z7CN35fP15A,14719
+openeo_gfmap/fetching/__init__.py,sha256=KFDwqKTwXUDhFqPqeaIg5uCL2xp7lXmNzcbAph-EU1c,938
+openeo_gfmap/fetching/commons.py,sha256=7kr34Lq3ZxKWQXJrtAHFJYkc93y6LHGfTe1jn7Adr64,7656
 openeo_gfmap/fetching/fetching.py,sha256=dHeOMzN6OPgD8YFfZtcCzEOwQqo47IeBgIdS2mrx3MY,3674
-openeo_gfmap/fetching/generic.py,sha256=QekJd2-BaEn_ObEaKEwpYTP7jkH5Enax7c7CgdpcRnY,5461
-openeo_gfmap/fetching/meteo.py,sha256=QVuyjPjzUzJyiYL3sxwSGA8bTgaSGI3ITkKkcW9WdzQ,3386
-openeo_gfmap/fetching/s1.py,sha256=bewQOzP5ClDhVzaKINAY3-IKPiBW7TCuVtUs_BRgSvA,6452
-openeo_gfmap/fetching/s2.py,sha256=Ulmjn57pCA2GyKV-OHnbTaLenMUK3_QpY06fDw3STaU,7699
+openeo_gfmap/fetching/generic.py,sha256=ojSO52cnLsWpC6FAnLRoXxfQmTiC839DzFH8MAok2B8,5851
+openeo_gfmap/fetching/s1.py,sha256=Ek9Ek-GExyKdb-9Ijja6I-izOmVvPY2C9w9gyyGGjII,6360
+openeo_gfmap/fetching/s2.py,sha256=ytjrZiZIwXxrdiky2V0bAKLBU9Dpaa5b2XsHvI6jl1M,7718
 openeo_gfmap/inference/__init__.py,sha256=M6NnKGYCpHNYmRL9OkHi5GmfCtWoJ0wCNR6VXRuDgjE,165
-openeo_gfmap/inference/model_inference.py,sha256=-Pf0PHfcO8Y0ok9lsx4Vp2qee19RhrkzHVLVVKTRkVE,12478
+openeo_gfmap/inference/model_inference.py,sha256=0qPUgrjI1hy5ZnyGwuuvvw5oxnMGdgvvu9Go6-e9LZQ,12550
 openeo_gfmap/manager/__init__.py,sha256=2bckkPiDQBgoBWD9spk1BKXy2UGkWKe50A3HmIwmqrA,795
-openeo_gfmap/manager/job_manager.py,sha256=PIsSBDNURwrunVTjqsxfKEFxi0xlBflQH8sC0j29Zoc,20056
-openeo_gfmap/manager/job_splitters.py,sha256=zV0Tr3aEa4WORJgY8Z-rRHqsosj-1pWpPsyBSUnuNwo,5123
+openeo_gfmap/manager/job_manager.py,sha256=7NwpU6kvrtqtvhtDjymbR4AKySp8E2KyCfBJFqrd2Ns,27165
+openeo_gfmap/manager/job_splitters.py,sha256=PD4DsZr34MEMMVMHMUiKyFvdgKYyQpL-Lohpak8g_vU,5947
 openeo_gfmap/preprocessing/__init__.py,sha256=-kJAy_WY4o8oqziRozcUuXtuGIM0IOvTCF6agTUgRWA,619
 openeo_gfmap/preprocessing/cloudmasking.py,sha256=d280H5fByjNbCVZHjPn_dUatNI-ejphu4A75sUVoRqo,10029
 openeo_gfmap/preprocessing/compositing.py,sha256=Jp9Ku5JpU7TJ4DYGc6YuqMeP1Ip7zns7NguC17BtFyA,2526
@@ -27,14 +26,15 @@ openeo_gfmap/preprocessing/udf_cldmask.py,sha256=WqqFLBK5rIQPkb_dlgUWWSzicsPtVSt
 openeo_gfmap/preprocessing/udf_rank.py,sha256=n2gSIY2ZHVVr9wJx1Bs2HtmvScAkz2NqhjxUM-iIKM0,1438
 openeo_gfmap/preprocessing/udf_score.py,sha256=L1d5do1lIRJFLWqbuSbXPdwR-hPoSZqVE8ffVtG5kI0,3330
 openeo_gfmap/stac/__init__.py,sha256=kVMJ9hrN4MjcRCOgRDCj5TfAWRXe0GHu2gJQjG-dS4Y,59
-openeo_gfmap/stac/constants.py,sha256=Oelktfzq3sE1leMI6_EC_Dt8yMvPA_8I2AeJSKqGxII,1485
-openeo_gfmap/utils/__init__.py,sha256=5UUoVq6PaNXar_1J82u-_6KInfuY7uNU4_u2E_Cj_HA,626
+openeo_gfmap/stac/constants.py,sha256=O1bcijRBj6YRqR_aAcYO5JzJg7mdzhzUSm4vKnxMbtQ,1485
+openeo_gfmap/utils/__init__.py,sha256=UDwkWUwsnV6ZLXeaJKOCos-MDG2ZaIFyg8s0IiRVtng,997
 openeo_gfmap/utils/build_df.py,sha256=OPmD_Onkl9ybYIiLxmU_GmanP8xD71F1ZybJc7xQmns,1515
-openeo_gfmap/utils/catalogue.py,sha256=-QjoxFZ9RIigPjXOEE-LQcLW88aoTxfI3oC0SYR3n68,8073
+openeo_gfmap/utils/catalogue.py,sha256=-dG07sJ6mXOk2RguiOPcrWdCo5z8BhNmXN0ae7j3kr0,13348
 openeo_gfmap/utils/intervals.py,sha256=V6l3ofww50fN_pvWC4NuGQ2ZsyGdhAlTZTiRcC0foVE,2395
 openeo_gfmap/utils/netcdf.py,sha256=KkAAxnq-ZCMjDMd82638noYwxqNpMsnpiU04Q-qX26A,698
+openeo_gfmap/utils/split_stac.py,sha256=asjT0jx6ic8GJFqqAisaWxOvQ_suSRv4sxyFOyHFvpI,3895
 openeo_gfmap/utils/tile_processing.py,sha256=QZ9bi5tPmyTVyyNvFZgd26s5dSnMl1grTKq2veK1C90,2068
-openeo_gfmap-0.1.0.dist-info/METADATA,sha256=BAThgJ7FwpCz2QLFWYkFiPkbg9UPrUDRGgAXjkq1iPc,4278
-openeo_gfmap-0.1.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-openeo_gfmap-0.1.0.dist-info/licenses/LICENSE,sha256=aUuGpjieWiscTNtyLcSaeVsJ4pb6J9c4wUq1bR0e4t4,11349
-openeo_gfmap-0.1.0.dist-info/RECORD,,
+openeo_gfmap-0.2.0.dist-info/METADATA,sha256=aSf8KibRnGJl6B8lRH1nT1RYWpR9TnMaKHy6Y3qIE-s,4278
+openeo_gfmap-0.2.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+openeo_gfmap-0.2.0.dist-info/licenses/LICENSE,sha256=aUuGpjieWiscTNtyLcSaeVsJ4pb6J9c4wUq1bR0e4t4,11349
+openeo_gfmap-0.2.0.dist-info/RECORD,,

{openeo_gfmap-0.1.0.dist-info → openeo_gfmap-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any