Lines Matching refs:node
36 Parse the source into an AST node.
56 Evaluate an expression node or a string containing only a Python
57 expression. The string or node provided may only consist of the following
67 def _raise_malformed_node(node):
68 msg = "malformed node or string"
69 if lno := getattr(node, 'lineno', None):
71 raise ValueError(msg + f': {node!r}')
72 def _convert_num(node):
73 if not isinstance(node, Constant) or type(node.value) not in (int, float, complex):
74 _raise_malformed_node(node)
75 return node.value
76 def _convert_signed_num(node):
77 if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
78 operand = _convert_num(node.operand)
79 if isinstance(node.op, UAdd):
83 return _convert_num(node)
84 def _convert(node):
85 if isinstance(node, Constant):
86 return node.value
87 elif isinstance(node, Tuple):
88 return tuple(map(_convert, node.elts))
89 elif isinstance(node, List):
90 return list(map(_convert, node.elts))
91 elif isinstance(node, Set):
92 return set(map(_convert, node.elts))
93 elif (isinstance(node, Call) and isinstance(node.func, Name) and
94 node.func.id == 'set' and node.args == node.keywords == []):
96 elif isinstance(node, Dict):
97 if len(node.keys) != len(node.values):
98 _raise_malformed_node(node)
99 return dict(zip(map(_convert, node.keys),
100 map(_convert, node.values)))
101 elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)):
102 left = _convert_signed_num(node.left)
103 right = _convert_num(node.right)
105 if isinstance(node.op, Add):
109 return _convert_signed_num(node)
113 def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
115 Return a formatted dump of the tree in node. This is mainly useful for
125 def _format(node, level=0):
133 if isinstance(node, AST):
134 cls = type(node)
138 for name in node._fields:
140 value = getattr(node, name)
153 if include_attributes and node._attributes:
154 for name in node._attributes:
156 value = getattr(node, name)
165 return '%s(%s)' % (node.__class__.__name__, ', '.join(args)), not args
166 return '%s(%s%s)' % (node.__class__.__name__, prefix, sep.join(args)), False
167 elif isinstance(node, list):
168 if not node:
170 return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
171 return repr(node), True
173 if not isinstance(node, AST):
174 raise TypeError('expected AST, got %r' % node.__class__.__name__)
177 return _format(node)[0]
197 def fix_missing_locations(node):
199 When you compile a node tree with compile(), the compiler expects lineno and
200 col_offset attributes for every node that supports them. This is rather
203 parent node. It works recursively starting at *node*.
205 def _fix(node, lineno, col_offset, end_lineno, end_col_offset):
206 if 'lineno' in node._attributes:
207 if not hasattr(node, 'lineno'):
208 node.lineno = lineno
210 lineno = node.lineno
211 if 'end_lineno' in node._attributes:
212 if getattr(node, 'end_lineno', None) is None:
213 node.end_lineno = end_lineno
215 end_lineno = node.end_lineno
216 if 'col_offset' in node._attributes:
217 if not hasattr(node, 'col_offset'):
218 node.col_offset = col_offset
220 col_offset = node.col_offset
221 if 'end_col_offset' in node._attributes:
222 if getattr(node, 'end_col_offset', None) is None:
223 node.end_col_offset = end_col_offset
225 end_col_offset = node.end_col_offset
226 for child in iter_child_nodes(node):
228 _fix(node, 1, 0, 1, 0)
229 return node
232 def increment_lineno(node, n=1):
234 Increment the line number and end line number of each node in the tree
235 starting at *node* by *n*. This is useful to "move code" to a different
238 for child in walk(node):
240 # but rather a field of the node itself.
252 return node
255 def iter_fields(node):
257 Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
258 that is present on *node*.
260 for field in node._fields:
262 yield field, getattr(node, field)
267 def iter_child_nodes(node):
269 Yield all direct child nodes of *node*, that is, all fields that are nodes
272 for name, field in iter_fields(node):
281 def get_docstring(node, clean=True):
283 Return the docstring for the given node or None if no docstring can
284 be found. If the node provided does not have docstrings a TypeError
290 if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
291 raise TypeError("%r can't have docstrings" % node.__class__.__name__)
292 if not(node.body and isinstance(node.body[0], Expr)):
294 node = node.body[0].value
295 if isinstance(node, Str):
296 text = node.s
297 elif isinstance(node, Constant) and isinstance(node.value, str):
298 text = node.value
343 def get_source_segment(source, node, *, padded=False):
344 """Get source code segment of the *source* that generated *node*.
353 if node.end_lineno is None or node.end_col_offset is None:
355 lineno = node.lineno - 1
356 end_lineno = node.end_lineno - 1
357 col_offset = node.col_offset
358 end_col_offset = node.end_col_offset
380 def walk(node):
382 Recursively yield all descendant nodes in the tree starting at *node*
383 (including *node* itself), in no specified order. This is useful if you
387 todo = deque([node])
389 node = todo.popleft()
390 todo.extend(iter_child_nodes(node))
391 yield node
396 A node visitor base class that walks the abstract syntax tree and calls a
397 visitor function for every node found. This function may return a value
404 class name of the node. So a `TryFinally` node visit function would
406 the `visit` method. If no visitor function exists for a node
414 def visit(self, node):
415 """Visit a node."""
416 method = 'visit_' + node.__class__.__name__
418 return visitor(node)
420 def generic_visit(self, node):
421 """Called if no explicit visitor function exists for a node."""
422 for field, value in iter_fields(node):
430 def visit_Constant(self, node):
431 value = node.value
448 return visitor(node)
449 return self.generic_visit(node)
458 visitor methods to replace or remove the old node. If the return value of
459 the visitor method is ``None``, the node will be removed from its location,
461 original node in which case no replacement takes place.
468 def visit_Name(self, node):
471 slice=Constant(value=node.id),
472 ctx=node.ctx
475 Keep in mind that if the node you're operating on has child nodes you must
477 method for the node first.
481 just a single node.
485 node = YourTransformer().visit(node)
488 def generic_visit(self, node):
489 for field, old_value in iter_fields(node):
505 delattr(node, field)
507 setattr(node, field, new_node)
508 return node
529 cls.__doc__ = """Deprecated AST node class. Use ast.Constant instead"""
604 """Deprecated AST node class."""
607 """Deprecated AST node class. Use the index value directly instead."""
612 """Deprecated AST node class. Use ast.Tuple instead."""
631 """Deprecated AST node class. Unused in Python 3."""
634 """Deprecated AST node class. Unused in Python 3."""
637 """Deprecated AST node class. Unused in Python 3."""
640 """Deprecated AST node class. Unused in Python 3."""
772 def require_parens(self, precedence, node):
774 return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
776 def get_precedence(self, node):
777 return self._precedences.get(node, _Precedence.TEST)
780 for node in nodes:
781 self._precedences[node] = precedence
783 def get_raw_docstring(self, node):
784 """If a docstring node is found in the body of the *node* parameter,
785 return that docstring node, None otherwise.
789 node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)
790 ) or len(node.body) < 1:
792 node = node.body[0]
793 if not isinstance(node, Expr):
795 node = node.value
796 if isinstance(node, Constant) and isinstance(node.value, str):
797 return node
799 def get_type_comment(self, node):
800 comment = self._type_ignores.get(node.lineno) or node.type_comment
804 def traverse(self, node):
805 if isinstance(node, list):
806 for item in node:
809 super().visit(node)
814 def visit(self, node):
816 (using ast.parse) will generate an AST equivalent to *node*"""
818 self.traverse(node)
821 def _write_docstring_and_traverse_body(self, node):
822 if (docstring := self.get_raw_docstring(node)):
824 self.traverse(node.body[1:])
826 self.traverse(node.body)
828 def visit_Module(self, node):
831 for ignore in node.type_ignores
833 self._write_docstring_and_traverse_body(node)
836 def visit_FunctionType(self, node):
839 lambda: self.write(", "), self.traverse, node.argtypes
843 self.traverse(node.returns)
845 def visit_Expr(self, node):
847 self.set_precedence(_Precedence.YIELD, node.value)
848 self.traverse(node.value)
850 def visit_NamedExpr(self, node):
851 with self.require_parens(_Precedence.NAMED_EXPR, node):
852 self.set_precedence(_Precedence.ATOM, node.target, node.value)
853 self.traverse(node.target)
855 self.traverse(node.value)
857 def visit_Import(self, node):
859 self.interleave(lambda: self.write(", "), self.traverse, node.names)
861 def visit_ImportFrom(self, node):
863 self.write("." * (node.level or 0))
864 if node.module:
865 self.write(node.module)
867 self.interleave(lambda: self.write(", "), self.traverse, node.names)
869 def visit_Assign(self, node):
871 for target in node.targets:
875 self.traverse(node.value)
876 if type_comment := self.get_type_comment(node):
879 def visit_AugAssign(self, node):
881 self.traverse(node.target)
882 self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
883 self.traverse(node.value)
885 def visit_AnnAssign(self, node):
887 with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
888 self.traverse(node.target)
890 self.traverse(node.annotation)
891 if node.value:
893 self.traverse(node.value)
895 def visit_Return(self, node):
897 if node.value:
899 self.traverse(node.value)
901 def visit_Pass(self, node):
904 def visit_Break(self, node):
907 def visit_Continue(self, node):
910 def visit_Delete(self, node):
912 self.interleave(lambda: self.write(", "), self.traverse, node.targets)
914 def visit_Assert(self, node):
916 self.traverse(node.test)
917 if node.msg:
919 self.traverse(node.msg)
921 def visit_Global(self, node):
923 self.interleave(lambda: self.write(", "), self.write, node.names)
925 def visit_Nonlocal(self, node):
927 self.interleave(lambda: self.write(", "), self.write, node.names)
929 def visit_Await(self, node):
930 with self.require_parens(_Precedence.AWAIT, node):
932 if node.value:
934 self.set_precedence(_Precedence.ATOM, node.value)
935 self.traverse(node.value)
937 def visit_Yield(self, node):
938 with self.require_parens(_Precedence.YIELD, node):
940 if node.value:
942 self.set_precedence(_Precedence.ATOM, node.value)
943 self.traverse(node.value)
945 def visit_YieldFrom(self, node):
946 with self.require_parens(_Precedence.YIELD, node):
948 if not node.value:
950 self.set_precedence(_Precedence.ATOM, node.value)
951 self.traverse(node.value)
953 def visit_Raise(self, node):
955 if not node.exc:
956 if node.cause:
960 self.traverse(node.exc)
961 if node.cause:
963 self.traverse(node.cause)
965 def do_visit_try(self, node):
968 self.traverse(node.body)
969 for ex in node.handlers:
971 if node.orelse:
974 self.traverse(node.orelse)
975 if node.finalbody:
978 self.traverse(node.finalbody)
980 def visit_Try(self, node):
984 self.do_visit_try(node)
988 def visit_TryStar(self, node):
992 self.do_visit_try(node)
996 def visit_ExceptHandler(self, node):
998 if node.type:
1000 self.traverse(node.type)
1001 if node.name:
1003 self.write(node.name)
1005 self.traverse(node.body)
1007 def visit_ClassDef(self, node):
1009 for deco in node.decorator_list:
1012 self.fill("class " + node.name)
1013 with self.delimit_if("(", ")", condition = node.bases or node.keywords):
1015 for e in node.bases:
1021 for e in node.keywords:
1029 self._write_docstring_and_traverse_body(node)
1031 def visit_FunctionDef(self, node):
1032 self._function_helper(node, "def")
1034 def visit_AsyncFunctionDef(self, node):
1035 self._function_helper(node, "async def")
1037 def _function_helper(self, node, fill_suffix):
1039 for deco in node.decorator_list:
1042 def_str = fill_suffix + " " + node.name
1045 self.traverse(node.args)
1046 if node.returns:
1048 self.traverse(node.returns)
1049 with self.block(extra=self.get_type_comment(node)):
1050 self._write_docstring_and_traverse_body(node)
1052 def visit_For(self, node):
1053 self._for_helper("for ", node)
1055 def visit_AsyncFor(self, node):
1056 self._for_helper("async for ", node)
1058 def _for_helper(self, fill, node):
1060 self.set_precedence(_Precedence.TUPLE, node.target)
1061 self.traverse(node.target)
1063 self.traverse(node.iter)
1064 with self.block(extra=self.get_type_comment(node)):
1065 self.traverse(node.body)
1066 if node.orelse:
1069 self.traverse(node.orelse)
1071 def visit_If(self, node):
1073 self.traverse(node.test)
1075 self.traverse(node.body)
1077 while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
1078 node = node.orelse[0]
1080 self.traverse(node.test)
1082 self.traverse(node.body)
1084 if node.orelse:
1087 self.traverse(node.orelse)
1089 def visit_While(self, node):
1091 self.traverse(node.test)
1093 self.traverse(node.body)
1094 if node.orelse:
1097 self.traverse(node.orelse)
1099 def visit_With(self, node):
1101 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1102 with self.block(extra=self.get_type_comment(node)):
1103 self.traverse(node.body)
1105 def visit_AsyncWith(self, node):
1107 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1108 with self.block(extra=self.get_type_comment(node)):
1109 self.traverse(node.body)
1155 def visit_JoinedStr(self, node):
1159 self._write_fstring_inner(node)
1169 for value in node.values:
1190 def _write_fstring_inner(self, node):
1191 if isinstance(node, JoinedStr):
1193 for value in node.values:
1195 elif isinstance(node, Constant) and isinstance(node.value, str):
1196 value = node.value.replace("{", "{{").replace("}", "}}")
1198 elif isinstance(node, FormattedValue):
1199 self.visit_FormattedValue(node)
1201 raise ValueError(f"Unexpected node inside JoinedStr, {node!r}")
1203 def visit_FormattedValue(self, node):
1210 expr = unparse_inner(node.value)
1219 if node.conversion != -1:
1220 self.write(f"!{chr(node.conversion)}")
1221 if node.format_spec:
1223 self._write_fstring_inner(node.format_spec)
1225 def visit_Name(self, node):
1226 self.write(node.id)
1228 def _write_docstring(self, node):
1230 if node.kind == "u":
1232 self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
1248 def visit_Constant(self, node):
1249 value = node.value
1256 if node.kind == "u":
1258 self._write_constant(node.value)
1260 def visit_List(self, node):
1262 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1264 def visit_ListComp(self, node):
1266 self.traverse(node.elt)
1267 for gen in node.generators:
1270 def visit_GeneratorExp(self, node):
1272 self.traverse(node.elt)
1273 for gen in node.generators:
1276 def visit_SetComp(self, node):
1278 self.traverse(node.elt)
1279 for gen in node.generators:
1282 def visit_DictComp(self, node):
1284 self.traverse(node.key)
1286 self.traverse(node.value)
1287 for gen in node.generators:
1290 def visit_comprehension(self, node):
1291 if node.is_async:
1295 self.set_precedence(_Precedence.TUPLE, node.target)
1296 self.traverse(node.target)
1298 self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
1299 self.traverse(node.iter)
1300 for if_clause in node.ifs:
1304 def visit_IfExp(self, node):
1305 with self.require_parens(_Precedence.TEST, node):
1306 self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
1307 self.traverse(node.body)
1309 self.traverse(node.test)
1311 self.set_precedence(_Precedence.TEST, node.orelse)
1312 self.traverse(node.orelse)
1314 def visit_Set(self, node):
1315 if node.elts:
1317 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1323 def visit_Dict(self, node):
1342 lambda: self.write(", "), write_item, zip(node.keys, node.values)
1345 def visit_Tuple(self, node):
1349 len(node.elts) == 0 or self.get_precedence(node) > _Precedence.TUPLE
1351 self.items_view(self.traverse, node.elts)
1361 def visit_UnaryOp(self, node):
1362 operator = self.unop[node.op.__class__.__name__]
1364 with self.require_parens(operator_precedence, node):
1370 self.set_precedence(operator_precedence, node.operand)
1371 self.traverse(node.operand)
1406 def visit_BinOp(self, node):
1407 operator = self.binop[node.op.__class__.__name__]
1409 with self.require_parens(operator_precedence, node):
1417 self.set_precedence(left_precedence, node.left)
1418 self.traverse(node.left)
1420 self.set_precedence(right_precedence, node.right)
1421 self.traverse(node.right)
1436 def visit_Compare(self, node):
1437 with self.require_parens(_Precedence.CMP, node):
1438 self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
1439 self.traverse(node.left)
1440 for o, e in zip(node.ops, node.comparators):
1447 def visit_BoolOp(self, node):
1448 operator = self.boolops[node.op.__class__.__name__]
1451 def increasing_level_traverse(node):
1454 self.set_precedence(operator_precedence, node)
1455 self.traverse(node)
1457 with self.require_parens(operator_precedence, node):
1459 self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
1461 def visit_Attribute(self, node):
1462 self.set_precedence(_Precedence.ATOM, node.value)
1463 self.traverse(node.value)
1464 # Special case: 3.__abs__() is a syntax error, so if node.value
1467 if isinstance(node.value, Constant) and isinstance(node.value.value, int):
1470 self.write(node.attr)
1472 def visit_Call(self, node):
1473 self.set_precedence(_Precedence.ATOM, node.func)
1474 self.traverse(node.func)
1477 for e in node.args:
1483 for e in node.keywords:
1490 def visit_Subscript(self, node):
1497 self.set_precedence(_Precedence.ATOM, node.value)
1498 self.traverse(node.value)
1500 if is_non_empty_tuple(node.slice):
1502 self.items_view(self.traverse, node.slice.elts)
1504 self.traverse(node.slice)
1506 def visit_Starred(self, node):
1508 self.set_precedence(_Precedence.EXPR, node.value)
1509 self.traverse(node.value)
1511 def visit_Ellipsis(self, node):
1514 def visit_Slice(self, node):
1515 if node.lower:
1516 self.traverse(node.lower)
1518 if node.upper:
1519 self.traverse(node.upper)
1520 if node.step:
1522 self.traverse(node.step)
1524 def visit_Match(self, node):
1526 self.traverse(node.subject)
1528 for case in node.cases:
1531 def visit_arg(self, node):
1532 self.write(node.arg)
1533 if node.annotation:
1535 self.traverse(node.annotation)
1537 def visit_arguments(self, node):
1540 all_args = node.posonlyargs + node.args
1541 defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
1552 if index == len(node.posonlyargs):
1556 if node.vararg or node.kwonlyargs:
1562 if node.vararg:
1563 self.write(node.vararg.arg)
1564 if node.vararg.annotation:
1566 self.traverse(node.vararg.annotation)
1569 if node.kwonlyargs:
1570 for a, d in zip(node.kwonlyargs, node.kw_defaults):
1578 if node.kwarg:
1583 self.write("**" + node.kwarg.arg)
1584 if node.kwarg.annotation:
1586 self.traverse(node.kwarg.annotation)
1588 def visit_keyword(self, node):
1589 if node.arg is None:
1592 self.write(node.arg)
1594 self.traverse(node.value)
1596 def visit_Lambda(self, node):
1597 with self.require_parens(_Precedence.TEST, node):
1600 self.traverse(node.args)
1604 self.set_precedence(_Precedence.TEST, node.body)
1605 self.traverse(node.body)
1607 def visit_alias(self, node):
1608 self.write(node.name)
1609 if node.asname:
1610 self.write(" as " + node.asname)
1612 def visit_withitem(self, node):
1613 self.traverse(node.context_expr)
1614 if node.optional_vars:
1616 self.traverse(node.optional_vars)
1618 def visit_match_case(self, node):
1620 self.traverse(node.pattern)
1621 if node.guard:
1623 self.traverse(node.guard)
1625 self.traverse(node.body)
1627 def visit_MatchValue(self, node):
1628 self.traverse(node.value)
1630 def visit_MatchSingleton(self, node):
1631 self._write_constant(node.value)
1633 def visit_MatchSequence(self, node):
1636 lambda: self.write(", "), self.traverse, node.patterns
1639 def visit_MatchStar(self, node):
1640 name = node.name
1645 def visit_MatchMapping(self, node):
1653 keys = node.keys
1657 zip(keys, node.patterns, strict=True),
1659 rest = node.rest
1665 def visit_MatchClass(self, node):
1666 self.set_precedence(_Precedence.ATOM, node.cls)
1667 self.traverse(node.cls)
1669 patterns = node.patterns
1673 attrs = node.kwd_attrs
1685 zip(attrs, node.kwd_patterns, strict=True),
1688 def visit_MatchAs(self, node):
1689 name = node.name
1690 pattern = node.pattern
1694 self.write(node.name)
1696 with self.require_parens(_Precedence.TEST, node):
1697 self.set_precedence(_Precedence.BOR, node.pattern)
1698 self.traverse(node.pattern)
1699 self.write(f" as {node.name}")
1701 def visit_MatchOr(self, node):
1702 with self.require_parens(_Precedence.BOR, node):
1703 self.set_precedence(_Precedence.BOR.next(), *node.patterns)
1704 self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)