Sat Mar 22 23:04:11 CET 2008

Author: georg.brandl
Date: Sat Mar 22 23:04:10 2008
New Revision: 61769

Modified:
   python/trunk/Doc/library/base64.rst
   python/trunk/Doc/library/bisect.rst
   python/trunk/Doc/library/cookie.rst
   python/trunk/Doc/library/difflib.rst
   python/trunk/Doc/library/fnmatch.rst
   python/trunk/Doc/library/fractions.rst
   python/trunk/Doc/library/functools.rst
   python/trunk/Doc/library/getopt.rst
   python/trunk/Doc/library/hashlib.rst
   python/trunk/Doc/library/heapq.rst
   python/trunk/Doc/library/itertools.rst
   python/trunk/Doc/library/md5.rst
   python/trunk/Doc/library/sched.rst
   python/trunk/Doc/library/sets.rst
   python/trunk/Doc/library/stdtypes.rst
   python/trunk/Doc/library/string.rst
   python/trunk/Doc/library/time.rst
   python/trunk/Doc/library/unicodedata.rst
   python/trunk/Doc/library/urlparse.rst
   python/trunk/Doc/library/weakref.rst
Log:
Enable doctest running for several other documents.
We have now over 640 doctests that are run with "make doctest".


Modified: python/trunk/Doc/library/base64.rst
==============================================================================

--- python/trunk/Doc/library/base64.rst	(original)
+++ python/trunk/Doc/library/base64.rst	Sat Mar 22 23:04:10 2008
@@ -150,7 +150,7 @@
    :func:`encodestring` returns a string containing one or more lines of
    base64-encoded data always including an extra trailing newline (``'\n'``).
 
-An example usage of the module::
+An example usage of the module:
 
    >>> import base64
    >>> encoded = base64.b64encode('data to be encoded')

Modified: python/trunk/Doc/library/bisect.rst
==============================================================================
--- python/trunk/Doc/library/bisect.rst	(original)
+++ python/trunk/Doc/library/bisect.rst	Sat Mar 22 23:04:10 2008
@@ -72,7 +72,7 @@
 The :func:`bisect` function is generally useful for categorizing numeric data.
 This example uses :func:`bisect` to look up a letter grade for an exam total
 (say) based on a set of ordered numeric breakpoints: 85 and up is an 'A', 75..84
-is a 'B', etc. ::
+is a 'B', etc.
 
    >>> grades = "FEDCBA"
    >>> breakpoints = [30, 44, 66, 75, 85]

Modified: python/trunk/Doc/library/cookie.rst
==============================================================================
--- python/trunk/Doc/library/cookie.rst	(original)
+++ python/trunk/Doc/library/cookie.rst	Sat Mar 22 23:04:10 2008
@@ -210,7 +210,10 @@
 Example
 -------
 
-The following example demonstrates how to use the :mod:`Cookie` module. ::
+The following example demonstrates how to use the :mod:`Cookie` module.
+
+.. doctest::
+   :options: +NORMALIZE_WHITESPACE
 
    >>> import Cookie
    >>> C = Cookie.SimpleCookie()
@@ -219,11 +222,11 @@
    >>> C["fig"] = "newton"
    >>> C["sugar"] = "wafer"
    >>> print C # generate HTTP headers
-   Set-Cookie: sugar=wafer
    Set-Cookie: fig=newton
-   >>> print C.output() # same thing
    Set-Cookie: sugar=wafer
+   >>> print C.output() # same thing
    Set-Cookie: fig=newton
+   Set-Cookie: sugar=wafer
    >>> C = Cookie.SmartCookie()
    >>> C["rocky"] = "road"
    >>> C["rocky"]["path"] = "/cookie"
@@ -234,8 +237,8 @@
    >>> C = Cookie.SmartCookie()
    >>> C.load("chips=ahoy; vienna=finger") # load from a string (HTTP header)
    >>> print C
-   Set-Cookie: vienna=finger
    Set-Cookie: chips=ahoy
+   Set-Cookie: vienna=finger
    >>> C = Cookie.SmartCookie()
    >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
    >>> print C

Modified: python/trunk/Doc/library/difflib.rst
==============================================================================
--- python/trunk/Doc/library/difflib.rst	(original)
+++ python/trunk/Doc/library/difflib.rst	Sat Mar 22 23:04:10 2008
@@ -1,4 +1,3 @@
-
 :mod:`difflib` --- Helpers for computing deltas
 ===============================================
 
@@ -8,7 +7,10 @@
 .. sectionauthor:: Tim Peters <tim_one at users.sourceforge.net>
 .. Markup by Fred L. Drake, Jr. <fdrake at acm.org>
 
+.. testsetup::
 
+   import sys
+   from difflib import *
 
 .. versionadded:: 2.1
 
@@ -148,12 +150,10 @@
    expressed in the format returned by :func:`time.ctime`.  If not specified, the
    strings default to blanks.
 
-   ::
-
       >>> s1 = ['bacon\n', 'eggs\n', 'ham\n', 'guido\n']
       >>> s2 = ['python\n', 'eggy\n', 'hamster\n', 'guido\n']
       >>> for line in context_diff(s1, s2, fromfile='before.py', tofile='after.py'):
-      ...     sys.stdout.write(line)
+      ...     sys.stdout.write(line)  # doctest: +NORMALIZE_WHITESPACE
       *** before.py
       --- after.py
       ***************
@@ -186,7 +186,7 @@
    Possibilities that don't score at least that similar to *word* are ignored.
 
    The best (no more than *n*) matches among the possibilities are returned in a
-   list, sorted by similarity score, most similar first. ::
+   list, sorted by similarity score, most similar first.
 
       >>> get_close_matches('appel', ['ape', 'apple', 'peach', 'puppy'])
       ['apple', 'ape']
@@ -221,7 +221,7 @@
    function :func:`IS_CHARACTER_JUNK`, which filters out whitespace characters (a
    blank or tab; note: bad idea to include newline in this!).
 
-   :file:`Tools/scripts/ndiff.py` is a command-line front-end to this function. ::
+   :file:`Tools/scripts/ndiff.py` is a command-line front-end to this function.
 
       >>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
       ...              'ore\ntree\nemu\n'.splitlines(1))
@@ -245,7 +245,7 @@
    lines originating from file 1 or 2 (parameter *which*), stripping off line
    prefixes.
 
-   Example::
+   Example:
 
       >>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
       ...              'ore\ntree\nemu\n'.splitlines(1))
@@ -285,13 +285,10 @@
    expressed in the format returned by :func:`time.ctime`.  If not specified, the
    strings default to blanks.
 
-   ::
-
-
       >>> s1 = ['bacon\n', 'eggs\n', 'ham\n', 'guido\n']
       >>> s2 = ['python\n', 'eggy\n', 'hamster\n', 'guido\n']
       >>> for line in unified_diff(s1, s2, fromfile='before.py', tofile='after.py'):
-      ...     sys.stdout.write(line)
+      ...     sys.stdout.write(line)   # doctest: +NORMALIZE_WHITESPACE
       --- before.py
       +++ after.py
       @@ -1,4 +1,4 @@
@@ -388,11 +385,11 @@
    conditions, the additional conditions ``k >= k'``, ``i <= i'``, and if ``i ==
    i'``, ``j <= j'`` are also met. In other words, of all maximal matching blocks,
    return one that starts earliest in *a*, and of all those maximal matching blocks
-   that start earliest in *a*, return the one that starts earliest in *b*. ::
+   that start earliest in *a*, return the one that starts earliest in *b*.
 
       >>> s = SequenceMatcher(None, " abcd", "abcd abcd")
       >>> s.find_longest_match(0, 5, 0, 9)
-      (0, 4, 5)
+      Match(a=0, b=4, size=5)
 
    If *isjunk* was provided, first the longest matching block is determined as
    above, but with the additional restriction that no junk element appears in the
@@ -403,11 +400,11 @@
    Here's the same example as before, but considering blanks to be junk. That
    prevents ``' abcd'`` from matching the ``' abcd'`` at the tail end of the second
    sequence directly.  Instead only the ``'abcd'`` can match, and matches the
-   leftmost ``'abcd'`` in the second sequence::
+   leftmost ``'abcd'`` in the second sequence:
 
       >>> s = SequenceMatcher(lambda x: x==" ", " abcd", "abcd abcd")
       >>> s.find_longest_match(0, 5, 0, 9)
-      (1, 0, 4)
+      Match(a=1, b=0, size=4)
 
    If no blocks match, this returns ``(alo, blo, 0)``.
 
@@ -433,11 +430,11 @@
       The guarantee that adjacent triples always describe non-adjacent blocks was
       implemented.
 
-   ::
+   .. doctest::
 
       >>> s = SequenceMatcher(None, "abxcd", "abcd")
       >>> s.get_matching_blocks()
-      [(0, 0, 2), (3, 2, 2), (5, 4, 0)]
+      [Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]
 
 
 .. method:: SequenceMatcher.get_opcodes()
@@ -466,7 +463,7 @@
    |               | are equal).                                 |
    +---------------+---------------------------------------------+
 
-   For example::
+   For example:
 
       >>> a = "qabxcd"
       >>> b = "abycdf"
@@ -524,7 +521,7 @@
 The three methods that return the ratio of matching to total characters can give
 different results due to differing levels of approximation, although
 :meth:`quick_ratio` and :meth:`real_quick_ratio` are always at least as large as
-:meth:`ratio`::
+:meth:`ratio`:
 
    >>> s = SequenceMatcher(None, "abcd", "bcde")
    >>> s.ratio()
@@ -540,7 +537,7 @@
 SequenceMatcher Examples
 ------------------------
 
-This example compares two strings, considering blanks to be "junk:" ::
+This example compares two strings, considering blanks to be "junk:"
 
    >>> s = SequenceMatcher(lambda x: x == " ",
    ...                     "private Thread currentThread;",
@@ -548,19 +545,18 @@
 
 :meth:`ratio` returns a float in [0, 1], measuring the similarity of the
 sequences.  As a rule of thumb, a :meth:`ratio` value over 0.6 means the
-sequences are close matches::
+sequences are close matches:
 
    >>> print round(s.ratio(), 3)
    0.866
 
 If you're only interested in where the sequences match,
-:meth:`get_matching_blocks` is handy::
+:meth:`get_matching_blocks` is handy:
 
    >>> for block in s.get_matching_blocks():
    ...     print "a[%d] and b[%d] match for %d elements" % block
    a[0] and b[0] match for 8 elements
-   a[8] and b[17] match for 6 elements
-   a[14] and b[23] match for 15 elements
+   a[8] and b[17] match for 21 elements
    a[29] and b[38] match for 0 elements
 
 Note that the last tuple returned by :meth:`get_matching_blocks` is always a
@@ -568,14 +564,13 @@
 tuple element (number of elements matched) is ``0``.
 
 If you want to know how to change the first sequence into the second, use
-:meth:`get_opcodes`::
+:meth:`get_opcodes`:
 
    >>> for opcode in s.get_opcodes():
    ...     print "%6s a[%d:%d] b[%d:%d]" % opcode
     equal a[0:8] b[0:8]
    insert a[8:8] b[8:17]
-    equal a[8:14] b[17:23]
-    equal a[14:29] b[23:38]
+    equal a[8:29] b[17:38]
 
 See also the function :func:`get_close_matches` in this module, which shows how
 simple code building on :class:`SequenceMatcher` can be used to do useful work.
@@ -628,7 +623,7 @@
 
 This example compares two texts. First we set up the texts, sequences of
 individual single-line strings ending with newlines (such sequences can also be
-obtained from the :meth:`readlines` method of file-like objects)::
+obtained from the :meth:`readlines` method of file-like objects):
 
    >>> text1 = '''  1. Beautiful is better than ugly.
    ...   2. Explicit is better than implicit.
@@ -645,7 +640,7 @@
    ...   5. Flat is better than nested.
    ... '''.splitlines(1)
 
-Next we instantiate a Differ object::
+Next we instantiate a Differ object:
 
    >>> d = Differ()
 
@@ -653,11 +648,11 @@
 filter out line and character "junk."  See the :meth:`Differ` constructor for
 details.
 
-Finally, we compare the two::
+Finally, we compare the two:
 
    >>> result = list(d.compare(text1, text2))
 
-``result`` is a list of strings, so let's pretty-print it::
+``result`` is a list of strings, so let's pretty-print it:
 
    >>> from pprint import pprint
    >>> pprint(result)
@@ -665,14 +660,14 @@
     '-   2. Explicit is better than implicit.\n',
     '-   3. Simple is better than complex.\n',
     '+   3.   Simple is better than complex.\n',
-    '?     ++                                \n',
+    '?     ++\n',
     '-   4. Complex is better than complicated.\n',
-    '?            ^                     ---- ^  \n',
+    '?            ^                     ---- ^\n',
     '+   4. Complicated is better than complex.\n',
-    '?           ++++ ^                      ^  \n',
+    '?           ++++ ^                      ^\n',
     '+   5. Flat is better than nested.\n']
 
-As a single multi-line string it looks like this::
+As a single multi-line string it looks like this:
 
    >>> import sys
    >>> sys.stdout.writelines(result)
@@ -697,7 +692,7 @@
 It is also contained in the Python source distribution, as
 :file:`Tools/scripts/diff.py`.
 
-::
+.. testcode::
 
    """ Command line interface to difflib.py providing diffs in four formats:
 

Modified: python/trunk/Doc/library/fnmatch.rst
==============================================================================
--- python/trunk/Doc/library/fnmatch.rst	(original)
+++ python/trunk/Doc/library/fnmatch.rst	Sat Mar 22 23:04:10 2008
@@ -72,7 +72,7 @@
 
    Return the shell-style *pattern* converted to a regular expression.
 
-   Example::
+   Example:
 
       >>> import fnmatch, re
       >>>

Modified: python/trunk/Doc/library/fractions.rst
==============================================================================
--- python/trunk/Doc/library/fractions.rst	(original)
+++ python/trunk/Doc/library/fractions.rst	Sat Mar 22 23:04:10 2008
@@ -50,18 +50,19 @@
 
    Finds and returns the closest :class:`Fraction` to ``self`` that
    has denominator at most max_denominator.  This method is useful for
-   finding rational approximations to a given floating-point number::
+   finding rational approximations to a given floating-point number:
 
+      >>> from fractions import Fraction
       >>> Fraction('3.1415926535897932').limit_denominator(1000)
-      Fraction(355, 113)
+      Fraction(355L, 113L)
 
-   or for recovering a rational number that's represented as a float::
+   or for recovering a rational number that's represented as a float:
 
       >>> from math import pi, cos
       >>> Fraction.from_float(cos(pi/3))
       Fraction(4503599627370497L, 9007199254740992L)
       >>> Fraction.from_float(cos(pi/3)).limit_denominator()
-      Fraction(1, 2)
+      Fraction(1L, 2L)
 
 
 .. method:: Fraction.__floor__()
@@ -90,4 +91,3 @@
 
    Module :mod:`numbers`
       The abstract base classes making up the numeric tower.
-

Modified: python/trunk/Doc/library/functools.rst
==============================================================================
--- python/trunk/Doc/library/functools.rst	(original)
+++ python/trunk/Doc/library/functools.rst	Sat Mar 22 23:04:10 2008
@@ -48,8 +48,9 @@
    some portion of a function's arguments and/or keywords resulting in a new object
    with a simplified signature.  For example, :func:`partial` can be used to create
    a callable that behaves like the :func:`int` function where the *base* argument
-   defaults to two::
+   defaults to two:
 
+      >>> from functools import partial
       >>> basetwo = partial(int, base=2)
       >>> basetwo.__doc__ = 'Convert base 2 string to an int.'
       >>> basetwo('10010')
@@ -79,8 +80,9 @@
 
    This is a convenience function for invoking ``partial(update_wrapper,
    wrapped=wrapped, assigned=assigned, updated=updated)`` as a function decorator
-   when defining a wrapper function. For example::
+   when defining a wrapper function. For example:
 
+      >>> from functools import wraps
       >>> def my_decorator(f):
       ...     @wraps(f)
       ...     def wrapper(*args, **kwds):

Modified: python/trunk/Doc/library/getopt.rst
==============================================================================
--- python/trunk/Doc/library/getopt.rst	(original)
+++ python/trunk/Doc/library/getopt.rst	Sat Mar 22 23:04:10 2008
@@ -82,7 +82,7 @@
 
    Alias for :exc:`GetoptError`; for backward compatibility.
 
-An example using only Unix style options::
+An example using only Unix style options:
 
    >>> import getopt
    >>> args = '-a -b -cfoo -d bar a1 a2'.split()
@@ -94,7 +94,7 @@
    >>> args
    ['a1', 'a2']
 
-Using long option names is equally easy::
+Using long option names is equally easy:
 
    >>> s = '--condition=foo --testing --output-file abc.def -x a1 a2'
    >>> args = s.split()
@@ -103,8 +103,7 @@
    >>> optlist, args = getopt.getopt(args, 'x', [
    ...     'condition=', 'output-file=', 'testing'])
    >>> optlist
-   [('--condition', 'foo'), ('--testing', ''), ('--output-file', 'abc.def'), ('-x',
-    '')]
+   [('--condition', 'foo'), ('--testing', ''), ('--output-file', 'abc.def'), ('-x', '')]
    >>> args
    ['a1', 'a2']
 

Modified: python/trunk/Doc/library/hashlib.rst
==============================================================================
--- python/trunk/Doc/library/hashlib.rst	(original)
+++ python/trunk/Doc/library/hashlib.rst	Sat Mar 22 23:04:10 2008
@@ -44,7 +44,7 @@
 OpenSSL library that Python uses on your platform.
 
 For example, to obtain the digest of the string ``'Nobody inspects the spammish
-repetition'``::
+repetition'``:
 
    >>> import hashlib
    >>> m = hashlib.md5()
@@ -57,7 +57,7 @@
    >>> m.block_size
    64
 
-More condensed::
+More condensed:
 
    >>> hashlib.sha224("Nobody inspects the spammish repetition").hexdigest()
    'a4337bc45a8fc544c03f52dc550cd6e1e87021bc896588bd79e901e2'
@@ -67,7 +67,7 @@
 hashes as well as any other algorithms that your OpenSSL library may offer.  The
 named constructors are much faster than :func:`new` and should be preferred.
 
-Using :func:`new` with an algorithm provided by OpenSSL::
+Using :func:`new` with an algorithm provided by OpenSSL:
 
    >>> h = hashlib.new('ripemd160')
    >>> h.update("Nobody inspects the spammish repetition")

Modified: python/trunk/Doc/library/heapq.rst
==============================================================================
--- python/trunk/Doc/library/heapq.rst	(original)
+++ python/trunk/Doc/library/heapq.rst	Sat Mar 22 23:04:10 2008
@@ -70,7 +70,7 @@
       if item > heap[0]:
           item = heapreplace(heap, item)
 
-Example of use::
+Example of use:
 
    >>> from heapq import heappush, heappop
    >>> heap = []
@@ -87,7 +87,6 @@
    >>> data.sort()
    >>> print data == ordered
    True
-   >>>
 
 The module also offers three general purpose functions based on heaps.
 

Modified: python/trunk/Doc/library/itertools.rst
==============================================================================
--- python/trunk/Doc/library/itertools.rst	(original)
+++ python/trunk/Doc/library/itertools.rst	Sat Mar 22 23:04:10 2008
@@ -8,6 +8,10 @@
 .. sectionauthor:: Raymond Hettinger <python at rcn.com>
 
 
+.. testsetup::
+
+   from itertools import *
+
 .. versionadded:: 2.3
 
 This module implements a number of :term:`iterator` building blocks inspired by
@@ -549,7 +553,9 @@
 --------
 
 The following examples show common uses for each tool and demonstrate ways they
-can be combined. ::
+can be combined.
+
+.. doctest::
 
    # Show a dictionary sorted and grouped by value
    >>> from operator import itemgetter
@@ -567,7 +573,7 @@
    # same group.
    >>> data = [ 1,  4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
    >>> for k, g in groupby(enumerate(data), lambda (i,x):i-x):
-   ...     print map(operator.itemgetter(1), g)
+   ...     print map(itemgetter(1), g)
    ... 
    [1]
    [4, 5, 6]
@@ -592,7 +598,9 @@
 kept small by linking the tools together in a functional style which helps
 eliminate temporary variables.  High speed is retained by preferring
 "vectorized" building blocks over the use of for-loops and :term:`generator`\s
-which incur interpreter overhead. ::
+which incur interpreter overhead.
+
+.. testcode::
 
    def take(n, seq):
        return list(islice(seq, n))

Modified: python/trunk/Doc/library/md5.rst
==============================================================================
--- python/trunk/Doc/library/md5.rst	(original)
+++ python/trunk/Doc/library/md5.rst	Sat Mar 22 23:04:10 2008
@@ -22,7 +22,7 @@
 concatenation of the strings fed to it so far using the :meth:`digest` method.
 
 For example, to obtain the digest of the string ``'Nobody inspects the spammish
-repetition'``::
+repetition'``:
 
    >>> import md5
    >>> m = md5.new()
@@ -31,7 +31,7 @@
    >>> m.digest()
    '\xbbd\x9c\x83\xdd\x1e\xa5\xc9\xd9\xde\xc9\xa1\x8d\xf0\xff\xe9'
 
-More condensed::
+More condensed:
 
    >>> md5.new("Nobody inspects the spammish repetition").digest()
    '\xbbd\x9c\x83\xdd\x1e\xa5\xc9\xd9\xde\xc9\xa1\x8d\xf0\xff\xe9'

Modified: python/trunk/Doc/library/sched.rst
==============================================================================
--- python/trunk/Doc/library/sched.rst	(original)
+++ python/trunk/Doc/library/sched.rst	Sat Mar 22 23:04:10 2008
@@ -25,7 +25,7 @@
 Example::
 
    >>> import sched, time
-   >>> s=sched.scheduler(time.time, time.sleep)
+   >>> s = sched.scheduler(time.time, time.sleep)
    >>> def print_time(): print "From print_time", time.time()
    ...
    >>> def print_some_times():

Modified: python/trunk/Doc/library/sets.rst
==============================================================================
--- python/trunk/Doc/library/sets.rst	(original)
+++ python/trunk/Doc/library/sets.rst	Sat Mar 22 23:04:10 2008
@@ -192,8 +192,6 @@
 Example
 -------
 
-::
-
    >>> from sets import Set
    >>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])
    >>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])
@@ -202,14 +200,14 @@
    >>> engineering_management = engineers & managers            # intersection
    >>> fulltime_management = managers - engineers - programmers # difference
    >>> engineers.add('Marvin')                                  # add element
-   >>> print engineers
+   >>> print engineers # doctest: +SKIP
    Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack'])
    >>> employees.issuperset(engineers)     # superset test
    False
    >>> employees.update(engineers)         # update from another set
    >>> employees.issuperset(engineers)
    True
-   >>> for group in [engineers, programmers, managers, employees]:
+   >>> for group in [engineers, programmers, managers, employees]: # doctest: +SKIP
    ...     group.discard('Susan')          # unconditionally remove element
    ...     print group
    ...

Modified: python/trunk/Doc/library/stdtypes.rst
==============================================================================
--- python/trunk/Doc/library/stdtypes.rst	(original)
+++ python/trunk/Doc/library/stdtypes.rst	Sat Mar 22 23:04:10 2008
@@ -630,7 +630,7 @@
    Values of *n* less than ``0`` are treated as ``0`` (which yields an empty
    sequence of the same type as *s*).  Note also that the copies are shallow;
    nested structures are not copied.  This often haunts new Python programmers;
-   consider::
+   consider:
 
       >>> lists = [[]] * 3
       >>> lists
@@ -642,7 +642,7 @@
    What has happened is that ``[[]]`` is a one-element list containing an empty
    list, so all three elements of ``[[]] * 3`` are (pointers to) this single empty
    list.  Modifying any of the elements of ``lists`` modifies this single list.
-   You can create a list of different lists this way::
+   You can create a list of different lists this way:
 
       >>> lists = [[] for i in range(3)]
       >>> lists[0].append(3)
@@ -875,7 +875,7 @@
    Return a copy of the string with leading characters removed.  The *chars*
    argument is a string specifying the set of characters to be removed.  If omitted
    or ``None``, the *chars* argument defaults to removing whitespace.  The *chars*
-   argument is not a prefix; rather, all combinations of its values are stripped::
+   argument is not a prefix; rather, all combinations of its values are stripped:
 
       >>> '   spacious   '.lstrip()
       'spacious   '
@@ -952,7 +952,7 @@
    Return a copy of the string with trailing characters removed.  The *chars*
    argument is a string specifying the set of characters to be removed.  If omitted
    or ``None``, the *chars* argument defaults to removing whitespace.  The *chars*
-   argument is not a suffix; rather, all combinations of its values are stripped::
+   argument is not a suffix; rather, all combinations of its values are stripped:
 
       >>> '   spacious   '.rstrip()
       '   spacious'
@@ -1012,7 +1012,7 @@
    The *chars* argument is a string specifying the set of characters to be removed.
    If omitted or ``None``, the *chars* argument defaults to removing whitespace.
    The *chars* argument is not a prefix or suffix; rather, all combinations of its
-   values are stripped::
+   values are stripped:
 
       >>> '   spacious   '.strip()
       'spacious'
@@ -1048,7 +1048,7 @@
 
    You can use the :func:`maketrans` helper function in the :mod:`string` module to
    create a translation table. For string objects, set the *table* argument to
-   ``None`` for translations that only delete characters::
+   ``None`` for translations that only delete characters:
 
       >>> 'read this short text'.translate(None, 'aeiou')
       'rd ths shrt txt'
@@ -1155,10 +1155,10 @@
 When the right argument is a dictionary (or other mapping type), then the
 formats in the string *must* include a parenthesised mapping key into that
 dictionary inserted immediately after the ``'%'`` character. The mapping key
-selects the value to be formatted from the mapping.  For example::
+selects the value to be formatted from the mapping.  For example:
 
    >>> print '%(language)s has %(#)03d quote types.' % \
-             {'language': "Python", "#": 2}
+   ...       {'language': "Python", "#": 2}
    Python has 002 quote types.
 
 In this case no ``*`` specifiers may occur in a format (since they require a

Modified: python/trunk/Doc/library/string.rst
==============================================================================
--- python/trunk/Doc/library/string.rst	(original)
+++ python/trunk/Doc/library/string.rst	Sat Mar 22 23:04:10 2008
@@ -168,7 +168,7 @@
    This is the object passed to the constructor's *template* argument.  In general,
    you shouldn't change it, but read-only access is not enforced.
 
-Here is an example of how to use a Template::
+Here is an example of how to use a Template:
 
    >>> from string import Template
    >>> s = Template('$who likes $what')

Modified: python/trunk/Doc/library/time.rst
==============================================================================
--- python/trunk/Doc/library/time.rst	(original)
+++ python/trunk/Doc/library/time.rst	Sat Mar 22 23:04:10 2008
@@ -382,11 +382,12 @@
    The default values used to fill in any missing data when more accurate values
    cannot be inferred are ``(1900, 1, 1, 0, 0, 0, 0, 1, -1)``.
 
-   For example::
+   For example:
 
       >>> import time
-      >>> time.strptime("30 Nov 00", "%d %b %y")
-      (2000, 11, 30, 0, 0, 0, 3, 335, -1)
+      >>> time.strptime("30 Nov 00", "%d %b %y")   # doctest: +NORMALIZE_WHITESPACE
+      time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0,
+                       tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
 
    Support for the ``%Z`` directive is based on the values contained in ``tzname``
    and whether ``daylight`` is true.  Because of this, it is platform-specific

Modified: python/trunk/Doc/library/unicodedata.rst
==============================================================================
--- python/trunk/Doc/library/unicodedata.rst	(original)
+++ python/trunk/Doc/library/unicodedata.rst	Sat Mar 22 23:04:10 2008
@@ -150,8 +150,9 @@
 
    .. versionadded:: 2.5
 
-Examples::
+Examples:
 
+   >>> import unicodedata
    >>> unicodedata.lookup('LEFT CURLY BRACKET')
    u'{'
    >>> unicodedata.name(u'/')

Modified: python/trunk/Doc/library/urlparse.rst
==============================================================================
--- python/trunk/Doc/library/urlparse.rst	(original)
+++ python/trunk/Doc/library/urlparse.rst	Sat Mar 22 23:04:10 2008
@@ -38,12 +38,13 @@
    smaller parts (for example, the network location is a single string), and %
    escapes are not expanded. The delimiters as shown above are not part of the
    result, except for a leading slash in the *path* component, which is retained if
-   present.  For example::
+   present.  For example:
 
       >>> from urlparse import urlparse
       >>> o = urlparse('http://www.cwi.nl:80/%7Eguido/Python.html')
-      >>> o
-      ('http', 'www.cwi.nl:80', '/%7Eguido/Python.html', '', '', '')
+      >>> o   # doctest: +NORMALIZE_WHITESPACE
+      ParseResult(scheme='http', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html',
+                  params='', query='', fragment='')
       >>> o.scheme
       'http'
       >>> o.port
@@ -164,7 +165,7 @@
    Construct a full ("absolute") URL by combining a "base URL" (*base*) with
    another URL (*url*).  Informally, this uses components of the base URL, in
    particular the addressing scheme, the network location and (part of) the path,
-   to provide missing components in the relative URL.  For example::
+   to provide missing components in the relative URL.  For example:
 
       >>> from urlparse import urljoin
       >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html')
@@ -178,7 +179,7 @@
       If *url* is an absolute URL (that is, starting with ``//`` or ``scheme://``),
       the *url*'s host name and/or scheme will be present in the result.  For example:
 
-   ::
+   .. doctest::
 
       >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html',
       ...         '//www.python.org/%7Eguido')
@@ -229,7 +230,7 @@
    and fragment identifiers will be removed.
 
    The result of this method is a fixpoint if passed back through the original
-   parsing function::
+   parsing function:
 
       >>> import urlparse
       >>> url = 'HTTP://www.Python.org/doc/#'

Modified: python/trunk/Doc/library/weakref.rst
==============================================================================
--- python/trunk/Doc/library/weakref.rst	(original)
+++ python/trunk/Doc/library/weakref.rst	Sat Mar 22 23:04:10 2008
@@ -243,7 +243,7 @@
 ----------------------
 
 Weak reference objects have no attributes or methods, but do allow the referent
-to be obtained, if it still exists, by calling it::
+to be obtained, if it still exists, by calling it:
 
    >>> import weakref
    >>> class Object:
@@ -256,7 +256,7 @@
    True
 
 If the referent no longer exists, calling the reference object returns
-:const:`None`::
+:const:`None`:
 
    >>> del o, o2
    >>> print r()
