Merge branch 'main' into extend_datetime_search

Author: rhysrevans3

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### 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)

data_loader.py

@@ -22,12 +22,17 @@ def load_collection(base_url, collection_id, data_dir):
     collection["id"] = collection_id
     try:
         resp = requests.post(f"{base_url}/collections", json=collection)
-        if resp.status_code == 200:
+        if resp.status_code == 200 or resp.status_code == 201:
             click.echo(f"Status code: {resp.status_code}")
             click.echo(f"Added collection: {collection['id']}")
         elif resp.status_code == 409:
             click.echo(f"Status code: {resp.status_code}")
             click.echo(f"Collection: {collection['id']} already exists")
+        else:
+            click.echo(f"Status code: {resp.status_code}")
+            click.echo(
+                f"Error writing {collection['id']} collection. Message: {resp.text}"
+            )
     except requests.ConnectionError:
         click.secho("Failed to connect", fg="red", err=True)
 

sample_data/collection.json

@@ -1,6 +1,7 @@
 {
   "id":"sentinel-s2-l2a-cogs-test",
   "stac_version":"1.0.0",
+  "type": "Collection",
   "description":"Sentinel-2a and Sentinel-2b imagery, processed to Level 2A (Surface Reflectance) and converted to Cloud-Optimized GeoTIFFs",
   "links":[
       {"rel":"self","href":"https://earth-search.aws.element84.com/v0/collections/sentinel-s2-l2a-cogs"},

stac_fastapi/core/stac_fastapi/core/core.py

@@ -154,6 +154,19 @@ async def landing_page(self, **kwargs) -> stac_types.LandingPage:
             conformance_classes=self.conformance_classes(),
             extension_schemas=[],
         )
+
+        if self.extension_is_enabled("FilterExtension"):
+            landing_page["links"].append(
+                {
+                    # TODO: replace this with Relations.queryables.value,
+                    "rel": "queryables",
+                    # TODO: replace this with MimeTypes.jsonschema,
+                    "type": "application/schema+json",
+                    "title": "Queryables",
+                    "href": urljoin(base_url, "queryables"),
+                }
+            )
+
         collections = await self.all_collections(request=kwargs["request"])
         for collection in collections["collections"]:
             landing_page["links"].append(
@@ -206,7 +219,7 @@ async def all_collections(self, **kwargs) -> stac_types.Collections:
         token = request.query_params.get("token")
 
         collections, next_token = await self.database.get_all_collections(
-            token=token, limit=limit, base_url=base_url
+            token=token, limit=limit, request=request
         )
 
         links = [
@@ -240,10 +253,12 @@ async def get_collection(
         Raises:
             NotFoundError: If the collection with the given id cannot be found in the database.
         """
-        base_url = str(kwargs["request"].base_url)
+        request = kwargs["request"]
         collection = await self.database.find_collection(collection_id=collection_id)
         return self.collection_serializer.db_to_stac(
-            collection=collection, base_url=base_url
+            collection=collection,
+            request=request,
+            extensions=[type(ext).__name__ for ext in self.extensions],
         )
 
     async def item_collection(
@@ -749,12 +764,14 @@ async def create_collection(
             ConflictError: If the collection already exists.
         """
         collection = collection.model_dump(mode="json")
-        base_url = str(kwargs["request"].base_url)
-        collection = self.database.collection_serializer.stac_to_db(
-            collection, base_url
-        )
+        request = kwargs["request"]
+        collection = self.database.collection_serializer.stac_to_db(collection, request)
         await self.database.create_collection(collection=collection)
-        return CollectionSerializer.db_to_stac(collection, base_url)
+        return CollectionSerializer.db_to_stac(
+            collection,
+            request,
+            extensions=[type(ext).__name__ for ext in self.database.extensions],
+        )
 
     @overrides
     async def update_collection(
@@ -781,16 +798,18 @@ async def update_collection(
         """
         collection = collection.model_dump(mode="json")
 
-        base_url = str(kwargs["request"].base_url)
+        request = kwargs["request"]
 
-        collection = self.database.collection_serializer.stac_to_db(
-            collection, base_url
-        )
+        collection = self.database.collection_serializer.stac_to_db(collection, request)
         await self.database.update_collection(
             collection_id=collection_id, collection=collection
         )
 
-        return CollectionSerializer.db_to_stac(collection, base_url)
+        return CollectionSerializer.db_to_stac(
+            collection,
+            request,
+            extensions=[type(ext).__name__ for ext in self.database.extensions],
+        )
 
     @overrides
     async def delete_collection(

stac_fastapi/core/stac_fastapi/core/models/links.py

@@ -107,6 +107,39 @@ async def get_links(
         return links
 
 
+@attr.s
+class CollectionLinks(BaseLinks):
+    """Create inferred links specific to collections."""
+
+    collection_id: str = attr.ib()
+    extensions: List[str] = attr.ib(default=attr.Factory(list))
+
+    def link_parent(self) -> Dict[str, Any]:
+        """Create the `parent` link."""
+        return dict(rel=Relations.parent, type=MimeTypes.json.value, href=self.base_url)
+
+    def link_items(self) -> Dict[str, Any]:
+        """Create the `items` link."""
+        return dict(
+            rel="items",
+            type=MimeTypes.geojson.value,
+            href=urljoin(self.base_url, f"collections/{self.collection_id}/items"),
+        )
+
+    def link_queryables(self) -> Dict[str, Any]:
+        """Create the `queryables` link."""
+        if "FilterExtension" in self.extensions:
+            return dict(
+                rel="queryables",
+                type=MimeTypes.json.value,
+                href=urljoin(
+                    self.base_url, f"collections/{self.collection_id}/queryables"
+                ),
+            )
+        else:
+            return None
+
+
 @attr.s
 class PagingLinks(BaseLinks):
     """Create links for paging."""

stac_fastapi/core/stac_fastapi/core/serializers.py

@@ -1,13 +1,15 @@
 """Serializers."""
 import abc
 from copy import deepcopy
-from typing import Any
+from typing import Any, List, Optional
 
 import attr
+from starlette.requests import Request
 
 from stac_fastapi.core.datetime_utils import now_to_rfc3339_str
+from stac_fastapi.core.models.links import CollectionLinks
 from stac_fastapi.types import stac as stac_types
-from stac_fastapi.types.links import CollectionLinks, ItemLinks, resolve_links
+from stac_fastapi.types.links import ItemLinks, resolve_links
 
 
 @attr.s
@@ -109,29 +111,34 @@ class CollectionSerializer(Serializer):
 
     @classmethod
     def stac_to_db(
-        cls, collection: stac_types.Collection, base_url: str
+        cls, collection: stac_types.Collection, request: Request
     ) -> stac_types.Collection:
         """
         Transform STAC Collection to database-ready STAC collection.
 
         Args:
             stac_data: the STAC Collection object to be transformed
-            base_url: the base URL for the STAC API
+            starlette.requests.Request: the API request
 
         Returns:
             stac_types.Collection: The database-ready STAC Collection object.
         """
         collection = deepcopy(collection)
-        collection["links"] = resolve_links(collection.get("links", []), base_url)
+        collection["links"] = resolve_links(
+            collection.get("links", []), str(request.base_url)
+        )
         return collection
 
     @classmethod
-    def db_to_stac(cls, collection: dict, base_url: str) -> stac_types.Collection:
+    def db_to_stac(
+        cls, collection: dict, request: Request, extensions: Optional[List[str]] = []
+    ) -> stac_types.Collection:
         """Transform database model to STAC collection.
 
         Args:
             collection (dict): The collection data in dictionary form, extracted from the database.
-            base_url (str): The base URL for the collection.
+            starlette.requests.Request: the API request
+            extensions: A list of the extension class names (`ext.__name__`) or all enabled STAC API extensions.
 
         Returns:
             stac_types.Collection: The STAC collection object.
@@ -157,13 +164,13 @@ def db_to_stac(cls, collection: dict, base_url: str) -> stac_types.Collection:
 
         # Create the collection links using CollectionLinks
         collection_links = CollectionLinks(
-            collection_id=collection_id, base_url=base_url
+            collection_id=collection_id, request=request, extensions=extensions
         ).create_links()
 
         # Add any additional links from the collection dictionary
         original_links = collection.get("links")
         if original_links:
-            collection_links += resolve_links(original_links, base_url)
+            collection_links += resolve_links(original_links, str(request.base_url))
         collection["links"] = collection_links
 
         # Return the stac_types.Collection object

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/app.py

@@ -59,6 +59,8 @@
     filter_extension,
 ]
 
+database_logic.extensions = [type(ext).__name__ for ext in extensions]
+
 post_request_model = create_post_request_model(extensions)
 
 api = StacApi(

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/database_logic.py

@@ -7,6 +7,7 @@
 
 import attr
 from elasticsearch_dsl import Q, Search
+from starlette.requests import Request
 
 from elasticsearch import exceptions, helpers  # type: ignore
 from stac_fastapi.core.extensions import filter
@@ -312,10 +313,12 @@ class DatabaseLogic:
         default=CollectionSerializer
     )
 
+    extensions: List[str] = attr.ib(default=attr.Factory(list))
+
     """CORE LOGIC"""
 
     async def get_all_collections(
-        self, token: Optional[str], limit: int, base_url: str
+        self, token: Optional[str], limit: int, request: Request
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
         """Retrieve a list of all collections from Elasticsearch, supporting pagination.
 
@@ -342,7 +345,7 @@ async def get_all_collections(
         hits = response["hits"]["hits"]
         collections = [
             self.collection_serializer.db_to_stac(
-                collection=hit["_source"], base_url=base_url
+                collection=hit["_source"], request=request, extensions=self.extensions
             )
             for hit in hits
         ]

stac_fastapi/opensearch/stac_fastapi/opensearch/app.py

@@ -59,6 +59,8 @@
     filter_extension,
 ]
 
+database_logic.extensions = [type(ext).__name__ for ext in extensions]
+
 post_request_model = create_post_request_model(extensions)
 
 api = StacApi(

stac_fastapi/opensearch/stac_fastapi/opensearch/database_logic.py

@@ -11,6 +11,7 @@
 from opensearchpy.exceptions import TransportError
 from opensearchpy.helpers.query import Q
 from opensearchpy.helpers.search import Search
+from starlette.requests import Request
 
 from stac_fastapi.core import serializers
 from stac_fastapi.core.extensions import filter
@@ -334,10 +335,12 @@ class DatabaseLogic:
         default=serializers.CollectionSerializer
     )
 
+    extensions: List[str] = attr.ib(default=attr.Factory(list))
+
     """CORE LOGIC"""
 
     async def get_all_collections(
-        self, token: Optional[str], limit: int, base_url: str
+        self, token: Optional[str], limit: int, request: Request
     ) -> Tuple[List[Dict[str, Any]], Optional[str]]:
         """
         Retrieve a list of all collections from Opensearch, supporting pagination.
@@ -367,7 +370,7 @@ async def get_all_collections(
         hits = response["hits"]["hits"]
         collections = [
             self.collection_serializer.db_to_stac(
-                collection=hit["_source"], base_url=base_url
+                collection=hit["_source"], request=request, extensions=self.extensions
             )
             for hit in hits
         ]