diff --git a/Lib/sched.py b/Lib/sched.py
index f51d835..fc5bd56 100644
--- a/Lib/sched.py
+++ b/Lib/sched.py
@@ -41,10 +41,10 @@
     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
@@ -52,19 +52,19 @@
     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 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.
+        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.
 
-	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.
+        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]
diff --git a/Lib/sgmllib.py b/Lib/sgmllib.py
index c1467b0..dfbfe5c 100644
--- a/Lib/sgmllib.py
+++ b/Lib/sgmllib.py
@@ -137,7 +137,7 @@
                     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 @@
     __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
diff --git a/Lib/shelve.py b/Lib/shelve.py
index a068536..952df16 100644
--- a/Lib/shelve.py
+++ b/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.
+    """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.
-        """
+    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 __init__(self, dict):
+        self.dict = dict
 
-        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 keys(self):
+        return self.dict.keys()
 
-        def __del__(self):
-                self.close()
+    def __len__(self):
+        return len(self.dict)
 
-        def sync(self):
-                if hasattr(self.dict, 'sync'):
-                        self.dict.sync()
-            
+    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.
-        """
-        
-        def __init__(self, filename, flag='c'):
-                import anydbm
-                Shelf.__init__(self, anydbm.open(filename, flag))
+    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 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.
-        """
-        
-        return DbfilenameShelf(filename, flag)
+    Argument is the filename for the dbm database.
+    See the module's __doc__ string for an overview of the interface.
+    """
+
+    return DbfilenameShelf(filename, flag)
diff --git a/Lib/shlex.py b/Lib/shlex.py
index 7bf81e2..de9b974 100644
--- a/Lib/shlex.py
+++ b/Lib/shlex.py
@@ -1,6 +1,6 @@
 """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
@@ -8,7 +8,7 @@
 
 
 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 @@
                 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 @@
         return "\"%s\", line %d: " % (infile, lineno)
 
 
-if __name__ == '__main__': 
+if __name__ == '__main__':
     if len(sys.argv) == 1:
         lexer = shlex()
     else:
diff --git a/Lib/shutil.py b/Lib/shutil.py
index dfde236..1ba58da 100644
--- a/Lib/shutil.py
+++ b/Lib/shutil.py
@@ -17,7 +17,7 @@
             break
         fdst.write(buf)
 
-	
+
 def copyfile(src, dst):
     """Copy data from src to dst"""
     fsrc = None
@@ -48,7 +48,7 @@
 
 def copy(src, dst):
     """Copy data and mode bits ("cp src dst").
-    
+
     The destination may be a directory.
 
     """
diff --git a/Lib/smtplib.py b/Lib/smtplib.py
index 064a9f8..b608840 100755
--- a/Lib/smtplib.py
+++ b/Lib/smtplib.py
@@ -36,7 +36,7 @@
 #     Eric S. Raymond <esr@thyrsus.com>
 # Better RFC 821 compliance (MAIL and RCPT, and CRLF in data)
 #     by Carey Evans <c.evans@clear.net.nz>, for picky mail servers.
-#    
+#
 # This was modified from the Python 1.5 library HTTP lib.
 
 import socket
@@ -48,7 +48,7 @@
 SMTP_PORT = 25
 CRLF="\r\n"
 
-# Exception classes used by this module. 
+# Exception classes used by this module.
 class SMTPException(Exception):
     """Base class for all exceptions raised by this module."""
 
@@ -89,8 +89,8 @@
 class SMTPRecipientsRefused(SMTPException):
     """All recipient addresses refused.
     The errors for each recipient are accessible through the attribute
-    'recipients', which is a dictionary of exactly the same sort as 
-    SMTP.sendmail() returns.  
+    'recipients', which is a dictionary of exactly the same sort as
+    SMTP.sendmail() returns.
     """
 
     def __init__(self, recipients):
@@ -137,27 +137,27 @@
 class SMTP:
     """This class manages a connection to an SMTP or ESMTP server.
     SMTP Objects:
-        SMTP objects have the following attributes:    
-            helo_resp 
-                This is the message given by the server in response to the 
+        SMTP objects have the following attributes:
+            helo_resp
+                This is the message given by the server in response to the
                 most recent HELO command.
-                
+
             ehlo_resp
-                This is the message given by the server in response to the 
+                This is the message given by the server in response to the
                 most recent EHLO command. This is usually multiline.
 
-            does_esmtp 
+            does_esmtp
                 This is a True value _after you do an EHLO command_, if the
                 server supports ESMTP.
 
-            esmtp_features 
+            esmtp_features
                 This is a dictionary, which, if the server supports ESMTP,
                 will _after you do an EHLO command_, contain the names of the
                 SMTP service extensions this server supports, and their
                 parameters (if any).
 
-                Note, all extension names are mapped to lower case in the 
-                dictionary. 
+                Note, all extension names are mapped to lower case in the
+                dictionary.
 
         See each method's docstrings for details.  In general, there is a
         method of the same name to perform each SMTP command.  There is also a
@@ -183,7 +183,7 @@
             (code, msg) = self.connect(host, port)
             if code != 220:
                 raise SMTPConnectError(code, msg)
-    
+
     def set_debuglevel(self, debuglevel):
         """Set the debug output level.
 
@@ -222,7 +222,7 @@
         (code,msg)=self.getreply()
         if self.debuglevel >0 : print "connect:", msg
         return (code,msg)
-    
+
     def send(self, str):
         """Send `str' to the server."""
         if self.debuglevel > 0: print 'send:', `str`
@@ -235,7 +235,7 @@
                 raise SMTPServerDisconnected('Server not connected')
         else:
             raise SMTPServerDisconnected('please run connect() first')
- 
+
     def putcmd(self, cmd, args=""):
         """Send a command to the server."""
         if args == "":
@@ -243,10 +243,10 @@
         else:
             str = '%s %s%s' % (cmd, args, CRLF)
         self.send(str)
-    
+
     def getreply(self):
         """Get a reply from the server.
-        
+
         Returns a tuple consisting of:
 
           - server response code (e.g. '250', or such, if all goes well)
@@ -280,10 +280,10 @@
                 break
 
         errmsg = string.join(resp,"\n")
-        if self.debuglevel > 0: 
+        if self.debuglevel > 0:
             print 'reply: retcode (%s); Msg: %s' % (errcode,errmsg)
         return errcode, errmsg
-    
+
     def docmd(self, cmd, args=""):
         """Send a command, and return its response code."""
         self.putcmd(cmd,args)
@@ -313,8 +313,8 @@
         else:
             self.putcmd("ehlo", socket.getfqdn())
         (code,msg)=self.getreply()
-        # According to RFC1869 some (badly written) 
-        # MTA's will disconnect on an ehlo. Toss an exception if 
+        # According to RFC1869 some (badly written)
+        # MTA's will disconnect on an ehlo. Toss an exception if
         # that happens -ddm
         if code == -1 and len(msg) == 0:
             raise SMTPServerDisconnected("Server not connected")
@@ -368,7 +368,7 @@
         return self.getreply()
 
     def data(self,msg):
-        """SMTP 'DATA' command -- sends message data to server. 
+        """SMTP 'DATA' command -- sends message data to server.
 
         Automatically quotes lines beginning with a period per rfc821.
         Raises SMTPDataError if there is an unexpected reply to the
@@ -404,14 +404,14 @@
 
     # some useful methods
     def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
-                 rcpt_options=[]): 
-        """This command performs an entire mail transaction. 
+                 rcpt_options=[]):
+        """This command performs an entire mail transaction.
 
-        The arguments are: 
+        The arguments are:
             - from_addr    : The address sending this mail.
             - to_addrs     : A list of addresses to send this mail to.  A bare
                              string will be treated as a list with 1 address.
-            - msg          : The message to send. 
+            - msg          : The message to send.
             - mail_options : List of ESMTP options (such as 8bitmime) for the
                              mail command.
             - rcpt_options : List of ESMTP options (such as DSN commands) for
@@ -430,7 +430,7 @@
         This method may raise the following exceptions:
 
          SMTPHeloError          The server didn't reply properly to
-                                the helo greeting. 
+                                the helo greeting.
          SMTPRecipientsRefused  The server rejected ALL recipients
                                 (no mail was sent).
          SMTPSenderRefused      The server didn't accept the from_addr.
@@ -441,7 +441,7 @@
         Note: the connection will be open even after an exception is raised.
 
         Example:
-      
+
          >>> import smtplib
          >>> s=smtplib.SMTP("localhost")
          >>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"]
@@ -453,7 +453,7 @@
          >>> s.sendmail("me@my.org",tolist,msg)
          { "three@three.org" : ( 550 ,"User unknown" ) }
          >>> s.quit()
-        
+
         In the above example, the message was accepted for delivery to three
         of the four addresses, and one was rejected, with the error code
         550.  If all addresses are accepted, then the method will return an
@@ -494,7 +494,7 @@
             self.rset()
             raise SMTPDataError(code, resp)
         #if we got here then somebody got our mail
-        return senderrs         
+        return senderrs
 
 
     def close(self):
diff --git a/Lib/sndhdr.py b/Lib/sndhdr.py
index b20a696..61cd5b3 100644
--- a/Lib/sndhdr.py
+++ b/Lib/sndhdr.py
@@ -32,20 +32,20 @@
 
 
 def what(filename):
-	"""Guess the type of a sound file"""
-	res = whathdr(filename)
-	return res
+    """Guess the type of a sound file"""
+    res = whathdr(filename)
+    return res
 
 
 def whathdr(filename):
-	"""Recognize sound headers"""
-	f = open(filename, 'r')
-	h = f.read(512)
-	for tf in tests:
-		res = tf(h, f)
-		if res:
-			return res
-	return None
+    """Recognize sound headers"""
+    f = open(filename, 'r')
+    h = f.read(512)
+    for tf in tests:
+        res = tf(h, f)
+        if res:
+            return res
+    return None
 
 
 #-----------------------------------#
@@ -55,113 +55,113 @@
 tests = []
 
 def test_aifc(h, f):
-	import aifc
-	if h[:4] != 'FORM':
-		return None
-	if h[8:12] == 'AIFC':
-		fmt = 'aifc'
-	elif h[8:12] == 'AIFF':
-		fmt = 'aiff'
-	else:
-		return None
-	f.seek(0)
-	try:
-		a = aifc.openfp(f, 'r')
-	except (EOFError, aifc.Error):
-		return None
-	return (fmt, a.getframerate(), a.getnchannels(), \
-		a.getnframes(), 8*a.getsampwidth())
+    import aifc
+    if h[:4] != 'FORM':
+        return None
+    if h[8:12] == 'AIFC':
+        fmt = 'aifc'
+    elif h[8:12] == 'AIFF':
+        fmt = 'aiff'
+    else:
+        return None
+    f.seek(0)
+    try:
+        a = aifc.openfp(f, 'r')
+    except (EOFError, aifc.Error):
+        return None
+    return (fmt, a.getframerate(), a.getnchannels(), \
+            a.getnframes(), 8*a.getsampwidth())
 
 tests.append(test_aifc)
 
 
 def test_au(h, f):
-	if h[:4] == '.snd':
-		f = get_long_be
-	elif h[:4] in ('\0ds.', 'dns.'):
-		f = get_long_le
-	else:
-		return None
-	type = 'au'
-	hdr_size = f(h[4:8])
-	data_size = f(h[8:12])
-	encoding = f(h[12:16])
-	rate = f(h[16:20])
-	nchannels = f(h[20:24])
-	sample_size = 1 # default
-	if encoding == 1:
-		sample_bits = 'U'
-	elif encoding == 2:
-		sample_bits = 8
-	elif encoding == 3:
-		sample_bits = 16
-		sample_size = 2
-	else:
-		sample_bits = '?'
-	frame_size = sample_size * nchannels
-	return type, rate, nchannels, data_size/frame_size, sample_bits
+    if h[:4] == '.snd':
+        f = get_long_be
+    elif h[:4] in ('\0ds.', 'dns.'):
+        f = get_long_le
+    else:
+        return None
+    type = 'au'
+    hdr_size = f(h[4:8])
+    data_size = f(h[8:12])
+    encoding = f(h[12:16])
+    rate = f(h[16:20])
+    nchannels = f(h[20:24])
+    sample_size = 1 # default
+    if encoding == 1:
+        sample_bits = 'U'
+    elif encoding == 2:
+        sample_bits = 8
+    elif encoding == 3:
+        sample_bits = 16
+        sample_size = 2
+    else:
+        sample_bits = '?'
+    frame_size = sample_size * nchannels
+    return type, rate, nchannels, data_size/frame_size, sample_bits
 
 tests.append(test_au)
 
 
 def test_hcom(h, f):
-	if h[65:69] != 'FSSD' or h[128:132] != 'HCOM':
-		return None
-	divisor = get_long_be(h[128+16:128+20])
-	return 'hcom', 22050/divisor, 1, -1, 8
+    if h[65:69] != 'FSSD' or h[128:132] != 'HCOM':
+        return None
+    divisor = get_long_be(h[128+16:128+20])
+    return 'hcom', 22050/divisor, 1, -1, 8
 
 tests.append(test_hcom)
 
 
 def test_voc(h, f):
-	if h[:20] != 'Creative Voice File\032':
-		return None
-	sbseek = get_short_le(h[20:22])
-	rate = 0
-	if 0 <= sbseek < 500 and h[sbseek] == '\1':
-		ratecode = ord(h[sbseek+4])
-		rate = int(1000000.0 / (256 - ratecode))
-	return 'voc', rate, 1, -1, 8
+    if h[:20] != 'Creative Voice File\032':
+        return None
+    sbseek = get_short_le(h[20:22])
+    rate = 0
+    if 0 <= sbseek < 500 and h[sbseek] == '\1':
+        ratecode = ord(h[sbseek+4])
+        rate = int(1000000.0 / (256 - ratecode))
+    return 'voc', rate, 1, -1, 8
 
 tests.append(test_voc)
 
 
 def test_wav(h, f):
-	# 'RIFF' <len> 'WAVE' 'fmt ' <len>
-	if h[:4] != 'RIFF' or h[8:12] != 'WAVE' or h[12:16] != 'fmt ':
-		return None
-	style = get_short_le(h[20:22])
-	nchannels = get_short_le(h[22:24])
-	rate = get_long_le(h[24:28])
-	sample_bits = get_short_le(h[34:36])
-	return 'wav', rate, nchannels, -1, sample_bits
+    # 'RIFF' <len> 'WAVE' 'fmt ' <len>
+    if h[:4] != 'RIFF' or h[8:12] != 'WAVE' or h[12:16] != 'fmt ':
+        return None
+    style = get_short_le(h[20:22])
+    nchannels = get_short_le(h[22:24])
+    rate = get_long_le(h[24:28])
+    sample_bits = get_short_le(h[34:36])
+    return 'wav', rate, nchannels, -1, sample_bits
 
 tests.append(test_wav)
 
 
 def test_8svx(h, f):
-	if h[:4] != 'FORM' or h[8:12] != '8SVX':
-		return None
-	# Should decode it to get #channels -- assume always 1
-	return '8svx', 0, 1, 0, 8
+    if h[:4] != 'FORM' or h[8:12] != '8SVX':
+        return None
+    # Should decode it to get #channels -- assume always 1
+    return '8svx', 0, 1, 0, 8
 
 tests.append(test_8svx)
 
 
 def test_sndt(h, f):
-	if h[:5] == 'SOUND':
-		nsamples = get_long_le(h[8:12])
-		rate = get_short_le(h[20:22])
-		return 'sndt', rate, 1, nsamples, 8
+    if h[:5] == 'SOUND':
+        nsamples = get_long_le(h[8:12])
+        rate = get_short_le(h[20:22])
+        return 'sndt', rate, 1, nsamples, 8
 
 tests.append(test_sndt)
 
 
 def test_sndr(h, f):
-	if h[:2] == '\0\0':
-		rate = get_short_le(h[2:4])
-		if 4000 <= rate <= 25000:
-			return 'sndr', rate, 1, -1, 8
+    if h[:2] == '\0\0':
+        rate = get_short_le(h[2:4])
+        if 4000 <= rate <= 25000:
+            return 'sndr', rate, 1, -1, 8
 
 tests.append(test_sndr)
 
@@ -171,16 +171,16 @@
 #---------------------------------------------#
 
 def get_long_be(s):
-	return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
+    return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
 
 def get_long_le(s):
-	return (ord(s[3])<<24) | (ord(s[2])<<16) | (ord(s[1])<<8) | ord(s[0])
+    return (ord(s[3])<<24) | (ord(s[2])<<16) | (ord(s[1])<<8) | ord(s[0])
 
 def get_short_be(s):
-	return (ord(s[0])<<8) | ord(s[1])
+    return (ord(s[0])<<8) | ord(s[1])
 
 def get_short_le(s):
-	return (ord(s[1])<<8) | ord(s[0])
+    return (ord(s[1])<<8) | ord(s[0])
 
 
 #--------------------#
@@ -188,40 +188,40 @@
 #--------------------#
 
 def test():
-	import sys
-	recursive = 0
-	if sys.argv[1:] and sys.argv[1] == '-r':
-		del sys.argv[1:2]
-		recursive = 1
-	try:
-		if sys.argv[1:]:
-			testall(sys.argv[1:], recursive, 1)
-		else:
-			testall(['.'], recursive, 1)
-	except KeyboardInterrupt:
-		sys.stderr.write('\n[Interrupted]\n')
-		sys.exit(1)
+    import sys
+    recursive = 0
+    if sys.argv[1:] and sys.argv[1] == '-r':
+        del sys.argv[1:2]
+        recursive = 1
+    try:
+        if sys.argv[1:]:
+            testall(sys.argv[1:], recursive, 1)
+        else:
+            testall(['.'], recursive, 1)
+    except KeyboardInterrupt:
+        sys.stderr.write('\n[Interrupted]\n')
+        sys.exit(1)
 
 def testall(list, recursive, toplevel):
-	import sys
-	import os
-	for filename in list:
-		if os.path.isdir(filename):
-			print filename + '/:',
-			if recursive or toplevel:
-				print 'recursing down:'
-				import glob
-				names = glob.glob(os.path.join(filename, '*'))
-				testall(names, recursive, 0)
-			else:
-				print '*** directory (use -r) ***'
-		else:
-			print filename + ':',
-			sys.stdout.flush()
-			try:
-				print what(filename)
-			except IOError:
-				print '*** not found ***'
+    import sys
+    import os
+    for filename in list:
+        if os.path.isdir(filename):
+            print filename + '/:',
+            if recursive or toplevel:
+                print 'recursing down:'
+                import glob
+                names = glob.glob(os.path.join(filename, '*'))
+                testall(names, recursive, 0)
+            else:
+                print '*** directory (use -r) ***'
+        else:
+            print filename + ':',
+            sys.stdout.flush()
+            try:
+                print what(filename)
+            except IOError:
+                print '*** not found ***'
 
 if __name__ == '__main__':
-	test()
+    test()
diff --git a/Lib/socket.py b/Lib/socket.py
index 10227aa..bff5514 100644
--- a/Lib/socket.py
+++ b/Lib/socket.py
@@ -4,7 +4,7 @@
 """\
 This module provides socket operations and some related functions.
 On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
-On other systems, it only supports IP. Functions specific for a 
+On other systems, it only supports IP. Functions specific for a
 socket are available as methods of the socket object.
 
 Functions:
diff --git a/Lib/stat.py b/Lib/stat.py
index 9280ce6..70750d8 100644
--- a/Lib/stat.py
+++ b/Lib/stat.py
@@ -24,10 +24,10 @@
 # Extract bits from the mode
 
 def S_IMODE(mode):
-	return mode & 07777
+    return mode & 07777
 
 def S_IFMT(mode):
-	return mode & 0170000
+    return mode & 0170000
 
 # Constants used as S_IFMT() for various file types
 # (not all are implemented on all systems)
@@ -43,25 +43,25 @@
 # Functions to test for each file type
 
 def S_ISDIR(mode):
-	return S_IFMT(mode) == S_IFDIR
+    return S_IFMT(mode) == S_IFDIR
 
 def S_ISCHR(mode):
-	return S_IFMT(mode) == S_IFCHR
+    return S_IFMT(mode) == S_IFCHR
 
 def S_ISBLK(mode):
-	return S_IFMT(mode) == S_IFBLK
+    return S_IFMT(mode) == S_IFBLK
 
 def S_ISREG(mode):
-	return S_IFMT(mode) == S_IFREG
+    return S_IFMT(mode) == S_IFREG
 
 def S_ISFIFO(mode):
-	return S_IFMT(mode) == S_IFIFO
+    return S_IFMT(mode) == S_IFIFO
 
 def S_ISLNK(mode):
-	return S_IFMT(mode) == S_IFLNK
+    return S_IFMT(mode) == S_IFLNK
 
 def S_ISSOCK(mode):
-	return S_IFMT(mode) == S_IFSOCK
+    return S_IFMT(mode) == S_IFSOCK
 
 # Names for permission bits
 
diff --git a/Lib/statcache.py b/Lib/statcache.py
index 26f90942..85a3e79 100644
--- a/Lib/statcache.py
+++ b/Lib/statcache.py
@@ -13,63 +13,63 @@
 
 
 def stat(path):
-	"""Stat a file, possibly out of the cache."""
-	if cache.has_key(path):
-		return cache[path]
-	cache[path] = ret = os.stat(path)
-	return ret
+    """Stat a file, possibly out of the cache."""
+    if cache.has_key(path):
+        return cache[path]
+    cache[path] = ret = os.stat(path)
+    return ret
 
 
 def reset():
-	"""Reset the cache completely."""
-	global cache
-	cache = {}
+    """Reset the cache completely."""
+    global cache
+    cache = {}
 
 
 def forget(path):
-	"""Remove a given item from the cache, if it exists."""
-	if cache.has_key(path):
-		del cache[path]
+    """Remove a given item from the cache, if it exists."""
+    if cache.has_key(path):
+        del cache[path]
 
 
 def forget_prefix(prefix):
-	"""Remove all pathnames with a given prefix."""
-	n = len(prefix)
-	for path in cache.keys():
-		if path[:n] == prefix:
-			del cache[path]
+    """Remove all pathnames with a given prefix."""
+    n = len(prefix)
+    for path in cache.keys():
+        if path[:n] == prefix:
+            del cache[path]
 
 
 def forget_dir(prefix):
-	"""Forget about a directory and all entries in it, but not about
-	entries in subdirectories."""
-	if prefix[-1:] == '/' and prefix != '/':
-		prefix = prefix[:-1]
-	forget(prefix)
-	if prefix[-1:] != '/':
-		prefix = prefix + '/'
-	n = len(prefix)
-	for path in cache.keys():
-		if path[:n] == prefix:
-			rest = path[n:]
-			if rest[-1:] == '/': rest = rest[:-1]
-			if '/' not in rest:
-				del cache[path]
+    """Forget about a directory and all entries in it, but not about
+    entries in subdirectories."""
+    if prefix[-1:] == '/' and prefix != '/':
+        prefix = prefix[:-1]
+    forget(prefix)
+    if prefix[-1:] != '/':
+        prefix = prefix + '/'
+    n = len(prefix)
+    for path in cache.keys():
+        if path[:n] == prefix:
+            rest = path[n:]
+            if rest[-1:] == '/': rest = rest[:-1]
+            if '/' not in rest:
+                del cache[path]
 
 
 def forget_except_prefix(prefix):
-	"""Remove all pathnames except with a given prefix.
-	Normally used with prefix = '/' after a chdir()."""
-	n = len(prefix)
-	for path in cache.keys():
-		if path[:n] != prefix:
-			del cache[path]
+    """Remove all pathnames except with a given prefix.
+    Normally used with prefix = '/' after a chdir()."""
+    n = len(prefix)
+    for path in cache.keys():
+        if path[:n] != prefix:
+            del cache[path]
 
 
 def isdir(path):
-	"""Check for directory."""
-	try:
-		st = stat(path)
-	except os.error:
-		return 0
-	return S_ISDIR(st[ST_MODE])
+    """Check for directory."""
+    try:
+        st = stat(path)
+    except os.error:
+        return 0
+    return S_ISDIR(st[ST_MODE])
diff --git a/Lib/statvfs.py b/Lib/statvfs.py
index 082f20a..06a323f 100644
--- a/Lib/statvfs.py
+++ b/Lib/statvfs.py
@@ -3,13 +3,13 @@
 # Indices for statvfs struct members in the tuple returned by
 # os.statvfs() and os.fstatvfs().
 
-F_BSIZE   = 0		# Preferred file system block size
-F_FRSIZE  = 1		# Fundamental file system block size
-F_BLOCKS  = 2		# Total number of file system blocks (FRSIZE)
-F_BFREE   = 3		# Total number of free blocks
-F_BAVAIL  = 4		# Free blocks available to non-superuser
-F_FILES   = 5		# Total number of file nodes
-F_FFREE   = 6		# Total number of free file nodes
-F_FAVAIL  = 7		# Free nodes available to non-superuser
-F_FLAG    = 8		# Flags (see your local statvfs man page)
-F_NAMEMAX = 9		# Maximum file name length
+F_BSIZE   = 0           # Preferred file system block size
+F_FRSIZE  = 1           # Fundamental file system block size
+F_BLOCKS  = 2           # Total number of file system blocks (FRSIZE)
+F_BFREE   = 3           # Total number of free blocks
+F_BAVAIL  = 4           # Free blocks available to non-superuser
+F_FILES   = 5           # Total number of file nodes
+F_FFREE   = 6           # Total number of free file nodes
+F_FAVAIL  = 7           # Free nodes available to non-superuser
+F_FLAG    = 8           # Flags (see your local statvfs man page)
+F_NAMEMAX = 9           # Maximum file name length
diff --git a/Lib/string.py b/Lib/string.py
index 0dffb2a..61b253e 100644
--- a/Lib/string.py
+++ b/Lib/string.py
@@ -27,7 +27,7 @@
 digits = '0123456789'
 hexdigits = digits + 'abcdef' + 'ABCDEF'
 octdigits = '01234567'
-punctuation = """!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~""" 
+punctuation = """!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
 printable = digits + letters + punctuation + whitespace
 
 # Case conversion helpers
diff --git a/Lib/sunau.py b/Lib/sunau.py
index 07f2784..0a40295 100644
--- a/Lib/sunau.py
+++ b/Lib/sunau.py
@@ -43,25 +43,25 @@
 method is not  necessary.
 
 This returns an instance of a class with the following public methods:
-        getnchannels()	-- returns number of audio channels (1 for
-        		   mono, 2 for stereo)
-        getsampwidth()	-- returns sample width in bytes
-        getframerate()	-- returns sampling frequency
-        getnframes()	-- returns number of audio frames
-        getcomptype()	-- returns compression type ('NONE' or 'ULAW')
-        getcompname()	-- returns human-readable version of
-        		   compression type ('not compressed' matches 'NONE')
-        getparams()	-- returns a tuple consisting of all of the
-        		   above in the above order
-        getmarkers()	-- returns None (for compatibility with the
-        		   aifc module)
-        getmark(id)	-- raises an error since the mark does not
-        		   exist (for compatibility with the aifc module)
-        readframes(n)	-- returns at most n frames of audio
-        rewind()	-- rewind to the beginning of the audio stream
-        setpos(pos)	-- seek to the specified position
-        tell()		-- return the current position
-        close()		-- close the instance (make it unusable)
+        getnchannels()  -- returns number of audio channels (1 for
+                           mono, 2 for stereo)
+        getsampwidth()  -- returns sample width in bytes
+        getframerate()  -- returns sampling frequency
+        getnframes()    -- returns number of audio frames
+        getcomptype()   -- returns compression type ('NONE' or 'ULAW')
+        getcompname()   -- returns human-readable version of
+                           compression type ('not compressed' matches 'NONE')
+        getparams()     -- returns a tuple consisting of all of the
+                           above in the above order
+        getmarkers()    -- returns None (for compatibility with the
+                           aifc module)
+        getmark(id)     -- raises an error since the mark does not
+                           exist (for compatibility with the aifc module)
+        readframes(n)   -- returns at most n frames of audio
+        rewind()        -- rewind to the beginning of the audio stream
+        setpos(pos)     -- seek to the specified position
+        tell()          -- return the current position
+        close()         -- close the instance (make it unusable)
 The position returned by tell() and the position given to setpos()
 are compatible and have nothing to do with the actual position in the
 file.
@@ -75,22 +75,22 @@
 close().
 
 This returns an instance of a class with the following public methods:
-        setnchannels(n)	-- set the number of channels
-        setsampwidth(n)	-- set the sample width
-        setframerate(n)	-- set the frame rate
-        setnframes(n)	-- set the number of frames
+        setnchannels(n) -- set the number of channels
+        setsampwidth(n) -- set the sample width
+        setframerate(n) -- set the frame rate
+        setnframes(n)   -- set the number of frames
         setcomptype(type, name)
-        		-- set the compression type and the
-        		   human-readable compression type
+                        -- set the compression type and the
+                           human-readable compression type
         setparams(tuple)-- set all parameters at once
-        tell()		-- return current position in output file
+        tell()          -- return current position in output file
         writeframesraw(data)
-        		-- write audio frames without pathing up the
-        		   file header
+                        -- write audio frames without pathing up the
+                           file header
         writeframes(data)
-        		-- write audio frames and patch up the file header
-        close()		-- patch up the file header and close the
-        		   output file
+                        -- write audio frames and patch up the file header
+        close()         -- patch up the file header and close the
+                           output file
 You should set the parameters before the first writeframesraw or
 writeframes.  The total number of frames does not need to be set,
 but when it is set to the correct value, the header does not have to
@@ -119,356 +119,356 @@
 AUDIO_FILE_ENCODING_ALAW_8 = 27
 
 # from <multimedia/audio_hdr.h>
-AUDIO_UNKNOWN_SIZE = 0xFFFFFFFFL	# ((unsigned)(~0))
+AUDIO_UNKNOWN_SIZE = 0xFFFFFFFFL        # ((unsigned)(~0))
 
 _simple_encodings = [AUDIO_FILE_ENCODING_MULAW_8,
-		     AUDIO_FILE_ENCODING_LINEAR_8,
-		     AUDIO_FILE_ENCODING_LINEAR_16,
-		     AUDIO_FILE_ENCODING_LINEAR_24,
-		     AUDIO_FILE_ENCODING_LINEAR_32,
-		     AUDIO_FILE_ENCODING_ALAW_8]
+                     AUDIO_FILE_ENCODING_LINEAR_8,
+                     AUDIO_FILE_ENCODING_LINEAR_16,
+                     AUDIO_FILE_ENCODING_LINEAR_24,
+                     AUDIO_FILE_ENCODING_LINEAR_32,
+                     AUDIO_FILE_ENCODING_ALAW_8]
 
 class Error(Exception):
-	pass
+    pass
 
 def _read_u32(file):
-	x = 0L
-	for i in range(4):
-		byte = file.read(1)
-		if byte == '':
-			raise EOFError
-		x = x*256 + ord(byte)
-	return x
+    x = 0L
+    for i in range(4):
+        byte = file.read(1)
+        if byte == '':
+            raise EOFError
+        x = x*256 + ord(byte)
+    return x
 
 def _write_u32(file, x):
-	data = []
-	for i in range(4):
-		d, m = divmod(x, 256)
-		data.insert(0, m)
-		x = d
-	for i in range(4):
-		file.write(chr(int(data[i])))
+    data = []
+    for i in range(4):
+        d, m = divmod(x, 256)
+        data.insert(0, m)
+        x = d
+    for i in range(4):
+        file.write(chr(int(data[i])))
 
 class Au_read:
 
-	def __init__(self, f):
-		if type(f) == type(''):
-			import __builtin__
-			f = __builtin__.open(f, 'rb')
-		self.initfp(f)
+    def __init__(self, f):
+        if type(f) == type(''):
+            import __builtin__
+            f = __builtin__.open(f, 'rb')
+        self.initfp(f)
 
-	def __del__(self):
-		if self._file:
-			self.close()
+    def __del__(self):
+        if self._file:
+            self.close()
 
-	def initfp(self, file):
-		self._file = file
-		self._soundpos = 0
-		magic = int(_read_u32(file))
-		if magic != AUDIO_FILE_MAGIC:
-			raise Error, 'bad magic number'
-		self._hdr_size = int(_read_u32(file))
-		if self._hdr_size < 24:
-			raise Error, 'header size too small'
-		if self._hdr_size > 100:
-			raise Error, 'header size ridiculously large'
-		self._data_size = _read_u32(file)
-		if self._data_size != AUDIO_UNKNOWN_SIZE:
-			self._data_size = int(self._data_size)
-		self._encoding = int(_read_u32(file))
-		if self._encoding not in _simple_encodings:
-			raise Error, 'encoding not (yet) supported'
-		if self._encoding in (AUDIO_FILE_ENCODING_MULAW_8,
-			  AUDIO_FILE_ENCODING_ALAW_8):
-			self._sampwidth = 2
-			self._framesize = 1
-		elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_8:
-			self._framesize = self._sampwidth = 1
-		elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_16:
-			self._framesize = self._sampwidth = 2
-		elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_24:
-			self._framesize = self._sampwidth = 3
-		elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_32:
-			self._framesize = self._sampwidth = 4
-		else:
-			raise Error, 'unknown encoding'
-		self._framerate = int(_read_u32(file))
-		self._nchannels = int(_read_u32(file))
-		self._framesize = self._framesize * self._nchannels
-		if self._hdr_size > 24:
-			self._info = file.read(self._hdr_size - 24)
-			for i in range(len(self._info)):
-				if self._info[i] == '\0':
-					self._info = self._info[:i]
-					break
-		else:
-			self._info = ''
+    def initfp(self, file):
+        self._file = file
+        self._soundpos = 0
+        magic = int(_read_u32(file))
+        if magic != AUDIO_FILE_MAGIC:
+            raise Error, 'bad magic number'
+        self._hdr_size = int(_read_u32(file))
+        if self._hdr_size < 24:
+            raise Error, 'header size too small'
+        if self._hdr_size > 100:
+            raise Error, 'header size ridiculously large'
+        self._data_size = _read_u32(file)
+        if self._data_size != AUDIO_UNKNOWN_SIZE:
+            self._data_size = int(self._data_size)
+        self._encoding = int(_read_u32(file))
+        if self._encoding not in _simple_encodings:
+            raise Error, 'encoding not (yet) supported'
+        if self._encoding in (AUDIO_FILE_ENCODING_MULAW_8,
+                  AUDIO_FILE_ENCODING_ALAW_8):
+            self._sampwidth = 2
+            self._framesize = 1
+        elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_8:
+            self._framesize = self._sampwidth = 1
+        elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_16:
+            self._framesize = self._sampwidth = 2
+        elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_24:
+            self._framesize = self._sampwidth = 3
+        elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_32:
+            self._framesize = self._sampwidth = 4
+        else:
+            raise Error, 'unknown encoding'
+        self._framerate = int(_read_u32(file))
+        self._nchannels = int(_read_u32(file))
+        self._framesize = self._framesize * self._nchannels
+        if self._hdr_size > 24:
+            self._info = file.read(self._hdr_size - 24)
+            for i in range(len(self._info)):
+                if self._info[i] == '\0':
+                    self._info = self._info[:i]
+                    break
+        else:
+            self._info = ''
 
-	def getfp(self):
-		return self._file
+    def getfp(self):
+        return self._file
 
-	def getnchannels(self):
-		return self._nchannels
+    def getnchannels(self):
+        return self._nchannels
 
-	def getsampwidth(self):
-		return self._sampwidth
+    def getsampwidth(self):
+        return self._sampwidth
 
-	def getframerate(self):
-		return self._framerate
+    def getframerate(self):
+        return self._framerate
 
-	def getnframes(self):
-		if self._data_size == AUDIO_UNKNOWN_SIZE:
-			return AUDIO_UNKNOWN_SIZE
-		if self._encoding in _simple_encodings:
-			return self._data_size / self._framesize
-		return 0		# XXX--must do some arithmetic here
+    def getnframes(self):
+        if self._data_size == AUDIO_UNKNOWN_SIZE:
+            return AUDIO_UNKNOWN_SIZE
+        if self._encoding in _simple_encodings:
+            return self._data_size / self._framesize
+        return 0                # XXX--must do some arithmetic here
 
-	def getcomptype(self):
-		if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
-			return 'ULAW'
-		elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
-			return 'ALAW'
-		else:
-			return 'NONE'
+    def getcomptype(self):
+        if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
+            return 'ULAW'
+        elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
+            return 'ALAW'
+        else:
+            return 'NONE'
 
-	def getcompname(self):
-		if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
-			return 'CCITT G.711 u-law'
-		elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
-			return 'CCITT G.711 A-law'
-		else:
-			return 'not compressed'
+    def getcompname(self):
+        if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
+            return 'CCITT G.711 u-law'
+        elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8:
+            return 'CCITT G.711 A-law'
+        else:
+            return 'not compressed'
 
-	def getparams(self):
-		return self.getnchannels(), self.getsampwidth(), \
-			  self.getframerate(), self.getnframes(), \
-			  self.getcomptype(), self.getcompname()
+    def getparams(self):
+        return self.getnchannels(), self.getsampwidth(), \
+                  self.getframerate(), self.getnframes(), \
+                  self.getcomptype(), self.getcompname()
 
-	def getmarkers(self):
-		return None
+    def getmarkers(self):
+        return None
 
-	def getmark(self, id):
-		raise Error, 'no marks'
+    def getmark(self, id):
+        raise Error, 'no marks'
 
-	def readframes(self, nframes):
-		if self._encoding in _simple_encodings:
-			if nframes == AUDIO_UNKNOWN_SIZE:
-				data = self._file.read()
-			else:
-				data = self._file.read(nframes * self._framesize * self._nchannels)
-			if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
-				import audioop
-				data = audioop.ulaw2lin(data, self._sampwidth)
-			return data
-		return None		# XXX--not implemented yet
+    def readframes(self, nframes):
+        if self._encoding in _simple_encodings:
+            if nframes == AUDIO_UNKNOWN_SIZE:
+                data = self._file.read()
+            else:
+                data = self._file.read(nframes * self._framesize * self._nchannels)
+            if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
+                import audioop
+                data = audioop.ulaw2lin(data, self._sampwidth)
+            return data
+        return None             # XXX--not implemented yet
 
-	def rewind(self):
-		self._soundpos = 0
-		self._file.seek(self._hdr_size)
+    def rewind(self):
+        self._soundpos = 0
+        self._file.seek(self._hdr_size)
 
-	def tell(self):
-		return self._soundpos
+    def tell(self):
+        return self._soundpos
 
-	def setpos(self, pos):
-		if pos < 0 or pos > self.getnframes():
-			raise Error, 'position not in range'
-		self._file.seek(pos * self._framesize + self._hdr_size)
-		self._soundpos = pos
+    def setpos(self, pos):
+        if pos < 0 or pos > self.getnframes():
+            raise Error, 'position not in range'
+        self._file.seek(pos * self._framesize + self._hdr_size)
+        self._soundpos = pos
 
-	def close(self):
-		self._file = None
+    def close(self):
+        self._file = None
 
 class Au_write:
 
-	def __init__(self, f):
-		if type(f) == type(''):
-			import __builtin__
-			f = __builtin__.open(f, 'wb')
-		self.initfp(f)
+    def __init__(self, f):
+        if type(f) == type(''):
+            import __builtin__
+            f = __builtin__.open(f, 'wb')
+        self.initfp(f)
 
-	def __del__(self):
-		if self._file:
-			self.close()
+    def __del__(self):
+        if self._file:
+            self.close()
 
-	def initfp(self, file):
-		self._file = file
-		self._framerate = 0
-		self._nchannels = 0
-		self._sampwidth = 0
-		self._framesize = 0
-		self._nframes = AUDIO_UNKNOWN_SIZE
-		self._nframeswritten = 0
-		self._datawritten = 0
-		self._datalength = 0
-		self._info = ''
-		self._comptype = 'ULAW'	# default is U-law
+    def initfp(self, file):
+        self._file = file
+        self._framerate = 0
+        self._nchannels = 0
+        self._sampwidth = 0
+        self._framesize = 0
+        self._nframes = AUDIO_UNKNOWN_SIZE
+        self._nframeswritten = 0
+        self._datawritten = 0
+        self._datalength = 0
+        self._info = ''
+        self._comptype = 'ULAW' # default is U-law
 
-	def setnchannels(self, nchannels):
-		if self._nframeswritten:
-			raise Error, 'cannot change parameters after starting to write'
-		if nchannels not in (1, 2, 4):
-			raise Error, 'only 1, 2, or 4 channels supported'
-		self._nchannels = nchannels
+    def setnchannels(self, nchannels):
+        if self._nframeswritten:
+            raise Error, 'cannot change parameters after starting to write'
+        if nchannels not in (1, 2, 4):
+            raise Error, 'only 1, 2, or 4 channels supported'
+        self._nchannels = nchannels
 
-	def getnchannels(self):
-		if not self._nchannels:
-			raise Error, 'number of channels not set'
-		return self._nchannels
+    def getnchannels(self):
+        if not self._nchannels:
+            raise Error, 'number of channels not set'
+        return self._nchannels
 
-	def setsampwidth(self, sampwidth):
-		if self._nframeswritten:
-			raise Error, 'cannot change parameters after starting to write'
-		if sampwidth not in (1, 2, 4):
-			raise Error, 'bad sample width'
-		self._sampwidth = sampwidth
+    def setsampwidth(self, sampwidth):
+        if self._nframeswritten:
+            raise Error, 'cannot change parameters after starting to write'
+        if sampwidth not in (1, 2, 4):
+            raise Error, 'bad sample width'
+        self._sampwidth = sampwidth
 
-	def getsampwidth(self):
-		if not self._framerate:
-			raise Error, 'sample width not specified'
-		return self._sampwidth
+    def getsampwidth(self):
+        if not self._framerate:
+            raise Error, 'sample width not specified'
+        return self._sampwidth
 
-	def setframerate(self, framerate):
-		if self._nframeswritten:
-			raise Error, 'cannot change parameters after starting to write'
-		self._framerate = framerate
+    def setframerate(self, framerate):
+        if self._nframeswritten:
+            raise Error, 'cannot change parameters after starting to write'
+        self._framerate = framerate
 
-	def getframerate(self):
-		if not self._framerate:
-			raise Error, 'frame rate not set'
-		return self._framerate
+    def getframerate(self):
+        if not self._framerate:
+            raise Error, 'frame rate not set'
+        return self._framerate
 
-	def setnframes(self, nframes):
-		if self._nframeswritten:
-			raise Error, 'cannot change parameters after starting to write'
-		if nframes < 0:
-			raise Error, '# of frames cannot be negative'
-		self._nframes = nframes
+    def setnframes(self, nframes):
+        if self._nframeswritten:
+            raise Error, 'cannot change parameters after starting to write'
+        if nframes < 0:
+            raise Error, '# of frames cannot be negative'
+        self._nframes = nframes
 
-	def getnframes(self):
-		return self._nframeswritten
+    def getnframes(self):
+        return self._nframeswritten
 
-	def setcomptype(self, type, name):
-		if type in ('NONE', 'ULAW'):
-			self._comptype = type
-		else:
-			raise Error, 'unknown compression type'
+    def setcomptype(self, type, name):
+        if type in ('NONE', 'ULAW'):
+            self._comptype = type
+        else:
+            raise Error, 'unknown compression type'
 
-	def getcomptype(self):
-		return self._comptype
+    def getcomptype(self):
+        return self._comptype
 
-	def getcompname(self):
-		if self._comptype == 'ULAW':
-			return 'CCITT G.711 u-law'
-		elif self._comptype == 'ALAW':
-			return 'CCITT G.711 A-law'
-		else:
-			return 'not compressed'
+    def getcompname(self):
+        if self._comptype == 'ULAW':
+            return 'CCITT G.711 u-law'
+        elif self._comptype == 'ALAW':
+            return 'CCITT G.711 A-law'
+        else:
+            return 'not compressed'
 
-	def setparams(self, (nchannels, sampwidth, framerate, nframes, comptype, compname)):
-		self.setnchannels(nchannels)
-		self.setsampwidth(sampwidth)
-		self.setframerate(framerate)
-		self.setnframes(nframes)
-		self.setcomptype(comptype, compname)
+    def setparams(self, (nchannels, sampwidth, framerate, nframes, comptype, compname)):
+        self.setnchannels(nchannels)
+        self.setsampwidth(sampwidth)
+        self.setframerate(framerate)
+        self.setnframes(nframes)
+        self.setcomptype(comptype, compname)
 
-	def getparams(self):
-		return self.getnchannels(), self.getsampwidth(), \
-			  self.getframerate(), self.getnframes(), \
-			  self.getcomptype(), self.getcompname()
+    def getparams(self):
+        return self.getnchannels(), self.getsampwidth(), \
+                  self.getframerate(), self.getnframes(), \
+                  self.getcomptype(), self.getcompname()
 
-	def tell(self):
-		return self._nframeswritten
+    def tell(self):
+        return self._nframeswritten
 
-	def writeframesraw(self, data):
-		self._ensure_header_written()
-		nframes = len(data) / self._framesize
-		if self._comptype == 'ULAW':
-			import audioop
-			data = audioop.lin2ulaw(data, self._sampwidth)
-		self._file.write(data)
-		self._nframeswritten = self._nframeswritten + nframes
-		self._datawritten = self._datawritten + len(data)
+    def writeframesraw(self, data):
+        self._ensure_header_written()
+        nframes = len(data) / self._framesize
+        if self._comptype == 'ULAW':
+            import audioop
+            data = audioop.lin2ulaw(data, self._sampwidth)
+        self._file.write(data)
+        self._nframeswritten = self._nframeswritten + nframes
+        self._datawritten = self._datawritten + len(data)
 
-	def writeframes(self, data):
-		self.writeframesraw(data)
-		if self._nframeswritten != self._nframes or \
-			  self._datalength != self._datawritten:
-			self._patchheader()
+    def writeframes(self, data):
+        self.writeframesraw(data)
+        if self._nframeswritten != self._nframes or \
+                  self._datalength != self._datawritten:
+            self._patchheader()
 
-	def close(self):
-		self._ensure_header_written()
-		if self._nframeswritten != self._nframes or \
-			  self._datalength != self._datawritten:
-			self._patchheader()
-		self._file.flush()
-		self._file = None
+    def close(self):
+        self._ensure_header_written()
+        if self._nframeswritten != self._nframes or \
+                  self._datalength != self._datawritten:
+            self._patchheader()
+        self._file.flush()
+        self._file = None
 
-	#
-	# private methods
-	#
+    #
+    # private methods
+    #
 
-	def _ensure_header_written(self):
-		if not self._nframeswritten:
-			if not self._nchannels:
-				raise Error, '# of channels not specified'
-			if not self._sampwidth:
-				raise Error, 'sample width not specified'
-			if not self._framerate:
-				raise Error, 'frame rate not specified'
-			self._write_header()
+    def _ensure_header_written(self):
+        if not self._nframeswritten:
+            if not self._nchannels:
+                raise Error, '# of channels not specified'
+            if not self._sampwidth:
+                raise Error, 'sample width not specified'
+            if not self._framerate:
+                raise Error, 'frame rate not specified'
+            self._write_header()
 
-	def _write_header(self):
-		if self._comptype == 'NONE':
-			if self._sampwidth == 1:
-				encoding = AUDIO_FILE_ENCODING_LINEAR_8
-				self._framesize = 1
-			elif self._sampwidth == 2:
-				encoding = AUDIO_FILE_ENCODING_LINEAR_16
-				self._framesize = 2
-			elif self._sampwidth == 4:
-				encoding = AUDIO_FILE_ENCODING_LINEAR_32
-				self._framesize = 4
-			else:
-				raise Error, 'internal error'
-		elif self._comptype == 'ULAW':
-			encoding = AUDIO_FILE_ENCODING_MULAW_8
-			self._framesize = 1
-		else:
-			raise Error, 'internal error'
-		self._framesize = self._framesize * self._nchannels
-		_write_u32(self._file, AUDIO_FILE_MAGIC)
-		header_size = 25 + len(self._info)
-		header_size = (header_size + 7) & ~7
-		_write_u32(self._file, header_size)
-		if self._nframes == AUDIO_UNKNOWN_SIZE:
-			length = AUDIO_UNKNOWN_SIZE
-		else:
-			length = self._nframes * self._framesize
-		_write_u32(self._file, length)
-		self._datalength = length
-		_write_u32(self._file, encoding)
-		_write_u32(self._file, self._framerate)
-		_write_u32(self._file, self._nchannels)
-		self._file.write(self._info)
-		self._file.write('\0'*(header_size - len(self._info) - 24))
+    def _write_header(self):
+        if self._comptype == 'NONE':
+            if self._sampwidth == 1:
+                encoding = AUDIO_FILE_ENCODING_LINEAR_8
+                self._framesize = 1
+            elif self._sampwidth == 2:
+                encoding = AUDIO_FILE_ENCODING_LINEAR_16
+                self._framesize = 2
+            elif self._sampwidth == 4:
+                encoding = AUDIO_FILE_ENCODING_LINEAR_32
+                self._framesize = 4
+            else:
+                raise Error, 'internal error'
+        elif self._comptype == 'ULAW':
+            encoding = AUDIO_FILE_ENCODING_MULAW_8
+            self._framesize = 1
+        else:
+            raise Error, 'internal error'
+        self._framesize = self._framesize * self._nchannels
+        _write_u32(self._file, AUDIO_FILE_MAGIC)
+        header_size = 25 + len(self._info)
+        header_size = (header_size + 7) & ~7
+        _write_u32(self._file, header_size)
+        if self._nframes == AUDIO_UNKNOWN_SIZE:
+            length = AUDIO_UNKNOWN_SIZE
+        else:
+            length = self._nframes * self._framesize
+        _write_u32(self._file, length)
+        self._datalength = length
+        _write_u32(self._file, encoding)
+        _write_u32(self._file, self._framerate)
+        _write_u32(self._file, self._nchannels)
+        self._file.write(self._info)
+        self._file.write('\0'*(header_size - len(self._info) - 24))
 
-	def _patchheader(self):
-		self._file.seek(8)
-		_write_u32(self._file, self._datawritten)
-		self._datalength = self._datawritten
-		self._file.seek(0, 2)
+    def _patchheader(self):
+        self._file.seek(8)
+        _write_u32(self._file, self._datawritten)
+        self._datalength = self._datawritten
+        self._file.seek(0, 2)
 
 def open(f, mode=None):
-	if mode is None:
-		if hasattr(f, 'mode'):
-			mode = f.mode
-		else:
-			mode = 'rb'
-	if mode in ('r', 'rb'):
-		return Au_read(f)
-	elif mode in ('w', 'wb'):
-		return Au_write(f)
-	else:
-		raise Error, "mode must be 'r', 'rb', 'w', or 'wb'"
+    if mode is None:
+        if hasattr(f, 'mode'):
+            mode = f.mode
+        else:
+            mode = 'rb'
+    if mode in ('r', 'rb'):
+        return Au_read(f)
+    elif mode in ('w', 'wb'):
+        return Au_write(f)
+    else:
+        raise Error, "mode must be 'r', 'rb', 'w', or 'wb'"
 
 openfp = open
diff --git a/Lib/sunaudio.py b/Lib/sunaudio.py
index 87dc6ee..86a5b41 100644
--- a/Lib/sunaudio.py
+++ b/Lib/sunaudio.py
@@ -3,42 +3,42 @@
 MAGIC = '.snd'
 
 class error(Exception):
-	pass
+    pass
 
 
 def get_long_be(s):
-	"""Convert a 4-char value to integer."""
-	return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
+    """Convert a 4-char value to integer."""
+    return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
 
 
 def gethdr(fp):
-	"""Read a sound header from an open file."""
-	if fp.read(4) != MAGIC:
-		raise error, 'gethdr: bad magic word'
-	hdr_size = get_long_be(fp.read(4))
-	data_size = get_long_be(fp.read(4))
-	encoding = get_long_be(fp.read(4))
-	sample_rate = get_long_be(fp.read(4))
-	channels = get_long_be(fp.read(4))
-	excess = hdr_size - 24
-	if excess < 0:
-		raise error, 'gethdr: bad hdr_size'
-	if excess > 0:
-		info = fp.read(excess)
-	else:
-		info = ''
-	return (data_size, encoding, sample_rate, channels, info)
+    """Read a sound header from an open file."""
+    if fp.read(4) != MAGIC:
+        raise error, 'gethdr: bad magic word'
+    hdr_size = get_long_be(fp.read(4))
+    data_size = get_long_be(fp.read(4))
+    encoding = get_long_be(fp.read(4))
+    sample_rate = get_long_be(fp.read(4))
+    channels = get_long_be(fp.read(4))
+    excess = hdr_size - 24
+    if excess < 0:
+        raise error, 'gethdr: bad hdr_size'
+    if excess > 0:
+        info = fp.read(excess)
+    else:
+        info = ''
+    return (data_size, encoding, sample_rate, channels, info)
 
 
 def printhdr(file):
-	"""Read and print the sound header of a named file."""
-	hdr = gethdr(open(file, 'r'))
-	data_size, encoding, sample_rate, channels, info = hdr
-	while info[-1:] == '\0':
-		info = info[:-1]
-	print 'File name:  ', file
-	print 'Data size:  ', data_size
-	print 'Encoding:   ', encoding
-	print 'Sample rate:', sample_rate
-	print 'Channels:   ', channels
-	print 'Info:       ', `info`
+    """Read and print the sound header of a named file."""
+    hdr = gethdr(open(file, 'r'))
+    data_size, encoding, sample_rate, channels, info = hdr
+    while info[-1:] == '\0':
+        info = info[:-1]
+    print 'File name:  ', file
+    print 'Data size:  ', data_size
+    print 'Encoding:   ', encoding
+    print 'Sample rate:', sample_rate
+    print 'Channels:   ', channels
+    print 'Info:       ', `info`