Untabify to pass the -tt test.

Lib/httplib.py

@@ -44,27 +44,27 @@ HTTPS_PORT = 443
 
 class FakeSocket:
     def __init__(self, sock, ssl):
-	self.__sock = sock
-	self.__ssl = ssl
-	return
-
-    def makefile(self, mode):		# hopefully, never have to write
-	msgbuf = ""
-	while 1:
-	    try:
-		msgbuf = msgbuf + self.__ssl.read()
-	    except socket.sslerror, msg:
-		break
-	return StringIO(msgbuf)
+        self.__sock = sock
+        self.__ssl = ssl
+        return
+
+    def makefile(self, mode):           # hopefully, never have to write
+        msgbuf = ""
+        while 1:
+            try:
+                msgbuf = msgbuf + self.__ssl.read()
+            except socket.sslerror, msg:
+                break
+        return StringIO(msgbuf)
 
     def send(self, stuff, flags = 0):
-	return self.__ssl.write(stuff)
+        return self.__ssl.write(stuff)
 
     def recv(self, len = 1024, flags = 0):
-	return self.__ssl.read(len)
+        return self.__ssl.read(len)
 
     def __getattr__(self, attr):
-	return getattr(self.__sock, attr)
+        return getattr(self.__sock, attr)
 
 class HTTP:
     """This class manages a connection to an HTTP server."""

Lib/mimetypes.py

@@ -30,8 +30,8 @@ import urllib
 knownfiles = [
     "/usr/local/etc/httpd/conf/mime.types",
     "/usr/local/lib/netscape/mime.types",
-    "/usr/local/etc/httpd/conf/mime.types",	# Apache 1.2
-    "/usr/local/etc/mime.types",		# Apache 1.3
+    "/usr/local/etc/httpd/conf/mime.types",     # Apache 1.2
+    "/usr/local/etc/mime.types",                # Apache 1.3
     ]
 
 inited = 0
@@ -56,24 +56,24 @@ def guess_type(url):
         init()
     scheme, url = urllib.splittype(url)
     if scheme == 'data':
-	# syntax of data URLs:
-	# dataurl   := "data:" [ mediatype ] [ ";base64" ] "," data
-	# mediatype := [ type "/" subtype ] *( ";" parameter )
-	# data      := *urlchar
-	# parameter := attribute "=" value
-	# type/subtype defaults to "text/plain"
-	comma = string.find(url, ',')
-	if comma < 0:
-	    # bad data URL
-	    return None, None
-	semi = string.find(url, ';', 0, comma)
-	if semi >= 0:
-	    type = url[:semi]
-	else:
-	    type = url[:comma]
-	if '=' in type or '/' not in type:
-	    type = 'text/plain'
-	return type, None		# never compressed, so encoding is None
+        # syntax of data URLs:
+        # dataurl   := "data:" [ mediatype ] [ ";base64" ] "," data
+        # mediatype := [ type "/" subtype ] *( ";" parameter )
+        # data      := *urlchar
+        # parameter := attribute "=" value
+        # type/subtype defaults to "text/plain"
+        comma = string.find(url, ',')
+        if comma < 0:
+            # bad data URL
+            return None, None
+        semi = string.find(url, ';', 0, comma)
+        if semi >= 0:
+            type = url[:semi]
+        else:
+            type = url[:comma]
+        if '=' in type or '/' not in type:
+            type = 'text/plain'
+        return type, None               # never compressed, so encoding is None
     base, ext = posixpath.splitext(url)
     while suffix_map.has_key(ext):
         base, ext = posixpath.splitext(base + suffix_map[ext])

Lib/rfc822.py

@@ -332,11 +332,11 @@ class Message:
         """
         raw = []
         for h in self.getallmatchingheaders(name):
-	    if h[0] in ' \t':
-	        raw.append(h)
-	    else:
-	        if raw:
-		    raw.append(', ')
+            if h[0] in ' \t':
+                raw.append(h)
+            else:
+                if raw:
+                    raw.append(', ')
                 i = string.find(h, ':')
                 if i > 0:
                     addr = h[i+1:]
@@ -786,7 +786,7 @@ def dump_address_pair(pair):
 
 _monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul',
                'aug', 'sep', 'oct', 'nov', 'dec',
-	       'january', 'february', 'march', 'april', 'may', 'june', 'july',
+               'january', 'february', 'march', 'april', 'may', 'june', 'july',
                'august', 'september', 'october', 'november', 'december']
 _daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
 
@@ -837,16 +837,16 @@ def parsedate_tz(data):
     mm = _monthnames.index(mm)+1
     if mm > 12: mm = mm - 12
     if dd[-1] == ',':
-	dd = dd[:-1]
+        dd = dd[:-1]
     i = string.find(yy, ':')
     if i > 0:
-	yy, tm = tm, yy
+        yy, tm = tm, yy
     if yy[-1] == ',':
-	yy = yy[:-1]
+        yy = yy[:-1]
     if yy[0] not in string.digits:
-	yy, tz = tz, yy
+        yy, tz = tz, yy
     if tm[-1] == ',':
-	tm = tm[:-1]
+        tm = tm[:-1]
     tm = string.splitfields(tm, ':')
     if len(tm) == 2:
         [thh, tmm] = tm

Lib/shelve.py

@@ -10,19 +10,19 @@ are ordinary strings.
 To summarize the interface (key is a string, data is an arbitrary
 object):
 
-	import shelve
-	d = shelve.open(filename) # open, with (g)dbm filename -- no suffix
+        import shelve
+        d = shelve.open(filename) # open, with (g)dbm filename -- no suffix
 
-	d[key] = data	# store data at key (overwrites old data if
-			# using an existing key)
-	data = d[key]	# retrieve data at key (raise KeyError if no
-			# such key)
-	del d[key]	# delete data stored at key (raises KeyError
-			# if no such key)
-	flag = d.has_key(key)	# true if the key exists
-	list = d.keys()	# a list of all existing keys (slow!)
+        d[key] = data   # store data at key (overwrites old data if
+                        # using an existing key)
+        data = d[key]   # retrieve data at key (raise KeyError if no
+                        # such key)
+        del d[key]      # delete data stored at key (raises KeyError
+                        # if no such key)
+        flag = d.has_key(key)   # true if the key exists
+        list = d.keys() # a list of all existing keys (slow!)
 
-	d.close()	# close it
+        d.close()       # close it
 
 Dependent on the implementation, closing a persistent dictionary may
 or may not be necessary to flush changes to disk.
@@ -31,127 +31,127 @@ or may not be necessary to flush changes to disk.
 # 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.
-	"""
-	
-	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)

Lib/stringold.py

@@ -199,10 +199,10 @@ def atof(s):
 
     """
     if type(s) == _StringType:
-	return _float(s)
+        return _float(s)
     else:
-	raise TypeError('argument 1: expected string, %s found' %
-			type(s).__name__)
+        raise TypeError('argument 1: expected string, %s found' %
+                        type(s).__name__)
 
 # Convert string to integer
 def atoi(*args):
@@ -217,18 +217,18 @@ def atoi(*args):
 
     """
     try:
-	s = args[0]
+        s = args[0]
     except IndexError:
-	raise TypeError('function requires at least 1 argument: %d given' %
-			len(args))
+        raise TypeError('function requires at least 1 argument: %d given' %
+                        len(args))
     # Don't catch type error resulting from too many arguments to int().  The
     # error message isn't compatible but the error type is, and this function
     # is complicated enough already.
     if type(s) == _StringType:
-	return _apply(_int, args)
+        return _apply(_int, args)
     else:
-	raise TypeError('argument 1: expected string, %s found' %
-			type(s).__name__)
+        raise TypeError('argument 1: expected string, %s found' %
+                        type(s).__name__)
 
 
 # Convert string to long integer
@@ -245,18 +245,18 @@ def atol(*args):
 
     """
     try:
-	s = args[0]
+        s = args[0]
     except IndexError:
-	raise TypeError('function requires at least 1 argument: %d given' %
-			len(args))
+        raise TypeError('function requires at least 1 argument: %d given' %
+                        len(args))
     # Don't catch type error resulting from too many arguments to long().  The
     # error message isn't compatible but the error type is, and this function
     # is complicated enough already.
     if type(s) == _StringType:
-	return _apply(_long, args)
+        return _apply(_long, args)
     else:
-	raise TypeError('argument 1: expected string, %s found' %
-			type(s).__name__)
+        raise TypeError('argument 1: expected string, %s found' %
+                        type(s).__name__)
 
 
 # Left-justify a string
@@ -298,8 +298,8 @@ def center(s, width):
     if n <= 0: return s
     half = n/2
     if n%2 and width%2:
-	# This ensures that center(center(s, i), j) = center(s, j)
-	half = half+1
+        # This ensures that center(center(s, i), j) = center(s, j)
+        half = half+1
     return ' '*half +  s + ' '*(n-half)
 
 # Zero-fill a number, e.g., (12, 3) --> '012' and (-3, 3) --> '-03'
@@ -318,7 +318,7 @@ def zfill(x, width):
     if n >= width: return s
     sign = ''
     if s[0] in ('-', '+'):
-	sign, s = s[0], s[1:]
+        sign, s = s[0], s[1:]
     return sign + '0'*(width-n) + s
 
 # Expand tabs in a string.
@@ -333,12 +333,12 @@ def expandtabs(s, tabsize=8):
     """
     res = line = ''
     for c in s:
-	if c == '\t':
-	    c = ' '*(tabsize - len(line) % tabsize)
-	line = line + c
-	if c == '\n':
-	    res = res + line
-	    line = ''
+        if c == '\t':
+            c = ' '*(tabsize - len(line) % tabsize)
+        line = line + c
+        if c == '\n':
+            res = res + line
+            line = ''
     return res + line
 
 # Character translation through look-up table.
@@ -387,14 +387,14 @@ def maketrans(fromstr, tostr):
 
     """
     if len(fromstr) != len(tostr):
-	raise ValueError, "maketrans arguments must have same length"
+        raise ValueError, "maketrans arguments must have same length"
     global _idmapL
     if not _idmapL:
-	_idmapL = map(None, _idmap)
+        _idmapL = map(None, _idmap)
     L = _idmapL[:]
     fromstr = map(ord, fromstr)
     for i in range(len(fromstr)):
-	L[fromstr[i]] = tostr[i]
+        L[fromstr[i]] = tostr[i]
     return joinfields(L, "")
 
 # Substring replacement (global)
@@ -428,4 +428,4 @@ try:
     from strop import maketrans, lowercase, uppercase, whitespace
     letters = lowercase + uppercase
 except ImportError:
-    pass					  # Use the original versions
+    pass                                          # Use the original versions

Lib/whichdb.py

@@ -56,7 +56,7 @@ def whichdb(filename):
 
     # BSD hash v2 has a 12-byte NULL pad in front of the file type
     try:
-	(magic,) = struct.unpack("=l", s16[-4:])
+        (magic,) = struct.unpack("=l", s16[-4:])
     except struct.error:
         return ""