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

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

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

@@ -4,6 +4,7 @@ import typing
 
 import fastapi
 from modern_di import Container, Scope, providers
+from starlette.requests import HTTPConnection
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -18,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_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
 
 

{modern_di-0.4.3 → modern_di-0.5.0}/integrations/fastapi/tests/conftest.py

@@ -2,9 +2,9 @@ import contextlib
 import typing
 
 import fastapi
-import httpx
 import pytest
 from asgi_lifespan import LifespanManager
+from starlette.testclient import TestClient
 
 from modern_di_fastapi import setup_di
 
@@ -24,5 +24,5 @@ async def app() -> typing.AsyncIterator[fastapi.FastAPI]:
 
 
 @pytest.fixture
-def client(app: fastapi.FastAPI) -> httpx.AsyncClient:
-    return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test")
+def client(app: fastapi.FastAPI) -> TestClient:
+    return TestClient(app=app)

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.3 → 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 {}
@@ -45,16 +41,22 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
             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
@@ -64,6 +66,11 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
 
         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.3 → 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.3 → 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

{modern_di-0.4.3 → 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.3 → 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.3/integrations/fastapi/tests/test_fastapi_di.py

@@ -1,30 +0,0 @@
-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.3/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.3/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()