stac-fastapi-core 6.7.5__py3-none-any.whl → 6.8.0__py3-none-any.whl

stac_fastapi/core/models/__init__.py

@@ -1 +1,27 @@
-"""stac_fastapi.elasticsearch.models module."""
+"""STAC models."""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class Catalog(BaseModel):
+    """STAC Catalog model."""
+
+    type: str = "Catalog"
+    stac_version: str
+    id: str
+    title: Optional[str] = None
+    description: Optional[str] = None
+    links: List[Dict[str, Any]]
+    stac_extensions: Optional[List[str]] = None
+
+
+class PartialCatalog(BaseModel):
+    """Partial STAC Catalog model for updates."""
+
+    id: str
+    title: Optional[str] = None
+    description: Optional[str] = None
+    links: Optional[List[Dict[str, Any]]] = None
+    stac_extensions: Optional[List[str]] = None

stac_fastapi/core/models/links.py

@@ -113,6 +113,7 @@ class CollectionLinks(BaseLinks):
 
     collection_id: str = attr.ib()
     extensions: List[str] = attr.ib(default=attr.Factory(list))
+    parent_url: Optional[str] = attr.ib(default=None, kw_only=True)
 
     def link_self(self) -> Dict:
         """Return the self link."""
@@ -123,8 +124,14 @@ class CollectionLinks(BaseLinks):
         )
 
     def link_parent(self) -> Dict[str, Any]:
-        """Create the `parent` link."""
-        return dict(rel=Relations.parent, type=MimeTypes.json.value, href=self.base_url)
+        """Create the `parent` link.
+
+        The parent link represents the structural parent (the path the user is traversing):
+        - If accessed via /catalogs/{id}/collections/{id}, parent is the catalog
+        - If accessed via /collections/{id}, parent is the root landing page
+        """
+        parent_href = self.parent_url if self.parent_url else self.base_url
+        return dict(rel=Relations.parent, type=MimeTypes.json.value, href=parent_href)
 
     def link_items(self) -> Dict[str, Any]:
         """Create the `items` link."""

stac_fastapi/core/queryables.py

@@ -0,0 +1,105 @@
+"""A module for managing queryable attributes."""
+
+import asyncio
+import os
+import time
+from typing import Any, Dict, List, Set
+
+from fastapi import HTTPException
+
+
+class QueryablesCache:
+    """A thread-safe, time-based cache for queryable properties."""
+
+    def __init__(self, database_logic: Any):
+        """
+        Initialize the QueryablesCache.
+
+        Args:
+            database_logic: An instance of a class with a `get_queryables_mapping` method.
+        """
+        self._db_logic = database_logic
+        self._cache: Dict[str, List[str]] = {}
+        self._all_queryables: Set[str] = set()
+        self._last_updated: float = 0
+        self._lock = asyncio.Lock()
+        self.validation_enabled: bool = False
+        self.cache_ttl: int = 1800  # How often to refresh cache (in seconds)
+        self.reload_settings()
+
+    def reload_settings(self):
+        """Reload settings from environment variables."""
+        self.validation_enabled = (
+            os.getenv("VALIDATE_QUERYABLES", "false").lower() == "true"
+        )
+        self.cache_ttl = int(os.getenv("QUERYABLES_CACHE_TTL", "1800"))
+
+    async def _update_cache(self):
+        """Update the cache with the latest queryables from the database."""
+        if not self.validation_enabled:
+            return
+
+        async with self._lock:
+            if (time.time() - self._last_updated < self.cache_ttl) and self._cache:
+                return
+
+            queryables_mapping = await self._db_logic.get_queryables_mapping()
+            all_queryables_set = set(queryables_mapping.keys())
+
+            self._all_queryables = all_queryables_set
+
+            self._cache = {"*": list(all_queryables_set)}
+            self._last_updated = time.time()
+
+    async def get_all_queryables(self) -> Set[str]:
+        """
+        Return a set of all queryable attributes across all collections.
+
+        This method will update the cache if it's stale or has been cleared.
+        """
+        if not self.validation_enabled:
+            return set()
+
+        if (time.time() - self._last_updated >= self.cache_ttl) or not self._cache:
+            await self._update_cache()
+        return self._all_queryables
+
+    async def validate(self, fields: Set[str]) -> None:
+        """
+        Validate if the provided fields are queryable.
+
+        Raises HTTPException if invalid fields are found.
+        """
+        if not self.validation_enabled:
+            return
+
+        allowed_fields = await self.get_all_queryables()
+        invalid_fields = fields - allowed_fields
+        if invalid_fields:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid query fields: {', '.join(sorted(invalid_fields))}. "
+                "These fields are not defined in the collection's queryables. "
+                "Use the /queryables endpoint to see available fields.",
+            )
+
+
+def get_properties_from_cql2_filter(cql2_filter: Dict[str, Any]) -> Set[str]:
+    """Recursively extract property names from a CQL2 filter.
+
+    Property names are normalized by stripping the 'properties.' prefix
+    if present, to match queryables stored without the prefix.
+    """
+    props: Set[str] = set()
+    if "op" in cql2_filter and "args" in cql2_filter:
+        for arg in cql2_filter["args"]:
+            if isinstance(arg, dict):
+                if "op" in arg:
+                    props.update(get_properties_from_cql2_filter(arg))
+                elif "property" in arg:
+                    prop_name = arg["property"]
+                    # Strip 'properties.' prefix if present
+                    if prop_name.startswith("properties."):
+                        prop_name = prop_name[11:]
+                    props.add(prop_name)
+    return props

stac_fastapi/core/serializers.py

@@ -10,6 +10,7 @@ import attr
 from starlette.requests import Request
 
 from stac_fastapi.core.datetime_utils import now_to_rfc3339_str
+from stac_fastapi.core.models import Catalog
 from stac_fastapi.core.models.links import CollectionLinks
 from stac_fastapi.core.utilities import get_bool_env, get_excluded_from_items
 from stac_fastapi.types import stac as stac_types
@@ -180,8 +181,9 @@ class CollectionSerializer(Serializer):
         # Avoid modifying the input dict in-place ... doing so breaks some tests
         collection = deepcopy(collection)
 
-        # Remove internal bbox_shape field (not part of STAC spec)
+        # Remove internal fields (not part of STAC spec)
         collection.pop("bbox_shape", None)
+        collection.pop("parent_ids", None)
 
         # Set defaults
         collection_id = collection.get("id")
@@ -208,6 +210,7 @@ class CollectionSerializer(Serializer):
         original_links = collection.get("links")
         if original_links:
             collection_links += resolve_links(original_links, str(request.base_url))
+
         collection["links"] = collection_links
 
         if get_bool_env("STAC_INDEX_ASSETS"):
@@ -225,3 +228,146 @@ class CollectionSerializer(Serializer):
 
         # Return the stac_types.Collection object
         return stac_types.Collection(**collection)
+
+    @classmethod
+    def db_to_stac_in_catalog(
+        cls,
+        collection: dict,
+        request: Request,
+        catalog_id: str,
+        extensions: Optional[List[str]] = [],
+    ) -> stac_types.Collection:
+        """Transform database model to STAC collection within a catalog context.
+
+        This method is used when a collection is accessed via /catalogs/{id}/collections/{id}.
+        It sets the structural parent to the catalog and injects a catalog link.
+
+        Args:
+            collection (dict): The collection data in dictionary form, extracted from the database.
+            request: the API request
+            catalog_id: The ID of the parent catalog (sets structural parent)
+            extensions: A list of the extension class names (`ext.__name__`) or all enabled STAC API extensions.
+
+        Returns:
+            stac_types.Collection: The STAC collection object with catalog context.
+        """
+        # Avoid modifying the input dict in-place
+        collection = deepcopy(collection)
+
+        # Remove internal fields (not part of STAC spec)
+        collection.pop("bbox_shape", None)
+
+        # Set defaults
+        collection_id = collection.get("id")
+        collection.setdefault("type", "Collection")
+        collection.setdefault("stac_extensions", [])
+        collection.setdefault("stac_version", "")
+        collection.setdefault("title", "")
+        collection.setdefault("description", "")
+        collection.setdefault("keywords", [])
+        collection.setdefault("license", "")
+        collection.setdefault("providers", [])
+        collection.setdefault("summaries", {})
+        collection.setdefault(
+            "extent", {"spatial": {"bbox": []}, "temporal": {"interval": []}}
+        )
+        collection.setdefault("assets", {})
+
+        # Determine the structural parent URL
+        # When accessed via /catalogs/{id}/collections/{id}, the parent is the catalog
+        base_url = str(request.base_url)
+        parent_url = f"{base_url}catalogs/{catalog_id}"
+
+        # Create the collection links using CollectionLinks with catalog as parent
+        collection_links = CollectionLinks(
+            collection_id=collection_id,
+            request=request,
+            extensions=extensions,
+            parent_url=parent_url,
+        ).create_links()
+
+        # Add any additional links from the collection dictionary
+        original_links = collection.get("links")
+        if original_links:
+            collection_links += resolve_links(original_links, str(request.base_url))
+
+        # Inject catalog link for consistency (same as parent in this context)
+        catalog_link = {
+            "rel": "catalog",
+            "type": "application/json",
+            "href": parent_url,
+            "title": catalog_id,
+        }
+        collection_links.append(catalog_link)
+
+        collection["links"] = collection_links
+
+        if get_bool_env("STAC_INDEX_ASSETS"):
+            collection["assets"] = {
+                a.pop("es_key"): a for a in collection.get("assets", [])
+            }
+            collection["item_assets"] = {
+                i.pop("es_key"): i for i in collection.get("item_assets", [])
+            }
+
+        else:
+            collection["assets"] = collection.get("assets", {})
+            if item_assets := collection.get("item_assets"):
+                collection["item_assets"] = item_assets
+
+        # Return the stac_types.Collection object
+        return stac_types.Collection(**collection)
+
+
+class CatalogSerializer(Serializer):
+    """Serialization methods for STAC catalogs."""
+
+    @classmethod
+    def stac_to_db(cls, catalog: Catalog, request: Request) -> Catalog:
+        """
+        Transform STAC Catalog to database-ready STAC catalog.
+
+        Args:
+            catalog: the STAC Catalog object to be transformed
+            request: the API request
+
+        Returns:
+            Catalog: The database-ready STAC Catalog object.
+        """
+        catalog = deepcopy(catalog)
+        catalog.links = resolve_links(catalog.links, str(request.base_url))
+        return catalog
+
+    @classmethod
+    def db_to_stac(
+        cls, catalog: dict, request: Request, extensions: Optional[List[str]] = []
+    ) -> Catalog:
+        """Transform database model to STAC catalog.
+
+        Args:
+            catalog (dict): The catalog data in dictionary form, extracted from the database.
+            request (Request): the API request
+            extensions: A list of the extension class names (`ext.__name__`) or all enabled STAC API extensions.
+
+        Returns:
+            Catalog: The STAC catalog object.
+        """
+        # Avoid modifying the input dict in-place
+        catalog = deepcopy(catalog)
+
+        # Set defaults
+        catalog.setdefault("type", "Catalog")
+        catalog.setdefault("stac_extensions", [])
+        catalog.setdefault("stac_version", "")
+        catalog.setdefault("title", "")
+        catalog.setdefault("description", "")
+
+        # Create the catalog links - for now, just resolve existing links
+        original_links = catalog.get("links", [])
+        if original_links:
+            catalog["links"] = resolve_links(original_links, str(request.base_url))
+        else:
+            catalog["links"] = []
+
+        # Return the Catalog object
+        return Catalog(**catalog)

stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "6.7.5"
+__version__ = "6.8.0"

{stac_fastapi_core-6.7.5.dist-info → stac_fastapi_core-6.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.7.5
+Version: 6.8.0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
   [![GitHub forks](https://img.shields.io/github/forks/stac-utils/stac-fastapi-elasticsearch-opensearch.svg?color=blue)](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/network/members)
    [![PyPI version](https://img.shields.io/pypi/v/stac-fastapi-elasticsearch.svg?color=blue)](https://pypi.org/project/stac-fastapi-elasticsearch/)
   [![STAC](https://img.shields.io/badge/STAC-1.1.0-blue.svg)](https://github.com/radiantearth/stac-spec/tree/v1.1.0)
-  [![stac-fastapi](https://img.shields.io/badge/stac--fastapi-6.0.0-blue.svg)](https://github.com/stac-utils/stac-fastapi)
+  [![stac-fastapi](https://img.shields.io/badge/stac--fastapi-6.1.1-blue.svg)](https://github.com/stac-utils/stac-fastapi)
 
 Core functionality for stac-fastapi. For full documentation, please see the [main README](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/blob/main/README.md).
 

{stac_fastapi_core-6.7.5.dist-info → stac_fastapi_core-6.8.0.dist-info}/RECORD

@@ -1,25 +1,27 @@
 stac_fastapi/core/__init__.py,sha256=8izV3IWRGdXmDOK1hIPQAanbWs9EI04PJCGgqG1ZGIs,20
-stac_fastapi/core/base_database_logic.py,sha256=3_XJ_j06ogQHE-Tcjkv5Vye_zNDn9OEU9lNYU03am1k,4618
+stac_fastapi/core/base_database_logic.py,sha256=JL7DRcDdqeaLbSPPGcIUMs7q6I3Gm_E5XCOwFG458Io,6053
 stac_fastapi/core/base_settings.py,sha256=R3_Sx7n5XpGMs3zAwFJD7y008WvGU_uI2xkaabm82Kg,239
 stac_fastapi/core/basic_auth.py,sha256=RhFv3RVSHF6OaqnaaU2DO4ncJ_S5nB1q8UNpnVJJsrk,2155
-stac_fastapi/core/core.py,sha256=mmUP1da46EiON_TM2HYtxQxw8DHFg-2xEFoSg4P7UgU,50607
-stac_fastapi/core/datetime_utils.py,sha256=uhKZVfvsp6Y92__IB6HWn7C6VQU12DMeGuNg-78cb8Y,4534
+stac_fastapi/core/core.py,sha256=QvwZbXi5PssZXBXxyggLsYHfvzj57NidloI4uVXenzM,52238
+stac_fastapi/core/datetime_utils.py,sha256=QygF2mJFfI_zqCwmSIec3HYqrsVsn3nUcaRQx3CD7Zw,4683
+stac_fastapi/core/queryables.py,sha256=0gKdxlmCVaIj3ODpmyIfzLChEB1nNKXPZhA3K9ApfL0,3755
 stac_fastapi/core/rate_limit.py,sha256=Gu8dAaJReGsj1L91U6m2tflU6RahpXDRs2-AYSKoybA,1318
 stac_fastapi/core/redis_utils.py,sha256=6_lrXfZBi6vCCCibLDdwwHC3lLaXYTEmqQpxOMaCUH4,9689
 stac_fastapi/core/route_dependencies.py,sha256=hdtuMkv-zY1vg0YxiCz1aKP0SbBcORqDGEKDGgEazW8,5482
-stac_fastapi/core/serializers.py,sha256=HPA110RLZ17EnKrFf1rvVu5EwQHZto4V912Ofp_ypjA,7951
+stac_fastapi/core/serializers.py,sha256=l5EWZvlGjlfsZ3S4wHjWKD8sJBf83zd2dkursu18fV4,13345
 stac_fastapi/core/session.py,sha256=aXqu4LXfVbAAsChMVXd9gAhczA2bZPne6HqPeklAwMY,474
 stac_fastapi/core/utilities.py,sha256=XR_9afK_j8wCydgoXj-CMtRyI8KqgIL3d4HZOE779dU,7807
-stac_fastapi/core/version.py,sha256=WRUWk2u8pozjztw-4p6a3fAkitIN0nGhe4tLZ6P6xUk,45
-stac_fastapi/core/extensions/__init__.py,sha256=zSIAqou8jnakWPbkh4Ddcx1-oazZVBOs7U2PAakAdU0,291
+stac_fastapi/core/version.py,sha256=ib-H9zXMsXhMlZkHut5gkqf27FPYcv0_wBkKUIXnJbA,45
+stac_fastapi/core/extensions/__init__.py,sha256=oaK-UJDQSEISdQ8VtM0ESxpsv7Hx1HbAdmMnh6MTFD4,356
 stac_fastapi/core/extensions/aggregation.py,sha256=v1hUHqlYuMqfQ554g3cTp16pUyRYucQxPERbHPAFtf8,1878
+stac_fastapi/core/extensions/catalogs.py,sha256=s6yrubil90fCrav5Xgg0bUiEeq7dTU6EPC3SBy055fQ,38935
 stac_fastapi/core/extensions/collections_search.py,sha256=xpv51nffMq5a8grNSaLbv2IzeI5JH_pqcoWRbWhzn6Y,14406
 stac_fastapi/core/extensions/fields.py,sha256=NCT5XHvfaf297eDPNaIFsIzvJnbbUTpScqF0otdx0NA,1066
 stac_fastapi/core/extensions/filter.py,sha256=-NQGME7rR_ereuDx-LAa1M5JhEXFaKiTtkH2asraYHE,2998
 stac_fastapi/core/extensions/query.py,sha256=Xmo8pfZEZKPudZEjjozv3R0wLOP0ayjC9E67sBOXqWY,1803
-stac_fastapi/core/models/__init__.py,sha256=g-D1DiGfmC9Bg27DW9JzkN6fAvscv75wyhyiZ6NzvIk,48
-stac_fastapi/core/models/links.py,sha256=0dWSEMt3aa7NCISlHwo11zLBeIV1LwXG3JGjrXC3dZI,6672
+stac_fastapi/core/models/__init__.py,sha256=sUsEB7umGZVYXjT4EHqLwm8p2wevtRBdig2Ioj2ZdVQ,631
+stac_fastapi/core/models/links.py,sha256=5KEZKisFN34U4UuOzSQnDy0QdsUOT2VRuuY36vs-FGw,7074
 stac_fastapi/core/models/search.py,sha256=7SgAUyzHGXBXSqB4G6cwq9FMwoAS00momb7jvBkjyow,27
-stac_fastapi_core-6.7.5.dist-info/METADATA,sha256=i2ek_1Z3c6aC7j9G3Atn2bHzZket_Q8Kc5peUi-wvj0,3480
-stac_fastapi_core-6.7.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-stac_fastapi_core-6.7.5.dist-info/RECORD,,
+stac_fastapi_core-6.8.0.dist-info/METADATA,sha256=OTeCtPe2s5cQCqoACfM5bddnUvL92ux6tU_jks6q5EU,3480
+stac_fastapi_core-6.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+stac_fastapi_core-6.8.0.dist-info/RECORD,,

{stac_fastapi_core-6.7.5.dist-info → stac_fastapi_core-6.8.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any