def visit_comprehension(self, tree):
return (T('for {} in {}').format(self.visit(tree.target), self.visit(tree.iter)) +
T('').join(' if ' + self.visit(i) for i in tree.ifs))
def assignment_component(after, targets, value):
# return T('(lambda {}: {})({})').format(targets, after, value)
return T('[{} for {} in [({})]][0]').format(after, targets, value)
def visit_Assert(self, tree):
return T(
'({after} if {} else ([] for [] in []).throw(AssertionError{}))'
).format(
self.visit(tree.test),
'' if tree.msg is None else T('({})').format(self.visit(tree.msg)))
def visit_Str(self, tree):
return T('{!r}').format(tree.s)
def visit_Tuple(self, tree):
return T('({})').format(T(', ').join(map(self.visit, tree.elts)) +
','*(len(tree.elts) == 1))
def visit_Repr(self, tree):
return T('`{}`').format(self.visit(tree.value))
def visit_SetComp(self, tree):
return self.comprehension_code(
tree.generators,
lambda ns, g: T('{{{} {}}}').format(ns.visit(tree.elt), g))
def visit_Expr(self, tree):
return T('({}, {after})[1]').format(self.visit(tree.value))
def visit_ExtSlice(self, tree):
return (T(', ').join(map(self.visit, tree.dims)) +
','*(len(tree.dims) == 1))
def visit_DictComp(self, tree):
return self.comprehension_code(
tree.generators,
lambda ns, g: T('{{{}: {} {}}}').format(
T('{}'), ns.visit(tree.value), g).format(ns.visit(tree.key)))
def visit_Ellipsis(self, tree):
return T('...')
def visit_Dict(self, tree):
return T('{{{}}}').format(T(', ').join(
T('{}: {}').format(k, v)
for k, v in zip(map(self.visit, tree.keys), map(self.visit, tree.values))))
def visit_Delete(self, tree):
cs = [c for target in tree.targets for c in self.delete_code(target)]
if cs:
return T('({}, {after})[-1]').format(T(', ').join(cs))
else:
return T('{after}')
def visit_Continue(self, tree):
return T('{__continue}()')
def visit_Num(self, tree):
return T('{!r}').format(tree.n)
def visit_GeneratorExp(self, tree):
return self.comprehension_code(
tree.generators,
lambda ns, g: T('({} {})').format(ns.visit(tree.elt), g))
def visit_Pass(self, tree):
return T('{after}')
def visit_Global(self, tree):
return T('{after}')
def visit_Set(self, tree):
assert tree.elts, '{} is a dict'
return T('{{{}}}').format(T(', ').join(self.visit(elt) for elt in tree.elts))
def visit_If(self, tree):
test = self.visit(tree.test)
body = self.many_to_one(tree.body, after='__after()')
orelse = self.many_to_one(tree.orelse, after='__after()')
return T('(lambda __after: {} if {} else {})(lambda: {after})').format(
body, test, orelse)
def visit_Slice(self, tree):
return T('{}:{}{}').format(
'' if tree.lower is None else self.visit(tree.lower),
'' if tree.upper is None else self.visit(tree.upper),
'' if tree.step is None else ':' + self.visit(tree.step))
def visit_IfExp(self, tree):
test = self.visit(tree.test)
body = self.visit(tree.body)
orelse = self.visit(tree.orelse)
return T('({} if {} else {})').format(body, test, orelse)
def visit_Subscript(self, tree):
return T('{}[{}]').format(self.visit(tree.value), self.visit(tree.slice))
def visit_keyword(self, tree):
return T('{}={}').format(tree.arg, self.visit(tree.value))
def visit_UnaryOp(self, tree):
return T('({}{})').format(unaryop_code[type(tree.op)], self.visit(tree.operand))
def visit_List(self, tree):
elts = [self.visit(elt) for elt in tree.elts]
return T('[{}]').format(T(', ').join(elts))
def many_to_one(self, trees, after='None'):
# trees :: [Tree]
# return :: string
return reduce(lambda ctx, tree: ctx.format(after=self.visit(tree)),
trees, T('{after}')).format(after=after)
def visit_ListComp(self, tree):
return T('[{}]').format(T(' ').join([self.visit(tree.elt)] +
map(self.visit, tree.generators)))
def visit_Attribute(self, tree):
return T('{}.{}').format(self.visit(tree.value), tree.attr)
def visit_Compare(self, tree):
assert len(tree.ops) == len(tree.comparators)
return T('({})').format(self.visit(tree.left) + T('').join(
[cmpop_code[type(tree.ops[i])] + self.visit(tree.comparators[i])
for i in range(len(tree.ops))]))
