stac-fastapi.api 3.0.0a4__tar.gz → 3.0.0b2__tar.gz

{stac_fastapi_api-3.0.0a4 → stac_fastapi_api-3.0.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a4
+Version: 3.0.0b2
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering

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

@@ -18,18 +18,15 @@ 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
@@ -108,7 +105,10 @@ 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[Middleware] = attr.ib(
         default=attr.Factory(
@@ -211,7 +211,9 @@ class StacApi:
             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):
@@ -220,15 +222,12 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(
-                (api.ItemCollection if not fields_ext else None)
-                if self.settings.enable_response_models
-                else None
-            ),
+            response_model=api.ItemCollection
+            if self.settings.enable_response_models
+            else None,
             responses={
                 200: {
                     "content": {
@@ -252,15 +251,12 @@ class StacApi:
         Returns:
             None
         """
-        fields_ext = self.get_extension(FieldsExtension)
         self.router.add_api_route(
             name="Search",
             path="/search",
-            response_model=(
-                (api.ItemCollection if not fields_ext else None)
-                if self.settings.enable_response_models
-                else None
-            ),
+            response_model=api.ItemCollection
+            if self.settings.enable_response_models
+            else None,
             responses={
                 200: {
                     "content": {
@@ -302,7 +298,9 @@ class StacApi:
             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):
@@ -329,7 +327,9 @@ class StacApi:
             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):
@@ -338,16 +338,6 @@ 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",
@@ -366,7 +356,9 @@ class StacApi:
             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):

{stac_fastapi_api-3.0.0a4 → stac_fastapi_api-3.0.0b2}/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
+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
@@ -18,6 +18,12 @@ from stac_fastapi.types.search import (
     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",
@@ -80,18 +86,19 @@ def create_post_request_model(
     )
 
 
-@attr.s  # type:ignore
+@attr.s
 class CollectionUri(APIRequest):
     """Get or delete collection."""
 
-    collection_id: str = attr.ib(default=Path(..., description="Collection ID"))
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
 
 
 @attr.s
-class ItemUri(CollectionUri):
+class ItemUri(APIRequest):
     """Get or delete item."""
 
-    item_id: str = attr.ib(default=Path(..., description="Item ID"))
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+    item_id: Annotated[str, Path(description="Item ID")] = attr.ib()
 
 
 @attr.s
@@ -102,63 +109,24 @@ class EmptyRequest(APIRequest):
 
 
 @attr.s
-class ItemCollectionUri(CollectionUri):
+class ItemCollectionUri(APIRequest):
     """Get item collection."""
 
-    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."""
-
-    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."""
+    collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+    limit: Annotated[int, Query()] = attr.ib(default=10)
+    bbox: Annotated[Optional[BBox], Query()] = attr.ib(default=None, converter=str2bbox)
+    datetime: Annotated[Optional[DateTimeType], Query()] = attr.ib(
+        default=None, converter=str_to_interval
+    )
 
-        media_type = "application/schema+json"
 
-else:
-    from starlette.responses import JSONResponse
+class GeoJSONResponse(JSONResponse):
+    """JSON with custom, vendor content-type."""
 
-    class GeoJSONResponse(JSONResponse):
-        """JSON with custom, vendor content-type."""
+    media_type = "application/geo+json"
 
-        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.0b2/stac_fastapi/api/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.0a4
+Version: 3.0.0b2
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering

{stac_fastapi_api-3.0.0a4 → stac_fastapi_api-3.0.0b2}/tests/test_api.py

@@ -2,6 +2,7 @@ from fastapi import Depends, HTTPException, security, status
 from starlette.testclient import TestClient
 
 from stac_fastapi.api.app import StacApi
+from stac_fastapi.api.models import ItemCollectionUri, create_request_model
 from stac_fastapi.extensions.core import (
     TokenPaginationExtension,
     TransactionExtension,
@@ -13,6 +14,13 @@ class TestRouteDependencies:
     @staticmethod
     def _build_api(**overrides):
         settings = config.ApiSettings()
+
+        items_get_request_model = create_request_model(
+            "ItemCollectionURI",
+            base_model=ItemCollectionUri,
+            mixins=[TokenPaginationExtension().GET],
+        )
+
         return StacApi(
             **{
                 "settings": settings,
@@ -23,6 +31,7 @@ class TestRouteDependencies:
                     ),
                     TokenPaginationExtension(),
                 ],
+                "items_get_request_model": items_get_request_model,
                 **overrides,
             }
         )

{stac_fastapi_api-3.0.0a4 → stac_fastapi_api-3.0.0b2}/tests/test_app.py

@@ -1,13 +1,21 @@
 from datetime import datetime
 from typing import List, Optional, Union
 
+import attr
 import pytest
+from fastapi import Path, Query
 from fastapi.testclient import TestClient
 from pydantic import ValidationError
 from stac_pydantic import api
+from typing_extensions import Annotated
 
 from stac_fastapi.api import app
-from stac_fastapi.api.models import create_get_request_model, create_post_request_model
+from stac_fastapi.api.models import (
+    APIRequest,
+    JSONResponse,
+    create_get_request_model,
+    create_post_request_model,
+)
 from stac_fastapi.extensions.core import FieldsExtension, FilterExtension
 from stac_fastapi.types import stac
 from stac_fastapi.types.config import ApiSettings
@@ -200,7 +208,14 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
         def post_search(
             self, search_request: BaseSearchPostRequest, **kwargs
         ) -> stac.ItemCollection:
-            return {"not": "a proper stac item"}
+            resp = {"not": "a proper stac item"}
+
+            # if `fields` extension is enabled, then we return a JSONResponse
+            # to avoid Item validation
+            if getattr(search_request, "fields", None):
+                return JSONResponse(content=resp)
+
+            return resp
 
         def get_search(
             self,
@@ -212,7 +227,14 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
             limit: Optional[int] = 10,
             **kwargs,
         ) -> stac.ItemCollection:
-            return {"not": "a proper stac item"}
+            resp = {"not": "a proper stac item"}
+
+            # if `fields` extension is enabled, then we return a JSONResponse
+            # to avoid Item validation
+            if "fields" in kwargs:
+                return JSONResponse(content=resp)
+
+            return resp
 
         def get_item(self, item_id: str, collection_id: str, **kwargs) -> stac.Item:
             raise NotImplementedError
@@ -234,6 +256,7 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
         ) -> stac.ItemCollection:
             raise NotImplementedError
 
+    # With FieldsExtension
     test_app = app.StacApi(
         settings=ApiSettings(enable_response_models=validate),
         client=BadCoreClient(),
@@ -258,14 +281,18 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
             },
         )
 
+    # With or without validation, /search endpoints will always return 200
+    # because we have the `FieldsExtension` enabled, so the endpoint
+    # will avoid the model validation (by returning JSONResponse)
     assert get_search.status_code == 200, get_search.text
     assert post_search.status_code == 200, post_search.text
 
+    # Without FieldsExtension
     test_app = app.StacApi(
         settings=ApiSettings(enable_response_models=validate),
         client=BadCoreClient(),
-        search_get_request_model=create_get_request_model([FieldsExtension()]),
-        search_post_request_model=create_post_request_model([FieldsExtension()]),
+        search_get_request_model=create_get_request_model([]),
+        search_post_request_model=create_post_request_model([]),
         extensions=[],
     )
 
@@ -284,7 +311,10 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
                 },
             },
         )
+
     if validate:
+        # NOTE: the `fields` options will be ignored by fastAPI because it's
+        # not part of the request model, so the client should not by-pass the validation
         assert get_search.status_code == 500, (
             get_search.json()["code"] == "ResponseValidationError"
         )
@@ -294,3 +324,66 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
     else:
         assert get_search.status_code == 200, get_search.text
         assert post_search.status_code == 200, post_search.text
+
+
+def test_request_model(AsyncTestCoreClient):
+    """Test if request models are passed correctly."""
+
+    @attr.s
+    class CollectionsRequest(APIRequest):
+        user: Annotated[str, Query(...)] = attr.ib()
+
+    @attr.s
+    class CollectionRequest(APIRequest):
+        collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+        user: Annotated[str, Query(...)] = attr.ib()
+
+    @attr.s
+    class ItemsRequest(APIRequest):
+        collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+        user: Annotated[str, Query(...)] = attr.ib()
+
+    @attr.s
+    class ItemRequest(APIRequest):
+        collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
+        item_id: Annotated[str, Path(description="Item ID")] = attr.ib()
+        user: Annotated[str, Query(...)] = attr.ib()
+
+    test_app = app.StacApi(
+        settings=ApiSettings(),
+        client=AsyncTestCoreClient(),
+        collections_get_request_model=CollectionsRequest,
+        collection_get_request_model=CollectionRequest,
+        items_get_request_model=ItemsRequest,
+        item_get_request_model=ItemRequest,
+        extensions=[],
+    )
+
+    with TestClient(test_app.app) as client:
+        resp = client.get("/collections")
+        assert resp.status_code == 400
+
+        resp = client.get("/collections", params={"user": "Luke"})
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection")
+        assert resp.status_code == 400
+
+        resp = client.get("/collections/test_collection", params={"user": "Leia"})
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection/items")
+        assert resp.status_code == 400
+
+        resp = client.get(
+            "/collections/test_collection/items", params={"user": "Obi-Wan"}
+        )
+        assert resp.status_code == 200
+
+        resp = client.get("/collections/test_collection/items/test_item")
+        assert resp.status_code == 400
+
+        resp = client.get(
+            "/collections/test_collection/items/test_item", params={"user": "Chewbacca"}
+        )
+        assert resp.status_code == 200

{stac_fastapi_api-3.0.0a4 → stac_fastapi_api-3.0.0b2}/tests/test_models.py

@@ -1,17 +1,20 @@
 import json
 
 import pytest
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.testclient import TestClient
 from pydantic import ValidationError
 
 from stac_fastapi.api.models import create_get_request_model, create_post_request_model
-from stac_fastapi.extensions.core.filter.filter import FilterExtension
-from stac_fastapi.extensions.core.sort.sort import SortExtension
+from stac_fastapi.extensions.core import FieldsExtension, FilterExtension, SortExtension
 from stac_fastapi.types.search import BaseSearchGetRequest, BaseSearchPostRequest
 
 
 def test_create_get_request_model():
-    extensions = [FilterExtension()]
-    request_model = create_get_request_model(extensions, BaseSearchGetRequest)
+    request_model = create_get_request_model(
+        extensions=[FilterExtension(), FieldsExtension()],
+        base_model=BaseSearchGetRequest,
+    )
 
     model = request_model(
         collections="test1,test2",
@@ -26,13 +29,36 @@ def test_create_get_request_model():
         datetime="2020-01-01T00:00:00Z",
         limit=10,
         filter="test==test",
-        # FIXME: https://github.com/stac-utils/stac-fastapi/issues/638
-        # hyphen aliases are not properly working
-        # **{"filter-crs": "epsg:4326", "filter-lang": "cql2-text"},
+        filter_crs="epsg:4326",
+        filter_lang="cql2-text",
     )
 
     assert model.collections == ["test1", "test2"]
-    # assert model.filter_crs == "epsg:4326"
+    assert model.filter_crs == "epsg:4326"
+
+    with pytest.raises(HTTPException):
+        request_model(datetime="yo")
+
+    app = FastAPI()
+
+    @app.get("/test")
+    def route(model=Depends(request_model)):
+        return model
+
+    with TestClient(app) as client:
+        resp = client.get(
+            "/test",
+            params={
+                "collections": "test1,test2",
+                "filter-crs": "epsg:4326",
+                "filter-lang": "cql2-text",
+            },
+        )
+        assert resp.status_code == 200
+        response_dict = resp.json()
+        assert response_dict["collections"] == ["test1", "test2"]
+        assert response_dict["filter_crs"] == "epsg:4326"
+        assert response_dict["filter_lang"] == "cql2-text"
 
 
 @pytest.mark.parametrize(
@@ -40,8 +66,10 @@ def test_create_get_request_model():
     [(None, True), ({"test": "test"}, True), ("test==test", False), ([], False)],
 )
 def test_create_post_request_model(filter, passes):
-    extensions = [FilterExtension()]
-    request_model = create_post_request_model(extensions, BaseSearchPostRequest)
+    request_model = create_post_request_model(
+        extensions=[FilterExtension(), FieldsExtension()],
+        base_model=BaseSearchPostRequest,
+    )
 
     if not passes:
         with pytest.raises(ValidationError):
@@ -78,8 +106,10 @@ def test_create_post_request_model(filter, passes):
     ],
 )
 def test_create_post_request_model_nested_fields(sortby, passes):
-    extensions = [SortExtension()]
-    request_model = create_post_request_model(extensions, BaseSearchPostRequest)
+    request_model = create_post_request_model(
+        extensions=[SortExtension()],
+        base_model=BaseSearchPostRequest,
+    )
 
     if not passes:
         with pytest.raises(ValidationError):

stac_fastapi_api-3.0.0a4/stac_fastapi/api/version.py

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