modern-di-fastapi 0.3.0__tar.gz → 0.4.0__tar.gz

{modern_di_fastapi-0.3.0 → modern_di_fastapi-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di-fastapi
-Version: 0.3.0
+Version: 0.4.0
 Summary: Modern-DI integration for FastAPI
 Project-URL: repository, https://github.com/modern-python/modern-di
 Project-URL: docs, https://modern-di.readthedocs.io

modern_di_fastapi-0.4.0/modern_di_fastapi/__init__.py

@@ -0,0 +1,9 @@
+from modern_di_fastapi.main import Provide, build_di_container, fetch_di_container, setup_di
+
+
+__all__ = [
+    "Provide",
+    "build_di_container",
+    "fetch_di_container",
+    "setup_di",
+]

{modern_di_fastapi-0.3.0 → modern_di_fastapi-0.4.0}/modern_di_fastapi/main.py

@@ -1,15 +1,17 @@
 import dataclasses
+import enum
 import typing
 
 import fastapi
 from modern_di import Container, Scope, providers
+from starlette.requests import HTTPConnection
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 
 
-def setup_di(app: fastapi.FastAPI) -> Container:
-    app.state.di_container = Container(scope=Scope.APP)
+def setup_di(app: fastapi.FastAPI, scope: enum.IntEnum = Scope.APP) -> Container:
+    app.state.di_container = Container(scope=scope)
     return app.state.di_container
 
 
@@ -17,9 +19,17 @@ def fetch_di_container(app: fastapi.FastAPI) -> Container:
     return typing.cast(Container, app.state.di_container)
 
 
-async def _build_request_container(request: fastapi.Request) -> typing.AsyncIterator[Container]:
-    container: Container = fetch_di_container(request.app)
-    async with container.build_child_container(context={"request": request}) as request_container:
+async def build_di_container(connection: HTTPConnection) -> typing.AsyncIterator[Container]:
+    context: dict[str, typing.Any] = {}
+    scope: Scope | None = None
+    if isinstance(connection, fastapi.Request):
+        scope = Scope.REQUEST
+        context["request"] = connection
+    elif isinstance(connection, fastapi.WebSocket):
+        context["websocket"] = connection
+        scope = Scope.SESSION
+    container: Container = fetch_di_container(connection.app)
+    async with container.build_child_container(context=context, scope=scope) as request_container:
         yield request_container
 
 
@@ -28,7 +38,7 @@ class Dependency(typing.Generic[T_co]):
     dependency: providers.AbstractProvider[T_co]
 
     async def __call__(
-        self, request_container: typing.Annotated[Container, fastapi.Depends(_build_request_container)]
+        self, request_container: typing.Annotated[Container, fastapi.Depends(build_di_container)]
     ) -> T_co:
         return await self.dependency.async_resolve(request_container)
 

modern_di_fastapi-0.4.0/tests/conftest.py

@@ -0,0 +1,28 @@
+import contextlib
+import typing
+
+import fastapi
+import pytest
+from asgi_lifespan import LifespanManager
+from starlette.testclient import TestClient
+
+from modern_di_fastapi import setup_di
+
+
+@contextlib.asynccontextmanager
+async def lifespan(app_: fastapi.FastAPI) -> typing.AsyncIterator[None]:
+    container = setup_di(app_)
+    async with container:
+        yield
+
+
+@pytest.fixture
+async def app() -> typing.AsyncIterator[fastapi.FastAPI]:
+    app_ = fastapi.FastAPI(lifespan=lifespan)
+    async with LifespanManager(app_):
+        yield app_
+
+
+@pytest.fixture
+def client(app: fastapi.FastAPI) -> TestClient:
+    return TestClient(app=app)

modern_di_fastapi-0.4.0/tests/dependencies.py

@@ -0,0 +1,11 @@
+import dataclasses
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SimpleCreator:
+    dep1: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentCreator:
+    dep1: SimpleCreator

modern_di_fastapi-0.4.0/tests/test_routes.py

@@ -0,0 +1,61 @@
+import typing
+
+import fastapi
+import modern_di
+from modern_di import Scope, providers
+from starlette import status
+from starlette.testclient import TestClient
+
+from modern_di_fastapi import Provide, build_di_container
+from tests.dependencies import DependentCreator, SimpleCreator
+
+
+def context_adapter_function(*, request: fastapi.Request, **_: object) -> str:
+    return request.method
+
+
+app_factory = providers.Factory(Scope.APP, SimpleCreator, dep1="original")
+request_factory = providers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+action_factory = providers.Factory(Scope.ACTION, DependentCreator, dep1=app_factory.cast)
+context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_function)
+
+
+def test_factories(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.get("/")
+    async def read_root(
+        app_factory_instance: typing.Annotated[SimpleCreator, Provide(app_factory)],
+        request_factory_instance: typing.Annotated[DependentCreator, Provide(request_factory)],
+    ) -> None:
+        assert isinstance(app_factory_instance, SimpleCreator)
+        assert isinstance(request_factory_instance, DependentCreator)
+        assert request_factory_instance.dep1 is not app_factory_instance
+
+    response = client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() is None
+
+
+def test_context_adapter(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.get("/")
+    async def read_root(
+        method: typing.Annotated[str, Provide(context_adapter)],
+    ) -> None:
+        assert method == "GET"
+
+    response = client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() is None
+
+
+def test_factories_action_scope(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.get("/")
+    async def read_root(
+        request_container: typing.Annotated[modern_di.Container, fastapi.Depends(build_di_container)],
+    ) -> None:
+        with request_container.build_child_container() as action_container:
+            action_factory_instance = action_factory.sync_resolve(action_container)
+            assert isinstance(action_factory_instance, DependentCreator)
+
+    response = client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() is None

modern_di_fastapi-0.4.0/tests/test_websockets.py

@@ -0,0 +1,75 @@
+import typing
+
+import fastapi
+import modern_di
+from modern_di import Scope, providers
+from starlette.testclient import TestClient
+
+from modern_di_fastapi import Provide, build_di_container
+from tests.dependencies import DependentCreator, SimpleCreator
+
+
+def context_adapter_function(*, websocket: fastapi.WebSocket, **_: object) -> str:
+    return str(websocket.scope["path"])
+
+
+app_factory = providers.Factory(Scope.APP, SimpleCreator, dep1="original")
+session_factory = providers.Factory(Scope.SESSION, DependentCreator, dep1=app_factory.cast)
+request_factory = providers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+context_adapter = providers.ContextAdapter(Scope.SESSION, context_adapter_function)
+
+
+async def test_factories(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.websocket("/ws")
+    async def websocket_endpoint(
+        websocket: fastapi.WebSocket,
+        app_factory_instance: typing.Annotated[SimpleCreator, Provide(app_factory)],
+        session_factory_instance: typing.Annotated[DependentCreator, Provide(session_factory)],
+    ) -> None:
+        assert isinstance(app_factory_instance, SimpleCreator)
+        assert isinstance(session_factory_instance, DependentCreator)
+        assert session_factory_instance.dep1 is not app_factory_instance
+
+        await websocket.accept()
+        await websocket.send_text("test")
+        await websocket.close()
+
+    with client.websocket_connect("/ws") as websocket:
+        data = websocket.receive_text()
+        assert data == "test"
+
+
+async def test_factories_request_scope(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.websocket("/ws")
+    async def websocket_endpoint(
+        websocket: fastapi.WebSocket,
+        session_container: typing.Annotated[modern_di.Container, fastapi.Depends(build_di_container)],
+    ) -> None:
+        with session_container.build_child_container() as request_container:
+            request_factory_instance = request_factory.sync_resolve(request_container)
+            assert isinstance(request_factory_instance, DependentCreator)
+
+        await websocket.accept()
+        await websocket.send_text("test")
+        await websocket.close()
+
+    with client.websocket_connect("/ws") as websocket:
+        data = websocket.receive_text()
+        assert data == "test"
+
+
+async def test_context_adapter(client: TestClient, app: fastapi.FastAPI) -> None:
+    @app.websocket("/ws")
+    async def websocket_endpoint(
+        websocket: fastapi.WebSocket,
+        path: typing.Annotated[str, Provide(context_adapter)],
+    ) -> None:
+        assert path == "/ws"
+
+        await websocket.accept()
+        await websocket.send_text("test")
+        await websocket.close()
+
+    with client.websocket_connect("/ws") as websocket:
+        data = websocket.receive_text()
+        assert data == "test"

modern_di_fastapi-0.3.0/modern_di_fastapi/__init__.py

@@ -1,8 +0,0 @@
-from modern_di_fastapi.main import Provide, fetch_di_container, setup_di
-
-
-__all__ = [
-    "Provide",
-    "fetch_di_container",
-    "setup_di",
-]

modern_di_fastapi-0.3.0/tests/test_fastapi_di.py

@@ -1,65 +0,0 @@
-import contextlib
-import dataclasses
-import typing
-
-import fastapi
-import httpx
-import pytest
-from asgi_lifespan import LifespanManager
-from modern_di import Scope, providers
-from starlette import status
-from starlette.requests import Request
-
-from modern_di_fastapi import Provide, setup_di
-
-
-@contextlib.asynccontextmanager
-async def lifespan(app_: fastapi.FastAPI) -> typing.AsyncIterator[None]:
-    container = setup_di(app_)
-    async with container:
-        yield
-
-
-app = fastapi.FastAPI(lifespan=lifespan)
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class SimpleCreator:
-    dep1: str
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class DependentCreator:
-    dep1: SimpleCreator
-
-
-def context_adapter_function(*, request: Request, **_: object) -> str:
-    return request.method
-
-
-app_factory = providers.Factory(Scope.APP, SimpleCreator, dep1="original")
-request_factory = providers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
-context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_function)
-
-
-@app.get("/")
-async def read_root(
-    app_factory_instance: typing.Annotated[SimpleCreator, Provide(app_factory)],
-    request_factory_instance: typing.Annotated[DependentCreator, Provide(request_factory)],
-    method: typing.Annotated[str, Provide(context_adapter)],
-) -> str:
-    assert isinstance(app_factory_instance, SimpleCreator)
-    assert isinstance(request_factory_instance, DependentCreator)
-    return method
-
-
-@pytest.fixture(scope="session")
-async def client() -> typing.AsyncIterator[httpx.AsyncClient]:
-    async with LifespanManager(app):
-        yield httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test")
-
-
-async def test_read_main(client: httpx.AsyncClient) -> None:
-    response = await client.get("/")
-    assert response.status_code == status.HTTP_200_OK
-    assert response.json() == "GET"