Fix More trailing white space

Author: rowanvil

Doc/whatsnew/2.6.rst

@@ -307,8 +307,8 @@ The :mod:`threading` module's locks and condition variables  also support the
 The lock is acquired before the block is executed and always released once  the
 block is complete.
 
-The :func:`decimal.localcontext` function in the :mod:`decimal` module makes 
-it easy to save and restore the current decimal context, which encapsulates 
+The :func:`decimal.localcontext` function in the :mod:`decimal` module makes
+it easy to save and restore the current decimal context, which encapsulates
 the desired precision and rounding characteristics for computations::
 
    from decimal import Decimal, Context, localcontext
@@ -337,11 +337,11 @@ underlying implementation and should keep reading.
 A high-level explanation of the context management protocol is:
 
 * The expression is evaluated and should result in an object called a "context
-  manager".  The context manager must have :meth:`~object.__enter__` and 
+  manager".  The context manager must have :meth:`~object.__enter__` and
   :meth:`~object.__exit__` methods.
 
-* The context manager's :meth:`~object.__enter__` method is called.  The value 
-  returned is assigned to *VAR*.  If no ``as VAR`` clause is present, the 
+* The context manager's :meth:`~object.__enter__` method is called.  The value
+  returned is assigned to *VAR*.  If no ``as VAR`` clause is present, the
   value is simply discarded.
 
 * The code in *BLOCK* is executed.
@@ -431,14 +431,14 @@ The contextlib module
 The :mod:`contextlib` module provides some functions and a decorator that
 are useful when writing objects for use with the ':keyword:`with`' statement.
 
-The decorator is called :func:`~contextlib.contextmanager`, and lets you write 
-a single generator function instead of defining a new class.  The generator 
-should yield exactly one value.  The code up to the :keyword:`yield` will be 
-executed as the :meth:`~object.__enter__` method, and the value yielded will 
-be the method's return value that will get bound to the variable in the 
-':keyword:`with`' statement's :keyword:`!as` clause, if any.  The code after 
-the :keyword:`!yield` will be executed in the :meth:`~object.__exit__` method.  
-Any exception raised in the block will be raised by the :keyword:`!yield` 
+The decorator is called :func:`~contextlib.contextmanager`, and lets you write
+a single generator function instead of defining a new class.  The generator
+should yield exactly one value.  The code up to the :keyword:`yield` will be
+executed as the :meth:`~object.__enter__` method, and the value yielded will
+be the method's return value that will get bound to the variable in the
+':keyword:`with`' statement's :keyword:`!as` clause, if any.  The code after
+the :keyword:`!yield` will be executed in the :meth:`~object.__exit__` method.
+Any exception raised in the block will be raised by the :keyword:`!yield`
 statement.
 
 Using this decorator, our database example from the previous section
@@ -572,8 +572,8 @@ approach of the module is still similar.  The fundamental class
 is the :class:`~multiprocessing.Process`, which is passed a callable object and
 a collection of arguments.  The :meth:`~multiprocessing.Process.start` method
 sets the callable running in a subprocess, after which you can call
-the :meth:`~multiprocessing.Process.is_alive` method to check whether the 
-subprocess is still running and the :meth:`~multiprocessing.Process.join` 
+the :meth:`~multiprocessing.Process.is_alive` method to check whether the
+subprocess is still running and the :meth:`~multiprocessing.Process.join`
 method to wait for the process to exit.
 
 Here's a simple example where the subprocess will calculate a
@@ -621,14 +621,14 @@ the object to communicate.  (If the parent were to change the value of
 the global variable, the child's value would be unaffected, and vice
 versa.)
 
-Two other classes, :class:`~multiprocessing.pool.Pool` and 
-:class:`~multiprocessing.Manager`, provide higher-level interfaces.  
-:class:`~multiprocessing.pool.Pool` will create a fixed number of worker 
-processes, and requests can then be distributed to the workers by calling 
-:meth:`~multiprocessing.pool.Pool.apply` or 
-:meth:`~multiprocessing.pool.Pool.apply_async` to add a single request, and 
+Two other classes, :class:`~multiprocessing.pool.Pool` and
+:class:`~multiprocessing.Manager`, provide higher-level interfaces.
+:class:`~multiprocessing.pool.Pool` will create a fixed number of worker
+processes, and requests can then be distributed to the workers by calling
+:meth:`~multiprocessing.pool.Pool.apply` or
+:meth:`~multiprocessing.pool.Pool.apply_async` to add a single request, and
 :meth:`map` or :meth:`~multiprocessing.pool.Pool.map_async` to add a number of
-requests.  The following code uses a :class:`~multiprocessing.pool.Pool` to 
+requests.  The following code uses a :class:`~multiprocessing.pool.Pool` to
 spread requests across 5 worker processes and retrieve a list of results::
 
     from multiprocessing import Pool
@@ -650,17 +650,17 @@ This produces the following output::
     33452526613163807108170062053440751665152000000000
     ...
 
-The other high-level interface, the :class:`~multiprocessing.Manager` class, 
+The other high-level interface, the :class:`~multiprocessing.Manager` class,
 creates a separate server process that can hold master copies of Python data
 structures.  Other processes can then access and modify these data
 structures using proxy objects.  The following example creates a
 shared dictionary by calling the :meth:`dict` method; the worker
 processes then insert values into the dictionary.  (Locking is not
 done for you automatically, which doesn't matter in this example.
-:class:`~multiprocessing.Manager`'s methods also include 
-:meth:`~multiprocessing.managers.SyncManager.Lock`, 
+:class:`~multiprocessing.Manager`'s methods also include
+:meth:`~multiprocessing.managers.SyncManager.Lock`,
 :meth:`~multiprocessing.managers.SyncManager.RLock`,
-and :meth:`~multiprocessing.managers.SyncManager.Semaphore` to create 
+and :meth:`~multiprocessing.managers.SyncManager.Semaphore` to create
 shared locks.)
 
 ::
@@ -1036,21 +1036,21 @@ PEP 3116: New I/O Library
 
 Python's built-in file objects support a number of methods, but
 file-like objects don't necessarily support all of them.  Objects that
-imitate files usually support :meth:`~io.TextIOBase.read` and 
-:meth:`~io.TextIOBase.write`, but they may not support :meth:`readline`, 
-for example.  Python 3.0 introduces a layered I/O library in the :mod:`io` 
-module that separates buffering and text-handling features from the 
+imitate files usually support :meth:`~io.TextIOBase.read` and
+:meth:`~io.TextIOBase.write`, but they may not support :meth:`readline`,
+for example.  Python 3.0 introduces a layered I/O library in the :mod:`io`
+module that separates buffering and text-handling features from the
 fundamental read and write operations.
 
 There are three levels of abstract base classes provided by
 the :mod:`io` module:
 
 * :class:`~io.RawIOBase` defines raw I/O operations: :meth:`~io.RawIOBase.read`,
-  :meth:`~io.RawIOBase.readinto`, :meth:`~io.RawIOBase.write`, 
+  :meth:`~io.RawIOBase.readinto`, :meth:`~io.RawIOBase.write`,
   :meth:`~io.IOBase.seek`, :meth:`~io.IOBase.tell`, :meth:`~io.IOBase.truncate`,
    and :meth:`~io.IOBase.close`.
   Most of the methods of this class will often map to a single system call.
-  There are also :meth:`~io.IOBase.readable`, :meth:`~io.IOBase.writable`, 
+  There are also :meth:`~io.IOBase.readable`, :meth:`~io.IOBase.writable`,
   and :meth:`~io.IOBase.seekable` methods for determining what operations a
   given object will allow.
 
@@ -1062,7 +1062,7 @@ the :mod:`io` module:
   buffers data in memory to reduce the number of
   system calls used, making I/O processing more efficient.
   It supports all of the methods of :class:`~io.RawIOBase`,
-  and adds a :attr:`~io.BufferedIOBase.raw` attribute holding the underlying 
+  and adds a :attr:`~io.BufferedIOBase.raw` attribute holding the underlying
   raw object.
 
   There are five concrete classes implementing this ABC.