Merge branch 'main' into extend_datetime_search

Author: rhysrevans3

.github/workflows/cicd.yml

@@ -1,4 +1,4 @@
-name: stac-fastapi-elasticsearch
+name: sfeos
 
 on:
   push:

CHANGELOG.md

@@ -7,17 +7,21 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [v3.0.0a2]
+
 ### Added
  - Queryables landing page and collection links when the Filter Extension is enabled [#267](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/267)
 
 ### Changed
 
 - Updated stac-fastapi libraries to v3.0.0a1 [#265](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/265)
+- Updated stac-fastapi libraries to v3.0.0a3 [#269](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/269)
 
 ### Fixed
 
 - API sort extension tests [#264](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/264)
 - Basic auth permission fix for checking route path instead of absolute path [#266](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/266)
+- Remove deprecated filter_fields property, return all properties as default [#269](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/pull/269)
 
 ## [v3.0.0a1]
 
@@ -217,7 +221,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Added db_to_stac serializer to item_collection method in core.py.
 
 
-[Unreleased]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v3.0.0a1...main>
+[Unreleased]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v3.0.0a2...main>
+[v3.0.0a2]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v3.0.0a1...v3.0.0a2>
 [v3.0.0a1]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v3.0.0a0...v3.0.0a1>
 [v3.0.0a0]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v2.4.1...v3.0.0a0>
 [v2.4.1]: <https://github.com/stac-utils/stac-fastapi-elasticsearch/tree/v2.4.0...v2.4.1>

docker-compose.basic_auth_protected.yml

@@ -11,7 +11,7 @@ services:
     environment:
       - STAC_FASTAPI_TITLE=stac-fastapi-elasticsearch
       - STAC_FASTAPI_DESCRIPTION=A STAC FastAPI with an Elasticsearch backend
-      - STAC_FASTAPI_VERSION=3.0.0a1
+      - STAC_FASTAPI_VERSION=3.0.0a2
       - APP_HOST=0.0.0.0
       - APP_PORT=8080
       - RELOAD=true

docker-compose.basic_auth_public.yml

@@ -11,7 +11,7 @@ services:
     environment:
       - STAC_FASTAPI_TITLE=stac-fastapi-elasticsearch
       - STAC_FASTAPI_DESCRIPTION=A STAC FastAPI with an Elasticsearch backend
-      - STAC_FASTAPI_VERSION=3.0.0a1
+      - STAC_FASTAPI_VERSION=3.0.0a2
       - APP_HOST=0.0.0.0
       - APP_PORT=8080
       - RELOAD=true

docker-compose.yml

@@ -43,7 +43,7 @@ services:
     environment:
       - STAC_FASTAPI_TITLE=stac-fastapi-opensearch
       - STAC_FASTAPI_DESCRIPTION=A STAC FastAPI with an Opensearch backend
-      - STAC_FASTAPI_VERSION=3.0.0a1
+      - STAC_FASTAPI_VERSION=3.0.0a2
       - APP_HOST=0.0.0.0
       - APP_PORT=8082
       - RELOAD=true

stac_fastapi/core/setup.py

@@ -10,9 +10,9 @@
     "attrs>=23.2.0",
     "pydantic[dotenv]",
     "stac_pydantic>=3",
-    "stac-fastapi.types==3.0.0a1",
-    "stac-fastapi.api==3.0.0a1",
-    "stac-fastapi.extensions==3.0.0a1",
+    "stac-fastapi.types==3.0.0a3",
+    "stac-fastapi.api==3.0.0a3",
+    "stac-fastapi.extensions==3.0.0a3",
     "orjson",
     "overrides",
     "geojson-pydantic",

stac_fastapi/core/stac_fastapi/core/core.py

@@ -10,7 +10,6 @@
 
 import attr
 import orjson
-import stac_pydantic
 from fastapi import HTTPException, Request
 from overrides import overrides
 from pydantic import ValidationError
@@ -26,19 +25,16 @@
 from stac_fastapi.core.models.links import PagingLinks
 from stac_fastapi.core.serializers import CollectionSerializer, ItemSerializer
 from stac_fastapi.core.session import Session
+from stac_fastapi.core.utilities import filter_fields
+from stac_fastapi.extensions.core.filter.client import AsyncBaseFiltersClient
 from stac_fastapi.extensions.third_party.bulk_transactions import (
     BaseBulkTransactionsClient,
     BulkTransactionMethod,
     Items,
 )
 from stac_fastapi.types import stac as stac_types
-from stac_fastapi.types.config import Settings
 from stac_fastapi.types.conformance import BASE_CONFORMANCE_CLASSES
-from stac_fastapi.types.core import (
-    AsyncBaseCoreClient,
-    AsyncBaseFiltersClient,
-    AsyncBaseTransactionsClient,
-)
+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
@@ -492,34 +488,26 @@ async def get_search(
             base_args["intersects"] = orjson.loads(unquote_plus(intersects))
 
         if sortby:
-            sort_param = []
-            for sort in sortby:
-                sort_param.append(
-                    {
-                        "field": sort[1:],
-                        "direction": "desc" if sort[0] == "-" else "asc",
-                    }
-                )
-            base_args["sortby"] = sort_param
+            base_args["sortby"] = [
+                {"field": sort[1:], "direction": "desc" if sort[0] == "-" else "asc"}
+                for sort in sortby
+            ]
 
         if filter:
-            if filter_lang == "cql2-json":
-                base_args["filter-lang"] = "cql2-json"
-                base_args["filter"] = orjson.loads(unquote_plus(filter))
-            else:
-                base_args["filter-lang"] = "cql2-json"
-                base_args["filter"] = orjson.loads(to_cql2(parse_cql2_text(filter)))
+            base_args["filter-lang"] = "cql2-json"
+            base_args["filter"] = orjson.loads(
+                unquote_plus(filter)
+                if filter_lang == "cql2-json"
+                else to_cql2(parse_cql2_text(filter))
+            )
 
         if fields:
-            includes = set()
-            excludes = set()
+            includes, excludes = set(), set()
             for field in fields:
                 if field[0] == "-":
                     excludes.add(field[1:])
-                elif field[0] == "+":
-                    includes.add(field[1:])
                 else:
-                    includes.add(field)
+                    includes.add(field[1:] if field[0] in "+ " else field)
             base_args["fields"] = {"include": includes, "exclude": excludes}
 
         # Do the request
@@ -615,32 +603,22 @@ async def post_search(
             collection_ids=search_request.collections,
         )
 
+        fields = (
+            getattr(search_request, "fields", None)
+            if self.extension_is_enabled("FieldsExtension")
+            else None
+        )
+        include: Set[str] = fields.include if fields and fields.include else set()
+        exclude: Set[str] = fields.exclude if fields and fields.exclude else set()
+
         items = [
-            self.item_serializer.db_to_stac(item, base_url=base_url) for item in items
+            filter_fields(
+                self.item_serializer.db_to_stac(item, base_url=base_url),
+                include,
+                exclude,
+            )
+            for item in items
         ]
-
-        if self.extension_is_enabled("FieldsExtension"):
-            if search_request.query is not None:
-                query_include: Set[str] = set(
-                    [
-                        k if k in Settings.get().indexed_fields else f"properties.{k}"
-                        for k in search_request.query.keys()
-                    ]
-                )
-                if not search_request.fields.include:
-                    search_request.fields.include = query_include
-                else:
-                    search_request.fields.include.union(query_include)
-
-            filter_kwargs = search_request.fields.filter_fields
-
-            items = [
-                orjson.loads(
-                    stac_pydantic.Item(**feat).json(**filter_kwargs, exclude_unset=True)
-                )
-                for feat in items
-            ]
-
         links = await PagingLinks(request=request, next=next_token).get_links()
 
         return stac_types.ItemCollection(

stac_fastapi/core/stac_fastapi/core/extensions/fields.py

@@ -0,0 +1,41 @@
+"""Fields extension."""
+
+from typing import Optional, Set
+
+from pydantic import BaseModel, Field
+
+from stac_fastapi.extensions.core import FieldsExtension as FieldsExtensionBase
+from stac_fastapi.extensions.core.fields import request
+
+
+class PostFieldsExtension(request.PostFieldsExtension):
+    """PostFieldsExtension."""
+
+    # Set defaults if needed
+    # include : Optional[Set[str]] = Field(
+    #    default_factory=lambda: {
+    #         "id",
+    #         "type",
+    #         "stac_version",
+    #         "geometry",
+    #         "bbox",
+    #         "links",
+    #         "assets",
+    #         "properties.datetime",
+    #         "collection",
+    #     }
+    # )
+    include: Optional[Set[str]] = set()
+    exclude: Optional[Set[str]] = set()
+
+
+class FieldsExtensionPostRequest(BaseModel):
+    """Additional fields and schema for the POST request."""
+
+    fields: Optional[PostFieldsExtension] = Field(PostFieldsExtension())
+
+
+class FieldsExtension(FieldsExtensionBase):
+    """Override the POST model."""
+
+    POST = FieldsExtensionPostRequest

stac_fastapi/core/stac_fastapi/core/utilities.py

@@ -3,7 +3,9 @@
 This module contains functions for transforming geospatial coordinates,
 such as converting bounding boxes to polygon representations.
 """
-from typing import List
+from typing import Any, Dict, List, Optional, Set, Union
+
+from stac_fastapi.types.stac import Item
 
 MAX_LIMIT = 10000
 
@@ -21,3 +23,113 @@ def bbox2polygon(b0: float, b1: float, b2: float, b3: float) -> List[List[List[f
         List[List[List[float]]]: A polygon represented as a list of lists of coordinates.
     """
     return [[[b0, b1], [b2, b1], [b2, b3], [b0, b3], [b0, b1]]]
+
+
+# copied from stac-fastapi-pgstac
+# https://github.com/stac-utils/stac-fastapi-pgstac/blob/26f6d918eb933a90833f30e69e21ba3b4e8a7151/stac_fastapi/pgstac/utils.py#L10-L116
+def filter_fields(  # noqa: C901
+    item: Union[Item, Dict[str, Any]],
+    include: Optional[Set[str]] = None,
+    exclude: Optional[Set[str]] = None,
+) -> Item:
+    """Preserve and remove fields as indicated by the fields extension include/exclude sets.
+
+    Returns a shallow copy of the Item with the fields filtered.
+
+    This will not perform a deep copy; values of the original item will be referenced
+    in the return item.
+    """
+    if not include and not exclude:
+        return item
+
+    # Build a shallow copy of included fields on an item, or a sub-tree of an item
+    def include_fields(
+        source: Dict[str, Any], fields: Optional[Set[str]]
+    ) -> Dict[str, Any]:
+        if not fields:
+            return source
+
+        clean_item: Dict[str, Any] = {}
+        for key_path in fields or []:
+            key_path_parts = key_path.split(".")
+            key_root = key_path_parts[0]
+            if key_root in source:
+                if isinstance(source[key_root], dict) and len(key_path_parts) > 1:
+                    # The root of this key path on the item is a dict, and the
+                    # key path indicates a sub-key to be included. Walk the dict
+                    # from the root key and get the full nested value to include.
+                    value = include_fields(
+                        source[key_root], fields={".".join(key_path_parts[1:])}
+                    )
+
+                    if isinstance(clean_item.get(key_root), dict):
+                        # A previously specified key and sub-keys may have been included
+                        # already, so do a deep merge update if the root key already exists.
+                        dict_deep_update(clean_item[key_root], value)
+                    else:
+                        # The root key does not exist, so add it. Fields
+                        # extension only allows nested referencing on dicts, so
+                        # this won't overwrite anything.
+                        clean_item[key_root] = value
+                else:
+                    # The item value to include is not a dict, or, it is a dict but the
+                    # key path is for the whole value, not a sub-key. Include the entire
+                    # value in the cleaned item.
+                    clean_item[key_root] = source[key_root]
+            else:
+                # The key, or root key of a multi-part key, is not present in the item,
+                # so it is ignored
+                pass
+        return clean_item
+
+    # For an item built up for included fields, remove excluded fields. This
+    # modifies `source` in place.
+    def exclude_fields(source: Dict[str, Any], fields: Optional[Set[str]]) -> None:
+        for key_path in fields or []:
+            key_path_part = key_path.split(".")
+            key_root = key_path_part[0]
+            if key_root in source:
+                if isinstance(source[key_root], dict) and len(key_path_part) > 1:
+                    # Walk the nested path of this key to remove the leaf-key
+                    exclude_fields(
+                        source[key_root], fields={".".join(key_path_part[1:])}
+                    )
+                    # If, after removing the leaf-key, the root is now an empty
+                    # dict, remove it entirely
+                    if not source[key_root]:
+                        del source[key_root]
+                else:
+                    # The key's value is not a dict, or there is no sub-key to remove. The
+                    # entire key can be removed from the source.
+                    source.pop(key_root, None)
+
+    # Coalesce incoming type to a dict
+    item = dict(item)
+
+    clean_item = include_fields(item, include)
+
+    # If, after including all the specified fields, there are no included properties,
+    # return just id and collection.
+    if not clean_item:
+        return Item({"id": item["id"], "collection": item["collection"]})
+
+    exclude_fields(clean_item, exclude)
+
+    return Item(**clean_item)
+
+
+def dict_deep_update(merge_to: Dict[str, Any], merge_from: Dict[str, Any]) -> None:
+    """Perform a deep update of two dicts.
+
+    merge_to is updated in-place with the values from merge_from.
+    merge_from values take precedence over existing values in merge_to.
+    """
+    for k, v in merge_from.items():
+        if (
+            k in merge_to
+            and isinstance(merge_to[k], dict)
+            and isinstance(merge_from[k], dict)
+        ):
+            dict_deep_update(merge_to[k], merge_from[k])
+        else:
+            merge_to[k] = v

stac_fastapi/core/stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "3.0.0a1"
+__version__ = "3.0.0a2"