Whitespace normalization.

git-svn-id: http://svn.python.org/projects/python/trunk@18734 6015fed2-1504-0410-9fe1-9d1591cc4771

Author: tim_one

Lib/sched.py

@@ -41,30 +41,30 @@ def __init__(self, timefunc, delayfunc):
     def enterabs(self, time, priority, action, argument):
         """Enter a new event in the queue at an absolute time.
 
-	Returns an ID for the event which can be used to remove it,
-	if necessary.
+        Returns an ID for the event which can be used to remove it,
+        if necessary.
 
-	"""
+        """
         event = time, priority, action, argument
         bisect.insort(self.queue, event)
         return event # The ID
 
     def enter(self, delay, priority, action, argument):
         """A variant that specifies the time as a relative time.
 
-	This is actually the more commonly used interface.
+        This is actually the more commonly used interface.
 
-	"""
+        """
         time = self.timefunc() + delay
         return self.enterabs(time, priority, action, argument)
 
     def cancel(self, event):
         """Remove an event from the queue.
 
-	This must be presented the ID as returned by enter().
-	If the event is not in the queue, this raises RuntimeError.
+        This must be presented the ID as returned by enter().
+        If the event is not in the queue, this raises RuntimeError.
 
-	"""
+        """
         self.queue.remove(event)
 
     def empty(self):
@@ -73,25 +73,25 @@ def empty(self):
 
     def run(self):
         """Execute events until the queue is empty.
-   
-	When there is a positive delay until the first event, the
-	delay function is called and the event is left in the queue;
-	otherwise, the event is removed from the queue and executed
-	(its action function is called, passing it the argument).  If
-	the delay function returns prematurely, it is simply
-	restarted.
-
-	It is legal for both the delay function and the action
-	function to to modify the queue or to raise an exception;
-	exceptions are not caught but the scheduler's state remains
-	well-defined so run() may be called again.
-
-	A questionably hack is added to allow other threads to run:
-	just after an event is executed, a delay of 0 is executed, to
-	avoid monopolizing the CPU when other threads are also
-	runnable.
-
-	"""
+
+        When there is a positive delay until the first event, the
+        delay function is called and the event is left in the queue;
+        otherwise, the event is removed from the queue and executed
+        (its action function is called, passing it the argument).  If
+        the delay function returns prematurely, it is simply
+        restarted.
+
+        It is legal for both the delay function and the action
+        function to to modify the queue or to raise an exception;
+        exceptions are not caught but the scheduler's state remains
+        well-defined so run() may be called again.
+
+        A questionably hack is added to allow other threads to run:
+        just after an event is executed, a delay of 0 is executed, to
+        avoid monopolizing the CPU when other threads are also
+        runnable.
+
+        """
         q = self.queue
         while q:
             time, priority, action, argument = q[0]

Lib/sgmllib.py

@@ -137,7 +137,7 @@ def goahead(self, end):
                     k = self.parse_pi(i)
                     if k < 0: break
                     i = i+k
-                    continue                    
+                    continue
                 match = special.match(rawdata, i)
                 if match:
                     if self.literal:
@@ -211,7 +211,7 @@ def parse_pi(self, i):
     __starttag_text = None
     def get_starttag_text(self):
         return self.__starttag_text
-    
+
     # Internal -- handle starttag, return length or -1 if not terminated
     def parse_starttag(self, i):
         self.__starttag_text = None

Lib/shelve.py

@@ -31,127 +31,127 @@
 # Try using cPickle and cStringIO if available.
 
 try:
-        from cPickle import Pickler, Unpickler
+    from cPickle import Pickler, Unpickler
 except ImportError:
-        from pickle import Pickler, Unpickler
+    from pickle import Pickler, Unpickler
 
 try:
-        from cStringIO import StringIO
+    from cStringIO import StringIO
 except ImportError:
-        from StringIO import StringIO
+    from StringIO import StringIO
 
 
 class Shelf:
-        """Base class for shelf implementations.
-
-        This is initialized with a dictionary-like object.
-        See the module's __doc__ string for an overview of the interface.
-        """
-
-        def __init__(self, dict):
-                self.dict = dict
-        
-        def keys(self):
-                return self.dict.keys()
-        
-        def __len__(self):
-                return len(self.dict)
-        
-        def has_key(self, key):
-                return self.dict.has_key(key)
-
-        def get(self, key, default=None):
-                if self.dict.has_key(key):
-                        return self[key]
-                return default
-        
-        def __getitem__(self, key):
-                f = StringIO(self.dict[key])
-                return Unpickler(f).load()
-        
-        def __setitem__(self, key, value):
-                f = StringIO()
-                p = Pickler(f)
-                p.dump(value)
-                self.dict[key] = f.getvalue()
-        
-        def __delitem__(self, key):
-                del self.dict[key]
-        
-        def close(self):
-                try:
-                        self.dict.close()
-                except:
-                        pass
-                self.dict = 0
-
-        def __del__(self):
-                self.close()
-
-        def sync(self):
-                if hasattr(self.dict, 'sync'):
-                        self.dict.sync()
-            
+    """Base class for shelf implementations.
+
+    This is initialized with a dictionary-like object.
+    See the module's __doc__ string for an overview of the interface.
+    """
+
+    def __init__(self, dict):
+        self.dict = dict
+
+    def keys(self):
+        return self.dict.keys()
+
+    def __len__(self):
+        return len(self.dict)
+
+    def has_key(self, key):
+        return self.dict.has_key(key)
+
+    def get(self, key, default=None):
+        if self.dict.has_key(key):
+            return self[key]
+        return default
+
+    def __getitem__(self, key):
+        f = StringIO(self.dict[key])
+        return Unpickler(f).load()
+
+    def __setitem__(self, key, value):
+        f = StringIO()
+        p = Pickler(f)
+        p.dump(value)
+        self.dict[key] = f.getvalue()
+
+    def __delitem__(self, key):
+        del self.dict[key]
+
+    def close(self):
+        try:
+            self.dict.close()
+        except:
+            pass
+        self.dict = 0
+
+    def __del__(self):
+        self.close()
+
+    def sync(self):
+        if hasattr(self.dict, 'sync'):
+            self.dict.sync()
+
 
 class BsdDbShelf(Shelf):
-        """Shelf implementation using the "BSD" db interface.
+    """Shelf implementation using the "BSD" db interface.
 
-        This adds methods first(), next(), previous(), last() and
-        set_location() that have no counterpart in [g]dbm databases.
+    This adds methods first(), next(), previous(), last() and
+    set_location() that have no counterpart in [g]dbm databases.
 
-        The actual database must be opened using one of the "bsddb"
-        modules "open" routines (i.e. bsddb.hashopen, bsddb.btopen or
-        bsddb.rnopen) and passed to the constructor.
+    The actual database must be opened using one of the "bsddb"
+    modules "open" routines (i.e. bsddb.hashopen, bsddb.btopen or
+    bsddb.rnopen) and passed to the constructor.
 
-        See the module's __doc__ string for an overview of the interface.
-        """
+    See the module's __doc__ string for an overview of the interface.
+    """
 
-        def __init__(self, dict):
-            Shelf.__init__(self, dict)
+    def __init__(self, dict):
+        Shelf.__init__(self, dict)
 
-        def set_location(self, key):
-             (key, value) = self.dict.set_location(key)
-             f = StringIO(value)
-             return (key, Unpickler(f).load())
+    def set_location(self, key):
+        (key, value) = self.dict.set_location(key)
+        f = StringIO(value)
+        return (key, Unpickler(f).load())
 
-        def next(self):
-             (key, value) = self.dict.next()
-             f = StringIO(value)
-             return (key, Unpickler(f).load())
+    def next(self):
+        (key, value) = self.dict.next()
+        f = StringIO(value)
+        return (key, Unpickler(f).load())
 
-        def previous(self):
-             (key, value) = self.dict.previous()
-             f = StringIO(value)
-             return (key, Unpickler(f).load())
+    def previous(self):
+        (key, value) = self.dict.previous()
+        f = StringIO(value)
+        return (key, Unpickler(f).load())
 
-        def first(self):
-             (key, value) = self.dict.first()
-             f = StringIO(value)
-             return (key, Unpickler(f).load())
+    def first(self):
+        (key, value) = self.dict.first()
+        f = StringIO(value)
+        return (key, Unpickler(f).load())
 
-        def last(self):
-             (key, value) = self.dict.last()
-             f = StringIO(value)
-             return (key, Unpickler(f).load())
+    def last(self):
+        (key, value) = self.dict.last()
+        f = StringIO(value)
+        return (key, Unpickler(f).load())
 
 
 class DbfilenameShelf(Shelf):
-        """Shelf implementation using the "anydbm" generic dbm interface.
+    """Shelf implementation using the "anydbm" generic dbm interface.
+
+    This is initialized with the filename for the dbm database.
+    See the module's __doc__ string for an overview of the interface.
+    """
 
-        This is initialized with the filename for the dbm database.
-        See the module's __doc__ string for an overview of the interface.
-        """
-        
-        def __init__(self, filename, flag='c'):
-                import anydbm
-                Shelf.__init__(self, anydbm.open(filename, flag))
+    def __init__(self, filename, flag='c'):
+        import anydbm
+        Shelf.__init__(self, anydbm.open(filename, flag))
 
 
 def open(filename, flag='c'):
-        """Open a persistent dictionary for reading and writing.
+    """Open a persistent dictionary for reading and writing.
+
+    Argument is the filename for the dbm database.
+    See the module's __doc__ string for an overview of the interface.
+    """
 
-        Argument is the filename for the dbm database.
-        See the module's __doc__ string for an overview of the interface.
-        """
-        
-        return DbfilenameShelf(filename, flag)
+    return DbfilenameShelf(filename, flag)

Lib/shlex.py

@@ -1,14 +1,14 @@
 """A lexical analyzer class for simple shell-like syntaxes."""
 
-# Module and documentation by Eric S. Raymond, 21 Dec 1998 
+# Module and documentation by Eric S. Raymond, 21 Dec 1998
 # Input stacking and error message cleanup added by ESR, March 2000
 
 import os.path
 import sys
 
 
 class shlex:
-    "A lexical analyzer class for simple shell-like syntaxes." 
+    "A lexical analyzer class for simple shell-like syntaxes."
     def __init__(self, instream=None, infile=None):
         if instream:
             self.instream = instream
@@ -88,7 +88,7 @@ def read_token(self):
                 self.lineno = self.lineno + 1
             if self.debug >= 3:
                 print "shlex: in state", repr(self.state), \
-                      "I see character:", repr(nextchar) 
+                      "I see character:", repr(nextchar)
             if self.state is None:
                 self.token = ''         # past end of file
                 break
@@ -181,7 +181,7 @@ def error_leader(self, infile=None, lineno=None):
         return "\"%s\", line %d: " % (infile, lineno)
 
 
-if __name__ == '__main__': 
+if __name__ == '__main__':
     if len(sys.argv) == 1:
         lexer = shlex()
     else:

Lib/shutil.py

@@ -17,7 +17,7 @@ def copyfileobj(fsrc, fdst, length=16*1024):
             break
         fdst.write(buf)
 
-	
+
 def copyfile(src, dst):
     """Copy data from src to dst"""
     fsrc = None
@@ -48,7 +48,7 @@ def copystat(src, dst):
 
 def copy(src, dst):
     """Copy data and mode bits ("cp src dst").
-    
+
     The destination may be a directory.
 
     """