stac-fastapi.api 2.4.8__tar.gz → 2.5.0__tar.gz

stac_fastapi_api-2.5.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: stac-fastapi.api
+Version: 2.5.0
+Summary: An implementation of STAC API based on the FastAPI framework.
+Home-page: https://github.com/stac-utils/stac-fastapi
+Author: Arturo Engineering
+Author-email: engineering@arturo.ai
+License: MIT
+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: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: attrs
+Requires-Dist: pydantic[dotenv]<2
+Requires-Dist: stac_pydantic==2.0.*
+Requires-Dist: brotli_asgi
+Requires-Dist: stac-fastapi.types
+Provides-Extra: dev
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: requests; extra == "dev"
+Requires-Dist: pystac[validation]==1.*; extra == "dev"
+Provides-Extra: benchmark
+Requires-Dist: pytest-benchmark; extra == "benchmark"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: pdocs; extra == "docs"

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/setup.py

@@ -7,7 +7,7 @@ with open("README.md") as f:
 
 install_requires = [
     "attrs",
-    "pydantic[dotenv]",
+    "pydantic[dotenv]<2",
     "stac_pydantic==2.0.*",
     "brotli_asgi",
     "stac-fastapi.types",
@@ -23,6 +23,9 @@ extra_reqs = {
         "requests",
         "pystac[validation]==1.*",
     ],
+    "benchmark": [
+        "pytest-benchmark",
+    ],
     "docs": ["mkdocs", "mkdocs-material", "pdocs"],
 }
 
@@ -38,6 +41,10 @@ setup(
         "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",
+        "Programming Language :: Python :: 3.12",
         "License :: OSI Approved :: MIT License",
     ],
     keywords="STAC FastAPI COG",

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi/api/app.py

@@ -1,4 +1,5 @@
 """Fastapi app creation."""
+
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 import attr
@@ -83,10 +84,22 @@ class StacApi:
         converter=update_openapi,
     )
     router: APIRouter = attr.ib(default=attr.Factory(APIRouter))
-    title: str = attr.ib(default="stac-fastapi")
-    api_version: str = attr.ib(default="0.1")
+    title: str = attr.ib(
+        default=attr.Factory(
+            lambda self: self.settings.stac_fastapi_title, takes_self=True
+        )
+    )
+    api_version: str = attr.ib(
+        default=attr.Factory(
+            lambda self: self.settings.stac_fastapi_version, takes_self=True
+        )
+    )
     stac_version: str = attr.ib(default=STAC_VERSION)
-    description: str = attr.ib(default="stac-fastapi")
+    description: str = attr.ib(
+        default=attr.Factory(
+            lambda self: self.settings.stac_fastapi_description, takes_self=True
+        )
+    )
     search_get_request_model: Type[BaseSearchGetRequest] = attr.ib(
         default=BaseSearchGetRequest
     )
@@ -132,9 +145,7 @@ class StacApi:
             response_model_exclude_unset=False,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.landing_page, EmptyRequest, self.response_class
-            ),
+            endpoint=create_async_endpoint(self.client.landing_page, EmptyRequest),
         )
 
     def register_conformance_classes(self):
@@ -153,9 +164,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.conformance, EmptyRequest, self.response_class
-            ),
+            endpoint=create_async_endpoint(self.client.conformance, EmptyRequest),
         )
 
     def register_get_item(self):
@@ -172,9 +181,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.get_item, ItemUri, GeoJSONResponse
-            ),
+            endpoint=create_async_endpoint(self.client.get_item, ItemUri),
         )
 
     def register_post_search(self):
@@ -195,7 +202,7 @@ class StacApi:
             response_model_exclude_none=True,
             methods=["POST"],
             endpoint=create_async_endpoint(
-                self.client.post_search, self.search_post_request_model, GeoJSONResponse
+                self.client.post_search, self.search_post_request_model
             ),
         )
 
@@ -217,7 +224,7 @@ class StacApi:
             response_model_exclude_none=True,
             methods=["GET"],
             endpoint=create_async_endpoint(
-                self.client.get_search, self.search_get_request_model, GeoJSONResponse
+                self.client.get_search, self.search_get_request_model
             ),
         )
 
@@ -237,9 +244,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.all_collections, EmptyRequest, self.response_class
-            ),
+            endpoint=create_async_endpoint(self.client.all_collections, EmptyRequest),
         )
 
     def register_get_collection(self):
@@ -256,9 +261,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.get_collection, CollectionUri, self.response_class
-            ),
+            endpoint=create_async_endpoint(self.client.get_collection, CollectionUri),
         )
 
     def register_get_item_collection(self):
@@ -287,9 +290,7 @@ class StacApi:
             response_model_exclude_unset=True,
             response_model_exclude_none=True,
             methods=["GET"],
-            endpoint=create_async_endpoint(
-                self.client.item_collection, request_model, GeoJSONResponse
-            ),
+            endpoint=create_async_endpoint(self.client.item_collection, request_model),
         )
 
     def register_core(self):

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi/api/middleware.py

@@ -10,7 +10,7 @@ from starlette.types import ASGIApp, Receive, Scope, Send
 
 class CORSMiddleware(_CORSMiddleware):
     """Subclass of Starlette's standard CORS middleware with default values set to those
-    reccomended by the STAC API spec.
+    recommended by the STAC API spec.
 
     https://github.com/radiantearth/stac-api-spec/blob/914cf8108302e2ec734340080a45aaae4859bb63/implementation.md#cors
     """
@@ -103,6 +103,7 @@ class ProxyHeaderMiddleware:
                             # ignore ports that are not valid integers
                             pass
         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:

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi/api/models.py

@@ -7,13 +7,15 @@ import attr
 from fastapi import Body, Path
 from pydantic import BaseModel, create_model
 from pydantic.fields import UndefinedType
+from stac_pydantic.shared import BBox
 
 from stac_fastapi.types.extension import ApiExtension
+from stac_fastapi.types.rfc3339 import DateTimeType
 from stac_fastapi.types.search import (
     APIRequest,
     BaseSearchGetRequest,
     BaseSearchPostRequest,
-    str2list,
+    str2bbox,
 )
 
 
@@ -124,8 +126,8 @@ class ItemCollectionUri(CollectionUri):
     """Get item collection."""
 
     limit: int = attr.ib(default=10)
-    bbox: Optional[str] = attr.ib(default=None, converter=str2list)
-    datetime: Optional[str] = attr.ib(default=None)
+    bbox: Optional[BBox] = attr.ib(default=None, converter=str2bbox)
+    datetime: Optional[DateTimeType] = attr.ib(default=None)
 
 
 class POSTTokenPagination(BaseModel):

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi/api/routes.py

@@ -1,6 +1,8 @@
 """Route factories."""
+
 import functools
 import inspect
+import warnings
 from typing import Any, Callable, Dict, List, Optional, Type, TypedDict, Union
 
 from fastapi import Depends, params
@@ -8,18 +10,16 @@ from fastapi.dependencies.utils import get_parameterless_sub_dependant
 from pydantic import BaseModel
 from starlette.concurrency import run_in_threadpool
 from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
+from starlette.responses import Response
 from starlette.routing import BaseRoute, Match
 from starlette.status import HTTP_204_NO_CONTENT
 
 from stac_fastapi.api.models import APIRequest
 
 
-def _wrap_response(resp: Any, response_class: Type[Response]) -> Response:
-    if isinstance(resp, Response):
+def _wrap_response(resp: Any) -> Any:
+    if resp is not None:
         return resp
-    elif resp is not None:
-        return response_class(resp)
     else:  # None is returned as 204 No Content
         return Response(status_code=HTTP_204_NO_CONTENT)
 
@@ -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: Type[Response] = JSONResponse,
+    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.warns(
+            "`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)
 
@@ -53,9 +60,7 @@ def create_async_endpoint(
             request_data: request_model = Depends(),  # type:ignore
         ):
             """Endpoint."""
-            return _wrap_response(
-                await func(request=request, **request_data.kwargs()), response_class
-            )
+            return _wrap_response(await func(request=request, **request_data.kwargs()))
 
     elif issubclass(request_model, BaseModel):
 
@@ -64,9 +69,7 @@ def create_async_endpoint(
             request_data: request_model,  # type:ignore
         ):
             """Endpoint."""
-            return _wrap_response(
-                await func(request_data, request=request), response_class
-            )
+            return _wrap_response(await func(request_data, request=request))
 
     else:
 
@@ -75,9 +78,7 @@ def create_async_endpoint(
             request_data: Dict[str, Any],  # type:ignore
         ):
             """Endpoint."""
-            return _wrap_response(
-                await func(request_data, request=request), response_class
-            )
+            return _wrap_response(await func(request_data, request=request))
 
     return _endpoint
 

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi/api/version.py

@@ -1,2 +1,2 @@
 """Library version."""
-__version__ = "2.4.8"
+__version__ = "2.5.0"

stac_fastapi_api-2.5.0/stac_fastapi.api.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: stac-fastapi.api
+Version: 2.5.0
+Summary: An implementation of STAC API based on the FastAPI framework.
+Home-page: https://github.com/stac-utils/stac-fastapi
+Author: Arturo Engineering
+Author-email: engineering@arturo.ai
+License: MIT
+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: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: attrs
+Requires-Dist: pydantic[dotenv]<2
+Requires-Dist: stac_pydantic==2.0.*
+Requires-Dist: brotli_asgi
+Requires-Dist: stac-fastapi.types
+Provides-Extra: dev
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: requests; extra == "dev"
+Requires-Dist: pystac[validation]==1.*; extra == "dev"
+Provides-Extra: benchmark
+Requires-Dist: pytest-benchmark; extra == "benchmark"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: pdocs; extra == "docs"

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi.api.egg-info/SOURCES.txt

@@ -15,4 +15,6 @@ stac_fastapi/api/middleware.py
 stac_fastapi/api/models.py
 stac_fastapi/api/openapi.py
 stac_fastapi/api/routes.py
-stac_fastapi/api/version.py
+stac_fastapi/api/version.py
+tests/test_api.py
+tests/test_middleware.py

{stac-fastapi.api-2.4.8 → stac_fastapi_api-2.5.0}/stac_fastapi.api.egg-info/requires.txt

@@ -1,9 +1,12 @@
 attrs
-pydantic[dotenv]
+pydantic[dotenv]<2
 stac_pydantic==2.0.*
 brotli_asgi
 stac-fastapi.types
 
+[benchmark]
+pytest-benchmark
+
 [dev]
 httpx
 pytest

stac_fastapi_api-2.5.0/tests/test_api.py

@@ -0,0 +1,140 @@
+from fastapi import Depends, HTTPException, security, status
+from starlette.testclient import TestClient
+
+from stac_fastapi.api.app import StacApi
+from stac_fastapi.extensions.core import TokenPaginationExtension, TransactionExtension
+from stac_fastapi.types import config, core
+
+
+class TestRouteDependencies:
+    @staticmethod
+    def _build_api(**overrides):
+        settings = config.ApiSettings()
+        return StacApi(
+            **{
+                "settings": settings,
+                "client": DummyCoreClient(),
+                "extensions": [
+                    TransactionExtension(
+                        client=DummyTransactionsClient(), settings=settings
+                    ),
+                    TokenPaginationExtension(),
+                ],
+                **overrides,
+            }
+        )
+
+    @staticmethod
+    def _assert_dependency_applied(api, routes):
+        with TestClient(api.app) as client:
+            for route in routes:
+                response = getattr(client, route["method"].lower())(route["path"])
+                assert (
+                    response.status_code == 401
+                ), "Unauthenticated requests should be rejected"
+                assert response.json() == {"detail": "Not authenticated"}
+
+                path = route["path"].format(
+                    collectionId="test_collection", itemId="test_item"
+                )
+                response = client.request(
+                    method=route["method"].lower(),
+                    url=path,
+                    auth=("bob", "dobbs"),
+                    content='{"dummy": "payload"}',
+                    headers={"content-type": "application/json"},
+                )
+                assert (
+                    response.status_code == 200
+                ), "Authenticated requests should be accepted"
+                assert response.json() == "dummy response"
+
+    def test_openapi_content_type(self):
+        api = self._build_api()
+        with TestClient(api.app) as client:
+            response = client.get(api.settings.openapi_url)
+            assert (
+                response.headers["content-type"]
+                == "application/vnd.oai.openapi+json;version=3.0"
+            )
+
+    def test_build_api_with_route_dependencies(self):
+        routes = [
+            {"path": "/collections", "method": "POST"},
+            {"path": "/collections/{collectionId}", "method": "PUT"},
+            {"path": "/collections/{collectionId}", "method": "DELETE"},
+            {"path": "/collections/{collectionId}/items", "method": "POST"},
+            {"path": "/collections/{collectionId}/items/{itemId}", "method": "PUT"},
+            {"path": "/collections/{collectionId}/items/{itemId}", "method": "DELETE"},
+        ]
+        dependencies = [Depends(must_be_bob)]
+        api = self._build_api(route_dependencies=[(routes, dependencies)])
+        self._assert_dependency_applied(api, routes)
+
+    def test_add_route_dependencies_after_building_api(self):
+        routes = [
+            {"path": "/collections", "method": "POST"},
+            {"path": "/collections/{collectionId}", "method": "PUT"},
+            {"path": "/collections/{collectionId}", "method": "DELETE"},
+            {"path": "/collections/{collectionId}/items", "method": "POST"},
+            {"path": "/collections/{collectionId}/items/{itemId}", "method": "PUT"},
+            {"path": "/collections/{collectionId}/items/{itemId}", "method": "DELETE"},
+        ]
+        api = self._build_api()
+        api.add_route_dependencies(scopes=routes, dependencies=[Depends(must_be_bob)])
+        self._assert_dependency_applied(api, routes)
+
+
+class DummyCoreClient(core.BaseCoreClient):
+    def all_collections(self, *args, **kwargs):
+        ...
+
+    def get_collection(self, *args, **kwargs):
+        ...
+
+    def get_item(self, *args, **kwargs):
+        ...
+
+    def get_search(self, *args, **kwargs):
+        ...
+
+    def post_search(self, *args, **kwargs):
+        ...
+
+    def item_collection(self, *args, **kwargs):
+        ...
+
+
+class DummyTransactionsClient(core.BaseTransactionsClient):
+    """Defines a pattern for implementing the STAC transaction extension."""
+
+    def create_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def update_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def delete_item(self, *args, **kwargs):
+        return "dummy response"
+
+    def create_collection(self, *args, **kwargs):
+        return "dummy response"
+
+    def update_collection(self, *args, **kwargs):
+        return "dummy response"
+
+    def delete_collection(self, *args, **kwargs):
+        return "dummy response"
+
+
+def must_be_bob(
+    credentials: security.HTTPBasicCredentials = Depends(security.HTTPBasic()),
+):
+    if credentials.username == "bob":
+        return True
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="You're not Bob",
+        headers={"WWW-Authenticate": "Basic"},
+    )

stac_fastapi_api-2.5.0/tests/test_middleware.py

@@ -0,0 +1,168 @@
+from unittest import mock
+
+import pytest
+from starlette.applications import Starlette
+from starlette.testclient import TestClient
+
+from stac_fastapi.api.app import StacApi
+from stac_fastapi.api.middleware import ProxyHeaderMiddleware
+from stac_fastapi.types.config import ApiSettings
+from stac_fastapi.types.core import BaseCoreClient
+
+
+@pytest.fixture
+def proxy_header_middleware() -> ProxyHeaderMiddleware:
+    app = Starlette()
+    return ProxyHeaderMiddleware(app)
+
+
+@pytest.fixture
+def test_client() -> TestClient:
+    app = StacApi(settings=ApiSettings(), client=mock.create_autospec(BaseCoreClient))
+    with TestClient(app.app) as client:
+        yield client
+
+
+@pytest.mark.parametrize(
+    "headers,key,expected",
+    [
+        ([(b"host", b"testserver")], "host", "testserver"),
+        ([(b"host", b"testserver")], "user-agent", None),
+        (
+            [(b"host", b"testserver"), (b"accept-encoding", b"gzip, deflate, br")],
+            "accept-encoding",
+            "gzip, deflate, br",
+        ),
+    ],
+)
+def test_get_header_value_by_name(
+    proxy_header_middleware: ProxyHeaderMiddleware, headers, key, expected
+):
+    scope = {"headers": headers}
+    actual = proxy_header_middleware._get_header_value_by_name(scope, key)
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "headers,key,value",
+    [
+        ([(b"host", b"testserver")], "host", "another-server"),
+        ([(b"host", b"testserver")], "user-agent", "agent"),
+        (
+            [(b"host", b"testserver"), (b"accept-encoding", b"gzip, deflate, br")],
+            "accept-encoding",
+            "deflate",
+        ),
+    ],
+)
+def test_replace_header_value_by_name(
+    proxy_header_middleware: ProxyHeaderMiddleware, headers, key, value
+):
+    scope = {"headers": headers}
+    updated_headers = proxy_header_middleware._replace_header_value_by_name(
+        scope, key, value
+    )
+
+    header_value = proxy_header_middleware._get_header_value_by_name(
+        {"headers": updated_headers}, key
+    )
+    assert header_value == value
+
+
+@pytest.mark.parametrize(
+    "scope,expected",
+    [
+        (
+            {"scheme": "https", "server": ["testserver", 80], "headers": []},
+            ("https", "testserver", 80),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"host", b"testserver:81")],
+            },
+            ("http", "testserver", 81),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"host", b"testserver")],
+            },
+            ("http", "testserver", None),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"forwarded", b"proto=https;host=test:1234")],
+            },
+            ("https", "test", 1234),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"forwarded", b"proto=https;host=test:not-an-integer")],
+            },
+            ("https", "test", 80),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"x-forwarded-host", b"test")],
+            },
+            ("http", "test", 80),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"x-forwarded-proto", b"https")],
+            },
+            ("https", "testserver", 80),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"x-forwarded-port", b"1111")],
+            },
+            ("http", "testserver", 1111),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [(b"x-forwarded-port", b"not-an-integer")],
+            },
+            ("http", "testserver", 80),
+        ),
+        (
+            {
+                "scheme": "http",
+                "server": ["testserver", 80],
+                "headers": [
+                    (b"forwarded", b"proto=https;host=test:1234"),
+                    (b"x-forwarded-host", b"another-test"),
+                    (b"x-forwarded-port", b"1111"),
+                    (b"x-forwarded-proto", b"https"),
+                ],
+            },
+            ("https", "test", 1234),
+        ),
+    ],
+)
+def test_get_forwarded_url_parts(
+    proxy_header_middleware: ProxyHeaderMiddleware, scope, expected
+):
+    actual = proxy_header_middleware._get_forwarded_url_parts(scope)
+    assert actual == expected
+
+
+def test_cors_middleware(test_client):
+    resp = test_client.get("/_mgmt/ping", headers={"Origin": "http://netloc"})
+    assert resp.status_code == 200
+    assert resp.headers["access-control-allow-origin"] == "*"

stac-fastapi.api-2.4.8/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: stac-fastapi.api
-Version: 2.4.8
-Summary: An implementation of STAC API based on the FastAPI framework.
-Home-page: https://github.com/stac-utils/stac-fastapi
-Author: Arturo Engineering
-Author-email: engineering@arturo.ai
-License: MIT
-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: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: docs

stac-fastapi.api-2.4.8/stac_fastapi.api.egg-info/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: stac-fastapi.api
-Version: 2.4.8
-Summary: An implementation of STAC API based on the FastAPI framework.
-Home-page: https://github.com/stac-utils/stac-fastapi
-Author: Arturo Engineering
-Author-email: engineering@arturo.ai
-License: MIT
-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: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: docs