def test_infer_node_3() -> None: """Return a set containing a nodes.ClassDef object when the attribute has a type annotation""" node = astroid.extract_node(""" class Component: pass class Composite: def __init__(self, component: Component): self.component = component """) instance_attr = node.instance_attrs.get("component")[0] assert isinstance(infer_node(instance_attr), set) assert isinstance(infer_node(instance_attr).pop(), nodes.ClassDef)
def visit_assignname(self, node: nodes.AssignName) -> None: """Visit an astroid.AssignName node. handle locals_type """ # avoid double parsing done by different Linkers.visit # running over the same project: if hasattr(node, "_handled"): return node._handled = True if node.name in node.frame(future=True): frame = node.frame(future=True) else: # the name has been defined as 'global' in the frame and belongs # there. frame = node.root() if not hasattr(frame, "locals_type"): # If the frame doesn't have a locals_type yet, # it means it wasn't yet visited. Visit it now # to add what's missing from it. if isinstance(frame, nodes.ClassDef): self.visit_classdef(frame) elif isinstance(frame, nodes.FunctionDef): self.visit_functiondef(frame) else: self.visit_module(frame) current = frame.locals_type[node.name] frame.locals_type[node.name] = list(set(current) | utils.infer_node(node))
def handle_assignattr_type(node, parent): """handle an astroid.assignattr node handle instance_attrs_type """ current = set(parent.instance_attrs_type[node.attrname]) parent.instance_attrs_type[node.attrname] = list( current | utils.infer_node(node))
def handle_assignattr_type(node: nodes.AssignAttr, parent: nodes.ClassDef) -> None: """Handle an astroid.assignattr node. handle instance_attrs_type """ current = set(parent.instance_attrs_type[node.attrname]) parent.instance_attrs_type[node.attrname] = list( current | utils.infer_node(node))
def test_infer_node_2(mock_infer: Any, mock_get_annotation: Any) -> None: """Return set(node.infer()) when InferenceError is not raised and an annotation has not been returned """ mock_get_annotation.return_value = None node = astroid.extract_node("a: str = 'mystr'") mock_infer.return_value = "x" assert infer_node(node) == set("x") assert mock_infer.called
def test_infer_node_4() -> None: """Verify the label for an argument with a typehint of the type nodes.Subscript """ node = astroid.extract_node(""" class MyClass: def __init__(self, my_int: Optional[int] = None): self.my_test_int = my_int """) instance_attr = node.instance_attrs.get("my_test_int")[0] assert isinstance(instance_attr, nodes.AssignAttr) inferred = infer_node(instance_attr).pop() assert isinstance(inferred, nodes.Subscript) assert inferred.name == "Optional[int]"