Use Annotated instead of default arg notation?

[SyntaxColoring]

Hi! Chiming in here because I had some thoughts on the sketch that @adriangb posted over in the pytest issue tracker. Sorry if you've already considered this—I haven't had a chance to look through all the details of your project yet.

Here was that sketch:

from typing import AsyncGenerator, List

import pytest

from di.pytest import Depends, inject


class Log(List[str]):
    pass


def dep(log: Log = Depends(Log)) -> int:
    log.append("dep")
    return 1


async def generator_dep(inner_val: int = Depends(dep), log: Log = Depends(Log)) -> AsyncGenerator[int, None]:
    log.append("generator_dep setup")
    yield inner_val + 1
    log.append("generator_dep teardown")


@pytest.mark.anyio
@inject
async def test_inject(v: int = Depends(generator_dep), log: Log = Depends(Log)) -> None:
    assert v == 2
    assert log == ["dep", "generator_dep setup"]  # teardown hasn't run yet

My feedback is to reconsider the log: Log = Depends(Log) syntax shown here. It can be pretty dangerous.

The problem is that the value returned by Depends(...) is not actually valid to use as an argument—it's only there as a placeholder for the dependency injection framework. So if the function is ever called without that dependency injection framework, like this:

test_inject()  # Allow the `v` and `log` args to be their defaults

Then all hell breaks loose. The internal placeholder object, which is definitely not an int or Log, will leak into the function and cause confusing errors down the line. And there's nothing that mypy can do to catch this.

FastAPI has this problem, and it repeatedly bites the unwary. (If you want, I can dig up examples on their issue tracker.)

I would instead consider something like this:

@inject
async def foo(
    my_int: typing.Annotated[int, Depends(generator_dep)],
    my_log: Log = typing.Annotated[int, Depends(Log)]
) -> None:
    ...

[adriangb]

Both are actually supported: https://www.adriangb.com/di/0.32.5/wiring/#manual-wiring

There is one advantage to the log: Log = Depends(Log) syntax: MyPy will show you an error if you do something like v: int = Depends(lambda: "string")

[adriangb]

I'll also note that this is super flexible: you can customize the Depends() implementation (API is here) to support any marker scheme you want. The container / execution engine is totally decoupled from wiring.