v0.2.0

.github/workflows/setup.yml

@@ -39,4 +39,4 @@ jobs:
 
     - name: Run tests
       run: |
-        pytest
+        tox

README.md

@@ -1,4 +1,8 @@
 ## DIshka (from russian "small DI")
+[![PyPI version](https://badge.fury.io/py/dishka.svg)](https://badge.fury.io/py/dishka)
+[![downloads](https://img.shields.io/pypi/dm/dishka.svg)](https://pypistats.org/packages/dishka)
+[![license](https://img.shields.io/github/license/reagento/dishka)](https://github.com/reagento/dishka/blob/master/LICENSE)
+[![license](https://img.shields.io/badge/💬-Telegram-blue)](https://t.me/reagento_ru)
 
 Small DI framework with scopes and agreeable API.
 

examples/aiogram_bot.py

@@ -2,44 +2,13 @@
 import logging
 import os
 import random
-from inspect import Parameter
-from typing import Annotated, Container, Iterable
+from typing import Annotated, Iterable
 
-from aiogram import BaseMiddleware, Bot, Dispatcher, Router
+from aiogram import Bot, Dispatcher, Router
 from aiogram.types import Message, TelegramObject, User
 
-from dishka import Provider, Scope, make_async_container, provide
-from dishka.inject import Depends, wrap_injection
-
-
-# framework level
-def inject(func):
-    getter = lambda kwargs: kwargs["container"]
-    additional_params = [Parameter(
-        name="container",
-        annotation=Container,
-        kind=Parameter.KEYWORD_ONLY,
-    )]
-
-    return wrap_injection(
-        func=func,
-        remove_depends=True,
-        container_getter=getter,
-        additional_params=additional_params,
-        is_async=True,
-    )
-
-
-class ContainerMiddleware(BaseMiddleware):
-    def __init__(self, container):
-        self.container = container
-
-    async def __call__(
-            self, handler, event, data,
-    ):
-        async with self.container({TelegramObject: event}) as subcontainer:
-            data["container"] = subcontainer
-            return await handler(event, data)
+from dishka import Provider, Scope, provide
+from dishka.integrations.aiogram import Depends, inject, setup_dishka
 
 
 # app dependency logic
@@ -73,14 +42,12 @@ async def start(
 async def main():
     # real main
     logging.basicConfig(level=logging.INFO)
-    async with make_async_container(MyProvider()) as container:
-        bot = Bot(token=API_TOKEN)
-        dp = Dispatcher()
-        for observer in dp.observers.values():
-            observer.middleware(ContainerMiddleware(container))
-        dp.include_router(router)
+    bot = Bot(token=API_TOKEN)
+    dp = Dispatcher()
+    dp.include_router(router)
+    setup_dishka(providers=[MyProvider()], router=dp)
+    await dp.start_polling(bot)
 
-        await dp.start_polling(bot)
 
 
 if __name__ == '__main__':

examples/benchmarks/fastapi_app.py

@@ -1,53 +1,13 @@
 import logging
-from contextlib import asynccontextmanager
-from inspect import Parameter
-from typing import Annotated, Callable, Iterable, NewType, get_type_hints
+from typing import Annotated, Callable, Iterable, NewType
 
 import uvicorn
 from fastapi import APIRouter
 from fastapi import Depends as FastapiDepends
-from fastapi import FastAPI, Request
-
-from dishka import Provider, Scope, make_async_container, provide
-from dishka.inject import Depends, wrap_injection
-
-
-# framework level
-def inject(func):
-    hints = get_type_hints(func)
-    requests_param = next(
-        (name for name, hint in hints.items() if hint is Request),
-        None,
-    )
-    if requests_param:
-        getter = lambda kwargs: kwargs[requests_param].state.container
-        additional_params = []
-    else:
-        getter = lambda kwargs: kwargs["___r___"].state.container
-        additional_params = [Parameter(
-            name="___r___",
-            annotation=Request,
-            kind=Parameter.KEYWORD_ONLY,
-        )]
-
-    return wrap_injection(
-        func=func,
-        remove_depends=True,
-        container_getter=getter,
-        additional_params=additional_params,
-        is_async=True,
-    )
-
-
-def container_middleware():
-    async def add_request_container(request: Request, call_next):
-        async with request.app.state.container(
-                {Request: request}
-        ) as subcontainer:
-            request.state.container = subcontainer
-            return await call_next(request)
-
-    return add_request_container
+from fastapi import FastAPI
+
+from dishka import Provider, Scope, provide
+from dishka.integrations.fastapi import Depends, DishkaApp, inject
 
 
 class Stub:
@@ -143,23 +103,15 @@ def new_a(b: B = FastapiDepends(Stub(B)), c: C = FastapiDepends(Stub(C))):
     return A(b, c)
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    async with make_async_container(MyProvider()) as container:
-        app.state.container = container
-        yield
-
-
 def create_app() -> FastAPI:
     logging.basicConfig(level=logging.WARNING)
 
-    app = FastAPI(lifespan=lifespan)
-    app.middleware("http")(container_middleware())
+    app = FastAPI()
     app.dependency_overrides[A] = new_a
     app.dependency_overrides[B] = lambda: B(1)
     app.dependency_overrides[C] = lambda: C(1)
     app.include_router(router)
-    return app
+    return DishkaApp(providers=[MyProvider()], app=app)
 
 
 if __name__ == "__main__":

examples/fastapi_app.py

@@ -1,57 +1,16 @@
 import logging
 from abc import abstractmethod
-from contextlib import asynccontextmanager
-from inspect import Parameter
-from typing import (
-    Annotated, get_type_hints, Protocol, Any, get_origin,
-    get_args,
-)
+from typing import Annotated, Protocol
 
 import uvicorn
-from fastapi import APIRouter
-from fastapi import FastAPI, Request
+from fastapi import APIRouter, FastAPI
 
 from dishka import (
-    Depends, wrap_injection, Provider, Scope, make_async_container, provide,
+    Provider, Scope, provide,
+)
+from dishka.integrations.fastapi import (
+    Depends, inject, DishkaApp,
 )
-
-
-# framework level
-def inject(func):
-    hints = get_type_hints(func)
-    requests_param = next(
-        (name for name, hint in hints.items() if hint is Request),
-        None,
-    )
-    if requests_param:
-        getter = lambda kwargs: kwargs[requests_param].state.container
-        additional_params = []
-    else:
-        getter = lambda kwargs: kwargs["___r___"].state.container
-        additional_params = [Parameter(
-            name="___r___",
-            annotation=Request,
-            kind=Parameter.KEYWORD_ONLY,
-        )]
-
-    return wrap_injection(
-        func=func,
-        remove_depends=True,
-        container_getter=getter,
-        additional_params=additional_params,
-        is_async=True,
-    )
-
-
-def container_middleware():
-    async def add_request_container(request: Request, call_next):
-        async with request.app.state.container(
-                {Request: request}
-        ) as subcontainer:
-            request.state.container = subcontainer
-            return await call_next(request)
-
-    return add_request_container
 
 
 # app core
@@ -99,24 +58,19 @@ async def index(
     return result
 
 
-# app configuration
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    async with make_async_container(
-            AdaptersProvider(), InteractorProvider(),
-    ) as container:
-        app.state.container = container
-        yield
-
-
-def create_app() -> FastAPI:
-    logging.basicConfig(level=logging.WARNING)
+def create_app():
+    logging.basicConfig(
+        level=logging.WARNING,
+        format='%(asctime)s  %(process)-7s %(module)-20s %(message)s',
+    )
 
-    app = FastAPI(lifespan=lifespan)
-    app.middleware("http")(container_middleware())
+    app = FastAPI()
     app.include_router(router)
-    return app
+    return DishkaApp(
+        providers=[AdaptersProvider(), InteractorProvider()],
+        app=app,
+    )
 
 
 if __name__ == "__main__":
-    uvicorn.run(create_app(), host="0.0.0.0", port=8000)
+    uvicorn.run(create_app(), host="0.0.0.0", port=8000, lifespan="on")

examples/flask_app.py

@@ -0,0 +1,66 @@
+from abc import abstractmethod
+from typing import Annotated, Protocol
+
+from flask import Flask
+
+from dishka import (
+    Provider, Scope, provide,
+)
+from dishka.integrations.flask import (
+    Depends, inject, setup_dishka,
+)
+
+
+# app core
+class DbGateway(Protocol):
+    @abstractmethod
+    def get(self) -> str:
+        raise NotImplementedError
+
+
+class FakeDbGateway(DbGateway):
+    def get(self) -> str:
+        return "Hello"
+
+
+class Interactor:
+    def __init__(self, db: DbGateway):
+        self.db = db
+
+    def __call__(self) -> str:
+        return self.db.get()
+
+
+# app dependency logic
+class AdaptersProvider(Provider):
+    @provide(scope=Scope.REQUEST)
+    def get_db(self) -> DbGateway:
+        return FakeDbGateway()
+
+
+class InteractorProvider(Provider):
+    i1 = provide(Interactor, scope=Scope.REQUEST)
+
+
+# presentation layer
+app = Flask(__name__)
+
+
+@app.get("/")
+@inject
+def index(
+        *,
+        interactor: Annotated[Interactor, Depends()],
+) -> str:
+    result = interactor()
+    return result
+
+
+container = setup_dishka(
+    providers=[AdaptersProvider(), InteractorProvider()],
+    app=app,
+)
+try:
+    app.run()
+finally:
+    container.close()