Forward return type of injected dependencies with Depends()

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn’t find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google “How to X in FastAPI” and didn’t find any information.
• I already read and followed all the tutorial in the docs and didn’t find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

"""
I have a dependency that specifies a return type, but that type is erased 
when I inject it into an endpoint using `Depends()`
"""
from fastapi import FastAPI, Depends

app = FastAPI()

async def dependency() -> int:
    return 0

@app.get("/")
async def root(dep = Depends(dependency)):
    # Get mypy to emit the return type of the value returned by the dependency
    reveal_type(dep)  # Revealed type is "Any"

Description

When injecting dependency it into my view function with Depends(dependency), the return type (int) is erased and replaced with Any.

This can be verified by running mypy against my code sample above (reveal_type() should cause mypy to emit the type it infers)

Wanted Solution

It would be great if the return type of dependency were preserved, i.e.

@app.get("/")
async def root(dep = Depends(dependency)):
    reveal_type(dep)  # Revealed type is "int"

---

Depends is currently defined as:

def Depends(dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True) -> Any:

I’m no expert on the Python type system or Mypy, but I think the following could get Mypy to correctly infer the return type of dependency:

from typing import TypeVar, Awaitable, Union

T_ = TypeVar("T_")
MaybeAwaitable = Union[T_, Awaitable[T_]]

T = TypeVar("T")
def Depends(dependency: Optional[Callable[..., MaybeAwaitable[T]]] = None, *, use_cache: bool = True) -> T:
    return params.Depends(dependency=dependency, use_cache=use_cache)

Wanted Code

"""
The return type of my dependency should be preserved 
when injecting it with `Depends(dependency)`
"""
from fastapi import FastAPI, Depends

app = FastAPI()

async def dependency() -> int:
    return 0

@app.get("/")
async def root(dep = Depends(dependency)):
    reveal_type(dep)  # Revealed type is "int"

Alternatives

No response

Operating System

macOS

Operating System Details

No response

FastAPI Version

0.75.0

Python Version

3.7.9

Additional Context

My current approach is to explicitly annotate my injected dependencies, but this is prone to error since Mypy doesn’t help catch these issues.

Consider:

from fastapi import FastAPI, Depends

app = FastAPI()

# Returns a different type now
async def dict_dependency() -> dict:
    return {}

@app.get("/")
async def root(dict_dep: int = Depends(dict_dependency)):
	# But Mypy doesn't catch the issue
    reveal_type(dict_dep)  # Revealed type is "int"

[invokermain]

Is there not a middle ground where we can forward the return type if we are 100% sure, and otherwise return Any? It’s a massive shame to discard this completely because of how useful it would be for FastAPI users? Something like:

_DependenciesWithYield = Union[
    Callable[..., Iterable[T]],
    Callable[..., Generator[T, None, None]],
    Callable[..., AsyncIterable[T]],
    Callable[..., AsyncGenerator[T, None]],
]

@typing.overload
def Depends(dependency: None = None) -> Any:
    ...


@typing.overload
def Depends(dependency: _DependenciesWithYield[T]) -> Any:
    ...


@typing.overload
def Depends(dependency: Union[Callable[..., T], Callable[..., Awaitable[T]]]) -> T:
    ...


def Depends(dependency = None) -> Any:
    # Implementation
    pass

[ThirVondukr]

After some analysis i think it’s not possible to add correct type annotation to Depends mostly because of context manager-like dependencies that are usually annotated with Iterable[T] or Generator[T, None, None]

If we assume that all dependencies annotated with Iterable[T] return T would break dependencies that return iterable objects:

_DependenciesWithYield = Union[
    Callable[..., Iterable[T]],
    Callable[..., Generator[T, None, None]],
    Callable[..., AsyncIterable[T]],
    Callable[..., AsyncGenerator[T, None]],
]


@typing.overload
def Depends(dependency: _DependenciesWithYield[T]) -> T:
    ...


def dependency() -> list[int]:
    return [42]
    

def dependency_with_yield() -> Iterable[T]:
    yield 42


reveal_type(Depends(dependency))  # int, Correct return type is `list[int]` or `Iterable[int]`
reveal_type(Depends(dependency_with_yield))  # int

Perhaps some context manager specific type annotations could be used to resolve problem with iterables and generators and wrap fastapi dependencies into @contextlib.contextmanager manually