Path 1: 32 calls (0.8)

Name (32)

('Annotated', 'Literal') (30) ('Literal',) (2)

True (21) False (11) 

1def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> bool:
2    """Check if `node` is a member of the `typing` module and has one of the names from
3    `names_to_check`.
4    """
5    if isinstance(node, nodes.Name):
6        try:
7            import_from = node.lookup(node.name)[1][0]
8        except IndexError:
9            return False
10
11        if isinstance(import_from, nodes.ImportFrom):
12            return (
13                import_from.modname == "typing"
14                and import_from.real_name(node.name) in names_to_check
15            )
16    elif isinstance(node, nodes.Attribute):
17        inferred_module = safe_infer(node.expr)
18        return (
19            isinstance(inferred_module, nodes.Module)
20            and inferred_module.name == "typing"
21            and node.attrname in names_to_check
22        )
23    return False

Path 2: 5 calls (0.12)

Attribute (5)

('Annotated', 'Literal') (4) ('Literal',) (1)

True (5) 

1def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> bool:
2    """Check if `node` is a member of the `typing` module and has one of the names from
3    `names_to_check`.
4    """
5    if isinstance(node, nodes.Name):
6        try:
7            import_from = node.lookup(node.name)[1][0]
8        except IndexError:
9            return False
10
11        if isinstance(import_from, nodes.ImportFrom):
12            return (
13                import_from.modname == "typing"
14                and import_from.real_name(node.name) in names_to_check
15            )
16    elif isinstance(node, nodes.Attribute):
17        inferred_module = safe_infer(node.expr)
18        return (
19            isinstance(inferred_module, nodes.Module)
20            and inferred_module.name == "typing"
21            and node.attrname in names_to_check
22        )
23    return False

Path 3: 1 calls (0.03)

Name (1)

('Annotated', 'Literal') (1)

False (1) 

1def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> bool:
2    """Check if `node` is a member of the `typing` module and has one of the names from
3    `names_to_check`.
4    """
5    if isinstance(node, nodes.Name):
6        try:
7            import_from = node.lookup(node.name)[1][0]
8        except IndexError:
9            return False
10
11        if isinstance(import_from, nodes.ImportFrom):
12            return (
13                import_from.modname == "typing"
14                and import_from.real_name(node.name) in names_to_check
15            )
16    elif isinstance(node, nodes.Attribute):
17        inferred_module = safe_infer(node.expr)
18        return (
19            isinstance(inferred_module, nodes.Module)
20            and inferred_module.name == "typing"
21            and node.attrname in names_to_check
22        )
23    return False

Path 4: 1 calls (0.03)

Name (1)

('Literal',) (1)

False (1)

IndexError (1) 

1def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> bool:
2    """Check if `node` is a member of the `typing` module and has one of the names from
3    `names_to_check`.
4    """
5    if isinstance(node, nodes.Name):
6        try:
7            import_from = node.lookup(node.name)[1][0]
8        except IndexError:
9            return False
10
11        if isinstance(import_from, nodes.ImportFrom):
12            return (
13                import_from.modname == "typing"
14                and import_from.real_name(node.name) in names_to_check
15            )
16    elif isinstance(node, nodes.Attribute):
17        inferred_module = safe_infer(node.expr)
18        return (
19            isinstance(inferred_module, nodes.Module)
20            and inferred_module.name == "typing"
21            and node.attrname in names_to_check
22        )
23    return False

Path 5: 1 calls (0.03)

Attribute (1)

('Literal',) (1)

False (1) 

1def is_typing_member(node: nodes.NodeNG, names_to_check: tuple[str, ...]) -> bool:
2    """Check if `node` is a member of the `typing` module and has one of the names from
3    `names_to_check`.
4    """
5    if isinstance(node, nodes.Name):
6        try:
7            import_from = node.lookup(node.name)[1][0]
8        except IndexError:
9            return False
10
11        if isinstance(import_from, nodes.ImportFrom):
12            return (
13                import_from.modname == "typing"
14                and import_from.real_name(node.name) in names_to_check
15            )
16    elif isinstance(node, nodes.Attribute):
17        inferred_module = safe_infer(node.expr)
18        return (
19            isinstance(inferred_module, nodes.Module)
20            and inferred_module.name == "typing"
21            and node.attrname in names_to_check
22        )
23    return False