stac-fastapi.types 3.0.0b2__tar.gz → 3.0.1__tar.gz

{stac_fastapi_types-3.0.0b2 → stac_fastapi_types-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.types
-Version: 3.0.0b2
+Version: 3.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
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: fastapi-slim>=0.111.0
+Requires-Dist: fastapi>=0.109.0
 Requires-Dist: attrs>=23.2.0
 Requires-Dist: pydantic-settings>=2
 Requires-Dist: stac_pydantic~=3.1

{stac_fastapi_types-3.0.0b2 → stac_fastapi_types-3.0.1}/setup.py

@@ -6,7 +6,7 @@ with open("README.md") as f:
     desc = f.read()
 
 install_requires = [
-    "fastapi-slim>=0.111.0",
+    "fastapi>=0.109.0",
     "attrs>=23.2.0",
     "pydantic-settings>=2",
     "stac_pydantic~=3.1",

{stac_fastapi_types-3.0.0b2 → stac_fastapi_types-3.0.1}/stac_fastapi/types/core.py

@@ -1,8 +1,6 @@
 """Base clients."""
 
 import abc
-import importlib
-import warnings
 from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urljoin
 
@@ -784,18 +782,3 @@ class AsyncBaseCoreClient(LandingPageMixin, abc.ABC):
             An ItemCollection.
         """
         ...
-
-
-# TODO: remove for 3.0.0 final release
-def __getattr__(name: str) -> Any:
-    if name in ["AsyncBaseFiltersClient", "BaseFiltersClient"]:
-        warnings.warn(
-            f"""importing {name} from `stac_fastapi.types.core` is deprecated,
-            please import it from `stac_fastapi.extensions.core.filter.client`.""",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        clients = importlib.import_module("stac_fastapi.extensions.core.filter.client")
-        return getattr(clients, name)
-
-    raise AttributeError(f"module {__name__} has no attribute {name}")

stac_fastapi_types-3.0.1/stac_fastapi/types/search.py

@@ -0,0 +1,190 @@
+"""stac_fastapi.types.search module.
+
+"""
+
+from typing import Dict, List, Optional, Union
+
+import attr
+from fastapi import Query
+from pydantic import Field, PositiveInt
+from pydantic.functional_validators import AfterValidator
+from stac_pydantic.api import Search
+from stac_pydantic.shared import BBox
+from typing_extensions import Annotated
+
+from stac_fastapi.types.rfc3339 import DateTimeType, str_to_interval
+
+
+def crop(v: PositiveInt) -> PositiveInt:
+    """Crop value to 10,000."""
+    limit = 10_000
+    if v > limit:
+        v = limit
+    return v
+
+
+def str2list(x: str) -> Optional[List[str]]:
+    """Convert string to list base on , delimiter."""
+    if x:
+        return x.split(",")
+
+    return None
+
+
+def str2bbox(x: str) -> Optional[BBox]:
+    """Convert string to BBox based on , delimiter."""
+    if x:
+        t = tuple(float(v) for v in str2list(x))
+        assert len(t) == 4
+        return t
+
+    return None
+
+
+def _collection_converter(
+    val: Annotated[
+        Optional[str],
+        Query(
+            description="Array of collection Ids to search for items.",
+            json_schema_extra={
+                "example": "collection1,collection2",
+            },
+        ),
+    ] = None,
+) -> Optional[List[str]]:
+    return str2list(val)
+
+
+def _ids_converter(
+    val: Annotated[
+        Optional[str],
+        Query(
+            description="Array of Item ids to return.",
+            json_schema_extra={
+                "example": "item1,item2",
+            },
+        ),
+    ] = None,
+) -> Optional[List[str]]:
+    return str2list(val)
+
+
+def _bbox_converter(
+    val: Annotated[
+        Optional[str],
+        Query(
+            description="Only return items intersecting this bounding box. Mutually exclusive with **intersects**.",  # noqa: E501
+            json_schema_extra={
+                "example": "-175.05,-85.05,175.05,85.05",
+            },
+        ),
+    ] = None,
+) -> Optional[BBox]:
+    return str2bbox(val)
+
+
+def _datetime_converter(
+    val: Annotated[
+        Optional[str],
+        Query(
+            description="""Only return items that have a temporal property that intersects this value.\n
+Either a date-time or an interval, open or closed. Date and time expressions adhere to RFC 3339. Open intervals are expressed using double-dots.""",  # noqa: E501
+            openapi_examples={
+                "datetime": {"value": "2018-02-12T23:20:50Z"},
+                "closed-interval": {"value": "2018-02-12T00:00:00Z/2018-03-18T12:31:12Z"},
+                "open-interval-from": {"value": "2018-02-12T00:00:00Z/.."},
+                "open-interval-to": {"value": "../2018-03-18T12:31:12Z"},
+            },
+        ),
+    ] = None,
+):
+    return str_to_interval(val)
+
+
+# Be careful: https://github.com/samuelcolvin/pydantic/issues/1423#issuecomment-642797287
+NumType = Union[float, int]
+Limit = Annotated[PositiveInt, AfterValidator(crop)]
+
+
+@attr.s
+class APIRequest:
+    """Generic API Request base class."""
+
+    def kwargs(self) -> Dict:
+        """Transform api request params into format which matches the signature of the
+        endpoint."""
+        return self.__dict__
+
+
+@attr.s
+class BaseSearchGetRequest(APIRequest):
+    """Base arguments for GET Request."""
+
+    collections: Optional[List[str]] = attr.ib(
+        default=None, converter=_collection_converter
+    )
+    ids: Optional[List[str]] = attr.ib(default=None, converter=_ids_converter)
+    bbox: Optional[BBox] = attr.ib(default=None, converter=_bbox_converter)
+    intersects: Annotated[
+        Optional[str],
+        Query(
+            description="""Only return items intersecting this GeoJSON Geometry. Mutually exclusive with **bbox**. \n
+*Remember to URL encode the GeoJSON geometry when using GET request*.""",  # noqa: E501
+            openapi_examples={
+                "madrid": {
+                    "value": {
+                        "type": "Feature",
+                        "properties": {},
+                        "geometry": {
+                            "coordinates": [
+                                [
+                                    [-3.8549260500072933, 40.54923557897152],
+                                    [-3.8549260500072933, 40.29428000041938],
+                                    [-3.516597069715033, 40.29428000041938],
+                                    [-3.516597069715033, 40.54923557897152],
+                                    [-3.8549260500072933, 40.54923557897152],
+                                ]
+                            ],
+                            "type": "Polygon",
+                        },
+                    },
+                },
+                "new-york": {
+                    "value": {
+                        "type": "Feature",
+                        "properties": {},
+                        "geometry": {
+                            "coordinates": [
+                                [
+                                    [-74.50117532354284, 41.128266394414055],
+                                    [-74.50117532354284, 40.35633909727355],
+                                    [-73.46713183168603, 40.35633909727355],
+                                    [-73.46713183168603, 41.128266394414055],
+                                    [-74.50117532354284, 41.128266394414055],
+                                ]
+                            ],
+                            "type": "Polygon",
+                        },
+                    },
+                },
+            },
+        ),
+    ] = attr.ib(default=None)
+    datetime: Optional[DateTimeType] = attr.ib(
+        default=None, converter=_datetime_converter
+    )
+    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)
+
+
+class BaseSearchPostRequest(Search):
+    """Base arguments for POST Request."""
+
+    limit: Optional[Limit] = Field(
+        10,
+        description="Limits the number of results that are included in each page of the response (capped to 10_000).",  # noqa: E501
+    )

stac_fastapi_types-3.0.1/stac_fastapi/types/version.py

@@ -0,0 +1,3 @@
+"""Library version."""
+
+__version__ = "3.0.1"

{stac_fastapi_types-3.0.0b2 → stac_fastapi_types-3.0.1}/stac_fastapi.types.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.types
-Version: 3.0.0b2
+Version: 3.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
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: fastapi-slim>=0.111.0
+Requires-Dist: fastapi>=0.109.0
 Requires-Dist: attrs>=23.2.0
 Requires-Dist: pydantic-settings>=2
 Requires-Dist: stac_pydantic~=3.1

{stac_fastapi_types-3.0.0b2 → stac_fastapi_types-3.0.1}/stac_fastapi.types.egg-info/requires.txt

@@ -1,4 +1,4 @@
-fastapi-slim>=0.111.0
+fastapi>=0.109.0
 attrs>=23.2.0
 pydantic-settings>=2
 stac_pydantic~=3.1

stac_fastapi_types-3.0.1/tests/test_limit.py

@@ -0,0 +1,55 @@
+import pytest
+from fastapi import Depends, FastAPI
+from fastapi.testclient import TestClient
+from pydantic import ValidationError
+
+from stac_fastapi.types.search import BaseSearchGetRequest, BaseSearchPostRequest
+
+
+@pytest.mark.parametrize("value", [0, -1])
+def test_limit_ge(value):
+    with pytest.raises(ValidationError):
+        BaseSearchPostRequest(limit=value)
+
+
+@pytest.mark.parametrize("value", [1, 10_000])
+def test_limit(value):
+    search = BaseSearchPostRequest(limit=value)
+    assert search.limit == value
+
+
+@pytest.mark.parametrize("value", [10_001, 100_000, 1_000_000])
+def test_limit_le(value):
+    search = BaseSearchPostRequest(limit=value)
+    assert search.limit == 10_000
+
+
+def test_limit_get_request():
+    """test GET model."""
+
+    app = FastAPI()
+
+    @app.get("/test")
+    def route(model=Depends(BaseSearchGetRequest)):
+        return model
+
+    with TestClient(app) as client:
+        resp = client.get(
+            "/test",
+            params={
+                "limit": 10,
+            },
+        )
+        assert resp.status_code == 200
+        response_dict = resp.json()
+        assert response_dict["limit"] == 10
+
+        resp = client.get(
+            "/test",
+            params={
+                "limit": 100_000,
+            },
+        )
+        assert resp.status_code == 200
+        response_dict = resp.json()
+        assert response_dict["limit"] == 10_000

stac_fastapi_types-3.0.0b2/stac_fastapi/types/search.py

@@ -1,74 +0,0 @@
-"""stac_fastapi.types.search module.
-
-"""
-
-from typing import Dict, List, Optional, Union
-
-import attr
-from fastapi import Query
-from pydantic import PositiveInt
-from pydantic.functional_validators import AfterValidator
-from stac_pydantic.api import Search
-from stac_pydantic.shared import BBox
-from typing_extensions import Annotated
-
-from stac_fastapi.types.rfc3339 import DateTimeType, str_to_interval
-
-
-def crop(v: PositiveInt) -> PositiveInt:
-    """Crop value to 10,000."""
-    limit = 10_000
-    if v > limit:
-        v = limit
-    return v
-
-
-def str2list(x: str) -> Optional[List]:
-    """Convert string to list base on , delimiter."""
-    if x:
-        return x.split(",")
-
-
-def str2bbox(x: str) -> Optional[BBox]:
-    """Convert string to BBox based on , delimiter."""
-    if x:
-        t = tuple(float(v) for v in str2list(x))
-        assert len(t) == 4
-        return t
-
-
-# Be careful: https://github.com/samuelcolvin/pydantic/issues/1423#issuecomment-642797287
-NumType = Union[float, int]
-Limit = Annotated[PositiveInt, AfterValidator(crop)]
-
-
-@attr.s
-class APIRequest:
-    """Generic API Request base class."""
-
-    def kwargs(self) -> Dict:
-        """Transform api request params into format which matches the signature of the
-        endpoint."""
-        return self.__dict__
-
-
-@attr.s
-class BaseSearchGetRequest(APIRequest):
-    """Base arguments for GET Request."""
-
-    collections: Annotated[Optional[str], Query()] = attr.ib(
-        default=None, converter=str2list
-    )
-    ids: Annotated[Optional[str], Query()] = attr.ib(default=None, converter=str2list)
-    bbox: Annotated[Optional[BBox], Query()] = attr.ib(default=None, converter=str2bbox)
-    intersects: Annotated[Optional[str], Query()] = attr.ib(default=None)
-    datetime: Annotated[Optional[DateTimeType], Query()] = attr.ib(
-        default=None, converter=str_to_interval
-    )
-    limit: Annotated[Optional[int], Query()] = attr.ib(default=10)
-
-
-class BaseSearchPostRequest(Search):
-    """Base arguments for POST Request."""
-
-    limit: Optional[Limit] = 10

stac_fastapi_types-3.0.0b2/stac_fastapi/types/version.py

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

stac_fastapi_types-3.0.0b2/tests/test_limit.py

@@ -1,22 +0,0 @@
-import pytest
-from pydantic import ValidationError
-
-from stac_fastapi.types.search import BaseSearchPostRequest
-
-
-@pytest.mark.parametrize("value", [0, -1])
-def test_limit_ge(value):
-    with pytest.raises(ValidationError):
-        BaseSearchPostRequest(limit=value)
-
-
-@pytest.mark.parametrize("value", [1, 10_000])
-def test_limit(value):
-    search = BaseSearchPostRequest(limit=value)
-    assert search.limit == value
-
-
-@pytest.mark.parametrize("value", [10_001, 100_000, 1_000_000])
-def test_limit_le(value):
-    search = BaseSearchPostRequest(limit=value)
-    assert search.limit == 10_000