Lines Matching refs:self
414 def visit(self, node):
417 visitor = getattr(self, method, self.generic_visit)
420 def generic_visit(self, node):
426 self.visit(item)
428 self.visit(value)
430 def visit_Constant(self, node):
441 visitor = getattr(self, method)
449 return self.generic_visit(node)
468 def visit_Name(self, node):
488 def generic_visit(self, node):
494 value = self.visit(value)
503 new_node = self.visit(old_value)
516 def _getter(self):
518 return self.value
520 def _setter(self, value):
521 self.value = value
621 def _dims_getter(self):
623 return self.elts
625 def _dims_setter(self, value):
626 self.elts = value
672 def next(self):
674 return self.__class__(self + 1)
676 return self
688 def __init__(self, *, _avoid_backslashes=False):
689 self._source = []
690 self._precedences = {}
691 self._type_ignores = {}
692 self._indent = 0
693 self._avoid_backslashes = _avoid_backslashes
694 self._in_try_star = False
696 def interleave(self, inter, f, seq):
708 def items_view(self, traverser, items):
714 self.write(",")
716 self.interleave(lambda: self.write(", "), traverser, items)
718 def maybe_newline(self):
720 if self._source:
721 self.write("\n")
723 def fill(self, text=""):
726 self.maybe_newline()
727 self.write(" " * self._indent + text)
729 def write(self, *text):
731 self._source.extend(text)
734 def buffered(self, buffer = None):
738 original_source = self._source
739 self._source = buffer
741 self._source = original_source
744 def block(self, *, extra = None):
750 self.write(":")
752 self.write(extra)
753 self._indent += 1
755 self._indent -= 1
758 def delimit(self, start, end):
762 self.write(start)
764 self.write(end)
766 def delimit_if(self, start, end, condition):
768 return self.delimit(start, end)
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)
779 def set_precedence(self, precedence, *nodes):
781 self._precedences[node] = precedence
783 def get_raw_docstring(self, 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):
807 self.traverse(item)
813 # the subclass visit() method, which resets self._source to an empty list)
814 def visit(self, node):
817 self._source = []
818 self.traverse(node)
819 return "".join(self._source)
821 def _write_docstring_and_traverse_body(self, node):
822 if (docstring := self.get_raw_docstring(node)):
823 self._write_docstring(docstring)
824 self.traverse(node.body[1:])
826 self.traverse(node.body)
828 def visit_Module(self, node):
829 self._type_ignores = {
833 self._write_docstring_and_traverse_body(node)
834 self._type_ignores.clear()
836 def visit_FunctionType(self, node):
837 with self.delimit("(", ")"):
838 self.interleave(
839 lambda: self.write(", "), self.traverse, node.argtypes
842 self.write(" -> ")
843 self.traverse(node.returns)
845 def visit_Expr(self, node):
846 self.fill()
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)
854 self.write(" := ")
855 self.traverse(node.value)
857 def visit_Import(self, node):
858 self.fill("import ")
859 self.interleave(lambda: self.write(", "), self.traverse, node.names)
861 def visit_ImportFrom(self, node):
862 self.fill("from ")
863 self.write("." * (node.level or 0))
865 self.write(node.module)
866 self.write(" import ")
867 self.interleave(lambda: self.write(", "), self.traverse, node.names)
869 def visit_Assign(self, node):
870 self.fill()
872 self.set_precedence(_Precedence.TUPLE, target)
873 self.traverse(target)
874 self.write(" = ")
875 self.traverse(node.value)
876 if type_comment := self.get_type_comment(node):
877 self.write(type_comment)
879 def visit_AugAssign(self, node):
880 self.fill()
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):
886 self.fill()
887 with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
888 self.traverse(node.target)
889 self.write(": ")
890 self.traverse(node.annotation)
892 self.write(" = ")
893 self.traverse(node.value)
895 def visit_Return(self, node):
896 self.fill("return")
898 self.write(" ")
899 self.traverse(node.value)
901 def visit_Pass(self, node):
902 self.fill("pass")
904 def visit_Break(self, node):
905 self.fill("break")
907 def visit_Continue(self, node):
908 self.fill("continue")
910 def visit_Delete(self, node):
911 self.fill("del ")
912 self.interleave(lambda: self.write(", "), self.traverse, node.targets)
914 def visit_Assert(self, node):
915 self.fill("assert ")
916 self.traverse(node.test)
918 self.write(", ")
919 self.traverse(node.msg)
921 def visit_Global(self, node):
922 self.fill("global ")
923 self.interleave(lambda: self.write(", "), self.write, node.names)
925 def visit_Nonlocal(self, node):
926 self.fill("nonlocal ")
927 self.interleave(lambda: self.write(", "), self.write, node.names)
929 def visit_Await(self, node):
930 with self.require_parens(_Precedence.AWAIT, node):
931 self.write("await")
933 self.write(" ")
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):
939 self.write("yield")
941 self.write(" ")
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):
947 self.write("yield from ")
950 self.set_precedence(_Precedence.ATOM, node.value)
951 self.traverse(node.value)
953 def visit_Raise(self, node):
954 self.fill("raise")
959 self.write(" ")
960 self.traverse(node.exc)
962 self.write(" from ")
963 self.traverse(node.cause)
965 def do_visit_try(self, node):
966 self.fill("try")
967 with self.block():
968 self.traverse(node.body)
970 self.traverse(ex)
972 self.fill("else")
973 with self.block():
974 self.traverse(node.orelse)
976 self.fill("finally")
977 with self.block():
978 self.traverse(node.finalbody)
980 def visit_Try(self, node):
981 prev_in_try_star = self._in_try_star
983 self._in_try_star = False
984 self.do_visit_try(node)
986 self._in_try_star = prev_in_try_star
988 def visit_TryStar(self, node):
989 prev_in_try_star = self._in_try_star
991 self._in_try_star = True
992 self.do_visit_try(node)
994 self._in_try_star = prev_in_try_star
996 def visit_ExceptHandler(self, node):
997 self.fill("except*" if self._in_try_star else "except")
999 self.write(" ")
1000 self.traverse(node.type)
1002 self.write(" as ")
1003 self.write(node.name)
1004 with self.block():
1005 self.traverse(node.body)
1007 def visit_ClassDef(self, node):
1008 self.maybe_newline()
1010 self.fill("@")
1011 self.traverse(deco)
1012 self.fill("class " + node.name)
1013 with self.delimit_if("(", ")", condition = node.bases or node.keywords):
1017 self.write(", ")
1020 self.traverse(e)
1023 self.write(", ")
1026 self.traverse(e)
1028 with self.block():
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):
1038 self.maybe_newline()
1040 self.fill("@")
1041 self.traverse(deco)
1043 self.fill(def_str)
1044 with self.delimit("(", ")"):
1045 self.traverse(node.args)
1047 self.write(" -> ")
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):
1059 self.fill(fill)
1060 self.set_precedence(_Precedence.TUPLE, node.target)
1061 self.traverse(node.target)
1062 self.write(" in ")
1063 self.traverse(node.iter)
1064 with self.block(extra=self.get_type_comment(node)):
1065 self.traverse(node.body)
1067 self.fill("else")
1068 with self.block():
1069 self.traverse(node.orelse)
1071 def visit_If(self, node):
1072 self.fill("if ")
1073 self.traverse(node.test)
1074 with self.block():
1075 self.traverse(node.body)
1079 self.fill("elif ")
1080 self.traverse(node.test)
1081 with self.block():
1082 self.traverse(node.body)
1085 self.fill("else")
1086 with self.block():
1087 self.traverse(node.orelse)
1089 def visit_While(self, node):
1090 self.fill("while ")
1091 self.traverse(node.test)
1092 with self.block():
1093 self.traverse(node.body)
1095 self.fill("else")
1096 with self.block():
1097 self.traverse(node.orelse)
1099 def visit_With(self, node):
1100 self.fill("with ")
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):
1106 self.fill("async with ")
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)
1112 self, string, *, quote_types=_ALL_QUOTES, escape_special_whitespace=False
1149 def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
1151 string, quote_types = self._str_literal_helper(string, quote_types=quote_types)
1153 self.write(f"{quote_type}{string}{quote_type}")
1155 def visit_JoinedStr(self, node):
1156 self.write("f")
1157 if self._avoid_backslashes:
1158 with self.buffered() as buffer:
1159 self._write_fstring_inner(node)
1160 return self._write_str_avoiding_backslashes("".join(buffer))
1170 with self.buffered() as buffer:
1171 self._write_fstring_inner(value)
1179 value, quote_types = self._str_literal_helper(
1188 self.write(f"{quote_type}{value}{quote_type}")
1190 def _write_fstring_inner(self, node):
1194 self._write_fstring_inner(value)
1197 self.write(value)
1199 self.visit_FormattedValue(node)
1203 def visit_FormattedValue(self, node):
1205 unparser = type(self)(_avoid_backslashes=True)
1209 with self.delimit("{", "}"):
1217 self.write(" ")
1218 self.write(expr)
1220 self.write(f"!{chr(node.conversion)}")
1222 self.write(":")
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):
1229 self.fill()
1231 self.write("u")
1232 self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
1234 def _write_constant(self, value):
1238 self.write(
1243 elif self._avoid_backslashes and isinstance(value, str):
1244 self._write_str_avoiding_backslashes(value)
1246 self.write(repr(value))
1248 def visit_Constant(self, node):
1251 with self.delimit("(", ")"):
1252 self.items_view(self._write_constant, value)
1254 self.write("...")
1257 self.write("u")
1258 self._write_constant(node.value)
1260 def visit_List(self, node):
1261 with self.delimit("[", "]"):
1262 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1264 def visit_ListComp(self, node):
1265 with self.delimit("[", "]"):
1266 self.traverse(node.elt)
1268 self.traverse(gen)
1270 def visit_GeneratorExp(self, node):
1271 with self.delimit("(", ")"):
1272 self.traverse(node.elt)
1274 self.traverse(gen)
1276 def visit_SetComp(self, node):
1277 with self.delimit("{", "}"):
1278 self.traverse(node.elt)
1280 self.traverse(gen)
1282 def visit_DictComp(self, node):
1283 with self.delimit("{", "}"):
1284 self.traverse(node.key)
1285 self.write(": ")
1286 self.traverse(node.value)
1288 self.traverse(gen)
1290 def visit_comprehension(self, node):
1292 self.write(" async for ")
1294 self.write(" for ")
1295 self.set_precedence(_Precedence.TUPLE, node.target)
1296 self.traverse(node.target)
1297 self.write(" in ")
1298 self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
1299 self.traverse(node.iter)
1301 self.write(" if ")
1302 self.traverse(if_clause)
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)
1308 self.write(" if ")
1309 self.traverse(node.test)
1310 self.write(" else ")
1311 self.set_precedence(_Precedence.TEST, node.orelse)
1312 self.traverse(node.orelse)
1314 def visit_Set(self, node):
1316 with self.delimit("{", "}"):
1317 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1321 self.write('{*()}')
1323 def visit_Dict(self, node):
1325 self.traverse(k)
1326 self.write(": ")
1327 self.traverse(v)
1334 self.write("**")
1335 self.set_precedence(_Precedence.EXPR, v)
1336 self.traverse(v)
1340 with self.delimit("{", "}"):
1341 self.interleave(
1342 lambda: self.write(", "), write_item, zip(node.keys, node.values)
1345 def visit_Tuple(self, node):
1346 with self.delimit_if(
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__]
1363 operator_precedence = self.unop_precedence[operator]
1364 with self.require_parens(operator_precedence, node):
1365 self.write(operator)
1369 self.write(" ")
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__]
1408 operator_precedence = self.binop_precedence[operator]
1409 with self.require_parens(operator_precedence, node):
1410 if operator in self.binop_rassoc:
1417 self.set_precedence(left_precedence, node.left)
1418 self.traverse(node.left)
1419 self.write(f" {operator} ")
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)
1441 self.write(" " + self.cmpops[o.__class__.__name__] + " ")
1442 self.traverse(e)
1447 def visit_BoolOp(self, node):
1448 operator = self.boolops[node.op.__class__.__name__]
1449 operator_precedence = self.boolop_precedence[operator]
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)
1468 self.write(" ")
1469 self.write(".")
1470 self.write(node.attr)
1472 def visit_Call(self, node):
1473 self.set_precedence(_Precedence.ATOM, node.func)
1474 self.traverse(node.func)
1475 with self.delimit("(", ")"):
1479 self.write(", ")
1482 self.traverse(e)
1485 self.write(", ")
1488 self.traverse(e)
1490 def visit_Subscript(self, node):
1497 self.set_precedence(_Precedence.ATOM, node.value)
1498 self.traverse(node.value)
1499 with self.delimit("[", "]"):
1502 self.items_view(self.traverse, node.slice.elts)
1504 self.traverse(node.slice)
1506 def visit_Starred(self, node):
1507 self.write("*")
1508 self.set_precedence(_Precedence.EXPR, node.value)
1509 self.traverse(node.value)
1511 def visit_Ellipsis(self, node):
1512 self.write("...")
1514 def visit_Slice(self, node):
1516 self.traverse(node.lower)
1517 self.write(":")
1519 self.traverse(node.upper)
1521 self.write(":")
1522 self.traverse(node.step)
1524 def visit_Match(self, node):
1525 self.fill("match ")
1526 self.traverse(node.subject)
1527 with self.block():
1529 self.traverse(case)
1531 def visit_arg(self, node):
1532 self.write(node.arg)
1534 self.write(": ")
1535 self.traverse(node.annotation)
1537 def visit_arguments(self, node):
1547 self.write(", ")
1548 self.traverse(a)
1550 self.write("=")
1551 self.traverse(d)
1553 self.write(", /")
1560 self.write(", ")
1561 self.write("*")
1563 self.write(node.vararg.arg)
1565 self.write(": ")
1566 self.traverse(node.vararg.annotation)
1571 self.write(", ")
1572 self.traverse(a)
1574 self.write("=")
1575 self.traverse(d)
1582 self.write(", ")
1583 self.write("**" + node.kwarg.arg)
1585 self.write(": ")
1586 self.traverse(node.kwarg.annotation)
1588 def visit_keyword(self, node):
1590 self.write("**")
1592 self.write(node.arg)
1593 self.write("=")
1594 self.traverse(node.value)
1596 def visit_Lambda(self, node):
1597 with self.require_parens(_Precedence.TEST, node):
1598 self.write("lambda")
1599 with self.buffered() as buffer:
1600 self.traverse(node.args)
1602 self.write(" ", *buffer)
1603 self.write(": ")
1604 self.set_precedence(_Precedence.TEST, node.body)
1605 self.traverse(node.body)
1607 def visit_alias(self, node):
1608 self.write(node.name)
1610 self.write(" as " + node.asname)
1612 def visit_withitem(self, node):
1613 self.traverse(node.context_expr)
1615 self.write(" as ")
1616 self.traverse(node.optional_vars)
1618 def visit_match_case(self, node):
1619 self.fill("case ")
1620 self.traverse(node.pattern)
1622 self.write(" if ")
1623 self.traverse(node.guard)
1624 with self.block():
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):
1634 with self.delimit("[", "]"):
1635 self.interleave(
1636 lambda: self.write(", "), self.traverse, node.patterns
1639 def visit_MatchStar(self, node):
1643 self.write(f"*{name}")
1645 def visit_MatchMapping(self, node):
1648 self.traverse(k)
1649 self.write(": ")
1650 self.traverse(p)
1652 with self.delimit("{", "}"):
1654 self.interleave(
1655 lambda: self.write(", "),
1662 self.write(", ")
1663 self.write(f"**{rest}")
1665 def visit_MatchClass(self, node):
1666 self.set_precedence(_Precedence.ATOM, node.cls)
1667 self.traverse(node.cls)
1668 with self.delimit("(", ")"):
1670 self.interleave(
1671 lambda: self.write(", "), self.traverse, patterns
1677 self.write(f"{attr}=")
1678 self.traverse(pattern)
1681 self.write(", ")
1682 self.interleave(
1683 lambda: self.write(", "),
1688 def visit_MatchAs(self, node):
1692 self.write("_")
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)