stac-fastapi.api 2.5.5__tar.gz → 3.0.0__tar.gz

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 2.5.5
+Version: 3.0.0
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -18,11 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: attrs
-Requires-Dist: pydantic[dotenv]<2
-Requires-Dist: stac_pydantic==2.0.*
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types
+Requires-Dist: stac-fastapi.types~=3.0
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
@@ -30,7 +27,6 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: requests; extra == "dev"
-Requires-Dist: pystac[validation]==1.*; extra == "dev"
 Provides-Extra: benchmark
 Requires-Dist: pytest-benchmark; extra == "benchmark"
 Provides-Extra: docs

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/setup.py

@@ -6,11 +6,8 @@ with open("README.md") as f:
     desc = f.read()
 
 install_requires = [
-    "attrs",
-    "pydantic[dotenv]<2",
-    "stac_pydantic==2.0.*",
     "brotli_asgi",
-    "stac-fastapi.types",
+    "stac-fastapi.types~=3.0",
 ]
 
 extra_reqs = {
@@ -21,7 +18,6 @@ extra_reqs = {
         "pytest-asyncio",
         "pre-commit",
         "requests",
-        "pystac[validation]==1.*",
     ],
     "benchmark": [
         "pytest-benchmark",

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/app.py

@@ -1,5 +1,6 @@
 """Fastapi app creation."""
 
+
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 import attr
@@ -7,27 +8,25 @@ from brotli_asgi import BrotliMiddleware
 from fastapi import APIRouter, FastAPI
 from fastapi.openapi.utils import get_openapi
 from fastapi.params import Depends
-from stac_pydantic import Collection, Item, ItemCollection
-from stac_pydantic.api import ConformanceClasses, LandingPage
+from stac_pydantic import api
 from stac_pydantic.api.collections import Collections
-from stac_pydantic.version import STAC_VERSION
+from stac_pydantic.api.version import STAC_API_VERSION
+from stac_pydantic.shared import MimeTypes
+from starlette.middleware import Middleware
 from starlette.responses import JSONResponse, Response
 
 from stac_fastapi.api.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 from stac_fastapi.api.middleware import CORSMiddleware, ProxyHeaderMiddleware
 from stac_fastapi.api.models import (
+    APIRequest,
     CollectionUri,
     EmptyRequest,
     GeoJSONResponse,
     ItemCollectionUri,
     ItemUri,
-    create_request_model,
 )
 from stac_fastapi.api.openapi import update_openapi
 from stac_fastapi.api.routes import Scope, add_route_dependencies, create_async_endpoint
-
-# TODO: make this module not depend on `stac_fastapi.extensions`
-from stac_fastapi.extensions.core import FieldsExtension, TokenPaginationExtension
 from stac_fastapi.types.config import ApiSettings, Settings
 from stac_fastapi.types.core import AsyncBaseCoreClient, BaseCoreClient
 from stac_fastapi.types.extension import ApiExtension
@@ -94,7 +93,7 @@ class StacApi:
             lambda self: self.settings.stac_fastapi_version, takes_self=True
         )
     )
-    stac_version: str = attr.ib(default=STAC_VERSION)
+    stac_version: str = attr.ib(default=STAC_API_VERSION)
     description: str = attr.ib(
         default=attr.Factory(
             lambda self: self.settings.stac_fastapi_description, takes_self=True
@@ -106,11 +105,18 @@ class StacApi:
     search_post_request_model: Type[BaseSearchPostRequest] = attr.ib(
         default=BaseSearchPostRequest
     )
-    pagination_extension = attr.ib(default=TokenPaginationExtension)
+    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 = attr.ib(
+    middlewares: List[Middleware] = attr.ib(
         default=attr.Factory(
-            lambda: [BrotliMiddleware, CORSMiddleware, ProxyHeaderMiddleware]
+            lambda: [
+                Middleware(BrotliMiddleware),
+                Middleware(CORSMiddleware),
+                Middleware(ProxyHeaderMiddleware),
+            ]
         )
     )
     route_dependencies: List[Tuple[List[Scope], List[Depends]]] = attr.ib(default=[])
@@ -138,9 +144,17 @@ class StacApi:
         self.router.add_api_route(
             name="Landing Page",
             path="/",
-            response_model=LandingPage
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.LandingPage if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.LandingPage,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=False,
             response_model_exclude_none=True,
@@ -157,9 +171,17 @@ class StacApi:
         self.router.add_api_route(
             name="Conformance Classes",
             path="/conformance",
-            response_model=ConformanceClasses
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.Conformance if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.Conformance,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -176,12 +198,22 @@ class StacApi:
         self.router.add_api_route(
             name="Get Item",
             path="/collections/{collection_id}/items/{item_id}",
-            response_model=Item if self.settings.enable_response_models else None,
+            response_model=api.Item if self.settings.enable_response_models else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.Item,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.get_item, ItemUri),
+            endpoint=create_async_endpoint(
+                self.client.get_item, self.item_get_request_model
+            ),
         )
 
     def register_post_search(self):
@@ -190,13 +222,20 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(ItemCollection if not fields_ext else None)
+            response_model=api.ItemCollection
             if self.settings.enable_response_models
             else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -212,13 +251,20 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(ItemCollection if not fields_ext else None)
+            response_model=api.ItemCollection
             if self.settings.enable_response_models
             else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
@@ -237,14 +283,24 @@ class StacApi:
         self.router.add_api_route(
             name="Get Collections",
             path="/collections",
-            response_model=Collections
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                Collections if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": Collections,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.all_collections, EmptyRequest),
+            endpoint=create_async_endpoint(
+                self.client.all_collections, self.collections_get_request_model
+            ),
         )
 
     def register_get_collection(self):
@@ -256,12 +312,24 @@ class StacApi:
         self.router.add_api_route(
             name="Get Collection",
             path="/collections/{collection_id}",
-            response_model=Collection if self.settings.enable_response_models else None,
+            response_model=api.Collection
+            if self.settings.enable_response_models
+            else None,
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.json.value: {},
+                    },
+                    "model": api.Collection,
+                },
+            },
             response_class=self.response_class,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.get_collection, CollectionUri),
+            endpoint=create_async_endpoint(
+                self.client.get_collection, self.collection_get_request_model
+            ),
         )
 
     def register_get_item_collection(self):
@@ -270,27 +338,27 @@ class StacApi:
         Returns:
             None
         """
-        pagination_extension = self.get_extension(self.pagination_extension)
-        if pagination_extension is not None:
-            mixins = [pagination_extension.GET]
-        else:
-            mixins = None
-        request_model = create_request_model(
-            "ItemCollectionURI",
-            base_model=ItemCollectionUri,
-            mixins=mixins,
-        )
         self.router.add_api_route(
             name="Get ItemCollection",
             path="/collections/{collection_id}/items",
-            response_model=ItemCollection
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                api.ItemCollection if self.settings.enable_response_models else None
+            ),
+            responses={
+                200: {
+                    "content": {
+                        MimeTypes.geojson.value: {},
+                    },
+                    "model": api.ItemCollection,
+                },
+            },
             response_class=GeoJSONResponse,
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(self.client.item_collection, request_model),
+            endpoint=create_async_endpoint(
+                self.client.item_collection, self.items_get_request_model
+            ),
         )
 
     def register_core(self):
@@ -377,10 +445,6 @@ class StacApi:
         self.client.title = self.title
         self.client.description = self.description
 
-        fields_ext = self.get_extension(FieldsExtension)
-        if fields_ext:
-            self.settings.default_includes = fields_ext.default_includes
-
         Settings.set(self.settings)
         self.app.state.settings = self.settings
 
@@ -406,8 +470,11 @@ class StacApi:
         self.app.openapi = self.customize_openapi
 
         # add middlewares
+        if self.middlewares and self.app.middleware_stack is not None:
+            raise RuntimeError("Cannot add middleware after an application has started")
+
         for middleware in self.middlewares:
-            self.app.add_middleware(middleware)
+            self.app.user_middleware.insert(0, middleware)
 
         # customize route dependencies
         for scopes, dependencies in self.route_dependencies:

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/config.py

@@ -1,4 +1,5 @@
 """Application settings."""
+
 import enum
 
 
@@ -11,12 +12,14 @@ class ApiExtensions(enum.Enum):
     Ref: https://github.com/stac-api-extensions
     """
 
-    context = "context"
     fields = "fields"
     filter = "filter"
     query = "query"
     sort = "sort"
     transaction = "transaction"
+    aggregation = "aggregation"
+    collection_search = "collection-search"
+    free_text = "free-text"
 
 
 class AddOns(enum.Enum):

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/errors.py

@@ -4,7 +4,7 @@ import logging
 from typing import Callable, Dict, Type, TypedDict
 
 from fastapi import FastAPI
-from fastapi.exceptions import RequestValidationError
+from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from starlette import status
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -27,6 +27,7 @@ DEFAULT_STATUS_CODES = {
     DatabaseError: status.HTTP_424_FAILED_DEPENDENCY,
     Exception: status.HTTP_500_INTERNAL_SERVER_ERROR,
     InvalidQueryParameter: status.HTTP_400_BAD_REQUEST,
+    ResponseValidationError: status.HTTP_500_INTERNAL_SERVER_ERROR,
 }
 
 

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/middleware.py

@@ -1,4 +1,5 @@
 """Api middleware."""
+
 import re
 import typing
 from http.client import HTTP_PORT, HTTPS_PORT

stac_fastapi_api-3.0.0/stac_fastapi/api/models.py

@@ -0,0 +1,138 @@
+"""Api request/response models."""
+
+from typing import List, Optional, Type, Union
+
+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.rfc3339 import DateTimeType
+from stac_fastapi.types.search import (
+    APIRequest,
+    BaseSearchGetRequest,
+    BaseSearchPostRequest,
+    Limit,
+    _bbox_converter,
+    _datetime_converter,
+)
+
+try:
+    import orjson  # noqa
+    from fastapi.responses import ORJSONResponse as JSONResponse
+except ImportError:  # pragma: nocover
+    from starlette.responses import JSONResponse
+
+
+def create_request_model(
+    model_name="SearchGetRequest",
+    base_model: Union[Type[BaseModel], APIRequest] = BaseSearchGetRequest,
+    extensions: Optional[List[ApiExtension]] = None,
+    mixins: Optional[Union[List[BaseModel], List[APIRequest]]] = None,
+    request_type: Optional[str] = "GET",
+) -> Union[Type[BaseModel], APIRequest]:
+    """Create a pydantic model for validating request bodies."""
+    fields = {}
+    extension_models = []
+
+    # Check extensions for additional parameters to search
+    for extension in extensions or []:
+        if extension_model := extension.get_request_model(request_type):
+            extension_models.append(extension_model)
+
+    mixins = mixins or []
+
+    models = [base_model] + extension_models + mixins
+
+    # Handle GET requests
+    if all([issubclass(m, APIRequest) for m in models]):
+        return attr.make_class(model_name, attrs={}, bases=tuple(models))
+
+    # Handle POST requests
+    elif all([issubclass(m, BaseModel) for m in models]):
+        for model in models:
+            for k, field_info in model.model_fields.items():
+                fields[k] = (field_info.annotation, field_info)
+        return create_model(model_name, **fields, __base__=base_model)
+
+    raise TypeError("Mixed Request Model types. Check extension request types.")
+
+
+def create_get_request_model(
+    extensions: Optional[List[ApiExtension]],
+    base_model: BaseSearchGetRequest = BaseSearchGetRequest,
+) -> APIRequest:
+    """Wrap create_request_model to create the GET request model."""
+
+    return create_request_model(
+        "SearchGetRequest",
+        base_model=base_model,
+        extensions=extensions,
+        request_type="GET",
+    )
+
+
+def create_post_request_model(
+    extensions: Optional[List[ApiExtension]],
+    base_model: BaseSearchPostRequest = BaseSearchPostRequest,
+) -> Type[BaseModel]:
+    """Wrap create_request_model to create the POST request model."""
+    return create_request_model(
+        "SearchPostRequest",
+        base_model=base_model,
+        extensions=extensions,
+        request_type="POST",
+    )
+
+
+@attr.s
+class CollectionUri(APIRequest):
+    """Get or delete collection."""
+
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+
+
+@attr.s
+class ItemUri(APIRequest):
+    """Get or delete item."""
+
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+    item_id: Annotated[str, Path(description="Item ID")] = attr.ib()
+
+
+@attr.s
+class EmptyRequest(APIRequest):
+    """Empty request."""
+
+    ...
+
+
+@attr.s
+class ItemCollectionUri(APIRequest):
+    """Get item collection."""
+
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+    limit: Annotated[
+        Optional[Limit],
+        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)
+    datetime: Optional[DateTimeType] = attr.ib(
+        default=None, converter=_datetime_converter
+    )
+
+
+class GeoJSONResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
+
+    media_type = "application/geo+json"
+
+
+class JSONSchemaResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
+
+    media_type = "application/schema+json"

stac_fastapi_api-3.0.0/stac_fastapi/api/openapi.py

@@ -0,0 +1,37 @@
+"""openapi."""
+
+from fastapi import FastAPI
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import Route, request_response
+
+
+def update_openapi(app: FastAPI) -> FastAPI:
+    """Update OpenAPI response content-type.
+
+    This function modifies the openapi route to comply with the STAC API spec's required
+    content-type response header.
+    """
+    # Find the route for the openapi_url in the app
+    openapi_route: Route = next(
+        route for route in app.router.routes if route.path == app.openapi_url
+    )
+    # Store the old endpoint function so we can call it from the patched function
+    old_endpoint = openapi_route.endpoint
+
+    # Create a patched endpoint function that modifies the content type of the response
+    async def patched_openapi_endpoint(req: Request) -> Response:
+        # Get the response from the old endpoint function
+        response: JSONResponse = await old_endpoint(req)
+        # Update the content type header in place
+        response.headers["content-type"] = "application/vnd.oai.openapi+json;version=3.0"
+        # Return the updated response
+        return response
+
+    # When a Route is accessed the `handle` function calls `self.app`. Which is
+    # the endpoint function wrapped with `request_response`. So we need to wrap
+    # our patched function and replace the existing app with it.
+    openapi_route.app = request_response(patched_openapi_endpoint)
+
+    # return the patched app
+    return app

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/routes.py

@@ -1,8 +1,8 @@
 """Route factories."""
 
+import copy
 import functools
 import inspect
-import warnings
 from typing import Any, Callable, Dict, List, Optional, Type, TypedDict, Union
 
 from fastapi import Depends, params
@@ -37,19 +37,12 @@ def sync_to_async(func):
 def create_async_endpoint(
     func: Callable,
     request_model: Union[Type[APIRequest], Type[BaseModel], Dict],
-    response_class: Optional[Type[Response]] = None,
 ):
     """Wrap a function in a coroutine which may be used to create a FastAPI endpoint.
 
     Synchronous functions are executed asynchronously using a background thread.
     """
 
-    if response_class:
-        warnings.warn(
-            "`response_class` option is deprecated, please set the Response class directly in the endpoint.",  # noqa: E501
-            DeprecationWarning,
-        )
-
     if not inspect.iscoroutinefunction(func):
         func = sync_to_async(func)
 
@@ -100,15 +93,28 @@ def add_route_dependencies(
     Allows a developer to add dependencies to a route after the route has been
     defined.
 
+    "*" can be used for path or method to match all allowed routes.
+
     Returns:
         None
     """
     for scope in scopes:
+        _scope = copy.deepcopy(scope)
         for route in routes:
-            match, _ = route.matches({"type": "http", **scope})
+            if scope["path"] == "*":
+                _scope["path"] = route.path
+
+            if scope["method"] == "*":
+                _scope["method"] = list(route.methods)[0]
+
+            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]:

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi/api/version.py

@@ -1,2 +1,3 @@
 """Library version."""
-__version__ = "2.5.5"
+
+__version__ = "3.0.0"

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 2.5.5
+Version: 3.0.0
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -18,11 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: attrs
-Requires-Dist: pydantic[dotenv]<2
-Requires-Dist: stac_pydantic==2.0.*
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types
+Requires-Dist: stac-fastapi.types~=3.0
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
@@ -30,7 +27,6 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: requests; extra == "dev"
-Requires-Dist: pystac[validation]==1.*; extra == "dev"
 Provides-Extra: benchmark
 Requires-Dist: pytest-benchmark; extra == "benchmark"
 Provides-Extra: docs

{stac_fastapi_api-2.5.5 → stac_fastapi_api-3.0.0}/stac_fastapi.api.egg-info/SOURCES.txt

@@ -17,5 +17,7 @@ stac_fastapi/api/openapi.py
 stac_fastapi/api/routes.py
 stac_fastapi/api/version.py
 tests/test_api.py
+tests/test_app.py
 tests/test_app_prefix.py
-tests/test_middleware.py
+tests/test_middleware.py
+tests/test_models.py