modern-di 0.4.2__tar.gz → 0.4.3__tar.gz

{modern_di-0.4.2 → modern_di-0.4.3}/.github/workflows/publish.yml

@@ -15,12 +15,16 @@ jobs:
         with:
           enable-cache: true
           cache-dependency-glob: "pyproject.toml"
-      - run: just publish modern-di
-        if: startsWith(github.ref_name, 'core')
+
+      - if: startsWith(github.ref_name, 'core')
+        run: just publish modern-di
         env:
           PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
 
-      - run: just publish modern-di-fastapi
-        if: startsWith(github.ref_name, 'fastapi')
+      - if: startsWith(github.ref_name, 'fastapi')
+        run: |
+          export SETUPTOOLS_SCM_PRETEND_VERSION=$(echo "${{ github.ref_name }}" | sed 's/^fastapi-//; s/-.*$//')
+          echo "SETUPTOOLS_SCM_PRETEND_VERSION=$SETUPTOOLS_SCM_PRETEND_VERSION"
+          just publish modern-di-fastapi
         env:
           PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}

{modern_di-0.4.2 → modern_di-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.4.2
+Version: 0.4.3
 Summary: Dependency Injection framework with IOC-container and scopes
 Project-URL: repository, https://github.com/modern-python/modern-di
 Project-URL: docs, https://modern-di.readthedocs.io

modern_di-0.4.3/integrations/fastapi/Justfile

@@ -0,0 +1,18 @@
+default: install lint test
+
+install:
+    uv lock --upgrade
+    uv sync --all-extras --frozen
+
+lint:
+    uv run ruff format .
+    uv run ruff check . --fix
+    uv run mypy .
+
+lint-ci:
+    uv run ruff format . --check
+    uv run ruff check . --no-fix
+    uv run mypy .
+
+test *args:
+    uv run pytest {{ args }}

modern_di-0.4.3/integrations/fastapi/modern_di_fastapi/__init__.py

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

modern_di-0.4.3/integrations/fastapi/modern_di_fastapi/main.py

@@ -0,0 +1,38 @@
+import dataclasses
+import enum
+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, scope: enum.IntEnum = Scope.APP) -> Container:
+    app.state.di_container = Container(scope=scope)
+    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-0.4.2 → modern_di-0.4.3}/integrations/fastapi/pyproject.toml

@@ -49,9 +49,6 @@ build-backend = "hatchling.build"
 source = "vcs"
 fallback-version = "0"
 
-[tool.hatch.build.targets.wheel]
-packages = ["integrations/fastapi"]
-
 [tool.mypy]
 python_version = "3.10"
 strict = true

modern_di-0.4.3/integrations/fastapi/tests/conftest.py

@@ -0,0 +1,28 @@
+import contextlib
+import typing
+
+import fastapi
+import httpx
+import pytest
+from asgi_lifespan import LifespanManager
+
+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) -> httpx.AsyncClient:
+    return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test")

modern_di-0.4.3/integrations/fastapi/tests/dependencies.py

@@ -0,0 +1,17 @@
+import dataclasses
+
+import fastapi
+
+
+@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: fastapi.Request, **_: object) -> str:
+    return request.method

modern_di-0.4.3/integrations/fastapi/tests/test_fastapi_di.py

@@ -0,0 +1,30 @@
+import typing
+
+import fastapi
+import httpx
+from modern_di import Scope, providers
+from starlette import status
+
+from modern_di_fastapi import Provide
+from tests.dependencies import DependentCreator, SimpleCreator, context_adapter_function
+
+
+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)
+
+
+async def test_read_main(client: httpx.AsyncClient, 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)],
+        method: typing.Annotated[str, Provide(context_adapter)],
+    ) -> str:
+        assert isinstance(app_factory_instance, SimpleCreator)
+        assert isinstance(request_factory_instance, DependentCreator)
+        return method
+
+    response = await client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == "GET"

{modern_di-0.4.2 → modern_di-0.4.3}/modern_di/container.py

@@ -38,6 +38,7 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         self._is_async = None
         self._provider_states = {}
         self._overrides = {}
+        self.context = {}
 
     def _check_entered(self) -> None:
         if self._is_async is None:
@@ -57,6 +58,10 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
 
     def find_container(self, scope: enum.IntEnum) -> "typing_extensions.Self":
         container = self
+        if container.scope < scope:
+            msg = f"Scope {scope.name} is not initialized"
+            raise RuntimeError(msg)
+
         while container.scope > scope and container.parent_container:
             container = typing.cast("typing_extensions.Self", container.parent_container)
         return container

{modern_di-0.4.2 → modern_di-0.4.3}/tests/providers/test_factory.py

@@ -85,3 +85,9 @@ async def test_factory_wrong_dependency_scope() -> None:
     request_factory_ = providers.Factory(Scope.REQUEST, SimpleCreator, dep1="original")
     with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
         providers.Singleton(Scope.APP, some_factory, request_factory_.cast)
+
+
+async def test_factory_scope_is_not_initialized() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        with pytest.raises(RuntimeError, match="Scope REQUEST is not initialize"):
+            await request_factory.async_resolve(app_container)

modern_di-0.4.2/integrations/fastapi/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-0.4.2/integrations/fastapi/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-0.4.2/integrations/fastapi/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)

modern_di-0.4.2/integrations/fastapi/tests/test_fastapi_di.py

@@ -1,69 +0,0 @@
-import contextlib
-import dataclasses
-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
-
-
-@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:
-        yield
-
-
-app = fastapi.FastAPI(lifespan=lifespan)
-app.add_middleware(ContainerMiddleware)
-
-
-@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, FromDI(app_factory)],
-    request_factory_instance: typing.Annotated[DependentCreator, FromDI(request_factory)],
-    method: typing.Annotated[str, FromDI(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(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"