Type annotation for function arguments outside of a function

[Apakottur]

I have the following code, which type checks even when using mypy --strict:

from typing import Callable, TypeVar, ParamSpec, Any

P = ParamSpec("P")
T = TypeVar("T")

def outer(callback: Callable[P, T], args: Any) -> T:
    return callback(*args)

def inner(x: int, y: int) -> int:
    return x + y

assert 3 == outer(inner, (1, "2"))

How can I type the function outer in a way that will fail type checking in this case?

[AlexWaygood]

I think this will be possible with PEP 646:

from typing import Callable, TypeVar, TypeVarTuple

Ts = TypeVarTuple("Ts")
T = TypeVar("T")

def outer(callback: Callable[[*Ts], T], args: tuple[*Ts]) -> T:
    return callback(*args)

def inner(x: int, y: int) -> int:
    return x + y

assert 3 == outer(inner, (1, "2"))

Mypy does not yet support PEP 646, however.

[erictraut]

Your first example should generate an error. That looks like a bug in mypy. (For comparison, pyright emits an error for the expression callback(*args).)

If you want to use PEP 612, you need to pass the arguments separately, not as a tuple.

def outer(callback: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
    return callback(*args, **kwargs)

def inner(x: int, y: int) -> int:
    return x + y

assert 3 == outer(inner, 1, 2)  # No error
assert 3 == outer(inner, 1, 2, 3)  # Error
assert 3 == outer(inner, 1, "2")  # Error

If you want to pass arguments as a tuple, the approach that Alex suggested will work. Mypy doesn't have support for PEP 646 at this time, but pyright and pyre do. To make this work with versions of Python prior to 3.11, you need to leverage typing_extensions.Unpack.

from typing import Callable, TypeVar
from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")
T = TypeVar("T")

def outer(callback: Callable[[Unpack[Ts]], T], args: tuple[Unpack[Ts]]) -> T:
    return callback(*args)

def inner(x: int, y: int) -> int:
    return x + y

assert 3 == outer(inner, (1, "2"))  # Error
assert 3 == outer(inner, (1, 2))  # No Error

[Apakottur]

Thanks for the answers.
In my case I have a set of functions func_1, func_2, ..., func_10 that I am executing on a different machine.
I pass the function and argument separately, they are serialized, "sent" elsewhere, deserialized and executed.

Is there another way for me to implement this so that typing is enforced by mypy?

I was thinking of creating a dataclass for each function+args combo and then a union of all these dataclasses, but I was wondering if there's a nicer way to do this?

[Akuli]

Dataclasses seem like a good idea to me. The function itself could be a method on the dataclass. When you serialize an object, the methods are usually not included, because they are defined on the type, not on the object itself.

@dataclass
class Inner:
    x: int
    y: int

    def run(self) -> int:
        return self.x + self.y

You can then use a Protocol to say that outer(runnable) returns the same type as runnable.run():

T = TypeVar("T")

class Runnable(Generic[T], Protocol):
    def run(self) -> T: ...

def outer(runnable: Runnable[T]) -> T:
    return runnable.run()

print(outer(Inner(1, 2)))  # prints 3

This ended up looking a lot like Java's Runnable interface, but I hope you don't mind :)