I have a lot of functions that have the same signature, let's say (int, int) -> int.
Is there a way to type these functions with a Callable (or something else) to avoid specifying the types of the parameters and the return type for each of these functions? I would like to do something like that (but it obviously fails):
from typing import Callable
f: Callable[[int, int], int]
def f(x, y): # with the previous line, this is equivalent to 'def f(x: int, y: int) -> int:'
...
Running mypy results in:
file.py:4: error: Name "f" already defined on line 3
Found 1 error in 1 file (checked 1 source file)
Maybe there's a more elegant solution. Not recommended but you can set the <function>.__annotations__. More info about it here.
from typing import get_type_hints
callable_int_annotations = {"x": int, "y": int, "return": int}
def f_with_hint(x: int, y: int) -> int:
return x + y
def f_without_hint(x, y):
return x + y
print(f"Before {get_type_hints(f_with_hint)=}")
print(f"Before {get_type_hints(f_without_hint)=}")
f_without_hint.__annotations__ = callable_int_annotations
print(f"After {get_type_hints(f_with_hint)=}")
print(f"After {get_type_hints(f_without_hint)=}")
Before get_type_hints(f_with_hint)={'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
Before get_type_hints(f_without_hint)={}
After get_type_hints(f_with_hint)={'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
After get_type_hints(f_without_hint)={'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}