Merged revisions 75952-75953,75955,76105,76143,76223,76259,76326,76376-76377 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r75952 | georg.brandl | 2009-10-29 21:38:32 +0100 (Do, 29 Okt 2009) | 1 line

  Use the correct function name in docstring.
........
  r75953 | georg.brandl | 2009-10-29 21:39:50 +0100 (Do, 29 Okt 2009) | 1 line

  Remove mention of the old -X command line switch.
........
  r75955 | georg.brandl | 2009-10-29 21:54:03 +0100 (Do, 29 Okt 2009) | 1 line

  Use a single style for all the docstrings in the math module.
........
  r76105 | georg.brandl | 2009-11-04 08:38:12 +0100 (Mi, 04 Nov 2009) | 1 line

  #7259: show correct equivalent for operator.i* operations in docstring; fix minor issues in operator docs.
........
  r76143 | georg.brandl | 2009-11-07 09:26:07 +0100 (Sa, 07 Nov 2009) | 1 line

  #7271: fix typo.
........
  r76223 | georg.brandl | 2009-11-12 09:29:46 +0100 (Do, 12 Nov 2009) | 1 line

  Give the profile module a module directive.
........
  r76259 | georg.brandl | 2009-11-14 12:50:51 +0100 (Sa, 14 Nov 2009) | 1 line

  Fix terminology.
........
  r76326 | georg.brandl | 2009-11-16 17:44:05 +0100 (Mo, 16 Nov 2009) | 1 line

  #7302: fix link.
........
  r76376 | georg.brandl | 2009-11-18 20:39:14 +0100 (Mi, 18 Nov 2009) | 1 line

  upcase Python
........
  r76377 | georg.brandl | 2009-11-18 21:05:15 +0100 (Mi, 18 Nov 2009) | 1 line

  Fix markup.
........

Doc/library/functions.rst

@@ -173,7 +173,7 @@ available.  They are listed here in alphabetical order.
 
    .. note::
 
-      When compiling a string with multi-line statements, line endings must be
+      When compiling a string with multi-line code, line endings must be
       represented by a single newline character (``'\n'``), and the input must
       be terminated by at least one newline character.  If line endings are
       represented by ``'\r\n'``, use :meth:`str.replace` to change them into

Doc/library/operator.rst

@@ -117,6 +117,14 @@ The mathematical and bitwise operations are the most numerous:
    .. versionadded:: 2.2
 
 
+.. function:: index(a)
+              __index__(a)
+
+   Return *a* converted to an integer.  Equivalent to ``a.__index__()``.
+
+   .. versionadded:: 2.5
+
+
 .. function:: inv(obj)
               invert(obj)
               __inv__(obj)
@@ -149,7 +157,7 @@ The mathematical and bitwise operations are the most numerous:
 .. function:: neg(obj)
               __neg__(obj)
 
-   Return *obj* negated.
+   Return *obj* negated (``-obj``).
 
 
 .. function:: or_(a, b)
@@ -161,7 +169,7 @@ The mathematical and bitwise operations are the most numerous:
 .. function:: pos(obj)
               __pos__(obj)
 
-   Return *obj* positive.
+   Return *obj* positive (``+obj``).
 
 
 .. function:: pow(a, b)
@@ -199,15 +207,7 @@ The mathematical and bitwise operations are the most numerous:
    Return the bitwise exclusive or of *a* and *b*.
 
 
-.. function:: index(a)
+Operations which work with sequences (some of them with mappings too) include:
-              __index__(a)
-
-   Return *a* converted to an integer.  Equivalent to ``a.__index__()``.
-
-   .. versionadded:: 2.5
-
-
-Operations which work with sequences include:
 
 .. function:: concat(a, b)
               __concat__(a, b)
@@ -359,7 +359,7 @@ example, the :term:`statement` ``x += y`` is equivalent to
 .. function:: ilshift(a, b)
               __ilshift__(a, b)
 
-   ``a = ilshift(a, b)`` is equivalent to ``a <``\ ``<= b``.
+   ``a = ilshift(a, b)`` is equivalent to ``a <<= b``.
 
    .. versionadded:: 2.5
 
@@ -572,79 +572,81 @@ Mapping Operators to Functions
 This table shows how abstract operations correspond to operator symbols in the
 Python syntax and the functions in the :mod:`operator` module.
 
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Operation             | Syntax                  | Function                              |
-+=======================+=========================+=================================+
++=======================+=========================+=======================================+
 | Addition              | ``a + b``               | ``add(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Concatenation         | ``seq1 + seq2``         | ``concat(seq1, seq2)``                |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Containment Test      | ``obj in seq``          | ``contains(seq, obj)``                |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Division              | ``a / b``               | ``div(a, b)`` (without                |
 |                       |                         | ``__future__.division``)              |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Division              | ``a / b``               | ``truediv(a, b)`` (with               |
 |                       |                         | ``__future__.division``)              |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Division              | ``a // b``              | ``floordiv(a, b)``                    |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Bitwise And           | ``a & b``               | ``and_(a, b)``                        |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Bitwise Exclusive Or  | ``a ^ b``               | ``xor(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Bitwise Inversion     | ``~ a``                 | ``invert(a)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Bitwise Or            | ``a | b``               | ``or_(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Exponentiation        | ``a ** b``              | ``pow(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Identity              | ``a is b``              | ``is_(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Identity              | ``a is not b``          | ``is_not(a, b)``                      |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Indexed Assignment    | ``obj[k] = v``          | ``setitem(obj, k, v)``                |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Indexed Deletion      | ``del obj[k]``          | ``delitem(obj, k)``                   |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Indexing              | ``obj[k]``              | ``getitem(obj, k)``                   |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Left Shift            | ``a << b``              | ``lshift(a, b)``                      |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Modulo                | ``a % b``               | ``mod(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Multiplication        | ``a * b``               | ``mul(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Negation (Arithmetic) | ``- a``                 | ``neg(a)``                            |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Negation (Logical)    | ``not a``               | ``not_(a)``                           |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
+| Positive              | ``+ a``                 | ``pos(a)``                            |
++-----------------------+-------------------------+---------------------------------------+
 | Right Shift           | ``a >> b``              | ``rshift(a, b)``                      |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Sequence Repetition   | ``seq * i``             | ``repeat(seq, i)``                    |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
-| Slice Assignment      | ``seq[i:j] = values``   | ``setslice(seq, i, j, values)`` |
+| Slice Assignment      | ``seq[i:j] = values``   | ``setitem(seq, slice(i, j), values)`` |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
-| Slice Deletion        | ``del seq[i:j]``        | ``delslice(seq, i, j)``         |
+| Slice Deletion        | ``del seq[i:j]``        | ``delitem(seq, slice(i, j))``         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
-| Slicing               | ``seq[i:j]``            | ``getslice(seq, i, j)``         |
+| Slicing               | ``seq[i:j]``            | ``getitem(seq, slice(i, j))``         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | String Formatting     | ``s % obj``             | ``mod(s, obj)``                       |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Subtraction           | ``a - b``               | ``sub(a, b)``                         |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Truth Test            | ``obj``                 | ``truth(obj)``                        |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Ordering              | ``a < b``               | ``lt(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Ordering              | ``a <= b``              | ``le(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Equality              | ``a == b``              | ``eq(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Difference            | ``a != b``              | ``ne(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Ordering              | ``a >= b``              | ``ge(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 | Ordering              | ``a > b``               | ``gt(a, b)``                          |
-+-----------------------+-------------------------+---------------------------------+
++-----------------------+-------------------------+---------------------------------------+
 

Doc/library/profile.rst

@@ -7,6 +7,8 @@ The Python Profilers
 
 .. sectionauthor:: James Roskind
 
+.. module:: profile
+   :synopsis: Python source profiler.
 
 .. index:: single: InfoSeek Corporation
 

Doc/library/string.rst

@@ -550,11 +550,10 @@ these rules.  The methods of :class:`Template` are:
 
    :class:`Template` instances also provide one public data attribute:
 
+   .. attribute:: template
 
-.. attribute:: string.template
+      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.
-   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:
 

Doc/library/turtle.rst

@@ -1901,7 +1901,7 @@ The public classes of the module :mod:`turtle`
    Subclass of TurtleScreen, with :ref:`four methods added <screenspecific>`.
 
 
-.. class:: ScrolledCavas(master)
+.. class:: ScrolledCanvas(master)
 
    :param master: some Tkinter widget to contain the ScrolledCanvas, i.e.
       a Tkinter-canvas with scrollbars added

Doc/library/xml.dom.rst

@@ -79,7 +79,7 @@ implementations are free to support the strict mapping from IDL).  See section
    `Document Object Model (DOM) Level 1 Specification <http://www.w3.org/TR/REC-DOM-Level-1/>`_
       The W3C recommendation for the DOM supported by :mod:`xml.dom.minidom`.
 
-   `Python Language Mapping Specification <http://www.omg.org/docs/formal/02-11-05.pdf>`_
+   `Python Language Mapping Specification <http://www.omg.org/spec/PYTH/1.2/PDF>`_
       This specifies the mapping from OMG IDL to Python.
 
 

Doc/library/zipfile.rst

@@ -22,7 +22,7 @@ documentation). It can handle ZIP files that use the ZIP64 extensions
 (that is ZIP files that are more than 4 GByte in size).  It supports
 decryption of encrypted files in ZIP archives, but it currently cannot
 create an encrypted file.  Decryption is extremely slow as it is
-implemented in native python rather than C.
+implemented in native Python rather than C.
 
 For other archive formats, see the :mod:`bz2`, :mod:`gzip`, and
 :mod:`tarfile` modules.

Misc/Porting

@@ -31,8 +31,7 @@ target platform.  Forget about the posix module for now -- simply take
 it out of the config.c file.
 
 Bang on it until you get a >>> prompt.  (You may have to disable the
-importing of "site.py" and "exceptions.py" by passing -X and -S
+importing of "site.py" by passing the -S options.)
-options.
 
 Then bang on it until it executes very simple Python statements.
 

Modules/mathmodule.c

@@ -351,8 +351,8 @@ FUNC1(floor, floor, 0,
       "floor(x)\n\nReturn the floor of x as a float.\n"
       "This is the largest integral value <= x.")
 FUNC1(log1p, log1p, 1,
-      "log1p(x)\n\nReturn the natural logarithm of 1+x (base e).\n\
+      "log1p(x)\n\nReturn the natural logarithm of 1+x (base e).\n"
-      The result is computed in a way which is accurate for x near zero.")
+      "The result is computed in a way which is accurate for x near zero.")
 FUNC1(sin, sin, 0,
       "sin(x)\n\nReturn the sine of x (measured in radians).")
 FUNC1(sinh, sinh, 1,
@@ -581,7 +581,7 @@ _fsum_error:
 #undef NUM_PARTIALS
 
 PyDoc_STRVAR(math_fsum_doc,
-"sum(iterable)\n\n\
+"fsum(iterable)\n\n\
 Return an accurate floating point sum of values in the iterable.\n\
 Assumes IEEE-754 floating point arithmetic.");
 
@@ -739,7 +739,8 @@ math_ldexp(PyObject *self, PyObject *args)
 }
 
 PyDoc_STRVAR(math_ldexp_doc,
-"ldexp(x, i) -> x * (2**i)");
+"ldexp(x, i)\n\n\
+Return x * (2**i).");
 
 static PyObject *
 math_modf(PyObject *self, PyObject *arg)
@@ -830,7 +831,8 @@ math_log(PyObject *self, PyObject *args)
 }
 
 PyDoc_STRVAR(math_log_doc,
-"log(x[, base]) -> the logarithm of x to the given base.\n\
+"log(x[, base])\n\n\
+Return the logarithm of x to the given base.\n\
 If the base not specified, returns the natural logarithm (base e) of x.");
 
 static PyObject *
@@ -840,7 +842,7 @@ math_log10(PyObject *self, PyObject *arg)
 }
 
 PyDoc_STRVAR(math_log10_doc,
-"log10(x) -> the base 10 logarithm of x.");
+"log10(x)\n\nReturn the base 10 logarithm of x.");
 
 static PyObject *
 math_fmod(PyObject *self, PyObject *args)
@@ -1017,7 +1019,8 @@ math_degrees(PyObject *self, PyObject *arg)
 }
 
 PyDoc_STRVAR(math_degrees_doc,
-"degrees(x) -> converts angle x from radians to degrees");
+"degrees(x)\n\n\
+Convert angle x from radians to degrees.");
 
 static PyObject *
 math_radians(PyObject *self, PyObject *arg)
@@ -1029,7 +1032,8 @@ math_radians(PyObject *self, PyObject *arg)
 }
 
 PyDoc_STRVAR(math_radians_doc,
-"radians(x) -> converts angle x from degrees to radians");
+"radians(x)\n\n\
+Convert angle x from degrees to radians.");
 
 static PyObject *
 math_isnan(PyObject *self, PyObject *arg)
@@ -1041,8 +1045,8 @@ math_isnan(PyObject *self, PyObject *arg)
 }
 
 PyDoc_STRVAR(math_isnan_doc,
-"isnan(x) -> bool\n\
+"isnan(x) -> bool\n\n\
-Checks if float x is not a number (NaN)");
+Check if float x is not a number (NaN).");
 
 static PyObject *
 math_isinf(PyObject *self, PyObject *arg)
@@ -1054,8 +1058,8 @@ math_isinf(PyObject *self, PyObject *arg)
 }
 
 PyDoc_STRVAR(math_isinf_doc,
-"isinf(x) -> bool\n\
+"isinf(x) -> bool\n\n\
-Checks if float x is infinite (positive or negative)");
+Check if float x is infinite (positive or negative).");
 
 static PyMethodDef math_methods[] = {
 	{"acos",	math_acos,	METH_O,		math_acos_doc},

Modules/operator.c

@@ -7,7 +7,7 @@ PyDoc_STRVAR(operator_doc,
 This module exports a set of functions implemented in C corresponding\n\
 to the intrinsic operators of Python.  For example, operator.add(x, y)\n\
 is equivalent to the expression x+y.  The function names are those\n\
-used for special class methods; variants without leading and trailing\n\
+used for special methods; variants without leading and trailing\n\
 '__' are also provided for convenience.");
 
 #define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
@@ -258,26 +258,26 @@ spam2o(not_,__not__, "not_(a) -- Same as not a.")
 spam2(and_,__and__, "and_(a, b) -- Same as a & b.")
 spam2(xor,__xor__, "xor(a, b) -- Same as a ^ b.")
 spam2(or_,__or__, "or_(a, b) -- Same as a | b.")
-spam2(iadd,__iadd__, "iadd(a, b) -- Same as a += b.")
+spam2(iadd,__iadd__, "a = iadd(a, b) -- Same as a += b.")
-spam2(isub,__isub__, "isub(a, b) -- Same as a -= b.")
+spam2(isub,__isub__, "a = isub(a, b) -- Same as a -= b.")
-spam2(imul,__imul__, "imul(a, b) -- Same as a *= b.")
+spam2(imul,__imul__, "a = imul(a, b) -- Same as a *= b.")
-spam2(idiv,__idiv__, "idiv(a, b) -- Same as a /= b when __future__.division is not in effect.")
+spam2(idiv,__idiv__, "a = idiv(a, b) -- Same as a /= b when __future__.division is not in effect.")
-spam2(ifloordiv,__ifloordiv__, "ifloordiv(a, b) -- Same as a //= b.")
+spam2(ifloordiv,__ifloordiv__, "a = ifloordiv(a, b) -- Same as a //= b.")
-spam2(itruediv,__itruediv__, "itruediv(a, b) -- Same as a /= b when __future__.division is in effect.")
+spam2(itruediv,__itruediv__, "a = itruediv(a, b) -- Same as a /= b when __future__.division is in effect.")
-spam2(imod,__imod__, "imod(a, b) -- Same as a %= b.")
+spam2(imod,__imod__, "a = imod(a, b) -- Same as a %= b.")
-spam2(ilshift,__ilshift__, "ilshift(a, b) -- Same as a <<= b.")
+spam2(ilshift,__ilshift__, "a = ilshift(a, b) -- Same as a <<= b.")
-spam2(irshift,__irshift__, "irshift(a, b) -- Same as a >>= b.")
+spam2(irshift,__irshift__, "a = irshift(a, b) -- Same as a >>= b.")
-spam2(iand,__iand__, "iand(a, b) -- Same as a &= b.")
+spam2(iand,__iand__, "a = iand(a, b) -- Same as a &= b.")
-spam2(ixor,__ixor__, "ixor(a, b) -- Same as a ^= b.")
+spam2(ixor,__ixor__, "a = ixor(a, b) -- Same as a ^= b.")
-spam2(ior,__ior__, "ior(a, b) -- Same as a |= b.")
+spam2(ior,__ior__, "a = ior(a, b) -- Same as a |= b.")
 spam2(concat,__concat__,
  "concat(a, b) -- Same as a + b, for a and b sequences.")
 spam2(repeat,__repeat__,
  "repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.")
 spam2(iconcat,__iconcat__,
- "iconcat(a, b) -- Same as a += b, for a and b sequences.")
+ "a = iconcat(a, b) -- Same as a += b, for a and b sequences.")
 spam2(irepeat,__irepeat__,
- "irepeat(a, b) -- Same as a *= b, where a is a sequence, and b is an integer.")
+ "a = irepeat(a, b) -- Same as a *= b, where a is a sequence, and b is an integer.")
 spam2(getitem,__getitem__,
  "getitem(a, b) -- Same as a[b].")
 spam2(setitem,__setitem__,
@@ -285,7 +285,7 @@ spam2(setitem,__setitem__,
 spam2(delitem,__delitem__,
  "delitem(a, b) -- Same as del a[b].")
 spam2(pow,__pow__, "pow(a, b) -- Same as a ** b.")
-spam2(ipow,__ipow__, "ipow(a, b) -- Same as a **= b.")
+spam2(ipow,__ipow__, "a = ipow(a, b) -- Same as a **= b.")
 spam2(getslice,__getslice__,
  "getslice(a, b, c) -- Same as a[b:c].")
 spam2(setslice,__setslice__,