Why is TypeIs Not Narrowing

[CraigMilhiserBrivo]

I do not know if this is a user bug or a problem in pyright. I will open an issue or fix my code.

I am using
Identifier ms-pyright.pyright
Version 1.1.407

Python 3.14.2

In the below code, I thought that adding the hasattr to make sure the relation attribute exists and then the TypeIs would narrow the type to Node1. The hasattr protects the _is_node from accessing an attribute that does not exist. Then the _is_node TypeIs narrows the type to a Node1.

from typing import TypeIs


class Node:
    name: str


class Node1(Node):
    relation: Node


class Node2(Node):
    pass


def _is_node(value: object) -> TypeIs[Node]:
    return isinstance(value, Node)


def _is_node1(value: object) -> TypeIs[Node1]:
    return isinstance(value, Node1)


def get_relation_name(node: Node) -> str:
    return node.name


# Need to add # pyright: ignore[reportAttributeAccessIssue] to each of the if and get_relation_name calls in func0 and func1 to avoid pyright errors


def func0(variable: Node) -> str:
    if hasattr(variable, "relation") and _is_node(value=variable.relation):
        return_val = get_relation_name(node=variable.relation)
    else:
        return_val = "Not Found"

    return return_val


def func1(variable: Node1 | Node2) -> str:
    if hasattr(variable, "relation") and _is_node1(value=variable.relation):
        return_val = get_relation_name(node=variable.relation)
    else:
        return_val = "Not Found"

    return return_val

# This works by defining manually the type of variable to Node1
def func_this_works(variable: Node1) -> str:
    if hasattr(variable, "relation") and _is_node1(value=variable.relation):
        return_val = get_relation_name(node=variable.relation)
    else:
        return_val = "Not Found"

    return return_val

[erictraut]

hasattr(x) isn't a type narrowing pattern supported by pyright, so no type narrowing is performed based on this call. For a complete list of supported type narrowing patterns, refer to this documentation.

[CraigMilhiserBrivo]

But the _is_node returning TypeIs[] is type narrowing. The hasattr protects the isNode.

[erictraut]

Type narrowing is a static analysis concept, not a runtime concept. The hasattr call provides protection at runtime, but it has no effect at static analysis time because pyright doesn't recognize it as a type guard. In your code, the type of variable remains unchanged after the hasattr call from the perspective of the type checker. The type of variable is Node prior to the call, and it remains the same type after the call. Since Node has no attribute named relation, pyright reports an error when you attempt to access that attribute.

In theory, it would be possible for a type checker to recognize hasattr as a valid type guard and perform narrowing by creating some internal (not expressible) type the represents an intersection between Node and "a protocol that defines an attribute relation whose type is unknown". Pyright doesn't do this. I think that the authors of ty are exploring something like this.

[CraigMilhiserBrivo]

So the TypeIs does not narrow it either. Thanks. I can ignore the message.

MyPy, in strict mode, does not give give any errors/warnings here. Perhaps it is wrong or they built in the infrastructure.