Type narrowing after inspect.iscoroutinefunction

[petrusek]

Hi,
I would like to know, if it is possible to narrow down a type after an if with inspect.iscoroutinefunction.

import asyncio
import inspect
from typing import Awaitable, Callable, Union

stored_callback: Callable[[int], None]

def set_callback(user_callback: Callable[[int], Union[None, Awaitable[None]]]) -> None:
    if (inspect.iscoroutinefunction(user_callback)):
        # user_callback type: Callable[[int], Awaitable[None]]
        def wrapped_callback(param: int):
            asyncio.create_task(user_callback(param))

        stored_callback = wrapped_callback

    else:
        # user_callback type: Callable[[int], None]
        stored_callback = user_callback

Also, if there is some better user-friendly way how to handle both sync and async callbacks, please let me know.
Thank you for any help!

[erictraut]

No, pyright doesn't currently know about inspect.iscoroutinefunction for type narrowing. The full list of supported type guards can be found here: https://github.com/microsoft/pyright/blob/master/docs/type-concepts.md#type-guards.

We do occasionally add support for new type guards, but every case requires specialized logic and adds complexity (and in some cases degrades overall analysis performance), so we have a high bar for which cases to support. That means we need evidence that it's a frequently-used idiom in Python code and would benefit some reasonable number of pyright users. That evidence usually takes the form of:

1. A significant number of upvotes in issues like this
2. Evidence that other Python type checkers (like mypy) also perform type narrowing for that idiom

I don't think inspect.iscoroutinefunction (currently) meets the bar, but others can upvote this issue if they'd like, and we'll track that input.

We recently added a new mechanism called "user-defined type guards" that allows you to write your own type guard functions. That could be a good solution in this case. For details, refer to PEP 647.

[erictraut]

Here's how you would use user-defined TypeGuard in a generic fashion.

_P = ParamSpec("_P")
_T = TypeVar("_T")


def is_coroutine_function(
    user_callback: Callable[_P, Union[_T, Awaitable[_T]]],
) -> TypeGuard[Callable[_P, Awaitable[_T]]]:
    return inspect.iscoroutinefunction(user_callback)

[petrusek]

Thank you,
it seems we have been both writing it at the same time :-) ...

However, I've found a few (I guess solvable) issues:

• while it does work inside the if's then branch, it stops working in the wrapped_callback nested function :-(
  • solved with a local variable
• the else branch seems to need its own type guard (which is easy to add)

It would be great if inspect.iscoroutinefunction would have this generic type guard too :-) ... that way everybody would benefit from your PEP 647 feature (which is great).

Anyway, thank you very much for helping me with this one!

[erictraut]

Type narrowing is never applied to captured variables in nested scopes because the code flow analysis cannot generally determine whether the value assigned to the captured variable changes by the time the code in the nested scope is executed. The correct way to handle this is through the use of a local variable, as you noted.

Yes, PEP 647 states that user-defined type guards apply narrowing only in the positive (if) case, not the negative (else) case. That's because one cannot assume symmetry between the two cases.