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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di-fastapi
-Version: 0.1.4
+Version: 0.3.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.3.0/modern_di_fastapi/__init__.py

@@ -0,0 +1,8 @@
+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/modern_di_fastapi/main.py

@@ -0,0 +1,37 @@
+import dataclasses
+import typing
+
+import fastapi
+from modern_di import Container, Scope, providers
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+def setup_di(app: fastapi.FastAPI) -> Container:
+    app.state.di_container = Container(scope=Scope.APP)
+    return app.state.di_container
+
+
+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:
+        yield request_container
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+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)]
+    ) -> T_co:
+        return await self.dependency.async_resolve(request_container)
+
+
+def Provide(dependency: providers.AbstractProvider[T_co], *, use_cache: bool = True) -> T_co:  # noqa: N802
+    return typing.cast(T_co, fastapi.Depends(dependency=Dependency(dependency), use_cache=use_cache))

{modern_di_fastapi-0.1.4 → modern_di_fastapi-0.3.0}/tests/test_fastapi_di.py

@@ -4,27 +4,23 @@ import typing
 
 import fastapi
 import httpx
-import modern_di
 import pytest
 from asgi_lifespan import LifespanManager
 from modern_di import Scope, providers
 from starlette import status
 from starlette.requests import Request
 
-import modern_di_fastapi
-from modern_di_fastapi import ContainerMiddleware, FromDI
+from modern_di_fastapi import Provide, setup_di
 
 
 @contextlib.asynccontextmanager
 async def lifespan(app_: fastapi.FastAPI) -> typing.AsyncIterator[None]:
-    di_container = modern_di.Container(scope=modern_di.Scope.APP)
-    modern_di_fastapi.setup_modern_di(container=di_container, app=app_)
-    async with di_container:
+    container = setup_di(app_)
+    async with container:
         yield
 
 
 app = fastapi.FastAPI(lifespan=lifespan)
-app.add_middleware(ContainerMiddleware)
 
 
 @dataclasses.dataclass(kw_only=True, slots=True)
@@ -48,9 +44,9 @@ context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_functi
 
 @app.get("/")
 async def read_root(
-    app_factory_instance: typing.Annotated[SimpleCreator, FromDI(app_factory)],
-    request_factory_instance: typing.Annotated[DependentCreator, FromDI(request_factory)],
-    method: typing.Annotated[str, FromDI(context_adapter)],
+    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)
@@ -60,7 +56,7 @@ async def read_root(
 @pytest.fixture(scope="session")
 async def client() -> typing.AsyncIterator[httpx.AsyncClient]:
     async with LifespanManager(app):
-        yield httpx.AsyncClient(app=app, base_url="http://test")
+        yield httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test")
 
 
 async def test_read_main(client: httpx.AsyncClient) -> None:

modern_di_fastapi-0.1.4/modern_di_fastapi/__init__.py

@@ -1,9 +0,0 @@
-from modern_di_fastapi.depends import FromDI, setup_modern_di
-from modern_di_fastapi.middleware import ContainerMiddleware
-
-
-__all__ = [
-    "ContainerMiddleware",
-    "FromDI",
-    "setup_modern_di",
-]

modern_di_fastapi-0.1.4/modern_di_fastapi/depends.py

@@ -1,24 +0,0 @@
-import dataclasses
-import typing
-
-import fastapi
-from modern_di import Container, providers
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-
-
-@dataclasses.dataclass(slots=True, frozen=True)
-class Dependency(typing.Generic[T_co]):
-    dependency: providers.AbstractProvider[T_co]
-
-    async def __call__(self, request: fastapi.Request) -> T_co:
-        return await self.dependency.async_resolve(request.state.modern_di_container)
-
-
-def FromDI(dependency: providers.AbstractProvider[T_co], *, use_cache: bool = True) -> T_co:  # noqa: N802
-    return typing.cast(T_co, fastapi.Depends(dependency=Dependency(dependency), use_cache=use_cache))
-
-
-def setup_modern_di(container: Container, app: fastapi.FastAPI) -> None:
-    app.state.modern_di_container = container

modern_di_fastapi-0.1.4/modern_di_fastapi/middleware.py

@@ -1,27 +0,0 @@
-import typing
-
-import modern_di
-from starlette.requests import Request
-from starlette.types import ASGIApp, Receive, Scope, Send
-
-
-class ContainerMiddleware:
-    def __init__(self, app: ASGIApp) -> None:
-        self.app = app
-
-    async def __call__(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        if scope["type"] != "http":
-            return await self.app(scope, receive, send)
-
-        request = Request(scope, receive=receive, send=send)
-        context: dict[str, typing.Any] = {"request": request}
-
-        container: modern_di.Container = request.app.state.modern_di_container
-        async with container.build_child_container(context=context) as request_container:
-            request.state.modern_di_container = request_container
-            return await self.app(scope, receive, send)