Check if any of multiple variables are None but satisfy pyright

[geeshta]

I think the examples speak the best for them selves. I have a number of variables and do not want to write a long chain of if conditions like this:

if var1 is None or var2 is None or var3 is None: ...

so I'm using the built-in any function. However pyright doesn't recognize that I checked and underlines whenever I try to use the variables where they must not be None.

# If I check explicitly in the if condition, pyright is happy
def example1(var1: str | None) -> str:
    if var1 is None:
        return "Oops"
    return var1

# If I check inside of the any() function, pyright acts like the variable can still be None
def example2(var1: str | None, var2: str | None, var3: str | None) -> str:
    if any(var is None for var in (var1, var2, var3)):
        return "Oops"
    # vvv Expression of type "str | None" cannot be assigned to return type "str" vvv
    return var1

[geeshta]

This also doesn't work:

# If I check with a loop, pyright acts like the variable can still be None
def example3(var1: str | None, var2: str | None, var3: str | None) -> str:
    for var in (var1, var2, var3):
        if var is None:
            return "Oops"
    # vvv Expression of type "str | None" cannot be assigned to return type "str" vvv
    return var1

[erictraut]

A call to any is not a supported type guard pattern. For a complete list of type guard patterns supported by pyright, see this documentation. We do occasionally add support for new type guard patterns, but each new pattern requires custom logic and potentially slows down overall type analysis, so we do so cautiously.

Type guard patterns are very specific to syntactic forms because they operate on the syntax tree rather than evaluated types. The any pattern that you're using in your example above involves not only a call to the any function but also a generator expression that converts to bool values and a tuple expression that contains one or more variable expressions. It's highly unlikely that we would ever support this specific type guard pattern because this is an atypical idiom in Python. I've never seen it used before. A more typical (and simpler) idiom would be if None in (var1, var2, var3). This is also not currently a supported type guard pattern (in either pyright or mypy), but it's more likely that we would consider adding support for such a pattern in the future if there was sufficient demand.

In the meantime, you can use the more verbose if var1 is None or var2 is None or var3 is None. I personally find this more readable than your code above, but that's subjective.

The second example (the loop) does not work because type narrowing is applied to individual variables. Type checkers do not track relationships between variable types. The type of var is narrowed in your example, but the type guard doesn't apply to var1 in this case. There's no "entanglement" between the type of var and var1. So this behavior is expected.

Here are a couple of other options that might interest you:

# Use a match statement
def example4(var1: str | None, var2: str | None, var3: str | None) -> str:
    x = (var1, var2, var3)
    match x:
        case (None, _, _) | (_, None, _) | (_, _, None):
            return "Oops"
    return x[0]

# Use a user-defined type guard
from typing import TypeGuard

def containsNoNones(v: tuple[str | None, ...]) -> TypeGuard[tuple[str, ...]]:
    return None not in v

def example5(var1: str | None, var2: str | None, var3: str | None) -> str:
    x = (var1, var2, var3)
    if not containsNoNones(x):
        return "Oops"
    var1, var2, var3 = x
    return var1

[geeshta]

Thank you, after having sleeping on it I also don't really like the code I provided. Thank you for the suggested solutions. I opted for the the or chaining in the end. Anyway I didn't know much about typeguard so your answer is very helpful.