Remove tabs from the documentation.

Doc/extending/newtypes.rst

@@ -840,8 +840,8 @@ As you can see, the source code closely resembles the :class:`Noddy` examples in
 previous sections. We will break down the main differences between them. ::
 
    typedef struct {
-   	PyListObject list;
+       PyListObject list;
-   	int state;
+       int state;
    } Shoddy;
 
 The primary difference for derived type objects is that the base type's object
@@ -854,10 +854,10 @@ be safely cast to both *PyListObject\** and *Shoddy\**. ::
    static int
    Shoddy_init(Shoddy *self, PyObject *args, PyObject *kwds)
    {
-   	if (PyList_Type.tp_init((PyObject *)self, args, kwds) < 0)
+       if (PyList_Type.tp_init((PyObject *)self, args, kwds) < 0)
-   		return -1;
+          return -1;
-   	self->state = 0;
+       self->state = 0;
-   	return 0;
+       return 0;
    }
 
 In the :attr:`__init__` method for our type, we can see how to call through to
@@ -876,18 +876,18 @@ the module's :cfunc:`init` function. ::
    PyMODINIT_FUNC
    initshoddy(void)
    {
-   	PyObject *m;
+       PyObject *m;
 
-   	ShoddyType.tp_base = &PyList_Type;
+       ShoddyType.tp_base = &PyList_Type;
-   	if (PyType_Ready(&ShoddyType) < 0)
+       if (PyType_Ready(&ShoddyType) < 0)
-   		return;
+           return;
 
-   	m = Py_InitModule3("shoddy", NULL, "Shoddy module");
+       m = Py_InitModule3("shoddy", NULL, "Shoddy module");
-   	if (m == NULL)
+       if (m == NULL)
-   		return;
+           return;
 
-   	Py_INCREF(&ShoddyType);
+       Py_INCREF(&ShoddyType);
-   	PyModule_AddObject(m, "Shoddy", (PyObject *) &ShoddyType);
+       PyModule_AddObject(m, "Shoddy", (PyObject *) &ShoddyType);
    }
 
 Before calling :cfunc:`PyType_Ready`, the type structure must have the
@@ -1167,7 +1167,7 @@ structure::
    typedef struct PyMethodDef {
        char        *ml_name;       /* method name */
        PyCFunction  ml_meth;       /* implementation function */
-       int	         ml_flags;      /* flags */
+       int          ml_flags;      /* flags */
        char        *ml_doc;        /* docstring */
    } PyMethodDef;
 

Doc/howto/curses.rst

@@ -297,7 +297,7 @@ So, to display a reverse-video status line on the top line of the screen, you
 could code::
 
    stdscr.addstr(0, 0, "Current mode: Typing mode",
-   	      curses.A_REVERSE)
+                 curses.A_REVERSE)
    stdscr.refresh()
 
 The curses library also supports color on those terminals that provide it, The

Doc/howto/regex.rst

@@ -917,7 +917,7 @@ module::
 
    InternalDate = re.compile(r'INTERNALDATE "'
            r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'
-   	r'(?P<year>[0-9][0-9][0-9][0-9])'
+           r'(?P<year>[0-9][0-9][0-9][0-9])'
            r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
            r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
            r'"')

Doc/howto/sockets.rst

@@ -190,33 +190,33 @@ length message::
        '''
 
        def __init__(self, sock=None):
-   	if sock is None:
+           if sock is None:
-   	    self.sock = socket.socket(
+               self.sock = socket.socket(
-   		socket.AF_INET, socket.SOCK_STREAM)
+                   socket.AF_INET, socket.SOCK_STREAM)
-   	else:
+           else:
-   	    self.sock = sock
+               self.sock = sock
 
        def connect(self, host, port):
-   	self.sock.connect((host, port))
+           self.sock.connect((host, port))
 
        def mysend(self, msg):
-   	totalsent = 0
+           totalsent = 0
-   	while totalsent < MSGLEN:
+           while totalsent < MSGLEN:
-   	    sent = self.sock.send(msg[totalsent:])
+               sent = self.sock.send(msg[totalsent:])
-   	    if sent == 0:
+               if sent == 0:
-   		raise RuntimeError, \
+                   raise RuntimeError, \
-   		    "socket connection broken"
+                       "socket connection broken"
-   	    totalsent = totalsent + sent
+               totalsent = totalsent + sent
 
        def myreceive(self):
-   	msg = ''
+           msg = ''
-   	while len(msg) < MSGLEN:
+           while len(msg) < MSGLEN:
-   	    chunk = self.sock.recv(MSGLEN-len(msg))
+               chunk = self.sock.recv(MSGLEN-len(msg))
-   	    if chunk == '':
+               if chunk == '':
-   		raise RuntimeError, \
+                   raise RuntimeError, \
-   		    "socket connection broken"
+                       "socket connection broken"
-   	    msg = msg + chunk
+               msg = msg + chunk
-   	return msg
+           return msg
 
 The sending code here is usable for almost any messaging scheme - in Python you
 send strings, and you can use ``len()`` to determine its length (even if it has

Doc/howto/unicode.rst

@@ -30,8 +30,8 @@ For a while people just wrote programs that didn't display accents.  I remember
 looking at Apple ][ BASIC programs, published in French-language publications in
 the mid-1980s, that had lines like these::
 
-	PRINT "FICHIER EST COMPLETE."
+   PRINT "FICHIER EST COMPLETE."
-	PRINT "CARACTERE NON ACCEPTE."
+   PRINT "CARACTERE NON ACCEPTE."
 
 Those messages should contain accents, and they just look wrong to someone who
 can read French.
@@ -89,11 +89,11 @@ standard, a code point is written using the notation U+12ca to mean the
 character with value 0x12ca (4810 decimal).  The Unicode standard contains a lot
 of tables listing characters and their corresponding code points::
 
-	0061    'a'; LATIN SMALL LETTER A
+   0061    'a'; LATIN SMALL LETTER A
-	0062    'b'; LATIN SMALL LETTER B
+   0062    'b'; LATIN SMALL LETTER B
-	0063    'c'; LATIN SMALL LETTER C
+   0063    'c'; LATIN SMALL LETTER C
-        ...
+   ...
-	007B	'{'; LEFT CURLY BRACKET
+   007B    '{'; LEFT CURLY BRACKET
 
 Strictly, these definitions imply that it's meaningless to say 'this is
 character U+12ca'.  U+12ca is a code point, which represents some particular
@@ -597,19 +597,19 @@ encoding and a list of Unicode strings will be returned, while passing an 8-bit
 path will return the 8-bit versions of the filenames.  For example, assuming the
 default filesystem encoding is UTF-8, running the following program::
 
-	fn = u'filename\u4500abc'
+   fn = u'filename\u4500abc'
-	f = open(fn, 'w')
+   f = open(fn, 'w')
-	f.close()
+   f.close()
 
-	import os
+   import os
-	print os.listdir('.')
+   print os.listdir('.')
-	print os.listdir(u'.')
+   print os.listdir(u'.')
 
 will produce the following output::
 
-	amk:~$ python t.py
+   amk:~$ python t.py
-	['.svn', 'filename\xe4\x94\x80abc', ...]
+   ['.svn', 'filename\xe4\x94\x80abc', ...]
-	[u'.svn', u'filename\u4500abc', ...]
+   [u'.svn', u'filename\u4500abc', ...]
 
 The first list contains UTF-8-encoded filenames, and the second list contains
 the Unicode versions.
@@ -703,26 +703,26 @@ Version 1.02: posted August 16 2005.  Corrects factual errors.
    - [ ] Unicode introduction
        - [ ] ASCII
        - [ ] Terms
-	   - [ ] Character
+           - [ ] Character
-	   - [ ] Code point
+           - [ ] Code point
-	 - [ ] Encodings
+         - [ ] Encodings
-	    - [ ] Common encodings: ASCII, Latin-1, UTF-8
+            - [ ] Common encodings: ASCII, Latin-1, UTF-8
        - [ ] Unicode Python type
-	   - [ ] Writing unicode literals
+           - [ ] Writing unicode literals
-	       - [ ] Obscurity: -U switch
+               - [ ] Obscurity: -U switch
-	   - [ ] Built-ins
+           - [ ] Built-ins
-	       - [ ] unichr()
+               - [ ] unichr()
-	       - [ ] ord()
+               - [ ] ord()
-	       - [ ] unicode() constructor
+               - [ ] unicode() constructor
-	   - [ ] Unicode type
+           - [ ] Unicode type
-	       - [ ] encode(), decode() methods
+               - [ ] encode(), decode() methods
        - [ ] Unicodedata module for character properties
        - [ ] I/O
-	   - [ ] Reading/writing Unicode data into files
+           - [ ] Reading/writing Unicode data into files
-	       - [ ] Byte-order marks
+               - [ ] Byte-order marks
-	   - [ ] Unicode filenames
+           - [ ] Unicode filenames
        - [ ] Writing Unicode programs
-	   - [ ] Do everything in Unicode
+           - [ ] Do everything in Unicode
-	   - [ ] Declaring source code encodings (PEP 263)
+           - [ ] Declaring source code encodings (PEP 263)
        - [ ] Other issues
-	   - [ ] Building Python (UCS2, UCS4)
+           - [ ] Building Python (UCS2, UCS4)

Doc/library/abc.rst

@@ -43,15 +43,15 @@ This module provides the following class:
       Register *subclass* as a "virtual subclass" of this ABC. For
       example::
 
-	from abc import ABCMeta
+        from abc import ABCMeta
 
-	class MyABC:
+        class MyABC:
-	    __metaclass__ = ABCMeta
+            __metaclass__ = ABCMeta
 
-	MyABC.register(tuple)
+        MyABC.register(tuple)
 
-	assert issubclass(tuple, MyABC)
+        assert issubclass(tuple, MyABC)
-	assert isinstance((), MyABC)
+        assert isinstance((), MyABC)
 
    You can also override this method in an abstract base class:
 

Doc/library/collections.rst

@@ -53,7 +53,7 @@ ABC                        Inherits               Abstract Methods        Mixin
 :class:`Hashable`                                 ``__hash__``
 :class:`Iterable`                                 ``__iter__``
 :class:`Iterator`          :class:`Iterable`      ``__next__``            ``__iter__``
-:class:`Sized`          			  ``__len__``
+:class:`Sized`                                    ``__len__``
 :class:`Callable`                                 ``__call__``
 
 :class:`Sequence`          :class:`Sized`,        ``__getitem__``         ``__contains__``. ``__iter__``, ``__reversed__``.
@@ -80,7 +80,7 @@ ABC                        Inherits               Abstract Methods        Mixin
 :class:`MutableMapping`    :class:`Mapping`       ``__getitem__``         Inherited Mapping methods and
                                                   ``__setitem__``,        ``pop``, ``popitem``, ``clear``, ``update``,
                                                   ``__delitem__``,        and ``setdefault``
-						  ``__iter__``, and
+                                                  ``__iter__``, and
                                                   ``__len__``
 
 :class:`MappingView`       :class:`Sized`                                 ``__len__``
@@ -96,7 +96,7 @@ particular functionality, for example::
 
     size = None
     if isinstance(myvar, collections.Sized):
-	size = len(myvar)
+        size = len(myvar)
 
 Several of the ABCs are also useful as mixins that make it easier to develop
 classes supporting container APIs.  For example, to write a class supporting

Doc/library/gettext.rst

@@ -648,10 +648,9 @@ translation until later.  A classic example is::
 
    animals = ['mollusk',
               'albatross',
-   	   'rat',
+              'rat',
-   	   'penguin',
+              'penguin',
-   	   'python',
+              'python', ]
-   	   ]
    # ...
    for a in animals:
        print a
@@ -666,10 +665,9 @@ Here is one way you can handle this situation::
 
    animals = [_('mollusk'),
               _('albatross'),
-   	   _('rat'),
+              _('rat'),
-   	   _('penguin'),
+              _('penguin'),
-   	   _('python'),
+              _('python'), ]
-   	   ]
 
    del _
 
@@ -692,10 +690,9 @@ Another way to handle this is with the following example::
 
    animals = [N_('mollusk'),
               N_('albatross'),
-   	   N_('rat'),
+              N_('rat'),
-   	   N_('penguin'),
+              N_('penguin'),
-   	   N_('python'),
+              N_('python'), ]
-   	   ]
 
    # ...
    for a in animals:

Doc/library/multiprocessing.rst

@@ -37,7 +37,7 @@ Windows.
         >>> from multiprocessing import Pool
         >>> p = Pool(5)
         >>> def f(x):
-        ... 	return x*x
+        ...     return x*x
         ...
         >>> p.map(f, [1,2,3])
         Process PoolWorker-1:

Doc/library/optparse.rst

@@ -548,8 +548,8 @@ Continuing with the parser defined above, adding an
 :class:`OptionGroup` to a parser is easy::
 
     group = OptionGroup(parser, "Dangerous Options",
-			"Caution: use these options at your own risk.  "
+                        "Caution: use these options at your own risk.  "
-			"It is believed that some of them bite.")
+                        "It is believed that some of them bite.")
     group.add_option("-g", action="store_true", help="Group option.")
     parser.add_option_group(group)
 
@@ -563,12 +563,12 @@ This would result in the following help output::
       -q, --quiet          be vewwy quiet (I'm hunting wabbits)
       -fFILE, --file=FILE  write output to FILE
       -mMODE, --mode=MODE  interaction mode: one of 'novice', 'intermediate'
-			   [default], 'expert'
+                           [default], 'expert'
 
       Dangerous Options:
-	Caution: use of these options is at your own risk.  It is believed that
+      Caution: use of these options is at your own risk.  It is believed that
-	some of them bite.
+      some of them bite.
-	-g                 Group option.
+      -g                 Group option.
 
 .. _optparse-printing-version-string:
 

Doc/library/sched.rst

@@ -58,7 +58,7 @@ Example::
     ...     print time.time()
     ...     Timer(5, print_time, ()).start()
     ...     Timer(10, print_time, ()).start()
-    ...     time.sleep(11)	# sleep while time-delay events execute
+    ...     time.sleep(11)  # sleep while time-delay events execute
     ...     print time.time()
     ...
     >>> print_some_times()

Doc/library/socket.rst

@@ -852,20 +852,21 @@ sends traffic to the first one connected successfully. ::
    HOST = None               # Symbolic name meaning all available interfaces
    PORT = 50007              # Arbitrary non-privileged port
    s = None
-   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
+   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
+                                 socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
        af, socktype, proto, canonname, sa = res
        try:
-   	s = socket.socket(af, socktype, proto)
+           s = socket.socket(af, socktype, proto)
        except socket.error, msg:
-   	s = None
+           s = None
-   	continue
+           continue
        try:
-   	s.bind(sa)
+           s.bind(sa)
-   	s.listen(1)
+           s.listen(1)
        except socket.error, msg:
-   	s.close()
+           s.close()
-   	s = None
+           s = None
-   	continue
+           continue
        break
    if s is None:
        print 'could not open socket'
@@ -890,16 +891,16 @@ sends traffic to the first one connected successfully. ::
    for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
        af, socktype, proto, canonname, sa = res
        try:
-   	s = socket.socket(af, socktype, proto)
+           s = socket.socket(af, socktype, proto)
        except socket.error, msg:
-   	s = None
+           s = None
-   	continue
+           continue
        try:
-   	s.connect(sa)
+           s.connect(sa)
        except socket.error, msg:
-   	s.close()
+           s.close()
-   	s = None
+           s = None
-   	continue
+           continue
        break
    if s is None:
        print 'could not open socket'

Doc/library/xmlrpclib.rst

@@ -560,8 +560,8 @@ transport.  The following example shows how:
            self.proxy = proxy
        def make_connection(self, host):
            self.realhost = host
-   	h = httplib.HTTP(self.proxy)
+           h = httplib.HTTP(self.proxy)
-   	return h
+           return h
        def send_request(self, connection, handler, request_body):
            connection.putrequest("POST", 'http://%s%s' % (self.realhost, handler))
        def send_host(self, connection, host):

Doc/license.rst

@@ -453,7 +453,7 @@ The source code for the :mod:`md5` module contains the following notice::
 
      This code implements the MD5 Algorithm defined in RFC 1321, whose
      text is available at
-   	http://www.ietf.org/rfc/rfc1321.txt
+           http://www.ietf.org/rfc/rfc1321.txt
      The code is derived from the text of the RFC, including the test suite
      (section A.5) but excluding the rest of Appendix A.  It does not include
      any code or documentation that is identified in the RFC as being
@@ -464,12 +464,12 @@ The source code for the :mod:`md5` module contains the following notice::
      that follows (in reverse chronological order):
 
      2002-04-13 lpd Removed support for non-ANSI compilers; removed
-   	references to Ghostscript; clarified derivation from RFC 1321;
+           references to Ghostscript; clarified derivation from RFC 1321;
-   	now handles byte order either statically or dynamically.
+           now handles byte order either statically or dynamically.
      1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
      1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
-   	added conditionalization for C++ compilation from Martin
+           added conditionalization for C++ compilation from Martin
-   	Purschke <purschke@bnl.gov>.
+           Purschke <purschke@bnl.gov>.
      1999-05-03 lpd Original version.
 
 

Doc/tutorial/datastructures.rst

@@ -251,7 +251,7 @@ would evaluate to a tuple, it must be parenthesized. ::
    []
    >>> [[x,x**2] for x in vec]
    [[2, 4], [4, 16], [6, 36]]
-   >>> [x, x**2 for x in vec]	# error - parens required for tuples
+   >>> [x, x**2 for x in vec]  # error - parens required for tuples
      File "<stdin>", line 1, in ?
        [x, x**2 for x in vec]
                   ^

Doc/tutorial/stdlib2.rst

@@ -62,7 +62,7 @@ formatting numbers with group separators::
    >>> locale.format("%d", x, grouping=True)
    '1,234,567'
    >>> locale.format("%s%.*f", (conv['currency_symbol'],
-   ...	      conv['frac_digits'], x), grouping=True)
+   ...               conv['frac_digits'], x), grouping=True)
    '$1,234,567.80'
 
 

Doc/whatsnew/2.0.rst

@@ -281,7 +281,7 @@ write the following to do it::
    # containing the substring S.
    sublist = filter( lambda s, substring=S:
                         string.find(s, substring) != -1,
-   	          L)
+                     L)
 
 Because of Python's scoping rules, a default argument is used so that the
 anonymous function created by the :keyword:`lambda` statement knows what
@@ -293,7 +293,7 @@ List comprehensions have the form::
 
    [ expression for expr in sequence1
                 for expr2 in sequence2 ...
-   	     for exprN in sequenceN
+                for exprN in sequenceN
                 if condition ]
 
 The :keyword:`for`...\ :keyword:`in` clauses contain the sequences to be
@@ -368,7 +368,7 @@ instance with an incremented value.
        def __init__(self, value):
            self.value = value
        def __iadd__(self, increment):
-   	return Number( self.value + increment)
+           return Number( self.value + increment)
 
    n = Number(5)
    n += 3
@@ -852,13 +852,12 @@ the PyXML package::
    from distutils.core import setup, Extension
 
    expat_extension = Extension('xml.parsers.pyexpat',
-   	define_macros = [('XML_NS', None)],
+        define_macros = [('XML_NS', None)],
-   	include_dirs = [ 'extensions/expat/xmltok',
+        include_dirs = [ 'extensions/expat/xmltok',
-   	                 'extensions/expat/xmlparse' ],
+                         'extensions/expat/xmlparse' ],
-   	sources = [ 'extensions/pyexpat.c',
+        sources = [ 'extensions/pyexpat.c',
-   	            'extensions/expat/xmltok/xmltok.c',
+                    'extensions/expat/xmltok/xmltok.c',
-    		    'extensions/expat/xmltok/xmlrole.c',
+                    'extensions/expat/xmltok/xmlrole.c', ]
-                     ]
           )
    setup (name = "PyXML", version = "0.5.4",
           ext_modules =[ expat_extension ] )

Doc/whatsnew/2.2.rst

@@ -295,7 +295,7 @@ will be used in methods to call a method in the superclass; for example,
 
    class D (B,C):
        def save (self):
-   	# Call superclass .save()
+           # Call superclass .save()
            super(D, self).save()
            # Save D's private information here
            ...

Doc/whatsnew/2.4.rst

@@ -396,10 +396,10 @@ single class called :class:`Popen`  whose constructor supports a number of
 different keyword arguments. ::
 
    class Popen(args, bufsize=0, executable=None,
-   	    stdin=None, stdout=None, stderr=None,
+               stdin=None, stdout=None, stderr=None,
-   	    preexec_fn=None, close_fds=False, shell=False,
+               preexec_fn=None, close_fds=False, shell=False,
-   	    cwd=None, env=None, universal_newlines=False,
+               cwd=None, env=None, universal_newlines=False,
-   	    startupinfo=None, creationflags=0):
+               startupinfo=None, creationflags=0):
 
 *args* is commonly a sequence of strings that will be the arguments to the
 program executed as the subprocess.  (If the *shell* argument is true, *args*

Doc/whatsnew/2.6.rst

@@ -586,30 +586,30 @@ multiple of 4.
 
 
     def factorial(queue, N):
-	"Compute a factorial."
+        "Compute a factorial."
-	# If N is a multiple of 4, this function will take much longer.
+        # If N is a multiple of 4, this function will take much longer.
-	if (N % 4) == 0:
+        if (N % 4) == 0:
-	    time.sleep(.05 * N/4)
+            time.sleep(.05 * N/4)
 
-	# Calculate the result
+        # Calculate the result
-	fact = 1L
+        fact = 1L
-	for i in range(1, N+1):
+        for i in range(1, N+1):
-	    fact = fact * i
+            fact = fact * i
 
-	# Put the result on the queue
+        # Put the result on the queue
-	queue.put(fact)
+        queue.put(fact)
 
     if __name__ == '__main__':
-	queue = Queue()
+        queue = Queue()
 
-	N = 5
+        N = 5
 
-	p = Process(target=factorial, args=(queue, N))
+        p = Process(target=factorial, args=(queue, N))
-	p.start()
+        p.start()
-	p.join()
+        p.join()
 
-	result = queue.get()
+        result = queue.get()
-	print 'Factorial', N, '=', result
+        print 'Factorial', N, '=', result
 
 A :class:`Queue` is used to communicate the input parameter *N* and
 the result.  The :class:`Queue` object is stored in a global variable.
@@ -630,12 +630,12 @@ across 5 worker processes and retrieve a list of results::
     from multiprocessing import Pool
 
     def factorial(N, dictionary):
-	"Compute a factorial."
+        "Compute a factorial."
-	...
+        ...
     p = Pool(5)
     result = p.map(factorial, range(1, 1000, 10))
     for v in result:
-	print v
+        print v
 
 This produces the following output::
 
@@ -1885,9 +1885,9 @@ changes, or look through the Subversion logs for all the details.
      ('id', 'name', 'type', 'size')
 
      >>> var = var_type(1, 'frequency', 'int', 4)
-     >>> print var[0], var.id		# Equivalent
+     >>> print var[0], var.id    # Equivalent
      1 1
-     >>> print var[2], var.type          # Equivalent
+     >>> print var[2], var.type  # Equivalent
      int int
      >>> var._asdict()
      {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
@@ -2046,8 +2046,8 @@ changes, or look through the Subversion logs for all the details.
 
      >>> list(itertools.product([1,2,3], [4,5,6]))
      [(1, 4), (1, 5), (1, 6),
-	  (2, 4), (2, 5), (2, 6),
+      (2, 4), (2, 5), (2, 6),
-	  (3, 4), (3, 5), (3, 6)]
+      (3, 4), (3, 5), (3, 6)]
 
   The optional *repeat* keyword argument is used for taking the
   product of an iterable or a set of iterables with themselves,