| # mako/_ast_util.py | |
| # Copyright (C) 2006-2015 the Mako authors and contributors <see AUTHORS file> | |
| # | |
| # This module is part of Mako and is released under | |
| # the MIT License: http://www.opensource.org/licenses/mit-license.php | |
| """ | |
| ast | |
| ~~~ | |
| The `ast` module helps Python applications to process trees of the Python | |
| abstract syntax grammar. The abstract syntax itself might change with | |
| each Python release; this module helps to find out programmatically what | |
| the current grammar looks like and allows modifications of it. | |
| An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as | |
| a flag to the `compile()` builtin function or by using the `parse()` | |
| function from this module. The result will be a tree of objects whose | |
| classes all inherit from `ast.AST`. | |
| A modified abstract syntax tree can be compiled into a Python code object | |
| using the built-in `compile()` function. | |
| Additionally various helper functions are provided that make working with | |
| the trees simpler. The main intention of the helper functions and this | |
| module in general is to provide an easy to use interface for libraries | |
| that work tightly with the python syntax (template engines for example). | |
| :copyright: Copyright 2008 by Armin Ronacher. | |
| :license: Python License. | |
| """ | |
| from _ast import * # noqa | |
| from mako.compat import arg_stringname | |
| BOOLOP_SYMBOLS = { | |
| And: 'and', | |
| Or: 'or' | |
| } | |
| BINOP_SYMBOLS = { | |
| Add: '+', | |
| Sub: '-', | |
| Mult: '*', | |
| Div: '/', | |
| FloorDiv: '//', | |
| Mod: '%', | |
| LShift: '<<', | |
| RShift: '>>', | |
| BitOr: '|', | |
| BitAnd: '&', | |
| BitXor: '^' | |
| } | |
| CMPOP_SYMBOLS = { | |
| Eq: '==', | |
| Gt: '>', | |
| GtE: '>=', | |
| In: 'in', | |
| Is: 'is', | |
| IsNot: 'is not', | |
| Lt: '<', | |
| LtE: '<=', | |
| NotEq: '!=', | |
| NotIn: 'not in' | |
| } | |
| UNARYOP_SYMBOLS = { | |
| Invert: '~', | |
| Not: 'not', | |
| UAdd: '+', | |
| USub: '-' | |
| } | |
| ALL_SYMBOLS = {} | |
| ALL_SYMBOLS.update(BOOLOP_SYMBOLS) | |
| ALL_SYMBOLS.update(BINOP_SYMBOLS) | |
| ALL_SYMBOLS.update(CMPOP_SYMBOLS) | |
| ALL_SYMBOLS.update(UNARYOP_SYMBOLS) | |
| def parse(expr, filename='<unknown>', mode='exec'): | |
| """Parse an expression into an AST node.""" | |
| return compile(expr, filename, mode, PyCF_ONLY_AST) | |
| def to_source(node, indent_with=' ' * 4): | |
| """ | |
| This function can convert a node tree back into python sourcecode. This | |
| is useful for debugging purposes, especially if you're dealing with custom | |
| asts not generated by python itself. | |
| It could be that the sourcecode is evaluable when the AST itself is not | |
| compilable / evaluable. The reason for this is that the AST contains some | |
| more data than regular sourcecode does, which is dropped during | |
| conversion. | |
| Each level of indentation is replaced with `indent_with`. Per default this | |
| parameter is equal to four spaces as suggested by PEP 8, but it might be | |
| adjusted to match the application's styleguide. | |
| """ | |
| generator = SourceGenerator(indent_with) | |
| generator.visit(node) | |
| return ''.join(generator.result) | |
| def dump(node): | |
| """ | |
| A very verbose representation of the node passed. This is useful for | |
| debugging purposes. | |
| """ | |
| def _format(node): | |
| if isinstance(node, AST): | |
| return '%s(%s)' % (node.__class__.__name__, | |
| ', '.join('%s=%s' % (a, _format(b)) | |
| for a, b in iter_fields(node))) | |
| elif isinstance(node, list): | |
| return '[%s]' % ', '.join(_format(x) for x in node) | |
| return repr(node) | |
| if not isinstance(node, AST): | |
| raise TypeError('expected AST, got %r' % node.__class__.__name__) | |
| return _format(node) | |
| def copy_location(new_node, old_node): | |
| """ | |
| Copy the source location hint (`lineno` and `col_offset`) from the | |
| old to the new node if possible and return the new one. | |
| """ | |
| for attr in 'lineno', 'col_offset': | |
| if attr in old_node._attributes and attr in new_node._attributes \ | |
| and hasattr(old_node, attr): | |
| setattr(new_node, attr, getattr(old_node, attr)) | |
| return new_node | |
| def fix_missing_locations(node): | |
| """ | |
| Some nodes require a line number and the column offset. Without that | |
| information the compiler will abort the compilation. Because it can be | |
| a dull task to add appropriate line numbers and column offsets when | |
| adding new nodes this function can help. It copies the line number and | |
| column offset of the parent node to the child nodes without this | |
| information. | |
| Unlike `copy_location` this works recursive and won't touch nodes that | |
| already have a location information. | |
| """ | |
| def _fix(node, lineno, col_offset): | |
| if 'lineno' in node._attributes: | |
| if not hasattr(node, 'lineno'): | |
| node.lineno = lineno | |
| else: | |
| lineno = node.lineno | |
| if 'col_offset' in node._attributes: | |
| if not hasattr(node, 'col_offset'): | |
| node.col_offset = col_offset | |
| else: | |
| col_offset = node.col_offset | |
| for child in iter_child_nodes(node): | |
| _fix(child, lineno, col_offset) | |
| _fix(node, 1, 0) | |
| return node | |
| def increment_lineno(node, n=1): | |
| """ | |
| Increment the line numbers of all nodes by `n` if they have line number | |
| attributes. This is useful to "move code" to a different location in a | |
| file. | |
| """ | |
| for node in zip((node,), walk(node)): | |
| if 'lineno' in node._attributes: | |
| node.lineno = getattr(node, 'lineno', 0) + n | |
| def iter_fields(node): | |
| """Iterate over all fields of a node, only yielding existing fields.""" | |
| # CPython 2.5 compat | |
| if not hasattr(node, '_fields') or not node._fields: | |
| return | |
| for field in node._fields: | |
| try: | |
| yield field, getattr(node, field) | |
| except AttributeError: | |
| pass | |
| def get_fields(node): | |
| """Like `iter_fiels` but returns a dict.""" | |
| return dict(iter_fields(node)) | |
| def iter_child_nodes(node): | |
| """Iterate over all child nodes or a node.""" | |
| for name, field in iter_fields(node): | |
| if isinstance(field, AST): | |
| yield field | |
| elif isinstance(field, list): | |
| for item in field: | |
| if isinstance(item, AST): | |
| yield item | |
| def get_child_nodes(node): | |
| """Like `iter_child_nodes` but returns a list.""" | |
| return list(iter_child_nodes(node)) | |
| def get_compile_mode(node): | |
| """ | |
| Get the mode for `compile` of a given node. If the node is not a `mod` | |
| node (`Expression`, `Module` etc.) a `TypeError` is thrown. | |
| """ | |
| if not isinstance(node, mod): | |
| raise TypeError('expected mod node, got %r' % node.__class__.__name__) | |
| return { | |
| Expression: 'eval', | |
| Interactive: 'single' | |
| }.get(node.__class__, 'expr') | |
| def get_docstring(node): | |
| """ | |
| Return the docstring for the given node or `None` if no docstring can be | |
| found. If the node provided does not accept docstrings a `TypeError` | |
| will be raised. | |
| """ | |
| if not isinstance(node, (FunctionDef, ClassDef, Module)): | |
| raise TypeError("%r can't have docstrings" % node.__class__.__name__) | |
| if node.body and isinstance(node.body[0], Str): | |
| return node.body[0].s | |
| def walk(node): | |
| """ | |
| Iterate over all nodes. This is useful if you only want to modify nodes in | |
| place and don't care about the context or the order the nodes are returned. | |
| """ | |
| from collections import deque | |
| todo = deque([node]) | |
| while todo: | |
| node = todo.popleft() | |
| todo.extend(iter_child_nodes(node)) | |
| yield node | |
| class NodeVisitor(object): | |
| """ | |
| Walks the abstract syntax tree and call visitor functions for every node | |
| found. The visitor functions may return values which will be forwarded | |
| by the `visit` method. | |
| 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 `get_visitor` function. 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. | |
| """ | |
| def get_visitor(self, node): | |
| """ | |
| Return the visitor function for this node or `None` if no visitor | |
| exists for this node. In that case the generic visit function is | |
| used instead. | |
| """ | |
| method = 'visit_' + node.__class__.__name__ | |
| return getattr(self, method, None) | |
| def visit(self, node): | |
| """Visit a node.""" | |
| f = self.get_visitor(node) | |
| if f is not None: | |
| return f(node) | |
| return self.generic_visit(node) | |
| 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) | |
| class NodeTransformer(NodeVisitor): | |
| """ | |
| Walks the abstract syntax tree and allows modifications of nodes. | |
| The `NodeTransformer` will walk the AST and use the return value of the | |
| visitor functions to replace or remove the old node. If the return | |
| value of the visitor function is `None` the node will be removed | |
| from the previous location otherwise it's replaced with the return | |
| value. The return value may be the original node in which case no | |
| replacement takes place. | |
| Here an example transformer that rewrites all `foo` to `data['foo']`:: | |
| class RewriteName(NodeTransformer): | |
| def visit_Name(self, node): | |
| return copy_location(Subscript( | |
| value=Name(id='data', ctx=Load()), | |
| slice=Index(value=Str(s=node.id)), | |
| ctx=node.ctx | |
| ), node) | |
| Keep in mind that if the node you're operating on has child nodes | |
| you must either transform the child nodes yourself or call the generic | |
| visit function for the node first. | |
| Nodes that were part of a collection of statements (that applies to | |
| all statement nodes) may also return a list of nodes rather than just | |
| a single node. | |
| Usually you use the transformer like this:: | |
| node = YourTransformer().visit(node) | |
| """ | |
| def generic_visit(self, node): | |
| for field, old_value in iter_fields(node): | |
| old_value = getattr(node, field, None) | |
| if isinstance(old_value, list): | |
| new_values = [] | |
| for value in old_value: | |
| if isinstance(value, AST): | |
| value = self.visit(value) | |
| if value is None: | |
| continue | |
| elif not isinstance(value, AST): | |
| new_values.extend(value) | |
| continue | |
| new_values.append(value) | |
| old_value[:] = new_values | |
| elif isinstance(old_value, AST): | |
| new_node = self.visit(old_value) | |
| if new_node is None: | |
| delattr(node, field) | |
| else: | |
| setattr(node, field, new_node) | |
| return node | |
| class SourceGenerator(NodeVisitor): | |
| """ | |
| This visitor is able to transform a well formed syntax tree into python | |
| sourcecode. For more details have a look at the docstring of the | |
| `node_to_source` function. | |
| """ | |
| def __init__(self, indent_with): | |
| self.result = [] | |
| self.indent_with = indent_with | |
| self.indentation = 0 | |
| self.new_lines = 0 | |
| def write(self, x): | |
| if self.new_lines: | |
| if self.result: | |
| self.result.append('\n' * self.new_lines) | |
| self.result.append(self.indent_with * self.indentation) | |
| self.new_lines = 0 | |
| self.result.append(x) | |
| def newline(self, n=1): | |
| self.new_lines = max(self.new_lines, n) | |
| def body(self, statements): | |
| self.new_line = True | |
| self.indentation += 1 | |
| for stmt in statements: | |
| self.visit(stmt) | |
| self.indentation -= 1 | |
| def body_or_else(self, node): | |
| self.body(node.body) | |
| if node.orelse: | |
| self.newline() | |
| self.write('else:') | |
| self.body(node.orelse) | |
| def signature(self, node): | |
| want_comma = [] | |
| def write_comma(): | |
| if want_comma: | |
| self.write(', ') | |
| else: | |
| want_comma.append(True) | |
| padding = [None] * (len(node.args) - len(node.defaults)) | |
| for arg, default in zip(node.args, padding + node.defaults): | |
| write_comma() | |
| self.visit(arg) | |
| if default is not None: | |
| self.write('=') | |
| self.visit(default) | |
| if node.vararg is not None: | |
| write_comma() | |
| self.write('*' + arg_stringname(node.vararg)) | |
| if node.kwarg is not None: | |
| write_comma() | |
| self.write('**' + arg_stringname(node.kwarg)) | |
| def decorators(self, node): | |
| for decorator in node.decorator_list: | |
| self.newline() | |
| self.write('@') | |
| self.visit(decorator) | |
| # Statements | |
| def visit_Assign(self, node): | |
| self.newline() | |
| for idx, target in enumerate(node.targets): | |
| if idx: | |
| self.write(', ') | |
| self.visit(target) | |
| self.write(' = ') | |
| self.visit(node.value) | |
| def visit_AugAssign(self, node): | |
| self.newline() | |
| self.visit(node.target) | |
| self.write(BINOP_SYMBOLS[type(node.op)] + '=') | |
| self.visit(node.value) | |
| def visit_ImportFrom(self, node): | |
| self.newline() | |
| self.write('from %s%s import ' % ('.' * node.level, node.module)) | |
| for idx, item in enumerate(node.names): | |
| if idx: | |
| self.write(', ') | |
| self.write(item) | |
| def visit_Import(self, node): | |
| self.newline() | |
| for item in node.names: | |
| self.write('import ') | |
| self.visit(item) | |
| def visit_Expr(self, node): | |
| self.newline() | |
| self.generic_visit(node) | |
| def visit_FunctionDef(self, node): | |
| self.newline(n=2) | |
| self.decorators(node) | |
| self.newline() | |
| self.write('def %s(' % node.name) | |
| self.signature(node.args) | |
| self.write('):') | |
| self.body(node.body) | |
| def visit_ClassDef(self, node): | |
| have_args = [] | |
| def paren_or_comma(): | |
| if have_args: | |
| self.write(', ') | |
| else: | |
| have_args.append(True) | |
| self.write('(') | |
| self.newline(n=3) | |
| self.decorators(node) | |
| self.newline() | |
| self.write('class %s' % node.name) | |
| for base in node.bases: | |
| paren_or_comma() | |
| self.visit(base) | |
| # XXX: the if here is used to keep this module compatible | |
| # with python 2.6. | |
| if hasattr(node, 'keywords'): | |
| for keyword in node.keywords: | |
| paren_or_comma() | |
| self.write(keyword.arg + '=') | |
| self.visit(keyword.value) | |
| if getattr(node, "starargs", None): | |
| paren_or_comma() | |
| self.write('*') | |
| self.visit(node.starargs) | |
| if getattr(node, "kwargs", None): | |
| paren_or_comma() | |
| self.write('**') | |
| self.visit(node.kwargs) | |
| self.write(have_args and '):' or ':') | |
| self.body(node.body) | |
| def visit_If(self, node): | |
| self.newline() | |
| self.write('if ') | |
| self.visit(node.test) | |
| self.write(':') | |
| self.body(node.body) | |
| while True: | |
| else_ = node.orelse | |
| if len(else_) == 1 and isinstance(else_[0], If): | |
| node = else_[0] | |
| self.newline() | |
| self.write('elif ') | |
| self.visit(node.test) | |
| self.write(':') | |
| self.body(node.body) | |
| else: | |
| self.newline() | |
| self.write('else:') | |
| self.body(else_) | |
| break | |
| def visit_For(self, node): | |
| self.newline() | |
| self.write('for ') | |
| self.visit(node.target) | |
| self.write(' in ') | |
| self.visit(node.iter) | |
| self.write(':') | |
| self.body_or_else(node) | |
| def visit_While(self, node): | |
| self.newline() | |
| self.write('while ') | |
| self.visit(node.test) | |
| self.write(':') | |
| self.body_or_else(node) | |
| def visit_With(self, node): | |
| self.newline() | |
| self.write('with ') | |
| self.visit(node.context_expr) | |
| if node.optional_vars is not None: | |
| self.write(' as ') | |
| self.visit(node.optional_vars) | |
| self.write(':') | |
| self.body(node.body) | |
| def visit_Pass(self, node): | |
| self.newline() | |
| self.write('pass') | |
| def visit_Print(self, node): | |
| # XXX: python 2.6 only | |
| self.newline() | |
| self.write('print ') | |
| want_comma = False | |
| if node.dest is not None: | |
| self.write(' >> ') | |
| self.visit(node.dest) | |
| want_comma = True | |
| for value in node.values: | |
| if want_comma: | |
| self.write(', ') | |
| self.visit(value) | |
| want_comma = True | |
| if not node.nl: | |
| self.write(',') | |
| def visit_Delete(self, node): | |
| self.newline() | |
| self.write('del ') | |
| for idx, target in enumerate(node): | |
| if idx: | |
| self.write(', ') | |
| self.visit(target) | |
| def visit_TryExcept(self, node): | |
| self.newline() | |
| self.write('try:') | |
| self.body(node.body) | |
| for handler in node.handlers: | |
| self.visit(handler) | |
| def visit_TryFinally(self, node): | |
| self.newline() | |
| self.write('try:') | |
| self.body(node.body) | |
| self.newline() | |
| self.write('finally:') | |
| self.body(node.finalbody) | |
| def visit_Global(self, node): | |
| self.newline() | |
| self.write('global ' + ', '.join(node.names)) | |
| def visit_Nonlocal(self, node): | |
| self.newline() | |
| self.write('nonlocal ' + ', '.join(node.names)) | |
| def visit_Return(self, node): | |
| self.newline() | |
| self.write('return ') | |
| self.visit(node.value) | |
| def visit_Break(self, node): | |
| self.newline() | |
| self.write('break') | |
| def visit_Continue(self, node): | |
| self.newline() | |
| self.write('continue') | |
| def visit_Raise(self, node): | |
| # XXX: Python 2.6 / 3.0 compatibility | |
| self.newline() | |
| self.write('raise') | |
| if hasattr(node, 'exc') and node.exc is not None: | |
| self.write(' ') | |
| self.visit(node.exc) | |
| if node.cause is not None: | |
| self.write(' from ') | |
| self.visit(node.cause) | |
| elif hasattr(node, 'type') and node.type is not None: | |
| self.visit(node.type) | |
| if node.inst is not None: | |
| self.write(', ') | |
| self.visit(node.inst) | |
| if node.tback is not None: | |
| self.write(', ') | |
| self.visit(node.tback) | |
| # Expressions | |
| def visit_Attribute(self, node): | |
| self.visit(node.value) | |
| self.write('.' + node.attr) | |
| def visit_Call(self, node): | |
| want_comma = [] | |
| def write_comma(): | |
| if want_comma: | |
| self.write(', ') | |
| else: | |
| want_comma.append(True) | |
| self.visit(node.func) | |
| self.write('(') | |
| for arg in node.args: | |
| write_comma() | |
| self.visit(arg) | |
| for keyword in node.keywords: | |
| write_comma() | |
| self.write(keyword.arg + '=') | |
| self.visit(keyword.value) | |
| if getattr(node, "starargs", None): | |
| write_comma() | |
| self.write('*') | |
| self.visit(node.starargs) | |
| if getattr(node, "kwargs", None): | |
| write_comma() | |
| self.write('**') | |
| self.visit(node.kwargs) | |
| self.write(')') | |
| def visit_Name(self, node): | |
| self.write(node.id) | |
| def visit_NameConstant(self, node): | |
| self.write(str(node.value)) | |
| def visit_arg(self, node): | |
| self.write(node.arg) | |
| def visit_Str(self, node): | |
| self.write(repr(node.s)) | |
| def visit_Bytes(self, node): | |
| self.write(repr(node.s)) | |
| def visit_Num(self, node): | |
| self.write(repr(node.n)) | |
| def visit_Tuple(self, node): | |
| self.write('(') | |
| idx = -1 | |
| for idx, item in enumerate(node.elts): | |
| if idx: | |
| self.write(', ') | |
| self.visit(item) | |
| self.write(idx and ')' or ',)') | |
| def sequence_visit(left, right): | |
| def visit(self, node): | |
| self.write(left) | |
| for idx, item in enumerate(node.elts): | |
| if idx: | |
| self.write(', ') | |
| self.visit(item) | |
| self.write(right) | |
| return visit | |
| visit_List = sequence_visit('[', ']') | |
| visit_Set = sequence_visit('{', '}') | |
| del sequence_visit | |
| def visit_Dict(self, node): | |
| self.write('{') | |
| for idx, (key, value) in enumerate(zip(node.keys, node.values)): | |
| if idx: | |
| self.write(', ') | |
| self.visit(key) | |
| self.write(': ') | |
| self.visit(value) | |
| self.write('}') | |
| def visit_BinOp(self, node): | |
| self.write('(') | |
| self.visit(node.left) | |
| self.write(' %s ' % BINOP_SYMBOLS[type(node.op)]) | |
| self.visit(node.right) | |
| self.write(')') | |
| def visit_BoolOp(self, node): | |
| self.write('(') | |
| for idx, value in enumerate(node.values): | |
| if idx: | |
| self.write(' %s ' % BOOLOP_SYMBOLS[type(node.op)]) | |
| self.visit(value) | |
| self.write(')') | |
| def visit_Compare(self, node): | |
| self.write('(') | |
| self.visit(node.left) | |
| for op, right in zip(node.ops, node.comparators): | |
| self.write(' %s ' % CMPOP_SYMBOLS[type(op)]) | |
| self.visit(right) | |
| self.write(')') | |
| def visit_UnaryOp(self, node): | |
| self.write('(') | |
| op = UNARYOP_SYMBOLS[type(node.op)] | |
| self.write(op) | |
| if op == 'not': | |
| self.write(' ') | |
| self.visit(node.operand) | |
| self.write(')') | |
| def visit_Subscript(self, node): | |
| self.visit(node.value) | |
| self.write('[') | |
| self.visit(node.slice) | |
| self.write(']') | |
| def visit_Slice(self, node): | |
| if node.lower is not None: | |
| self.visit(node.lower) | |
| self.write(':') | |
| if node.upper is not None: | |
| self.visit(node.upper) | |
| if node.step is not None: | |
| self.write(':') | |
| if not (isinstance(node.step, Name) and node.step.id == 'None'): | |
| self.visit(node.step) | |
| def visit_ExtSlice(self, node): | |
| for idx, item in node.dims: | |
| if idx: | |
| self.write(', ') | |
| self.visit(item) | |
| def visit_Yield(self, node): | |
| self.write('yield ') | |
| self.visit(node.value) | |
| def visit_Lambda(self, node): | |
| self.write('lambda ') | |
| self.signature(node.args) | |
| self.write(': ') | |
| self.visit(node.body) | |
| def visit_Ellipsis(self, node): | |
| self.write('Ellipsis') | |
| def generator_visit(left, right): | |
| def visit(self, node): | |
| self.write(left) | |
| self.visit(node.elt) | |
| for comprehension in node.generators: | |
| self.visit(comprehension) | |
| self.write(right) | |
| return visit | |
| visit_ListComp = generator_visit('[', ']') | |
| visit_GeneratorExp = generator_visit('(', ')') | |
| visit_SetComp = generator_visit('{', '}') | |
| del generator_visit | |
| def visit_DictComp(self, node): | |
| self.write('{') | |
| self.visit(node.key) | |
| self.write(': ') | |
| self.visit(node.value) | |
| for comprehension in node.generators: | |
| self.visit(comprehension) | |
| self.write('}') | |
| def visit_IfExp(self, node): | |
| self.visit(node.body) | |
| self.write(' if ') | |
| self.visit(node.test) | |
| self.write(' else ') | |
| self.visit(node.orelse) | |
| def visit_Starred(self, node): | |
| self.write('*') | |
| self.visit(node.value) | |
| def visit_Repr(self, node): | |
| # XXX: python 2.6 only | |
| self.write('`') | |
| self.visit(node.value) | |
| self.write('`') | |
| # Helper Nodes | |
| def visit_alias(self, node): | |
| self.write(node.name) | |
| if node.asname is not None: | |
| self.write(' as ' + node.asname) | |
| def visit_comprehension(self, node): | |
| self.write(' for ') | |
| self.visit(node.target) | |
| self.write(' in ') | |
| self.visit(node.iter) | |
| if node.ifs: | |
| for if_ in node.ifs: | |
| self.write(' if ') | |
| self.visit(if_) | |
| def visit_excepthandler(self, node): | |
| self.newline() | |
| self.write('except') | |
| if node.type is not None: | |
| self.write(' ') | |
| self.visit(node.type) | |
| if node.name is not None: | |
| self.write(' as ') | |
| self.visit(node.name) | |
| self.write(':') | |
| self.body(node.body) |