diff --git a/TestON/core/ast.py b/TestON/core/ast.py
index fd5dfdb..c876b45 100644
--- a/TestON/core/ast.py
+++ b/TestON/core/ast.py
@@ -29,58 +29,58 @@
 from _ast import __version__
 
 
-def parse(source, filename='<unknown>', mode='exec'):
+def parse( source, filename='<unknown>', mode='exec' ):
     """
     Parse the source into an AST node.
     Equivalent to compile(source, filename, mode, PyCF_ONLY_AST).
     """
-    return compile(source, filename, mode, PyCF_ONLY_AST)
+    return compile( source, filename, mode, PyCF_ONLY_AST )
 
 
-def literal_eval(node_or_string):
+def literal_eval( node_or_string ):
     """
     Safely evaluate an expression node or a string containing a Python
     expression.  The string or node provided may only consist of the following
     Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
     and None.
     """
-    _safe_names = {'None': None, 'True': True, 'False': False}
-    if isinstance(node_or_string, basestring):
-        node_or_string = parse(node_or_string, mode='eval')
-    if isinstance(node_or_string, Expression):
+    _safe_names = { 'None': None, 'True': True, 'False': False }
+    if isinstance( node_or_string, basestring ):
+        node_or_string = parse( node_or_string, mode='eval' )
+    if isinstance( node_or_string, Expression ):
         node_or_string = node_or_string.body
-    def _convert(node):
-        if isinstance(node, Str):
+
+    def _convert( node ):
+        if isinstance( node, Str ):
             return node.s
-        elif isinstance(node, Num):
+        elif isinstance( node, Num ):
             return node.n
-        elif isinstance(node, Tuple):
-            return tuple(map(_convert, node.elts))
-        elif isinstance(node, List):
-            return list(map(_convert, node.elts))
-        elif isinstance(node, Dict):
-            return dict((_convert(k), _convert(v)) for k, v
-                        in zip(node.keys, node.values))
-        elif isinstance(node, Name):
+        elif isinstance( node, Tuple ):
+            return tuple( map( _convert, node.elts ) )
+        elif isinstance( node, List ):
+            return list( map( _convert, node.elts ) )
+        elif isinstance( node, Dict ):
+            return dict( ( _convert( k ), _convert( v ) ) for k, v in zip( node.keys, node.values ) )
+        elif isinstance( node, Name ):
             if node.id in _safe_names:
-                return _safe_names[node.id]
-        elif isinstance(node, BinOp) and \
-             isinstance(node.op, (Add, Sub)) and \
-             isinstance(node.right, Num) and \
-             isinstance(node.right.n, complex) and \
-             isinstance(node.left, Num) and \
-             isinstance(node.left.n, (int, long, float)):
+                return _safe_names[ node.id ]
+        elif isinstance( node, BinOp ) and \
+             isinstance( node.op, ( Add, Sub ) ) and \
+             isinstance( node.right, Num ) and \
+             isinstance( node.right.n, complex ) and \
+             isinstance( node.left, Num ) and \
+             isinstance( node.left.n, ( int, long, float ) ):
             left = node.left.n
             right = node.right.n
-            if isinstance(node.op, Add):
+            if isinstance( node.op, Add ):
                 return left + right
             else:
                 return left - right
-        raise ValueError('malformed string')
-    return _convert(node_or_string)
+        raise ValueError( 'malformed string' )
+    return _convert( node_or_string )
 
 
-def dump(node, annotate_fields=True, include_attributes=False):
+def dump( node, annotate_fields=True, include_attributes=False ):
     """
     Return a formatted dump of the tree in *node*.  This is mainly useful for
     debugging purposes.  The returned string will show the names and the values
@@ -89,40 +89,39 @@
     numbers and column offsets are not dumped by default.  If this is wanted,
     *include_attributes* can be set to True.
     """
-    def _format(node):
-        if isinstance(node, AST):
-            fields = [(a, _format(b)) for a, b in iter_fields(node)]
-            rv = '%s(%s' % (node.__class__.__name__, ', '.join(
-                ('%s=%s' % field for field in fields)
+    def _format( node ):
+        if isinstance( node, AST ):
+            fields = [ ( a, _format( b ) ) for a, b in iter_fields( node ) ]
+            rv = '%s(%s' % ( node.__class__.__name__, ', '.join(
+                ( '%s=%s' % field for field in fields )
                 if annotate_fields else
-                (b for a, b in fields)
-            ))
+                ( b for a, b in fields )
+            ) )
             if include_attributes and node._attributes:
                 rv += fields and ', ' or ' '
-                rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
-                                for a in node._attributes)
+                rv += ', '.join( '%s=%s' % ( a, _format( getattr( node, a ) ) ) for a in node._attributes )
             return rv + ')'
-        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)
+        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):
+def copy_location( new_node, old_node ):
     """
     Copy source location (`lineno` and `col_offset` attributes) from
     *old_node* to *new_node* if possible, and return *new_node*.
     """
     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))
+           and hasattr( old_node, attr ):
+            setattr( new_node, attr, getattr( old_node, attr ) )
     return new_node
 
 
-def fix_missing_locations(node):
+def fix_missing_locations( node ):
     """
     When you compile a node tree with compile(), the compiler expects lineno and
     col_offset attributes for every node that supports them.  This is rather
@@ -130,91 +129,91 @@
     recursively where not already set, by setting them to the values of the
     parent node.  It works recursively starting at *node*.
     """
-    def _fix(node, lineno, col_offset):
+    def _fix( node, lineno, col_offset ):
         if 'lineno' in node._attributes:
-            if not hasattr(node, 'lineno'):
+            if not hasattr( node, 'lineno' ):
                 node.lineno = lineno
             else:
                 lineno = node.lineno
         if 'col_offset' in node._attributes:
-            if not hasattr(node, 'col_offset'):
+            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)
+        for child in iter_child_nodes( node ):
+            _fix( child, lineno, col_offset )
+    _fix( node, 1, 0 )
     return node
 
 
-def increment_lineno(node, n=1):
+def increment_lineno( node, n=1 ):
     """
     Increment the line number of each node in the tree starting at *node* by *n*.
     This is useful to "move code" to a different location in a file.
     """
-    for child in walk(node):
+    for child in walk( node ):
         if 'lineno' in child._attributes:
-            child.lineno = getattr(child, 'lineno', 0) + n
+            child.lineno = getattr( child, 'lineno', 0 ) + n
     return node
 
 
-def iter_fields(node):
+def iter_fields( node ):
     """
     Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
     that is present on *node*.
     """
     for field in node._fields:
         try:
-            yield field, getattr(node, field)
+            yield field, getattr( node, field )
         except AttributeError:
             pass
 
 
-def iter_child_nodes(node):
+def iter_child_nodes( node ):
     """
     Yield all direct child nodes of *node*, that is, all fields that are nodes
     and all items of fields that are lists of nodes.
     """
-    for name, field in iter_fields(node):
-        if isinstance(field, AST):
+    for name, field in iter_fields( node ):
+        if isinstance( field, AST ):
             yield field
-        elif isinstance(field, list):
+        elif isinstance( field, list ):
             for item in field:
-                if isinstance(item, AST):
+                if isinstance( item, AST ):
                     yield item
 
 
-def get_docstring(node, clean=True):
+def get_docstring( node, clean=True ):
     """
     Return the docstring for the given node or None if no docstring can
     be found.  If the node provided does not have 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], Expr) and \
-       isinstance(node.body[0].value, Str):
+    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 ], Expr ) and \
+       isinstance( node.body[ 0 ].value, Str ):
         if clean:
             import inspect
-            return inspect.cleandoc(node.body[0].value.s)
-        return node.body[0].value.s
+            return inspect.cleandoc( node.body[ 0 ].value.s )
+        return node.body[ 0 ].value.s
 
 
-def walk(node):
+def walk( node ):
     """
     Recursively yield all descendant nodes in the tree starting at *node*
     (including *node* itself), in no specified order.  This is useful if you
     only want to modify nodes in place and don't care about the context.
     """
     from collections import deque
-    todo = deque([node])
+    todo = deque( [ node ] )
     while todo:
         node = todo.popleft()
-        todo.extend(iter_child_nodes(node))
+        todo.extend( iter_child_nodes( node ) )
         yield node
 
 
-class NodeVisitor(object):
+class NodeVisitor( object ):
     """
     A node visitor base class that walks the abstract syntax tree and calls a
     visitor function for every node found.  This function may return a value
@@ -234,24 +233,24 @@
     allows modifications.
     """
 
-    def visit(self, node):
+    def visit( self, node ):
         """Visit a node."""
         method = 'visit_' + node.__class__.__name__
-        visitor = getattr(self, method, self.generic_visit)
-        return visitor(node)
+        visitor = getattr( self, method, self.generic_visit )
+        return visitor( node )
 
-    def generic_visit(self, 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 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)
+                    if isinstance( item, AST ):
+                        self.visit( item )
+            elif isinstance( value, AST ):
+                self.visit( value )
 
 
-class NodeTransformer(NodeVisitor):
+class NodeTransformer( NodeVisitor ):
     """
     A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
     allows modification of nodes.
@@ -287,25 +286,25 @@
        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):
+    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 isinstance( value, AST ):
+                        value = self.visit( value )
                         if value is None:
                             continue
-                        elif not isinstance(value, AST):
-                            new_values.extend(value)
+                        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)
+                    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)
+                    delattr( node, field )
                 else:
-                    setattr(node, field, new_node)
+                    setattr( node, field, new_node )
         return node