stac-fastapi-core 4.2.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.
@@ -13,45 +13,64 @@
 # 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):
@@ -89,124 +108,3 @@ class SpatialOp(str, Enum):
     S_CONTAINS = "s_contains"
     S_WITHIN = "s_within"
     S_DISJOINT = "s_disjoint"
-
-
-def to_es_field(queryables_mapping: Dict[str, Any], 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(queryables_mapping: Dict[str, Any], 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(queryables_mapping, 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(queryables_mapping, 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(queryables_mapping, query["args"][0]["property"])
-        return {"bool": {"must_not": {"exists": {"field": field}}}}
-
-    elif query["op"] == AdvancedComparisonOp.BETWEEN:
-        field = to_es_field(queryables_mapping, 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(queryables_mapping, 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(queryables_mapping, query["args"][0]["property"])
-        pattern = cql2_like_to_es(query["args"][1])
-        return {"wildcard": {field: {"value": pattern, "case_insensitive": True}}}
-
-    elif query["op"] in [
-        SpatialOp.S_INTERSECTS,
-        SpatialOp.S_CONTAINS,
-        SpatialOp.S_WITHIN,
-        SpatialOp.S_DISJOINT,
-    ]:
-        field = to_es_field(queryables_mapping, query["args"][0]["property"])
-        geometry = query["args"][1]
-
-        relation_mapping = {
-            SpatialOp.S_INTERSECTS: "intersects",
-            SpatialOp.S_CONTAINS: "contains",
-            SpatialOp.S_WITHIN: "within",
-            SpatialOp.S_DISJOINT: "disjoint",
-        }
-
-        relation = relation_mapping[query["op"]]
-        return {"geo_shape": {field: {"shape": geometry, "relation": relation}}}
-
-    return {}

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,46 +12,6 @@ from stac_fastapi.types.stac import Item
 MAX_LIMIT = 10000
 
 
-def validate_refresh(value: Union[str, bool]) -> str:
-    """
-    Validate the `refresh` parameter value.
-
-    Args:
-        value (Union[str, bool]): The `refresh` parameter value, which can be a string or a boolean.
-
-    Returns:
-        str: The validated value of the `refresh` parameter, which can be "true", "false", or "wait_for".
-    """
-    logger = logging.getLogger(__name__)
-
-    # Handle boolean-like values using get_bool_env
-    if isinstance(value, bool) or value in {
-        "true",
-        "false",
-        "1",
-        "0",
-        "yes",
-        "no",
-        "y",
-        "n",
-    }:
-        is_true = get_bool_env("DATABASE_REFRESH", default=value)
-        return "true" if is_true else "false"
-
-    # Normalize to lowercase for case-insensitivity
-    value = value.lower()
-
-    # Handle "wait_for" explicitly
-    if value == "wait_for":
-        return "wait_for"
-
-    # Log a warning for invalid values and default to "false"
-    logger.warning(
-        f"Invalid value for `refresh`: '{value}'. Expected 'true', 'false', or 'wait_for'. Defaulting to 'false'."
-    )
-    return "false"
-
-
 def get_bool_env(name: str, default: Union[bool, str] = False) -> bool:
     """
     Retrieve a boolean value from an environment variable.

stac_fastapi/core/version.py

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