# Copyright (c) 2014-2021, Simon Percivall and Spack Project Developers.
#
# SPDX-License-Identifier: Python-2.0
"Usage: unparse.py <path to source file>"
import ast
import sys
from ast import AST, FormattedValue, If, JoinedStr, Name, Tuple
from contextlib import contextmanager
from enum import IntEnum, auto
from typing import Optional
# TODO: if we require Python 3.7, use its `nullcontext()`
[docs]
@contextmanager
def nullcontext():
yield
[docs]
def is_non_empty_non_star_tuple(slice_value):
"""True for `(1, 2)`, False for `()` and `(1, *b)`"""
return (
isinstance(slice_value, Tuple)
and slice_value.elts
and not any(isinstance(elt, ast.Starred) for elt in slice_value.elts)
)
[docs]
def iter_fields(node):
"""
Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
that is present on *node*.
"""
for field in node._fields:
try:
yield field, getattr(node, field)
except AttributeError:
pass
[docs]
class NodeVisitor(object):
"""
A node visitor base class that walks the abstract syntax tree and calls a
visitor function for every node found. This function may return a value
which is forwarded by the `visit` method.
This class is meant to be subclassed, with the subclass adding visitor
methods.
Per default the visitor functions for the nodes are ``'visit_'`` +
class name of the node. So a `TryFinally` node visit function would
be `visit_TryFinally`. This behavior can be changed by overriding
the `visit` method. If no visitor function exists for a node
(return value `None`) the `generic_visit` visitor is used instead.
Don't use the `NodeVisitor` if you want to apply changes to nodes during
traversing. For this a special visitor exists (`NodeTransformer`) that
allows modifications.
"""
[docs]
def visit(self, node):
"""Visit a node."""
method = "visit_" + node.__class__.__name__
visitor = getattr(self, method, self.generic_visit)
return visitor(node)
[docs]
def generic_visit(self, node):
"""Called if no explicit visitor function exists for a node."""
for field, value in iter_fields(node):
if isinstance(value, list):
for item in value:
if isinstance(item, AST):
self.visit(item)
elif isinstance(value, AST):
self.visit(value)
# Large float and imaginary literals get turned into infinities in the AST.
# We unparse those infinities to INFSTR.
_INFSTR = "1e" + repr(sys.float_info.max_10_exp + 1)
class _Precedence(IntEnum):
"""Precedence table that originated from python grammar."""
NAMED_EXPR = auto() # <target> := <expr1>
TUPLE = auto() # <expr1>, <expr2>
YIELD = auto() # 'yield', 'yield from'
TEST = auto() # 'if'-'else', 'lambda'
OR = auto() # 'or'
AND = auto() # 'and'
NOT = auto() # 'not'
CMP = auto() # '<', '>', '==', '>=', '<=', '!=',
# 'in', 'not in', 'is', 'is not'
EXPR = auto()
BOR = EXPR # '|'
BXOR = auto() # '^'
BAND = auto() # '&'
SHIFT = auto() # '<<', '>>'
ARITH = auto() # '+', '-'
TERM = auto() # '*', '@', '/', '%', '//'
FACTOR = auto() # unary '+', '-', '~'
POWER = auto() # '**'
AWAIT = auto() # 'await'
ATOM = auto()
def next(self):
try:
return self.__class__(self + 1)
except ValueError:
return self
_SINGLE_QUOTES = ("'", '"')
_MULTI_QUOTES = ('"""', "'''")
_ALL_QUOTES = (*_SINGLE_QUOTES, *_MULTI_QUOTES)
[docs]
class Unparser(NodeVisitor):
"""Methods in this class recursively traverse an AST and
output source code for the abstract syntax; original formatting
is disregarded."""
def __init__(self, py_ver_consistent=False, _avoid_backslashes=False):
self._source = []
self._precedences = {}
self._type_ignores = {}
self._indent = 0
self._in_try_star = False
self._py_ver_consistent = py_ver_consistent
self._avoid_backslashes = _avoid_backslashes
[docs]
def interleave(self, inter, f, seq):
"""Call f on each item in seq, calling inter() in between."""
seq = iter(seq)
try:
f(next(seq))
except StopIteration:
pass
else:
for x in seq:
inter()
f(x)
[docs]
def items_view(self, traverser, items):
"""Traverse and separate the given *items* with a comma and append it to
the buffer. If *items* is a single item sequence, a trailing comma
will be added."""
if len(items) == 1:
traverser(items[0])
self.write(",")
else:
self.interleave(lambda: self.write(", "), traverser, items)
[docs]
def maybe_newline(self):
"""Adds a newline if it isn't the start of generated source"""
if self._source:
self.write("\n")
[docs]
def fill(self, text=""):
"""Indent a piece of text and append it, according to the current
indentation level"""
self.maybe_newline()
self.write(" " * self._indent + text)
[docs]
def write(self, *text):
"""Add new source parts"""
self._source.extend(text)
[docs]
@contextmanager
def buffered(self, buffer=None):
if buffer is None:
buffer = []
original_source = self._source
self._source = buffer
yield buffer
self._source = original_source
[docs]
@contextmanager
def block(self, *, extra=None):
"""A context manager for preparing the source for blocks. It adds
the character':', increases the indentation on enter and decreases
the indentation on exit. If *extra* is given, it will be directly
appended after the colon character.
"""
self.write(":")
if extra:
self.write(extra)
self._indent += 1
yield
self._indent -= 1
[docs]
@contextmanager
def delimit(self, start, end):
"""A context manager for preparing the source for expressions. It adds
*start* to the buffer and enters, after exit it adds *end*."""
self.write(start)
yield
self.write(end)
[docs]
def delimit_if(self, start, end, condition):
if condition:
return self.delimit(start, end)
else:
return nullcontext()
[docs]
def require_parens(self, precedence, node):
"""Shortcut to adding precedence related parens"""
return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
[docs]
def get_precedence(self, node):
return self._precedences.get(node, _Precedence.TEST)
[docs]
def set_precedence(self, precedence, *nodes):
for node in nodes:
self._precedences[node] = precedence
[docs]
def get_raw_docstring(self, node):
"""If a docstring node is found in the body of the *node* parameter,
return that docstring node, None otherwise.
Logic mirrored from ``_PyAST_GetDocString``."""
if (
not isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef, ast.ClassDef, ast.Module))
or len(node.body) < 1
):
return None
node = node.body[0]
if not isinstance(node, ast.Expr):
return None
node = node.value
if _is_str_literal(node):
return node
[docs]
def traverse(self, node):
if isinstance(node, list):
for item in node:
self.traverse(item)
else:
super().visit(node)
# Note: as visit() resets the output text, do NOT rely on
# NodeVisitor.generic_visit to handle any nodes (as it calls back in to
# the subclass visit() method, which resets self._source to an empty list)
[docs]
def visit(self, node):
"""Outputs a source code string that, if converted back to an ast
(using ast.parse) will generate an AST equivalent to *node*"""
self._source = []
self.traverse(node)
return "".join(self._source)
def _write_docstring_and_traverse_body(self, node):
docstring = self.get_raw_docstring(node)
if docstring:
self._write_docstring(docstring)
self.traverse(node.body[1:])
else:
self.traverse(node.body)
[docs]
def visit_Module(self, node):
# Python 3.8 introduced types
self._type_ignores = {
ignore.lineno: f"ignore{ignore.tag}" for ignore in getattr(node, "type_ignores", ())
}
self._write_docstring_and_traverse_body(node)
self._type_ignores.clear()
[docs]
def visit_FunctionType(self, node):
with self.delimit("(", ")"):
self.interleave(lambda: self.write(", "), self.traverse, node.argtypes)
self.write(" -> ")
self.traverse(node.returns)
[docs]
def visit_Expr(self, node):
self.fill()
self.set_precedence(_Precedence.YIELD, node.value)
self.traverse(node.value)
[docs]
def visit_NamedExpr(self, node):
with self.require_parens(_Precedence.NAMED_EXPR, node):
self.set_precedence(_Precedence.ATOM, node.target, node.value)
self.traverse(node.target)
self.write(" := ")
self.traverse(node.value)
[docs]
def visit_Import(self, node):
self.fill("import ")
self.interleave(lambda: self.write(", "), self.traverse, node.names)
[docs]
def visit_ImportFrom(self, node):
self.fill("from ")
self.write("." * (node.level or 0))
if node.module:
self.write(node.module)
self.write(" import ")
self.interleave(lambda: self.write(", "), self.traverse, node.names)
[docs]
def visit_Assign(self, node):
self.fill()
for target in node.targets:
self.set_precedence(_Precedence.TUPLE, target)
self.traverse(target)
self.write(" = ")
self.traverse(node.value)
type_comment = self.get_type_comment(node)
if type_comment:
self.write(type_comment)
[docs]
def visit_AugAssign(self, node):
self.fill()
self.traverse(node.target)
self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
self.traverse(node.value)
[docs]
def visit_AnnAssign(self, node):
self.fill()
with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
self.traverse(node.target)
self.write(": ")
self.traverse(node.annotation)
if node.value:
self.write(" = ")
self.traverse(node.value)
[docs]
def visit_Return(self, node):
self.fill("return")
if node.value:
self.write(" ")
self.traverse(node.value)
[docs]
def visit_Pass(self, node):
self.fill("pass")
[docs]
def visit_Break(self, node):
self.fill("break")
[docs]
def visit_Continue(self, node):
self.fill("continue")
[docs]
def visit_Delete(self, node):
self.fill("del ")
self.interleave(lambda: self.write(", "), self.traverse, node.targets)
[docs]
def visit_Assert(self, node):
self.fill("assert ")
self.traverse(node.test)
if node.msg:
self.write(", ")
self.traverse(node.msg)
[docs]
def visit_Global(self, node):
self.fill("global ")
self.interleave(lambda: self.write(", "), self.write, node.names)
[docs]
def visit_Nonlocal(self, node):
self.fill("nonlocal ")
self.interleave(lambda: self.write(", "), self.write, node.names)
[docs]
def visit_Await(self, node):
with self.require_parens(_Precedence.AWAIT, node):
self.write("await")
if node.value:
self.write(" ")
self.set_precedence(_Precedence.ATOM, node.value)
self.traverse(node.value)
[docs]
def visit_Yield(self, node):
with self.require_parens(_Precedence.YIELD, node):
self.write("yield")
if node.value:
self.write(" ")
self.set_precedence(_Precedence.ATOM, node.value)
self.traverse(node.value)
[docs]
def visit_YieldFrom(self, node):
with self.require_parens(_Precedence.YIELD, node):
self.write("yield from ")
if not node.value:
raise ValueError("Node can't be used without a value attribute.")
self.set_precedence(_Precedence.ATOM, node.value)
self.traverse(node.value)
[docs]
def visit_Raise(self, node):
self.fill("raise")
if not node.exc:
if node.cause:
raise ValueError("Node can't use cause without an exception.")
return
self.write(" ")
self.traverse(node.exc)
if node.cause:
self.write(" from ")
self.traverse(node.cause)
[docs]
def do_visit_try(self, node):
self.fill("try")
with self.block():
self.traverse(node.body)
for ex in node.handlers:
self.traverse(ex)
if node.orelse:
self.fill("else")
with self.block():
self.traverse(node.orelse)
if node.finalbody:
self.fill("finally")
with self.block():
self.traverse(node.finalbody)
[docs]
def visit_Try(self, node):
prev_in_try_star = self._in_try_star
try:
self._in_try_star = False
self.do_visit_try(node)
finally:
self._in_try_star = prev_in_try_star
[docs]
def visit_TryStar(self, node):
prev_in_try_star = self._in_try_star
try:
self._in_try_star = True
self.do_visit_try(node)
finally:
self._in_try_star = prev_in_try_star
[docs]
def visit_ExceptHandler(self, node):
self.fill("except*" if self._in_try_star else "except")
if node.type:
self.write(" ")
self.traverse(node.type)
if node.name:
self.write(" as ")
self.write(node.name)
with self.block():
self.traverse(node.body)
[docs]
def visit_ClassDef(self, node):
self.maybe_newline()
for deco in node.decorator_list:
self.fill("@")
self.traverse(deco)
self.fill("class " + node.name)
if hasattr(node, "type_params"):
self._type_params_helper(node.type_params)
with self.delimit_if("(", ")", condition=node.bases or node.keywords):
comma = False
for e in node.bases:
if comma:
self.write(", ")
else:
comma = True
self.traverse(e)
for e in node.keywords:
if comma:
self.write(", ")
else:
comma = True
self.traverse(e)
with self.block():
self._write_docstring_and_traverse_body(node)
[docs]
def visit_FunctionDef(self, node):
self._function_helper(node, "def")
[docs]
def visit_AsyncFunctionDef(self, node):
self._function_helper(node, "async def")
def _function_helper(self, node, fill_suffix):
self.maybe_newline()
for deco in node.decorator_list:
self.fill("@")
self.traverse(deco)
def_str = fill_suffix + " " + node.name
self.fill(def_str)
if hasattr(node, "type_params"):
self._type_params_helper(node.type_params)
with self.delimit("(", ")"):
self.traverse(node.args)
if node.returns:
self.write(" -> ")
self.traverse(node.returns)
with self.block(extra=self.get_type_comment(node)):
self._write_docstring_and_traverse_body(node)
def _type_params_helper(self, type_params):
if type_params is not None and len(type_params) > 0:
with self.delimit("[", "]"):
self.interleave(lambda: self.write(", "), self.traverse, type_params)
[docs]
def visit_TypeVar(self, node):
self.write(node.name)
if node.bound:
self.write(": ")
self.traverse(node.bound)
# Python 3.13 introduced default_value
if getattr(node, "default_value", False):
self.write(" = ")
self.traverse(node.default_value)
[docs]
def visit_TypeVarTuple(self, node):
self.write("*" + node.name)
# Python 3.13 introduced default_value
if getattr(node, "default_value", False):
self.write(" = ")
self.traverse(node.default_value)
[docs]
def visit_ParamSpec(self, node):
self.write("**" + node.name)
# Python 3.13 introduced default_value
if getattr(node, "default_value", False):
self.write(" = ")
self.traverse(node.default_value)
[docs]
def visit_TypeAlias(self, node):
self.fill("type ")
self.traverse(node.name)
self._type_params_helper(node.type_params)
self.write(" = ")
self.traverse(node.value)
[docs]
def visit_For(self, node):
self._for_helper("for ", node)
[docs]
def visit_AsyncFor(self, node):
self._for_helper("async for ", node)
def _for_helper(self, fill, node):
self.fill(fill)
self.set_precedence(_Precedence.TUPLE, node.target)
self.traverse(node.target)
self.write(" in ")
self.traverse(node.iter)
with self.block(extra=self.get_type_comment(node)):
self.traverse(node.body)
if node.orelse:
self.fill("else")
with self.block():
self.traverse(node.orelse)
[docs]
def visit_If(self, node):
self.fill("if ")
self.traverse(node.test)
with self.block():
self.traverse(node.body)
# collapse nested ifs into equivalent elifs.
while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
node = node.orelse[0]
self.fill("elif ")
self.traverse(node.test)
with self.block():
self.traverse(node.body)
# final else
if node.orelse:
self.fill("else")
with self.block():
self.traverse(node.orelse)
[docs]
def visit_While(self, node):
self.fill("while ")
self.traverse(node.test)
with self.block():
self.traverse(node.body)
if node.orelse:
self.fill("else")
with self.block():
self.traverse(node.orelse)
[docs]
def visit_With(self, node):
self.fill("with ")
self.interleave(lambda: self.write(", "), self.traverse, node.items)
with self.block(extra=self.get_type_comment(node)):
self.traverse(node.body)
[docs]
def visit_AsyncWith(self, node):
self.fill("async with ")
self.interleave(lambda: self.write(", "), self.traverse, node.items)
with self.block(extra=self.get_type_comment(node)):
self.traverse(node.body)
def _str_literal_helper(
self, string, *, quote_types=_ALL_QUOTES, escape_special_whitespace=False
):
"""Helper for writing string literals, minimizing escapes.
Returns the tuple (string literal to write, possible quote types).
"""
def escape_char(c):
# \n and \t are non-printable, but we only escape them if
# escape_special_whitespace is True
if not escape_special_whitespace and c in "\n\t":
return c
# Always escape backslashes and other non-printable characters
if c == "\\" or not c.isprintable():
return c.encode("unicode_escape").decode("ascii")
return c
escaped_string = "".join(map(escape_char, string))
possible_quotes = quote_types
if "\n" in escaped_string:
possible_quotes = [q for q in possible_quotes if q in _MULTI_QUOTES]
possible_quotes = [q for q in possible_quotes if q not in escaped_string]
if not possible_quotes:
# If there aren't any possible_quotes, fallback to using repr
# on the original string. Try to use a quote from quote_types,
# e.g., so that we use triple quotes for docstrings.
string = repr(string)
quote = next((q for q in quote_types if string[0] in q), string[0])
return string[1:-1], [quote]
if escaped_string:
# Sort so that we prefer '''"''' over """\""""
possible_quotes.sort(key=lambda q: q[0] == escaped_string[-1])
# If we're using triple quotes and we'd need to escape a final
# quote, escape it
if possible_quotes[0][0] == escaped_string[-1]:
assert len(possible_quotes[0]) == 3
escaped_string = escaped_string[:-1] + "\\" + escaped_string[-1]
return escaped_string, possible_quotes
def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
"""Write string literal value with a best effort attempt to avoid backslashes."""
string, quote_types = self._str_literal_helper(string, quote_types=quote_types)
quote_type = quote_types[0]
self.write(f"{quote_type}{string}{quote_type}")
# Python < 3.8. Num, Str, Bytes, NameConstant, Ellipsis replaced with Constant
# https://github.com/python/cpython/commit/3f22811fef73aec848d961593d95fa877f77ecbf
if sys.version_info < (3, 8):
def visit_Num(self, node):
repr_n = repr(node.n)
self.write(repr_n.replace("inf", _INFSTR))
def visit_Str(self, node):
self._write_constant(node.s)
def visit_Bytes(self, node):
self.write(repr(node.s))
def visit_NameConstant(self, node):
self.write(repr(node.value))
def visit_Ellipsis(self, node):
self.write("...")
def _ftstring_helper(self, parts):
new_parts = []
quote_types = list(_ALL_QUOTES)
fallback_to_repr = False
for value, is_constant in parts:
# Python 3.12 allows `f'{''}'`.
# But we unparse to `f'{""}'` for < 3.12 compat.
if True:
value, new_quote_types = self._str_literal_helper(
value, quote_types=quote_types, escape_special_whitespace=is_constant
)
if set(new_quote_types).isdisjoint(quote_types):
fallback_to_repr = True
break
quote_types = new_quote_types
elif "\n" in value:
quote_types = [q for q in quote_types if q in _MULTI_QUOTES]
assert quote_types
new_parts.append(value)
if fallback_to_repr:
# If we weren't able to find a quote type that works for all parts
# of the JoinedStr, fallback to using repr and triple single quotes.
quote_types = ["'''"]
new_parts.clear()
for value, is_constant in parts:
# Python 3.12 allows `f'{''}'`.
# We need to unparse to `f'{""}'` for < 3.12 compat.
if True:
value = repr('"' + value) # force repr to use single quotes
expected_prefix = "'\""
assert value.startswith(expected_prefix), repr(value)
value = value[len(expected_prefix) : -1]
new_parts.append(value)
value = "".join(new_parts)
quote_type = quote_types[0]
self.write(f"{quote_type}{value}{quote_type}")
def _write_ftstring(self, node, prefix):
self.write(prefix)
# Python 3.12 added support for backslashes inside format parts.
# We need to keep adding backslashes for python < 3.11 compat.
if self._avoid_backslashes:
with self.buffered() as buffer:
self._write_ftstring_inner(node)
return self._write_str_avoiding_backslashes("".join(buffer))
fstring_parts = []
for value in node.values:
with self.buffered() as buffer:
self._write_ftstring_inner(value)
fstring_parts.append(("".join(buffer), _is_str_literal(value)))
self._ftstring_helper(fstring_parts)
[docs]
def visit_JoinedStr(self, node):
self._write_ftstring(node, "f")
[docs]
def visit_TemplateStr(self, node):
self._write_ftstring(node, "t")
def _write_ftstring_inner(self, node, is_format_spec=False):
if isinstance(node, JoinedStr):
# for both the f-string itself, and format_spec
for value in node.values:
self._write_ftstring_inner(value, is_format_spec=is_format_spec)
elif isinstance(node, FormattedValue):
self.visit_FormattedValue(node)
elif _is_interpolation(node):
self.visit_Interpolation(node)
else: # str literal
maybe_string = _get_str_literal_value(node)
if maybe_string is None:
raise ValueError(f"Unexpected node inside JoinedStr, {node!r}")
value = maybe_string.replace("{", "{{").replace("}", "}}")
if is_format_spec:
value = value.replace("\\", "\\\\")
value = value.replace("'", "\\'")
value = value.replace('"', '\\"')
value = value.replace("\n", "\\n")
self.write(value)
def _unparse_interpolation_value(self, inner):
# Python <= 3.11 does not support backslashes inside format parts
unparser = type(self)(_avoid_backslashes=True)
unparser.set_precedence(_Precedence.TEST.next(), inner)
return unparser.visit(inner)
def _write_interpolation(self, node, use_str_attr=False):
with self.delimit("{", "}"):
if use_str_attr:
expr = node.str
else:
expr = self._unparse_interpolation_value(node.value)
# Python <= 3.11 does not support backslash in formats part
if "\\" in expr:
raise ValueError(
"Unable to avoid backslash in f-string expression part (python 3.11)"
)
if expr.startswith("{"):
# Separate pair of opening brackets as "{ {"
self.write(" ")
self.write(expr)
if node.conversion != -1:
self.write(f"!{chr(node.conversion)}")
if node.format_spec:
self.write(":")
self._write_ftstring_inner(node.format_spec, is_format_spec=True)
[docs]
def visit_Interpolation(self, node):
# If `str` is set to `None`, use the `value` to generate the source code.
self._write_interpolation(node, use_str_attr=node.str is not None)
[docs]
def visit_Name(self, node):
self.write(node.id)
def _write_docstring(self, node):
self.fill()
# Don't emit `u""` because it's not avail in python AST <= 3.7
# Ubuntu 18's Python 3.6 doesn't have "kind"
if not self._py_ver_consistent and getattr(node, "kind", None) == "u":
self.write("u")
# Python 3.8 replaced Str with Constant
value = _get_str_literal_value(node)
if value is None:
raise ValueError(f"Node {node!r} is not a string literal.")
self._write_str_avoiding_backslashes(value, quote_types=_MULTI_QUOTES)
def _write_constant(self, value):
if isinstance(value, (float, complex)):
# Substitute overflowing decimal literal for AST infinities,
# and inf - inf for NaNs.
self.write(
repr(value).replace("inf", _INFSTR).replace("nan", f"({_INFSTR}-{_INFSTR})")
)
# Python <= 3.11 does not support backslashes inside format parts
elif self._avoid_backslashes and isinstance(value, str):
self._write_str_avoiding_backslashes(value)
else:
self.write(repr(value))
[docs]
def visit_Constant(self, node):
value = node.value
if isinstance(value, tuple):
with self.delimit("(", ")"):
self.items_view(self._write_constant, value)
elif value is ...:
self.write("...")
else:
# Don't emit `u""` because it's not avail in python AST <= 3.7
# Ubuntu 18's Python 3.6 doesn't have "kind"
if not self._py_ver_consistent and getattr(node, "kind", None) == "u":
self.write("u")
self._write_constant(node.value)
[docs]
def visit_List(self, node):
with self.delimit("[", "]"):
self.interleave(lambda: self.write(", "), self.traverse, node.elts)
[docs]
def visit_ListComp(self, node):
with self.delimit("[", "]"):
self.traverse(node.elt)
for gen in node.generators:
self.traverse(gen)
[docs]
def visit_GeneratorExp(self, node):
with self.delimit("(", ")"):
self.traverse(node.elt)
for gen in node.generators:
self.traverse(gen)
[docs]
def visit_SetComp(self, node):
with self.delimit("{", "}"):
self.traverse(node.elt)
for gen in node.generators:
self.traverse(gen)
[docs]
def visit_DictComp(self, node):
with self.delimit("{", "}"):
self.traverse(node.key)
self.write(": ")
self.traverse(node.value)
for gen in node.generators:
self.traverse(gen)
[docs]
def visit_comprehension(self, node):
if node.is_async:
self.write(" async for ")
else:
self.write(" for ")
self.set_precedence(_Precedence.TUPLE, node.target)
self.traverse(node.target)
self.write(" in ")
self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
self.traverse(node.iter)
for if_clause in node.ifs:
self.write(" if ")
self.traverse(if_clause)
[docs]
def visit_IfExp(self, node):
with self.require_parens(_Precedence.TEST, node):
self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
self.traverse(node.body)
self.write(" if ")
self.traverse(node.test)
self.write(" else ")
self.set_precedence(_Precedence.TEST, node.orelse)
self.traverse(node.orelse)
[docs]
def visit_Set(self, node):
if node.elts:
with self.delimit("{", "}"):
self.interleave(lambda: self.write(", "), self.traverse, node.elts)
else:
# `{}` would be interpreted as a dictionary literal, and
# `set` might be shadowed. Thus:
self.write("{*()}")
[docs]
def visit_Dict(self, node):
def write_key_value_pair(k, v):
self.traverse(k)
self.write(": ")
self.traverse(v)
def write_item(item):
k, v = item
if k is None:
# for dictionary unpacking operator in dicts {**{'y': 2}}
# see PEP 448 for details
self.write("**")
self.set_precedence(_Precedence.EXPR, v)
self.traverse(v)
else:
write_key_value_pair(k, v)
with self.delimit("{", "}"):
self.interleave(lambda: self.write(", "), write_item, zip(node.keys, node.values))
[docs]
def visit_Tuple(self, node):
with self.delimit_if(
"(",
")",
# Don't drop redundant parenthesis to mimic python <= 3.10
self._py_ver_consistent
or len(node.elts) == 0
or self.get_precedence(node) > _Precedence.TUPLE,
):
self.items_view(self.traverse, node.elts)
unop = {"Invert": "~", "Not": "not", "UAdd": "+", "USub": "-"}
unop_precedence = {
"not": _Precedence.NOT,
"~": _Precedence.FACTOR,
"+": _Precedence.FACTOR,
"-": _Precedence.FACTOR,
}
[docs]
def visit_UnaryOp(self, node):
operator = self.unop[node.op.__class__.__name__]
operator_precedence = self.unop_precedence[operator]
with self.require_parens(operator_precedence, node):
self.write(operator)
# factor prefixes (+, -, ~) shouldn't be separated
# from the value they belong, (e.g: +1 instead of + 1)
if operator_precedence is not _Precedence.FACTOR:
self.write(" ")
self.set_precedence(operator_precedence, node.operand)
self.traverse(node.operand)
binop = {
"Add": "+",
"Sub": "-",
"Mult": "*",
"MatMult": "@",
"Div": "/",
"Mod": "%",
"LShift": "<<",
"RShift": ">>",
"BitOr": "|",
"BitXor": "^",
"BitAnd": "&",
"FloorDiv": "//",
"Pow": "**",
}
binop_precedence = {
"+": _Precedence.ARITH,
"-": _Precedence.ARITH,
"*": _Precedence.TERM,
"@": _Precedence.TERM,
"/": _Precedence.TERM,
"%": _Precedence.TERM,
"<<": _Precedence.SHIFT,
">>": _Precedence.SHIFT,
"|": _Precedence.BOR,
"^": _Precedence.BXOR,
"&": _Precedence.BAND,
"//": _Precedence.TERM,
"**": _Precedence.POWER,
}
binop_rassoc = frozenset(("**",))
[docs]
def visit_BinOp(self, node):
operator = self.binop[node.op.__class__.__name__]
operator_precedence = self.binop_precedence[operator]
with self.require_parens(operator_precedence, node):
if operator in self.binop_rassoc:
left_precedence = operator_precedence.next()
right_precedence = operator_precedence
else:
left_precedence = operator_precedence
right_precedence = operator_precedence.next()
self.set_precedence(left_precedence, node.left)
self.traverse(node.left)
self.write(f" {operator} ")
self.set_precedence(right_precedence, node.right)
self.traverse(node.right)
cmpops = {
"Eq": "==",
"NotEq": "!=",
"Lt": "<",
"LtE": "<=",
"Gt": ">",
"GtE": ">=",
"Is": "is",
"IsNot": "is not",
"In": "in",
"NotIn": "not in",
}
[docs]
def visit_Compare(self, node):
with self.require_parens(_Precedence.CMP, node):
self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
self.traverse(node.left)
for o, e in zip(node.ops, node.comparators):
self.write(" " + self.cmpops[o.__class__.__name__] + " ")
self.traverse(e)
boolops = {"And": "and", "Or": "or"}
boolop_precedence = {"and": _Precedence.AND, "or": _Precedence.OR}
[docs]
def visit_BoolOp(self, node):
operator = self.boolops[node.op.__class__.__name__]
operator_precedence = self.boolop_precedence[operator]
def increasing_level_traverse(node):
nonlocal operator_precedence
operator_precedence = operator_precedence.next()
self.set_precedence(operator_precedence, node)
self.traverse(node)
with self.require_parens(operator_precedence, node):
s = f" {operator} "
self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
[docs]
def visit_Attribute(self, node: ast.Attribute):
self.set_precedence(_Precedence.ATOM, node.value)
self.traverse(node.value)
# Special case: 3.__abs__() is a syntax error, so if node.value
# is an integer literal then we need to either parenthesize
# it or add an extra space to get 3 .__abs__().
if _is_int_literal(node.value):
self.write(" ")
self.write(".")
self.write(node.attr)
[docs]
def visit_Call(self, node):
self.set_precedence(_Precedence.ATOM, node.func)
self.traverse(node.func)
with self.delimit("(", ")"):
comma = False
for e in node.args:
if comma:
self.write(", ")
else:
comma = True
self.traverse(e)
for e in node.keywords:
if comma:
self.write(", ")
else:
comma = True
self.traverse(e)
[docs]
def visit_Subscript(self, node):
def is_non_empty_tuple(slice_value):
return isinstance(slice_value, Tuple) and slice_value.elts
self.set_precedence(_Precedence.ATOM, node.value)
self.traverse(node.value)
with self.delimit("[", "]"):
# Python >= 3.11 supports `a[42, *b]` (same AST as a[(42, *b)]),
# but this is syntax error in 3.10.
# So, always emit parenthesis `a[(42, *b)]`
if is_non_empty_non_star_tuple(node.slice):
self.items_view(self.traverse, node.slice.elts)
else:
self.traverse(node.slice)
[docs]
def visit_Starred(self, node):
self.write("*")
self.set_precedence(_Precedence.EXPR, node.value)
self.traverse(node.value)
# Python 3.9 simplified Subscript(Index(value)) to Subscript(value)
# https://github.com/python/cpython/commit/13d52c268699f199a8e917a0f1dc4c51e5346c42
[docs]
def visit_Index(self, node):
if is_non_empty_non_star_tuple(node.value):
self.items_view(self.traverse, node.value.elts)
else:
self.traverse(node.value)
[docs]
def visit_Slice(self, node):
if node.lower:
self.traverse(node.lower)
self.write(":")
if node.upper:
self.traverse(node.upper)
if node.step:
self.write(":")
self.traverse(node.step)
[docs]
def visit_Match(self, node):
self.fill("match ")
self.traverse(node.subject)
with self.block():
for case in node.cases:
self.traverse(case)
# Python 3.9 replaced ExtSlice(slices) with Tuple(slices, Load())
# https://github.com/python/cpython/commit/13d52c268699f199a8e917a0f1dc4c51e5346c42
[docs]
def visit_ExtSlice(self, node):
self.interleave(lambda: self.write(", "), self.traverse, node.dims)
[docs]
def visit_arg(self, node):
self.write(node.arg)
if node.annotation:
self.write(": ")
self.traverse(node.annotation)
[docs]
def visit_arguments(self, node):
first = True
# normal arguments
# Python 3.8 introduced position-only arguments (PEP 570)
all_args = getattr(node, "posonlyargs", []) + node.args
defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
for index, elements in enumerate(zip(all_args, defaults), 1):
a, d = elements
if first:
first = False
else:
self.write(", ")
self.traverse(a)
if d:
self.write("=")
self.traverse(d)
# Python 3.8 introduced position-only arguments (PEP 570)
if index == len(getattr(node, "posonlyargs", ())):
self.write(", /")
# varargs, or bare '*' if no varargs but keyword-only arguments present
if node.vararg or node.kwonlyargs:
if first:
first = False
else:
self.write(", ")
self.write("*")
if node.vararg:
self.write(node.vararg.arg)
if node.vararg.annotation:
self.write(": ")
self.traverse(node.vararg.annotation)
# keyword-only arguments
if node.kwonlyargs:
for a, d in zip(node.kwonlyargs, node.kw_defaults):
self.write(", ")
self.traverse(a)
if d:
self.write("=")
self.traverse(d)
# kwargs
if node.kwarg:
if first:
first = False
else:
self.write(", ")
self.write("**" + node.kwarg.arg)
if node.kwarg.annotation:
self.write(": ")
self.traverse(node.kwarg.annotation)
[docs]
def visit_keyword(self, node):
if node.arg is None:
self.write("**")
else:
self.write(node.arg)
self.write("=")
self.traverse(node.value)
[docs]
def visit_Lambda(self, node):
with self.require_parens(_Precedence.TEST, node):
self.write("lambda")
with self.buffered() as buffer:
self.traverse(node.args)
# Don't omit extra space to keep old package hash
# (extra space was removed in python 3.11)
if buffer or self._py_ver_consistent:
self.write(" ", *buffer)
self.write(": ")
self.set_precedence(_Precedence.TEST, node.body)
self.traverse(node.body)
[docs]
def visit_alias(self, node):
self.write(node.name)
if node.asname:
self.write(" as " + node.asname)
[docs]
def visit_withitem(self, node):
self.traverse(node.context_expr)
if node.optional_vars:
self.write(" as ")
self.traverse(node.optional_vars)
[docs]
def visit_match_case(self, node):
self.fill("case ")
self.traverse(node.pattern)
if node.guard:
self.write(" if ")
self.traverse(node.guard)
with self.block():
self.traverse(node.body)
[docs]
def visit_MatchValue(self, node):
self.traverse(node.value)
[docs]
def visit_MatchSingleton(self, node):
self._write_constant(node.value)
[docs]
def visit_MatchSequence(self, node):
with self.delimit("[", "]"):
self.interleave(lambda: self.write(", "), self.traverse, node.patterns)
[docs]
def visit_MatchStar(self, node):
name = node.name
if name is None:
name = "_"
self.write(f"*{name}")
[docs]
def visit_MatchMapping(self, node):
def write_key_pattern_pair(pair):
k, p = pair
self.traverse(k)
self.write(": ")
self.traverse(p)
with self.delimit("{", "}"):
keys = node.keys
self.interleave(
lambda: self.write(", "),
write_key_pattern_pair,
# (zip strict is >= Python 3.10)
zip(keys, node.patterns),
)
rest = node.rest
if rest is not None:
if keys:
self.write(", ")
self.write(f"**{rest}")
[docs]
def visit_MatchClass(self, node):
self.set_precedence(_Precedence.ATOM, node.cls)
self.traverse(node.cls)
with self.delimit("(", ")"):
patterns = node.patterns
self.interleave(lambda: self.write(", "), self.traverse, patterns)
attrs = node.kwd_attrs
if attrs:
def write_attr_pattern(pair):
attr, pattern = pair
self.write(f"{attr}=")
self.traverse(pattern)
if patterns:
self.write(", ")
self.interleave(
lambda: self.write(", "),
write_attr_pattern,
# (zip strict is >= Python 3.10)
zip(attrs, node.kwd_patterns),
)
[docs]
def visit_MatchAs(self, node):
name = node.name
pattern = node.pattern
if name is None:
self.write("_")
elif pattern is None:
self.write(node.name)
else:
with self.require_parens(_Precedence.TEST, node):
self.set_precedence(_Precedence.BOR, node.pattern)
self.traverse(node.pattern)
self.write(f" as {node.name}")
[docs]
def visit_MatchOr(self, node):
with self.require_parens(_Precedence.BOR, node):
self.set_precedence(_Precedence.BOR.next(), *node.patterns)
self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)
if sys.version_info >= (3, 8):
def _is_int_literal(node: ast.AST) -> bool:
"""Check if a node represents a literal int."""
return isinstance(node, ast.Constant) and isinstance(node.value, int)
def _is_str_literal(node: ast.AST) -> bool:
"""Check if a node represents a literal str."""
return isinstance(node, ast.Constant) and isinstance(node.value, str)
def _get_str_literal_value(node: ast.AST) -> Optional[str]:
"""Get the string value of a literal str node."""
if isinstance(node, ast.Constant) and isinstance(node.value, str):
return node.value
return None
else:
def _is_int_literal(node: ast.AST) -> bool:
"""Check if a node represents a literal int."""
return isinstance(node, ast.Num) and isinstance(node.n, int)
def _is_str_literal(node: ast.AST) -> bool:
"""Check if a node represents a literal str."""
return isinstance(node, ast.Str)
def _get_str_literal_value(node: ast.AST) -> Optional[str]:
"""Get the string value of a literal str node."""
return node.s if isinstance(node, ast.Str) else None
if sys.version_info >= (3, 14):
def _is_interpolation(node: ast.AST) -> bool:
"""Check if a node represents a template string literal."""
return isinstance(node, ast.Interpolation)
else:
def _is_interpolation(node: ast.AST) -> bool:
"""Check if a node represents a template string literal."""
return False