Issue #459 VectorCube: basic support for filter_bands, filter_bbox, filter_labels and filter_vector

Author: soxofaan

CHANGELOG.md

@@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial `load_geojson` support with `Connection.load_geojson()` ([#424](https://github.com/Open-EO/openeo-python-client/issues/424))
 - Initial `load_url` (for vector cubes) support with `Connection.load_url()` ([#424](https://github.com/Open-EO/openeo-python-client/issues/424))
 - Support lambda based property filtering in `Connection.load_stac()` ([#425](https://github.com/Open-EO/openeo-python-client/issues/425))
-
+- `VectorCube`: initial support for `filter_bands`, `filter_bbox`, `filter_labels` and `filter_vector` ([#459](https://github.com/Open-EO/openeo-python-client/issues/459))
 
 ### Changed
 

openeo/rest/_testing.py

@@ -1,6 +1,8 @@
 import re
+from typing import Union, Optional
 
-from openeo import Connection
+from openeo import Connection, DataCube
+from openeo.rest.vectorcube import VectorCube
 
 
 class DummyBackend:
@@ -91,8 +93,33 @@ def get_batch_pg(self) -> dict:
         assert len(self.batch_jobs) == 1
         return self.batch_jobs[max(self.batch_jobs.keys())]["pg"]
 
-    def get_pg(self) -> dict:
-        """Get one and only batch process graph (sync or batch)"""
+    def get_pg(self, process_id: Optional[str] = None) -> dict:
+        """
+        Get one and only batch process graph (sync or batch)
+
+        :param process_id: just return single process graph node with this process_id
+        :return: process graph (flat graph representation) or process graph node
+        """
         pgs = self.sync_requests + [b["pg"] for b in self.batch_jobs.values()]
         assert len(pgs) == 1
-        return pgs[0]
+        pg = pgs[0]
+        if process_id:
+            # Just return single node (by process_id)
+            found = [node for node in pg.values() if node.get("process_id") == process_id]
+            if len(found) != 1:
+                raise RuntimeError(
+                    f"Expected single process graph node with {process_id=}, but found {len(found)}: {found}"
+                )
+            return found[0]
+        return pg
+
+    def execute(self, cube: Union[DataCube, VectorCube], process_id: Optional[str] = None) -> dict:
+        """
+        Execute given cube (synchronously) and return observed process graph (or subset thereof).
+
+        :param cube: cube to execute on dummy back-end
+        :param process_id: just return single process graph node with this process_id
+        :return: process graph (flat graph representation) or process graph node
+        """
+        cube.execute()
+        return self.get_pg(process_id=process_id)

openeo/rest/vectorcube.py

@@ -1,7 +1,7 @@
 import json
 import pathlib
 import typing
-from typing import List, Optional, Union
+from typing import List, Optional, Union, Tuple, Callable
 
 import shapely.geometry.base
 
@@ -14,7 +14,7 @@
 from openeo.rest._datacube import THIS, UDF, _ProcessGraphAbstraction, build_child_callback
 from openeo.rest.job import BatchJob
 from openeo.rest.mlmodel import MlModel
-from openeo.util import dict_no_none, guess_format
+from openeo.util import dict_no_none, guess_format, crs_to_epsg_code, to_bbox_dict, InvalidBBoxException
 
 if typing.TYPE_CHECKING:
     # Imports for type checking only (circular import issue at runtime).
@@ -327,6 +327,75 @@ def create_job(
 
     send_job = legacy_alias(create_job, name="send_job", since="0.10.0")
 
+    @openeo_process
+    def filter_bands(self, bands: List[str]) -> "VectorCube":
+        """
+        .. versionadded:: 0.22.0
+        """
+        # TODO #459 docs
+        return self.process(
+            process_id="filter_bands",
+            arguments={"data": THIS, "bands": bands},
+        )
+
+    @openeo_process
+    def filter_bbox(
+        self,
+        *,
+        west: Optional[float] = None,
+        south: Optional[float] = None,
+        east: Optional[float] = None,
+        north: Optional[float] = None,
+        extent: Optional[Union[dict, List[float], Tuple[float, float, float, float], Parameter]] = None,
+        crs: Optional[int] = None,
+    ) -> "VectorCube":
+        """
+        .. versionadded:: 0.22.0
+        """
+        # TODO #459 docs
+        if any(c is not None for c in [west, south, east, north]):
+            if extent is not None:
+                raise InvalidBBoxException("Don't specify both west/south/east/north and extent")
+            extent = dict_no_none(west=west, south=south, east=east, north=north)
+
+        if isinstance(extent, Parameter):
+            pass
+        else:
+            extent = to_bbox_dict(extent, crs=crs)
+        return self.process(
+            process_id="filter_bbox",
+            arguments={"data": THIS, "extent": extent},
+        )
+
+    @openeo_process
+    def filter_labels(
+        self, condition: Union[PGNode, Callable], dimension: str, context: Optional[dict] = None
+    ) -> "VectorCube":
+        """
+        .. versionadded:: 0.22.0
+        """
+        # TODO #459 docs
+        condition = build_child_callback(condition, parent_parameters=["value"])
+        return self.process(
+            process_id="filter_labels",
+            arguments=dict_no_none(data=THIS, condition=condition, dimension=dimension, context=context),
+        )
+
+    @openeo_process
+    def filter_vector(
+        self, geometries: Union["VectorCube", shapely.geometry.base.BaseGeometry, dict], relation: str = "intersects"
+    ) -> "VectorCube":
+        """
+        .. versionadded:: 0.22.0
+        """
+        # TODO #459 docs
+        if not isinstance(geometries, (VectorCube, Parameter)):
+            geometries = self.load_geojson(connection=self.connection, data=geometries)
+        return self.process(
+            process_id="filter_vector",
+            arguments={"data": THIS, "geometries": geometries, "relation": relation},
+        )
+
     @openeo_process
     def fit_class_random_forest(
         self,

openeo/util.py

@@ -520,6 +520,10 @@ def in_interactive_mode() -> bool:
     return hasattr(sys, "ps1")
 
 
+class InvalidBBoxException(ValueError):
+    pass
+
+
 class BBoxDict(dict):
     """
     Dictionary based helper to easily create/work with bounding box dictionaries
@@ -528,50 +532,50 @@ class BBoxDict(dict):
     .. versionadded:: 0.10.1
     """
 
-    def __init__(self, *, west: float, south: float, east: float, north: float, crs: Optional[str] = None):
+    def __init__(self, *, west: float, south: float, east: float, north: float, crs: Optional[Union[str, int]] = None):
         super().__init__(west=west, south=south, east=east, north=north)
         if crs is not None:
-            # TODO: #259, should we covert EPSG strings to int here with crs_to_epsg_code?
-            # self.update(crs=crs_to_epsg_code(crs))
-            self.update(crs=crs)
+            self.update(crs=crs_to_epsg_code(crs))
 
     # TODO: provide west, south, east, north, crs as @properties? Read-only or read-write?
 
     @classmethod
     def from_any(cls, x: Any, *, crs: Optional[str] = None) -> 'BBoxDict':
         if isinstance(x, dict):
+            if crs and "crs" in x and crs != x["crs"]:
+                raise InvalidBBoxException(f"Two CRS values specified: {crs} and {x['crs']}")
             return cls.from_dict({"crs": crs, **x})
         elif isinstance(x, (list, tuple)):
             return cls.from_sequence(x, crs=crs)
         elif isinstance(x, shapely.geometry.base.BaseGeometry):
             return cls.from_sequence(x.bounds, crs=crs)
         # TODO: support other input? E.g.: WKT string, GeoJson-style dictionary (Polygon, FeatureCollection, ...)
         else:
-            raise ValueError(f"Can not construct BBoxDict from {x!r}")
+            raise InvalidBBoxException(f"Can not construct BBoxDict from {x!r}")
 
     @classmethod
     def from_dict(cls, data: dict) -> 'BBoxDict':
         """Build from dictionary with at least keys "west", "south", "east", and "north"."""
         expected_fields = {"west", "south", "east", "north"}
-        # TODO: also support converting support case fields?
-        if not all(k in data for k in expected_fields):
-            raise ValueError(
-                f"Expecting fields {expected_fields}, but only found {expected_fields.intersection(data.keys())}."
-            )
-        return cls(
-            west=data["west"], south=data["south"], east=data["east"], north=data["north"],
-            crs=data.get("crs")
-        )
+        # TODO: also support upper case fields?
+        # TODO: optional support for parameterized bbox fields?
+        missing = expected_fields.difference(data.keys())
+        if missing:
+            raise InvalidBBoxException(f"Missing bbox fields {sorted(missing)}")
+        invalid = {k: data[k] for k in expected_fields if not isinstance(data[k], (int, float))}
+        if invalid:
+            raise InvalidBBoxException(f"Non-numerical bbox fields {invalid}.")
+        return cls(west=data["west"], south=data["south"], east=data["east"], north=data["north"], crs=data.get("crs"))
 
     @classmethod
     def from_sequence(cls, seq: Union[list, tuple], crs: Optional[str] = None) -> 'BBoxDict':
         """Build from sequence of 4 bounds (west, south, east and north)."""
         if len(seq) != 4:
-            raise ValueError(f"Expected sequence with 4 items, but got {len(seq)}.")
+            raise InvalidBBoxException(f"Expected sequence with 4 items, but got {len(seq)}.")
         return cls(west=seq[0], south=seq[1], east=seq[2], north=seq[3], crs=crs)
 
 
-def to_bbox_dict(x: Any, *, crs: Optional[str] = None) -> BBoxDict:
+def to_bbox_dict(x: Any, *, crs: Optional[Union[str, int]] = None) -> BBoxDict:
     """
     Convert given data or object to a bounding box dictionary
     (having keys "west", "south", "east", "north", and optionally "crs").