Depends vs Dishka

fastapi_depends.py

import time

import anyio
from fastapi import Depends, FastAPI

app = FastAPI()


def sync_dependency_one() -> str:
    time.sleep(0.00000001)
    return "sync_dependency_one"


def sync_dependency_two(
    injected_sync_one: str = Depends(sync_dependency_one),
) -> list[str]:
    time.sleep(0.00000001)
    return [injected_sync_one, "sync_dependency_two"]


def sync_dependency_three(
    injected_sync_two: list[str] = Depends(sync_dependency_two),
) -> list[str]:
    time.sleep(0.00000001)
    return [*injected_sync_two, "sync_dependency_three"]


async def async_dependency_one() -> str:
    await anyio.sleep(0.00000001)
    return "async_dependency_one"


async def async_dependency_two(
    injected_async_one: str = Depends(async_dependency_one),
) -> list[str]:
    await anyio.sleep(0.00000001)
    return [injected_async_one, "async_dependency_two"]


async def async_dependency_three(
    injected_async_two: list[str] = Depends(async_dependency_two),
) -> list[str]:
    await anyio.sleep(0.00000001)
    return [*injected_async_two, "async_dependency_three"]


async def dependencies_mixed(
    injected_sync_three: list[str] = Depends(sync_dependency_three),
    injected_async_three: list[str] = Depends(async_dependency_three),
) -> tuple[list[str], list[str]]:
    return injected_sync_three, injected_async_three


@app.get("/async-dependencies-sync")
async def async_dependencies_sync(
    injected_sync_one: str = Depends(sync_dependency_one),
    injected_sync_two: list[str] = Depends(sync_dependency_two),
    injected_sync_three: list[str] = Depends(sync_dependency_three),
) -> list[str]:
    return injected_sync_three


@app.get("/async-dependencies-async")
async def async_dependencies_async(
    injected_async_one: str = Depends(async_dependency_one),
    injected_async_two: list[str] = Depends(async_dependency_two),
    injected_async_three: list[str] = Depends(async_dependency_three),
) -> list[str]:
    return injected_async_three


@app.get("/async-dependencies-mixed")
async def async_dependencies_mixed(
    injected_sync_one: str = Depends(sync_dependency_one),
    injected_sync_two: list[str] = Depends(sync_dependency_two),
    injected_sync_three: list[str] = Depends(sync_dependency_three),
    injected_async_one: str = Depends(async_dependency_one),
    injected_async_two: list[str] = Depends(async_dependency_two),
    injected_async_three: list[str] = Depends(async_dependency_three),
    injected_mixed: tuple[list[str], list[str]] = Depends(dependencies_mixed),
) -> tuple[list[str], list[str]]:
    return injected_mixed

fastapi_dishka.py

import time
from typing import Annotated, NewType

import anyio
from dishka import Provider, Scope, provide, make_async_container
from dishka.integrations.fastapi import Depends as DishkaDepends, inject, setup_dishka
from fastapi import FastAPI

app = FastAPI()

SyncStr = NewType("SyncStr", str)
SyncListStr1 = NewType("SyncListStr1", list[str])
SyncListStr2 = NewType("SyncListStr2", list[str])

AsyncStr = NewType("AsyncStr", str)
AsyncListStr1 = NewType("AsyncListStr1", list[str])
AsyncListStr2 = NewType("AsyncListStr2", list[str])


class SyncProvider(Provider):
    scope = Scope.REQUEST

    @provide
    def get_sync_dependency_one(self) -> SyncStr:
        time.sleep(0.00000001)
        return "sync_dependency_one"

    @provide
    def get_sync_dependency_two(self, injected_sync_one: SyncStr) -> SyncListStr1:
        time.sleep(0.00000001)
        return [injected_sync_one, "sync_dependency_two"]

    @provide
    def sync_dependency_three(self, injected_sync_two: SyncListStr1) -> SyncListStr2:
        time.sleep(0.00000001)
        return [*injected_sync_two, "sync_dependency_three"]


class AsyncProvider(Provider):
    scope = Scope.REQUEST

    @provide
    async def get_async_dependency_one(self) -> AsyncStr:
        await anyio.sleep(0.00000001)
        return "async_dependency_one"

    @provide
    async def get_async_dependency_two(self, injected_async_one: AsyncStr) -> AsyncListStr1:
        await anyio.sleep(0.00000001)
        return [injected_async_one, "async_dependency_two"]

    @provide
    async def async_dependency_three(self, injected_async_two: AsyncListStr1) -> AsyncListStr2:
        await anyio.sleep(0.00000001)
        return [*injected_async_two, "async_dependency_three"]


class MixedProvider(Provider):
    scope = Scope.REQUEST

    @provide
    async def get_dependencies_mixed(
            self,
            injected_sync_three: SyncListStr2,
            injected_async_three: AsyncListStr2,
    ) -> tuple[SyncListStr2, AsyncListStr2]:
        return injected_sync_three, injected_async_three


@app.get("/async-dependencies-sync")
@inject
async def async_dependencies_sync(
    injected_sync_one: Annotated[SyncStr, DishkaDepends()],
    injected_sync_two: Annotated[SyncListStr1, DishkaDepends()],
    injected_sync_three: Annotated[SyncListStr2, DishkaDepends()],
) -> SyncListStr2:
    return injected_sync_three


@app.get("/async-dependencies-async")
@inject
async def async_dependencies_async(
    injected_async_one: Annotated[AsyncStr, DishkaDepends()],
    injected_async_two: Annotated[AsyncListStr1, DishkaDepends()],
    injected_async_three: Annotated[AsyncListStr2, DishkaDepends()],
) -> AsyncListStr2:
    return injected_async_three


@app.get("/async-dependencies-mixed")
@inject
async def async_dependencies_mixed(
    injected_sync_one: Annotated[SyncStr, DishkaDepends()],
    injected_sync_two: Annotated[SyncListStr1, DishkaDepends()],
    injected_sync_three: Annotated[SyncListStr2, DishkaDepends()],
    injected_async_one: Annotated[AsyncStr, DishkaDepends()],
    injected_async_two: Annotated[AsyncListStr1, DishkaDepends()],
    injected_async_three: Annotated[AsyncListStr2, DishkaDepends()],
    injected_mixed: Annotated[tuple[SyncListStr2, AsyncListStr2], DishkaDepends()],
) -> tuple[SyncListStr2, AsyncListStr2]:
    return injected_mixed

container = make_async_container(SyncProvider(), AsyncProvider(), MixedProvider())
setup_dishka(container, app)