Review changes - Wrap at line 79 and don't ignore iter function

Author: rowanvil

Doc/whatsnew/2.6.rst

@@ -307,9 +307,9 @@ 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:`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::
+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,12 +337,12 @@ 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 :meth:`~object.__exit__`
-  methods.
+  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 value is simply
-  discarded.
+* 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,15 @@ 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` 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` 
+statement.
 
 Using this decorator, our database example from the previous section
 could be written as::
@@ -571,8 +572,9 @@ 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` method to wait for the process to exit.
+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
 factorial.  The function doing the calculation is written strangely so
@@ -619,13 +621,15 @@ 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 :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 spread requests
-across 5 worker processes and retrieve a list of results::
+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 
+spread requests across 5 worker processes and retrieve a list of results::
 
     from multiprocessing import Pool
 
@@ -646,15 +650,18 @@ This produces the following output::
     33452526613163807108170062053440751665152000000000
     ...
 
-The other high-level interface, the :class:`~multiprocessing.Manager` class, creates a
-separate server process that can hold master copies of Python data
+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`, :meth:`~multiprocessing.managers.SyncManager.RLock`,
-and :meth:`~multiprocessing.managers.SyncManager.Semaphore` to create shared locks.)
+: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 
+shared locks.)
 
 ::
 
@@ -824,7 +831,7 @@ documentation for a :ref:`complete list <formatstrings>`; here's a sample:
       format, followed by a percent sign.
 ===== ========================================================================
 
-Classes and types can define a :meth:`__format__` method to control how they're
+Classes and types can define a ``__format__`` method to control how they're
 formatted.  It receives a single argument, the format specifier::
 
    def __format__(self, format_spec):
@@ -834,7 +841,7 @@ formatted.  It receives a single argument, the format specifier::
            return str(self)
 
 There's also a :func:`format` builtin that will format a single
-value.  It calls the type's :meth:`__format__` method with the
+value.  It calls the type's ``__format__`` method with the
 provided specifier::
 
     >>> format(75.6564, '.2f')
@@ -1029,22 +1036,23 @@ 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 fundamental read and write
-operations.
+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.IOBase.seek`, :meth:`~io.IOBase.tell`, :meth:`~io.IOBase.truncate`,
-  and :meth:`~io.IOBase.close`.
+  :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`, and :meth:`~io.IOBase.seekable`
-  methods for determining what operations a given object will allow.
+  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.
 
   Python 3.0 has concrete implementations of this class for files and
   sockets, but Python 2.6 hasn't restructured its file and socket objects
@@ -1054,7 +1062,8 @@ 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 raw object.
+  and adds a :attr:`~io.BufferedIOBase.raw` attribute holding the underlying 
+  raw object.
 
   There are five concrete classes implementing this ABC.
   :class:`~io.BufferedWriter` and :class:`~io.BufferedReader` are for objects
@@ -1173,8 +1182,8 @@ dictionary-style access.  The phrase "dictionary-style" is vague, however.
 It probably means that accessing items with ``obj[1]`` works.
 Does it imply that setting items with ``obj[2] = value`` works?
 Or that the object will have :meth:`!keys`, :meth:`!values`, and :meth:`!items`
-methods?  What about the iterative variants  such as :meth:`!iterkeys`?  :meth:`!copy`
-and :meth:`!update`?  Iterating over the object with :func:`!iter`?
+methods?  What about the iterative variants  such as :meth:`!iterkeys`?  
+:meth:`!copy`and :meth:`!update`?  Iterating over the object with :func:`iter`?
 
 The Python 2.6 :mod:`collections` module includes a number of
 different ABCs that represent these distinctions.  :class:`Iterable`