stac-fastapi-core 4.1.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

stac_fastapi/core/extensions/filter.py

@@ -1,4 +1,4 @@
-"""Filter extension logic for es conversion."""
+"""Filter extension logic for conversion."""
 
 # """
 # Implements Filter Extension.
@@ -10,48 +10,67 @@
 # defines the LIKE, IN, and BETWEEN operators.
 
 # Basic Spatial Operators (http://www.opengis.net/spec/cql2/1.0/conf/basic-spatial-operators)
-# defines the intersects operator (S_INTERSECTS).
+# defines spatial operators (S_INTERSECTS, S_CONTAINS, S_WITHIN, S_DISJOINT).
 # """
 
-import re
 from enum import Enum
 from typing import Any, Dict
 
-_cql2_like_patterns = re.compile(r"\\.|[%_]|\\$")
-_valid_like_substitutions = {
-    "\\\\": "\\",
-    "\\%": "%",
-    "\\_": "_",
-    "%": "*",
-    "_": "?",
+DEFAULT_QUERYABLES: Dict[str, Dict[str, Any]] = {
+    "id": {
+        "description": "ID",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/definitions/core/allOf/2/properties/id",
+    },
+    "collection": {
+        "description": "Collection",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/definitions/core/allOf/2/then/properties/collection",
+    },
+    "geometry": {
+        "description": "Geometry",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/definitions/core/allOf/1/oneOf/0/properties/geometry",
+    },
+    "datetime": {
+        "description": "Acquisition Timestamp",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/datetime.json#/properties/datetime",
+    },
+    "created": {
+        "description": "Creation Timestamp",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/datetime.json#/properties/created",
+    },
+    "updated": {
+        "description": "Creation Timestamp",
+        "$ref": "https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/datetime.json#/properties/updated",
+    },
+    "cloud_cover": {
+        "description": "Cloud Cover",
+        "$ref": "https://stac-extensions.github.io/eo/v1.0.0/schema.json#/definitions/fields/properties/eo:cloud_cover",
+    },
+    "cloud_shadow_percentage": {
+        "title": "Cloud Shadow Percentage",
+        "description": "Cloud Shadow Percentage",
+        "type": "number",
+        "minimum": 0,
+        "maximum": 100,
+    },
+    "nodata_pixel_percentage": {
+        "title": "No Data Pixel Percentage",
+        "description": "No Data Pixel Percentage",
+        "type": "number",
+        "minimum": 0,
+        "maximum": 100,
+    },
 }
+"""Queryables that are present in all collections."""
 
+OPTIONAL_QUERYABLES: Dict[str, Dict[str, Any]] = {
+    "platform": {
+        "$enum": True,
+        "description": "Satellite platform identifier",
+    },
+}
+"""Queryables that are present in some collections."""
 
-def _replace_like_patterns(match: re.Match) -> str:
-    pattern = match.group()
-    try:
-        return _valid_like_substitutions[pattern]
-    except KeyError:
-        raise ValueError(f"'{pattern}' is not a valid escape sequence")
-
-
-def cql2_like_to_es(string: str) -> str:
-    """
-    Convert CQL2 "LIKE" characters to Elasticsearch "wildcard" characters.
-
-    Args:
-        string (str): The string containing CQL2 wildcard characters.
-
-    Returns:
-        str: The converted string with Elasticsearch compatible wildcards.
-
-    Raises:
-        ValueError: If an invalid escape sequence is encountered.
-    """
-    return _cql2_like_patterns.sub(
-        repl=_replace_like_patterns,
-        string=string,
-    )
+ALL_QUERYABLES: Dict[str, Dict[str, Any]] = DEFAULT_QUERYABLES | OPTIONAL_QUERYABLES
 
 
 class LogicalOp(str, Enum):
@@ -82,121 +101,10 @@ class AdvancedComparisonOp(str, Enum):
     IN = "in"
 
 
-class SpatialIntersectsOp(str, Enum):
-    """Enumeration for spatial intersection operator as per CQL2 standards."""
+class SpatialOp(str, Enum):
+    """Enumeration for spatial operators as per CQL2 standards."""
 
     S_INTERSECTS = "s_intersects"
-
-
-queryables_mapping = {
-    "id": "id",
-    "collection": "collection",
-    "geometry": "geometry",
-    "datetime": "properties.datetime",
-    "created": "properties.created",
-    "updated": "properties.updated",
-    "cloud_cover": "properties.eo:cloud_cover",
-    "cloud_shadow_percentage": "properties.s2:cloud_shadow_percentage",
-    "nodata_pixel_percentage": "properties.s2:nodata_pixel_percentage",
-}
-
-
-def to_es_field(field: str) -> str:
-    """
-    Map a given field to its corresponding Elasticsearch field according to a predefined mapping.
-
-    Args:
-        field (str): The field name from a user query or filter.
-
-    Returns:
-        str: The mapped field name suitable for Elasticsearch queries.
-    """
-    return queryables_mapping.get(field, field)
-
-
-def to_es(query: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Transform a simplified CQL2 query structure to an Elasticsearch compatible query DSL.
-
-    Args:
-        query (Dict[str, Any]): The query dictionary containing 'op' and 'args'.
-
-    Returns:
-        Dict[str, Any]: The corresponding Elasticsearch query in the form of a dictionary.
-    """
-    if query["op"] in [LogicalOp.AND, LogicalOp.OR, LogicalOp.NOT]:
-        bool_type = {
-            LogicalOp.AND: "must",
-            LogicalOp.OR: "should",
-            LogicalOp.NOT: "must_not",
-        }[query["op"]]
-        return {"bool": {bool_type: [to_es(sub_query) for sub_query in query["args"]]}}
-
-    elif query["op"] in [
-        ComparisonOp.EQ,
-        ComparisonOp.NEQ,
-        ComparisonOp.LT,
-        ComparisonOp.LTE,
-        ComparisonOp.GT,
-        ComparisonOp.GTE,
-    ]:
-        range_op = {
-            ComparisonOp.LT: "lt",
-            ComparisonOp.LTE: "lte",
-            ComparisonOp.GT: "gt",
-            ComparisonOp.GTE: "gte",
-        }
-
-        field = to_es_field(query["args"][0]["property"])
-        value = query["args"][1]
-        if isinstance(value, dict) and "timestamp" in value:
-            value = value["timestamp"]
-            if query["op"] == ComparisonOp.EQ:
-                return {"range": {field: {"gte": value, "lte": value}}}
-            elif query["op"] == ComparisonOp.NEQ:
-                return {
-                    "bool": {
-                        "must_not": [{"range": {field: {"gte": value, "lte": value}}}]
-                    }
-                }
-            else:
-                return {"range": {field: {range_op[query["op"]]: value}}}
-        else:
-            if query["op"] == ComparisonOp.EQ:
-                return {"term": {field: value}}
-            elif query["op"] == ComparisonOp.NEQ:
-                return {"bool": {"must_not": [{"term": {field: value}}]}}
-            else:
-                return {"range": {field: {range_op[query["op"]]: value}}}
-
-    elif query["op"] == ComparisonOp.IS_NULL:
-        field = to_es_field(query["args"][0]["property"])
-        return {"bool": {"must_not": {"exists": {"field": field}}}}
-
-    elif query["op"] == AdvancedComparisonOp.BETWEEN:
-        field = to_es_field(query["args"][0]["property"])
-        gte, lte = query["args"][1], query["args"][2]
-        if isinstance(gte, dict) and "timestamp" in gte:
-            gte = gte["timestamp"]
-        if isinstance(lte, dict) and "timestamp" in lte:
-            lte = lte["timestamp"]
-        return {"range": {field: {"gte": gte, "lte": lte}}}
-
-    elif query["op"] == AdvancedComparisonOp.IN:
-        field = to_es_field(query["args"][0]["property"])
-        values = query["args"][1]
-        if not isinstance(values, list):
-            raise ValueError(f"Arg {values} is not a list")
-        return {"terms": {field: values}}
-
-    elif query["op"] == AdvancedComparisonOp.LIKE:
-        field = to_es_field(query["args"][0]["property"])
-        pattern = cql2_like_to_es(query["args"][1])
-        return {"wildcard": {field: {"value": pattern, "case_insensitive": True}}}
-
-    elif query["op"] == SpatialIntersectsOp.S_INTERSECTS:
-        field = to_es_field(query["args"][0]["property"])
-        geometry = query["args"][1]
-        return {"geo_shape": {field: {"shape": geometry, "relation": "intersects"}}}
-
-    return {}
+    S_CONTAINS = "s_contains"
+    S_WITHIN = "s_within"
+    S_DISJOINT = "s_disjoint"

stac_fastapi/core/route_dependencies.py

@@ -2,11 +2,11 @@
 
 import importlib
 import inspect
-import json
 import logging
 import os
 from typing import List
 
+import orjson
 from fastapi import Depends
 from jsonschema import validate
 
@@ -84,14 +84,14 @@ route_dependencies_schema = {
 
 def get_route_dependencies_conf(route_dependencies_env: str) -> list:
     """Get Route dependencies configuration from file or environment variable."""
-    if os.path.exists(route_dependencies_env):
-        with open(route_dependencies_env, encoding="utf-8") as route_dependencies_file:
-            route_dependencies_conf = json.load(route_dependencies_file)
+    if os.path.isfile(route_dependencies_env):
+        with open(route_dependencies_env, "rb") as f:
+            route_dependencies_conf = orjson.loads(f.read())
 
     else:
         try:
-            route_dependencies_conf = json.loads(route_dependencies_env)
-        except json.JSONDecodeError as exception:
+            route_dependencies_conf = orjson.loads(route_dependencies_env)
+        except orjson.JSONDecodeError as exception:
             _LOGGER.error("Invalid JSON format for route dependencies. %s", exception)
             raise
 

stac_fastapi/core/utilities.py

@@ -12,20 +12,35 @@ from stac_fastapi.types.stac import Item
 MAX_LIMIT = 10000
 
 
-def get_bool_env(name: str, default: bool = False) -> bool:
+def get_bool_env(name: str, default: Union[bool, str] = False) -> bool:
     """
     Retrieve a boolean value from an environment variable.
 
     Args:
         name (str): The name of the environment variable.
-        default (bool, optional): The default value to use if the variable is not set or unrecognized. Defaults to False.
+        default (Union[bool, str], optional): The default value to use if the variable is not set or unrecognized. Defaults to False.
 
     Returns:
         bool: The boolean value parsed from the environment variable.
     """
-    value = os.getenv(name, str(default).lower())
     true_values = ("true", "1", "yes", "y")
     false_values = ("false", "0", "no", "n")
+
+    # Normalize the default value
+    if isinstance(default, bool):
+        default_str = "true" if default else "false"
+    elif isinstance(default, str):
+        default_str = default.lower()
+    else:
+        logger = logging.getLogger(__name__)
+        logger.warning(
+            f"The `default` parameter must be a boolean or string, got {type(default).__name__}. "
+            f"Falling back to `False`."
+        )
+        default_str = "false"
+
+    # Retrieve and normalize the environment variable value
+    value = os.getenv(name, default_str)
     if value.lower() in true_values:
         return True
     elif value.lower() in false_values:
@@ -34,9 +49,9 @@ def get_bool_env(name: str, default: bool = False) -> bool:
         logger = logging.getLogger(__name__)
         logger.warning(
             f"Environment variable '{name}' has unrecognized value '{value}'. "
-            f"Expected one of {true_values + false_values}. Using default: {default}"
+            f"Expected one of {true_values + false_values}. Using default: {default_str}"
         )
-        return default
+        return default_str in true_values
 
 
 def bbox2polygon(b0: float, b1: float, b2: float, b3: float) -> List[List[List[float]]]:

stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "4.1.0"
+__version__ = "5.0.0"