Python 3 type hinting for decorator
Solution 1
You can't use Callable
to say anything about additional arguments; they are not generic. Your only option is to say that your decorator takes a Callable
and that a different Callable
is returned.
In your case you can nail down the return type with a typevar:
RT = TypeVar('RT') # return type
def inject_user() -> Callable[[Callable[..., RT]], Callable[..., RT]]:
def decorator(func: Callable[..., RT]) -> Callable[..., RT]:
def wrapper(*args, **kwargs) -> RT:
# ...
Even then the resulting decorated foo()
function has a typing signature of def (*Any, **Any) -> builtins.bool*
when you use reveal_type()
.
Various proposals are currently being discussed to make Callable
more flexible but those have not yet come to fruition. See
- Allow variadic generics
-
Proposal: Generalize
Callable
to be able to specify argument names and kinds - TypeVar to represent a Callable's arguments
- Support function decorators excellently
for some examples. The last one in that list is an umbrella ticket that includes your specific usecase, the decorator that alters the callable signature:
Mess with the return type or with arguments
For an arbitrary function you can't do this at all yet -- there isn't even a syntax. Here's me making up some syntax for it.
Solution 2
PEP 612 was accepted after the accepted answer, and we now have typing.ParamSpec
and typing.Concatenate
in Python 3.10. With these variables, we can correctly type some decorators that manipulate positional parameters.
Note that mypy's support for PEP 612 is still under way (tracking issue).
The code in question can be typed like this (though not tested on mypy for the reason above)
from typing import Callable, ParamSpec, Concatenate, TypeVar
Param = ParamSpec("Param")
RetType = TypeVar("RetType")
OriginalFunc = Callable[Param, RetType]
DecoratedFunc = Callable[Concatenate[Param, str], RetType]
def get_authenticated_user(): return "John"
def inject_user() -> Callable[[OriginalFunc], DecoratedFunc]:
def decorator(func: OriginalFunc) -> DecoratedFunc:
def wrapper(*args, **kwargs) -> RetType:
user = get_authenticated_user()
if user is None:
raise Exception("Don't!")
return func(*args, user, **kwargs) # <- call signature modified
return wrapper
return decorator
@inject_user()
def foo(a: int, username: str) -> bool:
print(username)
return bool(a % 2)
foo(2) # Type check OK
foo("no!") # Type check should fail
![FunkySayu](https://i.stack.imgur.com/ymPSQ.png?s=256&g=1)
Comments
-
FunkySayu about 2 years
Consider the following code:
from typing import Callable, Any TFunc = Callable[..., Any] def get_authenticated_user(): return "John" def require_auth() -> Callable[TFunc, TFunc]: def decorator(func: TFunc) -> TFunc: def wrapper(*args, **kwargs) -> Any: user = get_authenticated_user() if user is None: raise Exception("Don't!") return func(*args, **kwargs) return wrapper return decorator @require_auth() def foo(a: int) -> bool: return bool(a % 2) foo(2) # Type check OK foo("no!") # Type check failing as intended
This piece of code is working as intended. Now imagine I want to extend this, and instead of just executing
func(*args, **kwargs)
I want to inject the username in the arguments. Therefore, I modify the function signature.from typing import Callable, Any TFunc = Callable[..., Any] def get_authenticated_user(): return "John" def inject_user() -> Callable[TFunc, TFunc]: def decorator(func: TFunc) -> TFunc: def wrapper(*args, **kwargs) -> Any: user = get_authenticated_user() if user is None: raise Exception("Don't!") return func(*args, user, **kwargs) # <- call signature modified return wrapper return decorator @inject_user() def foo(a: int, username: str) -> bool: print(username) return bool(a % 2) foo(2) # Type check OK foo("no!") # Type check OK <---- UNEXPECTED
I can't figure out a correct way to type this. I know that on this example, decorated function and returned function should technically have the same signature (but even that is not detected).
-
gertvdijk about 2 yearsNow that support for this has landed in mypy & Python 3.10 I tried this out, but I get this error on the typing of the
Callable
declarations (Param = ParamSpec("Param"); MyFunc = Callable[Param, RetType]
): mypy:error: The first argument to Callable must be a list of types, parameter specification, or "..."