stac-fastapi.core 3.2.4__tar.gz → 4.0.0a0__tar.gz

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac_fastapi.core
-Version: 3.2.4
+Version: 4.0.0a0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/setup.py

@@ -6,13 +6,13 @@ with open("README.md") as f:
     desc = f.read()
 
 install_requires = [
-    "fastapi-slim",
+    "fastapi",
     "attrs>=23.2.0",
     "pydantic",
-    "stac_pydantic>=3",
-    "stac-fastapi.types==3.0.0",
-    "stac-fastapi.api==3.0.0",
-    "stac-fastapi.extensions==3.0.0",
+    "stac_pydantic==3.1.*",
+    "stac-fastapi.api==5.1.1",
+    "stac-fastapi.extensions==5.1.1",
+    "stac-fastapi.types==5.1.1",
     "orjson",
     "overrides",
     "geojson-pydantic",

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi/core/core.py

@@ -1,10 +1,11 @@
 """Core client."""
 
 import logging
+from collections import deque
 from datetime import datetime as datetime_type
 from datetime import timezone
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set, Type, Union
+from typing import Any, Dict, List, Literal, Optional, Set, Type, Union
 from urllib.parse import unquote_plus, urljoin
 
 import attr
@@ -36,13 +37,11 @@ from stac_fastapi.types.conformance import BASE_CONFORMANCE_CLASSES
 from stac_fastapi.types.core import AsyncBaseCoreClient, AsyncBaseTransactionsClient
 from stac_fastapi.types.extension import ApiExtension
 from stac_fastapi.types.requests import get_base_url
-from stac_fastapi.types.rfc3339 import DateTimeType
+from stac_fastapi.types.rfc3339 import DateTimeType, rfc3339_str_to_datetime
 from stac_fastapi.types.search import BaseSearchPostRequest
 
 logger = logging.getLogger(__name__)
 
-NumType = Union[float, int]
-
 
 @attr.s
 class CoreClient(AsyncBaseCoreClient):
@@ -278,7 +277,7 @@ class CoreClient(AsyncBaseCoreClient):
         self,
         collection_id: str,
         bbox: Optional[BBox] = None,
-        datetime: Optional[DateTimeType] = None,
+        datetime: Optional[str] = None,
         limit: Optional[int] = 10,
         token: Optional[str] = None,
         **kwargs,
@@ -288,7 +287,7 @@ class CoreClient(AsyncBaseCoreClient):
         Args:
             collection_id (str): The identifier of the collection to read items from.
             bbox (Optional[BBox]): The bounding box to filter items by.
-            datetime (Optional[DateTimeType]): The datetime range to filter items by.
+            datetime (Optional[str]): The datetime range to filter items by.
             limit (int): The maximum number of items to return. The default value is 10.
             token (str): A token used for pagination.
             request (Request): The incoming request.
@@ -427,23 +426,34 @@ class CoreClient(AsyncBaseCoreClient):
 
         return result
 
-    def _format_datetime_range(self, date_tuple: DateTimeType) -> str:
+    def _format_datetime_range(self, date_str: str) -> str:
         """
-        Convert a tuple of datetime objects or None into a formatted string for API requests.
+        Convert a datetime range string into a normalized UTC string for API requests using rfc3339_str_to_datetime.
 
         Args:
-            date_tuple (tuple): A tuple containing two elements, each can be a datetime object or None.
+            date_str (str): A string containing two datetime values separated by a '/'.
 
         Returns:
-            str: A string formatted as 'YYYY-MM-DDTHH:MM:SS.sssZ/YYYY-MM-DDTHH:MM:SS.sssZ', with '..' used if any element is None.
+            str: A string formatted as 'YYYY-MM-DDTHH:MM:SSZ/YYYY-MM-DDTHH:MM:SSZ', with '..' used if any element is None.
         """
 
-        def format_datetime(dt):
-            """Format a single datetime object to the ISO8601 extended format with 'Z'."""
-            return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" if dt else ".."
-
-        start, end = date_tuple
-        return f"{format_datetime(start)}/{format_datetime(end)}"
+        def normalize(dt):
+            dt = dt.strip()
+            if not dt or dt == "..":
+                return ".."
+            dt_obj = rfc3339_str_to_datetime(dt)
+            dt_utc = dt_obj.astimezone(timezone.utc)
+            return dt_utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        if not isinstance(date_str, str):
+            return "../.."
+        if "/" not in date_str:
+            return f"{normalize(date_str)}/{normalize(date_str)}"
+        try:
+            start, end = date_str.split("/", 1)
+        except Exception:
+            return "../.."
+        return f"{normalize(start)}/{normalize(end)}"
 
     async def get_search(
         self,
@@ -451,7 +461,7 @@ class CoreClient(AsyncBaseCoreClient):
         collections: Optional[List[str]] = None,
         ids: Optional[List[str]] = None,
         bbox: Optional[BBox] = None,
-        datetime: Optional[DateTimeType] = None,
+        datetime: Optional[str] = None,
         limit: Optional[int] = 10,
         query: Optional[str] = None,
         token: Optional[str] = None,
@@ -459,7 +469,7 @@ class CoreClient(AsyncBaseCoreClient):
         sortby: Optional[str] = None,
         q: Optional[List[str]] = None,
         intersects: Optional[str] = None,
-        filter: Optional[str] = None,
+        filter_expr: Optional[str] = None,
         filter_lang: Optional[str] = None,
         **kwargs,
     ) -> stac_types.ItemCollection:
@@ -469,7 +479,7 @@ class CoreClient(AsyncBaseCoreClient):
             collections (Optional[List[str]]): List of collection IDs to search in.
             ids (Optional[List[str]]): List of item IDs to search for.
             bbox (Optional[BBox]): Bounding box to search in.
-            datetime (Optional[DateTimeType]): Filter items based on the datetime field.
+            datetime (Optional[str]): Filter items based on the datetime field.
             limit (Optional[int]): Maximum number of results to return.
             query (Optional[str]): Query string to filter the results.
             token (Optional[str]): Access token to use when searching the catalog.
@@ -496,7 +506,7 @@ class CoreClient(AsyncBaseCoreClient):
         }
 
         if datetime:
-            base_args["datetime"] = self._format_datetime_range(datetime)
+            base_args["datetime"] = self._format_datetime_range(date_str=datetime)
 
         if intersects:
             base_args["intersects"] = orjson.loads(unquote_plus(intersects))
@@ -507,12 +517,12 @@ class CoreClient(AsyncBaseCoreClient):
                 for sort in sortby
             ]
 
-        if filter:
-            base_args["filter-lang"] = "cql2-json"
+        if filter_expr:
+            base_args["filter_lang"] = "cql2-json"
             base_args["filter"] = orjson.loads(
-                unquote_plus(filter)
+                unquote_plus(filter_expr)
                 if filter_lang == "cql2-json"
-                else to_cql2(parse_cql2_text(filter))
+                else to_cql2(parse_cql2_text(filter_expr))
             )
 
         if fields:
@@ -594,8 +604,8 @@ class CoreClient(AsyncBaseCoreClient):
                     )
 
         # only cql2_json is supported here
-        if hasattr(search_request, "filter"):
-            cql2_filter = getattr(search_request, "filter", None)
+        if hasattr(search_request, "filter_expr"):
+            cql2_filter = getattr(search_request, "filter_expr", None)
             try:
                 search = self.database.apply_cql2_filter(search, cql2_filter)
             except Exception as e:
@@ -735,9 +745,7 @@ class TransactionsClient(AsyncBaseTransactionsClient):
         return ItemSerializer.db_to_stac(item, base_url)
 
     @overrides
-    async def delete_item(
-        self, item_id: str, collection_id: str, **kwargs
-    ) -> Optional[stac_types.Item]:
+    async def delete_item(self, item_id: str, collection_id: str, **kwargs) -> None:
         """Delete an item from a collection.
 
         Args:
@@ -745,7 +753,7 @@ class TransactionsClient(AsyncBaseTransactionsClient):
             collection_id (str): The identifier of the collection that contains the item.
 
         Returns:
-            Optional[stac_types.Item]: The deleted item, or `None` if the item was successfully deleted.
+            None: Returns 204 No Content on successful deletion
         """
         await self.database.delete_item(item_id=item_id, collection_id=collection_id)
         return None
@@ -815,23 +823,20 @@ class TransactionsClient(AsyncBaseTransactionsClient):
         )
 
     @overrides
-    async def delete_collection(
-        self, collection_id: str, **kwargs
-    ) -> Optional[stac_types.Collection]:
+    async def delete_collection(self, collection_id: str, **kwargs) -> None:
         """
         Delete a collection.
 
         This method deletes an existing collection in the database.
 
         Args:
-            collection_id (str): The identifier of the collection that contains the item.
-            kwargs: Additional keyword arguments.
+            collection_id (str): The identifier of the collection to delete
 
         Returns:
-            None.
+            None: Returns 204 No Content on successful deletion
 
         Raises:
-            NotFoundError: If the collection doesn't exist.
+            NotFoundError: If the collection doesn't exist
         """
         await self.database.delete_collection(collection_id=collection_id)
         return None
@@ -907,11 +912,81 @@ class BulkTransactionsClient(BaseBulkTransactionsClient):
         return f"Successfully added {len(processed_items)} Items."
 
 
+_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,
+    },
+}
+
+_ES_MAPPING_TYPE_TO_JSON: Dict[
+    str, Literal["string", "number", "boolean", "object", "array", "null"]
+] = {
+    "date": "string",
+    "date_nanos": "string",
+    "keyword": "string",
+    "match_only_text": "string",
+    "text": "string",
+    "wildcard": "string",
+    "byte": "number",
+    "double": "number",
+    "float": "number",
+    "half_float": "number",
+    "long": "number",
+    "scaled_float": "number",
+    "short": "number",
+    "token_count": "number",
+    "unsigned_long": "number",
+    "geo_point": "object",
+    "geo_shape": "object",
+    "nested": "array",
+}
+
+
 @attr.s
 class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
     """Defines a pattern for implementing the STAC filter extension."""
 
-    # todo: use the ES _mapping endpoint to dynamically find what fields exist
+    database: BaseDatabaseLogic = attr.ib()
+
     async def get_queryables(
         self, collection_id: Optional[str] = None, **kwargs
     ) -> Dict[str, Any]:
@@ -932,55 +1007,62 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
         Returns:
             Dict[str, Any]: A dictionary containing the queryables for the given collection.
         """
-        return {
+        queryables: Dict[str, Any] = {
             "$schema": "https://json-schema.org/draft/2019-09/schema",
             "$id": "https://stac-api.example.com/queryables",
             "type": "object",
-            "title": "Queryables for Example STAC API",
-            "description": "Queryable names for the example STAC API Item Search filter.",
-            "properties": {
-                "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": {
-                    "description": "Cloud Shadow Percentage",
-                    "title": "Cloud Shadow Percentage",
-                    "type": "number",
-                    "minimum": 0,
-                    "maximum": 100,
-                },
-                "nodata_pixel_percentage": {
-                    "description": "No Data Pixel Percentage",
-                    "title": "No Data Pixel Percentage",
-                    "type": "number",
-                    "minimum": 0,
-                    "maximum": 100,
-                },
-            },
+            "title": "Queryables for STAC API",
+            "description": "Queryable names for the STAC API Item Search filter.",
+            "properties": _DEFAULT_QUERYABLES,
             "additionalProperties": True,
         }
+        if not collection_id:
+            return queryables
+
+        properties: Dict[str, Any] = queryables["properties"]
+        queryables.update(
+            {
+                "properties": properties,
+                "additionalProperties": False,
+            }
+        )
+
+        mapping_data = await self.database.get_items_mapping(collection_id)
+        mapping_properties = next(iter(mapping_data.values()))["mappings"]["properties"]
+        stack = deque(mapping_properties.items())
+
+        while stack:
+            field_name, field_def = stack.popleft()
+
+            # Iterate over nested fields
+            field_properties = field_def.get("properties")
+            if field_properties:
+                # Fields in Item Properties should be exposed with their un-prefixed names,
+                # and not require expressions to prefix them with properties,
+                # e.g., eo:cloud_cover instead of properties.eo:cloud_cover.
+                if field_name == "properties":
+                    stack.extend(field_properties.items())
+                else:
+                    stack.extend(
+                        (f"{field_name}.{k}", v) for k, v in field_properties.items()
+                    )
+
+            # Skip non-indexed or disabled fields
+            field_type = field_def.get("type")
+            if not field_type or not field_def.get("enabled", True):
+                continue
+
+            # Generate field properties
+            field_result = _DEFAULT_QUERYABLES.get(field_name, {})
+            properties[field_name] = field_result
+
+            field_name_human = field_name.replace("_", " ").title()
+            field_result.setdefault("title", field_name_human)
+
+            field_type_json = _ES_MAPPING_TYPE_TO_JSON.get(field_type, field_type)
+            field_result.setdefault("type", field_type_json)
+
+            if field_type in {"date", "date_nanos"}:
+                field_result.setdefault("format", "date-time")
+
+        return queryables

stac_fastapi.core-4.0.0a0/stac_fastapi/core/database_logic.py

@@ -0,0 +1,226 @@
+"""Database logic core."""
+
+import os
+from functools import lru_cache
+from typing import Any, Dict, List, Optional, Protocol
+
+from stac_fastapi.types.stac import Item
+
+
+# stac_pydantic classes extend _GeometryBase, which doesn't have a type field,
+# So create our own Protocol for typing
+# Union[ Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon, GeometryCollection]
+class Geometry(Protocol):  # noqa
+    type: str
+    coordinates: Any
+
+
+COLLECTIONS_INDEX = os.getenv("STAC_COLLECTIONS_INDEX", "collections")
+ITEMS_INDEX_PREFIX = os.getenv("STAC_ITEMS_INDEX_PREFIX", "items_")
+
+ES_INDEX_NAME_UNSUPPORTED_CHARS = {
+    "\\",
+    "/",
+    "*",
+    "?",
+    '"',
+    "<",
+    ">",
+    "|",
+    " ",
+    ",",
+    "#",
+    ":",
+}
+
+_ES_INDEX_NAME_UNSUPPORTED_CHARS_TABLE = str.maketrans(
+    "", "", "".join(ES_INDEX_NAME_UNSUPPORTED_CHARS)
+)
+
+ITEM_INDICES = f"{ITEMS_INDEX_PREFIX}*,-*kibana*,-{COLLECTIONS_INDEX}*"
+
+DEFAULT_SORT = {
+    "properties.datetime": {"order": "desc"},
+    "id": {"order": "desc"},
+    "collection": {"order": "desc"},
+}
+
+ES_ITEMS_SETTINGS = {
+    "index": {
+        "sort.field": list(DEFAULT_SORT.keys()),
+        "sort.order": [v["order"] for v in DEFAULT_SORT.values()],
+    }
+}
+
+ES_MAPPINGS_DYNAMIC_TEMPLATES = [
+    # Common https://github.com/radiantearth/stac-spec/blob/master/item-spec/common-metadata.md
+    {
+        "descriptions": {
+            "match_mapping_type": "string",
+            "match": "description",
+            "mapping": {"type": "text"},
+        }
+    },
+    {
+        "titles": {
+            "match_mapping_type": "string",
+            "match": "title",
+            "mapping": {"type": "text"},
+        }
+    },
+    # Projection Extension https://github.com/stac-extensions/projection
+    {"proj_epsg": {"match": "proj:epsg", "mapping": {"type": "integer"}}},
+    {
+        "proj_projjson": {
+            "match": "proj:projjson",
+            "mapping": {"type": "object", "enabled": False},
+        }
+    },
+    {
+        "proj_centroid": {
+            "match": "proj:centroid",
+            "mapping": {"type": "geo_point"},
+        }
+    },
+    {
+        "proj_geometry": {
+            "match": "proj:geometry",
+            "mapping": {"type": "object", "enabled": False},
+        }
+    },
+    {
+        "no_index_href": {
+            "match": "href",
+            "mapping": {"type": "text", "index": False},
+        }
+    },
+    # Default all other strings not otherwise specified to keyword
+    {"strings": {"match_mapping_type": "string", "mapping": {"type": "keyword"}}},
+    {"numerics": {"match_mapping_type": "long", "mapping": {"type": "float"}}},
+]
+
+ES_ITEMS_MAPPINGS = {
+    "numeric_detection": False,
+    "dynamic_templates": ES_MAPPINGS_DYNAMIC_TEMPLATES,
+    "properties": {
+        "id": {"type": "keyword"},
+        "collection": {"type": "keyword"},
+        "geometry": {"type": "geo_shape"},
+        "assets": {"type": "object", "enabled": False},
+        "links": {"type": "object", "enabled": False},
+        "properties": {
+            "type": "object",
+            "properties": {
+                # Common https://github.com/radiantearth/stac-spec/blob/master/item-spec/common-metadata.md
+                "datetime": {"type": "date"},
+                "start_datetime": {"type": "date"},
+                "end_datetime": {"type": "date"},
+                "created": {"type": "date"},
+                "updated": {"type": "date"},
+                # Satellite Extension https://github.com/stac-extensions/sat
+                "sat:absolute_orbit": {"type": "integer"},
+                "sat:relative_orbit": {"type": "integer"},
+            },
+        },
+    },
+}
+
+ES_COLLECTIONS_MAPPINGS = {
+    "numeric_detection": False,
+    "dynamic_templates": ES_MAPPINGS_DYNAMIC_TEMPLATES,
+    "properties": {
+        "id": {"type": "keyword"},
+        "extent.spatial.bbox": {"type": "long"},
+        "extent.temporal.interval": {"type": "date"},
+        "providers": {"type": "object", "enabled": False},
+        "links": {"type": "object", "enabled": False},
+        "item_assets": {"type": "object", "enabled": False},
+    },
+}
+
+
+@lru_cache(256)
+def index_by_collection_id(collection_id: str) -> str:
+    """
+    Translate a collection id into an Elasticsearch index name.
+
+    Args:
+        collection_id (str): The collection id to translate into an index name.
+
+    Returns:
+        str: The index name derived from the collection id.
+    """
+    cleaned = collection_id.translate(_ES_INDEX_NAME_UNSUPPORTED_CHARS_TABLE)
+    return (
+        f"{ITEMS_INDEX_PREFIX}{cleaned.lower()}_{collection_id.encode('utf-8').hex()}"
+    )
+
+
+@lru_cache(256)
+def index_alias_by_collection_id(collection_id: str) -> str:
+    """
+    Translate a collection id into an Elasticsearch index alias.
+
+    Args:
+        collection_id (str): The collection id to translate into an index alias.
+
+    Returns:
+        str: The index alias derived from the collection id.
+    """
+    cleaned = collection_id.translate(_ES_INDEX_NAME_UNSUPPORTED_CHARS_TABLE)
+    return f"{ITEMS_INDEX_PREFIX}{cleaned}"
+
+
+def indices(collection_ids: Optional[List[str]]) -> str:
+    """
+    Get a comma-separated string of index names for a given list of collection ids.
+
+    Args:
+        collection_ids: A list of collection ids.
+
+    Returns:
+        A string of comma-separated index names. If `collection_ids` is empty, returns the default indices.
+    """
+    return (
+        ",".join(map(index_alias_by_collection_id, collection_ids))
+        if collection_ids
+        else ITEM_INDICES
+    )
+
+
+def mk_item_id(item_id: str, collection_id: str) -> str:
+    """Create the document id for an Item in Elasticsearch.
+
+    Args:
+        item_id (str): The id of the Item.
+        collection_id (str): The id of the Collection that the Item belongs to.
+
+    Returns:
+        str: The document id for the Item, combining the Item id and the Collection id, separated by a `|` character.
+    """
+    return f"{item_id}|{collection_id}"
+
+
+def mk_actions(collection_id: str, processed_items: List[Item]) -> List[Dict[str, Any]]:
+    """Create Elasticsearch bulk actions for a list of processed items.
+
+    Args:
+        collection_id (str): The identifier for the collection the items belong to.
+        processed_items (List[Item]): The list of processed items to be bulk indexed.
+
+    Returns:
+        List[Dict[str, Union[str, Dict]]]: The list of bulk actions to be executed,
+        each action being a dictionary with the following keys:
+        - `_index`: the index to store the document in.
+        - `_id`: the document's identifier.
+        - `_source`: the source of the document.
+    """
+    index_alias = index_alias_by_collection_id(collection_id)
+    return [
+        {
+            "_index": index_alias,
+            "_id": mk_item_id(item["id"], item["collection"]),
+            "_source": item,
+        }
+        for item in processed_items
+    ]

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi/core/extensions/aggregation.py

@@ -338,7 +338,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
         datetime: Optional[DateTimeType] = None,
         intersects: Optional[str] = None,
         filter_lang: Optional[str] = None,
-        filter: Optional[str] = None,
+        filter_expr: Optional[str] = None,
         aggregations: Optional[str] = None,
         ids: Optional[List[str]] = None,
         bbox: Optional[BBox] = None,
@@ -380,8 +380,8 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
             if datetime:
                 base_args["datetime"] = self._format_datetime_range(datetime)
 
-            if filter:
-                base_args["filter"] = self.get_filter(filter, filter_lang)
+            if filter_expr:
+                base_args["filter"] = self.get_filter(filter_expr, filter_lang)
             aggregate_request = EsAggregationExtensionPostRequest(**base_args)
         else:
             # Workaround for optional path param in POST requests
@@ -389,9 +389,9 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                 collection_id = path.split("/")[2]
 
             filter_lang = "cql2-json"
-            if aggregate_request.filter:
-                aggregate_request.filter = self.get_filter(
-                    aggregate_request.filter, filter_lang
+            if aggregate_request.filter_expr:
+                aggregate_request.filter_expr = self.get_filter(
+                    aggregate_request.filter_expr, filter_lang
                 )
 
         if collection_id:
@@ -465,10 +465,10 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                         detail=f"Aggregation {agg_name} not supported at catalog level",
                     )
 
-        if aggregate_request.filter:
+        if aggregate_request.filter_expr:
             try:
                 search = self.database.apply_cql2_filter(
-                    search, aggregate_request.filter
+                    search, aggregate_request.filter_expr
                 )
             except Exception as e:
                 raise HTTPException(

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi/core/extensions/query.py

@@ -8,7 +8,7 @@ import operator
 from dataclasses import dataclass
 from enum import auto
 from types import DynamicClassAttribute
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Callable, Dict, Optional
 
 from pydantic import BaseModel, root_validator
 from stac_pydantic.utils import AutoValueEnum
@@ -17,8 +17,6 @@ from stac_fastapi.extensions.core.query import QueryExtension as QueryExtensionB
 
 logger = logging.getLogger("uvicorn")
 logger.setLevel(logging.INFO)
-# Be careful: https://github.com/samuelcolvin/pydantic/issues/1423#issuecomment-642797287
-NumType = Union[float, int]
 
 
 class Operator(str, AutoValueEnum):

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi/core/models/links.py

@@ -12,7 +12,7 @@ from starlette.requests import Request
 
 # These can be inferred from the item/collection, so they aren't included in the database
 # Instead they are dynamically generated when querying the database using the classes defined below
-INFERRED_LINK_RELS = ["self", "item", "parent", "collection", "root"]
+INFERRED_LINK_RELS = {"self", "item", "parent", "collection", "root"}
 
 
 def merge_params(url: str, newparams: Dict) -> str:

stac_fastapi.core-4.0.0a0/stac_fastapi/core/version.py

@@ -0,0 +1,2 @@
+"""library version."""
+__version__ = "4.0.0a0"

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi.core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.core
-Version: 3.2.4
+Version: 4.0.0a0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT

{stac_fastapi.core-3.2.4 → stac_fastapi.core-4.0.0a0}/stac_fastapi.core.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ stac_fastapi/core/base_database_logic.py
 stac_fastapi/core/base_settings.py
 stac_fastapi/core/basic_auth.py
 stac_fastapi/core/core.py
+stac_fastapi/core/database_logic.py
 stac_fastapi/core/datetime_utils.py
 stac_fastapi/core/rate_limit.py
 stac_fastapi/core/route_dependencies.py

stac_fastapi.core-4.0.0a0/stac_fastapi.core.egg-info/requires.txt

@@ -0,0 +1,13 @@
+fastapi
+attrs>=23.2.0
+pydantic
+stac_pydantic==3.1.*
+stac-fastapi.api==5.1.1
+stac-fastapi.extensions==5.1.1
+stac-fastapi.types==5.1.1
+orjson
+overrides
+geojson-pydantic
+pygeofilter==0.3.1
+jsonschema
+slowapi==0.1.9

stac_fastapi.core-3.2.4/stac_fastapi/core/version.py

@@ -1,2 +0,0 @@
-"""library version."""
-__version__ = "3.2.4"

stac_fastapi.core-3.2.4/stac_fastapi.core.egg-info/requires.txt

@@ -1,13 +0,0 @@
-fastapi-slim
-attrs>=23.2.0
-pydantic
-stac_pydantic>=3
-stac-fastapi.types==3.0.0
-stac-fastapi.api==3.0.0
-stac-fastapi.extensions==3.0.0
-orjson
-overrides
-geojson-pydantic
-pygeofilter==0.3.1
-jsonschema
-slowapi==0.1.9