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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0
+Version: 3.0.0a1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -19,7 +19,7 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types~=3.0
+Requires-Dist: stac-fastapi.types
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

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

@@ -7,7 +7,7 @@ with open("README.md") as f:
 
 install_requires = [
     "brotli_asgi",
-    "stac-fastapi.types~=3.0",
+    "stac-fastapi.types",
 ]
 
 extra_reqs = {

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

@@ -18,15 +18,18 @@ 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
@@ -105,10 +108,7 @@ class StacApi:
     search_post_request_model: Type[BaseSearchPostRequest] = 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)
+    pagination_extension = attr.ib(default=TokenPaginationExtension)
     response_class: Type[Response] = attr.ib(default=JSONResponse)
     middlewares: List[Middleware] = attr.ib(
         default=attr.Factory(
@@ -211,9 +211,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.get_item, self.item_get_request_model
-            ),
+            endpoint=create_async_endpoint(self.client.get_item, ItemUri),
         )
 
     def register_post_search(self):
@@ -222,12 +220,15 @@ class StacApi:
         Returns:
             None
         """
+        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=api.ItemCollection
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                (api.ItemCollection if not fields_ext else None)
+                if self.settings.enable_response_models
+                else None
+            ),
             responses={
                 200: {
                     "content": {
@@ -251,12 +252,15 @@ class StacApi:
         Returns:
             None
         """
+        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=api.ItemCollection
-            if self.settings.enable_response_models
-            else None,
+            response_model=(
+                (api.ItemCollection if not fields_ext else None)
+                if self.settings.enable_response_models
+                else None
+            ),
             responses={
                 200: {
                     "content": {
@@ -298,9 +302,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.all_collections, self.collections_get_request_model
-            ),
+            endpoint=create_async_endpoint(self.client.all_collections, EmptyRequest),
         )
 
     def register_get_collection(self):
@@ -327,9 +329,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.get_collection, self.collection_get_request_model
-            ),
+            endpoint=create_async_endpoint(self.client.get_collection, CollectionUri),
         )
 
     def register_get_item_collection(self):
@@ -338,6 +338,16 @@ 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",
@@ -356,9 +366,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.item_collection, self.items_get_request_model
-            ),
+            endpoint=create_async_endpoint(self.client.item_collection, request_model),
         )
 
     def register_core(self):
@@ -431,6 +439,11 @@ class StacApi:
         """
         return add_route_dependencies(self.app.router.routes, scopes, dependencies)
 
+    def add_middleware(self, middleware: Middleware):
+        """Add a middleware class to the application."""
+        self.app.user_middleware.insert(0, middleware)
+        self.app.middleware_stack = self.app.build_middleware_stack()
+
     def __attrs_post_init__(self):
         """Post-init hook.
 
@@ -445,6 +458,10 @@ 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
 
@@ -470,11 +487,8 @@ 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.user_middleware.insert(0, middleware)
+            self.add_middleware(middleware)
 
         # customize route dependencies
         for scopes, dependencies in self.route_dependencies:

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

@@ -12,14 +12,12 @@ 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-3.0.0 → stac_fastapi_api-3.0.0a1}/stac_fastapi/api/models.py

@@ -1,12 +1,12 @@
 """Api request/response models."""
 
+import importlib.util
 from typing import List, Optional, Type, Union
 
 import attr
-from fastapi import Path, Query
+from fastapi import Path
 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
@@ -14,17 +14,10 @@ from stac_fastapi.types.search import (
     APIRequest,
     BaseSearchGetRequest,
     BaseSearchPostRequest,
-    Limit,
-    _bbox_converter,
-    _datetime_converter,
+    str2bbox,
+    str_to_interval,
 )
 
-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",
@@ -87,19 +80,18 @@ def create_post_request_model(
     )
 
 
-@attr.s
+@attr.s  # type:ignore
 class CollectionUri(APIRequest):
     """Get or delete collection."""
 
-    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+    collection_id: str = attr.ib(default=Path(..., description="Collection ID"))
 
 
 @attr.s
-class ItemUri(APIRequest):
+class ItemUri(CollectionUri):
     """Get or delete item."""
 
-    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
-    item_id: Annotated[str, Path(description="Item ID")] = attr.ib()
+    item_id: str = attr.ib(default=Path(..., description="Item ID"))
 
 
 @attr.s
@@ -110,29 +102,63 @@ class EmptyRequest(APIRequest):
 
 
 @attr.s
-class ItemCollectionUri(APIRequest):
+class ItemCollectionUri(CollectionUri):
     """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
-    )
+    limit: int = attr.ib(default=10)
+    bbox: Optional[BBox] = attr.ib(default=None, converter=str2bbox)
+    datetime: Optional[DateTimeType] = attr.ib(default=None, converter=str_to_interval)
+
+
+class POSTTokenPagination(BaseModel):
+    """Token pagination model for POST requests."""
+
+    token: Optional[str] = None
+
+
+@attr.s
+class GETTokenPagination(APIRequest):
+    """Token pagination for GET requests."""
+
+    token: Optional[str] = attr.ib(default=None)
+
 
+class POSTPagination(BaseModel):
+    """Page based pagination for POST requests."""
 
-class GeoJSONResponse(JSONResponse):
-    """JSON with custom, vendor content-type."""
+    page: Optional[str] = None
+
+
+@attr.s
+class GETPagination(APIRequest):
+    """Page based pagination for GET requests."""
+
+    page: Optional[str] = attr.ib(default=None)
+
+
+# Test for ORJSON and use it rather than stdlib JSON where supported
+if importlib.util.find_spec("orjson") is not None:
+    from fastapi.responses import ORJSONResponse
+
+    class GeoJSONResponse(ORJSONResponse):
+        """JSON with custom, vendor content-type."""
+
+        media_type = "application/geo+json"
+
+    class JSONSchemaResponse(ORJSONResponse):
+        """JSON with custom, vendor content-type."""
+
+        media_type = "application/schema+json"
+
+else:
+    from starlette.responses import JSONResponse
 
-    media_type = "application/geo+json"
+    class GeoJSONResponse(JSONResponse):
+        """JSON with custom, vendor content-type."""
 
+        media_type = "application/geo+json"
 
-class JSONSchemaResponse(JSONResponse):
-    """JSON with custom, vendor content-type."""
+    class JSONSchemaResponse(JSONResponse):
+        """JSON with custom, vendor content-type."""
 
-    media_type = "application/schema+json"
+        media_type = "application/schema+json"

stac_fastapi_api-3.0.0a1/stac_fastapi/api/openapi.py

@@ -0,0 +1,87 @@
+"""openapi."""
+
+import warnings
+
+from fastapi import FastAPI
+from fastapi.openapi.utils import get_openapi
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import Route, request_response
+
+from stac_fastapi.api.config import ApiExtensions
+from stac_fastapi.types.config import ApiSettings
+
+
+class VndOaiResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
+
+    media_type = "application/vnd.oai.openapi+json;version=3.0"
+
+    def __init__(self, *args, **kwargs):
+        """Init function with deprecation warning."""
+        warnings.warn(
+            "VndOaiResponse is deprecated and will be removed in v3.0",
+            DeprecationWarning,
+        )
+        super().__init__(*args, **kwargs)
+
+
+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
+
+
+def config_openapi(app: FastAPI, settings: ApiSettings):
+    """Config openapi."""
+    warnings.warn(
+        "config_openapi is deprecated and will be removed in v3.0",
+        DeprecationWarning,
+    )
+
+    def custom_openapi():
+        """Config openapi."""
+        if app.openapi_schema:
+            return app.openapi_schema
+
+        openapi_schema = get_openapi(
+            title="Arturo STAC API", version="0.1", routes=app.routes
+        )
+
+        if settings.api_extension_is_enabled(ApiExtensions.fields):
+            openapi_schema["paths"]["/search"]["get"]["responses"]["200"]["content"][
+                "application/json"
+            ]["schema"] = {"$ref": "#/components/schemas/ItemCollection"}
+            openapi_schema["paths"]["/search"]["post"]["responses"]["200"]["content"][
+                "application/json"
+            ]["schema"] = {"$ref": "#/components/schemas/ItemCollection"}
+
+        app.openapi_schema = openapi_schema
+        return app.openapi_schema
+
+    app.openapi = custom_openapi

{stac_fastapi_api-3.0.0 → stac_fastapi_api-3.0.0a1}/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,12 +37,19 @@ 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)
 
@@ -93,28 +100,15 @@ 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:
-            if scope["path"] == "*":
-                _scope["path"] = route.path
-
-            if scope["method"] == "*":
-                _scope["method"] = list(route.methods)[0]
-
-            match, _ = route.matches({"type": "http", **_scope})
+            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-3.0.0a1/stac_fastapi/api/version.py

@@ -0,0 +1,2 @@
+"""Library version."""
+__version__ = "3.0.0a1"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0
+Version: 3.0.0a1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -19,7 +19,7 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types~=3.0
+Requires-Dist: stac-fastapi.types
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{stac_fastapi_api-3.0.0 → stac_fastapi_api-3.0.0a1}/stac_fastapi.api.egg-info/requires.txt

@@ -1,5 +1,5 @@
 brotli_asgi
-stac-fastapi.types~=3.0
+stac-fastapi.types
 
 [benchmark]
 pytest-benchmark