You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
906 lines
27 KiB
906 lines
27 KiB
"Usage: unparse.py <path to source file>"
|
|
from __future__ import print_function, unicode_literals
|
|
import six
|
|
import sys
|
|
import ast
|
|
import os
|
|
import tokenize
|
|
from six import StringIO
|
|
|
|
# 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)
|
|
|
|
def interleave(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)
|
|
|
|
class Unparser:
|
|
"""Methods in this class recursively traverse an AST and
|
|
output source code for the abstract syntax; original formatting
|
|
is disregarded. """
|
|
|
|
def __init__(self, tree, file = sys.stdout):
|
|
"""Unparser(tree, file=sys.stdout) -> None.
|
|
Print the source for tree to file."""
|
|
self.f = file
|
|
self.future_imports = []
|
|
self._indent = 0
|
|
self.dispatch(tree)
|
|
print("", file=self.f)
|
|
self.f.flush()
|
|
|
|
def fill(self, text = ""):
|
|
"Indent a piece of text, according to the current indentation level"
|
|
self.f.write("\n"+" "*self._indent + text)
|
|
|
|
def write(self, text):
|
|
"Append a piece of text to the current line."
|
|
self.f.write(six.text_type(text))
|
|
|
|
def enter(self):
|
|
"Print ':', and increase the indentation."
|
|
self.write(":")
|
|
self._indent += 1
|
|
|
|
def leave(self):
|
|
"Decrease the indentation level."
|
|
self._indent -= 1
|
|
|
|
def dispatch(self, tree):
|
|
"Dispatcher function, dispatching tree type T to method _T."
|
|
if isinstance(tree, list):
|
|
for t in tree:
|
|
self.dispatch(t)
|
|
return
|
|
meth = getattr(self, "_"+tree.__class__.__name__)
|
|
meth(tree)
|
|
|
|
|
|
############### Unparsing methods ######################
|
|
# There should be one method per concrete grammar type #
|
|
# Constructors should be grouped by sum type. Ideally, #
|
|
# this would follow the order in the grammar, but #
|
|
# currently doesn't. #
|
|
########################################################
|
|
|
|
def _Module(self, tree):
|
|
for stmt in tree.body:
|
|
self.dispatch(stmt)
|
|
|
|
def _Interactive(self, tree):
|
|
for stmt in tree.body:
|
|
self.dispatch(stmt)
|
|
|
|
def _Expression(self, tree):
|
|
self.dispatch(tree.body)
|
|
|
|
# stmt
|
|
def _Expr(self, tree):
|
|
self.fill()
|
|
self.dispatch(tree.value)
|
|
|
|
def _NamedExpr(self, tree):
|
|
self.write("(")
|
|
self.dispatch(tree.target)
|
|
self.write(" := ")
|
|
self.dispatch(tree.value)
|
|
self.write(")")
|
|
|
|
def _Import(self, t):
|
|
self.fill("import ")
|
|
interleave(lambda: self.write(", "), self.dispatch, t.names)
|
|
|
|
def _ImportFrom(self, t):
|
|
# A from __future__ import may affect unparsing, so record it.
|
|
if t.module and t.module == '__future__':
|
|
self.future_imports.extend(n.name for n in t.names)
|
|
|
|
self.fill("from ")
|
|
self.write("." * t.level)
|
|
if t.module:
|
|
self.write(t.module)
|
|
self.write(" import ")
|
|
interleave(lambda: self.write(", "), self.dispatch, t.names)
|
|
|
|
def _Assign(self, t):
|
|
self.fill()
|
|
for target in t.targets:
|
|
self.dispatch(target)
|
|
self.write(" = ")
|
|
self.dispatch(t.value)
|
|
|
|
def _AugAssign(self, t):
|
|
self.fill()
|
|
self.dispatch(t.target)
|
|
self.write(" "+self.binop[t.op.__class__.__name__]+"= ")
|
|
self.dispatch(t.value)
|
|
|
|
def _AnnAssign(self, t):
|
|
self.fill()
|
|
if not t.simple and isinstance(t.target, ast.Name):
|
|
self.write('(')
|
|
self.dispatch(t.target)
|
|
if not t.simple and isinstance(t.target, ast.Name):
|
|
self.write(')')
|
|
self.write(": ")
|
|
self.dispatch(t.annotation)
|
|
if t.value:
|
|
self.write(" = ")
|
|
self.dispatch(t.value)
|
|
|
|
def _Return(self, t):
|
|
self.fill("return")
|
|
if t.value:
|
|
self.write(" ")
|
|
self.dispatch(t.value)
|
|
|
|
def _Pass(self, t):
|
|
self.fill("pass")
|
|
|
|
def _Break(self, t):
|
|
self.fill("break")
|
|
|
|
def _Continue(self, t):
|
|
self.fill("continue")
|
|
|
|
def _Delete(self, t):
|
|
self.fill("del ")
|
|
interleave(lambda: self.write(", "), self.dispatch, t.targets)
|
|
|
|
def _Assert(self, t):
|
|
self.fill("assert ")
|
|
self.dispatch(t.test)
|
|
if t.msg:
|
|
self.write(", ")
|
|
self.dispatch(t.msg)
|
|
|
|
def _Exec(self, t):
|
|
self.fill("exec ")
|
|
self.dispatch(t.body)
|
|
if t.globals:
|
|
self.write(" in ")
|
|
self.dispatch(t.globals)
|
|
if t.locals:
|
|
self.write(", ")
|
|
self.dispatch(t.locals)
|
|
|
|
def _Print(self, t):
|
|
self.fill("print ")
|
|
do_comma = False
|
|
if t.dest:
|
|
self.write(">>")
|
|
self.dispatch(t.dest)
|
|
do_comma = True
|
|
for e in t.values:
|
|
if do_comma:self.write(", ")
|
|
else:do_comma=True
|
|
self.dispatch(e)
|
|
if not t.nl:
|
|
self.write(",")
|
|
|
|
def _Global(self, t):
|
|
self.fill("global ")
|
|
interleave(lambda: self.write(", "), self.write, t.names)
|
|
|
|
def _Nonlocal(self, t):
|
|
self.fill("nonlocal ")
|
|
interleave(lambda: self.write(", "), self.write, t.names)
|
|
|
|
def _Await(self, t):
|
|
self.write("(")
|
|
self.write("await")
|
|
if t.value:
|
|
self.write(" ")
|
|
self.dispatch(t.value)
|
|
self.write(")")
|
|
|
|
def _Yield(self, t):
|
|
self.write("(")
|
|
self.write("yield")
|
|
if t.value:
|
|
self.write(" ")
|
|
self.dispatch(t.value)
|
|
self.write(")")
|
|
|
|
def _YieldFrom(self, t):
|
|
self.write("(")
|
|
self.write("yield from")
|
|
if t.value:
|
|
self.write(" ")
|
|
self.dispatch(t.value)
|
|
self.write(")")
|
|
|
|
def _Raise(self, t):
|
|
self.fill("raise")
|
|
if six.PY3:
|
|
if not t.exc:
|
|
assert not t.cause
|
|
return
|
|
self.write(" ")
|
|
self.dispatch(t.exc)
|
|
if t.cause:
|
|
self.write(" from ")
|
|
self.dispatch(t.cause)
|
|
else:
|
|
self.write(" ")
|
|
if t.type:
|
|
self.dispatch(t.type)
|
|
if t.inst:
|
|
self.write(", ")
|
|
self.dispatch(t.inst)
|
|
if t.tback:
|
|
self.write(", ")
|
|
self.dispatch(t.tback)
|
|
|
|
def _Try(self, t):
|
|
self.fill("try")
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
for ex in t.handlers:
|
|
self.dispatch(ex)
|
|
if t.orelse:
|
|
self.fill("else")
|
|
self.enter()
|
|
self.dispatch(t.orelse)
|
|
self.leave()
|
|
if t.finalbody:
|
|
self.fill("finally")
|
|
self.enter()
|
|
self.dispatch(t.finalbody)
|
|
self.leave()
|
|
|
|
def _TryExcept(self, t):
|
|
self.fill("try")
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
for ex in t.handlers:
|
|
self.dispatch(ex)
|
|
if t.orelse:
|
|
self.fill("else")
|
|
self.enter()
|
|
self.dispatch(t.orelse)
|
|
self.leave()
|
|
|
|
def _TryFinally(self, t):
|
|
if len(t.body) == 1 and isinstance(t.body[0], ast.TryExcept):
|
|
# try-except-finally
|
|
self.dispatch(t.body)
|
|
else:
|
|
self.fill("try")
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
self.fill("finally")
|
|
self.enter()
|
|
self.dispatch(t.finalbody)
|
|
self.leave()
|
|
|
|
def _ExceptHandler(self, t):
|
|
self.fill("except")
|
|
if t.type:
|
|
self.write(" ")
|
|
self.dispatch(t.type)
|
|
if t.name:
|
|
self.write(" as ")
|
|
if six.PY3:
|
|
self.write(t.name)
|
|
else:
|
|
self.dispatch(t.name)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
def _ClassDef(self, t):
|
|
self.write("\n")
|
|
for deco in t.decorator_list:
|
|
self.fill("@")
|
|
self.dispatch(deco)
|
|
self.fill("class "+t.name)
|
|
if six.PY3:
|
|
self.write("(")
|
|
comma = False
|
|
for e in t.bases:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.dispatch(e)
|
|
for e in t.keywords:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.dispatch(e)
|
|
if sys.version_info[:2] < (3, 5):
|
|
if t.starargs:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.write("*")
|
|
self.dispatch(t.starargs)
|
|
if t.kwargs:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.write("**")
|
|
self.dispatch(t.kwargs)
|
|
self.write(")")
|
|
elif t.bases:
|
|
self.write("(")
|
|
for a in t.bases:
|
|
self.dispatch(a)
|
|
self.write(", ")
|
|
self.write(")")
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
def _FunctionDef(self, t):
|
|
self.__FunctionDef_helper(t, "def")
|
|
|
|
def _AsyncFunctionDef(self, t):
|
|
self.__FunctionDef_helper(t, "async def")
|
|
|
|
def __FunctionDef_helper(self, t, fill_suffix):
|
|
self.write("\n")
|
|
for deco in t.decorator_list:
|
|
self.fill("@")
|
|
self.dispatch(deco)
|
|
def_str = fill_suffix+" "+t.name + "("
|
|
self.fill(def_str)
|
|
self.dispatch(t.args)
|
|
self.write(")")
|
|
if getattr(t, "returns", False):
|
|
self.write(" -> ")
|
|
self.dispatch(t.returns)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
def _For(self, t):
|
|
self.__For_helper("for ", t)
|
|
|
|
def _AsyncFor(self, t):
|
|
self.__For_helper("async for ", t)
|
|
|
|
def __For_helper(self, fill, t):
|
|
self.fill(fill)
|
|
self.dispatch(t.target)
|
|
self.write(" in ")
|
|
self.dispatch(t.iter)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
if t.orelse:
|
|
self.fill("else")
|
|
self.enter()
|
|
self.dispatch(t.orelse)
|
|
self.leave()
|
|
|
|
def _If(self, t):
|
|
self.fill("if ")
|
|
self.dispatch(t.test)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
# collapse nested ifs into equivalent elifs.
|
|
while (t.orelse and len(t.orelse) == 1 and
|
|
isinstance(t.orelse[0], ast.If)):
|
|
t = t.orelse[0]
|
|
self.fill("elif ")
|
|
self.dispatch(t.test)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
# final else
|
|
if t.orelse:
|
|
self.fill("else")
|
|
self.enter()
|
|
self.dispatch(t.orelse)
|
|
self.leave()
|
|
|
|
def _While(self, t):
|
|
self.fill("while ")
|
|
self.dispatch(t.test)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
if t.orelse:
|
|
self.fill("else")
|
|
self.enter()
|
|
self.dispatch(t.orelse)
|
|
self.leave()
|
|
|
|
def _generic_With(self, t, async_=False):
|
|
self.fill("async with " if async_ else "with ")
|
|
if hasattr(t, 'items'):
|
|
interleave(lambda: self.write(", "), self.dispatch, t.items)
|
|
else:
|
|
self.dispatch(t.context_expr)
|
|
if t.optional_vars:
|
|
self.write(" as ")
|
|
self.dispatch(t.optional_vars)
|
|
self.enter()
|
|
self.dispatch(t.body)
|
|
self.leave()
|
|
|
|
def _With(self, t):
|
|
self._generic_With(t)
|
|
|
|
def _AsyncWith(self, t):
|
|
self._generic_With(t, async_=True)
|
|
|
|
# expr
|
|
def _Bytes(self, t):
|
|
self.write(repr(t.s))
|
|
|
|
def _Str(self, tree):
|
|
if six.PY3:
|
|
self.write(repr(tree.s))
|
|
else:
|
|
# if from __future__ import unicode_literals is in effect,
|
|
# then we want to output string literals using a 'b' prefix
|
|
# and unicode literals with no prefix.
|
|
if "unicode_literals" not in self.future_imports:
|
|
self.write(repr(tree.s))
|
|
elif isinstance(tree.s, str):
|
|
self.write("b" + repr(tree.s))
|
|
elif isinstance(tree.s, unicode):
|
|
self.write(repr(tree.s).lstrip("u"))
|
|
else:
|
|
assert False, "shouldn't get here"
|
|
|
|
def _JoinedStr(self, t):
|
|
# JoinedStr(expr* values)
|
|
self.write("f")
|
|
string = StringIO()
|
|
self._fstring_JoinedStr(t, string.write)
|
|
# Deviation from `unparse.py`: Try to find an unused quote.
|
|
# This change is made to handle _very_ complex f-strings.
|
|
v = string.getvalue()
|
|
if '\n' in v or '\r' in v:
|
|
quote_types = ["'''", '"""']
|
|
else:
|
|
quote_types = ["'", '"', '"""', "'''"]
|
|
for quote_type in quote_types:
|
|
if quote_type not in v:
|
|
v = "{quote_type}{v}{quote_type}".format(quote_type=quote_type, v=v)
|
|
break
|
|
else:
|
|
v = repr(v)
|
|
self.write(v)
|
|
|
|
def _FormattedValue(self, t):
|
|
# FormattedValue(expr value, int? conversion, expr? format_spec)
|
|
self.write("f")
|
|
string = StringIO()
|
|
self._fstring_JoinedStr(t, string.write)
|
|
self.write(repr(string.getvalue()))
|
|
|
|
def _fstring_JoinedStr(self, t, write):
|
|
for value in t.values:
|
|
meth = getattr(self, "_fstring_" + type(value).__name__)
|
|
meth(value, write)
|
|
|
|
def _fstring_Str(self, t, write):
|
|
value = t.s.replace("{", "{{").replace("}", "}}")
|
|
write(value)
|
|
|
|
def _fstring_Constant(self, t, write):
|
|
assert isinstance(t.value, str)
|
|
value = t.value.replace("{", "{{").replace("}", "}}")
|
|
write(value)
|
|
|
|
def _fstring_FormattedValue(self, t, write):
|
|
write("{")
|
|
expr = StringIO()
|
|
Unparser(t.value, expr)
|
|
expr = expr.getvalue().rstrip("\n")
|
|
if expr.startswith("{"):
|
|
write(" ") # Separate pair of opening brackets as "{ {"
|
|
write(expr)
|
|
if t.conversion != -1:
|
|
conversion = chr(t.conversion)
|
|
assert conversion in "sra"
|
|
write("!{conversion}".format(conversion=conversion))
|
|
if t.format_spec:
|
|
write(":")
|
|
meth = getattr(self, "_fstring_" + type(t.format_spec).__name__)
|
|
meth(t.format_spec, write)
|
|
write("}")
|
|
|
|
def _Name(self, t):
|
|
self.write(t.id)
|
|
|
|
def _NameConstant(self, t):
|
|
self.write(repr(t.value))
|
|
|
|
def _Repr(self, t):
|
|
self.write("`")
|
|
self.dispatch(t.value)
|
|
self.write("`")
|
|
|
|
def _write_constant(self, value):
|
|
if isinstance(value, (float, complex)):
|
|
# Substitute overflowing decimal literal for AST infinities.
|
|
self.write(repr(value).replace("inf", INFSTR))
|
|
else:
|
|
self.write(repr(value))
|
|
|
|
def _Constant(self, t):
|
|
value = t.value
|
|
if isinstance(value, tuple):
|
|
self.write("(")
|
|
if len(value) == 1:
|
|
self._write_constant(value[0])
|
|
self.write(",")
|
|
else:
|
|
interleave(lambda: self.write(", "), self._write_constant, value)
|
|
self.write(")")
|
|
elif value is Ellipsis: # instead of `...` for Py2 compatibility
|
|
self.write("...")
|
|
else:
|
|
if t.kind == "u":
|
|
self.write("u")
|
|
self._write_constant(t.value)
|
|
|
|
def _Num(self, t):
|
|
repr_n = repr(t.n)
|
|
if six.PY3:
|
|
self.write(repr_n.replace("inf", INFSTR))
|
|
else:
|
|
# Parenthesize negative numbers, to avoid turning (-1)**2 into -1**2.
|
|
if repr_n.startswith("-"):
|
|
self.write("(")
|
|
if "inf" in repr_n and repr_n.endswith("*j"):
|
|
repr_n = repr_n.replace("*j", "j")
|
|
# Substitute overflowing decimal literal for AST infinities.
|
|
self.write(repr_n.replace("inf", INFSTR))
|
|
if repr_n.startswith("-"):
|
|
self.write(")")
|
|
|
|
def _List(self, t):
|
|
self.write("[")
|
|
interleave(lambda: self.write(", "), self.dispatch, t.elts)
|
|
self.write("]")
|
|
|
|
def _ListComp(self, t):
|
|
self.write("[")
|
|
self.dispatch(t.elt)
|
|
for gen in t.generators:
|
|
self.dispatch(gen)
|
|
self.write("]")
|
|
|
|
def _GeneratorExp(self, t):
|
|
self.write("(")
|
|
self.dispatch(t.elt)
|
|
for gen in t.generators:
|
|
self.dispatch(gen)
|
|
self.write(")")
|
|
|
|
def _SetComp(self, t):
|
|
self.write("{")
|
|
self.dispatch(t.elt)
|
|
for gen in t.generators:
|
|
self.dispatch(gen)
|
|
self.write("}")
|
|
|
|
def _DictComp(self, t):
|
|
self.write("{")
|
|
self.dispatch(t.key)
|
|
self.write(": ")
|
|
self.dispatch(t.value)
|
|
for gen in t.generators:
|
|
self.dispatch(gen)
|
|
self.write("}")
|
|
|
|
def _comprehension(self, t):
|
|
if getattr(t, 'is_async', False):
|
|
self.write(" async for ")
|
|
else:
|
|
self.write(" for ")
|
|
self.dispatch(t.target)
|
|
self.write(" in ")
|
|
self.dispatch(t.iter)
|
|
for if_clause in t.ifs:
|
|
self.write(" if ")
|
|
self.dispatch(if_clause)
|
|
|
|
def _IfExp(self, t):
|
|
self.write("(")
|
|
self.dispatch(t.body)
|
|
self.write(" if ")
|
|
self.dispatch(t.test)
|
|
self.write(" else ")
|
|
self.dispatch(t.orelse)
|
|
self.write(")")
|
|
|
|
def _Set(self, t):
|
|
assert(t.elts) # should be at least one element
|
|
self.write("{")
|
|
interleave(lambda: self.write(", "), self.dispatch, t.elts)
|
|
self.write("}")
|
|
|
|
def _Dict(self, t):
|
|
self.write("{")
|
|
def write_key_value_pair(k, v):
|
|
self.dispatch(k)
|
|
self.write(": ")
|
|
self.dispatch(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.dispatch(v)
|
|
else:
|
|
write_key_value_pair(k, v)
|
|
interleave(lambda: self.write(", "), write_item, zip(t.keys, t.values))
|
|
self.write("}")
|
|
|
|
def _Tuple(self, t):
|
|
self.write("(")
|
|
if len(t.elts) == 1:
|
|
elt = t.elts[0]
|
|
self.dispatch(elt)
|
|
self.write(",")
|
|
else:
|
|
interleave(lambda: self.write(", "), self.dispatch, t.elts)
|
|
self.write(")")
|
|
|
|
unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
|
|
def _UnaryOp(self, t):
|
|
self.write("(")
|
|
self.write(self.unop[t.op.__class__.__name__])
|
|
self.write(" ")
|
|
if six.PY2 and isinstance(t.op, ast.USub) and isinstance(t.operand, ast.Num):
|
|
# If we're applying unary minus to a number, parenthesize the number.
|
|
# This is necessary: -2147483648 is different from -(2147483648) on
|
|
# a 32-bit machine (the first is an int, the second a long), and
|
|
# -7j is different from -(7j). (The first has real part 0.0, the second
|
|
# has real part -0.0.)
|
|
self.write("(")
|
|
self.dispatch(t.operand)
|
|
self.write(")")
|
|
else:
|
|
self.dispatch(t.operand)
|
|
self.write(")")
|
|
|
|
binop = { "Add":"+", "Sub":"-", "Mult":"*", "MatMult":"@", "Div":"/", "Mod":"%",
|
|
"LShift":"<<", "RShift":">>", "BitOr":"|", "BitXor":"^", "BitAnd":"&",
|
|
"FloorDiv":"//", "Pow": "**"}
|
|
def _BinOp(self, t):
|
|
self.write("(")
|
|
self.dispatch(t.left)
|
|
self.write(" " + self.binop[t.op.__class__.__name__] + " ")
|
|
self.dispatch(t.right)
|
|
self.write(")")
|
|
|
|
cmpops = {"Eq":"==", "NotEq":"!=", "Lt":"<", "LtE":"<=", "Gt":">", "GtE":">=",
|
|
"Is":"is", "IsNot":"is not", "In":"in", "NotIn":"not in"}
|
|
def _Compare(self, t):
|
|
self.write("(")
|
|
self.dispatch(t.left)
|
|
for o, e in zip(t.ops, t.comparators):
|
|
self.write(" " + self.cmpops[o.__class__.__name__] + " ")
|
|
self.dispatch(e)
|
|
self.write(")")
|
|
|
|
boolops = {ast.And: 'and', ast.Or: 'or'}
|
|
def _BoolOp(self, t):
|
|
self.write("(")
|
|
s = " %s " % self.boolops[t.op.__class__]
|
|
interleave(lambda: self.write(s), self.dispatch, t.values)
|
|
self.write(")")
|
|
|
|
def _Attribute(self,t):
|
|
self.dispatch(t.value)
|
|
# Special case: 3.__abs__() is a syntax error, so if t.value
|
|
# is an integer literal then we need to either parenthesize
|
|
# it or add an extra space to get 3 .__abs__().
|
|
if isinstance(t.value, getattr(ast, 'Constant', getattr(ast, 'Num', None))) and isinstance(t.value.n, int):
|
|
self.write(" ")
|
|
self.write(".")
|
|
self.write(t.attr)
|
|
|
|
def _Call(self, t):
|
|
self.dispatch(t.func)
|
|
self.write("(")
|
|
comma = False
|
|
for e in t.args:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.dispatch(e)
|
|
for e in t.keywords:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.dispatch(e)
|
|
if sys.version_info[:2] < (3, 5):
|
|
if t.starargs:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.write("*")
|
|
self.dispatch(t.starargs)
|
|
if t.kwargs:
|
|
if comma: self.write(", ")
|
|
else: comma = True
|
|
self.write("**")
|
|
self.dispatch(t.kwargs)
|
|
self.write(")")
|
|
|
|
def _Subscript(self, t):
|
|
self.dispatch(t.value)
|
|
self.write("[")
|
|
self.dispatch(t.slice)
|
|
self.write("]")
|
|
|
|
def _Starred(self, t):
|
|
self.write("*")
|
|
self.dispatch(t.value)
|
|
|
|
# slice
|
|
def _Ellipsis(self, t):
|
|
self.write("...")
|
|
|
|
def _Index(self, t):
|
|
self.dispatch(t.value)
|
|
|
|
def _Slice(self, t):
|
|
if t.lower:
|
|
self.dispatch(t.lower)
|
|
self.write(":")
|
|
if t.upper:
|
|
self.dispatch(t.upper)
|
|
if t.step:
|
|
self.write(":")
|
|
self.dispatch(t.step)
|
|
|
|
def _ExtSlice(self, t):
|
|
interleave(lambda: self.write(', '), self.dispatch, t.dims)
|
|
|
|
# argument
|
|
def _arg(self, t):
|
|
self.write(t.arg)
|
|
if t.annotation:
|
|
self.write(": ")
|
|
self.dispatch(t.annotation)
|
|
|
|
# others
|
|
def _arguments(self, t):
|
|
first = True
|
|
# normal arguments
|
|
all_args = getattr(t, 'posonlyargs', []) + t.args
|
|
defaults = [None] * (len(all_args) - len(t.defaults)) + t.defaults
|
|
for index, elements in enumerate(zip(all_args, defaults), 1):
|
|
a, d = elements
|
|
if first:first = False
|
|
else: self.write(", ")
|
|
self.dispatch(a)
|
|
if d:
|
|
self.write("=")
|
|
self.dispatch(d)
|
|
if index == len(getattr(t, 'posonlyargs', ())):
|
|
self.write(", /")
|
|
|
|
# varargs, or bare '*' if no varargs but keyword-only arguments present
|
|
if t.vararg or getattr(t, "kwonlyargs", False):
|
|
if first:first = False
|
|
else: self.write(", ")
|
|
self.write("*")
|
|
if t.vararg:
|
|
if hasattr(t.vararg, 'arg'):
|
|
self.write(t.vararg.arg)
|
|
if t.vararg.annotation:
|
|
self.write(": ")
|
|
self.dispatch(t.vararg.annotation)
|
|
else:
|
|
self.write(t.vararg)
|
|
if getattr(t, 'varargannotation', None):
|
|
self.write(": ")
|
|
self.dispatch(t.varargannotation)
|
|
|
|
# keyword-only arguments
|
|
if getattr(t, "kwonlyargs", False):
|
|
for a, d in zip(t.kwonlyargs, t.kw_defaults):
|
|
if first:first = False
|
|
else: self.write(", ")
|
|
self.dispatch(a),
|
|
if d:
|
|
self.write("=")
|
|
self.dispatch(d)
|
|
|
|
# kwargs
|
|
if t.kwarg:
|
|
if first:first = False
|
|
else: self.write(", ")
|
|
if hasattr(t.kwarg, 'arg'):
|
|
self.write("**"+t.kwarg.arg)
|
|
if t.kwarg.annotation:
|
|
self.write(": ")
|
|
self.dispatch(t.kwarg.annotation)
|
|
else:
|
|
self.write("**"+t.kwarg)
|
|
if getattr(t, 'kwargannotation', None):
|
|
self.write(": ")
|
|
self.dispatch(t.kwargannotation)
|
|
|
|
def _keyword(self, t):
|
|
if t.arg is None:
|
|
# starting from Python 3.5 this denotes a kwargs part of the invocation
|
|
self.write("**")
|
|
else:
|
|
self.write(t.arg)
|
|
self.write("=")
|
|
self.dispatch(t.value)
|
|
|
|
def _Lambda(self, t):
|
|
self.write("(")
|
|
self.write("lambda ")
|
|
self.dispatch(t.args)
|
|
self.write(": ")
|
|
self.dispatch(t.body)
|
|
self.write(")")
|
|
|
|
def _alias(self, t):
|
|
self.write(t.name)
|
|
if t.asname:
|
|
self.write(" as "+t.asname)
|
|
|
|
def _withitem(self, t):
|
|
self.dispatch(t.context_expr)
|
|
if t.optional_vars:
|
|
self.write(" as ")
|
|
self.dispatch(t.optional_vars)
|
|
|
|
def roundtrip(filename, output=sys.stdout):
|
|
if six.PY3:
|
|
with open(filename, "rb") as pyfile:
|
|
encoding = tokenize.detect_encoding(pyfile.readline)[0]
|
|
with open(filename, "r", encoding=encoding) as pyfile:
|
|
source = pyfile.read()
|
|
else:
|
|
with open(filename, "r") as pyfile:
|
|
source = pyfile.read()
|
|
tree = compile(source, filename, "exec", ast.PyCF_ONLY_AST, dont_inherit=True)
|
|
Unparser(tree, output)
|
|
|
|
|
|
|
|
def testdir(a):
|
|
try:
|
|
names = [n for n in os.listdir(a) if n.endswith('.py')]
|
|
except OSError:
|
|
print("Directory not readable: %s" % a, file=sys.stderr)
|
|
else:
|
|
for n in names:
|
|
fullname = os.path.join(a, n)
|
|
if os.path.isfile(fullname):
|
|
output = StringIO()
|
|
print('Testing %s' % fullname)
|
|
try:
|
|
roundtrip(fullname, output)
|
|
except Exception as e:
|
|
print(' Failed to compile, exception is %s' % repr(e))
|
|
elif os.path.isdir(fullname):
|
|
testdir(fullname)
|
|
|
|
def main(args):
|
|
if args[0] == '--testdir':
|
|
for a in args[1:]:
|
|
testdir(a)
|
|
else:
|
|
for a in args:
|
|
roundtrip(a)
|
|
|
|
if __name__=='__main__':
|
|
main(sys.argv[1:])
|