Protocol for callable argument that can be sync, async, or generator

[rmartin16]

Is it possible to type handler using a Protocol such that the next three functions are accepted inputs? Or if not a Protocol, a definition that can exist independent of the implementation?

def run_handler(handler) -> bool:
    return run_handler_magic(handler)

async def async_handler(name: str, **kwargs: Any) -> bool:
    return True

def sync_handler(name: str, **kwargs: Any) -> bool:
    return True

def gen_handler(name: str, **kwargs: Any) -> bool:
    yield True

I was hoping to get something like this working....but I just can't get it accepted by mypy:

class Handler(Protocol):
    @overload
    def __call__(self, name: str, **kwargs: Any) -> bool: ...

    @overload
    def __call__(self, name: str, **kwargs: Any) -> Generator[Any, None, bool]: ...

    @overload
    async def __call__(self, name: str, **kwargs: Any) -> bool: ...

FWIW, I think I've got this working...but I really wanted to avoid littering several classes with all these overloads & dense typing and just use a Protocol instead:

@overload
def run_handler(handler: Callable[[str], bool]) -> None: ...

@overload
def run_handler(handler: Callable[[str], Awaitable[bool]]) -> None: ...

@overload
def run_handler(handler: Callable[[str], Generator[Any, None, bool]]) -> None: ...

def run_handler(handler) -> bool:
    return run_handler_magic(handler)

[Daverball]

You could use a Union instead of using overload, since the return type is always the same, and TypeAlias to keep things readable:

SyncHandler: TypeAlias = Callable[[str], bool]
AsyncHandler: TypeAlias = Callable[[str], Awaitable[bool]]
GenHandler: TypeAlias = Callable[[str], Generator[Any, None, bool]]

def run_handler(handler: SyncHandler | AsyncHandler | GenHandler) -> bool:
    return run_handler_magic(handler)

[Daverball]

BTW the reason your Protocol doesn't work is because it's essentially modelling an Intersection between the three handler types i.e. the opposite of a union, you're saying the handler needs to be able to support all three signatures, instead of just one of them.

[Daverball]

Your Protocol also imposes a restriction on the name of the first argument, and assumes that it must be able to accept any keyword arguments beyond that one named argument, the proper way to write a callback protocol equivalent to e.g. Callable[[str], bool] would be:

class SyncHandler(Protocol):
    def __call__(self, name: str, /) -> bool: ...

The / denotes that anything preceding it is a positional only argument, i.e. you are communicating intent than anywhere a SyncHandler is used it will be called with one argument positionally, the actual implementation may specify a different name for the argument and it may also specify further optional arguments.