stac-fastapi.api 3.0.2__tar.gz → 3.0.4__tar.gz

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.2
+Version: 3.0.4
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/setup.py

@@ -41,6 +41,7 @@ setup(
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "License :: OSI Approved :: MIT License",
     ],
     keywords="STAC FastAPI COG",

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/stac_fastapi/api/app.py

@@ -10,8 +10,8 @@ from fastapi.openapi.utils import get_openapi
 from fastapi.params import Depends
 from stac_pydantic import api
 from stac_pydantic.api.collections import Collections
-from stac_pydantic.api.version import STAC_API_VERSION
 from stac_pydantic.shared import MimeTypes
+from stac_pydantic.version import STAC_VERSION
 from starlette.middleware import Middleware
 from starlette.responses import JSONResponse, Response
 
@@ -77,6 +77,7 @@ class StacApi:
                 openapi_url=self.settings.openapi_url,
                 docs_url=self.settings.docs_url,
                 redoc_url=None,
+                root_path=self.settings.root_path,
             ),
             takes_self=True,
         ),
@@ -93,7 +94,7 @@ class StacApi:
             lambda self: self.settings.stac_fastapi_version, takes_self=True
         )
     )
-    stac_version: str = attr.ib(default=STAC_API_VERSION)
+    stac_version: str = attr.ib(default=STAC_VERSION)
     description: str = attr.ib(
         default=attr.Factory(
             lambda self: self.settings.stac_fastapi_description, takes_self=True

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/stac_fastapi/api/errors.py

@@ -4,6 +4,7 @@ import logging
 from typing import Callable, Dict, Type, TypedDict
 
 from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError, ResponseValidationError
 from starlette import status
 from starlette.requests import Request
@@ -88,7 +89,7 @@ def add_exception_handlers(
         request: Request, exc: RequestValidationError
     ) -> JSONResponse:
         return JSONResponse(
-            content=ErrorResponse(code=exc.__class__.__name__, description=str(exc)),
+            content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
             status_code=status.HTTP_400_BAD_REQUEST,
         )
 

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/stac_fastapi/api/version.py

@@ -1,3 +1,3 @@
 """Library version."""
 
-__version__ = "3.0.2"
+__version__ = "3.0.4"

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.api
-Version: 3.0.2
+Version: 3.0.4
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/tests/test_app.py

@@ -165,13 +165,11 @@ def test_filter_extension(validate, TestCoreClient, item_dict):
                 type="FeatureCollection", features=[stac.Item(**item_dict)]
             )
 
-    post_request_model = create_post_request_model([FilterExtension()])
-
     test_app = app.StacApi(
         settings=ApiSettings(enable_response_models=validate),
-        client=FilterClient(post_request_model=post_request_model),
+        client=FilterClient(),
         search_get_request_model=create_get_request_model([FilterExtension()]),
-        search_post_request_model=post_request_model,
+        search_post_request_model=create_post_request_model([FilterExtension()]),
         extensions=[FilterExtension()],
     )
 
@@ -191,7 +189,7 @@ def test_filter_extension(validate, TestCoreClient, item_dict):
                 "collections": ["test"],
                 "filter": {},
                 "filter-crs": "EPSG:4326",
-                "filter-lang": "cql2-text",
+                "filter-lang": "cql2-json",
             },
         )
 
@@ -387,3 +385,70 @@ def test_request_model(AsyncTestCoreClient):
             "/collections/test_collection/items/test_item", params={"user": "Chewbacca"}
         )
         assert resp.status_code == 200
+
+
+def test_client_datetime_input_params():
+    """Test all endpoints. Verify input models."""
+
+    class FakeClient(BaseCoreClient):
+        def post_search(self, search_request: BaseSearchPostRequest, **kwargs):
+            return search_request.datetime
+
+        def get_search(
+            self,
+            collections: Optional[List[str]] = None,
+            ids: Optional[List[str]] = None,
+            bbox: Optional[List[NumType]] = None,
+            intersects: Optional[str] = None,
+            datetime: Optional[Union[str, datetime]] = None,
+            limit: Optional[int] = 10,
+            **kwargs,
+        ):
+            return datetime
+
+        def get_item(self, item_id: str, collection_id: str, **kwargs) -> stac.Item:
+            raise NotImplementedError
+
+        def all_collections(self, **kwargs) -> stac.Collections:
+            raise NotImplementedError
+
+        def get_collection(self, collection_id: str, **kwargs) -> stac.Collection:
+            raise NotImplementedError
+
+        def item_collection(
+            self,
+            collection_id: str,
+            bbox: Optional[List[Union[float, int]]] = None,
+            datetime: Optional[Union[str, datetime]] = None,
+            limit: int = 10,
+            token: str = None,
+            **kwargs,
+        ) -> stac.ItemCollection:
+            raise NotImplementedError
+
+    test_app = app.StacApi(
+        settings=ApiSettings(enable_response_models=False),
+        client=FakeClient(),
+    )
+
+    with TestClient(test_app.app) as client:
+        get_search = client.get(
+            "/search",
+            params={
+                "collections": ["test"],
+                "datetime": "2020-01-01T00:00:00.00001Z",
+            },
+        )
+        post_search = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+                "datetime": "2020-01-01T00:00:00.00001Z",
+            },
+        )
+
+    assert get_search.status_code == 200, get_search.text
+    assert get_search.json() == "2020-01-01T00:00:00.000010+00:00"
+
+    assert post_search.status_code == 200, post_search.text
+    assert post_search.json() == "2020-01-01T00:00:00.00001Z"

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/tests/test_app_prefix.py

@@ -144,3 +144,67 @@ def test_async_api_prefix(AsyncTestCoreClient, prefix):
 
             resp = client.get(prefix + expected_path)
             assert resp.status_code == 200
+
+
+@pytest.mark.parametrize("prefix", ["", "/a_prefix"])
+def test_api_prefix_with_root_path(TestCoreClient, prefix):
+    api_settings = ApiSettings(
+        openapi_url=f"{prefix}/api", docs_url=f"{prefix}/api.html", root_path="/api/v1"
+    )
+
+    api = StacApi(
+        settings=api_settings,
+        client=TestCoreClient(),
+        router=APIRouter(prefix=prefix),
+    )
+
+    prefix = "/api/v1" + prefix
+    with TestClient(api.app, base_url="http://stac.io", root_path="/api/v1") as client:
+        landing = client.get(f"{prefix}/")
+        assert landing.status_code == 200, landing.json()
+        print(landing.text)
+        service_doc = client.get(f"{prefix}/api.html")
+        assert service_doc.status_code == 200, service_doc.text
+
+        service_desc = client.get(f"{prefix}/api")
+        assert service_desc.status_code == 200, service_desc.json()
+
+        conformance = client.get(f"{prefix}/conformance")
+        assert conformance.status_code == 200, conformance.json()
+
+        # NOTE: The collections/collection/items/item links do not have the prefix
+        # because they are created in the fixtures
+        collections = client.get(f"{prefix}/collections")
+        assert collections.status_code == 200, collections.json()
+        collection_id = collections.json()["collections"][0]["id"]
+
+        collection = client.get(f"{prefix}/collections/{collection_id}")
+        assert collection.status_code == 200, collection.json()
+
+        items = client.get(f"{prefix}/collections/{collection_id}/items")
+        assert items.status_code == 200, items.json()
+
+        item_id = items.json()["features"][0]["id"]
+        item = client.get(f"{prefix}/collections/{collection_id}/items/{item_id}")
+        assert item.status_code == 200, item.json()
+
+        link_tests = [
+            ("root", "application/json", "/"),
+            ("conformance", "application/json", "/conformance"),
+            ("data", "application/json", "/collections"),
+            ("search", "application/geo+json", "/search"),
+            ("service-doc", "text/html", "/api.html"),
+            ("service-desc", "application/vnd.oai.openapi+json;version=3.0", "/api"),
+        ]
+
+        for rel_type, expected_media_type, expected_path in link_tests:
+            link = get_link(landing.json(), rel_type)
+
+            assert link is not None, f"Missing {rel_type} link in landing page"
+            assert link.get("type") == expected_media_type
+
+            link_path = urllib.parse.urlsplit(link.get("href")).path
+            assert link_path == prefix + expected_path
+
+            resp = client.get(prefix + expected_path)
+            assert resp.status_code == 200

{stac_fastapi_api-3.0.2 → stac_fastapi_api-3.0.4}/tests/test_models.py

@@ -26,7 +26,7 @@ def test_create_get_request_model():
                 "coordinates": [[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]],
             }
         ),
-        datetime="2020-01-01T00:00:00Z",
+        datetime="2020-01-01T00:00:00.00001Z",
         limit=10,
         filter="test==test",
         filter_crs="epsg:4326",
@@ -35,6 +35,8 @@ def test_create_get_request_model():
 
     assert model.collections == ["test1", "test2"]
     assert model.filter_crs == "epsg:4326"
+    d = model.datetime
+    assert d.microsecond == 10
 
     with pytest.raises(HTTPException):
         request_model(datetime="yo")
@@ -62,10 +64,10 @@ def test_create_get_request_model():
 
 
 @pytest.mark.parametrize(
-    "filter,passes",
-    [(None, True), ({"test": "test"}, True), ("test==test", False), ([], False)],
+    "filter_val,passes",
+    [(None, True), ({"test": "test"}, True), ([], False)],
 )
-def test_create_post_request_model(filter, passes):
+def test_create_post_request_model(filter_val, passes):
     request_model = create_post_request_model(
         extensions=[FilterExtension(), FieldsExtension()],
         base_model=BaseSearchPostRequest,
@@ -73,21 +75,22 @@ def test_create_post_request_model(filter, passes):
 
     if not passes:
         with pytest.raises(ValidationError):
-            model = request_model(filter=filter)
+            model = request_model(filter=filter_val)
     else:
         model = request_model(
             collections=["test1", "test2"],
             ids=["test1", "test2"],
             bbox=[0, 0, 1, 1],
-            datetime="2020-01-01T00:00:00Z",
+            datetime="2020-01-01T00:00:00.00001Z",
             limit=10,
-            filter=filter,
-            **{"filter-crs": "epsg:4326", "filter-lang": "cql2-text"},
+            filter=filter_val,
+            **{"filter-crs": "epsg:4326", "filter-lang": "cql2-json"},
         )
 
         assert model.collections == ["test1", "test2"]
         assert model.filter_crs == "epsg:4326"
-        assert model.filter == filter
+        assert model.filter == filter_val
+        assert model.datetime == "2020-01-01T00:00:00.00001Z"
 
 
 @pytest.mark.parametrize(