int being a subtype of float and type narrowing

[decorator-factory]

Suppose that x has type str | float. Should if not isinstance(x, float): narrow x to str, or to str | int? If it narrows it to str, it seems like the checking will be "unsound", because ints are considered assignable to float, but the isinstance check doesn't consider integers to be floats.

Right now both mypy and pyright think this is OK:

def f(x: float | str) -> None:
    if isinstance(x, float):
        print(x + 3.14)
    else:
        print(x + "!!!")

But a call like f(42) (also considered legal) will cause a runtime error, because the execution will go to the else branch.

I don't have any real-world examples for this issue, so this is purely hypothetical for now.

[erictraut]

Yes, isinstance narrowing is inexact. You can contrive many edge cases where it produces behavior that's not strictly type safe.

Consider that a class could be a subclass of both str and float at the same time, yet it's useful for the isinstance narrowing logic to assume that it is one or the other. Also, classes can implement a __instancecheck__ that "lies" about whether two classes have a subclass relationship. And there are cases (like the one you mention above) where the type system indicates that there is a subclass relationship when such a relationship doesn't exist at runtime.

So yes, there are plenty of holes here. This is one of those situations where practicality trumps purity.

[Akuli]

I can't think of a practical use for floats where ints wouldn't be acceptable too. So to me, it seems that isinstance(x, float) is buggy, unless you also check for isinstance(x, int).

Maybe it would be better to narrow x to int | str in the else? I don't think that would cause much false positives.