stac-fastapi.api 6.2.1__tar.gz → 6.3.1__tar.gz

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac-fastapi-api
-Version: 6.2.1
+Version: 6.3.1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi
 Author-email: ArturoAI <engineering@arturo.ai>

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/app.py

@@ -1,8 +1,7 @@
 """Fastapi app creation."""
 
-
 import inspect
-from typing import Awaitable, Callable, Dict, List, Optional, Tuple, Type, Union
+from collections.abc import Awaitable, Callable
 
 import attr
 from brotli_asgi import BrotliMiddleware
@@ -79,9 +78,9 @@ class StacApi:
     """
 
     settings: ApiSettings = attr.ib()
-    client: Union[AsyncBaseCoreClient, BaseCoreClient] = attr.ib()
-    extensions: List[ApiExtension] = attr.ib(default=attr.Factory(list))
-    exceptions: Dict[Type[Exception], int] = attr.ib(
+    client: AsyncBaseCoreClient | BaseCoreClient = attr.ib()
+    extensions: list[ApiExtension] = attr.ib(default=attr.Factory(list))
+    exceptions: dict[type[Exception], int] = attr.ib(
         default=attr.Factory(lambda: DEFAULT_STATUS_CODES)
     )
     title: str = attr.ib(
@@ -116,14 +115,14 @@ class StacApi:
         converter=update_openapi,  # type: ignore
     )
     router: APIRouter = attr.ib(default=attr.Factory(APIRouter))
-    search_get_request_model: Type[APIRequest] = attr.ib(default=BaseSearchGetRequest)
-    search_post_request_model: Type[BaseModel] = attr.ib(default=BaseSearchPostRequest)
-    collections_get_request_model: Type[APIRequest] = attr.ib(default=EmptyRequest)
-    collection_get_request_model: Type[APIRequest] = attr.ib(default=CollectionUri)
-    items_get_request_model: Type[APIRequest] = attr.ib(default=ItemCollectionUri)
-    item_get_request_model: Type[APIRequest] = attr.ib(default=ItemUri)
-    response_class: Type[Response] = attr.ib(default=JSONResponse)
-    middlewares: List[Middleware] = attr.ib(
+    search_get_request_model: type[APIRequest] = attr.ib(default=BaseSearchGetRequest)
+    search_post_request_model: type[BaseModel] = attr.ib(default=BaseSearchPostRequest)
+    collections_get_request_model: type[APIRequest] = attr.ib(default=EmptyRequest)
+    collection_get_request_model: type[APIRequest] = attr.ib(default=CollectionUri)
+    items_get_request_model: type[APIRequest] = attr.ib(default=ItemCollectionUri)
+    item_get_request_model: type[APIRequest] = attr.ib(default=ItemUri)
+    response_class: type[Response] = attr.ib(default=JSONResponse)
+    middlewares: list[Middleware] = attr.ib(
         default=attr.Factory(
             lambda: [
                 Middleware(BrotliMiddleware),
@@ -139,12 +138,12 @@ class StacApi:
             ]
         )
     )
-    route_dependencies: List[Tuple[List[Scope], List[Depends]]] = attr.ib(default=[])
-    health_check: Union[Callable[[], Dict], Callable[[], Awaitable[Dict]]] = attr.ib(
+    route_dependencies: list[tuple[list[Scope], list[Depends]]] = attr.ib(default=[])
+    health_check: Callable[[], dict] | Callable[[], Awaitable[dict]] = attr.ib(
         default=lambda: {"status": "UP"}
     )
 
-    def get_extension(self, extension: Type[ApiExtension]) -> Optional[ApiExtension]:
+    def get_extension(self, extension: type[ApiExtension]) -> ApiExtension | None:
         """Get an extension.
 
         Args:
@@ -388,7 +387,7 @@ class StacApi:
         mgmt_router.add_api_route(
             name="Ping",
             path="/_mgmt/ping",
-            response_model=Dict,
+            response_model=dict,
             responses={
                 200: {
                     "content": {
@@ -424,7 +423,7 @@ class StacApi:
         self.app.include_router(mgmt_router, tags=["Liveliness/Readiness"])
 
     def add_route_dependencies(
-        self, scopes: List[Scope], dependencies: List[Depends]
+        self, scopes: list[Scope], dependencies: list[Depends]
     ) -> None:
         """Add custom dependencies to routes.
 

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/errors.py

@@ -1,7 +1,8 @@
 """Error handling."""
 
 import logging
-from typing import Callable, Dict, Type, TypedDict
+from collections.abc import Callable
+from typing import TypedDict
 
 from fastapi import FastAPI
 from fastapi.encoders import jsonable_encoder
@@ -69,7 +70,7 @@ def exception_handler_factory(status_code: int) -> Callable:
 
 
 def add_exception_handlers(
-    app: FastAPI, status_codes: Dict[Type[Exception], int]
+    app: FastAPI, status_codes: dict[type[Exception], int]
 ) -> None:
     """Add exception handlers to the FastAPI application.
 

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/middleware.py

@@ -5,7 +5,6 @@ import re
 import typing
 import warnings
 from http.client import HTTP_PORT, HTTPS_PORT
-from typing import List, Optional, Tuple
 
 from starlette.middleware.cors import CORSMiddleware as _CORSMiddleware
 from starlette.types import ASGIApp, Receive, Scope, Send
@@ -29,7 +28,7 @@ class CORSMiddleware(_CORSMiddleware):
         ),
         allow_headers: typing.Sequence[str] = ("Content-Type",),
         allow_credentials: bool = False,
-        allow_origin_regex: typing.Optional[str] = None,
+        allow_origin_regex: str | None = None,
         expose_headers: typing.Sequence[str] = (),
         max_age: int = 600,
         **kwargs: typing.Any,
@@ -91,7 +90,7 @@ class ProxyHeaderMiddleware:
 
         await self.app(scope, receive, send)
 
-    def _get_forwarded_url_parts(self, scope: Scope) -> Tuple[str, str, int]:
+    def _get_forwarded_url_parts(self, scope: Scope) -> tuple[str, str, int]:
         proto = scope.get("scheme", "http")
         # Assume default port based on protocol, can be overridden later
         port = 443 if proto == "https" else 80
@@ -107,7 +106,7 @@ class ProxyHeaderMiddleware:
             domain, port = scope["server"]
             port = int(port)
 
-        forwarded_port: Optional[str] = None
+        forwarded_port: str | None = None
         forwarding_occurred = any(
             key
             in [
@@ -144,8 +143,8 @@ class ProxyHeaderMiddleware:
         return (proto, domain, port)
 
     def _get_header_value_by_name(
-        self, scope: Scope, header_name: str, default_value: Optional[str] = None
-    ) -> Optional[str]:
+        self, scope: Scope, header_name: str, default_value: str | None = None
+    ) -> str | None:
         headers = scope["headers"]
         candidates = [
             value.decode() for key, value in headers if key.decode() == header_name
@@ -155,7 +154,7 @@ class ProxyHeaderMiddleware:
     @staticmethod
     def _replace_header_value_by_name(
         scope: Scope, header_name: str, new_value: str
-    ) -> List[Tuple[str, str]]:
+    ) -> list[tuple[str, str]]:
         return [
             (name, value)
             for name, value in scope["headers"]

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/models.py

@@ -1,12 +1,11 @@
 """Api request/response models."""
 
-from typing import List, Literal, Optional, Type, Union, cast
+from typing import Annotated, Literal, cast
 
 import attr
 from fastapi import Path, Query
 from pydantic import BaseModel, create_model
 from stac_pydantic.shared import BBox
-from typing_extensions import Annotated
 
 from stac_fastapi.types.extension import ApiExtension
 from stac_fastapi.types.search import (
@@ -29,14 +28,14 @@ except ImportError:  # pragma: nocover
 
 def create_request_model(
     model_name="SearchGetRequest",
-    base_model: Union[Type[BaseModel], Type[APIRequest]] = BaseSearchGetRequest,
-    extensions: Optional[List[ApiExtension]] = None,
-    mixins: Optional[Union[List[Type[BaseModel]], List[Type[APIRequest]]]] = None,
+    base_model: type[BaseModel] | type[APIRequest] = BaseSearchGetRequest,
+    extensions: list[ApiExtension] | None = None,
+    mixins: list[type[BaseModel]] | list[type[APIRequest]] | None = None,
     request_type: str = "GET",
-) -> Union[Type[BaseModel], Type[APIRequest]]:
+) -> type[BaseModel] | type[APIRequest]:
     """Create a pydantic model for validating request bodies."""
     fields = {}
-    extension_models: List[Union[Type[BaseModel], Type[APIRequest]]] = []
+    extension_models: list[type[BaseModel] | type[APIRequest]] = []
 
     # Check extensions for additional parameters to search
     for extension in extensions or []:
@@ -50,7 +49,7 @@ def create_request_model(
     # Handle GET requests
     if all([issubclass(m, APIRequest) for m in models]):
         get_model = attr.make_class(model_name, attrs={}, bases=tuple(models))
-        return cast(Type[APIRequest], get_model)
+        return cast(type[APIRequest], get_model)
 
     # Handle POST requests
     elif all([issubclass(m, BaseModel) for m in models]):
@@ -59,15 +58,15 @@ def create_request_model(
                 fields[k] = (field_info.annotation, field_info)
 
         post_model = create_model(model_name, **fields, __base__=base_model)  # type: ignore
-        return cast(Type[BaseModel], post_model)
+        return cast(type[BaseModel], post_model)
 
     raise TypeError("Mixed Request Model types. Check extension request types.")
 
 
 def create_get_request_model(
-    extensions: Optional[List[ApiExtension]],
-    base_model: Type[APIRequest] = BaseSearchGetRequest,
-) -> Type[APIRequest]:
+    extensions: list[ApiExtension] | None,
+    base_model: type[APIRequest] = BaseSearchGetRequest,
+) -> type[APIRequest]:
     """Wrap create_request_model to create the GET request model."""
     model = create_request_model(
         "SearchGetRequest",
@@ -75,13 +74,13 @@ def create_get_request_model(
         extensions=extensions,
         request_type="GET",
     )
-    return cast(Type[APIRequest], model)
+    return cast(type[APIRequest], model)
 
 
 def create_post_request_model(
-    extensions: Optional[List[ApiExtension]],
-    base_model: Type[BaseModel] = BaseSearchPostRequest,
-) -> Type[BaseModel]:
+    extensions: list[ApiExtension] | None,
+    base_model: type[BaseModel] = BaseSearchPostRequest,
+) -> type[BaseModel]:
     """Wrap create_request_model to create the POST request model."""
     model = create_request_model(
         "SearchPostRequest",
@@ -89,7 +88,7 @@ def create_post_request_model(
         extensions=extensions,
         request_type="POST",
     )
-    return cast(Type[BaseModel], model)
+    return cast(type[BaseModel], model)
 
 
 @attr.s
@@ -120,12 +119,12 @@ class ItemCollectionUri(APIRequest, DatetimeMixin):
 
     collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
     limit: Annotated[
-        Optional[Limit],
+        Limit | None,
         Query(
             description="Limits the number of results that are included in each page of the response (capped to 10_000)."  # noqa: E501
         ),
     ] = attr.ib(default=10)
-    bbox: Optional[BBox] = attr.ib(default=None, converter=_bbox_converter)  # type: ignore [misc]
+    bbox: BBox | None = attr.ib(default=None, converter=_bbox_converter)  # type: ignore [misc]
     datetime: DateTimeQueryType = attr.ib(default=None, validator=_validate_datetime)
 
 

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/routes.py

@@ -3,7 +3,8 @@
 import copy
 import functools
 import inspect
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Type, TypedDict, Union
+from collections.abc import Awaitable, Callable
+from typing import Any, TypedDict
 
 from fastapi import Depends, FastAPI, params
 from fastapi.datastructures import DefaultPlaceholder
@@ -38,7 +39,7 @@ def sync_to_async(func):
 
 def create_async_endpoint(
     func: Callable,
-    request_model: Union[Type[APIRequest], Type[BaseModel], Dict],
+    request_model: type[APIRequest] | type[BaseModel] | dict,
 ) -> Callable[[Any, Any], Awaitable[Any]]:
     """Wrap a function in a coroutine which may be used to create a FastAPI endpoint.
 
@@ -52,7 +53,7 @@ def create_async_endpoint(
 
     if isinstance(request_model, dict):
 
-        async def _endpoint(request: Request, request_data: Dict[str, Any]):
+        async def _endpoint(request: Request, request_data: dict[str, Any]):
             """Endpoint."""
             return _wrap_response(await func(request_data, request=request))
 
@@ -80,11 +81,50 @@ class Scope(TypedDict, total=False):
     # https://github.com/encode/starlette/blob/6af5c515e0a896cbf3f86ee043b88f6c24200bcf/starlette/types.py#L3
     path: str
     method: str
-    type: Optional[str]
+    type: str | None
+
+
+def _is_endpoint_route(route: BaseRoute) -> bool:
+    """Check if route is a standard endpoint (not a mount or sub-router)."""
+    return (
+        hasattr(route, "path") and hasattr(route, "methods") and route.methods is not None
+    )
+
+
+def _apply_dependencies_to_route(
+    route: BaseRoute, scopes: list[Scope], dependencies: list[params.Depends]
+) -> None:
+    """Apply dependencies to a single route matching the given scopes."""
+    for scope in scopes:
+        _scope = copy.deepcopy(scope)
+
+        if scope["path"] == "*":
+            _scope["path"] = route.path  # type: ignore
+
+        if scope["method"] == "*":
+            _scope["method"] = list(route.methods)[0]  # type: ignore
+
+        match, _ = route.matches({"type": "http", **_scope})
+        if match != Match.FULL:
+            continue
+
+        if not hasattr(route, "dependant"):
+            continue
+
+        for depends in dependencies[::-1]:
+            route.dependant.dependencies.insert(
+                0,
+                get_parameterless_sub_dependant(
+                    depends=depends,
+                    path=route.path_format,  # type: ignore
+                ),
+            )
+
+        route.dependencies.extend(dependencies)  # type: ignore
 
 
 def add_route_dependencies(
-    routes: List[BaseRoute], scopes: List[Scope], dependencies: List[params.Depends]
+    routes: list[BaseRoute], scopes: list[Scope], dependencies: list[params.Depends]
 ) -> None:
     """Add dependencies to routes.
 
@@ -96,48 +136,19 @@ def add_route_dependencies(
     Returns:
         None
     """
-    for scope in scopes:
-        _scope = copy.deepcopy(scope)
-        for route in routes:
-            if scope["path"] == "*":
-                # NOTE: ignore type, because BaseRoute has no "path" attribute
-                # but APIRoute does.
-                _scope["path"] = route.path  # type: ignore
-
-            # NOTE: ignore type, because BaseRoute has no "method" attribute
-            # but APIRoute does.
-            if scope["method"] == "*":
-                _scope["method"] = list(route.methods)[0]  # type: ignore
-
-            match, _ = route.matches({"type": "http", **_scope})
-            if match != Match.FULL:
-                continue
-
-            # Ignore paths without dependants, e.g. /api, /api.html, /docs/oauth2-redirect
-            if not hasattr(route, "dependant"):
-                continue
-
-            # Mimicking how APIRoute handles dependencies:
-            # https://github.com/tiangolo/fastapi/blob/1760da0efa55585c19835d81afa8ca386036c325/fastapi/routing.py#L408-L412
-            for depends in dependencies[::-1]:
-                route.dependant.dependencies.insert(
-                    0,
-                    get_parameterless_sub_dependant(
-                        # NOTE: ignore type, because BaseRoute has no "path_format"
-                        # attribute but APIRoute does.
-                        depends=depends,
-                        path=route.path_format,  # type: ignore
-                    ),
-                )
-
-            # Register dependencies directly on route so that they aren't ignored if
-            # the routes are later associated with an app (e.g.
-            # app.include_router(router))
-            # https://github.com/tiangolo/fastapi/blob/58ab733f19846b4875c5b79bfb1f4d1cb7f4823f/fastapi/applications.py#L337-L360
-            # https://github.com/tiangolo/fastapi/blob/58ab733f19846b4875c5b79bfb1f4d1cb7f4823f/fastapi/routing.py#L677-L678
-            # NOTE: ignore type, because BaseRoute has no "dependencies" attribute
-            # but APIRoute does.
-            route.dependencies.extend(dependencies)  # type: ignore
+    for route in routes:
+        if hasattr(route, "original_router"):
+            add_route_dependencies(route.original_router.routes, scopes, dependencies)
+            continue
+
+        if hasattr(route, "routes") and route.routes:
+            add_route_dependencies(route.routes, scopes, dependencies)
+            continue
+
+        if not _is_endpoint_route(route):
+            continue
+
+        _apply_dependencies_to_route(route, scopes, dependencies)
 
 
 def add_direct_response(app: FastAPI) -> None:
@@ -148,7 +159,7 @@ def add_direct_response(app: FastAPI) -> None:
     ref: https://gist.github.com/Zaczero/00f3a2679ebc0a25eb938ed82bc63553
     """
 
-    def wrap_endpoint(endpoint: Callable, cls: Type[Response]):
+    def wrap_endpoint(endpoint: Callable, cls: type[Response]):
         @functools.wraps(endpoint)
         async def wrapper(*args, **kwargs):
             content = await endpoint(*args, **kwargs)

{stac_fastapi_api-6.2.1 → stac_fastapi_api-6.3.1}/stac_fastapi/api/version.py

@@ -1,3 +1,3 @@
 """Library version."""
 
-__version__ = "6.2.1"
+__version__ = "6.3.1"