stac-fastapi.core 2.1.0__tar.gz → 2.3.1__tar.gz

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.core
-Version: 2.1.0
+Version: 2.3.1
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -18,13 +18,14 @@ Requires-Dist: fastapi
 Requires-Dist: attrs
 Requires-Dist: pydantic[dotenv]<2
 Requires-Dist: stac_pydantic==2.0.*
-Requires-Dist: stac-fastapi.types==2.4.9
-Requires-Dist: stac-fastapi.api==2.4.9
-Requires-Dist: stac-fastapi.extensions==2.4.9
+Requires-Dist: stac-fastapi.types==2.5.5.post1
+Requires-Dist: stac-fastapi.api==2.5.5.post1
+Requires-Dist: stac-fastapi.extensions==2.5.5.post1
 Requires-Dist: pystac[validation]
 Requires-Dist: orjson
 Requires-Dist: overrides
 Requires-Dist: geojson-pydantic
 Requires-Dist: pygeofilter==0.2.1
+Requires-Dist: typing_extensions==4.4.0
 
 # stac-fastapi core library for Elasticsearch and Opensearch backends

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/setup.py

@@ -10,14 +10,15 @@ install_requires = [
     "attrs",
     "pydantic[dotenv]<2",
     "stac_pydantic==2.0.*",
-    "stac-fastapi.types==2.4.9",
-    "stac-fastapi.api==2.4.9",
-    "stac-fastapi.extensions==2.4.9",
+    "stac-fastapi.types==2.5.5.post1",
+    "stac-fastapi.api==2.5.5.post1",
+    "stac-fastapi.extensions==2.5.5.post1",
     "pystac[validation]",
     "orjson",
     "overrides",
     "geojson-pydantic",
     "pygeofilter==0.2.1",
+    "typing_extensions==4.4.0",
 ]
 
 setup(

stac_fastapi_core-2.3.1/stac_fastapi/core/basic_auth.py

@@ -0,0 +1,115 @@
+"""Basic Authentication Module."""
+
+import json
+import logging
+import os
+import secrets
+from typing import Any, Dict
+
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.routing import APIRoute
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from typing_extensions import Annotated
+
+from stac_fastapi.api.app import StacApi
+
+_LOGGER = logging.getLogger("uvicorn.default")
+_SECURITY = HTTPBasic()
+_BASIC_AUTH: Dict[str, Any] = {}
+
+
+def has_access(
+    request: Request, credentials: Annotated[HTTPBasicCredentials, Depends(_SECURITY)]
+) -> str:
+    """Check if the provided credentials match the expected \
+        username and password stored in environment variables for basic authentication.
+
+    Args:
+        request (Request): The FastAPI request object.
+        credentials (HTTPBasicCredentials): The HTTP basic authentication credentials.
+
+    Returns:
+        str: The username if authentication is successful.
+
+    Raises:
+        HTTPException: If authentication fails due to incorrect username or password.
+    """
+    global _BASIC_AUTH
+
+    users = _BASIC_AUTH.get("users")
+    user: Dict[str, Any] = next(
+        (u for u in users if u.get("username") == credentials.username), {}
+    )
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+
+    # Compare the provided username and password with the correct ones using compare_digest
+    if not secrets.compare_digest(
+        credentials.username.encode("utf-8"), user.get("username").encode("utf-8")
+    ) or not secrets.compare_digest(
+        credentials.password.encode("utf-8"), user.get("password").encode("utf-8")
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+
+    permissions = user.get("permissions", [])
+    path = request.url.path
+    method = request.method
+
+    if permissions == "*":
+        return credentials.username
+    for permission in permissions:
+        if permission["path"] == path and method in permission.get("method", []):
+            return credentials.username
+
+    raise HTTPException(
+        status_code=status.HTTP_403_FORBIDDEN,
+        detail=f"Insufficient permissions for [{method} {path}]",
+    )
+
+
+def apply_basic_auth(api: StacApi) -> None:
+    """Apply basic authentication to the provided FastAPI application \
+        based on environment variables for username, password, and endpoints.
+
+    Args:
+        api (StacApi): The FastAPI application.
+
+    Raises:
+        HTTPException: If there are issues with the configuration or format
+                       of the environment variables.
+    """
+    global _BASIC_AUTH
+
+    basic_auth_json_str = os.environ.get("BASIC_AUTH")
+    if not basic_auth_json_str:
+        _LOGGER.info("Basic authentication disabled.")
+        return
+
+    try:
+        _BASIC_AUTH = json.loads(basic_auth_json_str)
+    except json.JSONDecodeError as exception:
+        _LOGGER.error(f"Invalid JSON format for BASIC_AUTH. {exception=}")
+        raise
+    public_endpoints = _BASIC_AUTH.get("public_endpoints", [])
+    users = _BASIC_AUTH.get("users")
+    if not users:
+        raise Exception("Invalid JSON format for BASIC_AUTH. Key 'users' undefined.")
+
+    app = api.app
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            for method in route.methods:
+                endpoint = {"path": route.path, "method": method}
+                if endpoint not in public_endpoints:
+                    api.add_route_dependencies([endpoint], [Depends(has_access)])
+
+    _LOGGER.info("Basic authentication enabled.")

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi/core/core.py

@@ -1,4 +1,4 @@
-"""Item crud client."""
+"""Core client."""
 import logging
 import re
 from datetime import datetime as datetime_type
@@ -15,7 +15,7 @@ from pydantic import ValidationError
 from pygeofilter.backends.cql2_json import to_cql2
 from pygeofilter.parsers.cql2_text import parse as parse_cql2_text
 from stac_pydantic.links import Relations
-from stac_pydantic.shared import MimeTypes
+from stac_pydantic.shared import BBox, MimeTypes
 from stac_pydantic.version import STAC_VERSION
 
 from stac_fastapi.core.base_database_logic import BaseDatabaseLogic
@@ -37,8 +37,8 @@ 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.extension import ApiExtension
-from stac_fastapi.types.links import CollectionLinks
 from stac_fastapi.types.requests import get_base_url
+from stac_fastapi.types.rfc3339 import DateTimeType
 from stac_fastapi.types.search import BaseSearchPostRequest
 from stac_fastapi.types.stac import Collection, Collections, Item, ItemCollection
 
@@ -245,8 +245,8 @@ class CoreClient(AsyncBaseCoreClient):
     async def item_collection(
         self,
         collection_id: str,
-        bbox: Optional[List[NumType]] = None,
-        datetime: Union[str, datetime_type, None] = None,
+        bbox: Optional[BBox] = None,
+        datetime: Optional[DateTimeType] = None,
         limit: int = 10,
         token: str = None,
         **kwargs,
@@ -255,8 +255,8 @@ class CoreClient(AsyncBaseCoreClient):
 
         Args:
             collection_id (str): The identifier of the collection to read items from.
-            bbox (Optional[List[NumType]]): The bounding box to filter items by.
-            datetime (Union[str, datetime_type, None]): The datetime range to filter items by.
+            bbox (Optional[BBox]): The bounding box to filter items by.
+            datetime (Optional[DateTimeType]): 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.
@@ -350,53 +350,64 @@ class CoreClient(AsyncBaseCoreClient):
         return self.item_serializer.db_to_stac(item, base_url)
 
     @staticmethod
-    def _return_date(interval_str):
+    def _return_date(
+        interval: Optional[Union[DateTimeType, str]]
+    ) -> Dict[str, Optional[str]]:
         """
-        Convert a date interval string into a dictionary for filtering search results.
+        Convert a date interval.
 
-        The date interval string should be formatted as either a single date or a range of dates separated
-        by "/". The date format should be ISO-8601 (YYYY-MM-DDTHH:MM:SSZ). If the interval string is a
-        single date, it will be converted to a dictionary with a single "eq" key whose value is the date in
-        the ISO-8601 format. If the interval string is a range of dates, it will be converted to a
-        dictionary with "gte" (greater than or equal to) and "lte" (less than or equal to) keys. If the
-        interval string is a range of dates with ".." instead of "/", the start and end dates will be
-        assigned default values to encompass the entire possible date range.
+        (which may be a datetime, a tuple of one or two datetimes a string
+        representing a datetime or range, or None) into a dictionary for filtering
+        search results with Elasticsearch.
+
+        This function ensures the output dictionary contains 'gte' and 'lte' keys,
+        even if they are set to None, to prevent KeyError in the consuming logic.
 
         Args:
-            interval_str (str): The date interval string to be converted.
+            interval (Optional[Union[DateTimeType, str]]): The date interval, which might be a single datetime,
+                a tuple with one or two datetimes, a string, or None.
 
         Returns:
-            dict: A dictionary representing the date interval for use in filtering search results.
+            dict: A dictionary representing the date interval for use in filtering search results,
+                always containing 'gte' and 'lte' keys.
         """
-        intervals = interval_str.split("/")
-        if len(intervals) == 1:
-            datetime = f"{intervals[0][0:19]}Z"
-            return {"eq": datetime}
-        else:
-            start_date = intervals[0]
-            end_date = intervals[1]
-            if ".." not in intervals:
-                start_date = f"{start_date[0:19]}Z"
-                end_date = f"{end_date[0:19]}Z"
-            elif start_date != "..":
-                start_date = f"{start_date[0:19]}Z"
-                end_date = "2200-12-01T12:31:12Z"
-            elif end_date != "..":
-                start_date = "1900-10-01T00:00:00Z"
-                end_date = f"{end_date[0:19]}Z"
-            else:
-                start_date = "1900-10-01T00:00:00Z"
-                end_date = "2200-12-01T12:31:12Z"
+        result: Dict[str, Optional[str]] = {"gte": None, "lte": None}
 
-        return {"lte": end_date, "gte": start_date}
+        if interval is None:
+            return result
+
+        if isinstance(interval, str):
+            if "/" in interval:
+                parts = interval.split("/")
+                result["gte"] = parts[0] if parts[0] != ".." else None
+                result["lte"] = (
+                    parts[1] if len(parts) > 1 and parts[1] != ".." else None
+                )
+            else:
+                converted_time = interval if interval != ".." else None
+                result["gte"] = result["lte"] = converted_time
+            return result
+
+        if isinstance(interval, datetime_type):
+            datetime_iso = interval.isoformat()
+            result["gte"] = result["lte"] = datetime_iso
+        elif isinstance(interval, tuple):
+            start, end = interval
+            # Ensure datetimes are converted to UTC and formatted with 'Z'
+            if start:
+                result["gte"] = start.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+            if end:
+                result["lte"] = end.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+        return result
 
     async def get_search(
         self,
         request: Request,
         collections: Optional[List[str]] = None,
         ids: Optional[List[str]] = None,
-        bbox: Optional[List[NumType]] = None,
-        datetime: Optional[Union[str, datetime_type]] = None,
+        bbox: Optional[BBox] = None,
+        datetime: Optional[DateTimeType] = None,
         limit: Optional[int] = 10,
         query: Optional[str] = None,
         token: Optional[str] = None,
@@ -412,8 +423,8 @@ class CoreClient(AsyncBaseCoreClient):
         Args:
             collections (Optional[List[str]]): List of collection IDs to search in.
             ids (Optional[List[str]]): List of item IDs to search for.
-            bbox (Optional[List[NumType]]): Bounding box to search in.
-            datetime (Optional[Union[str, datetime_type]]): Filter items based on the datetime field.
+            bbox (Optional[BBox]): Bounding box to search in.
+            datetime (Optional[DateTimeType]): 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.
@@ -460,7 +471,6 @@ class CoreClient(AsyncBaseCoreClient):
                         "direction": "desc" if sort[0] == "-" else "asc",
                     }
                 )
-            print(sort_param)
             base_args["sortby"] = sort_param
 
         if filter:
@@ -667,7 +677,7 @@ class TransactionsClient(AsyncBaseTransactionsClient):
         else:
             item = await self.database.prep_create_item(item=item, base_url=base_url)
             await self.database.create_item(item, refresh=kwargs.get("refresh", False))
-            return item
+            return ItemSerializer.db_to_stac(item, base_url)
 
     @overrides
     async def update_item(
@@ -731,10 +741,9 @@ class TransactionsClient(AsyncBaseTransactionsClient):
             ConflictError: If the collection already exists.
         """
         base_url = str(kwargs["request"].base_url)
-        collection_links = CollectionLinks(
-            collection_id=collection["id"], base_url=base_url
-        ).create_links()
-        collection["links"] = collection_links
+        collection = self.database.collection_serializer.stac_to_db(
+            collection, base_url
+        )
         await self.database.create_collection(collection=collection)
 
         return CollectionSerializer.db_to_stac(collection, base_url)
@@ -767,11 +776,9 @@ class TransactionsClient(AsyncBaseTransactionsClient):
             "collection_id", collection["id"]
         )
 
-        collection_links = CollectionLinks(
-            collection_id=collection["id"], base_url=base_url
-        ).create_links()
-        collection["links"] = collection_links
-
+        collection = self.database.collection_serializer.stac_to_db(
+            collection, base_url
+        )
         await self.database.update_collection(
             collection_id=collection_id, collection=collection
         )

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi/core/models/links.py

@@ -1,7 +1,7 @@
 """link helpers."""
 
 from typing import Any, Dict, List, Optional
-from urllib.parse import ParseResult, parse_qs, unquote, urlencode, urljoin, urlparse
+from urllib.parse import ParseResult, parse_qs, urlencode, urljoin, urlparse
 
 import attr
 from stac_pydantic.links import Relations
@@ -20,7 +20,7 @@ def merge_params(url: str, newparams: Dict) -> str:
     u = urlparse(url)
     params = parse_qs(u.query)
     params.update(newparams)
-    param_string = unquote(urlencode(params, True))
+    param_string = urlencode(params, True)
 
     href = ParseResult(
         scheme=u.scheme,

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi/core/serializers.py

@@ -60,11 +60,7 @@ class ItemSerializer(Serializer):
         Returns:
             stac_types.Item: The database-ready STAC item object.
         """
-        item_links = ItemLinks(
-            collection_id=stac_data["collection"],
-            item_id=stac_data["id"],
-            base_url=base_url,
-        ).create_links()
+        item_links = resolve_links(stac_data.get("links", []), base_url)
         stac_data["links"] = item_links
 
         now = now_to_rfc3339_str()
@@ -111,6 +107,24 @@ class ItemSerializer(Serializer):
 class CollectionSerializer(Serializer):
     """Serialization methods for STAC collections."""
 
+    @classmethod
+    def stac_to_db(
+        cls, collection: stac_types.Collection, base_url: str
+    ) -> 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
+
+        Returns:
+            stac_types.Collection: The database-ready STAC Collection object.
+        """
+        collection = deepcopy(collection)
+        collection["links"] = resolve_links(collection.get("links", []), base_url)
+        return collection
+
     @classmethod
     def db_to_stac(cls, collection: dict, base_url: str) -> stac_types.Collection:
         """Transform database model to STAC collection.

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi/core/types/core.py

@@ -1,4 +1,4 @@
-"""Base clients. Takef from stac-fastapi.types.core v2.4.9."""
+"""Base clients. Taken from stac-fastapi.types.core v2.4.9."""
 import abc
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "2.1.0"
+__version__ = "2.3.1"

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi.core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.core
-Version: 2.1.0
+Version: 2.3.1
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -18,13 +18,14 @@ Requires-Dist: fastapi
 Requires-Dist: attrs
 Requires-Dist: pydantic[dotenv]<2
 Requires-Dist: stac_pydantic==2.0.*
-Requires-Dist: stac-fastapi.types==2.4.9
-Requires-Dist: stac-fastapi.api==2.4.9
-Requires-Dist: stac-fastapi.extensions==2.4.9
+Requires-Dist: stac-fastapi.types==2.5.5.post1
+Requires-Dist: stac-fastapi.api==2.5.5.post1
+Requires-Dist: stac-fastapi.extensions==2.5.5.post1
 Requires-Dist: pystac[validation]
 Requires-Dist: orjson
 Requires-Dist: overrides
 Requires-Dist: geojson-pydantic
 Requires-Dist: pygeofilter==0.2.1
+Requires-Dist: typing_extensions==4.4.0
 
 # stac-fastapi core library for Elasticsearch and Opensearch backends

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi.core.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ stac_fastapi.core.egg-info/top_level.txt
 stac_fastapi/core/__init__.py
 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/datetime_utils.py
 stac_fastapi/core/serializers.py

{stac-fastapi.core-2.1.0 → stac_fastapi_core-2.3.1}/stac_fastapi.core.egg-info/requires.txt

@@ -2,11 +2,12 @@ fastapi
 attrs
 pydantic[dotenv]<2
 stac_pydantic==2.0.*
-stac-fastapi.types==2.4.9
-stac-fastapi.api==2.4.9
-stac-fastapi.extensions==2.4.9
+stac-fastapi.types==2.5.5.post1
+stac-fastapi.api==2.5.5.post1
+stac-fastapi.extensions==2.5.5.post1
 pystac[validation]
 orjson
 overrides
 geojson-pydantic
 pygeofilter==0.2.1
+typing_extensions==4.4.0