mako/_ast_util.py - third_party/mako - Git at Google

 # mako/_ast_util.py
 # Copyright (C) 2006-2014 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 *
 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 node.starargs is not None:
                 paren_or_comma()
                 self.write('*')
                 self.visit(node.starargs)
             if node.kwargs is not 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 node.starargs is not None:
             write_comma()
             self.write('*')
             self.visit(node.starargs)
         if node.kwargs is not 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)
	# mako/_ast_util.py
	# Copyright (C) 2006-2014 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 *
	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 node.starargs is not None:
	paren_or_comma()
	self.write('*')
	self.visit(node.starargs)
	if node.kwargs is not 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 node.starargs is not None:
	write_comma()
	self.write('*')
	self.visit(node.starargs)
	if node.kwargs is not 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)