我可以使用 typing.Callable 类型来自动注释 function 吗？ 如何？

Question

Suppose we define a type for a callback like so:

CallbackFn = Callable[[str, str, int, int], None]

When I want to implement a callback function, and have external tools type-check it against CallbackFn , I have to annotate the types explicitly:

def my_callback(s1: str, s2: str, i1: int, i2: int) -> None:
  ...

Is there any way that I can use the type hint defined in CallbackFn to annoate a function - something like def my_callback(s1,s2,i1,i2) as CallbackFn: - to avoid the explicit annotation work?

Answer 1

In a few cases, yes. But it's not recommended

my_callback: CallbackFn = lambda s1, s2, i1, i2: <do the thing>

Obviously you're limited by the constraints of a lambda (no statements etc)

Answer 2

This is quite easy to do with a no-op decorator.

from collections.abc import Callable
from typing import Any, TypeAlias, TypeVar

CallbackFn: TypeAlias = Callable[[str, str, int, int], None]
Any4ParamCallableT = TypeVar("Any4ParamCallableT", bound=Callable[[Any, Any, Any, Any], None])

def asCallbackFn(f: Any4ParamCallableT, /) -> CallbackFn:
    """No-op decorator to impart typing to the function being decorated"""
    return f

@asCallbackFn
def my_callback(s1, s2, i1, i2):
    return

Here's a deliberate attempt to use wrong types in the return and parameter values:

# mypy: Incompatible types in assignment (expression has type "None", variable has type "int") [assignment]
# mypy: Argument 1 to "my_callback" has incompatible type "int"; expected "str" [arg-type]
# mypy: Argument 2 to "my_callback" has incompatible type "int"; expected "str" [arg-type]
retval: int = my_callback(1, 2, 3, 4)

I don't really recommend trying to do what you're doing though, it's better to explicitly type each function. Among other things, you'll lose the ability to use keyword argument calling convention if you type things with Callable[[<type>, ...], ...] (you can use a callback protocol, but then that forces you to name all your callback functions with the same named arguments).

Answer 3

You could use a decorator to do this

decorator function:

def annotate(callback):

    def wrapper(fn):
        print(fn)
        
        annotations = callback.__dict__["__args__"]

        for i, name in enumerate(fn.__code__.co_varnames):
            fn.__annotations__[name] = annotations[i]

        fn.__annotations__['return'] = annotations[-1]
        
        return fn

    return wrapper

To use it, simply do:

CallbackFn = Callable[[str, str, int, int], None]

@annotate(CallbackFn)
def my_callback(s1: str, s2: str, i1: int, i2: int) -> None:
  pass

Hope this helps