stac-fastapi.api 3.0.5__tar.gz → 4.0.1__tar.gz

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stac-fastapi.api
-Version: 3.0.5
+Version: 4.0.1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -10,17 +10,16 @@ Keywords: STAC FastAPI COG
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3.8
 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types~=3.0
+Requires-Dist: stac-fastapi.types~=4.0
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/setup.py

@@ -7,7 +7,7 @@ with open("README.md") as f:
 
 install_requires = [
     "brotli_asgi",
-    "stac-fastapi.types~=3.0",
+    "stac-fastapi.types~=4.0",
 ]
 
 extra_reqs = {
@@ -31,12 +31,11 @@ setup(
     description="An implementation of STAC API based on the FastAPI framework.",
     long_description=desc,
     long_description_content_type="text/markdown",
-    python_requires=">=3.8",
+    python_requires=">=3.9",
     classifiers=[
         "Intended Audience :: Developers",
         "Intended Audience :: Information Technology",
         "Intended Audience :: Science/Research",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/stac_fastapi/api/middleware.py

@@ -1,9 +1,10 @@
 """Api middleware."""
 
+import contextlib
 import re
 import typing
 from http.client import HTTP_PORT, HTTPS_PORT
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from starlette.middleware.cors import CORSMiddleware as _CORSMiddleware
 from starlette.types import ASGIApp, Receive, Scope, Send
@@ -44,6 +45,10 @@ class CORSMiddleware(_CORSMiddleware):
         )
 
 
+_PROTO_HEADER_REGEX = re.compile(r"proto=(?P<proto>http(s)?)")
+_HOST_HEADER_REGEX = re.compile(r"host=(?P<host>[\w.-]+)(:(?P<port>\d{1,5}))?")
+
+
 class ProxyHeaderMiddleware:
     """Account for forwarding headers when deriving base URL.
 
@@ -68,11 +73,13 @@ class ProxyHeaderMiddleware:
                         proto == "https" and port != HTTPS_PORT
                     ):
                         port_suffix = f":{port}"
+
                 scope["headers"] = self._replace_header_value_by_name(
                     scope,
                     "host",
                     f"{domain}{port_suffix}",
                 )
+
         await self.app(scope, receive, send)
 
     def _get_forwarded_url_parts(self, scope: Scope) -> Tuple[str]:
@@ -87,37 +94,30 @@ class ProxyHeaderMiddleware:
             else:
                 domain = header_host_parts[0]
                 port = None
-        forwarded = self._get_header_value_by_name(scope, "forwarded")
-        if forwarded is not None:
-            parts = forwarded.split(";")
-            for part in parts:
-                if len(part) > 0 and re.search("=", part):
-                    key, value = part.split("=")
-                    if key == "proto":
-                        proto = value
-                    elif key == "host":
-                        host_parts = value.split(":")
-                        domain = host_parts[0]
-                        try:
-                            port = int(host_parts[1]) if len(host_parts) == 2 else None
-                        except ValueError:
-                            # ignore ports that are not valid integers
-                            pass
+
+        port_str = None  # make sure it is defined in all paths since we access it later
+
+        if forwarded := self._get_header_value_by_name(scope, "forwarded"):
+            for proxy in forwarded.split(","):
+                if proto_expr := _PROTO_HEADER_REGEX.search(proxy):
+                    proto = proto_expr.group("proto")
+                if host_expr := _HOST_HEADER_REGEX.search(proxy):
+                    domain = host_expr.group("host")
+                    port_str = host_expr.group("port")  # None if not present in the match
+
         else:
             domain = self._get_header_value_by_name(scope, "x-forwarded-host", domain)
             proto = self._get_header_value_by_name(scope, "x-forwarded-proto", proto)
             port_str = self._get_header_value_by_name(scope, "x-forwarded-port", port)
-            try:
-                port = int(port_str) if port_str is not None else None
-            except ValueError:
-                # ignore ports that are not valid integers
-                pass
+
+        with contextlib.suppress(ValueError):  # ignore ports that are not valid integers
+            port = int(port_str) if port_str is not None else port
 
         return (proto, domain, port)
 
     def _get_header_value_by_name(
-        self, scope: Scope, header_name: str, default_value: str = None
-    ) -> str:
+        self, scope: Scope, header_name: str, default_value: Optional[str] = None
+    ) -> Optional[str]:
         headers = scope["headers"]
         candidates = [
             value.decode() for key, value in headers if key.decode() == header_name

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/stac_fastapi/api/models.py

@@ -9,14 +9,15 @@ 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,
+    DatetimeMixin,
+    DateTimeQueryType,
     Limit,
     _bbox_converter,
-    _datetime_converter,
+    _validate_datetime,
 )
 
 try:
@@ -110,7 +111,7 @@ class EmptyRequest(APIRequest):
 
 
 @attr.s
-class ItemCollectionUri(APIRequest):
+class ItemCollectionUri(APIRequest, DatetimeMixin):
     """Get item collection."""
 
     collection_id: Annotated[str, Path(description="Collection ID")] = attr.ib()
@@ -121,9 +122,7 @@ class ItemCollectionUri(APIRequest):
         ),
     ] = attr.ib(default=10)
     bbox: Optional[BBox] = attr.ib(default=None, converter=_bbox_converter)
-    datetime: Optional[DateTimeType] = attr.ib(
-        default=None, converter=_datetime_converter
-    )
+    datetime: DateTimeQueryType = attr.ib(default=None, validator=_validate_datetime)
 
 
 class GeoJSONResponse(JSONResponse):

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/stac_fastapi/api/version.py

@@ -1,3 +1,3 @@
 """Library version."""
 
-__version__ = "3.0.5"
+__version__ = "4.0.1"

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stac-fastapi.api
-Version: 3.0.5
+Version: 4.0.1
 Summary: An implementation of STAC API based on the FastAPI framework.
 Home-page: https://github.com/stac-utils/stac-fastapi
 Author: Arturo Engineering
@@ -10,17 +10,16 @@ Keywords: STAC FastAPI COG
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3.8
 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: brotli_asgi
-Requires-Dist: stac-fastapi.types~=3.0
+Requires-Dist: stac-fastapi.types~=4.0
 Provides-Extra: dev
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/stac_fastapi.api.egg-info/requires.txt

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

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/tests/test_app.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from typing import List, Optional, Union
 
 import attr
@@ -127,7 +126,7 @@ def test_filter_extension(validate, TestCoreClient, item_dict):
             self, search_request: BaseSearchPostRequest, **kwargs
         ) -> stac.ItemCollection:
             search_request.collections = ["test"]
-            search_request.filter = {}
+            search_request.filter_expr = {}
             search_request.filter_crs = "EPSG:4326"
             search_request.filter_lang = "cql2-text"
 
@@ -141,25 +140,16 @@ def test_filter_extension(validate, TestCoreClient, item_dict):
             ids: Optional[List[str]] = None,
             bbox: Optional[List[NumType]] = None,
             intersects: Optional[str] = None,
-            datetime: Optional[Union[str, datetime]] = None,
+            datetime: Optional[str] = None,
             limit: Optional[int] = 10,
-            filter: Optional[str] = None,
+            filter_expr: Optional[str] = None,
             filter_crs: Optional[str] = None,
             filter_lang: Optional[str] = None,
             **kwargs,
         ) -> stac.ItemCollection:
-            # Check if all filter parameters are passed correctly
-
-            assert filter == "TEST"
-
-            # FIXME: https://github.com/stac-utils/stac-fastapi/issues/638
-            # hyphen alias for filter_crs and filter_lang are currently not working
-            # Query parameters `filter-crs` and `filter-lang`
-            # should be recognized by the API
-            # They are present in the `request.query_params` but not in the `kwargs`
-
-            # assert filter_crs == "EPSG:4326"
-            # assert filter_lang == "cql2-text"
+            assert filter_expr == "TEST"
+            assert filter_crs == "EPSG:4326"
+            assert filter_lang == "cql2-text"
 
             return stac.ItemCollection(
                 type="FeatureCollection", features=[stac.Item(**item_dict)]
@@ -221,7 +211,7 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
             ids: Optional[List[str]] = None,
             bbox: Optional[List[NumType]] = None,
             intersects: Optional[str] = None,
-            datetime: Optional[Union[str, datetime]] = None,
+            datetime: Optional[str] = None,
             limit: Optional[int] = 10,
             **kwargs,
         ) -> stac.ItemCollection:
@@ -247,7 +237,7 @@ def test_fields_extension(validate, TestCoreClient, item_dict):
             self,
             collection_id: str,
             bbox: Optional[List[Union[float, int]]] = None,
-            datetime: Optional[Union[str, datetime]] = None,
+            datetime: Optional[str] = None,
             limit: int = 10,
             token: str = None,
             **kwargs,
@@ -392,6 +382,7 @@ def test_client_datetime_input_params():
 
     class FakeClient(BaseCoreClient):
         def post_search(self, search_request: BaseSearchPostRequest, **kwargs):
+            assert isinstance(search_request.datetime, str)
             return search_request.datetime
 
         def get_search(
@@ -400,10 +391,11 @@ def test_client_datetime_input_params():
             ids: Optional[List[str]] = None,
             bbox: Optional[List[NumType]] = None,
             intersects: Optional[str] = None,
-            datetime: Optional[Union[str, datetime]] = None,
+            datetime: Optional[str] = None,
             limit: Optional[int] = 10,
             **kwargs,
         ):
+            assert isinstance(datetime, str)
             return datetime
 
         def get_item(self, item_id: str, collection_id: str, **kwargs) -> stac.Item:
@@ -419,7 +411,7 @@ def test_client_datetime_input_params():
             self,
             collection_id: str,
             bbox: Optional[List[Union[float, int]]] = None,
-            datetime: Optional[Union[str, datetime]] = None,
+            datetime: Optional[str] = None,
             limit: int = 10,
             token: str = None,
             **kwargs,
@@ -439,6 +431,13 @@ def test_client_datetime_input_params():
                 "datetime": "2020-01-01T00:00:00.00001Z",
             },
         )
+        get_search_zero = client.get(
+            "/search",
+            params={
+                "collections": ["test"],
+                "datetime": "2020-01-01T00:00:00.0000Z",
+            },
+        )
         post_search = client.post(
             "/search",
             json={
@@ -446,9 +445,20 @@ def test_client_datetime_input_params():
                 "datetime": "2020-01-01T00:00:00.00001Z",
             },
         )
+        post_search_zero = client.post(
+            "/search",
+            json={
+                "collections": ["test"],
+                "datetime": "2020-01-01T00:00:00.0000Z",
+            },
+        )
 
     assert get_search.status_code == 200, get_search.text
-    assert get_search.json() == "2020-01-01T00:00:00.000010+00:00"
+    assert get_search.json() == "2020-01-01T00:00:00.00001Z"
+    assert get_search_zero.status_code == 200, get_search_zero.text
+    assert get_search_zero.json() == "2020-01-01T00:00:00.0000Z"
 
     assert post_search.status_code == 200, post_search.text
     assert post_search.json() == "2020-01-01T00:00:00.00001Z"
+    assert post_search_zero.status_code == 200, post_search_zero.text
+    assert post_search_zero.json() == "2020-01-01T00:00:00.0000Z"

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/tests/test_middleware.py

@@ -155,6 +155,48 @@ def test_replace_header_value_by_name(
             },
             ("https", "test", 1234),
         ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [
+                    (
+                        b"forwarded",
+                        # two proxy servers added an entry, we want to use the last one
+                        b"proto=https;host=test:1234,proto=https;host=second-server:1111",
+                    )
+                ],
+            },
+            ("https", "second-server", 1111),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [
+                    (
+                        b"forwarded",
+                        # check when host and port are inverted
+                        b"host=test:1234;proto=https",
+                    )
+                ],
+            },
+            ("https", "test", 1234),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [
+                    (
+                        b"forwarded",
+                        # proto is set, but no host
+                        b'for="85.193.181.55";proto=https,for="85.193.181.55";proto=https',
+                    )
+                ],
+            },
+            ("https", "testserver", 80),
+        ),
     ],
 )
 def test_get_forwarded_url_parts(

{stac_fastapi_api-3.0.5 → stac_fastapi_api-4.0.1}/tests/test_models.py

@@ -28,19 +28,32 @@ def test_create_get_request_model():
         ),
         datetime="2020-01-01T00:00:00.00001Z",
         limit=10,
-        filter="test==test",
+        filter_expr="test==test",
         filter_crs="epsg:4326",
         filter_lang="cql2-text",
     )
 
     assert model.collections == ["test1", "test2"]
+    assert model.filter_expr == "test==test"
     assert model.filter_crs == "epsg:4326"
-    d = model.datetime
+    d = model.start_date
     assert d.microsecond == 10
+    assert not model.end_date
 
+    model = request_model(
+        datetime="2020-01-01T00:00:00.00001Z/2020-01-02T00:00:00.00001Z",
+    )
+    assert model.start_date
+    assert model.end_date
+
+    # invalid datetime format
     with pytest.raises(HTTPException):
         request_model(datetime="yo")
 
+    # Wrong order
+    with pytest.raises(HTTPException):
+        request_model(datetime="2020-01-02T00:00:00.00001Z/2020-01-01T00:00:00.00001Z")
+
     app = FastAPI()
 
     @app.get("/test")
@@ -52,6 +65,7 @@ def test_create_get_request_model():
             "/test",
             params={
                 "collections": "test1,test2",
+                "filter": "test=test",
                 "filter-crs": "epsg:4326",
                 "filter-lang": "cql2-text",
             },
@@ -59,6 +73,7 @@ def test_create_get_request_model():
         assert resp.status_code == 200
         response_dict = resp.json()
         assert response_dict["collections"] == ["test1", "test2"]
+        assert response_dict["filter_expr"] == "test=test"
         assert response_dict["filter_crs"] == "epsg:4326"
         assert response_dict["filter_lang"] == "cql2-text"
 
@@ -77,21 +92,27 @@ def test_create_post_request_model(filter_val, passes):
         with pytest.raises(ValidationError):
             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:00.00001Z",
-            limit=10,
-            filter=filter_val,
-            **{"filter-crs": "epsg:4326", "filter-lang": "cql2-json"},
+        model = request_model.model_validate(
+            {
+                "collections": ["test1", "test2"],
+                "ids": ["test1", "test2"],
+                "bbox": [0, 0, 1, 1],
+                "datetime": "2020-01-01T00:00:00.00001Z",
+                "limit": 10,
+                "filter": filter_val,
+                "filter-crs": "epsg:4326",
+                "filter-lang": "cql2-json",
+            }
         )
 
         assert model.collections == ["test1", "test2"]
+        assert model.filter_expr == filter_val
         assert model.filter_crs == "epsg:4326"
-        assert model.filter == filter_val
         assert model.datetime == "2020-01-01T00:00:00.00001Z"
 
+    with pytest.raises(ValidationError):
+        request_model(datetime="yo")
+
 
 @pytest.mark.parametrize(
     "sortby,passes",