new modern-di

Author: lesnik512

app/application.py

@@ -1,30 +1,32 @@
 import dataclasses
 
 import litestar
+import modern_di
 import modern_di_litestar
 from advanced_alchemy.exceptions import DuplicateKeyError
 from lite_bootstrap import LitestarBootstrapper
 from litestar.config.app import AppConfig
 from opentelemetry.instrumentation.asyncpg import AsyncPGInstrumentor
 from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 
-from app import exceptions, ioc
+from app import exceptions, ioc, repositories
 from app.api.decks import ROUTER
 from app.settings import settings
 
 
 def build_app() -> litestar.Litestar:
+    di_container = modern_di.AsyncContainer(groups=[ioc.Dependencies])
     bootstrap_config = dataclasses.replace(
         settings.api_bootstrapper_config,
         application_config=AppConfig(
             exception_handlers={
                 DuplicateKeyError: exceptions.duplicate_key_error_handler,
             },
             route_handlers=[ROUTER],
-            plugins=[modern_di_litestar.ModernDIPlugin()],
+            plugins=[modern_di_litestar.ModernDIPlugin(di_container)],
             dependencies={
-                "decks_service": modern_di_litestar.FromDI(ioc.Dependencies.decks_service),
-                "cards_service": modern_di_litestar.FromDI(ioc.Dependencies.cards_service),
+                "decks_service": modern_di_litestar.FromDI(repositories.DecksService),
+                "cards_service": modern_di_litestar.FromDI(repositories.CardsService),
             },
             request_max_body_size=settings.request_max_body_size,
         ),

app/ioc.py

@@ -1,10 +1,10 @@
-from modern_di import BaseGraph, Scope, providers
+from modern_di import Group, Scope, providers
 
 from app import repositories
 from app.resources.db import create_sa_engine, create_session
 
 
-class Dependencies(BaseGraph):
+class Dependencies(Group):
     database_engine = providers.Resource(Scope.APP, create_sa_engine)
     session = providers.Resource(Scope.REQUEST, create_session, engine=database_engine.cast)
 

pyproject.toml

@@ -11,7 +11,7 @@ license = "MIT License"
 dependencies = [
     "litestar",
     "lite-bootstrap[litestar-all]",
-    "modern-di-litestar",
+    "modern-di-litestar>=1",
     "advanced-alchemy",
     "pydantic-settings",
     "granian[uvloop]",

tests/conftest.py

@@ -29,17 +29,17 @@ async def client(app: litestar.Litestar) -> typing.AsyncIterator[AsyncClient]:
 
 
 @pytest.fixture
-def di_container(app: litestar.Litestar) -> modern_di.Container:
+def di_container(app: litestar.Litestar) -> modern_di.AsyncContainer:
     return modern_di_litestar.fetch_di_container(app)
 
 
 @pytest.fixture(autouse=True)
-async def db_session(di_container: modern_di.Container) -> typing.AsyncIterator[AsyncSession]:
-    engine = await ioc.Dependencies.database_engine.async_resolve(di_container)
+async def db_session(di_container: modern_di.AsyncContainer) -> typing.AsyncIterator[AsyncSession]:
+    engine = await di_container.resolve_provider(ioc.Dependencies.database_engine)
     connection = await engine.connect()
     transaction = await connection.begin()
     await connection.begin_nested()
-    ioc.Dependencies.database_engine.override(connection, di_container)
+    di_container.override(ioc.Dependencies.database_engine, connection)
 
     try:
         yield AsyncSession(connection, expire_on_commit=False, autoflush=False)

tests/test_main.py

@@ -14,7 +14,7 @@ def test_main(monkeypatch: pytest.MonkeyPatch) -> None:
 
 async def test_session() -> None:
     async with (
-        modern_di.Container(scope=modern_di.Scope.APP) as container,
+        modern_di.AsyncContainer() as container,
         container.build_child_container(scope=modern_di.Scope.REQUEST) as request_container,
     ):
-        await ioc.Dependencies.session.async_resolve(request_container)
+        await request_container.resolve_provider(ioc.Dependencies.session)