Import of __future__ annotations breaks class dependency with NameError

[Spenhouet]

Minimal working example:

from __future__ import annotations

import uvicorn
from fastapi import Depends, FastAPI
from starlette.requests import Request
app = FastAPI()

class Test():
    def __call__(self, request: Request):
        return 'test'

@app.get("/test/")
def test_call(test: str = Depends(Test())):
    return {"test": test}

if __name__ == "__main__":
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True, debug=True)

Description

• Run the file / start the server
• It fails to start with the following exception:

Exception has occurred: NameError
name 'Request' is not defined

Environment

• OS: Windows:
• FastAPI Version 0.58.0:
• Python version: 3.7

Additional context

The issue only happens when the from __future__ import annotations import is added. Without this import it works fine.
We depend on this import in our code. We don't want to use strings for type definitions.

FastAPI seems to have issues with from __future__ import annotations. Here is a similar issues from the past that got resolved: #446

[Kludex]

Adding more information:

• It fails with Request from FastAPI (even if it's a reassignment, I'm just mentioning it).

from __future__ import annotations

import uvicorn
from fastapi import Depends, FastAPI, Request
app = FastAPI()

class Test():
    def __call__(self, request: Request):
        print(request.user)
        return 'test'

@app.get("/test/")
def test_call(test: str = Depends(Test())):
    return {"test": test}

if __name__ == "__main__":
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True, debug=True)

• annotations is optional in Python 3.7.0b1 (https://docs.python.org/3/library/__future__.html)

I'm not sure if the info that I've provided help us.

EDIT [19/10/2022]: I really didn't know much about a lot of stuff at the time. 👀
EDIT [23/01/2024]: Oh my god...

[soundstripe]

I'm running across this problem in Python 3.8 WITHOUT the from __future__ import annotations statement (postponed evaluation of type hints is default behavior in 3.8).

[soundstripe]

By marking the parameter type as 'Request' (with quotes) to explicitly make it a forward reference, it is possible to get a (slightly) better traceback for where this is happening in the FastAPI startup sequence.

..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\routing.py:517: in decorator
    self.add_api_route(
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\routing.py:456: in add_api_route
    route = route_class(
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\routing.py:373: in __init__
    self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:284: in get_dependant
    sub_dependant = get_param_sub_dependant(
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:107: in get_param_sub_dependant
    return get_sub_dependant(
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:143: in get_sub_dependant
    sub_dependant = get_dependant(
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:277: in get_dependant
    endpoint_signature = get_typed_signature(call)
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:233: in get_typed_signature
    typed_params = [
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:238: in <listcomp>
    annotation=get_typed_annotation(param, globalns),
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\fastapi\dependencies\utils.py:252: in get_typed_annotation
    annotation = evaluate_forwardref(annotation, globalns, globalns)
..\..\.virtualenvs\apiv2-7CyhPjuC\lib\site-packages\pydantic\typing.py:50: in evaluate_forwardref
    return type_._evaluate(globalns, localns)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = ForwardRef('Request')
globalns = {'__builtins__': {'ArithmeticError': <class 'ArithmeticError'>, 'AssertionError': <class 'AssertionError'>, 'AttributeError': <class 'AttributeError'>, 'BaseException': <class 'BaseException'>, ...}}
localns = {'__builtins__': {'ArithmeticError': <class 'ArithmeticError'>, 'AssertionError': <class 'AssertionError'>, 'AttributeError': <class 'AttributeError'>, 'BaseException': <class 'BaseException'>, ...}}

    def _evaluate(self, globalns, localns):
        if not self.__forward_evaluated__ or localns is not globalns:
            if globalns is None and localns is None:
                globalns = localns = {}
            elif globalns is None:
                globalns = localns
            elif localns is None:
                localns = globalns
            self.__forward_value__ = _type_check(
>               eval(self.__forward_code__, globalns, localns),
                "Forward references must evaluate to types.",
                is_argument=self.__forward_is_argument__)
E           NameError: name 'Request' is not defined

Looked a little farther and both globalns and localns are empty here

[rra]

I'm running into this problem too. It appears to be specific to objects used as dependencies via the __call__ method. If I rewrite my code so that the dependency is a regular function, the problem goes away. In my case, removing the from __future__ import did make the problem go away.

Note that regular function dependencies work fine with from __future__ import annotations. Only the module ones seem to encounter this bug.

[adam-discover]

Bump on this thread, exact same issue as original poster.

[Mause]

You have may better luck raising this on the pydantic repository

[gandhis1]

This is still a problem, not sure why it's a discussion now.

[nathan-chappell]

I guess the following code can be found in pydantic:

# pydantic/typing.py

if sys.version_info < (3, 9):

    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
        return type_._evaluate(globalns, localns)

else:

    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
        # Even though it is the right signature for python 3.9, mypy complains with
        # `error: Too many arguments for "_evaluate" of "ForwardRef"` hence the cast...
        return cast(Any, type_)._evaluate(globalns, localns, set())

You'll notice that they are using internal methods of typing (e.g. ForwardRef._evaluate). I don't have time to look through the entire pydantic typing implementation, but this doesn't seem like it's in accordance with: Annotations Best Practices.

Users of FastAPI can workaround this annoyance by providing a __globals__ dict in the class where you are defining a __call__ method that needs to be hooked coordinate with FastAPI's DI mechanism. Here is one obvious idea (modifying the example which opened the thread):

from __future__ import annotations
...
class Test():
    __globals__ = globals()

    def __call__(self, request: Request):
        return 'test'
...

Of course, instead of callings globals you can put a dict there, but I forsee that for most users the above trick will be a sufficient workaround.