Whitespace normalization.

Demo/parser/unparse.py

-"Usage: unparse.py <path to source file>"
-import sys
-
-class Unparser:
-    """Methods in this class recursively traverse an AST and
-    output source code for the abstract syntax; original formatting
-    is disregarged. """
-
-    def __init__(self, tree, file = sys.stdout):
-        """Unparser(tree, file=sys.stdout) -> None.
-         Print the source for tree to file."""
-        self.f = file
-        self._indent = 0
-        self.dispatch(tree)
-        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(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)
-    
-    # stmt
-    def _Expr(self, tree):
-        self.fill()
-        self.dispatch(tree.value)
-        
-    def _Import(self, t):
-        self.fill("import ")
-        first = True
-        for a in t.names:
-            if first:
-                first = False
-            else:
-                self.write(", ")
-            self.write(a.name)
-            if a.asname:
-                self.write(" as "+a.asname)
-                
-    def _Assign(self, t):
-        self.fill()
-        for target in t.targets:
-            self.dispatch(target)
-            self.write(" = ")
-        self.dispatch(t.value)
-        
-    def _ClassDef(self, t):
-        self.write("\n")
-        self.fill("class "+t.name)
-        if 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.write("\n")
-        self.fill("def "+t.name + "(")
-        self.dispatch(t.args)
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-        
-    def _If(self, t):
-        self.fill("if ")
-        self.dispatch(t.test)
-        self.enter()
-        # XXX elif?
-        self.dispatch(t.body)
-        self.leave()
-        if t.orelse:
-            self.fill("else")
-            self.enter()
-            self.dispatch(t.orelse)
-            self.leave()
-    
-    # expr 
-    def _Str(self, tree):
-        self.write(repr(tree.s))
-
-    def _Name(self, t):
-        self.write(t.id)
-        
-    def _List(self, t):
-        self.write("[")
-        for e in t.elts:
-            self.dispatch(e)
-            self.write(", ")
-        self.write("]")
-        
-    unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
-    def _UnaryOp(self, t):
-        self.write(self.unop[t.op.__class__.__name__])
-        self.write("(")
-        self.dispatch(t.operand)
-        self.write(")")
-        
-    # others
-    def _arguments(self, t):
-        first = True
-        # XXX t.defaults
-        for a in t.args:
-            if first:first = False
-            else: self.write(", ")
-            self.dispatch(a)
-        if t.vararg:
-            if first:first = False
-            else: self.write(", ")
-            self.write("*"+t.vararg)
-        if t.kwarg:
-            if first:first = False
-            else: self.write(", ")
-            self.write("**"+self.kwarg)
-        self.write(")")
-    
-def roundtrip(filename):
-    source = open(filename).read()
-    tree = compile(source, filename, "exec", 0x400)
-    Unparser(tree)
-    
-if __name__=='__main__':
-    roundtrip(sys.argv[1])
+"Usage: unparse.py <path to source file>"
+import sys
+
+class Unparser:
+    """Methods in this class recursively traverse an AST and
+    output source code for the abstract syntax; original formatting
+    is disregarged. """
+
+    def __init__(self, tree, file = sys.stdout):
+        """Unparser(tree, file=sys.stdout) -> None.
+         Print the source for tree to file."""
+        self.f = file
+        self._indent = 0
+        self.dispatch(tree)
+        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(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)
+
+    # stmt
+    def _Expr(self, tree):
+        self.fill()
+        self.dispatch(tree.value)
+
+    def _Import(self, t):
+        self.fill("import ")
+        first = True
+        for a in t.names:
+            if first:
+                first = False
+            else:
+                self.write(", ")
+            self.write(a.name)
+            if a.asname:
+                self.write(" as "+a.asname)
+
+    def _Assign(self, t):
+        self.fill()
+        for target in t.targets:
+            self.dispatch(target)
+            self.write(" = ")
+        self.dispatch(t.value)
+
+    def _ClassDef(self, t):
+        self.write("\n")
+        self.fill("class "+t.name)
+        if 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.write("\n")
+        self.fill("def "+t.name + "(")
+        self.dispatch(t.args)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _If(self, t):
+        self.fill("if ")
+        self.dispatch(t.test)
+        self.enter()
+        # XXX elif?
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave()
+
+    # expr
+    def _Str(self, tree):
+        self.write(repr(tree.s))
+
+    def _Name(self, t):
+        self.write(t.id)
+
+    def _List(self, t):
+        self.write("[")
+        for e in t.elts:
+            self.dispatch(e)
+            self.write(", ")
+        self.write("]")
+
+    unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
+    def _UnaryOp(self, t):
+        self.write(self.unop[t.op.__class__.__name__])
+        self.write("(")
+        self.dispatch(t.operand)
+        self.write(")")
+
+    # others
+    def _arguments(self, t):
+        first = True
+        # XXX t.defaults
+        for a in t.args:
+            if first:first = False
+            else: self.write(", ")
+            self.dispatch(a)
+        if t.vararg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("*"+t.vararg)
+        if t.kwarg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("**"+self.kwarg)
+        self.write(")")
+
+def roundtrip(filename):
+    source = open(filename).read()
+    tree = compile(source, filename, "exec", 0x400)
+    Unparser(tree)
+
+if __name__=='__main__':
+    roundtrip(sys.argv[1])

Lib/compiler/ast.py

@@ -553,7 +553,7 @@ class Function(Node):
             self.varargs = 1
         if flags & CO_VARKEYWORDS:
             self.kwargs = 1
-    
+
 
 
     def getChildren(self):
@@ -584,7 +584,7 @@ class GenExpr(Node):
         self.lineno = lineno
         self.argnames = ['[outmost-iterable]']
         self.varargs = self.kwargs = None
-    
+
 
 
     def getChildren(self):
@@ -763,7 +763,7 @@ class Lambda(Node):
             self.varargs = 1
         if flags & CO_VARKEYWORDS:
             self.kwargs = 1
-    
+
 
 
     def getChildren(self):

Lib/test/contextmanager.py

-class GeneratorContextManager(object):
-    def __init__(self, gen):
-        self.gen = gen
-
-    def __context__(self):
-        return self
-
-    def __enter__(self):
-        try:
-            return self.gen.next()
-        except StopIteration:
-            raise RuntimeError("generator didn't yield")
-
-    def __exit__(self, type, value, traceback):
-        if type is None:
-            try:
-                self.gen.next()
-            except StopIteration:
-                return
-            else:
-                raise RuntimeError("generator didn't stop")
-        else:
-            try:
-                self.gen.throw(type, value, traceback)
-            except (type, StopIteration):
-                return
-            else:
-                raise RuntimeError("generator caught exception")
-
-def contextmanager(func):
-    def helper(*args, **kwds):
-        return GeneratorContextManager(func(*args, **kwds))
-    return helper
-
+class GeneratorContextManager(object):
+    def __init__(self, gen):
+        self.gen = gen
+
+    def __context__(self):
+        return self
+
+    def __enter__(self):
+        try:
+            return self.gen.next()
+        except StopIteration:
+            raise RuntimeError("generator didn't yield")
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            try:
+                self.gen.next()
+            except StopIteration:
+                return
+            else:
+                raise RuntimeError("generator didn't stop")
+        else:
+            try:
+                self.gen.throw(type, value, traceback)
+            except (type, StopIteration):
+                return
+            else:
+                raise RuntimeError("generator caught exception")
+
+def contextmanager(func):
+    def helper(*args, **kwds):
+        return GeneratorContextManager(func(*args, **kwds))
+    return helper

Lib/test/nested.py

-import sys
-from collections import deque
-
-
-class nested(object):
-    def __init__(self, *contexts):
-        self.contexts = contexts
-        self.entered = None
-
-    def __context__(self):
-        return self
-
-    def __enter__(self):
-        if self.entered is not None:
-            raise RuntimeError("Context is not reentrant")
-        self.entered = deque()
-        vars = []
-        try:
-            for context in self.contexts:
-                mgr = context.__context__()
-                vars.append(mgr.__enter__())
-                self.entered.appendleft(mgr)
-        except:
-            self.__exit__(*sys.exc_info())
-            raise
-        return vars
-
-    def __exit__(self, *exc_info):
-        # Behave like nested with statements
-        # first in, last out
-        # New exceptions override old ones
-        ex = exc_info
-        for mgr in self.entered:
-            try:
-                mgr.__exit__(*ex)
-            except:
-                ex = sys.exc_info()
-        self.entered = None
-        if ex is not exc_info:
-            raise ex[0], ex[1], ex[2]
-
+import sys
+from collections import deque
+
+
+class nested(object):
+    def __init__(self, *contexts):
+        self.contexts = contexts
+        self.entered = None
+
+    def __context__(self):
+        return self
+
+    def __enter__(self):
+        if self.entered is not None:
+            raise RuntimeError("Context is not reentrant")
+        self.entered = deque()
+        vars = []
+        try:
+            for context in self.contexts:
+                mgr = context.__context__()
+                vars.append(mgr.__enter__())
+                self.entered.appendleft(mgr)
+        except:
+            self.__exit__(*sys.exc_info())
+            raise
+        return vars
+
+    def __exit__(self, *exc_info):
+        # Behave like nested with statements
+        # first in, last out
+        # New exceptions override old ones
+        ex = exc_info
+        for mgr in self.entered:
+            try:
+                mgr.__exit__(*ex)
+            except:
+                ex = sys.exc_info()
+        self.entered = None
+        if ex is not exc_info:
+            raise ex[0], ex[1], ex[2]

Lib/test/test_importhooks.py

@@ -190,7 +190,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
         TestImporter.modules['reloadmodule'] = (False, reload_co)
         reload(reloadmodule)
         self.failUnless(hasattr(reloadmodule,'reloaded'))
-        
+
         import hooktestpackage.oldabs
         self.assertEqual(hooktestpackage.oldabs.get_name(),
                          "hooktestpackage.oldabs")
@@ -208,7 +208,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
                          "hooktestpackage.futrel")
         self.assertEqual(hooktestpackage.futrel.sub,
                          hooktestpackage.sub)
-        
+
         import sub
         self.assertEqual(sub.get_name(), "sub")
 

Parser/asdl.py

@@ -38,7 +38,7 @@ class Id(Token):
 
     def __str__(self):
         return self.value
-        
+
 class String(Token):
     def __init__(self, value, lineno):
         self.type = 'String'
@@ -71,7 +71,7 @@ class ASDLScanner(spark.GenericScanner, object):
         # XXX doesn't distinguish upper vs. lower, which is
         # significant for ASDL.
         self.rv.append(Id(s, self.lineno))
-        
+
     def t_string(self, s):
         r'"[^"]*"'
         self.rv.append(String(s, self.lineno))
@@ -123,7 +123,7 @@ class ASDLParser(spark.GenericParser, object):
             raise ASDLSyntaxError(module.lineno,
                                   msg="expected 'module', found %s" % module)
         return Module(name, definitions, version)
-        
+
     def p_version(self, (version, V)):
         "version ::= Id String"
         if version.value != "version":

Parser/asdl_c.py

@@ -354,7 +354,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
             for f in prod.fields:
                 self.emit('"%s",' % f.name, 1)
             self.emit("};", 0)
-        
+
     def visitSum(self, sum, name):
         self.emit("PyTypeObject *%s_type;" % name, 0)
         if sum.attributes:
@@ -373,7 +373,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
         self.emit("static PyObject* ast2obj_%s(%s);" % (name, ptype), 0)
         for t in sum.types:
             self.visitConstructor(t, name)
-            
+
     def visitConstructor(self, cons, name):
         self.emit("PyTypeObject *%s_type;" % cons.name, 0)
         if cons.fields:
@@ -405,7 +405,7 @@ static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int
         }
         PyTuple_SET_ITEM(fnames, i, field);
     }
-    result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}", 
+    result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
                     type, base, "_fields", fnames, "__module__", "_ast");
     Py_DECREF(fnames);
     return (PyTypeObject*)result;
@@ -481,35 +481,35 @@ static PyObject* ast2obj_int(bool b)
             fields = name.value+"_fields"
         else:
             fields = "NULL"
-        self.emit('%s_type = make_type("%s", AST_type, %s, %d);' % 
+        self.emit('%s_type = make_type("%s", AST_type, %s, %d);' %
                         (name, name, fields, len(prod.fields)), 1)
         self.emit("if (!%s_type) return 0;" % name, 1)
-        
+
     def visitSum(self, sum, name):
         self.emit('%s_type = make_type("%s", AST_type, NULL, 0);' % (name, name), 1)
         self.emit("if (!%s_type) return 0;" % name, 1)
         if sum.attributes:
-            self.emit("if (!add_attributes(%s_type, %s_attributes, %d)) return 0;" % 
+            self.emit("if (!add_attributes(%s_type, %s_attributes, %d)) return 0;" %
                             (name, name, len(sum.attributes)), 1)
         else:
             self.emit("if (!add_attributes(%s_type, NULL, 0)) return 0;" % name, 1)
         simple = is_simple(sum)
         for t in sum.types:
             self.visitConstructor(t, name, simple)
-            
+
     def visitConstructor(self, cons, name, simple):
         if cons.fields:
             fields = cons.name.value+"_fields"
         else:
             fields = "NULL"
-        self.emit('%s_type = make_type("%s", %s_type, %s, %d);' % 
+        self.emit('%s_type = make_type("%s", %s_type, %s, %d);' %
                             (cons.name, cons.name, name, fields, len(cons.fields)), 1)
         self.emit("if (!%s_type) return 0;" % cons.name, 1)
         if simple:
             self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" %
                              (cons.name, cons.name), 1)
             self.emit("if (!%s_singleton) return 0;" % cons.name, 1)
-                             
+
 class ASTModuleVisitor(PickleVisitor):
 
     def visitModule(self, mod):
@@ -533,15 +533,15 @@ class ASTModuleVisitor(PickleVisitor):
 
     def visitProduct(self, prod, name):
         self.addObj(name)
-        
+
     def visitSum(self, sum, name):
         self.addObj(name)
         for t in sum.types:
             self.visitConstructor(t, name)
-            
+
     def visitConstructor(self, cons, name):
         self.addObj(cons.name)
-        
+
     def addObj(self, name):
         self.emit('if(PyDict_SetItemString(d, "%s", (PyObject*)%s_type) < 0) return;' % (name, name), 1)
 
@@ -609,7 +609,7 @@ class ObjVisitor(PickleVisitor):
             self.emit("if (!value) goto failed;", 1)
             self.emit('PyObject_SetAttrString(result, "%s", value);' % a.name, 1)
         self.func_end()
-        
+
     def simpleSum(self, sum, name):
         self.emit("PyObject* ast2obj_%s(%s_ty o)" % (name, name), 0)
         self.emit("{", 0)