Lines Matching full:node
36 Parse the source into an AST node.
56 Safely evaluate an expression node or a string containing a Python
57 expression. The string or node provided may only consist of the following
65 def _raise_malformed_node(node): argument
66 msg = "malformed node or string"
67 if lno := getattr(node, 'lineno', None):
69 raise ValueError(msg + f': {node!r}')
70 def _convert_num(node): argument
71 if not isinstance(node, Constant) or type(node.value) not in (int, float, complex):
72 _raise_malformed_node(node)
73 return node.value
74 def _convert_signed_num(node): argument
75 if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
76 operand = _convert_num(node.operand)
77 if isinstance(node.op, UAdd):
81 return _convert_num(node)
82 def _convert(node): argument
83 if isinstance(node, Constant):
84 return node.value
85 elif isinstance(node, Tuple):
86 return tuple(map(_convert, node.elts))
87 elif isinstance(node, List):
88 return list(map(_convert, node.elts))
89 elif isinstance(node, Set):
90 return set(map(_convert, node.elts))
91 elif (isinstance(node, Call) and isinstance(node.func, Name) and
92 node.func.id == 'set' and node.args == node.keywords == []):
94 elif isinstance(node, Dict):
95 if len(node.keys) != len(node.values):
96 _raise_malformed_node(node)
97 return dict(zip(map(_convert, node.keys),
98 map(_convert, node.values)))
99 elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)):
100 left = _convert_signed_num(node.left)
101 right = _convert_num(node.right)
103 if isinstance(node.op, Add):
107 return _convert_signed_num(node)
111 def dump(node, annotate_fields=True, include_attributes=False, *, indent=None): argument
113 Return a formatted dump of the tree in node. This is mainly useful for
123 def _format(node, level=0): argument
131 if isinstance(node, AST):
132 cls = type(node)
136 for name in node._fields:
138 value = getattr(node, name)
151 if include_attributes and node._attributes:
152 for name in node._attributes:
154 value = getattr(node, name)
163 return '%s(%s)' % (node.__class__.__name__, ', '.join(args)), not args
164 return '%s(%s%s)' % (node.__class__.__name__, prefix, sep.join(args)), False
165 elif isinstance(node, list):
166 if not node:
168 return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
169 return repr(node), True
171 if not isinstance(node, AST):
172 raise TypeError('expected AST, got %r' % node.__class__.__name__)
175 return _format(node)[0]
195 def fix_missing_locations(node): argument
197 When you compile a node tree with compile(), the compiler expects lineno and
198 col_offset attributes for every node that supports them. This is rather
201 parent node. It works recursively starting at *node*.
203 def _fix(node, lineno, col_offset, end_lineno, end_col_offset): argument
204 if 'lineno' in node._attributes:
205 if not hasattr(node, 'lineno'):
206 node.lineno = lineno
208 lineno = node.lineno
209 if 'end_lineno' in node._attributes:
210 if getattr(node, 'end_lineno', None) is None:
211 node.end_lineno = end_lineno
213 end_lineno = node.end_lineno
214 if 'col_offset' in node._attributes:
215 if not hasattr(node, 'col_offset'):
216 node.col_offset = col_offset
218 col_offset = node.col_offset
219 if 'end_col_offset' in node._attributes:
220 if getattr(node, 'end_col_offset', None) is None:
221 node.end_col_offset = end_col_offset
223 end_col_offset = node.end_col_offset
224 for child in iter_child_nodes(node):
226 _fix(node, 1, 0, 1, 0)
227 return node
230 def increment_lineno(node, n=1): argument
232 Increment the line number and end line number of each node in the tree
233 starting at *node* by *n*. This is useful to "move code" to a different
236 for child in walk(node):
244 return node
247 def iter_fields(node): argument
249 Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
250 that is present on *node*.
252 for field in node._fields:
254 yield field, getattr(node, field)
259 def iter_child_nodes(node): argument
261 Yield all direct child nodes of *node*, that is, all fields that are nodes
264 for name, field in iter_fields(node):
273 def get_docstring(node, clean=True): argument
275 Return the docstring for the given node or None if no docstring can
276 be found. If the node provided does not have docstrings a TypeError
282 if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
283 raise TypeError("%r can't have docstrings" % node.__class__.__name__)
284 if not(node.body and isinstance(node.body[0], Expr)):
286 node = node.body[0].value
287 if isinstance(node, Str):
288 text = node.s
289 elif isinstance(node, Constant) and isinstance(node.value, str):
290 text = node.value
335 def get_source_segment(source, node, *, padded=False): argument
336 """Get source code segment of the *source* that generated *node*.
345 if node.end_lineno is None or node.end_col_offset is None:
347 lineno = node.lineno - 1
348 end_lineno = node.end_lineno - 1
349 col_offset = node.col_offset
350 end_col_offset = node.end_col_offset
372 def walk(node): argument
374 Recursively yield all descendant nodes in the tree starting at *node*
375 (including *node* itself), in no specified order. This is useful if you
379 todo = deque([node])
381 node = todo.popleft()
382 todo.extend(iter_child_nodes(node))
383 yield node
388 A node visitor base class that walks the abstract syntax tree and calls a
389 visitor function for every node found. This function may return a value
396 class name of the node. So a `TryFinally` node visit function would
398 the `visit` method. If no visitor function exists for a node
406 def visit(self, node): argument
407 """Visit a node."""
408 method = 'visit_' + node.__class__.__name__
410 return visitor(node)
412 def generic_visit(self, node): argument
413 """Called if no explicit visitor function exists for a node."""
414 for field, value in iter_fields(node):
422 def visit_Constant(self, node): argument
423 value = node.value
440 return visitor(node)
441 return self.generic_visit(node)
450 visitor methods to replace or remove the old node. If the return value of
451 the visitor method is ``None``, the node will be removed from its location,
453 original node in which case no replacement takes place.
460 def visit_Name(self, node):
463 slice=Constant(value=node.id),
464 ctx=node.ctx
467 Keep in mind that if the node you're operating on has child nodes you must
469 method for the node first.
473 just a single node.
477 node = YourTransformer().visit(node)
480 def generic_visit(self, node): argument
481 for field, old_value in iter_fields(node):
497 delattr(node, field)
499 setattr(node, field, new_node)
500 return node
521 cls.__doc__ = """Deprecated AST node class. Use ast.Constant instead"""
596 """Deprecated AST node class."""
599 """Deprecated AST node class. Use the index value directly instead."""
604 """Deprecated AST node class. Use ast.Tuple instead."""
623 """Deprecated AST node class. Unused in Python 3."""
626 """Deprecated AST node class. Unused in Python 3."""
629 """Deprecated AST node class. Unused in Python 3."""
632 """Deprecated AST node class. Unused in Python 3."""
761 def require_parens(self, precedence, node): argument
763 return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
765 def get_precedence(self, node): argument
766 return self._precedences.get(node, _Precedence.TEST)
769 for node in nodes:
770 self._precedences[node] = precedence
772 def get_raw_docstring(self, node): argument
773 """If a docstring node is found in the body of the *node* parameter,
774 return that docstring node, None otherwise.
778 node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)
779 ) or len(node.body) < 1:
781 node = node.body[0]
782 if not isinstance(node, Expr):
784 node = node.value
785 if isinstance(node, Constant) and isinstance(node.value, str):
786 return node
788 def get_type_comment(self, node): argument
789 comment = self._type_ignores.get(node.lineno) or node.type_comment
793 def traverse(self, node): argument
794 if isinstance(node, list):
795 for item in node:
798 super().visit(node)
803 def visit(self, node): argument
805 (using ast.parse) will generate an AST equivalent to *node*"""
807 self.traverse(node)
810 def _write_docstring_and_traverse_body(self, node): argument
811 if (docstring := self.get_raw_docstring(node)):
813 self.traverse(node.body[1:])
815 self.traverse(node.body)
817 def visit_Module(self, node): argument
820 for ignore in node.type_ignores
822 self._write_docstring_and_traverse_body(node)
825 def visit_FunctionType(self, node): argument
828 lambda: self.write(", "), self.traverse, node.argtypes
832 self.traverse(node.returns)
834 def visit_Expr(self, node): argument
836 self.set_precedence(_Precedence.YIELD, node.value)
837 self.traverse(node.value)
839 def visit_NamedExpr(self, node): argument
840 with self.require_parens(_Precedence.TUPLE, node):
841 self.set_precedence(_Precedence.ATOM, node.target, node.value)
842 self.traverse(node.target)
844 self.traverse(node.value)
846 def visit_Import(self, node): argument
848 self.interleave(lambda: self.write(", "), self.traverse, node.names)
850 def visit_ImportFrom(self, node): argument
852 self.write("." * node.level)
853 if node.module:
854 self.write(node.module)
856 self.interleave(lambda: self.write(", "), self.traverse, node.names)
858 def visit_Assign(self, node): argument
860 for target in node.targets:
863 self.traverse(node.value)
864 if type_comment := self.get_type_comment(node):
867 def visit_AugAssign(self, node): argument
869 self.traverse(node.target)
870 self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
871 self.traverse(node.value)
873 def visit_AnnAssign(self, node): argument
875 with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
876 self.traverse(node.target)
878 self.traverse(node.annotation)
879 if node.value:
881 self.traverse(node.value)
883 def visit_Return(self, node): argument
885 if node.value:
887 self.traverse(node.value)
889 def visit_Pass(self, node): argument
892 def visit_Break(self, node): argument
895 def visit_Continue(self, node): argument
898 def visit_Delete(self, node): argument
900 self.interleave(lambda: self.write(", "), self.traverse, node.targets)
902 def visit_Assert(self, node): argument
904 self.traverse(node.test)
905 if node.msg:
907 self.traverse(node.msg)
909 def visit_Global(self, node): argument
911 self.interleave(lambda: self.write(", "), self.write, node.names)
913 def visit_Nonlocal(self, node): argument
915 self.interleave(lambda: self.write(", "), self.write, node.names)
917 def visit_Await(self, node): argument
918 with self.require_parens(_Precedence.AWAIT, node):
920 if node.value:
922 self.set_precedence(_Precedence.ATOM, node.value)
923 self.traverse(node.value)
925 def visit_Yield(self, node): argument
926 with self.require_parens(_Precedence.YIELD, node):
928 if node.value:
930 self.set_precedence(_Precedence.ATOM, node.value)
931 self.traverse(node.value)
933 def visit_YieldFrom(self, node): argument
934 with self.require_parens(_Precedence.YIELD, node):
936 if not node.value:
937 raise ValueError("Node can't be used without a value attribute.")
938 self.set_precedence(_Precedence.ATOM, node.value)
939 self.traverse(node.value)
941 def visit_Raise(self, node): argument
943 if not node.exc:
944 if node.cause:
945 raise ValueError(f"Node can't use cause without an exception.")
948 self.traverse(node.exc)
949 if node.cause:
951 self.traverse(node.cause)
953 def visit_Try(self, node): argument
956 self.traverse(node.body)
957 for ex in node.handlers:
959 if node.orelse:
962 self.traverse(node.orelse)
963 if node.finalbody:
966 self.traverse(node.finalbody)
968 def visit_ExceptHandler(self, node): argument
970 if node.type:
972 self.traverse(node.type)
973 if node.name:
975 self.write(node.name)
977 self.traverse(node.body)
979 def visit_ClassDef(self, node): argument
981 for deco in node.decorator_list:
984 self.fill("class " + node.name)
985 with self.delimit_if("(", ")", condition = node.bases or node.keywords):
987 for e in node.bases:
993 for e in node.keywords:
1001 self._write_docstring_and_traverse_body(node)
1003 def visit_FunctionDef(self, node): argument
1004 self._function_helper(node, "def")
1006 def visit_AsyncFunctionDef(self, node): argument
1007 self._function_helper(node, "async def")
1009 def _function_helper(self, node, fill_suffix): argument
1011 for deco in node.decorator_list:
1014 def_str = fill_suffix + " " + node.name
1017 self.traverse(node.args)
1018 if node.returns:
1020 self.traverse(node.returns)
1021 with self.block(extra=self.get_type_comment(node)):
1022 self._write_docstring_and_traverse_body(node)
1024 def visit_For(self, node): argument
1025 self._for_helper("for ", node)
1027 def visit_AsyncFor(self, node): argument
1028 self._for_helper("async for ", node)
1030 def _for_helper(self, fill, node): argument
1032 self.traverse(node.target)
1034 self.traverse(node.iter)
1035 with self.block(extra=self.get_type_comment(node)):
1036 self.traverse(node.body)
1037 if node.orelse:
1040 self.traverse(node.orelse)
1042 def visit_If(self, node): argument
1044 self.traverse(node.test)
1046 self.traverse(node.body)
1048 while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
1049 node = node.orelse[0]
1051 self.traverse(node.test)
1053 self.traverse(node.body)
1055 if node.orelse:
1058 self.traverse(node.orelse)
1060 def visit_While(self, node): argument
1062 self.traverse(node.test)
1064 self.traverse(node.body)
1065 if node.orelse:
1068 self.traverse(node.orelse)
1070 def visit_With(self, node): argument
1072 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1073 with self.block(extra=self.get_type_comment(node)):
1074 self.traverse(node.body)
1076 def visit_AsyncWith(self, node): argument
1078 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1079 with self.block(extra=self.get_type_comment(node)):
1080 self.traverse(node.body)
1126 def visit_JoinedStr(self, node): argument
1129 self._fstring_JoinedStr(node, self.buffer_writer)
1140 for value in node.values:
1157 def visit_FormattedValue(self, node): argument
1159 self._fstring_FormattedValue(node, self.buffer_writer)
1162 def _fstring_JoinedStr(self, node, write): argument
1163 for value in node.values:
1167 def _fstring_Constant(self, node, write): argument
1168 if not isinstance(node.value, str):
1170 value = node.value.replace("{", "{{").replace("}", "}}")
1173 def _fstring_FormattedValue(self, node, write): argument
1176 unparser.set_precedence(_Precedence.TEST.next(), node.value)
1177 expr = unparser.visit(node.value)
1183 if node.conversion != -1:
1184 conversion = chr(node.conversion)
1188 if node.format_spec:
1190 meth = getattr(self, "_fstring_" + type(node.format_spec).__name__)
1191 meth(node.format_spec, write)
1194 def visit_Name(self, node): argument
1195 self.write(node.id)
1197 def _write_docstring(self, node): argument
1199 if node.kind == "u":
1201 self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
1217 def visit_Constant(self, node): argument
1218 value = node.value
1225 if node.kind == "u":
1227 self._write_constant(node.value)
1229 def visit_List(self, node): argument
1231 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1233 def visit_ListComp(self, node): argument
1235 self.traverse(node.elt)
1236 for gen in node.generators:
1239 def visit_GeneratorExp(self, node): argument
1241 self.traverse(node.elt)
1242 for gen in node.generators:
1245 def visit_SetComp(self, node): argument
1247 self.traverse(node.elt)
1248 for gen in node.generators:
1251 def visit_DictComp(self, node): argument
1253 self.traverse(node.key)
1255 self.traverse(node.value)
1256 for gen in node.generators:
1259 def visit_comprehension(self, node): argument
1260 if node.is_async:
1264 self.set_precedence(_Precedence.TUPLE, node.target)
1265 self.traverse(node.target)
1267 self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
1268 self.traverse(node.iter)
1269 for if_clause in node.ifs:
1273 def visit_IfExp(self, node): argument
1274 with self.require_parens(_Precedence.TEST, node):
1275 self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
1276 self.traverse(node.body)
1278 self.traverse(node.test)
1280 self.set_precedence(_Precedence.TEST, node.orelse)
1281 self.traverse(node.orelse)
1283 def visit_Set(self, node): argument
1284 if node.elts:
1286 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1292 def visit_Dict(self, node): argument
1311 lambda: self.write(", "), write_item, zip(node.keys, node.values)
1314 def visit_Tuple(self, node): argument
1316 self.items_view(self.traverse, node.elts)
1326 def visit_UnaryOp(self, node): argument
1327 operator = self.unop[node.op.__class__.__name__]
1329 with self.require_parens(operator_precedence, node):
1335 self.set_precedence(operator_precedence, node.operand)
1336 self.traverse(node.operand)
1371 def visit_BinOp(self, node): argument
1372 operator = self.binop[node.op.__class__.__name__]
1374 with self.require_parens(operator_precedence, node):
1382 self.set_precedence(left_precedence, node.left)
1383 self.traverse(node.left)
1385 self.set_precedence(right_precedence, node.right)
1386 self.traverse(node.right)
1401 def visit_Compare(self, node): argument
1402 with self.require_parens(_Precedence.CMP, node):
1403 self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
1404 self.traverse(node.left)
1405 for o, e in zip(node.ops, node.comparators):
1412 def visit_BoolOp(self, node): argument
1413 operator = self.boolops[node.op.__class__.__name__]
1416 def increasing_level_traverse(node): argument
1419 self.set_precedence(operator_precedence, node)
1420 self.traverse(node)
1422 with self.require_parens(operator_precedence, node):
1424 self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
1426 def visit_Attribute(self, node): argument
1427 self.set_precedence(_Precedence.ATOM, node.value)
1428 self.traverse(node.value)
1429 # Special case: 3.__abs__() is a syntax error, so if node.value
1432 if isinstance(node.value, Constant) and isinstance(node.value.value, int):
1435 self.write(node.attr)
1437 def visit_Call(self, node): argument
1438 self.set_precedence(_Precedence.ATOM, node.func)
1439 self.traverse(node.func)
1442 for e in node.args:
1448 for e in node.keywords:
1455 def visit_Subscript(self, node): argument
1466 self.set_precedence(_Precedence.ATOM, node.value)
1467 self.traverse(node.value)
1469 if is_simple_tuple(node.slice):
1470 self.items_view(self.traverse, node.slice.elts)
1472 self.traverse(node.slice)
1474 def visit_Starred(self, node): argument
1476 self.set_precedence(_Precedence.EXPR, node.value)
1477 self.traverse(node.value)
1479 def visit_Ellipsis(self, node): argument
1482 def visit_Slice(self, node): argument
1483 if node.lower:
1484 self.traverse(node.lower)
1486 if node.upper:
1487 self.traverse(node.upper)
1488 if node.step:
1490 self.traverse(node.step)
1492 def visit_Match(self, node): argument
1494 self.traverse(node.subject)
1496 for case in node.cases:
1499 def visit_arg(self, node): argument
1500 self.write(node.arg)
1501 if node.annotation:
1503 self.traverse(node.annotation)
1505 def visit_arguments(self, node): argument
1508 all_args = node.posonlyargs + node.args
1509 defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
1520 if index == len(node.posonlyargs):
1524 if node.vararg or node.kwonlyargs:
1530 if node.vararg:
1531 self.write(node.vararg.arg)
1532 if node.vararg.annotation:
1534 self.traverse(node.vararg.annotation)
1537 if node.kwonlyargs:
1538 for a, d in zip(node.kwonlyargs, node.kw_defaults):
1546 if node.kwarg:
1551 self.write("**" + node.kwarg.arg)
1552 if node.kwarg.annotation:
1554 self.traverse(node.kwarg.annotation)
1556 def visit_keyword(self, node): argument
1557 if node.arg is None:
1560 self.write(node.arg)
1562 self.traverse(node.value)
1564 def visit_Lambda(self, node): argument
1565 with self.require_parens(_Precedence.TEST, node):
1567 self.traverse(node.args)
1569 self.set_precedence(_Precedence.TEST, node.body)
1570 self.traverse(node.body)
1572 def visit_alias(self, node): argument
1573 self.write(node.name)
1574 if node.asname:
1575 self.write(" as " + node.asname)
1577 def visit_withitem(self, node): argument
1578 self.traverse(node.context_expr)
1579 if node.optional_vars:
1581 self.traverse(node.optional_vars)
1583 def visit_match_case(self, node): argument
1585 self.traverse(node.pattern)
1586 if node.guard:
1588 self.traverse(node.guard)
1590 self.traverse(node.body)
1592 def visit_MatchValue(self, node): argument
1593 self.traverse(node.value)
1595 def visit_MatchSingleton(self, node): argument
1596 self._write_constant(node.value)
1598 def visit_MatchSequence(self, node): argument
1601 lambda: self.write(", "), self.traverse, node.patterns
1604 def visit_MatchStar(self, node): argument
1605 name = node.name
1610 def visit_MatchMapping(self, node): argument
1618 keys = node.keys
1622 zip(keys, node.patterns, strict=True),
1624 rest = node.rest
1630 def visit_MatchClass(self, node): argument
1631 self.set_precedence(_Precedence.ATOM, node.cls)
1632 self.traverse(node.cls)
1634 patterns = node.patterns
1638 attrs = node.kwd_attrs
1650 zip(attrs, node.kwd_patterns, strict=True),
1653 def visit_MatchAs(self, node): argument
1654 name = node.name
1655 pattern = node.pattern
1659 self.write(node.name)
1661 with self.require_parens(_Precedence.TEST, node):
1662 self.set_precedence(_Precedence.BOR, node.pattern)
1663 self.traverse(node.pattern)
1664 self.write(f" as {node.name}")
1666 def visit_MatchOr(self, node): argument
1667 with self.require_parens(_Precedence.BOR, node):
1668 self.set_precedence(_Precedence.BOR.next(), *node.patterns)
1669 self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)