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

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 shapely.geometry import box, shape
+from requests import adapters
+from shapely.geometry import Point, 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,23 @@ 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"]
+        ]
+        if len(shapely_geometries) == 1 and isinstance(shapely_geometries[0], Point):
+            point = shapely_geometries[0]
+            buffer_size = 0.0001
+            buffered_geometry = point.buffer(buffer_size)
+            bounds = buffered_geometry.bounds
+        else:
+            geometry = unary_union(shapely_geometries)
+            bounds = geometry.bounds
+        epsg = 4326
     elif isinstance(spatial_extent, BoundingBoxExtent):
         bounds = [
             spatial_extent.west,
@@ -153,17 +231,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 +268,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 +278,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 +289,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 +322,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.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: openeo_gfmap
-Version: 0.1.0
+Version: 0.3.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
@@ -13,14 +13,15 @@ Requires-Dist: cftime
 Requires-Dist: fastparquet
 Requires-Dist: geojson>=3.0.0
 Requires-Dist: geopandas
-Requires-Dist: h3
+Requires-Dist: h3==4.1.0
 Requires-Dist: h5netcdf>=1.2.0
 Requires-Dist: netcdf4
 Requires-Dist: numpy<2.0.0
 Requires-Dist: onnxruntime
-Requires-Dist: openeo
+Requires-Dist: openeo<=0.35
 Requires-Dist: pyarrow
 Requires-Dist: rasterio
+Requires-Dist: s2sphere==0.2.*
 Requires-Dist: scipy
 Provides-Extra: dev
 Requires-Dist: matplotlib>=3.3.0; extra == 'dev'

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

@@ -4,37 +4,37 @@ 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=-MZJBfF_wV94FejoYbFPNviEQx3jLmJXb6XLeHg7egE,27221
+openeo_gfmap/manager/job_splitters.py,sha256=FU-1Wuwr1Xu8vEwuEZACPRrgBhgeLm2DLx6E6QSNkdg,10826
 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
 openeo_gfmap/preprocessing/interpolation.py,sha256=VVD483NoC0KYUSh28XaBNZzNaybQjdyCN8rXyXy2W9E,327
-openeo_gfmap/preprocessing/sar.py,sha256=mYERSzjNJa92GriSCGmDI4lQLxFxRPeMUU3Yebs6NI0,2238
+openeo_gfmap/preprocessing/sar.py,sha256=XtOIlBrX3o2DlrGHBksHYWzOdzhkZMQT2rp5LxDbdMQ,1391
 openeo_gfmap/preprocessing/scaling.py,sha256=oUNhykVC41Je3E_men_-PikAKNwYhYbwN9J1_Ru8Zi4,2121
 openeo_gfmap/preprocessing/udf_cldmask.py,sha256=WqqFLBK5rIQPkb_dlgUWWSzicsPtVSthaIef40FHKJA,1162
 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=sgiXbRfywY77HSdQnnJ9eKoadc4TKQVa-uuaRadgAOw,13642
 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.3.0.dist-info/METADATA,sha256=9khjPclTO13jDj2FFvOiaznGb60XCWYN8D-TdK1-mjE,4322
+openeo_gfmap-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+openeo_gfmap-0.3.0.dist-info/licenses/LICENSE,sha256=aUuGpjieWiscTNtyLcSaeVsJ4pb6J9c4wUq1bR0e4t4,11349
+openeo_gfmap-0.3.0.dist-info/RECORD,,

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

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

openeo_gfmap/fetching/meteo.py

@@ -1,126 +0,0 @@
-"""Meteo data fetchers."""
-
-from functools import partial
-
-import openeo
-from geojson import GeoJSON
-
-from openeo_gfmap import (
-    Backend,
-    BackendContext,
-    FetchType,
-    SpatialContext,
-    TemporalContext,
-)
-from openeo_gfmap.fetching import CollectionFetcher
-from openeo_gfmap.fetching.commons import convert_band_names
-from openeo_gfmap.fetching.generic import (
-    _get_generic_fetcher,
-    _get_generic_processor,
-    _load_collection,
-)
-
-WEATHER_MAPPING_TERRASCOPE = {
-    "dewpoint-temperature": "AGERA5-DEWTEMP",
-    "precipitation-flux": "AGERA5-PRECIP",
-    "solar-radiation-flux": "AGERA5-SOLRAD",
-    "temperature-max": "AGERA5-TMAX",
-    "temperature-mean": "AGERA5-TMEAN",
-    "temperature-min": "AGERA5-TMIN",
-    "vapour-pressure": "AGERA5-VAPOUR",
-    "wind-speed": "AGERA5-WIND",
-}
-
-WEATHER_MAPPING_STAC = {
-    "dewpoint_temperature_mean": "AGERA5-DEWTEMP",
-    "total_precipitation": "AGERA5-PRECIP",
-    "solar_radiataion_flux": "AGERA5-SOLRAD",
-    "2m_temperature_max": "AGERA5-TMAX",
-    "2m_temperature_mean": "AGERA5-TMEAN",
-    "2m_temperature_min": "AGERA5-TMIN",
-    "vapour_pressure": "AGERA5-VAPOUR",
-    "wind_speed": "AGERA5-WIND",
-}
-
-
-def stac_fetcher(
-    connection: openeo.Connection,
-    spatial_extent: SpatialContext,
-    temporal_extent: TemporalContext,
-    bands: list,
-    fetch_type: FetchType,
-    **params,
-) -> openeo.DataCube:
-    bands = convert_band_names(bands, WEATHER_MAPPING_STAC)
-
-    cube = _load_collection(
-        connection,
-        bands,
-        "https://stac.openeo.vito.be/collections/agera5_daily",
-        spatial_extent,
-        temporal_extent,
-        fetch_type,
-        is_stac=True,
-        **params,
-    )
-
-    if isinstance(spatial_extent, GeoJSON) and fetch_type == FetchType.POLYGON:
-        cube = cube.filter_spatial(spatial_extent)
-
-    return cube
-
-
-METEO_BACKEND_MAP = {
-    Backend.TERRASCOPE: {
-        "fetch": partial(
-            _get_generic_fetcher,
-            collection_name="AGERA5",
-            band_mapping=WEATHER_MAPPING_TERRASCOPE,
-        ),
-        "preprocessor": partial(
-            _get_generic_processor,
-            collection_name="AGERA5",
-            band_mapping=WEATHER_MAPPING_TERRASCOPE,
-        ),
-    },
-    Backend.CDSE: {
-        "fetch": stac_fetcher,
-        "preprocessor": partial(
-            _get_generic_processor,
-            collection_name="AGERA5",
-            band_mapping=WEATHER_MAPPING_STAC,
-        ),
-    },
-    Backend.CDSE_STAGING: {
-        "fetch": stac_fetcher,
-        "preprocessor": partial(
-            _get_generic_processor,
-            collection_name="AGERA5",
-            band_mapping=WEATHER_MAPPING_STAC,
-        ),
-    },
-    Backend.FED: {
-        "fetch": stac_fetcher,
-        "preprocessor": partial(
-            _get_generic_processor,
-            collection_name="AGERA5",
-            band_mapping=WEATHER_MAPPING_STAC,
-        ),
-    },
-}
-
-
-def build_meteo_extractor(
-    backend_context: BackendContext,
-    bands: list,
-    fetch_type: FetchType,
-    **params,
-) -> CollectionFetcher:
-    backend_functions = METEO_BACKEND_MAP.get(backend_context.backend)
-
-    fetcher, preprocessor = (
-        partial(backend_functions["fetch"], fetch_type=fetch_type),
-        backend_functions["preprocessor"](fetch_type=fetch_type),
-    )
-
-    return CollectionFetcher(backend_context, bands, fetcher, preprocessor, **params)