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

{modern_di-0.4.2 → modern_di-0.5.0}/.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.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.4.2
+Version: 0.5.0
 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.5.0/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.5.0/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.5.0/integrations/fastapi/modern_di_fastapi/main.py

@@ -0,0 +1,47 @@
+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, 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(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
+
+
+@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.5.0}/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.5.0/integrations/fastapi/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-0.5.0/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.5.0/integrations/fastapi/tests/test_routes.py

@@ -0,0 +1,57 @@
+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_request_container
+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)
+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_request_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-0.5.0/integrations/fastapi/tests/test_websockets.py

@@ -0,0 +1,33 @@
+import typing
+
+import fastapi
+from modern_di import Scope, providers
+from starlette.testclient import TestClient
+
+from modern_di_fastapi import Provide
+from tests.dependencies import DependentCreator, SimpleCreator
+
+
+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)
+
+
+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_json({"msg": "Hello WebSocket"})
+        await websocket.close()
+
+    with client.websocket_connect("/ws") as websocket:
+        data = websocket.receive_json()
+        assert data == {"msg": "Hello WebSocket"}

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

@@ -23,10 +23,6 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         parent_container: typing.Optional["Container"] = None,
         context: dict[str, typing.Any] | None = None,
     ) -> None:
-        if scope.value != 1 and parent_container is None:
-            msg = "Only first scope can be used without parent_container"
-            raise RuntimeError(msg)
-
         self.scope = scope
         self.parent_container = parent_container
         self.context: dict[str, typing.Any] = context or {}
@@ -38,27 +34,43 @@ 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:
             msg = "Enter the context first"
             raise RuntimeError(msg)
 
-    def build_child_container(self, context: dict[str, typing.Any] | None = None) -> "typing_extensions.Self":
+    def build_child_container(
+        self, context: dict[str, typing.Any] | None = None, scope: enum.IntEnum | None = None
+    ) -> "typing_extensions.Self":
         self._check_entered()
+        if scope and scope <= self.scope:
+            msg = "Scope of child container must be more than current scope"
+            raise RuntimeError(msg)
 
-        try:
-            new_scope = self.scope.__class__(self.scope.value + 1)
-        except ValueError as exc:
-            msg = f"Max scope is reached, {self.scope.name}"
-            raise RuntimeError(msg) from exc
+        if not scope:
+            try:
+                scope = self.scope.__class__(self.scope.value + 1)
+            except ValueError as exc:
+                msg = f"Max scope is reached, {self.scope.name}"
+                raise RuntimeError(msg) from exc
 
-        return self.__class__(scope=new_scope, parent_container=self, context=context)
+        return self.__class__(scope=scope, parent_container=self, context=context)
 
     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)
+
+        if container.scope != scope:
+            msg = f"Scope {scope.name} is skipped"
+            raise RuntimeError(msg)
+
         return container
 
     def fetch_provider_state(

modern_di-0.5.0/modern_di/scope.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class Scope(enum.IntEnum):
+    APP = 1
+    SESSION = 2
+    REQUEST = 3
+    ACTION = 4
+    STEP = 5

{modern_di-0.4.2 → modern_di-0.5.0}/tests/providers/test_context_adapter.py

@@ -23,7 +23,7 @@ async def test_context_adapter_in_request_scope() -> None:
     now = datetime.datetime.now(tz=datetime.timezone.utc)
     async with (
         Container(scope=Scope.APP) as app_container,
-        app_container.build_child_container(context={"now": now}) as request_container,
+        app_container.build_child_container(context={"now": now}, scope=Scope.REQUEST) as request_container,
     ):
         instance1 = await request_context_adapter.async_resolve(request_container)
         instance2 = request_context_adapter.sync_resolve(request_container)

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

@@ -34,12 +34,12 @@ async def test_app_factory() -> None:
 
 async def test_request_factory() -> None:
     with Container(scope=Scope.APP) as app_container:
-        with app_container.build_child_container() as request_container:
+        with app_container.build_child_container(scope=Scope.REQUEST) as request_container:
             instance1 = request_factory.sync_resolve(request_container)
             instance2 = request_factory.sync_resolve(request_container)
             assert instance1 is not instance2
 
-        async with app_container.build_child_container() as request_container:
+        async with app_container.build_child_container(scope=Scope.REQUEST) as request_container:
             instance3 = await request_factory.async_resolve(request_container)
             instance4 = await request_factory.async_resolve(request_container)
             assert instance3 is not instance4
@@ -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 → modern_di-0.5.0}/tests/providers/test_selector.py

@@ -23,7 +23,7 @@ async def test_selector() -> None:
 async def test_selector_in_request_scope() -> None:
     async with (
         Container(scope=Scope.APP) as app_container,
-        app_container.build_child_container(context={"option": "request"}) as request_container,
+        app_container.build_child_container(context={"option": "request"}, scope=Scope.REQUEST) as request_container,
     ):
         instance1 = await request_selector.async_resolve(request_container)
         instance2 = request_selector.sync_resolve(request_container)

{modern_di-0.4.2 → modern_di-0.5.0}/tests/providers/test_singleton.py

@@ -43,12 +43,12 @@ async def test_app_singleton() -> None:
 
 async def test_request_singleton() -> None:
     with Container(scope=Scope.APP) as app_container:
-        with app_container.build_child_container() as request_container:
+        with app_container.build_child_container(scope=Scope.REQUEST) as request_container:
             instance1 = request_singleton.sync_resolve(request_container)
             instance2 = request_singleton.sync_resolve(request_container)
             assert instance1 is instance2
 
-        async with app_container.build_child_container() as request_container:
+        async with app_container.build_child_container(scope=Scope.REQUEST) as request_container:
             instance3 = await request_singleton.async_resolve(request_container)
             instance4 = await request_singleton.async_resolve(request_container)
             assert instance3 is instance4

modern_di-0.5.0/tests/test_container.py

@@ -0,0 +1,46 @@
+import pytest
+
+from modern_di import Container, Scope, providers
+
+
+def test_container_not_opened() -> None:
+    container = Container(scope=Scope.APP)
+    with pytest.raises(RuntimeError, match="Enter the context first"):
+        container.fetch_provider_state("some_id")
+
+
+def test_container_scope_skipped() -> None:
+    app_factory = providers.Factory(Scope.APP, lambda: "test")
+    with Container(scope=Scope.REQUEST) as container, pytest.raises(RuntimeError, match="Scope APP is skipped"):
+        app_factory.sync_resolve(container)
+
+
+async def test_container_build_child_async() -> None:
+    async with (
+        Container(scope=Scope.APP) as app_container,
+        app_container.build_child_container(scope=Scope.REQUEST) as request_container,
+    ):
+        assert request_container.scope == Scope.REQUEST
+        assert app_container.scope == Scope.APP
+
+
+def test_container_build_child_sync() -> None:
+    with (
+        Container(scope=Scope.APP) as app_container,
+        app_container.build_child_container(scope=Scope.REQUEST) as request_container,
+    ):
+        assert request_container.scope == Scope.REQUEST
+        assert app_container.scope == Scope.APP
+
+
+def test_container_scope_limit_reached() -> None:
+    with Container(scope=Scope.STEP) as app_container, pytest.raises(RuntimeError, match="Max scope is reached, STEP"):
+        app_container.build_child_container()
+
+
+async def test_container_build_child_wrong_scope() -> None:
+    with (
+        Container(scope=Scope.APP) as app_container,
+        pytest.raises(RuntimeError, match="Scope of child container must be more than current scope"),
+    ):
+        app_container.build_child_container(scope=Scope.APP)

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"

modern_di-0.4.2/modern_di/scope.py

@@ -1,8 +0,0 @@
-import enum
-
-
-class Scope(enum.IntEnum):
-    APP = 1
-    REQUEST = 2
-    ACTION = 3
-    STEP = 4

modern_di-0.4.2/tests/test_container.py

@@ -1,41 +0,0 @@
-import enum
-
-import pytest
-
-from modern_di import Container, Scope
-
-
-def test_container_wrong_init() -> None:
-    with pytest.raises(RuntimeError, match="Only first scope can be used without parent_container"):
-        Container(scope=Scope.REQUEST)
-
-
-def test_container_not_opened() -> None:
-    container = Container(scope=Scope.APP)
-    with pytest.raises(RuntimeError, match="Enter the context first"):
-        container.fetch_provider_state("some_id")
-
-
-async def test_container_build_child_async() -> None:
-    async with Container(scope=Scope.APP) as app_container, app_container.build_child_container() as request_container:
-        assert request_container.scope == Scope.REQUEST
-        assert app_container.scope == Scope.APP
-
-
-def test_container_build_child_sync() -> None:
-    with Container(scope=Scope.APP) as app_container, app_container.build_child_container() as request_container:
-        assert request_container.scope == Scope.REQUEST
-        assert app_container.scope == Scope.APP
-
-
-def test_container_scope_limit_reached() -> None:
-    class CustomScope(enum.IntEnum):
-        APP = 1
-        REQUEST = 2
-
-    with Container(scope=CustomScope.APP) as app_container, app_container.build_child_container() as request_container:
-        assert request_container.scope == CustomScope.REQUEST
-        assert app_container.scope == CustomScope.APP
-
-        with pytest.raises(RuntimeError, match="Max scope is reached, REQUEST"):
-            request_container.build_child_container()