diff -r 9e61563edb67 -r 1f8979a8c2c5 .hgignore
--- a/.hgignore	Sun Aug 11 16:48:44 2013 -0700
+++ b/.hgignore	Mon Aug 12 02:18:40 2013 +0200
@@ -36,7 +36,6 @@
 Modules/config.c
 Modules/ld_so_aix$
 Parser/pgen$
-^lcov-report/
 ^core
 ^python-gdb.py
 ^python.exe-gdb.py
@@ -92,7 +91,3 @@
 .coverage
 coverage/
 htmlcov/
-*.gcda
-*.gcno
-*.gcov
-coverage.info
diff -r 9e61563edb67 -r 1f8979a8c2c5 .hgtags
--- a/.hgtags	Sun Aug 11 16:48:44 2013 -0700
+++ b/.hgtags	Mon Aug 12 02:18:40 2013 +0200
@@ -114,4 +114,3 @@
 92c2cfb924055ce68c4f78f836dcfe688437ceb8 v3.3.1rc1
 d9893d13c6289aa03d33559ec67f97dcbf5c9e3c v3.3.1
 d047928ae3f6314a13b6137051315453d0ae89b6 v3.3.2
-46535f65e7f3bcdcf176f36d34bc1fed719ffd2b v3.4.0a1
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/allocation.rst
--- a/Doc/c-api/allocation.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/allocation.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -32,7 +32,7 @@
    Allocate a new Python object using the C structure type *TYPE* and the
    Python type object *type*.  Fields not defined by the Python object header
    are not initialized; the object's reference count will be one.  The size of
-   the memory allocation is determined from the :c:member:`~PyTypeObject.tp_basicsize` field of
+   the memory allocation is determined from the :attr:`tp_basicsize` field of
    the type object.
 
 
@@ -41,7 +41,7 @@
    Allocate a new Python object using the C structure type *TYPE* and the
    Python type object *type*.  Fields not defined by the Python object header
    are not initialized.  The allocated memory allows for the *TYPE* structure
-   plus *size* fields of the size given by the :c:member:`~PyTypeObject.tp_itemsize` field of
+   plus *size* fields of the size given by the :attr:`tp_itemsize` field of
    *type*.  This is useful for implementing objects like tuples, which are
    able to determine their size at construction time.  Embedding the array of
    fields into the same allocation decreases the number of allocations,
@@ -52,7 +52,7 @@
 
    Releases memory allocated to an object using :c:func:`PyObject_New` or
    :c:func:`PyObject_NewVar`.  This is normally called from the
-   :c:member:`~PyTypeObject.tp_dealloc` handler specified in the object's type.  The fields of
+   :attr:`tp_dealloc` handler specified in the object's type.  The fields of
    the object should not be accessed after this call as the memory is no
    longer a valid Python object.
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/exceptions.rst
--- a/Doc/c-api/exceptions.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/exceptions.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -607,28 +607,28 @@
    Ends a :c:func:`Py_EnterRecursiveCall`.  Must be called once for each
    *successful* invocation of :c:func:`Py_EnterRecursiveCall`.
 
-Properly implementing :c:member:`~PyTypeObject.tp_repr` for container types requires
+Properly implementing :attr:`tp_repr` for container types requires
 special recursion handling.  In addition to protecting the stack,
-:c:member:`~PyTypeObject.tp_repr` also needs to track objects to prevent cycles.  The
+:attr:`tp_repr` also needs to track objects to prevent cycles.  The
 following two functions facilitate this functionality.  Effectively,
 these are the C equivalent to :func:`reprlib.recursive_repr`.
 
 .. c:function:: int Py_ReprEnter(PyObject *object)
 
-   Called at the beginning of the :c:member:`~PyTypeObject.tp_repr` implementation to
+   Called at the beginning of the :attr:`tp_repr` implementation to
    detect cycles.
 
    If the object has already been processed, the function returns a
-   positive integer.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation
+   positive integer.  In that case the :attr:`tp_repr` implementation
    should return a string object indicating a cycle.  As examples,
    :class:`dict` objects return ``{...}`` and :class:`list` objects
    return ``[...]``.
 
    The function will return a negative integer if the recursion limit
-   is reached.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation should
+   is reached.  In that case the :attr:`tp_repr` implementation should
    typically return ``NULL``.
 
-   Otherwise, the function returns zero and the :c:member:`~PyTypeObject.tp_repr`
+   Otherwise, the function returns zero and the :attr:`tp_repr`
    implementation can continue normally.
 
 .. c:function:: void Py_ReprLeave(PyObject *object)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/gcsupport.rst
--- a/Doc/c-api/gcsupport.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/gcsupport.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -12,10 +12,10 @@
 or strings), do not need to provide any explicit support for garbage
 collection.
 
-To create a container type, the :c:member:`~PyTypeObject.tp_flags` field of the type object must
+To create a container type, the :attr:`tp_flags` field of the type object must
 include the :const:`Py_TPFLAGS_HAVE_GC` and provide an implementation of the
-:c:member:`~PyTypeObject.tp_traverse` handler.  If instances of the type are mutable, a
-:c:member:`~PyTypeObject.tp_clear` implementation must also be provided.
+:attr:`tp_traverse` handler.  If instances of the type are mutable, a
+:attr:`tp_clear` implementation must also be provided.
 
 
 .. data:: Py_TPFLAGS_HAVE_GC
@@ -57,7 +57,7 @@
    Adds the object *op* to the set of container objects tracked by the
    collector.  The collector can run at unexpected times so objects must be
    valid while being tracked.  This should be called once all the fields
-   followed by the :c:member:`~PyTypeObject.tp_traverse` handler become valid, usually near the
+   followed by the :attr:`tp_traverse` handler become valid, usually near the
    end of the constructor.
 
 
@@ -86,8 +86,8 @@
    Remove the object *op* from the set of container objects tracked by the
    collector.  Note that :c:func:`PyObject_GC_Track` can be called again on
    this object to add it back to the set of tracked objects.  The deallocator
-   (:c:member:`~PyTypeObject.tp_dealloc` handler) should call this for the object before any of
-   the fields used by the :c:member:`~PyTypeObject.tp_traverse` handler become invalid.
+   (:attr:`tp_dealloc` handler) should call this for the object before any of
+   the fields used by the :attr:`tp_traverse` handler become invalid.
 
 
 .. c:function:: void _PyObject_GC_UNTRACK(PyObject *op)
@@ -95,19 +95,19 @@
    A macro version of :c:func:`PyObject_GC_UnTrack`.  It should not be used for
    extension modules.
 
-The :c:member:`~PyTypeObject.tp_traverse` handler accepts a function parameter of this type:
+The :attr:`tp_traverse` handler accepts a function parameter of this type:
 
 
 .. c:type:: int (*visitproc)(PyObject *object, void *arg)
 
-   Type of the visitor function passed to the :c:member:`~PyTypeObject.tp_traverse` handler.
+   Type of the visitor function passed to the :attr:`tp_traverse` handler.
    The function should be called with an object to traverse as *object* and
-   the third parameter to the :c:member:`~PyTypeObject.tp_traverse` handler as *arg*.  The
+   the third parameter to the :attr:`tp_traverse` handler as *arg*.  The
    Python core uses several visitor functions to implement cyclic garbage
    detection; it's not expected that users will need to write their own
    visitor functions.
 
-The :c:member:`~PyTypeObject.tp_traverse` handler must have the following type:
+The :attr:`tp_traverse` handler must have the following type:
 
 
 .. c:type:: int (*traverseproc)(PyObject *self, visitproc visit, void *arg)
@@ -119,15 +119,15 @@
    object argument.  If *visit* returns a non-zero value that value should be
    returned immediately.
 
-To simplify writing :c:member:`~PyTypeObject.tp_traverse` handlers, a :c:func:`Py_VISIT` macro is
-provided.  In order to use this macro, the :c:member:`~PyTypeObject.tp_traverse` implementation
+To simplify writing :attr:`tp_traverse` handlers, a :c:func:`Py_VISIT` macro is
+provided.  In order to use this macro, the :attr:`tp_traverse` implementation
 must name its arguments exactly *visit* and *arg*:
 
 
 .. c:function:: void Py_VISIT(PyObject *o)
 
    Call the *visit* callback, with arguments *o* and *arg*. If *visit* returns
-   a non-zero value, then return it.  Using this macro, :c:member:`~PyTypeObject.tp_traverse`
+   a non-zero value, then return it.  Using this macro, :attr:`tp_traverse`
    handlers look like::
 
       static int
@@ -138,7 +138,7 @@
           return 0;
       }
 
-The :c:member:`~PyTypeObject.tp_clear` handler must be of the :c:type:`inquiry` type, or *NULL*
+The :attr:`tp_clear` handler must be of the :c:type:`inquiry` type, or *NULL*
 if the object is immutable.
 
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/init.rst
--- a/Doc/c-api/init.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/init.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -329,11 +329,7 @@
 
 .. c:function:: void PySys_SetArgv(int argc, wchar_t **argv)
 
-   This function works like :c:func:`PySys_SetArgvEx` with *updatepath* set
-   to 1 unless the :program:`python` interpreter was started with the
-   :option:`-I`.
-
-   .. versionchanged:: 3.4 The *updatepath* value depends on :option:`-I`.
+   This function works like :c:func:`PySys_SetArgvEx` with *updatepath* set to 1.
 
 
 .. c:function:: void Py_SetPythonHome(wchar_t *home)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/module.rst
--- a/Doc/c-api/module.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/module.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -189,22 +189,16 @@
 
    .. c:member:: Py_ssize_t m_size
 
-      Some modules allow re-initialization (calling their ``PyInit_*`` function
-      more than once). These modules should keep their state in a per-module
-      memory area that can be retrieved with :c:func:`PyModule_GetState`.
+      If the module object needs additional memory, this should be set to the
+      number of bytes to allocate; a pointer to the block of memory can be
+      retrieved with :c:func:`PyModule_GetState`.  If no memory is needed, set
+      this to ``-1``.
 
       This memory should be used, rather than static globals, to hold per-module
       state, since it is then safe for use in multiple sub-interpreters.  It is
       freed when the module object is deallocated, after the :c:member:`m_free`
       function has been called, if present.
 
-      Setting ``m_size`` to ``-1`` means that the module can not be
-      re-initialized because it has global state. Setting it to a non-negative
-      value means that the module can be re-initialized and specifies the
-      additional amount of memory it requires for its state.
-
-      See :PEP:`3121` for more details.
-
    .. c:member:: PyMethodDef* m_methods
 
       A pointer to a table of module-level functions, described by
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/type.rst
--- a/Doc/c-api/type.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/type.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -37,10 +37,10 @@
 
 .. c:function:: long PyType_GetFlags(PyTypeObject* type)
 
-   Return the :c:member:`~PyTypeObject.tp_flags` member of *type*. This function is primarily
+   Return the :attr:`tp_flags` member of *type*. This function is primarily
    meant for use with `Py_LIMITED_API`; the individual flag bits are
    guaranteed to be stable across Python releases, but access to
-   :c:member:`~PyTypeObject.tp_flags` itself is not part of the limited API.
+   :attr:`tp_flags` itself is not part of the limited API.
 
    .. versionadded:: 3.2
 
@@ -70,14 +70,14 @@
 
 .. c:function:: PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
 
-   Generic handler for the :c:member:`~PyTypeObject.tp_alloc` slot of a type object.  Use
+   Generic handler for the :attr:`tp_alloc` slot of a type object.  Use
    Python's default memory allocation mechanism to allocate a new instance and
    initialize all its contents to *NULL*.
 
 .. c:function:: PyObject* PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
 
-   Generic handler for the :c:member:`~PyTypeObject.tp_new` slot of a type object.  Create a
-   new instance using the type's :c:member:`~PyTypeObject.tp_alloc` slot.
+   Generic handler for the :attr:`tp_new` slot of a type object.  Create a
+   new instance using the type's :attr:`tp_alloc` slot.
 
 .. c:function:: int PyType_Ready(PyTypeObject *type)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/typeobj.rst
--- a/Doc/c-api/typeobj.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/typeobj.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -35,7 +35,7 @@
 The type object structure extends the :c:type:`PyVarObject` structure. The
 :attr:`ob_size` field is used for dynamic types (created by  :func:`type_new`,
 usually called from a class statement). Note that :c:data:`PyType_Type` (the
-metatype) initializes :c:member:`~PyTypeObject.tp_itemsize`, which means that its instances (i.e.
+metatype) initializes :attr:`tp_itemsize`, which means that its instances (i.e.
 type objects) *must* have the :attr:`ob_size` field.
 
 
@@ -102,7 +102,7 @@
    should be just the type name.  If the module is a submodule of a package, the
    full package name is part of the full module name.  For example, a type named
    :class:`T` defined in module :mod:`M` in subpackage :mod:`Q` in package :mod:`P`
-   should have the :c:member:`~PyTypeObject.tp_name` initializer ``"P.Q.M.T"``.
+   should have the :attr:`tp_name` initializer ``"P.Q.M.T"``.
 
    For dynamically allocated type objects, this should just be the type name, and
    the module name explicitly stored in the type dict as the value for key
@@ -113,7 +113,7 @@
    attribute, and everything after the last dot is made accessible as the
    :attr:`__name__` attribute.
 
-   If no dot is present, the entire :c:member:`~PyTypeObject.tp_name` field is made accessible as the
+   If no dot is present, the entire :attr:`tp_name` field is made accessible as the
    :attr:`__name__` attribute, and the :attr:`__module__` attribute is undefined
    (unless explicitly set in the dictionary, as explained above).  This means your
    type will be impossible to pickle.
@@ -127,13 +127,13 @@
    These fields allow calculating the size in bytes of instances of the type.
 
    There are two kinds of types: types with fixed-length instances have a zero
-   :c:member:`~PyTypeObject.tp_itemsize` field, types with variable-length instances have a non-zero
-   :c:member:`~PyTypeObject.tp_itemsize` field.  For a type with fixed-length instances, all
-   instances have the same size, given in :c:member:`~PyTypeObject.tp_basicsize`.
+   :attr:`tp_itemsize` field, types with variable-length instances have a non-zero
+   :attr:`tp_itemsize` field.  For a type with fixed-length instances, all
+   instances have the same size, given in :attr:`tp_basicsize`.
 
    For a type with variable-length instances, the instances must have an
-   :attr:`ob_size` field, and the instance size is :c:member:`~PyTypeObject.tp_basicsize` plus N
-   times :c:member:`~PyTypeObject.tp_itemsize`, where N is the "length" of the object.  The value of
+   :attr:`ob_size` field, and the instance size is :attr:`tp_basicsize` plus N
+   times :attr:`tp_itemsize`, where N is the "length" of the object.  The value of
    N is typically stored in the instance's :attr:`ob_size` field.  There are
    exceptions:  for example, ints use a negative :attr:`ob_size` to indicate a
    negative number, and N is ``abs(ob_size)`` there.  Also, the presence of an
@@ -146,20 +146,20 @@
    :c:macro:`PyObject_HEAD` or :c:macro:`PyObject_VAR_HEAD` (whichever is used to
    declare the instance struct) and this in turn includes the :attr:`_ob_prev` and
    :attr:`_ob_next` fields if they are present.  This means that the only correct
-   way to get an initializer for the :c:member:`~PyTypeObject.tp_basicsize` is to use the
+   way to get an initializer for the :attr:`tp_basicsize` is to use the
    ``sizeof`` operator on the struct used to declare the instance layout.
    The basic size does not include the GC header size.
 
    These fields are inherited separately by subtypes.  If the base type has a
-   non-zero :c:member:`~PyTypeObject.tp_itemsize`, it is generally not safe to set
-   :c:member:`~PyTypeObject.tp_itemsize` to a different non-zero value in a subtype (though this
+   non-zero :attr:`tp_itemsize`, it is generally not safe to set
+   :attr:`tp_itemsize` to a different non-zero value in a subtype (though this
    depends on the implementation of the base type).
 
    A note about alignment: if the variable items require a particular alignment,
-   this should be taken care of by the value of :c:member:`~PyTypeObject.tp_basicsize`.  Example:
-   suppose a type implements an array of ``double``. :c:member:`~PyTypeObject.tp_itemsize` is
+   this should be taken care of by the value of :attr:`tp_basicsize`.  Example:
+   suppose a type implements an array of ``double``. :attr:`tp_itemsize` is
    ``sizeof(double)``. It is the programmer's responsibility that
-   :c:member:`~PyTypeObject.tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
+   :attr:`tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
    alignment requirement for ``double``).
 
 
@@ -175,10 +175,10 @@
    destructor function should free all references which the instance owns, free all
    memory buffers owned by the instance (using the freeing function corresponding
    to the allocation function used to allocate the buffer), and finally (as its
-   last action) call the type's :c:member:`~PyTypeObject.tp_free` function.  If the type is not
+   last action) call the type's :attr:`tp_free` function.  If the type is not
    subtypable (doesn't have the :const:`Py_TPFLAGS_BASETYPE` flag bit set), it is
    permissible to call the object deallocator directly instead of via
-   :c:member:`~PyTypeObject.tp_free`.  The object deallocator should be the one used to allocate the
+   :attr:`tp_free`.  The object deallocator should be the one used to allocate the
    instance; this is normally :c:func:`PyObject_Del` if the instance was allocated
    using :c:func:`PyObject_New` or :c:func:`PyObject_VarNew`, or
    :c:func:`PyObject_GC_Del` if the instance was allocated using
@@ -193,25 +193,25 @@
 
    The print function is only called when the instance is printed to a *real* file;
    when it is printed to a pseudo-file (like a :class:`StringIO` instance), the
-   instance's :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` function is called to convert it to
-   a string.  These are also called when the type's :c:member:`~PyTypeObject.tp_print` field is
-   *NULL*.  A type should never implement :c:member:`~PyTypeObject.tp_print` in a way that produces
-   different output than :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` would.
+   instance's :attr:`tp_repr` or :attr:`tp_str` function is called to convert it to
+   a string.  These are also called when the type's :attr:`tp_print` field is
+   *NULL*.  A type should never implement :attr:`tp_print` in a way that produces
+   different output than :attr:`tp_repr` or :attr:`tp_str` would.
 
    The print function is called with the same signature as :c:func:`PyObject_Print`:
    ``int tp_print(PyObject *self, FILE *file, int flags)``.  The *self* argument is
    the instance to be printed.  The *file* argument is the stdio file to which it
    is to be printed.  The *flags* argument is composed of flag bits. The only flag
    bit currently defined is :const:`Py_PRINT_RAW`. When the :const:`Py_PRINT_RAW`
-   flag bit is set, the instance should be printed the same way as :c:member:`~PyTypeObject.tp_str`
+   flag bit is set, the instance should be printed the same way as :attr:`tp_str`
    would format it; when the :const:`Py_PRINT_RAW` flag bit is clear, the instance
-   should be printed the same was as :c:member:`~PyTypeObject.tp_repr` would format it. It should
+   should be printed the same was as :attr:`tp_repr` would format it. It should
    return ``-1`` and set an exception condition when an error occurred during the
    comparison.
 
-   It is possible that the :c:member:`~PyTypeObject.tp_print` field will be deprecated. In any case,
-   it is recommended not to define :c:member:`~PyTypeObject.tp_print`, but instead to rely on
-   :c:member:`~PyTypeObject.tp_repr` and :c:member:`~PyTypeObject.tp_str` for printing.
+   It is possible that the :attr:`tp_print` field will be deprecated. In any case,
+   it is recommended not to define :attr:`tp_print`, but instead to rely on
+   :attr:`tp_repr` and :attr:`tp_str` for printing.
 
    This field is inherited by subtypes.
 
@@ -221,13 +221,13 @@
    An optional pointer to the get-attribute-string function.
 
    This field is deprecated.  When it is defined, it should point to a function
-   that acts the same as the :c:member:`~PyTypeObject.tp_getattro` function, but taking a C string
+   that acts the same as the :attr:`tp_getattro` function, but taking a C string
    instead of a Python string object to give the attribute name.  The signature is
    the same as for :c:func:`PyObject_GetAttrString`.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattro`: a subtype
-   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
-   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+   This field is inherited by subtypes together with :attr:`tp_getattro`: a subtype
+   inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
+   the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
 
 
 .. c:member:: setattrfunc PyTypeObject.tp_setattr
@@ -235,13 +235,13 @@
    An optional pointer to the set-attribute-string function.
 
    This field is deprecated.  When it is defined, it should point to a function
-   that acts the same as the :c:member:`~PyTypeObject.tp_setattro` function, but taking a C string
+   that acts the same as the :attr:`tp_setattro` function, but taking a C string
    instead of a Python string object to give the attribute name.  The signature is
    the same as for :c:func:`PyObject_SetAttrString`.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattro`: a subtype
-   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
-   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+   This field is inherited by subtypes together with :attr:`tp_setattro`: a subtype
+   inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
+   the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
 
 
 .. c:member:: void* PyTypeObject.tp_reserved
@@ -275,7 +275,7 @@
    objects which implement the number protocol.  These fields are documented in
    :ref:`number-structs`.
 
-   The :c:member:`~PyTypeObject.tp_as_number` field is not inherited, but the contained fields are
+   The :attr:`tp_as_number` field is not inherited, but the contained fields are
    inherited individually.
 
 
@@ -285,7 +285,7 @@
    objects which implement the sequence protocol.  These fields are documented
    in :ref:`sequence-structs`.
 
-   The :c:member:`~PyTypeObject.tp_as_sequence` field is not inherited, but the contained fields
+   The :attr:`tp_as_sequence` field is not inherited, but the contained fields
    are inherited individually.
 
 
@@ -295,7 +295,7 @@
    objects which implement the mapping protocol.  These fields are documented in
    :ref:`mapping-structs`.
 
-   The :c:member:`~PyTypeObject.tp_as_mapping` field is not inherited, but the contained fields
+   The :attr:`tp_as_mapping` field is not inherited, but the contained fields
    are inherited individually.
 
 
@@ -323,9 +323,9 @@
    object raises :exc:`TypeError`.
 
    This field is inherited by subtypes together with
-   :c:member:`~PyTypeObject.tp_richcompare`: a subtype inherits both of
-   :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash`, when the subtype's
-   :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` are both *NULL*.
+   :attr:`tp_richcompare`: a subtype inherits both of
+   :attr:`tp_richcompare` and :attr:`tp_hash`, when the subtype's
+   :attr:`tp_richcompare` and :attr:`tp_hash` are both *NULL*.
 
 
 .. c:member:: ternaryfunc PyTypeObject.tp_call
@@ -363,9 +363,9 @@
    convenient to set this field to :c:func:`PyObject_GenericGetAttr`, which
    implements the normal way of looking for object attributes.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattr`: a subtype
-   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
-   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+   This field is inherited by subtypes together with :attr:`tp_getattr`: a subtype
+   inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
+   the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
 
 
 .. c:member:: setattrofunc PyTypeObject.tp_setattro
@@ -376,9 +376,9 @@
    convenient to set this field to :c:func:`PyObject_GenericSetAttr`, which
    implements the normal way of setting object attributes.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattr`: a subtype
-   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
-   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+   This field is inherited by subtypes together with :attr:`tp_setattr`: a subtype
+   inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
+   the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
 
 
 .. c:member:: PyBufferProcs* PyTypeObject.tp_as_buffer
@@ -387,7 +387,7 @@
    which implement the buffer interface.  These fields are documented in
    :ref:`buffer-structs`.
 
-   The :c:member:`~PyTypeObject.tp_as_buffer` field is not inherited, but the contained fields are
+   The :attr:`tp_as_buffer` field is not inherited, but the contained fields are
    inherited individually.
 
 
@@ -396,8 +396,8 @@
    This field is a bit mask of various flags.  Some flags indicate variant
    semantics for certain situations; others are used to indicate that certain
    fields in the type object (or in the extension structures referenced via
-   :c:member:`~PyTypeObject.tp_as_number`, :c:member:`~PyTypeObject.tp_as_sequence`, :c:member:`~PyTypeObject.tp_as_mapping`, and
-   :c:member:`~PyTypeObject.tp_as_buffer`) that were historically not always present are valid; if
+   :attr:`tp_as_number`, :attr:`tp_as_sequence`, :attr:`tp_as_mapping`, and
+   :attr:`tp_as_buffer`) that were historically not always present are valid; if
    such a flag bit is clear, the type fields it guards must not be accessed and
    must be considered to have a zero or *NULL* value instead.
 
@@ -407,13 +407,13 @@
    inherited if the extension structure is inherited, i.e. the base type's value of
    the flag bit is copied into the subtype together with a pointer to the extension
    structure.  The :const:`Py_TPFLAGS_HAVE_GC` flag bit is inherited together with
-   the :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields, i.e. if the
+   the :attr:`tp_traverse` and :attr:`tp_clear` fields, i.e. if the
    :const:`Py_TPFLAGS_HAVE_GC` flag bit is clear in the subtype and the
-   :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields in the subtype exist and have
+   :attr:`tp_traverse` and :attr:`tp_clear` fields in the subtype exist and have
    *NULL* values.
 
    The following bit masks are currently defined; these can be ORed together using
-   the ``|`` operator to form the value of the :c:member:`~PyTypeObject.tp_flags` field.  The macro
+   the ``|`` operator to form the value of the :attr:`tp_flags` field.  The macro
    :c:func:`PyType_HasFeature` takes a type and a flags value, *tp* and *f*, and
    checks whether ``tp->tp_flags & f`` is non-zero.
 
@@ -453,7 +453,7 @@
       is set, instances must be created using :c:func:`PyObject_GC_New` and
       destroyed using :c:func:`PyObject_GC_Del`.  More information in section
       :ref:`supporting-cycle-detection`.  This bit also implies that the
-      GC-related fields :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` are present in
+      GC-related fields :attr:`tp_traverse` and :attr:`tp_clear` are present in
       the type object.
 
 
@@ -465,14 +465,6 @@
       :const:`Py_TPFLAGS_HAVE_VERSION_TAG`.
 
 
-   .. data:: Py_TPFLAGS_HAVE_FINALIZE
-
-      This bit is set when the :c:member:`~PyTypeObject.tp_finalize` slot is present in the
-      type structure.
-
-      .. versionadded:: 3.4
-
-
 .. c:member:: char* PyTypeObject.tp_doc
 
    An optional pointer to a NUL-terminated C string giving the docstring for this
@@ -489,8 +481,8 @@
    about Python's garbage collection scheme can be found in section
    :ref:`supporting-cycle-detection`.
 
-   The :c:member:`~PyTypeObject.tp_traverse` pointer is used by the garbage collector to detect
-   reference cycles. A typical implementation of a :c:member:`~PyTypeObject.tp_traverse` function
+   The :attr:`tp_traverse` pointer is used by the garbage collector to detect
+   reference cycles. A typical implementation of a :attr:`tp_traverse` function
    simply calls :c:func:`Py_VISIT` on each of the instance's members that are Python
    objects.  For example, this is function :c:func:`local_traverse` from the
    :mod:`_thread` extension module::
@@ -516,9 +508,9 @@
    :c:func:`local_traverse` to have these specific names; don't name them just
    anything.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_clear` and the
-   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
-   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
+   This field is inherited by subtypes together with :attr:`tp_clear` and the
+   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
+   :attr:`tp_clear` are all inherited from the base type if they are all zero in
    the subtype.
 
 
@@ -527,17 +519,17 @@
    An optional pointer to a clear function for the garbage collector. This is only
    used if the :const:`Py_TPFLAGS_HAVE_GC` flag bit is set.
 
-   The :c:member:`~PyTypeObject.tp_clear` member function is used to break reference cycles in cyclic
-   garbage detected by the garbage collector.  Taken together, all :c:member:`~PyTypeObject.tp_clear`
+   The :attr:`tp_clear` member function is used to break reference cycles in cyclic
+   garbage detected by the garbage collector.  Taken together, all :attr:`tp_clear`
    functions in the system must combine to break all reference cycles.  This is
-   subtle, and if in any doubt supply a :c:member:`~PyTypeObject.tp_clear` function.  For example,
-   the tuple type does not implement a :c:member:`~PyTypeObject.tp_clear` function, because it's
+   subtle, and if in any doubt supply a :attr:`tp_clear` function.  For example,
+   the tuple type does not implement a :attr:`tp_clear` function, because it's
    possible to prove that no reference cycle can be composed entirely of tuples.
-   Therefore the :c:member:`~PyTypeObject.tp_clear` functions of other types must be sufficient to
+   Therefore the :attr:`tp_clear` functions of other types must be sufficient to
    break any cycle containing a tuple.  This isn't immediately obvious, and there's
-   rarely a good reason to avoid implementing :c:member:`~PyTypeObject.tp_clear`.
+   rarely a good reason to avoid implementing :attr:`tp_clear`.
 
-   Implementations of :c:member:`~PyTypeObject.tp_clear` should drop the instance's references to
+   Implementations of :attr:`tp_clear` should drop the instance's references to
    those of its members that may be Python objects, and set its pointers to those
    members to *NULL*, as in the following example::
 
@@ -562,18 +554,18 @@
    so that *self* knows the contained object can no longer be used.  The
    :c:func:`Py_CLEAR` macro performs the operations in a safe order.
 
-   Because the goal of :c:member:`~PyTypeObject.tp_clear` functions is to break reference cycles,
+   Because the goal of :attr:`tp_clear` functions is to break reference cycles,
    it's not necessary to clear contained objects like Python strings or Python
    integers, which can't participate in reference cycles. On the other hand, it may
    be convenient to clear all contained Python objects, and write the type's
-   :c:member:`~PyTypeObject.tp_dealloc` function to invoke :c:member:`~PyTypeObject.tp_clear`.
+   :attr:`tp_dealloc` function to invoke :attr:`tp_clear`.
 
    More information about Python's garbage collection scheme can be found in
    section :ref:`supporting-cycle-detection`.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_traverse` and the
-   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
-   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
+   This field is inherited by subtypes together with :attr:`tp_traverse` and the
+   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
+   :attr:`tp_clear` are all inherited from the base type if they are all zero in
    the subtype.
 
 
@@ -593,13 +585,13 @@
       comparisons makes sense (e.g. ``==`` and ``!=``, but not ``<`` and
       friends), directly raise :exc:`TypeError` in the rich comparison function.
 
-   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_hash`:
-   a subtype inherits :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` when
-   the subtype's :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` are both
+   This field is inherited by subtypes together with :attr:`tp_hash`:
+   a subtype inherits :attr:`tp_richcompare` and :attr:`tp_hash` when
+   the subtype's :attr:`tp_richcompare` and :attr:`tp_hash` are both
    *NULL*.
 
    The following constants are defined to be used as the third argument for
-   :c:member:`~PyTypeObject.tp_richcompare` and for :c:func:`PyObject_RichCompare`:
+   :attr:`tp_richcompare` and for :c:func:`PyObject_RichCompare`:
 
    +----------------+------------+
    | Constant       | Comparison |
@@ -627,26 +619,26 @@
    instance structure needs to include a field of type :c:type:`PyObject\*` which is
    initialized to *NULL*.
 
-   Do not confuse this field with :c:member:`~PyTypeObject.tp_weaklist`; that is the list head for
+   Do not confuse this field with :attr:`tp_weaklist`; that is the list head for
    weak references to the type object itself.
 
    This field is inherited by subtypes, but see the rules listed below. A subtype
    may override this offset; this means that the subtype uses a different weak
    reference list head than the base type.  Since the list head is always found via
-   :c:member:`~PyTypeObject.tp_weaklistoffset`, this should not be a problem.
+   :attr:`tp_weaklistoffset`, this should not be a problem.
 
    When a type defined by a class statement has no :attr:`__slots__` declaration,
    and none of its base types are weakly referenceable, the type is made weakly
    referenceable by adding a weak reference list head slot to the instance layout
-   and setting the :c:member:`~PyTypeObject.tp_weaklistoffset` of that slot's offset.
+   and setting the :attr:`tp_weaklistoffset` of that slot's offset.
 
    When a type's :attr:`__slots__` declaration contains a slot named
    :attr:`__weakref__`, that slot becomes the weak reference list head for
    instances of the type, and the slot's offset is stored in the type's
-   :c:member:`~PyTypeObject.tp_weaklistoffset`.
+   :attr:`tp_weaklistoffset`.
 
    When a type's :attr:`__slots__` declaration does not contain a slot named
-   :attr:`__weakref__`, the type inherits its :c:member:`~PyTypeObject.tp_weaklistoffset` from its
+   :attr:`__weakref__`, the type inherits its :attr:`tp_weaklistoffset` from its
    base type.
 
 .. c:member:: getiterfunc PyTypeObject.tp_iter
@@ -668,7 +660,7 @@
    *NULL* too.  Its presence signals that the instances of this type are
    iterators.
 
-   Iterator types should also define the :c:member:`~PyTypeObject.tp_iter` function, and that
+   Iterator types should also define the :attr:`tp_iter` function, and that
    function should return the iterator instance itself (not a new iterator
    instance).
 
@@ -683,7 +675,7 @@
    structures, declaring regular methods of this type.
 
    For each entry in the array, an entry is added to the type's dictionary (see
-   :c:member:`~PyTypeObject.tp_dict` below) containing a method descriptor.
+   :attr:`tp_dict` below) containing a method descriptor.
 
    This field is not inherited by subtypes (methods are inherited through a
    different mechanism).
@@ -696,7 +688,7 @@
    this type.
 
    For each entry in the array, an entry is added to the type's dictionary (see
-   :c:member:`~PyTypeObject.tp_dict` below) containing a member descriptor.
+   :attr:`tp_dict` below) containing a member descriptor.
 
    This field is not inherited by subtypes (members are inherited through a
    different mechanism).
@@ -708,7 +700,7 @@
    structures, declaring computed attributes of instances of this type.
 
    For each entry in the array, an entry is added to the type's dictionary (see
-   :c:member:`~PyTypeObject.tp_dict` below) containing a getset descriptor.
+   :attr:`tp_dict` below) containing a getset descriptor.
 
    This field is not inherited by subtypes (computed attributes are inherited
    through a different mechanism).
@@ -756,7 +748,7 @@
    .. warning::
 
       It is not safe to use :c:func:`PyDict_SetItem` on or otherwise modify
-      :c:member:`~PyTypeObject.tp_dict` with the dictionary C-API.
+      :attr:`tp_dict` with the dictionary C-API.
 
 
 .. c:member:: descrgetfunc PyTypeObject.tp_descr_get
@@ -792,7 +784,7 @@
    the instance variable dictionary; this offset is used by
    :c:func:`PyObject_GenericGetAttr`.
 
-   Do not confuse this field with :c:member:`~PyTypeObject.tp_dict`; that is the dictionary for
+   Do not confuse this field with :attr:`tp_dict`; that is the dictionary for
    attributes of the type object itself.
 
    If the value of this field is greater than zero, it specifies the offset from
@@ -801,20 +793,20 @@
    offset is more expensive to use, and should only be used when the instance
    structure contains a variable-length part.  This is used for example to add an
    instance variable dictionary to subtypes of :class:`str` or :class:`tuple`. Note
-   that the :c:member:`~PyTypeObject.tp_basicsize` field should account for the dictionary added to
+   that the :attr:`tp_basicsize` field should account for the dictionary added to
    the end in that case, even though the dictionary is not included in the basic
    object layout.  On a system with a pointer size of 4 bytes,
-   :c:member:`~PyTypeObject.tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
+   :attr:`tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
    at the very end of the structure.
 
    The real dictionary offset in an instance can be computed from a negative
-   :c:member:`~PyTypeObject.tp_dictoffset` as follows::
+   :attr:`tp_dictoffset` as follows::
 
       dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset
       if dictoffset is not aligned on sizeof(void*):
           round up to sizeof(void*)
 
-   where :c:member:`~PyTypeObject.tp_basicsize`, :c:member:`~PyTypeObject.tp_itemsize` and :c:member:`~PyTypeObject.tp_dictoffset` are
+   where :attr:`tp_basicsize`, :attr:`tp_itemsize` and :attr:`tp_dictoffset` are
    taken from the type object, and :attr:`ob_size` is taken from the instance.  The
    absolute value is taken because ints use the sign of :attr:`ob_size` to
    store the sign of the number.  (There's never a need to do this calculation
@@ -823,15 +815,15 @@
    This field is inherited by subtypes, but see the rules listed below. A subtype
    may override this offset; this means that the subtype instances store the
    dictionary at a difference offset than the base type.  Since the dictionary is
-   always found via :c:member:`~PyTypeObject.tp_dictoffset`, this should not be a problem.
+   always found via :attr:`tp_dictoffset`, this should not be a problem.
 
    When a type defined by a class statement has no :attr:`__slots__` declaration,
    and none of its base types has an instance variable dictionary, a dictionary
-   slot is added to the instance layout and the :c:member:`~PyTypeObject.tp_dictoffset` is set to
+   slot is added to the instance layout and the :attr:`tp_dictoffset` is set to
    that slot's offset.
 
    When a type defined by a class statement has a :attr:`__slots__` declaration,
-   the type inherits its :c:member:`~PyTypeObject.tp_dictoffset` from its base type.
+   the type inherits its :attr:`tp_dictoffset` from its base type.
 
    (Adding a slot named :attr:`__dict__` to the :attr:`__slots__` declaration does
    not have the expected effect, it just causes confusion.  Maybe this should be
@@ -855,12 +847,12 @@
    arguments represent positional and keyword arguments of the call to
    :meth:`__init__`.
 
-   The :c:member:`~PyTypeObject.tp_init` function, if not *NULL*, is called when an instance is
-   created normally by calling its type, after the type's :c:member:`~PyTypeObject.tp_new` function
-   has returned an instance of the type.  If the :c:member:`~PyTypeObject.tp_new` function returns an
+   The :attr:`tp_init` function, if not *NULL*, is called when an instance is
+   created normally by calling its type, after the type's :attr:`tp_new` function
+   has returned an instance of the type.  If the :attr:`tp_new` function returns an
    instance of some other type that is not a subtype of the original type, no
-   :c:member:`~PyTypeObject.tp_init` function is called; if :c:member:`~PyTypeObject.tp_new` returns an instance of a
-   subtype of the original type, the subtype's :c:member:`~PyTypeObject.tp_init` is called.
+   :attr:`tp_init` function is called; if :attr:`tp_new` returns an instance of a
+   subtype of the original type, the subtype's :attr:`tp_init` is called.
 
    This field is inherited by subtypes.
 
@@ -877,14 +869,14 @@
    initialization.  It should return a pointer to a block of memory of adequate
    length for the instance, suitably aligned, and initialized to zeros, but with
    :attr:`ob_refcnt` set to ``1`` and :attr:`ob_type` set to the type argument.  If
-   the type's :c:member:`~PyTypeObject.tp_itemsize` is non-zero, the object's :attr:`ob_size` field
+   the type's :attr:`tp_itemsize` is non-zero, the object's :attr:`ob_size` field
    should be initialized to *nitems* and the length of the allocated memory block
    should be ``tp_basicsize + nitems*tp_itemsize``, rounded up to a multiple of
    ``sizeof(void*)``; otherwise, *nitems* is not used and the length of the block
-   should be :c:member:`~PyTypeObject.tp_basicsize`.
+   should be :attr:`tp_basicsize`.
 
    Do not use this function to do any other instance initialization, not even to
-   allocate additional memory; that should be done by :c:member:`~PyTypeObject.tp_new`.
+   allocate additional memory; that should be done by :attr:`tp_new`.
 
    This field is inherited by static subtypes, but not by dynamic subtypes
    (subtypes created by a class statement); in the latter, this field is always set
@@ -906,20 +898,20 @@
 
    The subtype argument is the type of the object being created; the *args* and
    *kwds* arguments represent positional and keyword arguments of the call to the
-   type.  Note that subtype doesn't have to equal the type whose :c:member:`~PyTypeObject.tp_new`
+   type.  Note that subtype doesn't have to equal the type whose :attr:`tp_new`
    function is called; it may be a subtype of that type (but not an unrelated
    type).
 
-   The :c:member:`~PyTypeObject.tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
+   The :attr:`tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
    to allocate space for the object, and then do only as much further
    initialization as is absolutely necessary.  Initialization that can safely be
-   ignored or repeated should be placed in the :c:member:`~PyTypeObject.tp_init` handler.  A good
+   ignored or repeated should be placed in the :attr:`tp_init` handler.  A good
    rule of thumb is that for immutable types, all initialization should take place
-   in :c:member:`~PyTypeObject.tp_new`, while for mutable types, most initialization should be
-   deferred to :c:member:`~PyTypeObject.tp_init`.
+   in :attr:`tp_new`, while for mutable types, most initialization should be
+   deferred to :attr:`tp_init`.
 
    This field is inherited by subtypes, except it is not inherited by static types
-   whose :c:member:`~PyTypeObject.tp_base` is *NULL* or ``&PyBaseObject_Type``.
+   whose :attr:`tp_base` is *NULL* or ``&PyBaseObject_Type``.
 
 
 .. c:member:: destructor PyTypeObject.tp_free
@@ -943,7 +935,7 @@
 
    The garbage collector needs to know whether a particular object is collectible
    or not.  Normally, it is sufficient to look at the object's type's
-   :c:member:`~PyTypeObject.tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
+   :attr:`tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
    some types have a mixture of statically and dynamically allocated instances, and
    the statically allocated instances are not collectible.  Such types should
    define this function; it should return ``1`` for a collectible instance, and
@@ -976,47 +968,6 @@
    This field is not inherited; it is calculated fresh by :c:func:`PyType_Ready`.
 
 
-.. c:member:: destructor PyTypeObject.tp_finalize
-
-   An optional pointer to an instance finalization function.  Its signature is
-   :c:type:`destructor`::
-
-      void tp_finalize(PyObject *)
-
-   If :c:member:`~PyTypeObject.tp_finalize` is set, the interpreter calls it once when
-   finalizing an instance.  It is called either from the garbage
-   collector (if the instance is part of an isolated reference cycle) or
-   just before the object is deallocated.  Either way, it is guaranteed
-   to be called before attempting to break reference cycles, ensuring
-   that it finds the object in a sane state.
-
-   :c:member:`~PyTypeObject.tp_finalize` should not mutate the current exception status;
-   therefore, a recommended way to write a non-trivial finalizer is::
-
-      static void
-      local_finalize(PyObject *self)
-      {
-          PyObject *error_type, *error_value, *error_traceback;
-
-          /* Save the current exception, if any. */
-          PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
-          /* ... */
-
-          /* Restore the saved exception. */
-          PyErr_Restore(error_type, error_value, error_traceback);
-      }
-
-   For this field to be taken into account (even through inheritance),
-   you must also set the :const:`Py_TPFLAGS_HAVE_FINALIZE` flags bit.
-
-   This field is inherited by subtypes.
-
-   .. versionadded:: 3.4
-
-   .. seealso:: "Safe object finalization" (:pep:`442`)
-
-
 .. c:member:: PyObject* PyTypeObject.tp_cache
 
    Unused.  Not inherited.  Internal use only.
@@ -1055,7 +1006,7 @@
 
 .. c:member:: PyTypeObject* PyTypeObject.tp_next
 
-   Pointer to the next type object with a non-zero :c:member:`~PyTypeObject.tp_allocs` field.
+   Pointer to the next type object with a non-zero :attr:`tp_allocs` field.
 
 Also, note that, in a garbage collected Python, tp_dealloc may be called from
 any Python thread, not just the thread which created the object (if the object
@@ -1194,13 +1145,13 @@
 
    This function is used by :c:func:`PySequence_Concat` and has the same
    signature.  It is also used by the ``+`` operator, after trying the numeric
-   addition via the :c:member:`~PyTypeObject.tp_as_number.nb_add` slot.
+   addition via the :attr:`tp_as_number.nb_add` slot.
 
 .. c:member:: ssizeargfunc PySequenceMethods.sq_repeat
 
    This function is used by :c:func:`PySequence_Repeat` and has the same
    signature.  It is also used by the ``*`` operator, after trying numeric
-   multiplication via the :c:member:`~PyTypeObject.tp_as_number.nb_mul` slot.
+   multiplication via the :attr:`tp_as_number.nb_mul` slot.
 
 .. c:member:: ssizeargfunc PySequenceMethods.sq_item
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/c-api/unicode.rst
--- a/Doc/c-api/unicode.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/c-api/unicode.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -576,7 +576,7 @@
 
 
 .. c:function:: int PyUnicode_CopyCharacters(PyObject *to, Py_ssize_t to_start, \
-                    PyObject *from, Py_ssize_t from_start, Py_ssize_t how_many)
+                        PyObject *to, Py_ssize_t from_start, Py_ssize_t how_many)
 
    Copy characters from one Unicode object into another.  This function performs
    character conversion when necessary and falls back to :c:func:`memcpy` if
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/extending/newtypes.rst
--- a/Doc/extending/newtypes.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/extending/newtypes.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -135,11 +135,11 @@
 .. note::
 
    If you want your type to be subclassable from Python, and your type has the same
-   :c:member:`~PyTypeObject.tp_basicsize` as its base type, you may have problems with multiple
+   :attr:`tp_basicsize` as its base type, you may have problems with multiple
    inheritance.  A Python subclass of your type will have to list your type first
    in its :attr:`__bases__`, or else it will not be able to call your type's
    :meth:`__new__` method without getting an error.  You can avoid this problem by
-   ensuring that your type has a larger value for :c:member:`~PyTypeObject.tp_basicsize` than its
+   ensuring that your type has a larger value for :attr:`tp_basicsize` than its
    base type does.  Most of the time, this will be true anyway, because either your
    base type will be :class:`object`, or else you will be adding data members to
    your base type, and therefore increasing its size.
@@ -157,10 +157,9 @@
    Py_TPFLAGS_DEFAULT,        /* tp_flags */
 
 All types should include this constant in their flags.  It enables all of the
-members defined until at least Python 3.3.  If you need further members,
-you will need to OR the corresponding flags.
+members defined by the current version of Python.
 
-We provide a doc string for the type in :c:member:`~PyTypeObject.tp_doc`. ::
+We provide a doc string for the type in :attr:`tp_doc`. ::
 
    "Noddy objects",           /* tp_doc */
 
@@ -169,12 +168,12 @@
 the module.  We'll expand this example later to have more interesting behavior.
 
 For now, all we want to be able to do is to create new :class:`Noddy` objects.
-To enable object creation, we have to provide a :c:member:`~PyTypeObject.tp_new` implementation.
+To enable object creation, we have to provide a :attr:`tp_new` implementation.
 In this case, we can just use the default implementation provided by the API
 function :c:func:`PyType_GenericNew`.  We'd like to just assign this to the
-:c:member:`~PyTypeObject.tp_new` slot, but we can't, for portability sake, On some platforms or
+:attr:`tp_new` slot, but we can't, for portability sake, On some platforms or
 compilers, we can't statically initialize a structure member with a function
-defined in another C module, so, instead, we'll assign the :c:member:`~PyTypeObject.tp_new` slot
+defined in another C module, so, instead, we'll assign the :attr:`tp_new` slot
 in the module initialization function just before calling
 :c:func:`PyType_Ready`::
 
@@ -269,13 +268,13 @@
        Py_TYPE(self)->tp_free((PyObject*)self);
    }
 
-which is assigned to the :c:member:`~PyTypeObject.tp_dealloc` member::
+which is assigned to the :attr:`tp_dealloc` member::
 
    (destructor)Noddy_dealloc, /*tp_dealloc*/
 
 This method decrements the reference counts of the two Python attributes. We use
 :c:func:`Py_XDECREF` here because the :attr:`first` and :attr:`last` members
-could be *NULL*.  It then calls the :c:member:`~PyTypeObject.tp_free` member of the object's type
+could be *NULL*.  It then calls the :attr:`tp_free` member of the object's type
 to free the object's memory.  Note that the object's type might not be
 :class:`NoddyType`, because the object may be an instance of a subclass.
 
@@ -307,7 +306,7 @@
        return (PyObject *)self;
    }
 
-and install it in the :c:member:`~PyTypeObject.tp_new` member::
+and install it in the :attr:`tp_new` member::
 
    Noddy_new,                 /* tp_new */
 
@@ -327,17 +326,17 @@
 created. New methods always accept positional and keyword arguments, but they
 often ignore the arguments, leaving the argument handling to initializer
 methods. Note that if the type supports subclassing, the type passed may not be
-the type being defined.  The new method calls the :c:member:`~PyTypeObject.tp_alloc` slot to
-allocate memory. We don't fill the :c:member:`~PyTypeObject.tp_alloc` slot ourselves. Rather
+the type being defined.  The new method calls the :attr:`tp_alloc` slot to
+allocate memory. We don't fill the :attr:`tp_alloc` slot ourselves. Rather
 :c:func:`PyType_Ready` fills it for us by inheriting it from our base class,
 which is :class:`object` by default.  Most types use the default allocation.
 
 .. note::
 
-   If you are creating a co-operative :c:member:`~PyTypeObject.tp_new` (one that calls a base type's
-   :c:member:`~PyTypeObject.tp_new` or :meth:`__new__`), you must *not* try to determine what method
+   If you are creating a co-operative :attr:`tp_new` (one that calls a base type's
+   :attr:`tp_new` or :meth:`__new__`), you must *not* try to determine what method
    to call using method resolution order at runtime.  Always statically determine
-   what type you are going to call, and call its :c:member:`~PyTypeObject.tp_new` directly, or via
+   what type you are going to call, and call its :attr:`tp_new` directly, or via
    ``type->tp_base->tp_new``.  If you do not do this, Python subclasses of your
    type that also inherit from other Python-defined classes may not work correctly.
    (Specifically, you may not be able to create instances of such subclasses
@@ -374,11 +373,11 @@
        return 0;
    }
 
-by filling the :c:member:`~PyTypeObject.tp_init` slot. ::
+by filling the :attr:`tp_init` slot. ::
 
    (initproc)Noddy_init,         /* tp_init */
 
-The :c:member:`~PyTypeObject.tp_init` slot is exposed in Python as the :meth:`__init__` method. It
+The :attr:`tp_init` slot is exposed in Python as the :meth:`__init__` method. It
 is used to initialize an object after it's created. Unlike the new method, we
 can't guarantee that the initializer is called.  The initializer isn't called
 when unpickling objects and it can be overridden.  Our initializer accepts
@@ -408,7 +407,7 @@
 * when we know that deallocation of the object [#]_ will not cause any calls
   back into our type's code
 
-* when decrementing a reference count in a :c:member:`~PyTypeObject.tp_dealloc` handler when
+* when decrementing a reference count in a :attr:`tp_dealloc` handler when
   garbage-collections is not supported [#]_
 
 We want to expose our instance variables as attributes. There are a
@@ -424,7 +423,7 @@
        {NULL}  /* Sentinel */
    };
 
-and put the definitions in the :c:member:`~PyTypeObject.tp_members` slot::
+and put the definitions in the :attr:`tp_members` slot::
 
    Noddy_members,             /* tp_members */
 
@@ -484,7 +483,7 @@
        {NULL}  /* Sentinel */
    };
 
-and assign them to the :c:member:`~PyTypeObject.tp_methods` slot::
+and assign them to the :attr:`tp_methods` slot::
 
    Noddy_methods,             /* tp_methods */
 
@@ -579,7 +578,7 @@
        {NULL}  /* Sentinel */
    };
 
-and register it in the :c:member:`~PyTypeObject.tp_getset` slot::
+and register it in the :attr:`tp_getset` slot::
 
    Noddy_getseters,           /* tp_getset */
 
@@ -596,7 +595,7 @@
        {NULL}  /* Sentinel */
    };
 
-We also need to update the :c:member:`~PyTypeObject.tp_init` handler to only allow strings [#]_ to
+We also need to update the :attr:`tp_init` handler to only allow strings [#]_ to
 be passed::
 
    static int
@@ -714,7 +713,7 @@
 
 .. note::
 
-   Note that the :c:member:`~PyTypeObject.tp_traverse` implementation must name its arguments exactly
+   Note that the :attr:`tp_traverse` implementation must name its arguments exactly
    *visit* and *arg* in order to use :c:func:`Py_VISIT`.  This is to encourage
    uniformity across these boring implementations.
 
@@ -751,7 +750,7 @@
 reference count drops to zero, we might cause code to run that calls back into
 the object.  In addition, because we now support garbage collection, we also
 have to worry about code being run that triggers garbage collection.  If garbage
-collection is run, our :c:member:`~PyTypeObject.tp_traverse` handler could get called. We can't
+collection is run, our :attr:`tp_traverse` handler could get called. We can't
 take a chance of having :c:func:`Noddy_traverse` called when a member's reference
 count has dropped to zero and its value hasn't been set to *NULL*.
 
@@ -771,8 +770,8 @@
 
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 
-That's pretty much it.  If we had written custom :c:member:`~PyTypeObject.tp_alloc` or
-:c:member:`~PyTypeObject.tp_free` slots, we'd need to modify them for cyclic-garbage collection.
+That's pretty much it.  If we had written custom :attr:`tp_alloc` or
+:attr:`tp_free` slots, we'd need to modify them for cyclic-garbage collection.
 Most extensions will use the versions automatically provided.
 
 
@@ -831,8 +830,8 @@
 
 This pattern is important when writing a type with custom :attr:`new` and
 :attr:`dealloc` methods. The :attr:`new` method should not actually create the
-memory for the object with :c:member:`~PyTypeObject.tp_alloc`, that will be handled by the base
-class when calling its :c:member:`~PyTypeObject.tp_new`.
+memory for the object with :attr:`tp_alloc`, that will be handled by the base
+class when calling its :attr:`tp_new`.
 
 When filling out the :c:func:`PyTypeObject` for the :class:`Shoddy` type, you see
 a slot for :c:func:`tp_base`. Due to cross platform compiler issues, you can't
@@ -858,8 +857,8 @@
    }
 
 Before calling :c:func:`PyType_Ready`, the type structure must have the
-:c:member:`~PyTypeObject.tp_base` slot filled in. When we are deriving a new type, it is not
-necessary to fill out the :c:member:`~PyTypeObject.tp_alloc` slot with :c:func:`PyType_GenericNew`
+:attr:`tp_base` slot filled in. When we are deriving a new type, it is not
+necessary to fill out the :attr:`tp_alloc` slot with :c:func:`PyType_GenericNew`
 -- the allocate function from the base type will be inherited.
 
 After that, calling :c:func:`PyType_Ready` and adding the type object to the
@@ -902,7 +901,7 @@
 
 These fields tell the runtime how much memory to allocate when new objects of
 this type are created.  Python has some built-in support for variable length
-structures (think: strings, lists) which is where the :c:member:`~PyTypeObject.tp_itemsize` field
+structures (think: strings, lists) which is where the :attr:`tp_itemsize` field
 comes in.  This will be dealt with later. ::
 
    char *tp_doc;
@@ -929,9 +928,8 @@
 
 This function is called when the reference count of the instance of your type is
 reduced to zero and the Python interpreter wants to reclaim it.  If your type
-has memory to free or other clean-up to perform, you can put it here.  The
-object itself needs to be freed here as well.  Here is an example of this
-function::
+has memory to free or other clean-up to perform, put it here.  The object itself
+needs to be freed here as well.  Here is an example of this function::
 
    static void
    newdatatype_dealloc(newdatatypeobject * obj)
@@ -964,9 +962,10 @@
 
        if (self->my_callback != NULL) {
            PyObject *err_type, *err_value, *err_traceback;
+           int have_error = PyErr_Occurred() ? 1 : 0;
 
-           /* This saves the current exception state */
-           PyErr_Fetch(&err_type, &err_value, &err_traceback);
+           if (have_error)
+               PyErr_Fetch(&err_type, &err_value, &err_traceback);
 
            cbresult = PyObject_CallObject(self->my_callback, NULL);
            if (cbresult == NULL)
@@ -974,30 +973,14 @@
            else
                Py_DECREF(cbresult);
 
-           /* This restores the saved exception state */
-           PyErr_Restore(err_type, err_value, err_traceback);
+           if (have_error)
+               PyErr_Restore(err_type, err_value, err_traceback);
 
            Py_DECREF(self->my_callback);
        }
        Py_TYPE(obj)->tp_free((PyObject*)self);
    }
 
-.. note::
-   There are limitations to what you can safely do in a deallocator function.
-   First, if your type supports garbage collection (using :c:member:`~PyTypeObject.tp_traverse`
-   and/or :c:member:`~PyTypeObject.tp_clear`), some of the object's members can have been
-   cleared or finalized by the time :c:member:`~PyTypeObject.tp_dealloc` is called.  Second, in
-   :c:member:`~PyTypeObject.tp_dealloc`, your object is in an unstable state: its reference
-   count is equal to zero.  Any call to a non-trivial object or API (as in the
-   example above) might end up calling :c:member:`~PyTypeObject.tp_dealloc` again, causing a
-   double free and a crash.
-
-   Starting with Python 3.4, it is recommended not to put any complex
-   finalization code in :c:member:`~PyTypeObject.tp_dealloc`, and instead use the new
-   :c:member:`~PyTypeObject.tp_finalize` type method.
-
-   .. seealso::
-      :pep:`442` explains the new finalization scheme.
 
 .. index::
    single: string; object representation
@@ -1015,7 +998,7 @@
    reprfunc tp_repr;
    reprfunc tp_str;
 
-The :c:member:`~PyTypeObject.tp_repr` handler should return a string object containing a
+The :attr:`tp_repr` handler should return a string object containing a
 representation of the instance for which it is called.  Here is a simple
 example::
 
@@ -1026,15 +1009,15 @@
                                    obj->obj_UnderlyingDatatypePtr->size);
    }
 
-If no :c:member:`~PyTypeObject.tp_repr` handler is specified, the interpreter will supply a
-representation that uses the type's :c:member:`~PyTypeObject.tp_name` and a uniquely-identifying
+If no :attr:`tp_repr` handler is specified, the interpreter will supply a
+representation that uses the type's :attr:`tp_name` and a uniquely-identifying
 value for the object.
 
-The :c:member:`~PyTypeObject.tp_str` handler is to :func:`str` what the :c:member:`~PyTypeObject.tp_repr` handler
+The :attr:`tp_str` handler is to :func:`str` what the :attr:`tp_repr` handler
 described above is to :func:`repr`; that is, it is called when Python code calls
 :func:`str` on an instance of your object.  Its implementation is very similar
-to the :c:member:`~PyTypeObject.tp_repr` function, but the resulting string is intended for human
-consumption.  If :c:member:`~PyTypeObject.tp_str` is not specified, the :c:member:`~PyTypeObject.tp_repr` handler is
+to the :attr:`tp_repr` function, but the resulting string is intended for human
+consumption.  If :attr:`tp_str` is not specified, the :attr:`tp_repr` handler is
 used instead.
 
 Here is a simple example::
@@ -1099,7 +1082,7 @@
 type object.  Each descriptor controls access to one attribute of the instance
 object.  Each of the tables is optional; if all three are *NULL*, instances of
 the type will only have attributes that are inherited from their base type, and
-should leave the :c:member:`~PyTypeObject.tp_getattro` and :c:member:`~PyTypeObject.tp_setattro` fields *NULL* as
+should leave the :attr:`tp_getattro` and :attr:`tp_setattro` fields *NULL* as
 well, allowing the base type to handle attributes.
 
 The tables are declared as three fields of the type object::
@@ -1108,7 +1091,7 @@
    struct PyMemberDef *tp_members;
    struct PyGetSetDef *tp_getset;
 
-If :c:member:`~PyTypeObject.tp_methods` is not *NULL*, it must refer to an array of
+If :attr:`tp_methods` is not *NULL*, it must refer to an array of
 :c:type:`PyMethodDef` structures.  Each entry in the table is an instance of this
 structure::
 
@@ -1164,13 +1147,13 @@
    single: WRITE_RESTRICTED
    single: RESTRICTED
 
-An interesting advantage of using the :c:member:`~PyTypeObject.tp_members` table to build
+An interesting advantage of using the :attr:`tp_members` table to build
 descriptors that are used at runtime is that any attribute defined this way can
 have an associated doc string simply by providing the text in the table.  An
 application can use the introspection API to retrieve the descriptor from the
 class object, and get the doc string using its :attr:`__doc__` attribute.
 
-As with the :c:member:`~PyTypeObject.tp_methods` table, a sentinel entry with a :attr:`name` value
+As with the :attr:`tp_methods` table, a sentinel entry with a :attr:`name` value
 of *NULL* is required.
 
 .. XXX Descriptors need to be explained in more detail somewhere, but not here.
@@ -1194,7 +1177,7 @@
 called, so that if you do need to extend their functionality, you'll understand
 what needs to be done.
 
-The :c:member:`~PyTypeObject.tp_getattr` handler is called when the object requires an attribute
+The :attr:`tp_getattr` handler is called when the object requires an attribute
 look-up.  It is called in the same situations where the :meth:`__getattr__`
 method of a class would be called.
 
@@ -1214,11 +1197,11 @@
        return NULL;
    }
 
-The :c:member:`~PyTypeObject.tp_setattr` handler is called when the :meth:`__setattr__` or
+The :attr:`tp_setattr` handler is called when the :meth:`__setattr__` or
 :meth:`__delattr__` method of a class instance would be called.  When an
 attribute should be deleted, the third parameter will be *NULL*.  Here is an
 example that simply raises an exception; if this were really all you wanted, the
-:c:member:`~PyTypeObject.tp_setattr` handler should be set to *NULL*. ::
+:attr:`tp_setattr` handler should be set to *NULL*. ::
 
    static int
    newdatatype_setattr(newdatatypeobject *obj, char *name, PyObject *v)
@@ -1234,7 +1217,7 @@
 
    richcmpfunc tp_richcompare;
 
-The :c:member:`~PyTypeObject.tp_richcompare` handler is called when comparisons are needed.  It is
+The :attr:`tp_richcompare` handler is called when comparisons are needed.  It is
 analogous to the :ref:`rich comparison methods <richcmpfuncs>`, like
 :meth:`__lt__`, and also called by :c:func:`PyObject_RichCompare` and
 :c:func:`PyObject_RichCompareBool`.
@@ -1325,7 +1308,7 @@
 
 This function is called when an instance of your data type is "called", for
 example, if ``obj1`` is an instance of your data type and the Python script
-contains ``obj1('hello')``, the :c:member:`~PyTypeObject.tp_call` handler is invoked.
+contains ``obj1('hello')``, the :attr:`tp_call` handler is invoked.
 
 This function takes three arguments:
 
@@ -1412,7 +1395,7 @@
 For an object to be weakly referencable, the extension must include a
 :c:type:`PyObject\*` field in the instance structure for the use of the weak
 reference mechanism; it must be initialized to *NULL* by the object's
-constructor.  It must also set the :c:member:`~PyTypeObject.tp_weaklistoffset` field of the
+constructor.  It must also set the :attr:`tp_weaklistoffset` field of the
 corresponding type object to the offset of the field. For example, the instance
 type is defined with the following structure::
 
@@ -1498,7 +1481,7 @@
 .. [#] This is true when we know that the object is a basic type, like a string or a
    float.
 
-.. [#] We relied on this in the :c:member:`~PyTypeObject.tp_dealloc` handler in this example, because our
+.. [#] We relied on this in the :attr:`tp_dealloc` handler in this example, because our
    type doesn't support garbage collection. Even if a type supports garbage
    collection, there are calls that can be made to "untrack" the object from
    garbage collection, however, these calls are advanced and not covered here.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/includes/typestruct.h
--- a/Doc/includes/typestruct.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/includes/typestruct.h	Mon Aug 12 02:18:40 2013 +0200
@@ -70,11 +70,4 @@
     PyObject *tp_subclasses;
     PyObject *tp_weaklist;
 
-    destructor tp_del;
-
-    /* Type attribute cache version tag. Added in version 2.6 */
-    unsigned int tp_version_tag;
-
-    destructor tp_finalize;
-
 } PyTypeObject;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/aifc.rst
--- a/Doc/library/aifc.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/aifc.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -51,8 +51,7 @@
    used for writing, the file object should be seekable, unless you know ahead of
    time how many samples you are going to write in total and use
    :meth:`writeframesraw` and :meth:`setnframes`.
-   The :func:`.open` function may be used in a :keyword:`with` statement.  When
-   the :keyword:`with` block completes, the :meth:`~aifc.close` method is called.
+   Objects returned by :func:`.open` also supports the :keyword:`with` statement.
 
 .. versionchanged:: 3.4
    Support for the :keyword:`with` statement was added.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/datetime.rst
--- a/Doc/library/datetime.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/datetime.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -170,12 +170,10 @@
    * ``0 <= seconds < 3600*24`` (the number of seconds in one day)
    * ``-999999999 <= days <= 999999999``
 
-   If any argument is a float and there are fractional microseconds,
-   the fractional microseconds left over from all arguments are
-   combined and their sum is rounded to the nearest microsecond using
-   round-half-to-even tiebreaker.  If no argument is a float, the
-   conversion and normalization processes are exact (no information is
-   lost).
+   If any argument is a float and there are fractional microseconds, the fractional
+   microseconds left over from all arguments are combined and their sum is rounded
+   to the nearest microsecond.  If no argument is a float, the conversion and
+   normalization processes are exact (no information is lost).
 
    If the normalized value of days lies outside the indicated range,
    :exc:`OverflowError` is raised.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/difflib.rst
--- a/Doc/library/difflib.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/difflib.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -752,7 +752,7 @@
        # we're passing these as arguments to the diff function
        fromdate = time.ctime(os.stat(fromfile).st_mtime)
        todate = time.ctime(os.stat(tofile).st_mtime)
-       with open(fromfile) as fromf, open(tofile) as tof:
+       with open(fromlines) as fromf, open(tofile) as tof:
            fromlines, tolines = list(fromf), list(tof)
 
        if options.u:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/email.iterators.rst
--- a/Doc/library/email.iterators.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/email.iterators.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -33,22 +33,14 @@
    Thus, by default :func:`typed_subpart_iterator` returns each subpart that has a
    MIME type of :mimetype:`text/\*`.
 
-
 The following function has been added as a useful debugging tool.  It should
 *not* be considered part of the supported public interface for the package.
 
+
 .. function:: _structure(msg, fp=None, level=0, include_default=False)
 
    Prints an indented representation of the content types of the message object
-   structure.  For example:
-
-   .. testsetup::
-
-      >>> import email
-      >>> from email.iterators import _structure
-      >>> somefile = open('Lib/test/test_email/data/msg_02.txt')
-
-   .. doctest::
+   structure.  For example::
 
       >>> msg = email.message_from_file(somefile)
       >>> _structure(msg)
@@ -68,10 +60,6 @@
                   text/plain
           text/plain
 
-   .. testsetup::
-
-      >>> somefile.close()
-
    Optional *fp* is a file-like object to print the output to.  It must be
    suitable for Python's :func:`print` function.  *level* is used internally.
    *include_default*, if true, prints the default type as well.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/email.message.rst
--- a/Doc/library/email.message.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/email.message.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -31,32 +31,19 @@
 Here are the methods of the :class:`Message` class:
 
 
-.. class:: Message(policy=compat32)
+.. class:: Message()
 
-   The *policy* argument determiens the :mod:`~email.policy` that will be used
-   to update the message model.  The default value, :class:`compat32
-   <email.policy.Compat32>` maintains backward compatibility with the
-   Python 3.2 version of the email package.  For more information see the
-   :mod:`~email.policy` documentation.
+   The constructor takes no arguments.
 
-   .. versionchanged:: 3.3 The *policy* keyword argument was added.
 
-
-   .. method:: as_string(unixfrom=False, maxheaderlen=0, policy=None)
+   .. method:: as_string(unixfrom=False, maxheaderlen=0)
 
       Return the entire message flattened as a string.  When optional *unixfrom*
-      is true, the envelope header is included in the returned string.
-      *unixfrom* defaults to ``False``.  For backward compabitility reasons,
-      *maxheaderlen* defaults to ``0``, so if you want a different value you
-      must override it explicitly (the value specified for *max_line_length* in
-      the policy will be ignored by this method).  The *policy* argument may be
-      used to override the default policy obtained from the message instance.
-      This can be used to control some of the formatting produced by the
-      method, since the specified *policy* will be passed to the ``Generator``.
-
-      Flattening the message may trigger changes to the :class:`Message` if
-      defaults need to be filled in to complete the transformation to a string
-      (for example, MIME boundaries may be generated or modified).
+      is ``True``, the envelope header is included in the returned string.
+      *unixfrom* defaults to ``False``.  Flattening the message may trigger
+      changes to the :class:`Message` if defaults need to be filled in to
+      complete the transformation to a string (for example, MIME boundaries may
+      be generated or modified).
 
       Note that this method is provided as a convenience and may not always
       format the message the way you want.  For example, by default it does
@@ -72,57 +59,10 @@
          g.flatten(msg)
          text = fp.getvalue()
 
-      If the message object contains binary data that is not encoded according
-      to RFC standards, the non-compliant data will be replaced by unicode
-      "unknown character" code points.  (See also :meth:`.as_bytes` and
-      :class:`~email.generator.BytesGenerator`.)
-
-      .. versionchanged:: 3.4 the *policy* keyword argument was added.
-
 
    .. method:: __str__()
 
-      Equivalent to :meth:`.as_string()`.  Allows ``str(msg)`` to produce a
-      string containing the formatted message.
-
-
-   .. method:: as_bytes(unixfrom=False, policy=None)
-
-      Return the entire message flattened as a bytes object.  When optional
-      *unixfrom* is true, the envelope header is included in the returned
-      string.  *unixfrom* defaults to ``False``.  The *policy* argument may be
-      used to override the default policy obtained from the message instance.
-      This can be used to control some of the formatting produced by the
-      method, since the specified *policy* will be passed to the
-      ``BytesGenerator``.
-
-      Flattening the message may trigger changes to the :class:`Message` if
-      defaults need to be filled in to complete the transformation to a string
-      (for example, MIME boundaries may be generated or modified).
-
-      Note that this method is provided as a convenience and may not always
-      format the message the way you want.  For example, by default it does
-      not do the mangling of lines that begin with ``From`` that is
-      required by the unix mbox format.  For more flexibility, instantiate a
-      :class:`~email.generator.BytesGenerator` instance and use its
-      :meth:`flatten` method directly.  For example::
-
-         from io import BytesIO
-         from email.generator import BytesGenerator
-         fp = BytesIO()
-         g = BytesGenerator(fp, mangle_from_=True, maxheaderlen=60)
-         g.flatten(msg)
-         text = fp.getvalue()
-
-      .. versionadded:: 3.4
-
-
-   .. method:: __bytes__()
-
-      Equivalent to :meth:`.as_bytes()`.  Allows ``bytes(msg)`` to produce a
-      bytes object containing the formatted message.
-
-      .. versionadded:: 3.4
+      Equivalent to ``as_string(unixfrom=True)``.
 
 
    .. method:: is_multipart()
@@ -573,25 +513,16 @@
       iterator in a ``for`` loop; each iteration returns the next subpart.
 
       Here's an example that prints the MIME type of every part of a multipart
-      message structure:
+      message structure::
 
-       .. testsetup::
-
-            >>> from email import message_from_binary_file
-            >>> with open('Lib/test/test_email/data/msg_16.txt', 'rb') as f:
-            ...     msg = message_from_binary_file(f)
-
-       .. doctest::
-
-            >>> for part in msg.walk():
-            ...     print(part.get_content_type())
-            multipart/report
-            text/plain
-            message/delivery-status
-            text/plain
-            text/plain
-            message/rfc822
-            text/plain
+        >>> for part in msg.walk():
+        ...     print(part.get_content_type())
+        multipart/report
+        text/plain
+        message/delivery-status
+        text/plain
+        text/plain
+        message/rfc822
 
    :class:`Message` objects can also optionally contain two instance attributes,
    which can be used when generating the plain text of a MIME message.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/email.policy.rst
--- a/Doc/library/email.policy.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/email.policy.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -56,42 +56,19 @@
 attributes values changed.
 
 As an example, the following code could be used to read an email message from a
-file on disk and pass it to the system ``sendmail`` program on a Unix system:
+file on disk and pass it to the system ``sendmail`` program on a Unix system::
 
-.. testsetup::
-
-   >>> from unittest import mock
-   >>> mocker = mock.patch('subprocess.Popen')
-   >>> m = mocker.start()
-   >>> proc = mock.MagicMock()
-   >>> m.return_value = proc
-   >>> proc.stdin.close.return_value = None
-   >>> mymsg = open('mymsg.txt', 'w')
-   >>> mymsg.write('To: abc@xyz.com\n\n')
-   17
-   >>> mymsg.flush()
-
-.. doctest::
-
-   >>> from email import message_from_binary_file
+   >>> from email import msg_from_binary_file
    >>> from email.generator import BytesGenerator
-   >>> from email import policy
    >>> from subprocess import Popen, PIPE
-   >>> with open('mymsg.txt', 'rb') as f:
-   ...     msg = message_from_binary_file(f, policy=policy.default)
-   >>> p = Popen(['sendmail', msg['To'].addresses[0]], stdin=PIPE)
+   >>> with open('mymsg.txt', 'b') as f:
+   ...     msg = msg_from_binary_file(f)
+   >>> p = Popen(['sendmail', msg['To'][0].address], stdin=PIPE)
    >>> g = BytesGenerator(p.stdin, policy=msg.policy.clone(linesep='\r\n'))
    >>> g.flatten(msg)
    >>> p.stdin.close()
    >>> rc = p.wait()
 
-.. testsetup::
-
-   >>> mymsg.close()
-   >>> mocker.stop()
-   >>> import os
-   >>> os.remove('mymsg.txt')
-
 Here we are telling :class:`~email.generator.BytesGenerator` to use the RFC
 correct line separator characters when creating the binary string to feed into
 ``sendmail's`` ``stdin``, where the default policy would use ``\n`` line
@@ -105,23 +82,22 @@
 
    >>> import os
    >>> with open('converted.txt', 'wb') as f:
-   ...     f.write(msg.as_bytes(policy=msg.policy.clone(linesep=os.linesep)))
-   17
+   ...     f.write(msg.as_string(policy=msg.policy.clone(linesep=os.linesep))
 
 Policy objects can also be combined using the addition operator, producing a
 policy object whose settings are a combination of the non-default values of the
 summed objects::
 
-   >>> compat_SMTP = policy.compat32.clone(linesep='\r\n')
-   >>> compat_strict = policy.compat32.clone(raise_on_defect=True)
+   >>> compat_SMTP = email.policy.clone(linesep='\r\n')
+   >>> compat_strict = email.policy.clone(raise_on_defect=True)
    >>> compat_strict_SMTP = compat_SMTP + compat_strict
 
 This operation is not commutative; that is, the order in which the objects are
 added matters.  To illustrate::
 
-   >>> policy100 = policy.compat32.clone(max_line_length=100)
-   >>> policy80 = policy.compat32.clone(max_line_length=80)
-   >>> apolicy = policy100 + policy80
+   >>> policy100 = compat32.clone(max_line_length=100)
+   >>> policy80 = compat32.clone(max_line_length=80)
+   >>> apolicy = policy100 + Policy80
    >>> apolicy.max_line_length
    80
    >>> apolicy = policy80 + policy100
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/enum.rst
--- a/Doc/library/enum.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/enum.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -483,7 +483,7 @@
     ...     def __new__(cls):
     ...         value = len(cls.__members__) + 1
     ...         obj = object.__new__(cls)
-    ...         obj._value_ = value
+    ...         obj._value = value
     ...         return obj
     ...
     >>> class Color(AutoNumber):
@@ -505,19 +505,19 @@
     >>> class OrderedEnum(Enum):
     ...     def __ge__(self, other):
     ...         if self.__class__ is other.__class__:
-    ...             return self.value >= other.value
+    ...             return self._value >= other._value
     ...         return NotImplemented
     ...     def __gt__(self, other):
     ...         if self.__class__ is other.__class__:
-    ...             return self.value > other.value
+    ...             return self._value > other._value
     ...         return NotImplemented
     ...     def __le__(self, other):
     ...         if self.__class__ is other.__class__:
-    ...             return self.value <= other.value
+    ...             return self._value <= other._value
     ...         return NotImplemented
     ...     def __lt__(self, other):
     ...         if self.__class__ is other.__class__:
-    ...             return self.value < other.value
+    ...             return self._value < other._value
     ...         return NotImplemented
     ...
     >>> class Grade(OrderedEnum):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/functions.rst
--- a/Doc/library/functions.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/functions.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -996,6 +996,9 @@
       The *opener* parameter was added.
       The ``'x'`` mode was added.
 
+   .. versionchanged:: 3.4
+      The new file descriptor is now non-inheritable.
+
    The type of :term:`file object` returned by the :func:`open` function
    depends on the mode.  When :func:`open` is used to open a file in a text
    mode (``'w'``, ``'r'``, ``'wt'``, ``'rt'``, etc.), it returns a subclass of
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/gc.rst
--- a/Doc/library/gc.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/gc.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -139,8 +139,8 @@
 
    Return a list of objects directly referred to by any of the arguments. The
    referents returned are those objects visited by the arguments' C-level
-   :c:member:`~PyTypeObject.tp_traverse` methods (if any), and may not be all objects actually
-   directly reachable.  :c:member:`~PyTypeObject.tp_traverse` methods are supported only by objects
+   :attr:`tp_traverse` methods (if any), and may not be all objects actually
+   directly reachable.  :attr:`tp_traverse` methods are supported only by objects
    that support garbage collection, and are only required to visit objects that may
    be involved in a cycle.  So, for example, if an integer is directly reachable
    from an argument, that integer object may or may not appear in the result list.
@@ -176,13 +176,24 @@
 
 .. data:: garbage
 
-   A list of objects which the collector found to be unreachable but could
-   not be freed (uncollectable objects).  Starting with Python 3.4, this
-   list should be empty most of the time, except when using instances of
-   C extension types with a non-NULL ``tp_del`` slot.
+   A list of objects which the collector found to be unreachable but could not be
+   freed (uncollectable objects).  By default, this list contains only objects with
+   :meth:`__del__` methods. Objects that have :meth:`__del__` methods and are
+   part of a reference cycle cause the entire reference cycle to be uncollectable,
+   including objects not necessarily in the cycle but reachable only from it.
+   Python doesn't collect such cycles automatically because, in general, it isn't
+   possible for Python to guess a safe order in which to run the :meth:`__del__`
+   methods.  If you know a safe order, you can force the issue by examining the
+   *garbage* list, and explicitly breaking cycles due to your objects within the
+   list.  Note that these objects are kept alive even so by virtue of being in the
+   *garbage* list, so they should be removed from *garbage* too.  For example,
+   after breaking cycles, do ``del gc.garbage[:]`` to empty the list.  It's
+   generally better to avoid the issue by not creating cycles containing objects
+   with :meth:`__del__` methods, and *garbage* can be examined in that case to
+   verify that no such cycles are being created.
 
-   If :const:`DEBUG_SAVEALL` is set, then all unreachable objects will be
-   added to this list rather than freed.
+   If :const:`DEBUG_SAVEALL` is set, then all unreachable objects will be added
+   to this list rather than freed.
 
    .. versionchanged:: 3.2
       If this list is non-empty at interpreter shutdown, a
@@ -190,10 +201,6 @@
       :const:`DEBUG_UNCOLLECTABLE` is set, in addition all uncollectable objects
       are printed.
 
-   .. versionchanged:: 3.4
-      Following :pep:`442`, objects with a :meth:`__del__` method don't end
-      up in :attr:`gc.garbage` anymore.
-
 .. data:: callbacks
 
    A list of callbacks that will be invoked by the garbage collector before and
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/hashlib.rst
--- a/Doc/library/hashlib.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/hashlib.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -124,18 +124,6 @@
 
    The internal block size of the hash algorithm in bytes.
 
-A hash object has the following attributes:
-
-.. attribute:: hash.name
-
-   The canonical name of this hash, always lowercase and always suitable as a
-   parameter to :func:`new` to create another hash of this type.
-
-   .. versionchanged:: 3.4
-      The name attribute has been present in CPython since its inception, but
-      until Python 3.4 was not formally specified, so may not exist on some
-      platforms.
-
 A hash object has the following methods:
 
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/inspect.rst
--- a/Doc/library/inspect.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/inspect.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -797,23 +797,6 @@
    .. versionadded:: 3.3
 
 
-.. function:: unwrap(func, *, stop=None)
-
-   Get the object wrapped by *func*. It follows the chain of :attr:`__wrapped__`
-   attributes returning the last object in the chain.
-
-   *stop* is an optional callback accepting an object in the wrapper chain
-   as its sole argument that allows the unwrapping to be terminated early if
-   the callback returns a true value. If the callback never returns a true
-   value, the last object in the chain is returned as usual. For example,
-   :func:`signature` uses this to stop unwrapping if any object in the
-   chain has a ``__signature__`` attribute defined.
-
-   :exc:`ValueError` is raised if a cycle is encountered.
-
-   .. versionadded:: 3.4
-
-
 .. _inspect-stack:
 
 The interpreter stack
@@ -846,10 +829,6 @@
           finally:
               del frame
 
-   If you want to keep the frame around (for example to print a traceback
-   later), you can also break reference cycles by using the
-   :meth:`frame.clear` method.
-
 The optional *context* argument supported by most of these functions specifies
 the number of lines of context to return, which are centered around the current
 line.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/io.rst
--- a/Doc/library/io.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/io.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -522,6 +522,8 @@
    :mod:`os.open` as *opener* results in functionality similar to passing
    ``None``).
 
+   The newly created file is :ref:`non-inheritable <fd_inheritance>`.
+
    See the :func:`open` built-in function for examples on using the *opener*
    parameter.
 
@@ -529,6 +531,9 @@
       The *opener* parameter was added.
       The ``'x'`` mode was added.
 
+   .. versionchanged:: 3.4
+      The file is now non-inheritable.
+
    In addition to the attributes and methods from :class:`IOBase` and
    :class:`RawIOBase`, :class:`FileIO` provides the following data
    attributes:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/json.rst
--- a/Doc/library/json.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/json.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -349,26 +349,23 @@
 
    .. _py-to-json-table:
 
-   +----------------------------------------+---------------+
-   | Python                                 | JSON          |
-   +========================================+===============+
-   | dict                                   | object        |
-   +----------------------------------------+---------------+
-   | list, tuple                            | array         |
-   +----------------------------------------+---------------+
-   | str                                    | string        |
-   +----------------------------------------+---------------+
-   | int, float, int- & float-derived Enums | number        |
-   +----------------------------------------+---------------+
-   | True                                   | true          |
-   +----------------------------------------+---------------+
-   | False                                  | false         |
-   +----------------------------------------+---------------+
-   | None                                   | null          |
-   +----------------------------------------+---------------+
-
-   .. versionchanged:: 3.4
-      Added support for int- and float-derived Enum classes.
+   +-------------------+---------------+
+   | Python            | JSON          |
+   +===================+===============+
+   | dict              | object        |
+   +-------------------+---------------+
+   | list, tuple       | array         |
+   +-------------------+---------------+
+   | str               | string        |
+   +-------------------+---------------+
+   | int, float        | number        |
+   +-------------------+---------------+
+   | True              | true          |
+   +-------------------+---------------+
+   | False             | false         |
+   +-------------------+---------------+
+   | None              | null          |
+   +-------------------+---------------+
 
    To extend this to recognize other objects, subclass and implement a
    :meth:`default` method with another method that returns a serializable object
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/os.rst
--- a/Doc/library/os.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/os.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -685,17 +685,31 @@
 
 .. function:: dup(fd)
 
-   Return a duplicate of file descriptor *fd*.
+   Return a duplicate of file descriptor *fd*. The new file descriptor is
+   :ref:`non-inheritable <fd_inheritance>`.
+
+   On Windows, when duplicating a standard stream (0: stdin, 1: stdout,
+   2: stderr), the new file descriptor is :ref:`inheritable
+   <fd_inheritance>`.
 
    Availability: Unix, Windows.
 
+   .. versionchanged:: 3.4
+      The new file descriptor is now non-inheritable.
+
 
 .. function:: dup2(fd, fd2)
 
    Duplicate file descriptor *fd* to *fd2*, closing the latter first if necessary.
+   If *fd2* is ``0`` (stdin), ``1`` (stdout) or ``2`` (stderr), *fd2* is set to
+   :ref:`inheritable <fd_inheritance>`, otherwise *fd2* is set to
+   non-inheritable.
 
    Availability: Unix, Windows.
 
+   .. versionchanged:: 3.4
+      *fd2* is now set to non-inheritable.
+
 
 .. function:: fchmod(fd, mode)
 
@@ -848,6 +862,7 @@
    Open the file *file* and set various flags according to *flags* and possibly
    its mode according to *mode*.  When computing *mode*, the current umask value
    is first masked out.  Return the file descriptor for the newly opened file.
+   The new file descriptor is :ref:`non-inheritable <fd_inheritance>`.
 
    For a description of the flag and mode values, see the C run-time documentation;
    flag constants (like :const:`O_RDONLY` and :const:`O_WRONLY`) are defined in
@@ -859,6 +874,9 @@
 
    Availability: Unix, Windows.
 
+   .. versionchanged:: 3.4
+      The new file descriptor is now non-inheritable.
+
    .. note::
 
       This function is intended for low-level I/O.  For normal usage, use the
@@ -928,20 +946,28 @@
 
    .. index:: module: pty
 
-   Open a new pseudo-terminal pair. Return a pair of file descriptors ``(master,
-   slave)`` for the pty and the tty, respectively. For a (slightly) more portable
-   approach, use the :mod:`pty` module.
+   Open a new pseudo-terminal pair. Return a pair of file descriptors
+   ``(master, slave)`` for the pty and the tty, respectively. The new file
+   descriptors are :ref:`non-inheritable <fd_inheritance>`. For a (slightly) more
+   portable approach, use the :mod:`pty` module.
 
    Availability: some flavors of Unix.
 
+   .. versionchanged:: 3.4
+      The new file descriptors are now non-inheritable.
+
 
 .. function:: pipe()
 
-   Create a pipe.  Return a pair of file descriptors ``(r, w)`` usable for reading
-   and writing, respectively.
+   Create a pipe.  Return a pair of file descriptors ``(r, w)`` usable for
+   reading and writing, respectively. The new file descriptor are
+   :ref:`non-inheritable <fd_inheritance>`.
 
    Availability: Unix, Windows.
 
+   .. versionchanged:: 3.4
+      The new file descriptors are now non-inheritable.
+
 
 .. function:: pipe2(flags)
 
@@ -1173,6 +1199,48 @@
       Height of the terminal window in characters.
 
 
+.. _fd_inheritance:
+
+Inheritance of File Descriptors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A file descriptor has a inheritable flag which indicates if the file descriptor
+will be inherited or not in child processes. Since Python 3.4, file descriptors
+created by Python are non-inheritable by default.
+
+On UNIX, file descriptors with the inheritable flag unset are be closed in
+child processes at the execution (not at fork), other file descriptors are
+inherited.
+
+On Windows, handles and file descriptors with the inheritable flag unset are
+closed in child processes. There are 3 exceptions: file descriptors 0 (stdin),
+1 (stdout) and 2 (stderr) are inherited. Handles with the inheritable flag set
+are only inherited by child processes if the :mod:`subprocess` module is used
+with *close_fds* parameter set to ``False``. All file descriptors (except 0, 1
+and 2) are always closed when using the :mod:`subprocess` module, *close_fds*
+only concern handles. For :func:`os.spawn\*p\*` functions, handles and file
+descriptors with the inheritable flag set are all inherited.
+
+.. function:: get_inheritable(fd)
+
+    Get the inheritable flag of the specified file descriptor. Return a
+    :class:`bool`.
+
+    Availability: Windows, Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, Solaris.
+
+   .. versionadded:: 3.4
+
+.. function:: set_inheritable(fd, inheritable)
+
+    Set or clear the inheritable flag on the specified file descriptor.
+
+    Availability: Windows, Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, Solaris.
+
+   .. versionadded:: 3.4
+
+
+
+
 .. _os-file-dir:
 
 Files and Directories
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/select.rst
--- a/Doc/library/select.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/select.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -37,8 +37,13 @@
    increases this value, :c:func:`devpoll` may return an
    incomplete list of active file descriptors.
 
+   The new file descriptor is :ref:`non-inheritable <fd_inheritance>`.
+
    .. versionadded:: 3.3
 
+   .. versionchanged:: 3.4
+      The new file descriptor is now non-inheritable.
+
 .. function:: epoll(sizehint=-1, flags=0)
 
    (Only supported on Linux 2.5.44 and newer.) Return an edge polling object,
@@ -49,11 +54,14 @@
    :ref:`epoll-objects` below for the methods supported by epolling objects.
    They also support the :keyword:`with` statement.
 
+   The new file descriptor is :ref:`non-inheritable <fd_inheritance>`.
+
    .. versionchanged:: 3.3
       Added the *flags* parameter.
 
    .. versionchanged:: 3.4
       Support for the :keyword:`with` statement was added.
+      The new file descriptor is now non-inheritable.
 
 
 .. function:: poll()
@@ -69,6 +77,11 @@
    (Only supported on BSD.)  Returns a kernel queue object; see section
    :ref:`kqueue-objects` below for the methods supported by kqueue objects.
 
+   The new file descriptor is :ref:`non-inheritable <fd_inheritance>`.
+
+   .. versionchanged:: 3.4
+      The new file descriptor is now non-inheritable.
+
 
 .. function:: kevent(ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0)
 
@@ -199,6 +212,13 @@
    block until there is an event for this poll object.
 
 
+.. method:: devpoll.fileno()
+
+   Return the file descriptor number.
+
+   .. versionadded:: 3.4
+
+
 .. _epoll-objects:
 
 Edge and Level Trigger Polling (epoll) Objects
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/socket.rst
--- a/Doc/library/socket.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/socket.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -460,7 +460,7 @@
    ``'udp'``, otherwise any protocol will match.
 
 
-.. function:: socket([family[, type[, proto]]])
+.. function:: socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)
 
    Create a new socket using the given address family, socket type and protocol
    number.  The address family should be :const:`AF_INET` (the default),
@@ -471,14 +471,20 @@
    case where the address family is :const:`AF_CAN` the protocol should be one
    of :const:`CAN_RAW` or :const:`CAN_BCM`.
 
+   The newly created socket is :ref:`non-inheritable <fd_inheritance>`.
+
    .. versionchanged:: 3.3
       The AF_CAN family was added.
       The AF_RDS family was added.
 
-  .. versionchanged:: 3.4
-      The CAN_BCM protocol was added.
+   .. versionchanged:: 3.4
+       The CAN_BCM protocol was added.
 
-.. function:: socketpair([family[, type[, proto]]])
+   .. versionchanged:: 3.4
+      The socket is now non-inheritable.
+
+
+.. function:: socketpair(family=AF_INET, type=SOCK_STREAM, proto=0)
 
    Build a pair of connected socket objects using the given address family, socket
    type, and protocol number.  Address family, socket type, and protocol number are
@@ -486,12 +492,17 @@
    if defined on the platform; otherwise, the default is :const:`AF_INET`.
    Availability: Unix.
 
+   The newly created sockets are :ref:`non-inheritable <fd_inheritance>`.
+
    .. versionchanged:: 3.2
       The returned socket objects now support the whole socket API, rather
       than a subset.
 
+   .. versionchanged:: 3.4
+      The sockets are now non-inheritable.
 
-.. function:: fromfd(fd, family, type[, proto])
+
+.. function:: fromfd(fd, family, type, proto=0)
 
    Duplicate the file descriptor *fd* (an integer as returned by a file object's
    :meth:`fileno` method) and build a socket object from the result.  Address
@@ -730,6 +741,11 @@
    *new* socket object usable to send and receive data on the connection, and
    *address* is the address bound to the socket on the other end of the connection.
 
+   The newly created socket is :ref:`non-inheritable <fd_inheritance>`.
+
+   .. versionchanged:: 3.4
+      The socket is now non-inheritable.
+
 
 .. method:: socket.bind(address)
 
@@ -775,6 +791,16 @@
    .. versionadded:: 3.2
 
 
+.. method:: socket.dup()
+
+   Duplicate the socket.
+
+   The newly created socket is :ref:`non-inheritable <fd_inheritance>`.
+
+   .. versionchanged:: 3.4
+      The socket is now non-inheritable.
+
+
 .. method:: socket.fileno()
 
    Return the socket's file descriptor (a small integer).  This is useful with
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/ssl.rst
--- a/Doc/library/ssl.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/ssl.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -859,7 +859,7 @@
    does not contain certificates from *capath* unless a certificate was
    requested and loaded by a SSL connection.
 
-   .. versionadded:: 3.4
+   ..versionadded:: 3.4
 
 .. method:: SSLContext.set_default_verify_paths()
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/stdtypes.rst
--- a/Doc/library/stdtypes.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/stdtypes.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -751,7 +751,7 @@
    iterators for those iteration types.  (An example of an object supporting
    multiple forms of iteration would be a tree structure which supports both
    breadth-first and depth-first traversal.)  This method corresponds to the
-   :c:member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects in the Python/C
+   :attr:`tp_iter` slot of the type structure for Python objects in the Python/C
    API.
 
 The iterator objects themselves are required to support the following two
@@ -762,7 +762,7 @@
 
    Return the iterator object itself.  This is required to allow both containers
    and iterators to be used with the :keyword:`for` and :keyword:`in` statements.
-   This method corresponds to the :c:member:`~PyTypeObject.tp_iter` slot of the type structure for
+   This method corresponds to the :attr:`tp_iter` slot of the type structure for
    Python objects in the Python/C API.
 
 
@@ -770,7 +770,7 @@
 
    Return the next item from the container.  If there are no further items, raise
    the :exc:`StopIteration` exception.  This method corresponds to the
-   :c:member:`~PyTypeObject.tp_iternext` slot of the type structure for Python objects in the
+   :attr:`tp_iternext` slot of the type structure for Python objects in the
    Python/C API.
 
 Python defines several iterator objects to support iteration over general and
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/test.rst
--- a/Doc/library/test.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/test.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -387,40 +387,18 @@
       self.assertEqual(captured, "hello")
 
 
-.. function:: temp_dir(path=None, quiet=False)
-
-   A context manager that creates a temporary directory at *path* and
-   yields the directory.
-
-   If *path* is None, the temporary directory is created using
-   :func:`tempfile.mkdtemp`.  If *quiet* is ``False``, the context manager
-   raises an exception on error.  Otherwise, if *path* is specified and
-   cannot be created, only a warning is issued.
-
-
-.. function:: change_cwd(path, quiet=False)
+.. function:: temp_cwd(name='tempcwd', quiet=False, path=None)
 
    A context manager that temporarily changes the current working
-   directory to *path* and yields the directory.
+   directory (CWD).
 
-   If *quiet* is ``False``, the context manager raises an exception
-   on error.  Otherwise, it issues only a warning and keeps the current
-   working directory the same.
+   An existing path may be provided as *path*, in which case this function
+   makes no changes to the file system.
 
-
-.. function:: temp_cwd(name='tempcwd', quiet=False)
-
-   A context manager that temporarily creates a new directory and
-   changes the current working directory (CWD).
-
-   The context manager creates a temporary directory in the current
-   directory with name *name* before temporarily changing the current
-   working directory.  If *name* is None, the temporary directory is
-   created using :func:`tempfile.mkdtemp`.
-
-   If *quiet* is ``False`` and it is not possible to create or change
-   the CWD, an error is raised.  Otherwise, only a warning is raised
-   and the original CWD is used.
+   Otherwise, the new CWD is created in the current directory and it's named
+   *name*.  If *quiet* is ``False`` and it's not possible to create or
+   change the CWD, an error is raised.  If it's ``True``, only a warning
+   is raised and the original CWD is used.
 
 
 .. function:: temp_umask(umask)
@@ -489,7 +467,7 @@
    *fresh* is an iterable of additional module names that are also removed
    from the ``sys.modules`` cache before doing the import.
 
-   *blocked* is an iterable of module names that are replaced with ``None``
+   *blocked* is an iterable of module names that are replaced with :const:`0`
    in the module cache during the import to ensure that attempts to import
    them raise :exc:`ImportError`.
 
@@ -500,15 +478,15 @@
    Module and package deprecation messages are suppressed during this import
    if *deprecated* is ``True``.
 
-   This function will raise :exc:`ImportError` if the named module cannot be
-   imported.
+   This function will raise :exc:`unittest.SkipTest` if the named module
+   cannot be imported.
 
    Example use::
 
-      # Get copies of the warnings module for testing without affecting the
-      # version being used by the rest of the test suite. One copy uses the
-      # C implementation, the other is forced to use the pure Python fallback
-      # implementation
+      # Get copies of the warnings module for testing without
+      # affecting the version being used by the rest of the test suite
+      # One copy uses the C implementation, the other is forced to use
+      # the pure Python fallback implementation
       py_warnings = import_fresh_module('warnings', blocked=['_warnings'])
       c_warnings = import_fresh_module('warnings', fresh=['_warnings'])
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/unittest.rst
--- a/Doc/library/unittest.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/unittest.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -974,25 +974,25 @@
       Test that a warning is triggered when *callable* is called with any
       positional or keyword arguments that are also passed to
       :meth:`assertWarns`.  The test passes if *warning* is triggered and
-      fails if it isn't.  Any exception is an error.
+      fails if it isn't.  Also, any unexpected exception is an error.
       To catch any of a group of warnings, a tuple containing the warning
       classes may be passed as *warnings*.
 
       If only the *warning* and possibly the *msg* arguments are given,
-      return a context manager so that the code under test can be written
+      returns a context manager so that the code under test can be written
       inline rather than as a function::
 
          with self.assertWarns(SomeWarning):
              do_something()
 
-      When used as a context manager, :meth:`assertWarns` accepts the
+      When used as a context manager, :meth:`assertRaises` accepts the
       additional keyword argument *msg*.
 
       The context manager will store the caught warning object in its
       :attr:`warning` attribute, and the source line which triggered the
       warnings in the :attr:`filename` and :attr:`lineno` attributes.
       This can be useful if the intention is to perform additional checks
-      on the warning caught::
+      on the exception raised::
 
          with self.assertWarns(SomeWarning) as cm:
              do_something()
@@ -1077,7 +1077,7 @@
       like the :func:`round` function) and not *significant digits*.
 
       If *delta* is supplied instead of *places* then the difference
-      between *first* and *second* must be less or equal to (or greater than) *delta*.
+      between *first* and *second* must be less (or more) than *delta*.
 
       Supplying both *delta* and *places* raises a ``TypeError``.
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/wave.rst
--- a/Doc/library/wave.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/wave.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -19,30 +19,26 @@
 .. function:: open(file, mode=None)
 
    If *file* is a string, open the file by that name, otherwise treat it as a
-   seekable file-like object.  *mode* can be:
+   seekable file-like object.  *mode* can be any of
 
-   ``'rb'``
+   ``'r'``, ``'rb'``
       Read only mode.
 
-   ``'wb'``
+   ``'w'``, ``'wb'``
       Write only mode.
 
    Note that it does not allow read/write WAV files.
 
-   A *mode* of ``'rb'`` returns a :class:`Wave_read` object, while a *mode* of
-   ``'wb'`` returns a :class:`Wave_write` object.  If *mode* is omitted and a
-   file-like object is passed as *file*, ``file.mode`` is used as the default
-   value for *mode*.
+   A *mode* of ``'r'`` or ``'rb'`` returns a :class:`Wave_read` object, while a
+   *mode* of ``'w'`` or ``'wb'`` returns a :class:`Wave_write` object.  If
+   *mode* is omitted and a file-like object is passed as *file*, ``file.mode``
+   is used as the default value for *mode* (the ``'b'`` flag is still added if
+   necessary).
 
    If you pass in a file-like object, the wave object will not close it when its
    :meth:`close` method is called; it is the caller's responsibility to close
    the file object.
 
-   The :func:`.open` function may be used in a :keyword:`with` statement.  When
-   the :keyword:`with` block completes, the :meth:`Wave_read.close()
-   <wave.Wave_read.close>` or :meth:`Wave_write.close()
-   <wave.Wave_write.close()>` method is called.
-
 
 .. function:: openfp(file, mode)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/weakref.rst
--- a/Doc/library/weakref.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/weakref.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -529,13 +529,22 @@
         def __del__(self):
             self.remove()
 
-This solution has a serious problem: the :meth:`__del__` method may be
-called at shutdown after the :mod:`shutil` module has been cleaned up,
-in which case :attr:`shutil.rmtree` will have been replaced by :const:`None`.
-This will cause the :meth:`__del__` method to fail and the directory
-will not be removed.
+This solution has a couple of serious problems:
 
-Using finalizers we can avoid this problem::
+* There is no guarantee that the object will be garbage collected
+  before the program exists, so the directory might be left.  This is
+  because reference cycles containing an object with a :meth:`__del__`
+  method can never be collected.  And even if the :class:`TempDir`
+  object is not itself part of a reference cycle, it may still be kept
+  alive by some unkown uncollectable reference cycle.
+
+* The :meth:`__del__` method may be called at shutdown after the
+  :mod:`shutil` module has been cleaned up, in which case
+  :attr:`shutil.rmtree` will have been replaced by :const:`None`.
+  This will cause the :meth:`__del__` method to fail and the directory
+  will not be removed.
+
+Using finalizers we can avoid these problems::
 
     class TempDir:
         def __init__(self):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/xml.etree.elementtree.rst
--- a/Doc/library/xml.etree.elementtree.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/xml.etree.elementtree.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -416,8 +416,7 @@
    and ``"end-ns"`` (the "ns" events are used to get detailed namespace
    information).  If *events* is omitted, only ``"end"`` events are reported.
    *parser* is an optional parser instance.  If not given, the standard
-   :class:`XMLParser` parser is used.  *parser* can only use the default
-   :class:`TreeBuilder` as a target.  Returns an :term:`iterator` providing
+   :class:`XMLParser` parser is used.  Returns an :term:`iterator` providing
    ``(event, elem)`` pairs.
 
    Note that while :func:`iterparse` builds the tree incrementally, it issues
@@ -881,7 +880,7 @@
    events are used to get detailed namespace information).  If *events* is
    omitted, only ``"end"`` events are reported.  *parser* is an optional
    parser instance.  If not given, the standard :class:`XMLParser` parser is
-   used.  *parser* can only use the default :class:`TreeBuilder` as a target.
+   used.
 
    .. method:: data_received(data)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/library/xmlrpc.client.rst
--- a/Doc/library/xmlrpc.client.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/library/xmlrpc.client.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -439,14 +439,14 @@
 
    from xmlrpc.server import SimpleXMLRPCServer
 
-   def add(x, y):
-       return x + y
+   def add(x,y):
+       return x+y
 
    def subtract(x, y):
-       return x - y
+       return x-y
 
    def multiply(x, y):
-       return x * y
+       return x*y
 
    def divide(x, y):
        return x // y
@@ -467,13 +467,13 @@
 
    proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
    multicall = xmlrpc.client.MultiCall(proxy)
-   multicall.add(7, 3)
-   multicall.subtract(7, 3)
-   multicall.multiply(7, 3)
-   multicall.divide(7, 3)
+   multicall.add(7,3)
+   multicall.subtract(7,3)
+   multicall.multiply(7,3)
+   multicall.divide(7,3)
    result = multicall()
 
-   print("7+3=%d, 7-3=%d, 7*3=%d, 7//3=%d" % tuple(result))
+   print("7+3=%d, 7-3=%d, 7*3=%d, 7/3=%d" % tuple(result))
 
 
 Convenience Functions
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/reference/datamodel.rst
--- a/Doc/reference/datamodel.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/reference/datamodel.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -934,20 +934,6 @@
       frame).  A debugger can implement a Jump command (aka Set Next Statement)
       by writing to f_lineno.
 
-      Frame objects support one method:
-
-      .. method:: frame.clear()
-
-         This method clears all references to local variables held by the
-         frame.  Also, if the frame belonged to a generator, the generator
-         is finalized.  This helps break reference cycles involving frame
-         objects (for example when catching an exception and storing its
-         traceback for later use).
-
-         :exc:`RuntimeError` is raised if the frame is currently executing.
-
-         .. versionadded:: 3.4
-
    Traceback objects
       .. index::
          object: traceback
@@ -1134,10 +1120,12 @@
       ``sys.last_traceback`` keeps the stack frame alive).  The first situation
       can only be remedied by explicitly breaking the cycles; the latter two
       situations can be resolved by storing ``None`` in ``sys.last_traceback``.
-      Circular references which are garbage are detected and cleaned up when
-      the cyclic garbage collector is enabled (it's on by default). Refer to the
-      documentation for the :mod:`gc` module for more information about this
-      topic.
+      Circular references which are garbage are detected when the option cycle
+      detector is enabled (it's on by default), but can only be cleaned up if
+      there are no Python- level :meth:`__del__` methods involved. Refer to the
+      documentation for the :mod:`gc` module for more information about how
+      :meth:`__del__` methods are handled by the cycle detector, particularly
+      the description of the ``garbage`` value.
 
    .. warning::
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/tutorial/inputoutput.rst
--- a/Doc/tutorial/inputoutput.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/tutorial/inputoutput.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -322,11 +322,9 @@
    >>> f.write(s)
    18
 
-``f.tell()`` returns an integer giving the file object's current position in the file
-represented as number of bytes from the beginning of the file when in `binary mode` and
-an opaque number when in `text mode`.
-
-To change the file object's position, use ``f.seek(offset, from_what)``.  The position is computed
+``f.tell()`` returns an integer giving the file object's current position in the
+file, measured in bytes from the beginning of the file.  To change the file
+object's position, use ``f.seek(offset, from_what)``.  The position is computed
 from adding *offset* to a reference point; the reference point is selected by
 the *from_what* argument.  A *from_what* value of 0 measures from the beginning
 of the file, 1 uses the current file position, and 2 uses the end of the file as
@@ -347,10 +345,7 @@
 
 In text files (those opened without a ``b`` in the mode string), only seeks
 relative to the beginning of the file are allowed (the exception being seeking
-to the very file end with ``seek(0, 2)``) and the only valid *offset* values are
-those returned from the ``f.tell()``, or zero. Any other *offset* value produces
-undefined behaviour.
-
+to the very file end with ``seek(0, 2)``).
 
 When you're done with a file, call ``f.close()`` to close it and free up any
 system resources taken up by the open file.  After calling ``f.close()``,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/using/cmdline.rst
--- a/Doc/using/cmdline.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/using/cmdline.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -24,7 +24,7 @@
 
 When invoking Python, you may specify any of these options::
 
-    python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]
+    python [-bBdEhiOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]
 
 The most common use case is, of course, a simple invocation of a script::
 
@@ -175,8 +175,6 @@
        Python 3.0
 
 
-.. _using-on-misc-options:
-
 Miscellaneous options
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -215,17 +213,6 @@
    raises an exception.  See also :envvar:`PYTHONINSPECT`.
 
 
-.. cmdoption:: -I
-
-   Run Python in isolated mode. This also implies -E and -s.
-   In isolated mode :data:`sys.path` contains neither the script's directory nor
-   the user's site-packages directory. All :envvar:`PYTHON*` environment
-   variables are ignored, too. Further restrictions may be imposed to prevent
-   the user from injecting malicious code.
-
-   .. versionadded:: 3.4
-
-
 .. cmdoption:: -O
 
    Turn on basic optimizations.  This changes the filename extension for
@@ -411,7 +398,7 @@
 ---------------------
 
 These environment variables influence Python's behavior, they are processed
-before the command-line switches other than -E or -I.  It is customary that
+before the command-line switches other than -E.  It is customary that
 command-line switches override environmental variables where there is a
 conflict.
 
@@ -588,8 +575,6 @@
    Python traceback.  This is equivalent to :option:`-X` ``faulthandler``
    option.
 
-   .. versionadded:: 3.3
-
 
 Debug-mode variables
 ~~~~~~~~~~~~~~~~~~~~
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/whatsnew/2.2.rst
--- a/Doc/whatsnew/2.2.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/whatsnew/2.2.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -450,9 +450,9 @@
 Python classes can define an :meth:`__iter__` method, which should create and
 return a new iterator for the object; if the object is its own iterator, this
 method can just return ``self``.  In particular, iterators will usually be their
-own iterators.  Extension types implemented in C can implement a :c:member:`~PyTypeObject.tp_iter`
+own iterators.  Extension types implemented in C can implement a :attr:`tp_iter`
 function in order to return an iterator, and extension types that want to behave
-as iterators can define a :c:member:`~PyTypeObject.tp_iternext` function.
+as iterators can define a :attr:`tp_iternext` function.
 
 So, after all this, what do iterators actually do?  They have one required
 method, :meth:`next`, which takes no arguments and returns the next value.  When
@@ -478,7 +478,7 @@
 In 2.2, Python's :keyword:`for` statement no longer expects a sequence; it
 expects something for which :func:`iter` will return an iterator. For backward
 compatibility and convenience, an iterator is automatically constructed for
-sequences that don't implement :meth:`__iter__` or a :c:member:`~PyTypeObject.tp_iter` slot, so
+sequences that don't implement :meth:`__iter__` or a :attr:`tp_iter` slot, so
 ``for i in [1,2,3]`` will still work.  Wherever the Python interpreter loops
 over a sequence, it's been changed to use the iterator protocol.  This means you
 can do things like this::
diff -r 9e61563edb67 -r 1f8979a8c2c5 Doc/whatsnew/3.4.rst
--- a/Doc/whatsnew/3.4.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Doc/whatsnew/3.4.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -107,8 +107,7 @@
 
 Security improvements:
 
-* command line option for :ref:`isolated mode <using-on-misc-options>`,
-  :issue:`16499`.
+* None yet.
 
 Please read on for a comprehensive list of user-facing changes.
 
@@ -120,21 +119,6 @@
 Python memory allocators.
 
 
-.. _pep-442:
-
-PEP 442: Safe object finalization
-=================================
-
-This PEP removes the current limitations and quirks of object finalization.
-With it, objects with :meth:`__del__` methods, as well as generators
-with :keyword:`finally` clauses, can be finalized when they are part of a
-reference cycle.
-
-.. seealso::
-
-   :pep:`442` - Safe object finalization
-      PEP written and implemented by Antoine Pitrou
-
 
 Other Language Changes
 ======================
@@ -196,40 +180,11 @@
 plain tuple.  (Contributed by Claudiu Popa in :issue:`17818`.)
 
 
-email
------
-
-:meth:`~email.message.Message.as_string` now accepts a *policy* argument to
-override the default policy of the message when generating a string
-representation of it.  This means that ``as_string`` can now be used in more
-circumstances, instead of having to create and use a :mod:`~email.generator` in
-order to pass formatting parameters to its ``flatten`` method.
-
-New method :meth:`~email.message.Message.as_bytes` added to produce a bytes
-representation of the message in a fashion similar to how ``as_string``
-produces a string representation.  It does not accept the *maxheaderlen*
-argument, but does accept the *unixfrom* and *policy* arguments. The
-:class:`~email.message.Message` :meth:`~email.message.Message.__bytes__` method
-calls it, meaning that ``bytes(mymsg)`` will now produce the intuitive
-result:  a bytes object containing the fully formatted message.
-
-(Contributed by R. David Murray in :issue:`18600`.)
-
-
 functools
 ---------
 
 New :func:`functools.singledispatch` decorator: see the :pep:`443`.
 
-
-inspect
--------
-
-:func:`~inspect.unwrap` makes it easy to unravel wrapper function chains
-created by :func:`functools.wraps` (and any other API that sets the
-``__wrapped__`` attribute on a wrapper function).
-
-
 smtplib
 -------
 
@@ -260,26 +215,13 @@
 The :meth:`~wave.getparams` method now returns a namedtuple rather than a
 plain tuple.  (Contributed by Claudiu Popa in :issue:`17487`.)
 
-:meth:`wave.open` now supports the context manager protocol.  (Contributed
-by Claudiu Popa in :issue:`17616`.)
+stat
+---
 
-stat
-----
-
-The :mod:`stat` module is now backed by a C implementation in :mod:`_stat`. A C
+The stat module is now backed by a C implementation in :mod:`_stat`. A C
 implementation is required as most of the values aren't standardized and
 platform-dependent.  (Contributed by Christian Heimes in :issue:`11016`.)
 
-The module supports new file types: door, event port and whiteout.
-
-colorsys
---------
-
-The number of digits in the coefficients for the RGB --- YIQ conversions have
-been expanded so that they match the FCC NTSC versions.  The change in
-results should be less than 1% and may better match results found elsewhere.
-
-
 Optimizations
 =============
 
@@ -302,8 +244,7 @@
 Unsupported Operating Systems
 -----------------------------
 
-* OS/2
-* Windows 2000
+* None yet.
 
 
 Deprecated Python modules, functions and methods
@@ -386,5 +327,6 @@
   wrapped attribute set. This means ``__wrapped__`` attributes now correctly
   link a stack of decorated functions rather than every ``__wrapped__``
   attribute in the chain referring to the innermost function. Introspection
-  libraries that assumed the previous behaviour was intentional can use
-  :func:`inspect.unwrap` to gain equivalent behaviour.
+  libraries that assumed the previous behaviour was intentional will need to
+  be updated to walk the chain of ``__wrapped__`` attributes to find the
+  innermost function.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/fileutils.h
--- a/Include/fileutils.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/fileutils.h	Mon Aug 12 02:18:40 2013 +0200
@@ -27,11 +27,19 @@
     struct stat *statbuf);
 #endif
 
+PyAPI_FUNC(int) _Py_open(
+    const char *pathname,
+    int flags);
+
 PyAPI_FUNC(FILE *) _Py_wfopen(
     const wchar_t *path,
     const wchar_t *mode);
 
 PyAPI_FUNC(FILE*) _Py_fopen(
+    const char *pathname,
+    const char *mode);
+
+PyAPI_FUNC(FILE*) _Py_fopen_obj(
     PyObject *path,
     const char *mode);
 
@@ -53,6 +61,12 @@
     wchar_t *buf,
     size_t size);
 
+PyAPI_FUNC(int) _Py_get_inheritable(int fd);
+
+PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable, int *atomic_flag_works);
+
+PyAPI_FUNC(void) _Py_try_set_inheritable(int fd, int inheritable);
+
 #ifdef __cplusplus
 }
 #endif
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/frameobject.h
--- a/Include/frameobject.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/frameobject.h	Mon Aug 12 02:18:40 2013 +0200
@@ -36,8 +36,6 @@
            non-generator frames. See the save_exc_state and swap_exc_state
            functions in ceval.c for details of their use. */
     PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
-    /* Borrowed reference to a generator, or NULL */
-    PyObject *f_gen;
 
     PyThreadState *f_tstate;
     int f_lasti;                /* Last instruction if called */
@@ -48,7 +46,6 @@
        bytecode index. */
     int f_lineno;               /* Current line number */
     int f_iblock;               /* index in f_blockstack */
-    char f_executing;           /* whether the frame is still executing */
     PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
     PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
 } PyFrameObject;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/genobject.h
--- a/Include/genobject.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/genobject.h	Mon Aug 12 02:18:40 2013 +0200
@@ -36,8 +36,6 @@
 PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *);
 PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(PyObject **);
 PyObject *_PyGen_Send(PyGenObject *, PyObject *);
-PyAPI_FUNC(void) _PyGen_Finalize(PyObject *self);
-
 
 #ifdef __cplusplus
 }
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/longobject.h
--- a/Include/longobject.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/longobject.h	Mon Aug 12 02:18:40 2013 +0200
@@ -97,7 +97,6 @@
 #ifndef Py_LIMITED_API
 PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
 PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base);
-PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int);
 #endif
 
 #ifndef Py_LIMITED_API
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/object.h
--- a/Include/object.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/object.h	Mon Aug 12 02:18:40 2013 +0200
@@ -408,8 +408,6 @@
     /* Type attribute cache version tag. Added in version 2.6 */
     unsigned int tp_version_tag;
 
-    destructor tp_finalize;
-
 #ifdef COUNT_ALLOCS
     /* these must be last and never explicitly initialized */
     Py_ssize_t tp_allocs;
@@ -531,8 +529,6 @@
 PyAPI_FUNC(int) PyCallable_Check(PyObject *);
 
 PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *);
-PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);
-PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);
 
 /* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
    dict as the last parameter. */
@@ -650,12 +646,6 @@
                  Py_TPFLAGS_HAVE_VERSION_TAG | \
                 0)
 
-/* NOTE: The following flags reuse lower bits (removed as part of the
- * Python 3.0 transition). */
-
-/* Type structure has tp_finalize member (3.4) */
-#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)
-
 #ifdef Py_LIMITED_API
 #define PyType_HasFeature(t,f)  ((PyType_GetFlags(t) & (f)) != 0)
 #else
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/objimpl.h
--- a/Include/objimpl.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/objimpl.h	Mon Aug 12 02:18:40 2013 +0200
@@ -256,30 +256,6 @@
 
 #define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
 
-/* Bit 0 is set when tp_finalize is called */
-#define _PyGC_REFS_MASK_FINALIZED  (1 << 0)
-/* The (N-1) most significant bits contain the gc state / refcount */
-#define _PyGC_REFS_SHIFT           (1)
-#define _PyGC_REFS_MASK            (((size_t) -1) << _PyGC_REFS_SHIFT)
-
-#define _PyGCHead_REFS(g) ((g)->gc.gc_refs >> _PyGC_REFS_SHIFT)
-#define _PyGCHead_SET_REFS(g, v) do { \
-    (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK) \
-        | (v << _PyGC_REFS_SHIFT); \
-    } while (0)
-#define _PyGCHead_DECREF(g) ((g)->gc.gc_refs -= 1 << _PyGC_REFS_SHIFT)
-
-#define _PyGCHead_FINALIZED(g) (((g)->gc.gc_refs & _PyGC_REFS_MASK_FINALIZED) != 0)
-#define _PyGCHead_SET_FINALIZED(g, v) do {  \
-    (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK_FINALIZED) \
-        | (v != 0); \
-    } while (0)
-
-#define _PyGC_FINALIZED(o) _PyGCHead_FINALIZED(_Py_AS_GC(o))
-#define _PyGC_SET_FINALIZED(o, v) _PyGCHead_SET_FINALIZED(_Py_AS_GC(o), v)
-
-#define _PyGC_REFS(o) _PyGCHead_REFS(_Py_AS_GC(o))
-
 #define _PyGC_REFS_UNTRACKED                    (-2)
 #define _PyGC_REFS_REACHABLE                    (-3)
 #define _PyGC_REFS_TENTATIVELY_UNREACHABLE      (-4)
@@ -288,9 +264,9 @@
  * collector it must be safe to call the ob_traverse method. */
 #define _PyObject_GC_TRACK(o) do { \
     PyGC_Head *g = _Py_AS_GC(o); \
-    if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \
+    if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
         Py_FatalError("GC object already tracked"); \
-    _PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \
+    g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
     g->gc.gc_next = _PyGC_generation0; \
     g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
     g->gc.gc_prev->gc.gc_next = g; \
@@ -303,8 +279,8 @@
  */
 #define _PyObject_GC_UNTRACK(o) do { \
     PyGC_Head *g = _Py_AS_GC(o); \
-    assert(_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED); \
-    _PyGCHead_SET_REFS(g, _PyGC_REFS_UNTRACKED); \
+    assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
+    g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
     g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
     g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
     g->gc.gc_next = NULL; \
@@ -312,7 +288,7 @@
 
 /* True if the object is currently tracked by the GC. */
 #define _PyObject_GC_IS_TRACKED(o) \
-    (_PyGC_REFS(o) != _PyGC_REFS_UNTRACKED)
+    ((_Py_AS_GC(o))->gc.gc_refs != _PyGC_REFS_UNTRACKED)
 
 /* True if the object may be tracked by the GC in the future, or already is.
    This can be useful to implement some optimizations. */
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/patchlevel.h
--- a/Include/patchlevel.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/patchlevel.h	Mon Aug 12 02:18:40 2013 +0200
@@ -20,10 +20,10 @@
 #define PY_MINOR_VERSION	4
 #define PY_MICRO_VERSION	0
 #define PY_RELEASE_LEVEL	PY_RELEASE_LEVEL_ALPHA
-#define PY_RELEASE_SERIAL	1
+#define PY_RELEASE_SERIAL	0
 
 /* Version as a string */
-#define PY_VERSION      	"3.4.0a1+"
+#define PY_VERSION      	"3.4.0a0"
 /*--end constants--*/
 
 /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/pydebug.h
--- a/Include/pydebug.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/pydebug.h	Mon Aug 12 02:18:40 2013 +0200
@@ -20,7 +20,6 @@
 PyAPI_DATA(int) Py_NoUserSiteDirectory;
 PyAPI_DATA(int) Py_UnbufferedStdioFlag;
 PyAPI_DATA(int) Py_HashRandomizationFlag;
-PyAPI_DATA(int) Py_IsolatedFlag;
 
 /* this is a wrapper around getenv() that pays attention to
    Py_IgnoreEnvironmentFlag.  It should be used for getting variables like
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/pystate.h
--- a/Include/pystate.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/pystate.h	Mon Aug 12 02:18:40 2013 +0200
@@ -134,9 +134,6 @@
 PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
 #endif
 PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyState_ClearModules(void);
-#endif
 
 PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
 PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Include/setobject.h
--- a/Include/setobject.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Include/setobject.h	Mon Aug 12 02:18:40 2013 +0200
@@ -23,8 +23,8 @@
 
 typedef struct {
     /* Cached hash code of the key. */
+    Py_hash_t hash;
     PyObject *key;
-    Py_hash_t hash;
 } setentry;
 
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/_sitebuiltins.py
--- a/Lib/_sitebuiltins.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,99 +0,0 @@
-"""
-The objects used by the site module to add custom builtins.
-"""
-
-# Those objects are almost immortal and they keep a reference to their module
-# globals.  Defining them in the site module would keep too many references
-# alive.
-# Note this means this module should also avoid keep things alive in its
-# globals.
-
-import sys
-
-class Quitter(object):
-    def __init__(self, name, eof):
-        self.name = name
-        self.eof = eof
-    def __repr__(self):
-        return 'Use %s() or %s to exit' % (self.name, self.eof)
-    def __call__(self, code=None):
-        # Shells like IDLE catch the SystemExit, but listen when their
-        # stdin wrapper is closed.
-        try:
-            sys.stdin.close()
-        except:
-            pass
-        raise SystemExit(code)
-
-
-class _Printer(object):
-    """interactive prompt objects for printing the license text, a list of
-    contributors and the copyright notice."""
-
-    MAXLINES = 23
-
-    def __init__(self, name, data, files=(), dirs=()):
-        import os
-        self.__name = name
-        self.__data = data
-        self.__lines = None
-        self.__filenames = [os.path.join(dir, filename)
-                            for dir in dirs
-                            for filename in files]
-
-    def __setup(self):
-        if self.__lines:
-            return
-        data = None
-        for filename in self.__filenames:
-            try:
-                with open(filename, "r") as fp:
-                    data = fp.read()
-                break
-            except OSError:
-                pass
-        if not data:
-            data = self.__data
-        self.__lines = data.split('\n')
-        self.__linecnt = len(self.__lines)
-
-    def __repr__(self):
-        self.__setup()
-        if len(self.__lines) <= self.MAXLINES:
-            return "\n".join(self.__lines)
-        else:
-            return "Type %s() to see the full %s text" % ((self.__name,)*2)
-
-    def __call__(self):
-        self.__setup()
-        prompt = 'Hit Return for more, or q (and Return) to quit: '
-        lineno = 0
-        while 1:
-            try:
-                for i in range(lineno, lineno + self.MAXLINES):
-                    print(self.__lines[i])
-            except IndexError:
-                break
-            else:
-                lineno += self.MAXLINES
-                key = None
-                while key is None:
-                    key = input(prompt)
-                    if key not in ('', 'q'):
-                        key = None
-                if key == 'q':
-                    break
-
-
-class _Helper(object):
-    """Define the builtin 'help'.
-    This is a wrapper around pydoc.help (with a twist).
-
-    """
-
-    def __repr__(self):
-        return "Type help() for interactive help, " \
-               "or help(object) for help about object."
-    def __call__(self, *args, **kwds):
-        import pydoc
-        return pydoc.help(*args, **kwds)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/colorsys.py
--- a/Lib/colorsys.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/colorsys.py	Mon Aug 12 02:18:40 2013 +0200
@@ -33,25 +33,17 @@
 # YIQ: used by composite video signals (linear combinations of RGB)
 # Y: perceived grey level (0.0 == black, 1.0 == white)
 # I, Q: color components
-#
-# There are a great many versions of the constants used in these formulae.
-# The ones in this library uses constants from the FCC version of NTSC.
 
 def rgb_to_yiq(r, g, b):
     y = 0.30*r + 0.59*g + 0.11*b
-    i = 0.74*(r-y) - 0.27*(b-y)
-    q = 0.48*(r-y) + 0.41*(b-y)
+    i = 0.60*r - 0.28*g - 0.32*b
+    q = 0.21*r - 0.52*g + 0.31*b
     return (y, i, q)
 
 def yiq_to_rgb(y, i, q):
-    # r = y + (0.27*q + 0.41*i) / (0.74*0.41 + 0.27*0.48)
-    # b = y + (0.74*q - 0.48*i) / (0.74*0.41 + 0.27*0.48)
-    # g = y - (0.30*(r-y) + 0.11*(b-y)) / 0.59
-
-    r = y + 0.9468822170900693*i + 0.6235565819861433*q
-    g = y - 0.27478764629897834*i - 0.6356910791873801*q
-    b = y - 1.1085450346420322*i + 1.7090069284064666*q
-
+    r = y + 0.948262*i + 0.624013*q
+    g = y - 0.276066*i - 0.639810*q
+    b = y - 1.105450*i + 1.729860*q
     if r < 0.0:
         r = 0.0
     if g < 0.0:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/distutils/__init__.py
--- a/Lib/distutils/__init__.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/distutils/__init__.py	Mon Aug 12 02:18:40 2013 +0200
@@ -13,5 +13,5 @@
 # Updated automatically by the Python release process.
 #
 #--start constants--
-__version__ = "3.4.0a1"
+__version__ = "3.4.0a0"
 #--end constants--
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/email/architecture.rst
--- a/Lib/email/architecture.rst	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/email/architecture.rst	Mon Aug 12 02:18:40 2013 +0200
@@ -24,9 +24,9 @@
 Conceptually the package is organized around the model.  The model provides both
 "external" APIs intended for use by application programs using the library,
 and "internal" APIs intended for use by the Parser and Generator components.
-This division is intentionally a bit fuzzy; the API described by this
-documentation is all a public, stable API.  This allows for an application
-with special needs to implement its own parser and/or generator.
+This division is intentionally a bit fuzy; the API described by this documentation
+is all a public, stable API.  This allows for an application with special needs
+to implement its own parser and/or generator.
 
 In addition to the three major functional components, there is a third key
 component to the architecture:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/email/generator.py
--- a/Lib/email/generator.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/email/generator.py	Mon Aug 12 02:18:40 2013 +0200
@@ -349,7 +349,7 @@
     # This used to be a module level function; we use a classmethod for this
     # and _compile_re so we can continue to provide the module level function
     # for backward compatibility by doing
-    #   _make_boundary = Generator._make_boundary
+    #   _make_boudary = Generator._make_boundary
     # at the end of the module.  It *is* internal, so we could drop that...
     @classmethod
     def _make_boundary(cls, text=None):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/email/message.py
--- a/Lib/email/message.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/email/message.py	Mon Aug 12 02:18:40 2013 +0200
@@ -132,50 +132,22 @@
 
     def __str__(self):
         """Return the entire formatted message as a string.
+        This includes the headers, body, and envelope header.
         """
         return self.as_string()
 
-    def as_string(self, unixfrom=False, maxheaderlen=0, policy=None):
+    def as_string(self, unixfrom=False, maxheaderlen=0):
         """Return the entire formatted message as a string.
+        Optional `unixfrom' when True, means include the Unix From_ envelope
+        header.
 
-        Optional 'unixfrom', when true, means include the Unix From_ envelope
-        header.  For backward compatibility reasons, if maxheaderlen is
-        not specified it defaults to 0, so you must override it explicitly
-        if you want a different maxheaderlen.  'policy' is passed to the
-        Generator instance used to serialize the mesasge; if it is not
-        specified the policy associated with the message instance is used.
-
-        If the message object contains binary data that is not encoded
-        according to RFC standards, the non-compliant data will be replaced by
-        unicode "unknown character" code points.
+        This is a convenience method and may not generate the message exactly
+        as you intend.  For more flexibility, use the flatten() method of a
+        Generator instance.
         """
         from email.generator import Generator
-        policy = self.policy if policy is None else policy
         fp = StringIO()
-        g = Generator(fp,
-                      mangle_from_=False,
-                      maxheaderlen=maxheaderlen,
-                      policy=policy)
-        g.flatten(self, unixfrom=unixfrom)
-        return fp.getvalue()
-
-    def __bytes__(self):
-        """Return the entire formatted message as a bytes object.
-        """
-        return self.as_bytes()
-
-    def as_bytes(self, unixfrom=False, policy=None):
-        """Return the entire formatted message as a bytes object.
-
-        Optional 'unixfrom', when true, means include the Unix From_ envelope
-        header.  'policy' is passed to the BytesGenerator instance used to
-        serialize the message; if not specified the policy associated with
-        the message instance is used.
-        """
-        from email.generator import BytesGenerator
-        policy = self.policy if policy is None else policy
-        fp = BytesIO()
-        g = BytesGenerator(fp, mangle_from_=False, policy=policy)
+        g = Generator(fp, mangle_from_=False, maxheaderlen=maxheaderlen)
         g.flatten(self, unixfrom=unixfrom)
         return fp.getvalue()
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/enum.py
--- a/Lib/enum.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/enum.py	Mon Aug 12 02:18:40 2013 +0200
@@ -127,7 +127,6 @@
         enum_class = super().__new__(metacls, cls, bases, classdict)
         enum_class._member_names_ = []               # names in definition order
         enum_class._member_map_ = OrderedDict()      # name->value map
-        enum_class._member_type_ = member_type
 
         # Reverse value->name map for hashable values.
         enum_class._value2member_map_ = {}
@@ -160,6 +159,7 @@
                 if not hasattr(enum_member, '_value_'):
                     enum_member._value_ = member_type(*args)
             value = enum_member._value_
+            enum_member._member_type_ = member_type
             enum_member._name_ = member_name
             enum_member.__init__(*args)
             # If another member with the same value was already defined, the
@@ -223,6 +223,9 @@
     def __contains__(cls, member):
         return isinstance(member, cls) and member.name in cls._member_map_
 
+    def __dir__(self):
+        return ['__class__', '__doc__', '__members__'] + self._member_names_
+
     @property
     def __members__(cls):
         """Returns a mapping of member name->value.
@@ -430,6 +433,9 @@
     def __str__(self):
         return "%s.%s" % (self.__class__.__name__, self._name_)
 
+    def __dir__(self):
+        return (['__class__', '__doc__', 'name', 'value'])
+
     def __eq__(self, other):
         if type(other) is self.__class__:
             return self is other
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/EditorWindow.py
--- a/Lib/idlelib/EditorWindow.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/EditorWindow.py	Mon Aug 12 02:18:40 2013 +0200
@@ -882,9 +882,12 @@
         "Load and update the recent files list and menus"
         rf_list = []
         if os.path.exists(self.recent_files_path):
-            with open(self.recent_files_path, 'r',
-                      encoding='utf_8', errors='replace') as rf_list_file:
+            rf_list_file = open(self.recent_files_path,'r',
+                                encoding='utf_8', errors='replace')
+            try:
                 rf_list = rf_list_file.readlines()
+            finally:
+                rf_list_file.close()
         if new_file:
             new_file = os.path.abspath(new_file) + '\n'
             if new_file in rf_list:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/FormatParagraph.py
--- a/Lib/idlelib/FormatParagraph.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/FormatParagraph.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,19 +1,18 @@
-"""Extension to format a paragraph or selection to a max width.
+# Extension to format a paragraph
 
-Does basic, standard text formatting, and also understands Python
-comment blocks. Thus, for editing Python source code, this
-extension is really only suitable for reformatting these comment
-blocks or triple-quoted strings.
+# Does basic, standard text formatting, and also understands Python
+# comment blocks.  Thus, for editing Python source code, this
+# extension is really only suitable for reformatting these comment
+# blocks or triple-quoted strings.
 
-Known problems with comment reformatting:
-* If there is a selection marked, and the first line of the
-  selection is not complete, the block will probably not be detected
-  as comments, and will have the normal "text formatting" rules
-  applied.
-* If a comment block has leading whitespace that mixes tabs and
-  spaces, they will not be considered part of the same block.
-* Fancy comments, like this bulleted list, aren't handled :-)
-"""
+# Known problems with comment reformatting:
+# * If there is a selection marked, and the first line of the
+#   selection is not complete, the block will probably not be detected
+#   as comments, and will have the normal "text formatting" rules
+#   applied.
+# * If a comment block has leading whitespace that mixes tabs and
+#   spaces, they will not be considered part of the same block.
+# * Fancy comments, like this bulleted list, arent handled :-)
 
 import re
 from idlelib.configHandler import idleConf
@@ -33,31 +32,42 @@
         self.editwin = None
 
     def format_paragraph_event(self, event):
-        """Formats paragraph to a max width specified in idleConf.
-
-        If text is selected, format_paragraph_event will start breaking lines
-        at the max width, starting from the beginning selection.
-
-        If no text is selected, format_paragraph_event uses the current
-        cursor location to determine the paragraph (lines of text surrounded
-        by blank lines) and formats it.
-        """
-        maxformatwidth = idleConf.GetOption(
-                'main', 'FormatParagraph', 'paragraph', type='int')
+        maxformatwidth = int(idleConf.GetOption('main', 'FormatParagraph',
+                                                'paragraph', type='int'))
         text = self.editwin.text
         first, last = self.editwin.get_selection_indices()
         if first and last:
             data = text.get(first, last)
-            comment_header = get_comment_header(data)
+            comment_header = ''
         else:
             first, last, comment_header, data = \
                     find_paragraph(text, text.index("insert"))
         if comment_header:
-            newdata = reformat_comment(data, maxformatwidth, comment_header)
+            # Reformat the comment lines - convert to text sans header.
+            lines = data.split("\n")
+            lines = map(lambda st, l=len(comment_header): st[l:], lines)
+            data = "\n".join(lines)
+            # Reformat to maxformatwidth chars or a 20 char width,
+            # whichever is greater.
+            format_width = max(maxformatwidth - len(comment_header), 20)
+            newdata = reformat_paragraph(data, format_width)
+            # re-split and re-insert the comment header.
+            newdata = newdata.split("\n")
+            # If the block ends in a \n, we dont want the comment
+            # prefix inserted after it. (Im not sure it makes sense to
+            # reformat a comment block that isnt made of complete
+            # lines, but whatever!)  Can't think of a clean solution,
+            # so we hack away
+            block_suffix = ""
+            if not newdata[-1]:
+                block_suffix = "\n"
+                newdata = newdata[:-1]
+            builder = lambda item, prefix=comment_header: prefix+item
+            newdata = '\n'.join(map(builder, newdata)) + block_suffix
         else:
+            # Just a normal text format
             newdata = reformat_paragraph(data, maxformatwidth)
         text.tag_remove("sel", "1.0", "end")
-
         if newdata != data:
             text.mark_set("insert", first)
             text.undo_block_start()
@@ -70,44 +80,31 @@
         return "break"
 
 def find_paragraph(text, mark):
-    """Returns the start/stop indices enclosing the paragraph that mark is in.
-
-    Also returns the comment format string, if any, and paragraph of text
-    between the start/stop indices.
-    """
     lineno, col = map(int, mark.split("."))
-    line = text.get("%d.0" % lineno, "%d.end" % lineno)
-
-    # Look for start of next paragraph if the index passed in is a blank line
+    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
     while text.compare("%d.0" % lineno, "<", "end") and is_all_white(line):
         lineno = lineno + 1
-        line = text.get("%d.0" % lineno, "%d.end" % lineno)
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
     first_lineno = lineno
     comment_header = get_comment_header(line)
     comment_header_len = len(comment_header)
-
-    # Once start line found, search for end of paragraph (a blank line)
     while get_comment_header(line)==comment_header and \
               not is_all_white(line[comment_header_len:]):
         lineno = lineno + 1
-        line = text.get("%d.0" % lineno, "%d.end" % lineno)
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
     last = "%d.0" % lineno
-
-    # Search back to beginning of paragraph (first blank line before)
+    # Search back to beginning of paragraph
     lineno = first_lineno - 1
-    line = text.get("%d.0" % lineno, "%d.end" % lineno)
+    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
     while lineno > 0 and \
               get_comment_header(line)==comment_header and \
               not is_all_white(line[comment_header_len:]):
         lineno = lineno - 1
-        line = text.get("%d.0" % lineno, "%d.end" % lineno)
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
     first = "%d.0" % (lineno+1)
-
     return first, last, comment_header, text.get(first, last)
 
-# This should perhaps be replaced with textwrap.wrap
 def reformat_paragraph(data, limit):
-    """Return data reformatted to specified width (limit)."""
     lines = data.split("\n")
     i = 0
     n = len(lines)
@@ -130,7 +127,7 @@
             if not word:
                 continue # Can happen when line ends in whitespace
             if len((partial + word).expandtabs()) > limit and \
-                   partial != indent1:
+               partial != indent1:
                 new.append(partial.rstrip())
                 partial = indent2
             partial = partial + word + " "
@@ -142,50 +139,13 @@
     new.extend(lines[i:])
     return "\n".join(new)
 
-def reformat_comment(data, limit, comment_header):
-    """Return data reformatted to specified width with comment header."""
-
-    # Remove header from the comment lines
-    lc = len(comment_header)
-    data = "\n".join(line[lc:] for line in data.split("\n"))
-    # Reformat to maxformatwidth chars or a 20 char width,
-    # whichever is greater.
-    format_width = max(limit - len(comment_header), 20)
-    newdata = reformat_paragraph(data, format_width)
-    # re-split and re-insert the comment header.
-    newdata = newdata.split("\n")
-    # If the block ends in a \n, we dont want the comment prefix
-    # inserted after it. (Im not sure it makes sense to reformat a
-    # comment block that is not made of complete lines, but whatever!)
-    # Can't think of a clean solution, so we hack away
-    block_suffix = ""
-    if not newdata[-1]:
-        block_suffix = "\n"
-        newdata = newdata[:-1]
-    return '\n'.join(comment_header+line for line in newdata) + block_suffix
-
 def is_all_white(line):
-    """Return True if line is empty or all whitespace."""
-
     return re.match(r"^\s*$", line) is not None
 
 def get_indent(line):
-    """Return the initial space or tab indent of line."""
-    return re.match(r"^([ \t]*)", line).group()
+    return re.match(r"^(\s*)", line).group()
 
 def get_comment_header(line):
-    """Return string with leading whitespace and '#' from line or ''.
-
-    A null return indicates that the line is not a comment line. A non-
-    null return, such as '    #', will be used to find the other lines of
-    a comment block with the same  indent.
-    """
-    m = re.match(r"^([ \t]*#*)", line)
+    m = re.match(r"^(\s*#*)", line)
     if m is None: return ""
     return m.group(1)
-
-if __name__ == "__main__":
-    from test import support; support.use_resources = ['gui']
-    import unittest
-    unittest.main('idlelib.idle_test.test_formatparagraph',
-            verbosity=2, exit=False)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/IOBinding.py
--- a/Lib/idlelib/IOBinding.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/IOBinding.py	Mon Aug 12 02:18:40 2013 +0200
@@ -208,10 +208,11 @@
         try:
             # open the file in binary mode so that we can handle
             # end-of-line convention ourselves.
-            with open(filename, 'rb') as f:
-                two_lines = f.readline() + f.readline()
-                f.seek(0)
-                bytes = f.read()
+            f = open(filename,'rb')
+            two_lines = f.readline() + f.readline()
+            f.seek(0)
+            bytes = f.read()
+            f.close()
         except OSError as msg:
             tkMessageBox.showerror("I/O Error", str(msg), master=self.text)
             return False
@@ -372,8 +373,10 @@
             text = text.replace("\n", self.eol_convention)
         chars = self.encode(text)
         try:
-            with open(filename, "wb") as f:
-                f.write(chars)
+            f = open(filename, "wb")
+            f.write(chars)
+            f.flush()
+            f.close()
             return True
         except OSError as msg:
             tkMessageBox.showerror("I/O Error", str(msg),
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/ScriptBinding.py
--- a/Lib/idlelib/ScriptBinding.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/ScriptBinding.py	Mon Aug 12 02:18:40 2013 +0200
@@ -87,8 +87,9 @@
         self.shell = shell = self.flist.open_shell()
         saved_stream = shell.get_warning_stream()
         shell.set_warning_stream(shell.stderr)
-        with open(filename, 'rb') as f:
-            source = f.read()
+        f = open(filename, 'rb')
+        source = f.read()
+        f.close()
         if b'\r' in source:
             source = source.replace(b'\r\n', b'\n')
             source = source.replace(b'\r', b'\n')
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idle_test/README.txt
--- a/Lib/idlelib/idle_test/README.txt	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/idle_test/README.txt	Mon Aug 12 02:18:40 2013 +0200
@@ -40,20 +40,13 @@
 idle class. For the benefit of buildbot machines that do not have a graphics
 screen, gui tests must be 'guarded' by "requires('gui')" in a setUp
 function or method. This will typically be setUpClass.
-
-All gui objects must be destroyed by the end of the test, perhaps in a tearDown
-function. Creating the Tk root directly in a setUp allows a reference to be saved
-so it can be properly destroyed in the corresponding tearDown. 
 ---
     @classmethod
     def setUpClass(cls):
         requires('gui')
-        cls.root = tk.Tk()
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
 ---
+All gui objects must be destroyed by the end of the test, perhaps in a tearDown
+function.
 
 Support.requires('gui') returns true if it is either called in a main module
 (which never happens on buildbots) or if use_resources contains 'gui'.
@@ -63,9 +56,8 @@
 
 Since non-gui tests always run, but gui tests only sometimes, tests of non-gui
 operations should best avoid needing a gui. Methods that make incidental use of
-tkinter (tk) variables and messageboxes can do this by using the mock classes in
-idle_test/mock_tk.py. There is also a mock text that will handle some uses of the
-tk Text widget.
+tkinter variables and messageboxes can do this by using the mock classes in
+idle_test/mock_tk.py.
 
 
 3. Running Tests
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idle_test/test_calltips.py
--- a/Lib/idlelib/idle_test/test_calltips.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/idle_test/test_calltips.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,7 +1,7 @@
 import unittest
 import idlelib.CallTips as ct
 
-class Get_entityTest(unittest.TestCase):
+class Test_get_entity(unittest.TestCase):
     def test_bad_entity(self):
         self.assertIsNone(ct.get_entity('1/0'))
     def test_good_entity(self):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idle_test/test_config_name.py
--- a/Lib/idlelib/idle_test/test_config_name.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/idle_test/test_config_name.py	Mon Aug 12 02:18:40 2013 +0200
@@ -22,7 +22,7 @@
 orig_mbox = name_dialog_module.tkMessageBox
 showerror = Mbox.showerror
 
-class ConfigNameTest(unittest.TestCase):
+class TestConfigName(unittest.TestCase):
     dialog = Dummy_name_dialog()
 
     @classmethod
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idle_test/test_formatparagraph.py
--- a/Lib/idlelib/idle_test/test_formatparagraph.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,374 +0,0 @@
-# Test the functions and main class method of FormatParagraph.py
-import unittest
-from idlelib import FormatParagraph as fp
-from idlelib.EditorWindow import EditorWindow
-from tkinter import Tk, Text, TclError
-from test.support import requires
-
-
-class Is_Get_Test(unittest.TestCase):
-    """Test the is_ and get_ functions"""
-    test_comment = '# This is a comment'
-    test_nocomment = 'This is not a comment'
-    trailingws_comment = '# This is a comment   '
-    leadingws_comment = '    # This is a comment'
-    leadingws_nocomment = '    This is not a comment'
-
-    def test_is_all_white(self):
-        self.assertTrue(fp.is_all_white(''))
-        self.assertTrue(fp.is_all_white('\t\n\r\f\v'))
-        self.assertFalse(fp.is_all_white(self.test_comment))
-
-    def test_get_indent(self):
-        Equal = self.assertEqual
-        Equal(fp.get_indent(self.test_comment), '')
-        Equal(fp.get_indent(self.trailingws_comment), '')
-        Equal(fp.get_indent(self.leadingws_comment), '    ')
-        Equal(fp.get_indent(self.leadingws_nocomment), '    ')
-
-    def test_get_comment_header(self):
-        Equal = self.assertEqual
-        # Test comment strings
-        Equal(fp.get_comment_header(self.test_comment), '#')
-        Equal(fp.get_comment_header(self.trailingws_comment), '#')
-        Equal(fp.get_comment_header(self.leadingws_comment), '    #')
-        # Test non-comment strings
-        Equal(fp.get_comment_header(self.leadingws_nocomment), '    ')
-        Equal(fp.get_comment_header(self.test_nocomment), '')
-
-
-class FindTest(unittest.TestCase):
-    """Test the find_paragraph function in FormatParagraph.
-
-    Using the runcase() function, find_paragraph() is called with 'mark' set at
-    multiple indexes before and inside the test paragraph.
-
-    It appears that code with the same indentation as a quoted string is grouped
-    as part of the same paragraph, which is probably incorrect behavior.
-    """
-
-    @classmethod
-    def setUpClass(cls):
-        from idlelib.idle_test.mock_tk import Text
-        cls.text = Text()
-
-    def runcase(self, inserttext, stopline, expected):
-        # Check that find_paragraph returns the expected paragraph when
-        # the mark index is set to beginning, middle, end of each line
-        # up to but not including the stop line
-        text = self.text
-        text.insert('1.0', inserttext)
-        for line in range(1, stopline):
-            linelength = int(text.index("%d.end" % line).split('.')[1])
-            for col in (0, linelength//2, linelength):
-                tempindex = "%d.%d" % (line, col)
-                self.assertEqual(fp.find_paragraph(text, tempindex), expected)
-        text.delete('1.0', 'end')
-
-    def test_find_comment(self):
-        comment = (
-            "# Comment block with no blank lines before\n"
-            "# Comment line\n"
-            "\n")
-        self.runcase(comment, 3, ('1.0', '3.0', '#', comment[0:58]))
-
-        comment = (
-            "\n"
-            "# Comment block with whitespace line before and after\n"
-            "# Comment line\n"
-            "\n")
-        self.runcase(comment, 4, ('2.0', '4.0', '#', comment[1:70]))
-
-        comment = (
-            "\n"
-            "    # Indented comment block with whitespace before and after\n"
-            "    # Comment line\n"
-            "\n")
-        self.runcase(comment, 4, ('2.0', '4.0', '    #', comment[1:82]))
-
-        comment = (
-            "\n"
-            "# Single line comment\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:23]))
-
-        comment = (
-            "\n"
-            "    # Single line comment with leading whitespace\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:51]))
-
-        comment = (
-            "\n"
-            "# Comment immediately followed by code\n"
-            "x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:40]))
-
-        comment = (
-            "\n"
-            "    # Indented comment immediately followed by code\n"
-            "x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:53]))
-
-        comment = (
-            "\n"
-            "# Comment immediately followed by indented code\n"
-            "    x = 42\n"
-            "\n")
-        self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:49]))
-
-    def test_find_paragraph(self):
-        teststring = (
-            '"""String with no blank lines before\n'
-            'String line\n'
-            '"""\n'
-            '\n')
-        self.runcase(teststring, 4, ('1.0', '4.0', '', teststring[0:53]))
-
-        teststring = (
-            "\n"
-            '"""String with whitespace line before and after\n'
-            'String line.\n'
-            '"""\n'
-            '\n')
-        self.runcase(teststring, 5, ('2.0', '5.0', '', teststring[1:66]))
-
-        teststring = (
-            '\n'
-            '    """Indented string with whitespace before and after\n'
-            '    Comment string.\n'
-            '    """\n'
-            '\n')
-        self.runcase(teststring, 5, ('2.0', '5.0', '    ', teststring[1:85]))
-
-        teststring = (
-            '\n'
-            '"""Single line string."""\n'
-            '\n')
-        self.runcase(teststring, 3, ('2.0', '3.0', '', teststring[1:27]))
-
-        teststring = (
-            '\n'
-            '    """Single line string with leading whitespace."""\n'
-            '\n')
-        self.runcase(teststring, 3, ('2.0', '3.0', '    ', teststring[1:55]))
-
-
-class ReformatFunctionTest(unittest.TestCase):
-    """Test the reformat_paragraph function without the editor window."""
-
-    def test_reformat_paragrah(self):
-        Equal = self.assertEqual
-        reform = fp.reformat_paragraph
-        hw = "O hello world"
-        Equal(reform(' ', 1), ' ')
-        Equal(reform("Hello    world", 20), "Hello  world")
-
-        # Test without leading newline
-        Equal(reform(hw, 1), "O\nhello\nworld")
-        Equal(reform(hw, 6), "O\nhello\nworld")
-        Equal(reform(hw, 7), "O hello\nworld")
-        Equal(reform(hw, 12), "O hello\nworld")
-        Equal(reform(hw, 13), "O hello world")
-
-        # Test with leading newline
-        hw = "\nO hello world"
-        Equal(reform(hw, 1), "\nO\nhello\nworld")
-        Equal(reform(hw, 6), "\nO\nhello\nworld")
-        Equal(reform(hw, 7), "\nO hello\nworld")
-        Equal(reform(hw, 12), "\nO hello\nworld")
-        Equal(reform(hw, 13), "\nO hello world")
-
-
-class ReformatCommentTest(unittest.TestCase):
-    """Test the reformat_comment function without the editor window."""
-
-    def test_reformat_comment(self):
-        Equal = self.assertEqual
-
-        # reformat_comment formats to a minimum of 20 characters
-        test_string = (
-            "    \"\"\"this is a test of a reformat for a triple quoted string"
-            " will it reformat to less than 70 characters for me?\"\"\"")
-        result = fp.reformat_comment(test_string, 70, "    ")
-        expected = (
-            "    \"\"\"this is a test of a reformat for a triple quoted string will it\n"
-            "    reformat to less than 70 characters for me?\"\"\"")
-        Equal(result, expected)
-
-        test_comment = (
-            "# this is a test of a reformat for a triple quoted string will "
-            "it reformat to less than 70 characters for me?")
-        result = fp.reformat_comment(test_comment, 70, "#")
-        expected = (
-            "# this is a test of a reformat for a triple quoted string will it\n"
-            "# reformat to less than 70 characters for me?")
-        Equal(result, expected)
-
-
-class FormatClassTest(unittest.TestCase):
-    def test_init_close(self):
-        instance = fp.FormatParagraph('editor')
-        self.assertEqual(instance.editwin, 'editor')
-        instance.close()
-        self.assertEqual(instance.editwin, None)
-
-
-# For testing format_paragraph_event, Initialize FormatParagraph with
-# a mock Editor with .text and  .get_selection_indices.  The text must
-# be a Text wrapper that adds two methods
-
-# A real EditorWindow creates unneeded, time-consuming baggage and
-# sometimes emits shutdown warnings like this:
-# "warning: callback failed in WindowList <class '_tkinter.TclError'>
-# : invalid command name ".55131368.windows".
-# Calling EditorWindow._close in tearDownClass prevents this but causes
-# other problems (windows left open).
-
-class TextWrapper:
-    def __init__(self, master):
-        self.text = Text(master=master)
-    def __getattr__(self, name):
-        return getattr(self.text, name)
-    def undo_block_start(self): pass
-    def undo_block_stop(self): pass
-
-class Editor:
-    def __init__(self, root):
-        self.text = TextWrapper(root)
-    get_selection_indices = EditorWindow. get_selection_indices
-
-class FormatEventTest(unittest.TestCase):
-    """Test the formatting of text inside a Text widget.
-
-    This is done with FormatParagraph.format.paragraph_event,
-    which calls funtions in the module as appropriate.
-    """
-    test_string = (
-        "    '''this is a test of a reformat for a triple "
-        "quoted string will it reformat to less than 70 "
-        "characters for me?'''\n")
-    multiline_test_string = (
-        "    '''The first line is under the max width.\n"
-        "    The second line's length is way over the max width. It goes "
-        "on and on until it is over 100 characters long.\n"
-        "    Same thing with the third line. It is also way over the max "
-        "width, but FormatParagraph will fix it.\n"
-        "    '''\n")
-    multiline_test_comment = (
-        "# The first line is under the max width.\n"
-        "# The second line's length is way over the max width. It goes on "
-        "and on until it is over 100 characters long.\n"
-        "# Same thing with the third line. It is also way over the max "
-        "width, but FormatParagraph will fix it.\n"
-        "# The fourth line is short like the first line.")
-
-    @classmethod
-    def setUpClass(cls):
-        requires('gui')
-        cls.root = Tk()
-        editor = Editor(root=cls.root)
-        cls.text = editor.text.text  # Test code does not need the wrapper.
-        cls.formatter = fp.FormatParagraph(editor).format_paragraph_event
-        # Sets the insert mark just after the re-wrapped and inserted  text.
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.destroy()
-
-    def test_short_line(self):
-        self.text.insert('1.0', "Short line\n")
-        self.formatter("Dummy")
-        self.assertEqual(self.text.get('1.0', 'insert'), "Short line\n" )
-        self.text.delete('1.0', 'end')
-
-    def test_long_line(self):
-        text = self.text
-
-        # Set cursor ('insert' mark) to '1.0', within text.
-        text.insert('1.0', self.test_string)
-        text.mark_set('insert', '1.0')
-        self.formatter('ParameterDoesNothing')
-        result = text.get('1.0', 'insert')
-        # find function includes \n
-        expected = (
-"    '''this is a test of a reformat for a triple quoted string will it\n"
-"    reformat to less than 70 characters for me?'''\n")  # yes
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-        # Select from 1.11 to line end.
-        text.insert('1.0', self.test_string)
-        text.tag_add('sel', '1.11', '1.end')
-        self.formatter('ParameterDoesNothing')
-        result = text.get('1.0', 'insert')
-        # selection excludes \n
-        expected = (
-"    '''this is a test of a reformat for a triple quoted string will it reformat\n"
-" to less than 70 characters for me?'''")  # no
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-    def test_multiple_lines(self):
-        text = self.text
-        #  Select 2 long lines.
-        text.insert('1.0', self.multiline_test_string)
-        text.tag_add('sel', '2.0', '4.0')
-        self.formatter('ParameterDoesNothing')
-        result = text.get('2.0', 'insert')
-        expected = (
-"    The second line's length is way over the max width. It goes on and\n"
-"    on until it is over 100 characters long. Same thing with the third\n"
-"    line. It is also way over the max width, but FormatParagraph will\n"
-"    fix it.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-    def test_comment_block(self):
-        text = self.text
-
-        # Set cursor ('insert') to '1.0', within block.
-        text.insert('1.0', self.multiline_test_comment)
-        self.formatter('ParameterDoesNothing')
-        result = text.get('1.0', 'insert')
-        expected = (
-"# The first line is under the max width. The second line's length is\n"
-"# way over the max width. It goes on and on until it is over 100\n"
-"# characters long. Same thing with the third line. It is also way over\n"
-"# the max width, but FormatParagraph will fix it. The fourth line is\n"
-"# short like the first line.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-        # Select line 2, verify line 1 unaffected.
-        text.insert('1.0', self.multiline_test_comment)
-        text.tag_add('sel', '2.0', '3.0')
-        self.formatter('ParameterDoesNothing')
-        result = text.get('1.0', 'insert')
-        expected = (
-"# The first line is under the max width.\n"
-"# The second line's length is way over the max width. It goes on and\n"
-"# on until it is over 100 characters long.\n")
-        self.assertEqual(result, expected)
-        text.delete('1.0', 'end')
-
-# The following block worked with EditorWindow but fails with the mock.
-# Lines 2 and 3 get pasted together even though the previous block left
-# the previous line alone. More investigation is needed.
-##        # Select lines 3 and 4
-##        text.insert('1.0', self.multiline_test_comment)
-##        text.tag_add('sel', '3.0', '5.0')
-##        self.formatter('ParameterDoesNothing')
-##        result = text.get('3.0', 'insert')
-##        expected = (
-##"# Same thing with the third line. It is also way over the max width,\n"
-##"# but FormatParagraph will fix it. The fourth line is short like the\n"
-##"# first line.\n")
-##        self.assertEqual(result, expected)
-##        text.delete('1.0', 'end')
-
-
-if __name__ == '__main__':
-    unittest.main(verbosity=2, exit=2)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idle_test/test_text.py
--- a/Lib/idlelib/idle_test/test_text.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/idle_test/test_text.py	Mon Aug 12 02:18:40 2013 +0200
@@ -216,7 +216,10 @@
         requires('gui')
         from tkinter import Tk, Text
         cls.Text = Text
-        cls.root = Tk()
+        try:
+            cls.root = Tk()
+        except TclError as msg:
+            raise unittest.SkipTest('TclError: %s' % msg)
 
     @classmethod
     def tearDownClass(cls):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/idlelib/idlever.py
--- a/Lib/idlelib/idlever.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/idlelib/idlever.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,1 +1,1 @@
-IDLE_VERSION = "3.4.0a1"
+IDLE_VERSION = "3.4.0a0"
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/importlib/__init__.py
--- a/Lib/importlib/__init__.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/importlib/__init__.py	Mon Aug 12 02:18:40 2013 +0200
@@ -115,7 +115,7 @@
         parent_name = name.rpartition('.')[0]
         if parent_name and parent_name not in sys.modules:
             msg = "parent {!r} not in sys.modules"
-            raise ImportError(msg.format(parent_name), name=parent_name)
+            raise ImportError(msg.format(parentname), name=parent_name)
         return module.__loader__.load_module(name)
     finally:
         try:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/inspect.py
--- a/Lib/inspect.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/inspect.py	Mon Aug 12 02:18:40 2013 +0200
@@ -360,40 +360,6 @@
     "Return tuple of base classes (including cls) in method resolution order."
     return cls.__mro__
 
-# -------------------------------------------------------- function helpers
-
-def unwrap(func, *, stop=None):
-    """Get the object wrapped by *func*.
-
-   Follows the chain of :attr:`__wrapped__` attributes returning the last
-   object in the chain.
-
-   *stop* is an optional callback accepting an object in the wrapper chain
-   as its sole argument that allows the unwrapping to be terminated early if
-   the callback returns a true value. If the callback never returns a true
-   value, the last object in the chain is returned as usual. For example,
-   :func:`signature` uses this to stop unwrapping if any object in the
-   chain has a ``__signature__`` attribute defined.
-
-   :exc:`ValueError` is raised if a cycle is encountered.
-
-    """
-    if stop is None:
-        def _is_wrapper(f):
-            return hasattr(f, '__wrapped__')
-    else:
-        def _is_wrapper(f):
-            return hasattr(f, '__wrapped__') and not stop(f)
-    f = func  # remember the original func for error reporting
-    memo = {id(f)} # Memoise by id to tolerate non-hashable objects
-    while _is_wrapper(func):
-        func = func.__wrapped__
-        id_func = id(func)
-        if id_func in memo:
-            raise ValueError('wrapper loop when unwrapping {!r}'.format(f))
-        memo.add(id_func)
-    return func
-
 # -------------------------------------------------- source code extraction
 def indentsize(line):
     """Return the indent size, in spaces, at the start of a line of text."""
@@ -1380,9 +1346,6 @@
         sig = signature(obj.__func__)
         return sig.replace(parameters=tuple(sig.parameters.values())[1:])
 
-    # Was this function wrapped by a decorator?
-    obj = unwrap(obj, stop=(lambda f: hasattr(f, "__signature__")))
-
     try:
         sig = obj.__signature__
     except AttributeError:
@@ -1391,6 +1354,13 @@
         if sig is not None:
             return sig
 
+    try:
+        # Was this function wrapped by a decorator?
+        wrapped = obj.__wrapped__
+    except AttributeError:
+        pass
+    else:
+        return signature(wrapped)
 
     if isinstance(obj, types.FunctionType):
         return Signature.from_function(obj)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/json/encoder.py
--- a/Lib/json/encoder.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/json/encoder.py	Mon Aug 12 02:18:40 2013 +0200
@@ -175,7 +175,6 @@
     def encode(self, o):
         """Return a JSON string representation of a Python data structure.
 
-        >>> from json.encoder import JSONEncoder
         >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
         '{"foo": ["bar", "baz"]}'
 
@@ -299,13 +298,9 @@
             elif value is False:
                 yield buf + 'false'
             elif isinstance(value, int):
-                # Subclasses of int/float may override __str__, but we still
-                # want to encode them as integers/floats in JSON. One example
-                # within the standard library is IntEnum.
-                yield buf + str(int(value))
+                yield buf + str(value)
             elif isinstance(value, float):
-                # see comment above for int
-                yield buf + _floatstr(float(value))
+                yield buf + _floatstr(value)
             else:
                 yield buf
                 if isinstance(value, (list, tuple)):
@@ -351,8 +346,7 @@
             # JavaScript is weakly typed for these, so it makes sense to
             # also allow them.  Many encoders seem to do something like this.
             elif isinstance(key, float):
-                # see comment for int/float in _make_iterencode
-                key = _floatstr(float(key))
+                key = _floatstr(key)
             elif key is True:
                 key = 'true'
             elif key is False:
@@ -360,8 +354,7 @@
             elif key is None:
                 key = 'null'
             elif isinstance(key, int):
-                # see comment for int/float in _make_iterencode
-                key = str(int(key))
+                key = str(key)
             elif _skipkeys:
                 continue
             else:
@@ -381,11 +374,9 @@
             elif value is False:
                 yield 'false'
             elif isinstance(value, int):
-                # see comment for int/float in _make_iterencode
-                yield str(int(value))
+                yield str(value)
             elif isinstance(value, float):
-                # see comment for int/float in _make_iterencode
-                yield _floatstr(float(value))
+                yield _floatstr(value)
             else:
                 if isinstance(value, (list, tuple)):
                     chunks = _iterencode_list(value, _current_indent_level)
@@ -411,11 +402,9 @@
         elif o is False:
             yield 'false'
         elif isinstance(o, int):
-            # see comment for int/float in _make_iterencode
-            yield str(int(o))
+            yield str(o)
         elif isinstance(o, float):
-            # see comment for int/float in _make_iterencode
-            yield _floatstr(float(o))
+            yield _floatstr(o)
         elif isinstance(o, (list, tuple)):
             yield from _iterencode_list(o, _current_indent_level)
         elif isinstance(o, dict):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/logging/__init__.py
--- a/Lib/logging/__init__.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/logging/__init__.py	Mon Aug 12 02:18:40 2013 +0200
@@ -899,9 +899,6 @@
                     # couldn't find the right stack frame, for some reason
                     sys.stderr.write('Logged from file %s, line %s\n' % (
                                      record.filename, record.lineno))
-                # Issue 18671: output logging message and arguments
-                sys.stderr.write('Message: %r\n'
-                                 'Arguments: %s\n' % (record.msg, record.args))
             except OSError: #pragma: no cover
                 pass    # see issue 5971
             finally:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/multiprocessing/connection.py
--- a/Lib/multiprocessing/connection.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/multiprocessing/connection.py	Mon Aug 12 02:18:40 2013 +0200
@@ -532,7 +532,9 @@
             _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE,
             _winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
             _winapi.PIPE_WAIT,
-            1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
+            1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER,
+            # default security descriptor: the handle cannot be inherited
+            _winapi.NULL
             )
         h2 = _winapi.CreateFile(
             address, access, 0, _winapi.NULL, _winapi.OPEN_EXISTING,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/multiprocessing/heap.py
--- a/Lib/multiprocessing/heap.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/multiprocessing/heap.py	Mon Aug 12 02:18:40 2013 +0200
@@ -21,7 +21,7 @@
 __all__ = ['BufferWrapper']
 
 #
-# Inheritable class which wraps an mmap, and from which blocks can be allocated
+# Inheirtable class which wraps an mmap, and from which blocks can be allocated
 #
 
 if sys.platform == 'win32':
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/ntpath.py
--- a/Lib/ntpath.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/ntpath.py	Mon Aug 12 02:18:40 2013 +0200
@@ -335,35 +335,16 @@
         return False
     return True
 
-# Is a path a mount point?
-# Any drive letter root (eg c:\)
-# Any share UNC (eg \\server\share)
-# Any volume mounted on a filesystem folder
-#
-# No one method detects all three situations. Historically we've lexically
-# detected drive letter roots and share UNCs. The canonical approach to
-# detecting mounted volumes (querying the reparse tag) fails for the most
-# common case: drive letter roots. The alternative which uses GetVolumePathName
-# fails if the drive letter is the result of a SUBST.
-try:
-    from nt import _getvolumepathname
-except ImportError:
-    _getvolumepathname = None
+# Is a path a mount point?  Either a root (with or without drive letter)
+# or an UNC path with at most a / or \ after the mount point.
+
 def ismount(path):
-    """Test whether a path is a mount point (a drive root, the root of a
-    share, or a mounted volume)"""
+    """Test whether a path is a mount point (defined as root of drive)"""
     seps = _get_bothseps(path)
-    path = abspath(path)
     root, rest = splitdrive(path)
     if root and root[0] in seps:
         return (not rest) or (rest in seps)
-    if rest in seps:
-        return True
-
-    if _getvolumepathname:
-        return path.rstrip(seps) == _getvolumepathname(path).rstrip(seps)
-    else:
-        return False
+    return rest in seps
 
 
 # Expand paths beginning with '~' or '~user'.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/pty.py
--- a/Lib/pty.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/pty.py	Mon Aug 12 02:18:40 2013 +0200
@@ -105,7 +105,7 @@
         os.dup2(slave_fd, STDOUT_FILENO)
         os.dup2(slave_fd, STDERR_FILENO)
         if (slave_fd > STDERR_FILENO):
-            os.close (slave_fd)
+            os.close(slave_fd)
 
         # Explicitly open the tty to make it become a controlling tty.
         tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/pydoc_data/topics.py
--- a/Lib/pydoc_data/topics.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/pydoc_data/topics.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-# Autogenerated by Sphinx on Sat Aug  3 12:46:08 2013
+# Autogenerated by Sphinx on Sat Mar 23 15:42:31 2013
 topics = {'assert': '\nThe ``assert`` statement\n************************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n   assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, ``assert expression``, is equivalent to\n\n   if __debug__:\n      if not expression: raise AssertionError\n\nThe extended form, ``assert expression1, expression2``, is equivalent\nto\n\n   if __debug__:\n      if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that ``__debug__`` and ``AssertionError``\nrefer to the built-in variables with those names.  In the current\nimplementation, the built-in variable ``__debug__`` is ``True`` under\nnormal circumstances, ``False`` when optimization is requested\n(command line option -O).  The current code generator emits no code\nfor an assert statement when optimization is requested at compile\ntime.  Note that it is unnecessary to include the source code for the\nexpression that failed in the error message; it will be displayed as\npart of the stack trace.\n\nAssignments to ``__debug__`` are illegal.  The value for the built-in\nvariable is determined when the interpreter starts.\n',
  'assignment': '\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n   assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n   target_list     ::= target ("," target)* [","]\n   target          ::= identifier\n              | "(" target_list ")"\n              | "[" target_list "]"\n              | attributeref\n              | subscription\n              | slicing\n              | "*" target\n\n(See section *Primaries* for the syntax definitions for the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable.  The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list, optionally enclosed in\nparentheses or square brackets, is recursively defined as follows.\n\n* If the target list is a single target: The object is assigned to\n  that target.\n\n* If the target list is a comma-separated list of targets: The object\n  must be an iterable with the same number of items as there are\n  targets in the target list, and the items are assigned, from left to\n  right, to the corresponding targets.\n\n  * If the target list contains one target prefixed with an asterisk,\n    called a "starred" target: The object must be a sequence with at\n    least as many items as there are targets in the target list, minus\n    one.  The first items of the sequence are assigned, from left to\n    right, to the targets before the starred target.  The final items\n    of the sequence are assigned to the targets after the starred\n    target.  A list of the remaining items in the sequence is then\n    assigned to the starred target (the list can be empty).\n\n  * Else: The object must be a sequence with the same number of items\n    as there are targets in the target list, and the items are\n    assigned, from left to right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n  * If the name does not occur in a ``global`` or ``nonlocal``\n    statement in the current code block: the name is bound to the\n    object in the current local namespace.\n\n  * Otherwise: the name is bound to the object in the global namespace\n    or the outer namespace determined by ``nonlocal``, respectively.\n\n  The name is rebound if it was already bound.  This may cause the\n  reference count for the object previously bound to the name to reach\n  zero, causing the object to be deallocated and its destructor (if it\n  has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in square\n  brackets: The object must be an iterable with the same number of\n  items as there are targets in the target list, and its items are\n  assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n  the reference is evaluated.  It should yield an object with\n  assignable attributes; if this is not the case, ``TypeError`` is\n  raised.  That object is then asked to assign the assigned object to\n  the given attribute; if it cannot perform the assignment, it raises\n  an exception (usually but not necessarily ``AttributeError``).\n\n  Note: If the object is a class instance and the attribute reference\n  occurs on both sides of the assignment operator, the RHS expression,\n  ``a.x`` can access either an instance attribute or (if no instance\n  attribute exists) a class attribute.  The LHS target ``a.x`` is\n  always set as an instance attribute, creating it if necessary.\n  Thus, the two occurrences of ``a.x`` do not necessarily refer to the\n  same attribute: if the RHS expression refers to a class attribute,\n  the LHS creates a new instance attribute as the target of the\n  assignment:\n\n     class Cls:\n         x = 3             # class variable\n     inst = Cls()\n     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3\n\n  This description does not necessarily apply to descriptor\n  attributes, such as properties created with ``property()``.\n\n* If the target is a subscription: The primary expression in the\n  reference is evaluated.  It should yield either a mutable sequence\n  object (such as a list) or a mapping object (such as a dictionary).\n  Next, the subscript expression is evaluated.\n\n  If the primary is a mutable sequence object (such as a list), the\n  subscript must yield an integer.  If it is negative, the sequence\'s\n  length is added to it.  The resulting value must be a nonnegative\n  integer less than the sequence\'s length, and the sequence is asked\n  to assign the assigned object to its item with that index.  If the\n  index is out of range, ``IndexError`` is raised (assignment to a\n  subscripted sequence cannot add new items to a list).\n\n  If the primary is a mapping object (such as a dictionary), the\n  subscript must have a type compatible with the mapping\'s key type,\n  and the mapping is then asked to create a key/datum pair which maps\n  the subscript to the assigned object.  This can either replace an\n  existing key/value pair with the same key value, or insert a new\n  key/value pair (if no key with the same value existed).\n\n  For user-defined objects, the ``__setitem__()`` method is called\n  with appropriate arguments.\n\n* If the target is a slicing: The primary expression in the reference\n  is evaluated.  It should yield a mutable sequence object (such as a\n  list).  The assigned object should be a sequence object of the same\n  type.  Next, the lower and upper bound expressions are evaluated,\n  insofar they are present; defaults are zero and the sequence\'s\n  length.  The bounds should evaluate to integers. If either bound is\n  negative, the sequence\'s length is added to it.  The resulting\n  bounds are clipped to lie between zero and the sequence\'s length,\n  inclusive.  Finally, the sequence object is asked to replace the\n  slice with the items of the assigned sequence.  The length of the\n  slice may be different from the length of the assigned sequence,\n  thus changing the length of the target sequence, if the object\n  allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax for targets is taken to be the same as for expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (for\nexample ``a, b = b, a`` swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe!  For instance, the\nfollowing program prints ``[0, 2]``:\n\n   x = [0, 1]\n   i = 0\n   i, x[i] = 1, 2\n   print(x)\n\nSee also:\n\n   **PEP 3132** - Extended Iterable Unpacking\n      The specification for the ``*target`` feature.\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n   augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n   augtarget                 ::= identifier | attributeref | subscription | slicing\n   augop                     ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n             | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries* for the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the target (which, unlike normal\nassignment statements, cannot be an unpacking) and the expression\nlist, performs the binary operation specific to the type of assignment\non the two operands, and assigns the result to the original target.\nThe target is only evaluated once.\n\nAn augmented assignment expression like ``x += 1`` can be rewritten as\n``x = x + 1`` to achieve a similar, but not exactly equal effect. In\nthe augmented version, ``x`` is only evaluated once. Also, when\npossible, the actual operation is performed *in-place*, meaning that\nrather than creating a new object and assigning that to the target,\nthe old object is modified instead.\n\nWith the exception of assigning to tuples and multiple targets in a\nsingle statement, the assignment done by augmented assignment\nstatements is handled the same way as normal assignments. Similarly,\nwith the exception of the possible *in-place* behavior, the binary\noperation performed by augmented assignment is the same as the normal\nbinary operations.\n\nFor targets which are attribute references, the same *caveat about\nclass and instance attributes* applies as for regular assignments.\n',
- 'atom-identifiers': '\nIdentifiers (Names)\n*******************\n\nAn identifier occurring as an atom is a name.  See section\n*Identifiers and keywords* for lexical definition and section *Naming\nand binding* for documentation of naming and binding.\n\nWhen the name is bound to an object, evaluation of the atom yields\nthat object. When a name is not bound, an attempt to evaluate it\nraises a ``NameError`` exception.\n\n**Private name mangling:** When an identifier that textually occurs in\na class definition begins with two or more underscore characters and\ndoes not end in two or more underscores, it is considered a *private\nname* of that class. Private names are transformed to a longer form\nbefore code is generated for them.  The transformation inserts the\nclass name, with leading underscores removed and a single underscore\ninserted, in front of the name.  For example, the identifier\n``__spam`` occurring in a class named ``Ham`` will be transformed to\n``_Ham__spam``.  This transformation is independent of the syntactical\ncontext in which the identifier is used.  If the transformed name is\nextremely long (longer than 255 characters), implementation defined\ntruncation may happen. If the class name consists only of underscores,\nno transformation is done.\n',
+ 'atom-identifiers': '\nIdentifiers (Names)\n*******************\n\nAn identifier occurring as an atom is a name.  See section\n*Identifiers and keywords* for lexical definition and section *Naming\nand binding* for documentation of naming and binding.\n\nWhen the name is bound to an object, evaluation of the atom yields\nthat object. When a name is not bound, an attempt to evaluate it\nraises a ``NameError`` exception.\n\n**Private name mangling:** When an identifier that textually occurs in\na class definition begins with two or more underscore characters and\ndoes not end in two or more underscores, it is considered a *private\nname* of that class. Private names are transformed to a longer form\nbefore code is generated for them.  The transformation inserts the\nclass name in front of the name, with leading underscores removed, and\na single underscore inserted in front of the class name.  For example,\nthe identifier ``__spam`` occurring in a class named ``Ham`` will be\ntransformed to ``_Ham__spam``.  This transformation is independent of\nthe syntactical context in which the identifier is used.  If the\ntransformed name is extremely long (longer than 255 characters),\nimplementation defined truncation may happen.  If the class name\nconsists only of underscores, no transformation is done.\n',
  'atom-literals': "\nLiterals\n********\n\nPython supports string and bytes literals and various numeric\nliterals:\n\n   literal ::= stringliteral | bytesliteral\n               | integer | floatnumber | imagnumber\n\nEvaluation of a literal yields an object of the given type (string,\nbytes, integer, floating point number, complex number) with the given\nvalue.  The value may be approximated in the case of floating point\nand imaginary (complex) literals.  See section *Literals* for details.\n\nAll literals correspond to immutable data types, and hence the\nobject's identity is less important than its value.  Multiple\nevaluations of literals with the same value (either the same\noccurrence in the program text or a different occurrence) may obtain\nthe same object or a different object with the same value.\n",
  'attribute-access': '\nCustomizing attribute access\n****************************\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of ``x.name``)\nfor class instances.\n\nobject.__getattr__(self, name)\n\n   Called when an attribute lookup has not found the attribute in the\n   usual places (i.e. it is not an instance attribute nor is it found\n   in the class tree for ``self``).  ``name`` is the attribute name.\n   This method should return the (computed) attribute value or raise\n   an ``AttributeError`` exception.\n\n   Note that if the attribute is found through the normal mechanism,\n   ``__getattr__()`` is not called.  (This is an intentional asymmetry\n   between ``__getattr__()`` and ``__setattr__()``.) This is done both\n   for efficiency reasons and because otherwise ``__getattr__()``\n   would have no way to access other attributes of the instance.  Note\n   that at least for instance variables, you can fake total control by\n   not inserting any values in the instance attribute dictionary (but\n   instead inserting them in another object).  See the\n   ``__getattribute__()`` method below for a way to actually get total\n   control over attribute access.\n\nobject.__getattribute__(self, name)\n\n   Called unconditionally to implement attribute accesses for\n   instances of the class. If the class also defines\n   ``__getattr__()``, the latter will not be called unless\n   ``__getattribute__()`` either calls it explicitly or raises an\n   ``AttributeError``. This method should return the (computed)\n   attribute value or raise an ``AttributeError`` exception. In order\n   to avoid infinite recursion in this method, its implementation\n   should always call the base class method with the same name to\n   access any attributes it needs, for example,\n   ``object.__getattribute__(self, name)``.\n\n   Note: This method may still be bypassed when looking up special methods\n     as the result of implicit invocation via language syntax or\n     built-in functions. See *Special method lookup*.\n\nobject.__setattr__(self, name, value)\n\n   Called when an attribute assignment is attempted.  This is called\n   instead of the normal mechanism (i.e. store the value in the\n   instance dictionary). *name* is the attribute name, *value* is the\n   value to be assigned to it.\n\n   If ``__setattr__()`` wants to assign to an instance attribute, it\n   should call the base class method with the same name, for example,\n   ``object.__setattr__(self, name, value)``.\n\nobject.__delattr__(self, name)\n\n   Like ``__setattr__()`` but for attribute deletion instead of\n   assignment.  This should only be implemented if ``del obj.name`` is\n   meaningful for the object.\n\nobject.__dir__(self)\n\n   Called when ``dir()`` is called on the object. A sequence must be\n   returned. ``dir()`` converts the returned sequence to a list and\n   sorts it.\n\n\nImplementing Descriptors\n========================\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents).  In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' ``__dict__``.\n\nobject.__get__(self, instance, owner)\n\n   Called to get the attribute of the owner class (class attribute\n   access) or of an instance of that class (instance attribute\n   access). *owner* is always the owner class, while *instance* is the\n   instance that the attribute was accessed through, or ``None`` when\n   the attribute is accessed through the *owner*.  This method should\n   return the (computed) attribute value or raise an\n   ``AttributeError`` exception.\n\nobject.__set__(self, instance, value)\n\n   Called to set the attribute on an instance *instance* of the owner\n   class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n   Called to delete the attribute on an instance *instance* of the\n   owner class.\n\n\nInvoking Descriptors\n====================\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol:  ``__get__()``, ``__set__()``, and\n``__delete__()``. If any of those methods are defined for an object,\nit is said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, ``a.x`` has a\nlookup chain starting with ``a.__dict__[\'x\']``, then\n``type(a).__dict__[\'x\']``, and continuing through the base classes of\n``type(a)`` excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead.  Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called.\n\nThe starting point for descriptor invocation is a binding, ``a.x``.\nHow the arguments are assembled depends on ``a``:\n\nDirect Call\n   The simplest and least common call is when user code directly\n   invokes a descriptor method:    ``x.__get__(a)``.\n\nInstance Binding\n   If binding to an object instance, ``a.x`` is transformed into the\n   call: ``type(a).__dict__[\'x\'].__get__(a, type(a))``.\n\nClass Binding\n   If binding to a class, ``A.x`` is transformed into the call:\n   ``A.__dict__[\'x\'].__get__(None, A)``.\n\nSuper Binding\n   If ``a`` is an instance of ``super``, then the binding ``super(B,\n   obj).m()`` searches ``obj.__class__.__mro__`` for the base class\n   ``A`` immediately preceding ``B`` and then invokes the descriptor\n   with the call: ``A.__dict__[\'m\'].__get__(obj, obj.__class__)``.\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined.  A descriptor can define\nany combination of ``__get__()``, ``__set__()`` and ``__delete__()``.\nIf it does not define ``__get__()``, then accessing the attribute will\nreturn the descriptor object itself unless there is a value in the\nobject\'s instance dictionary.  If the descriptor defines ``__set__()``\nand/or ``__delete__()``, it is a data descriptor; if it defines\nneither, it is a non-data descriptor.  Normally, data descriptors\ndefine both ``__get__()`` and ``__set__()``, while non-data\ndescriptors have just the ``__get__()`` method.  Data descriptors with\n``__set__()`` and ``__get__()`` defined always override a redefinition\nin an instance dictionary.  In contrast, non-data descriptors can be\noverridden by instances.\n\nPython methods (including ``staticmethod()`` and ``classmethod()``)\nare implemented as non-data descriptors.  Accordingly, instances can\nredefine and override methods.  This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe ``property()`` function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n=========\n\nBy default, instances of classes have a dictionary for attribute\nstorage.  This wastes space for objects having very few instance\nvariables.  The space consumption can become acute when creating large\nnumbers of instances.\n\nThe default can be overridden by defining *__slots__* in a class\ndefinition. The *__slots__* declaration takes a sequence of instance\nvariables and reserves just enough space in each instance to hold a\nvalue for each variable.  Space is saved because *__dict__* is not\ncreated for each instance.\n\nobject.__slots__\n\n   This class variable can be assigned a string, iterable, or sequence\n   of strings with variable names used by instances.  If defined in a\n   class, *__slots__* reserves space for the declared variables and\n   prevents the automatic creation of *__dict__* and *__weakref__* for\n   each instance.\n\n\nNotes on using *__slots__*\n--------------------------\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n  attribute of that class will always be accessible, so a *__slots__*\n  definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n  variables not listed in the *__slots__* definition.  Attempts to\n  assign to an unlisted variable name raises ``AttributeError``. If\n  dynamic assignment of new variables is desired, then add\n  ``\'__dict__\'`` to the sequence of strings in the *__slots__*\n  declaration.\n\n* Without a *__weakref__* variable for each instance, classes defining\n  *__slots__* do not support weak references to its instances. If weak\n  reference support is needed, then add ``\'__weakref__\'`` to the\n  sequence of strings in the *__slots__* declaration.\n\n* *__slots__* are implemented at the class level by creating\n  descriptors (*Implementing Descriptors*) for each variable name.  As\n  a result, class attributes cannot be used to set default values for\n  instance variables defined by *__slots__*; otherwise, the class\n  attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n  where it is defined.  As a result, subclasses will have a *__dict__*\n  unless they also define *__slots__* (which must only contain names\n  of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the instance\n  variable defined by the base class slot is inaccessible (except by\n  retrieving its descriptor directly from the base class). This\n  renders the meaning of the program undefined.  In the future, a\n  check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n  "variable-length" built-in types such as ``int``, ``str`` and\n  ``tuple``.\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings may\n  also be used; however, in the future, special meaning may be\n  assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n  *__slots__*.\n',
  'attribute-references': '\nAttribute references\n********************\n\nAn attribute reference is a primary followed by a period and a name:\n\n   attributeref ::= primary "." identifier\n\nThe primary must evaluate to an object of a type that supports\nattribute references, which most objects do.  This object is then\nasked to produce the attribute whose name is the identifier (which can\nbe customized by overriding the ``__getattr__()`` method).  If this\nattribute is not available, the exception ``AttributeError`` is\nraised.  Otherwise, the type and value of the object produced is\ndetermined by the object.  Multiple evaluations of the same attribute\nreference may yield different objects.\n',
@@ -19,11 +19,11 @@
  'calls': '\nCalls\n*****\n\nA call calls a callable object (e.g., a *function*) with a possibly\nempty series of *arguments*:\n\n   call                 ::= primary "(" [argument_list [","] | comprehension] ")"\n   argument_list        ::= positional_arguments ["," keyword_arguments]\n                       ["," "*" expression] ["," keyword_arguments]\n                       ["," "**" expression]\n                     | keyword_arguments ["," "*" expression]\n                       ["," keyword_arguments] ["," "**" expression]\n                     | "*" expression ["," keyword_arguments] ["," "**" expression]\n                     | "**" expression\n   positional_arguments ::= expression ("," expression)*\n   keyword_arguments    ::= keyword_item ("," keyword_item)*\n   keyword_item         ::= identifier "=" expression\n\nA trailing comma may be present after the positional and keyword\narguments but does not affect the semantics.\n\nThe primary must evaluate to a callable object (user-defined\nfunctions, built-in functions, methods of built-in objects, class\nobjects, methods of class instances, and all objects having a\n``__call__()`` method are callable).  All argument expressions are\nevaluated before the call is attempted.  Please refer to section\n*Function definitions* for the syntax of formal *parameter* lists.\n\nIf keyword arguments are present, they are first converted to\npositional arguments, as follows.  First, a list of unfilled slots is\ncreated for the formal parameters.  If there are N positional\narguments, they are placed in the first N slots.  Next, for each\nkeyword argument, the identifier is used to determine the\ncorresponding slot (if the identifier is the same as the first formal\nparameter name, the first slot is used, and so on).  If the slot is\nalready filled, a ``TypeError`` exception is raised. Otherwise, the\nvalue of the argument is placed in the slot, filling it (even if the\nexpression is ``None``, it fills the slot).  When all arguments have\nbeen processed, the slots that are still unfilled are filled with the\ncorresponding default value from the function definition.  (Default\nvalues are calculated, once, when the function is defined; thus, a\nmutable object such as a list or dictionary used as default value will\nbe shared by all calls that don\'t specify an argument value for the\ncorresponding slot; this should usually be avoided.)  If there are any\nunfilled slots for which no default value is specified, a\n``TypeError`` exception is raised.  Otherwise, the list of filled\nslots is used as the argument list for the call.\n\n**CPython implementation detail:** An implementation may provide\nbuilt-in functions whose positional parameters do not have names, even\nif they are \'named\' for the purpose of documentation, and which\ntherefore cannot be supplied by keyword.  In CPython, this is the case\nfor functions implemented in C that use ``PyArg_ParseTuple()`` to\nparse their arguments.\n\nIf there are more positional arguments than there are formal parameter\nslots, a ``TypeError`` exception is raised, unless a formal parameter\nusing the syntax ``*identifier`` is present; in this case, that formal\nparameter receives a tuple containing the excess positional arguments\n(or an empty tuple if there were no excess positional arguments).\n\nIf any keyword argument does not correspond to a formal parameter\nname, a ``TypeError`` exception is raised, unless a formal parameter\nusing the syntax ``**identifier`` is present; in this case, that\nformal parameter receives a dictionary containing the excess keyword\narguments (using the keywords as keys and the argument values as\ncorresponding values), or a (new) empty dictionary if there were no\nexcess keyword arguments.\n\nIf the syntax ``*expression`` appears in the function call,\n``expression`` must evaluate to an iterable.  Elements from this\niterable are treated as if they were additional positional arguments;\nif there are positional arguments *x1*, ..., *xN*, and ``expression``\nevaluates to a sequence *y1*, ..., *yM*, this is equivalent to a call\nwith M+N positional arguments *x1*, ..., *xN*, *y1*, ..., *yM*.\n\nA consequence of this is that although the ``*expression`` syntax may\nappear *after* some keyword arguments, it is processed *before* the\nkeyword arguments (and the ``**expression`` argument, if any -- see\nbelow).  So:\n\n   >>> def f(a, b):\n   ...  print(a, b)\n   ...\n   >>> f(b=1, *(2,))\n   2 1\n   >>> f(a=1, *(2,))\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in ?\n   TypeError: f() got multiple values for keyword argument \'a\'\n   >>> f(1, *(2,))\n   1 2\n\nIt is unusual for both keyword arguments and the ``*expression``\nsyntax to be used in the same call, so in practice this confusion does\nnot arise.\n\nIf the syntax ``**expression`` appears in the function call,\n``expression`` must evaluate to a mapping, the contents of which are\ntreated as additional keyword arguments.  In the case of a keyword\nappearing in both ``expression`` and as an explicit keyword argument,\na ``TypeError`` exception is raised.\n\nFormal parameters using the syntax ``*identifier`` or ``**identifier``\ncannot be used as positional argument slots or as keyword argument\nnames.\n\nA call always returns some value, possibly ``None``, unless it raises\nan exception.  How this value is computed depends on the type of the\ncallable object.\n\nIf it is---\n\na user-defined function:\n   The code block for the function is executed, passing it the\n   argument list.  The first thing the code block will do is bind the\n   formal parameters to the arguments; this is described in section\n   *Function definitions*.  When the code block executes a ``return``\n   statement, this specifies the return value of the function call.\n\na built-in function or method:\n   The result is up to the interpreter; see *Built-in Functions* for\n   the descriptions of built-in functions and methods.\n\na class object:\n   A new instance of that class is returned.\n\na class instance method:\n   The corresponding user-defined function is called, with an argument\n   list that is one longer than the argument list of the call: the\n   instance becomes the first argument.\n\na class instance:\n   The class must define a ``__call__()`` method; the effect is then\n   the same as if that method was called.\n',
  'class': '\nClass definitions\n*****************\n\nA class definition defines a class object (see section *The standard\ntype hierarchy*):\n\n   classdef    ::= [decorators] "class" classname [inheritance] ":" suite\n   inheritance ::= "(" [parameter_list] ")"\n   classname   ::= identifier\n\nA class definition is an executable statement.  The inheritance list\nusually gives a list of base classes (see *Customizing class creation*\nfor more advanced uses), so each item in the list should evaluate to a\nclass object which allows subclassing.  Classes without an inheritance\nlist inherit, by default, from the base class ``object``; hence,\n\n   class Foo:\n       pass\n\nis equivalent to\n\n   class Foo(object):\n       pass\n\nThe class\'s suite is then executed in a new execution frame (see\n*Naming and binding*), using a newly created local namespace and the\noriginal global namespace. (Usually, the suite contains mostly\nfunction definitions.)  When the class\'s suite finishes execution, its\nexecution frame is discarded but its local namespace is saved. [4] A\nclass object is then created using the inheritance list for the base\nclasses and the saved local namespace for the attribute dictionary.\nThe class name is bound to this class object in the original local\nnamespace.\n\nClass creation can be customized heavily using *metaclasses*.\n\nClasses can also be decorated: just like when decorating functions,\n\n   @f1(arg)\n   @f2\n   class Foo: pass\n\nis equivalent to\n\n   class Foo: pass\n   Foo = f1(arg)(f2(Foo))\n\nThe evaluation rules for the decorator expressions are the same as for\nfunction decorators.  The result must be a class object, which is then\nbound to the class name.\n\n**Programmer\'s note:** Variables defined in the class definition are\nclass attributes; they are shared by instances.  Instance attributes\ncan be set in a method with ``self.name = value``.  Both class and\ninstance attributes are accessible through the notation\n"``self.name``", and an instance attribute hides a class attribute\nwith the same name when accessed in this way.  Class attributes can be\nused as defaults for instance attributes, but using mutable values\nthere can lead to unexpected results.  *Descriptors* can be used to\ncreate instance variables with different implementation details.\n\nSee also:\n\n   **PEP 3115** - Metaclasses in Python 3 **PEP 3129** - Class\n   Decorators\n\n-[ Footnotes ]-\n\n[1] The exception is propagated to the invocation stack unless there\n    is a ``finally`` clause which happens to raise another exception.\n    That new exception causes the old one to be lost.\n\n[2] Currently, control "flows off the end" except in the case of an\n    exception or the execution of a ``return``, ``continue``, or\n    ``break`` statement.\n\n[3] A string literal appearing as the first statement in the function\n    body is transformed into the function\'s ``__doc__`` attribute and\n    therefore the function\'s *docstring*.\n\n[4] A string literal appearing as the first statement in the class\n    body is transformed into the namespace\'s ``__doc__`` item and\n    therefore the class\'s *docstring*.\n',
  'comparisons': '\nComparisons\n***********\n\nUnlike C, all comparison operations in Python have the same priority,\nwhich is lower than that of any arithmetic, shifting or bitwise\noperation.  Also unlike C, expressions like ``a < b < c`` have the\ninterpretation that is conventional in mathematics:\n\n   comparison    ::= or_expr ( comp_operator or_expr )*\n   comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="\n                     | "is" ["not"] | ["not"] "in"\n\nComparisons yield boolean values: ``True`` or ``False``.\n\nComparisons can be chained arbitrarily, e.g., ``x < y <= z`` is\nequivalent to ``x < y and y <= z``, except that ``y`` is evaluated\nonly once (but in both cases ``z`` is not evaluated at all when ``x <\ny`` is found to be false).\n\nFormally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*,\n*op2*, ..., *opN* are comparison operators, then ``a op1 b op2 c ... y\nopN z`` is equivalent to ``a op1 b and b op2 c and ... y opN z``,\nexcept that each expression is evaluated at most once.\n\nNote that ``a op1 b op2 c`` doesn\'t imply any kind of comparison\nbetween *a* and *c*, so that, e.g., ``x < y > z`` is perfectly legal\n(though perhaps not pretty).\n\nThe operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare\nthe values of two objects.  The objects need not have the same type.\nIf both are numbers, they are converted to a common type.  Otherwise,\nthe ``==`` and ``!=`` operators *always* consider objects of different\ntypes to be unequal, while the ``<``, ``>``, ``>=`` and ``<=``\noperators raise a ``TypeError`` when comparing objects of different\ntypes that do not implement these operators for the given pair of\ntypes.  You can control comparison behavior of objects of non-built-in\ntypes by defining rich comparison methods like ``__gt__()``, described\nin section *Basic customization*.\n\nComparison of objects of the same type depends on the type:\n\n* Numbers are compared arithmetically.\n\n* The values ``float(\'NaN\')`` and ``Decimal(\'NaN\')`` are special. The\n  are identical to themselves, ``x is x`` but are not equal to\n  themselves, ``x != x``.  Additionally, comparing any value to a\n  not-a-number value will return ``False``.  For example, both ``3 <\n  float(\'NaN\')`` and ``float(\'NaN\') < 3`` will return ``False``.\n\n* Bytes objects are compared lexicographically using the numeric\n  values of their elements.\n\n* Strings are compared lexicographically using the numeric equivalents\n  (the result of the built-in function ``ord()``) of their characters.\n  [3] String and bytes object can\'t be compared!\n\n* Tuples and lists are compared lexicographically using comparison of\n  corresponding elements.  This means that to compare equal, each\n  element must compare equal and the two sequences must be of the same\n  type and have the same length.\n\n  If not equal, the sequences are ordered the same as their first\n  differing elements.  For example, ``[1,2,x] <= [1,2,y]`` has the\n  same value as ``x <= y``.  If the corresponding element does not\n  exist, the shorter sequence is ordered first (for example, ``[1,2] <\n  [1,2,3]``).\n\n* Mappings (dictionaries) compare equal if and only if they have the\n  same ``(key, value)`` pairs. Order comparisons ``(\'<\', \'<=\', \'>=\',\n  \'>\')`` raise ``TypeError``.\n\n* Sets and frozensets define comparison operators to mean subset and\n  superset tests.  Those relations do not define total orderings (the\n  two sets ``{1,2}`` and {2,3} are not equal, nor subsets of one\n  another, nor supersets of one another).  Accordingly, sets are not\n  appropriate arguments for functions which depend on total ordering.\n  For example, ``min()``, ``max()``, and ``sorted()`` produce\n  undefined results given a list of sets as inputs.\n\n* Most other objects of built-in types compare unequal unless they are\n  the same object; the choice whether one object is considered smaller\n  or larger than another one is made arbitrarily but consistently\n  within one execution of a program.\n\nComparison of objects of the differing types depends on whether either\nof the types provide explicit support for the comparison.  Most\nnumeric types can be compared with one another.  When cross-type\ncomparison is not supported, the comparison method returns\n``NotImplemented``.\n\nThe operators ``in`` and ``not in`` test for membership.  ``x in s``\nevaluates to true if *x* is a member of *s*, and false otherwise.  ``x\nnot in s`` returns the negation of ``x in s``.  All built-in sequences\nand set types support this as well as dictionary, for which ``in``\ntests whether a the dictionary has a given key. For container types\nsuch as list, tuple, set, frozenset, dict, or collections.deque, the\nexpression ``x in y`` is equivalent to ``any(x is e or x == e for e in\ny)``.\n\nFor the string and bytes types, ``x in y`` is true if and only if *x*\nis a substring of *y*.  An equivalent test is ``y.find(x) != -1``.\nEmpty strings are always considered to be a substring of any other\nstring, so ``"" in "abc"`` will return ``True``.\n\nFor user-defined classes which define the ``__contains__()`` method,\n``x in y`` is true if and only if ``y.__contains__(x)`` is true.\n\nFor user-defined classes which do not define ``__contains__()`` but do\ndefine ``__iter__()``, ``x in y`` is true if some value ``z`` with ``x\n== z`` is produced while iterating over ``y``.  If an exception is\nraised during the iteration, it is as if ``in`` raised that exception.\n\nLastly, the old-style iteration protocol is tried: if a class defines\n``__getitem__()``, ``x in y`` is true if and only if there is a non-\nnegative integer index *i* such that ``x == y[i]``, and all lower\ninteger indices do not raise ``IndexError`` exception.  (If any other\nexception is raised, it is as if ``in`` raised that exception).\n\nThe operator ``not in`` is defined to have the inverse true value of\n``in``.\n\nThe operators ``is`` and ``is not`` test for object identity: ``x is\ny`` is true if and only if *x* and *y* are the same object.  ``x is\nnot y`` yields the inverse truth value. [4]\n',
- 'compound': '\nCompound statements\n*******************\n\nCompound statements contain (groups of) other statements; they affect\nor control the execution of those other statements in some way.  In\ngeneral, compound statements span multiple lines, although in simple\nincarnations a whole compound statement may be contained in one line.\n\nThe ``if``, ``while`` and ``for`` statements implement traditional\ncontrol flow constructs.  ``try`` specifies exception handlers and/or\ncleanup code for a group of statements, while the ``with`` statement\nallows the execution of initialization and finalization code around a\nblock of code.  Function and class definitions are also syntactically\ncompound statements.\n\nCompound statements consist of one or more \'clauses.\'  A clause\nconsists of a header and a \'suite.\'  The clause headers of a\nparticular compound statement are all at the same indentation level.\nEach clause header begins with a uniquely identifying keyword and ends\nwith a colon.  A suite is a group of statements controlled by a\nclause.  A suite can be one or more semicolon-separated simple\nstatements on the same line as the header, following the header\'s\ncolon, or it can be one or more indented statements on subsequent\nlines.  Only the latter form of suite can contain nested compound\nstatements; the following is illegal, mostly because it wouldn\'t be\nclear to which ``if`` clause a following ``else`` clause would belong:\n\n   if test1: if test2: print(x)\n\nAlso note that the semicolon binds tighter than the colon in this\ncontext, so that in the following example, either all or none of the\n``print()`` calls are executed:\n\n   if x < y < z: print(x); print(y); print(z)\n\nSummarizing:\n\n   compound_stmt ::= if_stmt\n                     | while_stmt\n                     | for_stmt\n                     | try_stmt\n                     | with_stmt\n                     | funcdef\n                     | classdef\n   suite         ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT\n   statement     ::= stmt_list NEWLINE | compound_stmt\n   stmt_list     ::= simple_stmt (";" simple_stmt)* [";"]\n\nNote that statements always end in a ``NEWLINE`` possibly followed by\na ``DEDENT``.  Also note that optional continuation clauses always\nbegin with a keyword that cannot start a statement, thus there are no\nambiguities (the \'dangling ``else``\' problem is solved in Python by\nrequiring nested ``if`` statements to be indented).\n\nThe formatting of the grammar rules in the following sections places\neach clause on a separate line for clarity.\n\n\nThe ``if`` statement\n====================\n\nThe ``if`` statement is used for conditional execution:\n\n   if_stmt ::= "if" expression ":" suite\n               ( "elif" expression ":" suite )*\n               ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section *Boolean operations*\nfor the definition of true and false); then that suite is executed\n(and no other part of the ``if`` statement is executed or evaluated).\nIf all expressions are false, the suite of the ``else`` clause, if\npresent, is executed.\n\n\nThe ``while`` statement\n=======================\n\nThe ``while`` statement is used for repeated execution as long as an\nexpression is true:\n\n   while_stmt ::= "while" expression ":" suite\n                  ["else" ":" suite]\n\nThis repeatedly tests the expression and, if it is true, executes the\nfirst suite; if the expression is false (which may be the first time\nit is tested) the suite of the ``else`` clause, if present, is\nexecuted and the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ngoes back to testing the expression.\n\n\nThe ``for`` statement\n=====================\n\nThe ``for`` statement is used to iterate over the elements of a\nsequence (such as a string, tuple or list) or other iterable object:\n\n   for_stmt ::= "for" target_list "in" expression_list ":" suite\n                ["else" ":" suite]\n\nThe expression list is evaluated once; it should yield an iterable\nobject.  An iterator is created for the result of the\n``expression_list``.  The suite is then executed once for each item\nprovided by the iterator, in the order of ascending indices.  Each\nitem in turn is assigned to the target list using the standard rules\nfor assignments (see *Assignment statements*), and then the suite is\nexecuted.  When the items are exhausted (which is immediately when the\nsequence is empty or an iterator raises a ``StopIteration``\nexception), the suite in the ``else`` clause, if present, is executed,\nand the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ncontinues with the next item, or with the ``else`` clause if there was\nno next item.\n\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\n\nNames in the target list are not deleted when the loop is finished,\nbut if the sequence is empty, it will not have been assigned to at all\nby the loop.  Hint: the built-in function ``range()`` returns an\niterator of integers suitable to emulate the effect of Pascal\'s ``for\ni := a to b do``; e.g., ``list(range(3))`` returns the list ``[0, 1,\n2]``.\n\nNote: There is a subtlety when the sequence is being modified by the loop\n  (this can only occur for mutable sequences, i.e. lists).  An\n  internal counter is used to keep track of which item is used next,\n  and this is incremented on each iteration.  When this counter has\n  reached the length of the sequence the loop terminates.  This means\n  that if the suite deletes the current (or a previous) item from the\n  sequence, the next item will be skipped (since it gets the index of\n  the current item which has already been treated).  Likewise, if the\n  suite inserts an item in the sequence before the current item, the\n  current item will be treated again the next time through the loop.\n  This can lead to nasty bugs that can be avoided by making a\n  temporary copy using a slice of the whole sequence, e.g.,\n\n     for x in a[:]:\n         if x < 0: a.remove(x)\n\n\nThe ``try`` statement\n=====================\n\nThe ``try`` statement specifies exception handlers and/or cleanup code\nfor a group of statements:\n\n   try_stmt  ::= try1_stmt | try2_stmt\n   try1_stmt ::= "try" ":" suite\n                 ("except" [expression ["as" target]] ":" suite)+\n                 ["else" ":" suite]\n                 ["finally" ":" suite]\n   try2_stmt ::= "try" ":" suite\n                 "finally" ":" suite\n\nThe ``except`` clause(s) specify one or more exception handlers. When\nno exception occurs in the ``try`` clause, no exception handler is\nexecuted. When an exception occurs in the ``try`` suite, a search for\nan exception handler is started.  This search inspects the except\nclauses in turn until one is found that matches the exception.  An\nexpression-less except clause, if present, must be last; it matches\nany exception.  For an except clause with an expression, that\nexpression is evaluated, and the clause matches the exception if the\nresulting object is "compatible" with the exception.  An object is\ncompatible with an exception if it is the class or a base class of the\nexception object or a tuple containing an item compatible with the\nexception.\n\nIf no except clause matches the exception, the search for an exception\nhandler continues in the surrounding code and on the invocation stack.\n[1]\n\nIf the evaluation of an expression in the header of an except clause\nraises an exception, the original search for a handler is canceled and\na search starts for the new exception in the surrounding code and on\nthe call stack (it is treated as if the entire ``try`` statement\nraised the exception).\n\nWhen a matching except clause is found, the exception is assigned to\nthe target specified after the ``as`` keyword in that except clause,\nif present, and the except clause\'s suite is executed.  All except\nclauses must have an executable block.  When the end of this block is\nreached, execution continues normally after the entire try statement.\n(This means that if two nested handlers exist for the same exception,\nand the exception occurs in the try clause of the inner handler, the\nouter handler will not handle the exception.)\n\nWhen an exception has been assigned using ``as target``, it is cleared\nat the end of the except clause.  This is as if\n\n   except E as N:\n       foo\n\nwas translated to\n\n   except E as N:\n       try:\n           foo\n       finally:\n           del N\n\nThis means the exception must be assigned to a different name to be\nable to refer to it after the except clause.  Exceptions are cleared\nbecause with the traceback attached to them, they form a reference\ncycle with the stack frame, keeping all locals in that frame alive\nuntil the next garbage collection occurs.\n\nBefore an except clause\'s suite is executed, details about the\nexception are stored in the ``sys`` module and can be access via\n``sys.exc_info()``. ``sys.exc_info()`` returns a 3-tuple consisting of\nthe exception class, the exception instance and a traceback object\n(see section *The standard type hierarchy*) identifying the point in\nthe program where the exception occurred.  ``sys.exc_info()`` values\nare restored to their previous values (before the call) when returning\nfrom a function that handled an exception.\n\nThe optional ``else`` clause is executed if and when control flows off\nthe end of the ``try`` clause. [2] Exceptions in the ``else`` clause\nare not handled by the preceding ``except`` clauses.\n\nIf ``finally`` is present, it specifies a \'cleanup\' handler.  The\n``try`` clause is executed, including any ``except`` and ``else``\nclauses.  If an exception occurs in any of the clauses and is not\nhandled, the exception is temporarily saved. The ``finally`` clause is\nexecuted.  If there is a saved exception it is re-raised at the end of\nthe ``finally`` clause.  If the ``finally`` clause raises another\nexception, the saved exception is set as the context of the new\nexception. If the ``finally`` clause executes a ``return`` or\n``break`` statement, the saved exception is discarded:\n\n   def f():\n       try:\n           1/0\n       finally:\n           return 42\n\n   >>> f()\n   42\n\nThe exception information is not available to the program during\nexecution of the ``finally`` clause.\n\nWhen a ``return``, ``break`` or ``continue`` statement is executed in\nthe ``try`` suite of a ``try``...``finally`` statement, the\n``finally`` clause is also executed \'on the way out.\' A ``continue``\nstatement is illegal in the ``finally`` clause. (The reason is a\nproblem with the current implementation --- this restriction may be\nlifted in the future).\n\nAdditional information on exceptions can be found in section\n*Exceptions*, and information on using the ``raise`` statement to\ngenerate exceptions may be found in section *The raise statement*.\n\n\nThe ``with`` statement\n======================\n\nThe ``with`` statement is used to wrap the execution of a block with\nmethods defined by a context manager (see section *With Statement\nContext Managers*). This allows common\n``try``...``except``...``finally`` usage patterns to be encapsulated\nfor convenient reuse.\n\n   with_stmt ::= "with" with_item ("," with_item)* ":" suite\n   with_item ::= expression ["as" target]\n\nThe execution of the ``with`` statement with one "item" proceeds as\nfollows:\n\n1. The context expression (the expression given in the ``with_item``)\n   is evaluated to obtain a context manager.\n\n2. The context manager\'s ``__exit__()`` is loaded for later use.\n\n3. The context manager\'s ``__enter__()`` method is invoked.\n\n4. If a target was included in the ``with`` statement, the return\n   value from ``__enter__()`` is assigned to it.\n\n   Note: The ``with`` statement guarantees that if the ``__enter__()``\n     method returns without an error, then ``__exit__()`` will always\n     be called. Thus, if an error occurs during the assignment to the\n     target list, it will be treated the same as an error occurring\n     within the suite would be. See step 6 below.\n\n5. The suite is executed.\n\n6. The context manager\'s ``__exit__()`` method is invoked.  If an\n   exception caused the suite to be exited, its type, value, and\n   traceback are passed as arguments to ``__exit__()``. Otherwise,\n   three ``None`` arguments are supplied.\n\n   If the suite was exited due to an exception, and the return value\n   from the ``__exit__()`` method was false, the exception is\n   reraised.  If the return value was true, the exception is\n   suppressed, and execution continues with the statement following\n   the ``with`` statement.\n\n   If the suite was exited for any reason other than an exception, the\n   return value from ``__exit__()`` is ignored, and execution proceeds\n   at the normal location for the kind of exit that was taken.\n\nWith more than one item, the context managers are processed as if\nmultiple ``with`` statements were nested:\n\n   with A() as a, B() as b:\n       suite\n\nis equivalent to\n\n   with A() as a:\n       with B() as b:\n           suite\n\nChanged in version 3.1: Support for multiple context expressions.\n\nSee also:\n\n   **PEP 0343** - The "with" statement\n      The specification, background, and examples for the Python\n      ``with`` statement.\n\n\nFunction definitions\n====================\n\nA function definition defines a user-defined function object (see\nsection *The standard type hierarchy*):\n\n   funcdef        ::= [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite\n   decorators     ::= decorator+\n   decorator      ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE\n   dotted_name    ::= identifier ("." identifier)*\n   parameter_list ::= (defparameter ",")*\n                      ( "*" [parameter] ("," defparameter)* ["," "**" parameter]\n                      | "**" parameter\n                      | defparameter [","] )\n   parameter      ::= identifier [":" expression]\n   defparameter   ::= parameter ["=" expression]\n   funcname       ::= identifier\n\nA function definition is an executable statement.  Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function).  This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition.  The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object.  Multiple decorators are applied in\nnested fashion. For example, the following code\n\n   @f1(arg)\n   @f2\n   def func(): pass\n\nis equivalent to\n\n   def func(): pass\n   func = f1(arg)(f2(func))\n\nWhen one or more *parameters* have the form *parameter* ``=``\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted.  If a parameter has a default value, all following\nparameters up until the "``*``" must also have a default value ---\nthis is a syntactic restriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated from left to right when the\nfunction definition is executed.** This means that the expression is\nevaluated once, when the function is defined, and that the same "pre-\ncomputed" value is used for each call.  This is especially important\nto understand when a default parameter is a mutable object, such as a\nlist or a dictionary: if the function modifies the object (e.g. by\nappending an item to a list), the default value is in effect modified.\nThis is generally not what was intended.  A way around this is to use\n``None`` as the default, and explicitly test for it in the body of the\nfunction, e.g.:\n\n   def whats_on_the_telly(penguin=None):\n       if penguin is None:\n           penguin = []\n       penguin.append("property of the zoo")\n       return penguin\n\nFunction call semantics are described in more detail in section\n*Calls*. A function call always assigns values to all parameters\nmentioned in the parameter list, either from position arguments, from\nkeyword arguments, or from default values.  If the form\n"``*identifier``" is present, it is initialized to a tuple receiving\nany excess positional parameters, defaulting to the empty tuple.  If\nthe form "``**identifier``" is present, it is initialized to a new\ndictionary receiving any excess keyword arguments, defaulting to a new\nempty dictionary. Parameters after "``*``" or "``*identifier``" are\nkeyword-only parameters and may only be passed used keyword arguments.\n\nParameters may have annotations of the form "``: expression``"\nfollowing the parameter name.  Any parameter may have an annotation\neven those of the form ``*identifier`` or ``**identifier``.  Functions\nmay have "return" annotation of the form "``-> expression``" after the\nparameter list.  These annotations can be any valid Python expression\nand are evaluated when the function definition is executed.\nAnnotations may be evaluated in a different order than they appear in\nthe source code.  The presence of annotations does not change the\nsemantics of a function.  The annotation values are available as\nvalues of a dictionary keyed by the parameters\' names in the\n``__annotations__`` attribute of the function object.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions.  This uses lambda forms,\ndescribed in section *Lambdas*.  Note that the lambda form is merely a\nshorthand for a simplified function definition; a function defined in\na "``def``" statement can be passed around or assigned to another name\njust like a function defined by a lambda form.  The "``def``" form is\nactually more powerful since it allows the execution of multiple\nstatements and annotations.\n\n**Programmer\'s note:** Functions are first-class objects.  A "``def``"\nform executed inside a function definition defines a local function\nthat can be returned or passed around.  Free variables used in the\nnested function can access the local variables of the function\ncontaining the def.  See section *Naming and binding* for details.\n\nSee also:\n\n   **PEP 3107** - Function Annotations\n      The original specification for function annotations.\n\n\nClass definitions\n=================\n\nA class definition defines a class object (see section *The standard\ntype hierarchy*):\n\n   classdef    ::= [decorators] "class" classname [inheritance] ":" suite\n   inheritance ::= "(" [parameter_list] ")"\n   classname   ::= identifier\n\nA class definition is an executable statement.  The inheritance list\nusually gives a list of base classes (see *Customizing class creation*\nfor more advanced uses), so each item in the list should evaluate to a\nclass object which allows subclassing.  Classes without an inheritance\nlist inherit, by default, from the base class ``object``; hence,\n\n   class Foo:\n       pass\n\nis equivalent to\n\n   class Foo(object):\n       pass\n\nThe class\'s suite is then executed in a new execution frame (see\n*Naming and binding*), using a newly created local namespace and the\noriginal global namespace. (Usually, the suite contains mostly\nfunction definitions.)  When the class\'s suite finishes execution, its\nexecution frame is discarded but its local namespace is saved. [4] A\nclass object is then created using the inheritance list for the base\nclasses and the saved local namespace for the attribute dictionary.\nThe class name is bound to this class object in the original local\nnamespace.\n\nClass creation can be customized heavily using *metaclasses*.\n\nClasses can also be decorated: just like when decorating functions,\n\n   @f1(arg)\n   @f2\n   class Foo: pass\n\nis equivalent to\n\n   class Foo: pass\n   Foo = f1(arg)(f2(Foo))\n\nThe evaluation rules for the decorator expressions are the same as for\nfunction decorators.  The result must be a class object, which is then\nbound to the class name.\n\n**Programmer\'s note:** Variables defined in the class definition are\nclass attributes; they are shared by instances.  Instance attributes\ncan be set in a method with ``self.name = value``.  Both class and\ninstance attributes are accessible through the notation\n"``self.name``", and an instance attribute hides a class attribute\nwith the same name when accessed in this way.  Class attributes can be\nused as defaults for instance attributes, but using mutable values\nthere can lead to unexpected results.  *Descriptors* can be used to\ncreate instance variables with different implementation details.\n\nSee also:\n\n   **PEP 3115** - Metaclasses in Python 3 **PEP 3129** - Class\n   Decorators\n\n-[ Footnotes ]-\n\n[1] The exception is propagated to the invocation stack unless there\n    is a ``finally`` clause which happens to raise another exception.\n    That new exception causes the old one to be lost.\n\n[2] Currently, control "flows off the end" except in the case of an\n    exception or the execution of a ``return``, ``continue``, or\n    ``break`` statement.\n\n[3] A string literal appearing as the first statement in the function\n    body is transformed into the function\'s ``__doc__`` attribute and\n    therefore the function\'s *docstring*.\n\n[4] A string literal appearing as the first statement in the class\n    body is transformed into the namespace\'s ``__doc__`` item and\n    therefore the class\'s *docstring*.\n',
+ 'compound': '\nCompound statements\n*******************\n\nCompound statements contain (groups of) other statements; they affect\nor control the execution of those other statements in some way.  In\ngeneral, compound statements span multiple lines, although in simple\nincarnations a whole compound statement may be contained in one line.\n\nThe ``if``, ``while`` and ``for`` statements implement traditional\ncontrol flow constructs.  ``try`` specifies exception handlers and/or\ncleanup code for a group of statements, while the ``with`` statement\nallows the execution of initialization and finalization code around a\nblock of code.  Function and class definitions are also syntactically\ncompound statements.\n\nCompound statements consist of one or more \'clauses.\'  A clause\nconsists of a header and a \'suite.\'  The clause headers of a\nparticular compound statement are all at the same indentation level.\nEach clause header begins with a uniquely identifying keyword and ends\nwith a colon.  A suite is a group of statements controlled by a\nclause.  A suite can be one or more semicolon-separated simple\nstatements on the same line as the header, following the header\'s\ncolon, or it can be one or more indented statements on subsequent\nlines.  Only the latter form of suite can contain nested compound\nstatements; the following is illegal, mostly because it wouldn\'t be\nclear to which ``if`` clause a following ``else`` clause would belong:\n\n   if test1: if test2: print(x)\n\nAlso note that the semicolon binds tighter than the colon in this\ncontext, so that in the following example, either all or none of the\n``print()`` calls are executed:\n\n   if x < y < z: print(x); print(y); print(z)\n\nSummarizing:\n\n   compound_stmt ::= if_stmt\n                     | while_stmt\n                     | for_stmt\n                     | try_stmt\n                     | with_stmt\n                     | funcdef\n                     | classdef\n   suite         ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT\n   statement     ::= stmt_list NEWLINE | compound_stmt\n   stmt_list     ::= simple_stmt (";" simple_stmt)* [";"]\n\nNote that statements always end in a ``NEWLINE`` possibly followed by\na ``DEDENT``.  Also note that optional continuation clauses always\nbegin with a keyword that cannot start a statement, thus there are no\nambiguities (the \'dangling ``else``\' problem is solved in Python by\nrequiring nested ``if`` statements to be indented).\n\nThe formatting of the grammar rules in the following sections places\neach clause on a separate line for clarity.\n\n\nThe ``if`` statement\n====================\n\nThe ``if`` statement is used for conditional execution:\n\n   if_stmt ::= "if" expression ":" suite\n               ( "elif" expression ":" suite )*\n               ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section *Boolean operations*\nfor the definition of true and false); then that suite is executed\n(and no other part of the ``if`` statement is executed or evaluated).\nIf all expressions are false, the suite of the ``else`` clause, if\npresent, is executed.\n\n\nThe ``while`` statement\n=======================\n\nThe ``while`` statement is used for repeated execution as long as an\nexpression is true:\n\n   while_stmt ::= "while" expression ":" suite\n                  ["else" ":" suite]\n\nThis repeatedly tests the expression and, if it is true, executes the\nfirst suite; if the expression is false (which may be the first time\nit is tested) the suite of the ``else`` clause, if present, is\nexecuted and the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ngoes back to testing the expression.\n\n\nThe ``for`` statement\n=====================\n\nThe ``for`` statement is used to iterate over the elements of a\nsequence (such as a string, tuple or list) or other iterable object:\n\n   for_stmt ::= "for" target_list "in" expression_list ":" suite\n                ["else" ":" suite]\n\nThe expression list is evaluated once; it should yield an iterable\nobject.  An iterator is created for the result of the\n``expression_list``.  The suite is then executed once for each item\nprovided by the iterator, in the order of ascending indices.  Each\nitem in turn is assigned to the target list using the standard rules\nfor assignments (see *Assignment statements*), and then the suite is\nexecuted.  When the items are exhausted (which is immediately when the\nsequence is empty or an iterator raises a ``StopIteration``\nexception), the suite in the ``else`` clause, if present, is executed,\nand the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ncontinues with the next item, or with the ``else`` clause if there was\nno next item.\n\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\n\nNames in the target list are not deleted when the loop is finished,\nbut if the sequence is empty, it will not have been assigned to at all\nby the loop.  Hint: the built-in function ``range()`` returns an\niterator of integers suitable to emulate the effect of Pascal\'s ``for\ni := a to b do``; e.g., ``list(range(3))`` returns the list ``[0, 1,\n2]``.\n\nNote: There is a subtlety when the sequence is being modified by the loop\n  (this can only occur for mutable sequences, i.e. lists).  An\n  internal counter is used to keep track of which item is used next,\n  and this is incremented on each iteration.  When this counter has\n  reached the length of the sequence the loop terminates.  This means\n  that if the suite deletes the current (or a previous) item from the\n  sequence, the next item will be skipped (since it gets the index of\n  the current item which has already been treated).  Likewise, if the\n  suite inserts an item in the sequence before the current item, the\n  current item will be treated again the next time through the loop.\n  This can lead to nasty bugs that can be avoided by making a\n  temporary copy using a slice of the whole sequence, e.g.,\n\n     for x in a[:]:\n         if x < 0: a.remove(x)\n\n\nThe ``try`` statement\n=====================\n\nThe ``try`` statement specifies exception handlers and/or cleanup code\nfor a group of statements:\n\n   try_stmt  ::= try1_stmt | try2_stmt\n   try1_stmt ::= "try" ":" suite\n                 ("except" [expression ["as" target]] ":" suite)+\n                 ["else" ":" suite]\n                 ["finally" ":" suite]\n   try2_stmt ::= "try" ":" suite\n                 "finally" ":" suite\n\nThe ``except`` clause(s) specify one or more exception handlers. When\nno exception occurs in the ``try`` clause, no exception handler is\nexecuted. When an exception occurs in the ``try`` suite, a search for\nan exception handler is started.  This search inspects the except\nclauses in turn until one is found that matches the exception.  An\nexpression-less except clause, if present, must be last; it matches\nany exception.  For an except clause with an expression, that\nexpression is evaluated, and the clause matches the exception if the\nresulting object is "compatible" with the exception.  An object is\ncompatible with an exception if it is the class or a base class of the\nexception object or a tuple containing an item compatible with the\nexception.\n\nIf no except clause matches the exception, the search for an exception\nhandler continues in the surrounding code and on the invocation stack.\n[1]\n\nIf the evaluation of an expression in the header of an except clause\nraises an exception, the original search for a handler is canceled and\na search starts for the new exception in the surrounding code and on\nthe call stack (it is treated as if the entire ``try`` statement\nraised the exception).\n\nWhen a matching except clause is found, the exception is assigned to\nthe target specified after the ``as`` keyword in that except clause,\nif present, and the except clause\'s suite is executed.  All except\nclauses must have an executable block.  When the end of this block is\nreached, execution continues normally after the entire try statement.\n(This means that if two nested handlers exist for the same exception,\nand the exception occurs in the try clause of the inner handler, the\nouter handler will not handle the exception.)\n\nWhen an exception has been assigned using ``as target``, it is cleared\nat the end of the except clause.  This is as if\n\n   except E as N:\n       foo\n\nwas translated to\n\n   except E as N:\n       try:\n           foo\n       finally:\n           del N\n\nThis means the exception must be assigned to a different name to be\nable to refer to it after the except clause.  Exceptions are cleared\nbecause with the traceback attached to them, they form a reference\ncycle with the stack frame, keeping all locals in that frame alive\nuntil the next garbage collection occurs.\n\nBefore an except clause\'s suite is executed, details about the\nexception are stored in the ``sys`` module and can be access via\n``sys.exc_info()``. ``sys.exc_info()`` returns a 3-tuple consisting of\nthe exception class, the exception instance and a traceback object\n(see section *The standard type hierarchy*) identifying the point in\nthe program where the exception occurred.  ``sys.exc_info()`` values\nare restored to their previous values (before the call) when returning\nfrom a function that handled an exception.\n\nThe optional ``else`` clause is executed if and when control flows off\nthe end of the ``try`` clause. [2] Exceptions in the ``else`` clause\nare not handled by the preceding ``except`` clauses.\n\nIf ``finally`` is present, it specifies a \'cleanup\' handler.  The\n``try`` clause is executed, including any ``except`` and ``else``\nclauses.  If an exception occurs in any of the clauses and is not\nhandled, the exception is temporarily saved. The ``finally`` clause is\nexecuted.  If there is a saved exception it is re-raised at the end of\nthe ``finally`` clause.  If the ``finally`` clause raises another\nexception, the saved exception is set as the context of the new\nexception. If the ``finally`` clause executes a ``return`` or\n``break`` statement, the saved exception is discarded:\n\n   def f():\n       try:\n           1/0\n       finally:\n           return 42\n\n   >>> f()\n   42\n\nThe exception information is not available to the program during\nexecution of the ``finally`` clause.\n\nWhen a ``return``, ``break`` or ``continue`` statement is executed in\nthe ``try`` suite of a ``try``...``finally`` statement, the\n``finally`` clause is also executed \'on the way out.\' A ``continue``\nstatement is illegal in the ``finally`` clause. (The reason is a\nproblem with the current implementation --- this restriction may be\nlifted in the future).\n\nAdditional information on exceptions can be found in section\n*Exceptions*, and information on using the ``raise`` statement to\ngenerate exceptions may be found in section *The raise statement*.\n\n\nThe ``with`` statement\n======================\n\nThe ``with`` statement is used to wrap the execution of a block with\nmethods defined by a context manager (see section *With Statement\nContext Managers*). This allows common\n``try``...``except``...``finally`` usage patterns to be encapsulated\nfor convenient reuse.\n\n   with_stmt ::= "with" with_item ("," with_item)* ":" suite\n   with_item ::= expression ["as" target]\n\nThe execution of the ``with`` statement with one "item" proceeds as\nfollows:\n\n1. The context expression (the expression given in the ``with_item``)\n   is evaluated to obtain a context manager.\n\n2. The context manager\'s ``__exit__()`` is loaded for later use.\n\n3. The context manager\'s ``__enter__()`` method is invoked.\n\n4. If a target was included in the ``with`` statement, the return\n   value from ``__enter__()`` is assigned to it.\n\n   Note: The ``with`` statement guarantees that if the ``__enter__()``\n     method returns without an error, then ``__exit__()`` will always\n     be called. Thus, if an error occurs during the assignment to the\n     target list, it will be treated the same as an error occurring\n     within the suite would be. See step 6 below.\n\n5. The suite is executed.\n\n6. The context manager\'s ``__exit__()`` method is invoked.  If an\n   exception caused the suite to be exited, its type, value, and\n   traceback are passed as arguments to ``__exit__()``. Otherwise,\n   three ``None`` arguments are supplied.\n\n   If the suite was exited due to an exception, and the return value\n   from the ``__exit__()`` method was false, the exception is\n   reraised.  If the return value was true, the exception is\n   suppressed, and execution continues with the statement following\n   the ``with`` statement.\n\n   If the suite was exited for any reason other than an exception, the\n   return value from ``__exit__()`` is ignored, and execution proceeds\n   at the normal location for the kind of exit that was taken.\n\nWith more than one item, the context managers are processed as if\nmultiple ``with`` statements were nested:\n\n   with A() as a, B() as b:\n       suite\n\nis equivalent to\n\n   with A() as a:\n       with B() as b:\n           suite\n\nChanged in version 3.1: Support for multiple context expressions.\n\nSee also:\n\n   **PEP 0343** - The "with" statement\n      The specification, background, and examples for the Python\n      ``with`` statement.\n\n\nFunction definitions\n====================\n\nA function definition defines a user-defined function object (see\nsection *The standard type hierarchy*):\n\n   funcdef        ::= [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite\n   decorators     ::= decorator+\n   decorator      ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE\n   dotted_name    ::= identifier ("." identifier)*\n   parameter_list ::= (defparameter ",")*\n                      ( "*" [parameter] ("," defparameter)* ["," "**" parameter]\n                      | "**" parameter\n                      | defparameter [","] )\n   parameter      ::= identifier [":" expression]\n   defparameter   ::= parameter ["=" expression]\n   funcname       ::= identifier\n\nA function definition is an executable statement.  Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function).  This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition.  The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object.  Multiple decorators are applied in\nnested fashion. For example, the following code\n\n   @f1(arg)\n   @f2\n   def func(): pass\n\nis equivalent to\n\n   def func(): pass\n   func = f1(arg)(f2(func))\n\nWhen one or more *parameters* have the form *parameter* ``=``\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted.  If a parameter has a default value, all following\nparameters up until the "``*``" must also have a default value ---\nthis is a syntactic restriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated when the function definition\nis executed.** This means that the expression is evaluated once, when\nthe function is defined, and that the same "pre-computed" value is\nused for each call.  This is especially important to understand when a\ndefault parameter is a mutable object, such as a list or a dictionary:\nif the function modifies the object (e.g. by appending an item to a\nlist), the default value is in effect modified. This is generally not\nwhat was intended.  A way around this is to use ``None`` as the\ndefault, and explicitly test for it in the body of the function, e.g.:\n\n   def whats_on_the_telly(penguin=None):\n       if penguin is None:\n           penguin = []\n       penguin.append("property of the zoo")\n       return penguin\n\nFunction call semantics are described in more detail in section\n*Calls*. A function call always assigns values to all parameters\nmentioned in the parameter list, either from position arguments, from\nkeyword arguments, or from default values.  If the form\n"``*identifier``" is present, it is initialized to a tuple receiving\nany excess positional parameters, defaulting to the empty tuple.  If\nthe form "``**identifier``" is present, it is initialized to a new\ndictionary receiving any excess keyword arguments, defaulting to a new\nempty dictionary. Parameters after "``*``" or "``*identifier``" are\nkeyword-only parameters and may only be passed used keyword arguments.\n\nParameters may have annotations of the form "``: expression``"\nfollowing the parameter name.  Any parameter may have an annotation\neven those of the form ``*identifier`` or ``**identifier``.  Functions\nmay have "return" annotation of the form "``-> expression``" after the\nparameter list.  These annotations can be any valid Python expression\nand are evaluated when the function definition is executed.\nAnnotations may be evaluated in a different order than they appear in\nthe source code.  The presence of annotations does not change the\nsemantics of a function.  The annotation values are available as\nvalues of a dictionary keyed by the parameters\' names in the\n``__annotations__`` attribute of the function object.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions.  This uses lambda forms,\ndescribed in section *Lambdas*.  Note that the lambda form is merely a\nshorthand for a simplified function definition; a function defined in\na "``def``" statement can be passed around or assigned to another name\njust like a function defined by a lambda form.  The "``def``" form is\nactually more powerful since it allows the execution of multiple\nstatements and annotations.\n\n**Programmer\'s note:** Functions are first-class objects.  A "``def``"\nform executed inside a function definition defines a local function\nthat can be returned or passed around.  Free variables used in the\nnested function can access the local variables of the function\ncontaining the def.  See section *Naming and binding* for details.\n\nSee also:\n\n   **PEP 3107** - Function Annotations\n      The original specification for function annotations.\n\n\nClass definitions\n=================\n\nA class definition defines a class object (see section *The standard\ntype hierarchy*):\n\n   classdef    ::= [decorators] "class" classname [inheritance] ":" suite\n   inheritance ::= "(" [parameter_list] ")"\n   classname   ::= identifier\n\nA class definition is an executable statement.  The inheritance list\nusually gives a list of base classes (see *Customizing class creation*\nfor more advanced uses), so each item in the list should evaluate to a\nclass object which allows subclassing.  Classes without an inheritance\nlist inherit, by default, from the base class ``object``; hence,\n\n   class Foo:\n       pass\n\nis equivalent to\n\n   class Foo(object):\n       pass\n\nThe class\'s suite is then executed in a new execution frame (see\n*Naming and binding*), using a newly created local namespace and the\noriginal global namespace. (Usually, the suite contains mostly\nfunction definitions.)  When the class\'s suite finishes execution, its\nexecution frame is discarded but its local namespace is saved. [4] A\nclass object is then created using the inheritance list for the base\nclasses and the saved local namespace for the attribute dictionary.\nThe class name is bound to this class object in the original local\nnamespace.\n\nClass creation can be customized heavily using *metaclasses*.\n\nClasses can also be decorated: just like when decorating functions,\n\n   @f1(arg)\n   @f2\n   class Foo: pass\n\nis equivalent to\n\n   class Foo: pass\n   Foo = f1(arg)(f2(Foo))\n\nThe evaluation rules for the decorator expressions are the same as for\nfunction decorators.  The result must be a class object, which is then\nbound to the class name.\n\n**Programmer\'s note:** Variables defined in the class definition are\nclass attributes; they are shared by instances.  Instance attributes\ncan be set in a method with ``self.name = value``.  Both class and\ninstance attributes are accessible through the notation\n"``self.name``", and an instance attribute hides a class attribute\nwith the same name when accessed in this way.  Class attributes can be\nused as defaults for instance attributes, but using mutable values\nthere can lead to unexpected results.  *Descriptors* can be used to\ncreate instance variables with different implementation details.\n\nSee also:\n\n   **PEP 3115** - Metaclasses in Python 3 **PEP 3129** - Class\n   Decorators\n\n-[ Footnotes ]-\n\n[1] The exception is propagated to the invocation stack unless there\n    is a ``finally`` clause which happens to raise another exception.\n    That new exception causes the old one to be lost.\n\n[2] Currently, control "flows off the end" except in the case of an\n    exception or the execution of a ``return``, ``continue``, or\n    ``break`` statement.\n\n[3] A string literal appearing as the first statement in the function\n    body is transformed into the function\'s ``__doc__`` attribute and\n    therefore the function\'s *docstring*.\n\n[4] A string literal appearing as the first statement in the class\n    body is transformed into the namespace\'s ``__doc__`` item and\n    therefore the class\'s *docstring*.\n',
  'context-managers': '\nWith Statement Context Managers\n*******************************\n\nA *context manager* is an object that defines the runtime context to\nbe established when executing a ``with`` statement. The context\nmanager handles the entry into, and the exit from, the desired runtime\ncontext for the execution of the block of code.  Context managers are\nnormally invoked using the ``with`` statement (described in section\n*The with statement*), but can also be used by directly invoking their\nmethods.\n\nTypical uses of context managers include saving and restoring various\nkinds of global state, locking and unlocking resources, closing opened\nfiles, etc.\n\nFor more information on context managers, see *Context Manager Types*.\n\nobject.__enter__(self)\n\n   Enter the runtime context related to this object. The ``with``\n   statement will bind this method\'s return value to the target(s)\n   specified in the ``as`` clause of the statement, if any.\n\nobject.__exit__(self, exc_type, exc_value, traceback)\n\n   Exit the runtime context related to this object. The parameters\n   describe the exception that caused the context to be exited. If the\n   context was exited without an exception, all three arguments will\n   be ``None``.\n\n   If an exception is supplied, and the method wishes to suppress the\n   exception (i.e., prevent it from being propagated), it should\n   return a true value. Otherwise, the exception will be processed\n   normally upon exit from this method.\n\n   Note that ``__exit__()`` methods should not reraise the passed-in\n   exception; this is the caller\'s responsibility.\n\nSee also:\n\n   **PEP 0343** - The "with" statement\n      The specification, background, and examples for the Python\n      ``with`` statement.\n',
  'continue': '\nThe ``continue`` statement\n**************************\n\n   continue_stmt ::= "continue"\n\n``continue`` may only occur syntactically nested in a ``for`` or\n``while`` loop, but not nested in a function or class definition or\n``finally`` clause within that loop.  It continues with the next cycle\nof the nearest enclosing loop.\n\nWhen ``continue`` passes control out of a ``try`` statement with a\n``finally`` clause, that ``finally`` clause is executed before really\nstarting the next loop cycle.\n',
  'conversions': '\nArithmetic conversions\n**********************\n\nWhen a description of an arithmetic operator below uses the phrase\n"the numeric arguments are converted to a common type," this means\nthat the operator implementation for built-in types works that way:\n\n* If either argument is a complex number, the other is converted to\n  complex;\n\n* otherwise, if either argument is a floating point number, the other\n  is converted to floating point;\n\n* otherwise, both must be integers and no conversion is necessary.\n\nSome additional rules apply for certain operators (e.g., a string left\nargument to the \'%\' operator).  Extensions must define their own\nconversion behavior.\n',
- 'customization': '\nBasic customization\n*******************\n\nobject.__new__(cls[, ...])\n\n   Called to create a new instance of class *cls*.  ``__new__()`` is a\n   static method (special-cased so you need not declare it as such)\n   that takes the class of which an instance was requested as its\n   first argument.  The remaining arguments are those passed to the\n   object constructor expression (the call to the class).  The return\n   value of ``__new__()`` should be the new object instance (usually\n   an instance of *cls*).\n\n   Typical implementations create a new instance of the class by\n   invoking the superclass\'s ``__new__()`` method using\n   ``super(currentclass, cls).__new__(cls[, ...])`` with appropriate\n   arguments and then modifying the newly-created instance as\n   necessary before returning it.\n\n   If ``__new__()`` returns an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will be invoked like\n   ``__init__(self[, ...])``, where *self* is the new instance and the\n   remaining arguments are the same as were passed to ``__new__()``.\n\n   If ``__new__()`` does not return an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will not be invoked.\n\n   ``__new__()`` is intended mainly to allow subclasses of immutable\n   types (like int, str, or tuple) to customize instance creation.  It\n   is also commonly overridden in custom metaclasses in order to\n   customize class creation.\n\nobject.__init__(self[, ...])\n\n   Called when the instance is created.  The arguments are those\n   passed to the class constructor expression.  If a base class has an\n   ``__init__()`` method, the derived class\'s ``__init__()`` method,\n   if any, must explicitly call it to ensure proper initialization of\n   the base class part of the instance; for example:\n   ``BaseClass.__init__(self, [args...])``.  As a special constraint\n   on constructors, no value may be returned; doing so will cause a\n   ``TypeError`` to be raised at runtime.\n\nobject.__del__(self)\n\n   Called when the instance is about to be destroyed.  This is also\n   called a destructor.  If a base class has a ``__del__()`` method,\n   the derived class\'s ``__del__()`` method, if any, must explicitly\n   call it to ensure proper deletion of the base class part of the\n   instance.  Note that it is possible (though not recommended!) for\n   the ``__del__()`` method to postpone destruction of the instance by\n   creating a new reference to it.  It may then be called at a later\n   time when this new reference is deleted.  It is not guaranteed that\n   ``__del__()`` methods are called for objects that still exist when\n   the interpreter exits.\n\n   Note: ``del x`` doesn\'t directly call ``x.__del__()`` --- the former\n     decrements the reference count for ``x`` by one, and the latter\n     is only called when ``x``\'s reference count reaches zero.  Some\n     common situations that may prevent the reference count of an\n     object from going to zero include: circular references between\n     objects (e.g., a doubly-linked list or a tree data structure with\n     parent and child pointers); a reference to the object on the\n     stack frame of a function that caught an exception (the traceback\n     stored in ``sys.exc_info()[2]`` keeps the stack frame alive); or\n     a reference to the object on the stack frame that raised an\n     unhandled exception in interactive mode (the traceback stored in\n     ``sys.last_traceback`` keeps the stack frame alive).  The first\n     situation can only be remedied by explicitly breaking the cycles;\n     the latter two situations can be resolved by storing ``None`` in\n     ``sys.last_traceback``. Circular references which are garbage are\n     detected and cleaned up when the cyclic garbage collector is\n     enabled (it\'s on by default). Refer to the documentation for the\n     ``gc`` module for more information about this topic.\n\n   Warning: Due to the precarious circumstances under which ``__del__()``\n     methods are invoked, exceptions that occur during their execution\n     are ignored, and a warning is printed to ``sys.stderr`` instead.\n     Also, when ``__del__()`` is invoked in response to a module being\n     deleted (e.g., when execution of the program is done), other\n     globals referenced by the ``__del__()`` method may already have\n     been deleted or in the process of being torn down (e.g. the\n     import machinery shutting down).  For this reason, ``__del__()``\n     methods should do the absolute minimum needed to maintain\n     external invariants.  Starting with version 1.5, Python\n     guarantees that globals whose name begins with a single\n     underscore are deleted from their module before other globals are\n     deleted; if no other references to such globals exist, this may\n     help in assuring that imported modules are still available at the\n     time when the ``__del__()`` method is called.\n\nobject.__repr__(self)\n\n   Called by the ``repr()`` built-in function to compute the\n   "official" string representation of an object.  If at all possible,\n   this should look like a valid Python expression that could be used\n   to recreate an object with the same value (given an appropriate\n   environment).  If this is not possible, a string of the form\n   ``<...some useful description...>`` should be returned. The return\n   value must be a string object. If a class defines ``__repr__()``\n   but not ``__str__()``, then ``__repr__()`` is also used when an\n   "informal" string representation of instances of that class is\n   required.\n\n   This is typically used for debugging, so it is important that the\n   representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n   Called by ``str(object)`` and the built-in functions ``format()``\n   and ``print()`` to compute the "informal" or nicely printable\n   string representation of an object.  The return value must be a\n   *string* object.\n\n   This method differs from ``object.__repr__()`` in that there is no\n   expectation that ``__str__()`` return a valid Python expression: a\n   more convenient or concise representation can be used.\n\n   The default implementation defined by the built-in type ``object``\n   calls ``object.__repr__()``.\n\nobject.__bytes__(self)\n\n   Called by ``bytes()`` to compute a byte-string representation of an\n   object. This should return a ``bytes`` object.\n\nobject.__format__(self, format_spec)\n\n   Called by the ``format()`` built-in function (and by extension, the\n   ``str.format()`` method of class ``str``) to produce a "formatted"\n   string representation of an object. The ``format_spec`` argument is\n   a string that contains a description of the formatting options\n   desired. The interpretation of the ``format_spec`` argument is up\n   to the type implementing ``__format__()``, however most classes\n   will either delegate formatting to one of the built-in types, or\n   use a similar formatting option syntax.\n\n   See *Format Specification Mini-Language* for a description of the\n   standard formatting syntax.\n\n   The return value must be a string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n   These are the so-called "rich comparison" methods. The\n   correspondence between operator symbols and method names is as\n   follows: ``x<y`` calls ``x.__lt__(y)``, ``x<=y`` calls\n   ``x.__le__(y)``, ``x==y`` calls ``x.__eq__(y)``, ``x!=y`` calls\n   ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` calls\n   ``x.__ge__(y)``.\n\n   A rich comparison method may return the singleton\n   ``NotImplemented`` if it does not implement the operation for a\n   given pair of arguments. By convention, ``False`` and ``True`` are\n   returned for a successful comparison. However, these methods can\n   return any value, so if the comparison operator is used in a\n   Boolean context (e.g., in the condition of an ``if`` statement),\n   Python will call ``bool()`` on the value to determine if the result\n   is true or false.\n\n   There are no implied relationships among the comparison operators.\n   The truth of ``x==y`` does not imply that ``x!=y`` is false.\n   Accordingly, when defining ``__eq__()``, one should also define\n   ``__ne__()`` so that the operators will behave as expected.  See\n   the paragraph on ``__hash__()`` for some important notes on\n   creating *hashable* objects which support custom comparison\n   operations and are usable as dictionary keys.\n\n   There are no swapped-argument versions of these methods (to be used\n   when the left argument does not support the operation but the right\n   argument does); rather, ``__lt__()`` and ``__gt__()`` are each\n   other\'s reflection, ``__le__()`` and ``__ge__()`` are each other\'s\n   reflection, and ``__eq__()`` and ``__ne__()`` are their own\n   reflection.\n\n   Arguments to rich comparison methods are never coerced.\n\n   To automatically generate ordering operations from a single root\n   operation, see ``functools.total_ordering()``.\n\nobject.__hash__(self)\n\n   Called by built-in function ``hash()`` and for operations on\n   members of hashed collections including ``set``, ``frozenset``, and\n   ``dict``.  ``__hash__()`` should return an integer.  The only\n   required property is that objects which compare equal have the same\n   hash value; it is advised to somehow mix together (e.g. using\n   exclusive or) the hash values for the components of the object that\n   also play a part in comparison of objects.\n\n   Note: ``hash()`` truncates the value returned from an object\'s custom\n     ``__hash__()`` method to the size of a ``Py_ssize_t``.  This is\n     typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds.\n     If an object\'s   ``__hash__()`` must interoperate on builds of\n     different bit sizes, be sure to check the width on all supported\n     builds.  An easy way to do this is with ``python -c "import sys;\n     print(sys.hash_info.width)"``\n\n   If a class does not define an ``__eq__()`` method it should not\n   define a ``__hash__()`` operation either; if it defines\n   ``__eq__()`` but not ``__hash__()``, its instances will not be\n   usable as items in hashable collections.  If a class defines\n   mutable objects and implements an ``__eq__()`` method, it should\n   not implement ``__hash__()``, since the implementation of hashable\n   collections requires that a key\'s hash value is immutable (if the\n   object\'s hash value changes, it will be in the wrong hash bucket).\n\n   User-defined classes have ``__eq__()`` and ``__hash__()`` methods\n   by default; with them, all objects compare unequal (except with\n   themselves) and ``x.__hash__()`` returns an appropriate value such\n   that ``x == y`` implies both that ``x is y`` and ``hash(x) ==\n   hash(y)``.\n\n   A class that overrides ``__eq__()`` and does not define\n   ``__hash__()`` will have its ``__hash__()`` implicitly set to\n   ``None``.  When the ``__hash__()`` method of a class is ``None``,\n   instances of the class will raise an appropriate ``TypeError`` when\n   a program attempts to retrieve their hash value, and will also be\n   correctly identified as unhashable when checking ``isinstance(obj,\n   collections.Hashable``).\n\n   If a class that overrides ``__eq__()`` needs to retain the\n   implementation of ``__hash__()`` from a parent class, the\n   interpreter must be told this explicitly by setting ``__hash__ =\n   <ParentClass>.__hash__``.\n\n   If a class that does not override ``__eq__()`` wishes to suppress\n   hash support, it should include ``__hash__ = None`` in the class\n   definition. A class which defines its own ``__hash__()`` that\n   explicitly raises a ``TypeError`` would be incorrectly identified\n   as hashable by an ``isinstance(obj, collections.Hashable)`` call.\n\n   Note: By default, the ``__hash__()`` values of str, bytes and datetime\n     objects are "salted" with an unpredictable random value.\n     Although they remain constant within an individual Python\n     process, they are not predictable between repeated invocations of\n     Python.This is intended to provide protection against a denial-\n     of-service caused by carefully-chosen inputs that exploit the\n     worst case performance of a dict insertion, O(n^2) complexity.\n     See http://www.ocert.org/advisories/ocert-2011-003.html for\n     details.Changing hash values affects the iteration order of\n     dicts, sets and other mappings.  Python has never made guarantees\n     about this ordering (and it typically varies between 32-bit and\n     64-bit builds).See also ``PYTHONHASHSEED``.\n\n   Changed in version 3.3: Hash randomization is enabled by default.\n\nobject.__bool__(self)\n\n   Called to implement truth value testing and the built-in operation\n   ``bool()``; should return ``False`` or ``True``.  When this method\n   is not defined, ``__len__()`` is called, if it is defined, and the\n   object is considered true if its result is nonzero.  If a class\n   defines neither ``__len__()`` nor ``__bool__()``, all its instances\n   are considered true.\n',
+ 'customization': '\nBasic customization\n*******************\n\nobject.__new__(cls[, ...])\n\n   Called to create a new instance of class *cls*.  ``__new__()`` is a\n   static method (special-cased so you need not declare it as such)\n   that takes the class of which an instance was requested as its\n   first argument.  The remaining arguments are those passed to the\n   object constructor expression (the call to the class).  The return\n   value of ``__new__()`` should be the new object instance (usually\n   an instance of *cls*).\n\n   Typical implementations create a new instance of the class by\n   invoking the superclass\'s ``__new__()`` method using\n   ``super(currentclass, cls).__new__(cls[, ...])`` with appropriate\n   arguments and then modifying the newly-created instance as\n   necessary before returning it.\n\n   If ``__new__()`` returns an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will be invoked like\n   ``__init__(self[, ...])``, where *self* is the new instance and the\n   remaining arguments are the same as were passed to ``__new__()``.\n\n   If ``__new__()`` does not return an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will not be invoked.\n\n   ``__new__()`` is intended mainly to allow subclasses of immutable\n   types (like int, str, or tuple) to customize instance creation.  It\n   is also commonly overridden in custom metaclasses in order to\n   customize class creation.\n\nobject.__init__(self[, ...])\n\n   Called when the instance is created.  The arguments are those\n   passed to the class constructor expression.  If a base class has an\n   ``__init__()`` method, the derived class\'s ``__init__()`` method,\n   if any, must explicitly call it to ensure proper initialization of\n   the base class part of the instance; for example:\n   ``BaseClass.__init__(self, [args...])``.  As a special constraint\n   on constructors, no value may be returned; doing so will cause a\n   ``TypeError`` to be raised at runtime.\n\nobject.__del__(self)\n\n   Called when the instance is about to be destroyed.  This is also\n   called a destructor.  If a base class has a ``__del__()`` method,\n   the derived class\'s ``__del__()`` method, if any, must explicitly\n   call it to ensure proper deletion of the base class part of the\n   instance.  Note that it is possible (though not recommended!) for\n   the ``__del__()`` method to postpone destruction of the instance by\n   creating a new reference to it.  It may then be called at a later\n   time when this new reference is deleted.  It is not guaranteed that\n   ``__del__()`` methods are called for objects that still exist when\n   the interpreter exits.\n\n   Note: ``del x`` doesn\'t directly call ``x.__del__()`` --- the former\n     decrements the reference count for ``x`` by one, and the latter\n     is only called when ``x``\'s reference count reaches zero.  Some\n     common situations that may prevent the reference count of an\n     object from going to zero include: circular references between\n     objects (e.g., a doubly-linked list or a tree data structure with\n     parent and child pointers); a reference to the object on the\n     stack frame of a function that caught an exception (the traceback\n     stored in ``sys.exc_info()[2]`` keeps the stack frame alive); or\n     a reference to the object on the stack frame that raised an\n     unhandled exception in interactive mode (the traceback stored in\n     ``sys.last_traceback`` keeps the stack frame alive).  The first\n     situation can only be remedied by explicitly breaking the cycles;\n     the latter two situations can be resolved by storing ``None`` in\n     ``sys.last_traceback``. Circular references which are garbage are\n     detected when the option cycle detector is enabled (it\'s on by\n     default), but can only be cleaned up if there are no Python-\n     level ``__del__()`` methods involved. Refer to the documentation\n     for the ``gc`` module for more information about how\n     ``__del__()`` methods are handled by the cycle detector,\n     particularly the description of the ``garbage`` value.\n\n   Warning: Due to the precarious circumstances under which ``__del__()``\n     methods are invoked, exceptions that occur during their execution\n     are ignored, and a warning is printed to ``sys.stderr`` instead.\n     Also, when ``__del__()`` is invoked in response to a module being\n     deleted (e.g., when execution of the program is done), other\n     globals referenced by the ``__del__()`` method may already have\n     been deleted or in the process of being torn down (e.g. the\n     import machinery shutting down).  For this reason, ``__del__()``\n     methods should do the absolute minimum needed to maintain\n     external invariants.  Starting with version 1.5, Python\n     guarantees that globals whose name begins with a single\n     underscore are deleted from their module before other globals are\n     deleted; if no other references to such globals exist, this may\n     help in assuring that imported modules are still available at the\n     time when the ``__del__()`` method is called.\n\nobject.__repr__(self)\n\n   Called by the ``repr()`` built-in function to compute the\n   "official" string representation of an object.  If at all possible,\n   this should look like a valid Python expression that could be used\n   to recreate an object with the same value (given an appropriate\n   environment).  If this is not possible, a string of the form\n   ``<...some useful description...>`` should be returned. The return\n   value must be a string object. If a class defines ``__repr__()``\n   but not ``__str__()``, then ``__repr__()`` is also used when an\n   "informal" string representation of instances of that class is\n   required.\n\n   This is typically used for debugging, so it is important that the\n   representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n   Called by ``str(object)`` and the built-in functions ``format()``\n   and ``print()`` to compute the "informal" or nicely printable\n   string representation of an object.  The return value must be a\n   *string* object.\n\n   This method differs from ``object.__repr__()`` in that there is no\n   expectation that ``__str__()`` return a valid Python expression: a\n   more convenient or concise representation can be used.\n\n   The default implementation defined by the built-in type ``object``\n   calls ``object.__repr__()``.\n\nobject.__bytes__(self)\n\n   Called by ``bytes()`` to compute a byte-string representation of an\n   object. This should return a ``bytes`` object.\n\nobject.__format__(self, format_spec)\n\n   Called by the ``format()`` built-in function (and by extension, the\n   ``str.format()`` method of class ``str``) to produce a "formatted"\n   string representation of an object. The ``format_spec`` argument is\n   a string that contains a description of the formatting options\n   desired. The interpretation of the ``format_spec`` argument is up\n   to the type implementing ``__format__()``, however most classes\n   will either delegate formatting to one of the built-in types, or\n   use a similar formatting option syntax.\n\n   See *Format Specification Mini-Language* for a description of the\n   standard formatting syntax.\n\n   The return value must be a string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n   These are the so-called "rich comparison" methods. The\n   correspondence between operator symbols and method names is as\n   follows: ``x<y`` calls ``x.__lt__(y)``, ``x<=y`` calls\n   ``x.__le__(y)``, ``x==y`` calls ``x.__eq__(y)``, ``x!=y`` calls\n   ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` calls\n   ``x.__ge__(y)``.\n\n   A rich comparison method may return the singleton\n   ``NotImplemented`` if it does not implement the operation for a\n   given pair of arguments. By convention, ``False`` and ``True`` are\n   returned for a successful comparison. However, these methods can\n   return any value, so if the comparison operator is used in a\n   Boolean context (e.g., in the condition of an ``if`` statement),\n   Python will call ``bool()`` on the value to determine if the result\n   is true or false.\n\n   There are no implied relationships among the comparison operators.\n   The truth of ``x==y`` does not imply that ``x!=y`` is false.\n   Accordingly, when defining ``__eq__()``, one should also define\n   ``__ne__()`` so that the operators will behave as expected.  See\n   the paragraph on ``__hash__()`` for some important notes on\n   creating *hashable* objects which support custom comparison\n   operations and are usable as dictionary keys.\n\n   There are no swapped-argument versions of these methods (to be used\n   when the left argument does not support the operation but the right\n   argument does); rather, ``__lt__()`` and ``__gt__()`` are each\n   other\'s reflection, ``__le__()`` and ``__ge__()`` are each other\'s\n   reflection, and ``__eq__()`` and ``__ne__()`` are their own\n   reflection.\n\n   Arguments to rich comparison methods are never coerced.\n\n   To automatically generate ordering operations from a single root\n   operation, see ``functools.total_ordering()``.\n\nobject.__hash__(self)\n\n   Called by built-in function ``hash()`` and for operations on\n   members of hashed collections including ``set``, ``frozenset``, and\n   ``dict``.  ``__hash__()`` should return an integer.  The only\n   required property is that objects which compare equal have the same\n   hash value; it is advised to somehow mix together (e.g. using\n   exclusive or) the hash values for the components of the object that\n   also play a part in comparison of objects.\n\n   If a class does not define an ``__eq__()`` method it should not\n   define a ``__hash__()`` operation either; if it defines\n   ``__eq__()`` but not ``__hash__()``, its instances will not be\n   usable as items in hashable collections.  If a class defines\n   mutable objects and implements an ``__eq__()`` method, it should\n   not implement ``__hash__()``, since the implementation of hashable\n   collections requires that a key\'s hash value is immutable (if the\n   object\'s hash value changes, it will be in the wrong hash bucket).\n\n   User-defined classes have ``__eq__()`` and ``__hash__()`` methods\n   by default; with them, all objects compare unequal (except with\n   themselves) and ``x.__hash__()`` returns an appropriate value such\n   that ``x == y`` implies both that ``x is y`` and ``hash(x) ==\n   hash(y)``.\n\n   A class that overrides ``__eq__()`` and does not define\n   ``__hash__()`` will have its ``__hash__()`` implicitly set to\n   ``None``.  When the ``__hash__()`` method of a class is ``None``,\n   instances of the class will raise an appropriate ``TypeError`` when\n   a program attempts to retrieve their hash value, and will also be\n   correctly identified as unhashable when checking ``isinstance(obj,\n   collections.Hashable``).\n\n   If a class that overrides ``__eq__()`` needs to retain the\n   implementation of ``__hash__()`` from a parent class, the\n   interpreter must be told this explicitly by setting ``__hash__ =\n   <ParentClass>.__hash__``.\n\n   If a class that does not override ``__eq__()`` wishes to suppress\n   hash support, it should include ``__hash__ = None`` in the class\n   definition. A class which defines its own ``__hash__()`` that\n   explicitly raises a ``TypeError`` would be incorrectly identified\n   as hashable by an ``isinstance(obj, collections.Hashable)`` call.\n\n   Note: By default, the ``__hash__()`` values of str, bytes and datetime\n     objects are "salted" with an unpredictable random value.\n     Although they remain constant within an individual Python\n     process, they are not predictable between repeated invocations of\n     Python.This is intended to provide protection against a denial-\n     of-service caused by carefully-chosen inputs that exploit the\n     worst case performance of a dict insertion, O(n^2) complexity.\n     See http://www.ocert.org/advisories/ocert-2011-003.html for\n     details.Changing hash values affects the iteration order of\n     dicts, sets and other mappings.  Python has never made guarantees\n     about this ordering (and it typically varies between 32-bit and\n     64-bit builds).See also ``PYTHONHASHSEED``.\n\n   Changed in version 3.3: Hash randomization is enabled by default.\n\nobject.__bool__(self)\n\n   Called to implement truth value testing and the built-in operation\n   ``bool()``; should return ``False`` or ``True``.  When this method\n   is not defined, ``__len__()`` is called, if it is defined, and the\n   object is considered true if its result is nonzero.  If a class\n   defines neither ``__len__()`` nor ``__bool__()``, all its instances\n   are considered true.\n',
  'debugger': '\n``pdb`` --- The Python Debugger\n*******************************\n\nThe module ``pdb`` defines an interactive source code debugger for\nPython programs.  It supports setting (conditional) breakpoints and\nsingle stepping at the source line level, inspection of stack frames,\nsource code listing, and evaluation of arbitrary Python code in the\ncontext of any stack frame.  It also supports post-mortem debugging\nand can be called under program control.\n\nThe debugger is extensible -- it is actually defined as the class\n``Pdb``. This is currently undocumented but easily understood by\nreading the source.  The extension interface uses the modules ``bdb``\nand ``cmd``.\n\nThe debugger\'s prompt is ``(Pdb)``. Typical usage to run a program\nunder control of the debugger is:\n\n   >>> import pdb\n   >>> import mymodule\n   >>> pdb.run(\'mymodule.test()\')\n   > <string>(0)?()\n   (Pdb) continue\n   > <string>(1)?()\n   (Pdb) continue\n   NameError: \'spam\'\n   > <string>(1)?()\n   (Pdb)\n\nChanged in version 3.3: Tab-completion via the ``readline`` module is\navailable for commands and command arguments, e.g. the current global\nand local names are offered as arguments of the ``print`` command.\n\n``pdb.py`` can also be invoked as a script to debug other scripts.\nFor example:\n\n   python3 -m pdb myscript.py\n\nWhen invoked as a script, pdb will automatically enter post-mortem\ndebugging if the program being debugged exits abnormally.  After post-\nmortem debugging (or after normal exit of the program), pdb will\nrestart the program.  Automatic restarting preserves pdb\'s state (such\nas breakpoints) and in most cases is more useful than quitting the\ndebugger upon program\'s exit.\n\nNew in version 3.2: ``pdb.py`` now accepts a ``-c`` option that\nexecutes commands as if given in a ``.pdbrc`` file, see *Debugger\nCommands*.\n\nThe typical usage to break into the debugger from a running program is\nto insert\n\n   import pdb; pdb.set_trace()\n\nat the location you want to break into the debugger.  You can then\nstep through the code following this statement, and continue running\nwithout the debugger using the ``continue`` command.\n\nThe typical usage to inspect a crashed program is:\n\n   >>> import pdb\n   >>> import mymodule\n   >>> mymodule.test()\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in ?\n     File "./mymodule.py", line 4, in test\n       test2()\n     File "./mymodule.py", line 3, in test2\n       print(spam)\n   NameError: spam\n   >>> pdb.pm()\n   > ./mymodule.py(3)test2()\n   -> print(spam)\n   (Pdb)\n\nThe module defines the following functions; each enters the debugger\nin a slightly different way:\n\npdb.run(statement, globals=None, locals=None)\n\n   Execute the *statement* (given as a string or a code object) under\n   debugger control.  The debugger prompt appears before any code is\n   executed; you can set breakpoints and type ``continue``, or you can\n   step through the statement using ``step`` or ``next`` (all these\n   commands are explained below).  The optional *globals* and *locals*\n   arguments specify the environment in which the code is executed; by\n   default the dictionary of the module ``__main__`` is used.  (See\n   the explanation of the built-in ``exec()`` or ``eval()``\n   functions.)\n\npdb.runeval(expression, globals=None, locals=None)\n\n   Evaluate the *expression* (given as a string or a code object)\n   under debugger control.  When ``runeval()`` returns, it returns the\n   value of the expression.  Otherwise this function is similar to\n   ``run()``.\n\npdb.runcall(function, *args, **kwds)\n\n   Call the *function* (a function or method object, not a string)\n   with the given arguments.  When ``runcall()`` returns, it returns\n   whatever the function call returned.  The debugger prompt appears\n   as soon as the function is entered.\n\npdb.set_trace()\n\n   Enter the debugger at the calling stack frame.  This is useful to\n   hard-code a breakpoint at a given point in a program, even if the\n   code is not otherwise being debugged (e.g. when an assertion\n   fails).\n\npdb.post_mortem(traceback=None)\n\n   Enter post-mortem debugging of the given *traceback* object.  If no\n   *traceback* is given, it uses the one of the exception that is\n   currently being handled (an exception must be being handled if the\n   default is to be used).\n\npdb.pm()\n\n   Enter post-mortem debugging of the traceback found in\n   ``sys.last_traceback``.\n\nThe ``run*`` functions and ``set_trace()`` are aliases for\ninstantiating the ``Pdb`` class and calling the method of the same\nname.  If you want to access further features, you have to do this\nyourself:\n\nclass class pdb.Pdb(completekey=\'tab\', stdin=None, stdout=None, skip=None, nosigint=False)\n\n   ``Pdb`` is the debugger class.\n\n   The *completekey*, *stdin* and *stdout* arguments are passed to the\n   underlying ``cmd.Cmd`` class; see the description there.\n\n   The *skip* argument, if given, must be an iterable of glob-style\n   module name patterns.  The debugger will not step into frames that\n   originate in a module that matches one of these patterns. [1]\n\n   By default, Pdb sets a handler for the SIGINT signal (which is sent\n   when the user presses Ctrl-C on the console) when you give a\n   ``continue`` command. This allows you to break into the debugger\n   again by pressing Ctrl-C.  If you want Pdb not to touch the SIGINT\n   handler, set *nosigint* tot true.\n\n   Example call to enable tracing with *skip*:\n\n      import pdb; pdb.Pdb(skip=[\'django.*\']).set_trace()\n\n   New in version 3.1: The *skip* argument.\n\n   New in version 3.2: The *nosigint* argument.  Previously, a SIGINT\n   handler was never set by Pdb.\n\n   run(statement, globals=None, locals=None)\n   runeval(expression, globals=None, locals=None)\n   runcall(function, *args, **kwds)\n   set_trace()\n\n      See the documentation for the functions explained above.\n\n\nDebugger Commands\n=================\n\nThe commands recognized by the debugger are listed below.  Most\ncommands can be abbreviated to one or two letters as indicated; e.g.\n``h(elp)`` means that either ``h`` or ``help`` can be used to enter\nthe help command (but not ``he`` or ``hel``, nor ``H`` or ``Help`` or\n``HELP``).  Arguments to commands must be separated by whitespace\n(spaces or tabs).  Optional arguments are enclosed in square brackets\n(``[]``) in the command syntax; the square brackets must not be typed.\nAlternatives in the command syntax are separated by a vertical bar\n(``|``).\n\nEntering a blank line repeats the last command entered.  Exception: if\nthe last command was a ``list`` command, the next 11 lines are listed.\n\nCommands that the debugger doesn\'t recognize are assumed to be Python\nstatements and are executed in the context of the program being\ndebugged.  Python statements can also be prefixed with an exclamation\npoint (``!``).  This is a powerful way to inspect the program being\ndebugged; it is even possible to change a variable or call a function.\nWhen an exception occurs in such a statement, the exception name is\nprinted but the debugger\'s state is not changed.\n\nThe debugger supports *aliases*.  Aliases can have parameters which\nallows one a certain level of adaptability to the context under\nexamination.\n\nMultiple commands may be entered on a single line, separated by\n``;;``.  (A single ``;`` is not used as it is the separator for\nmultiple commands in a line that is passed to the Python parser.)  No\nintelligence is applied to separating the commands; the input is split\nat the first ``;;`` pair, even if it is in the middle of a quoted\nstring.\n\nIf a file ``.pdbrc`` exists in the user\'s home directory or in the\ncurrent directory, it is read in and executed as if it had been typed\nat the debugger prompt.  This is particularly useful for aliases.  If\nboth files exist, the one in the home directory is read first and\naliases defined there can be overridden by the local file.\n\nChanged in version 3.2: ``.pdbrc`` can now contain commands that\ncontinue debugging, such as ``continue`` or ``next``.  Previously,\nthese commands had no effect.\n\nh(elp) [command]\n\n   Without argument, print the list of available commands.  With a\n   *command* as argument, print help about that command.  ``help pdb``\n   displays the full documentation (the docstring of the ``pdb``\n   module).  Since the *command* argument must be an identifier,\n   ``help exec`` must be entered to get help on the ``!`` command.\n\nw(here)\n\n   Print a stack trace, with the most recent frame at the bottom.  An\n   arrow indicates the current frame, which determines the context of\n   most commands.\n\nd(own) [count]\n\n   Move the current frame *count* (default one) levels down in the\n   stack trace (to a newer frame).\n\nu(p) [count]\n\n   Move the current frame *count* (default one) levels up in the stack\n   trace (to an older frame).\n\nb(reak) [([filename:]lineno | function) [, condition]]\n\n   With a *lineno* argument, set a break there in the current file.\n   With a *function* argument, set a break at the first executable\n   statement within that function.  The line number may be prefixed\n   with a filename and a colon, to specify a breakpoint in another\n   file (probably one that hasn\'t been loaded yet).  The file is\n   searched on ``sys.path``.  Note that each breakpoint is assigned a\n   number to which all the other breakpoint commands refer.\n\n   If a second argument is present, it is an expression which must\n   evaluate to true before the breakpoint is honored.\n\n   Without argument, list all breaks, including for each breakpoint,\n   the number of times that breakpoint has been hit, the current\n   ignore count, and the associated condition if any.\n\ntbreak [([filename:]lineno | function) [, condition]]\n\n   Temporary breakpoint, which is removed automatically when it is\n   first hit. The arguments are the same as for ``break``.\n\ncl(ear) [filename:lineno | bpnumber [bpnumber ...]]\n\n   With a *filename:lineno* argument, clear all the breakpoints at\n   this line. With a space separated list of breakpoint numbers, clear\n   those breakpoints. Without argument, clear all breaks (but first\n   ask confirmation).\n\ndisable [bpnumber [bpnumber ...]]\n\n   Disable the breakpoints given as a space separated list of\n   breakpoint numbers.  Disabling a breakpoint means it cannot cause\n   the program to stop execution, but unlike clearing a breakpoint, it\n   remains in the list of breakpoints and can be (re-)enabled.\n\nenable [bpnumber [bpnumber ...]]\n\n   Enable the breakpoints specified.\n\nignore bpnumber [count]\n\n   Set the ignore count for the given breakpoint number.  If count is\n   omitted, the ignore count is set to 0.  A breakpoint becomes active\n   when the ignore count is zero.  When non-zero, the count is\n   decremented each time the breakpoint is reached and the breakpoint\n   is not disabled and any associated condition evaluates to true.\n\ncondition bpnumber [condition]\n\n   Set a new *condition* for the breakpoint, an expression which must\n   evaluate to true before the breakpoint is honored.  If *condition*\n   is absent, any existing condition is removed; i.e., the breakpoint\n   is made unconditional.\n\ncommands [bpnumber]\n\n   Specify a list of commands for breakpoint number *bpnumber*.  The\n   commands themselves appear on the following lines.  Type a line\n   containing just ``end`` to terminate the commands. An example:\n\n      (Pdb) commands 1\n      (com) print some_variable\n      (com) end\n      (Pdb)\n\n   To remove all commands from a breakpoint, type commands and follow\n   it immediately with ``end``; that is, give no commands.\n\n   With no *bpnumber* argument, commands refers to the last breakpoint\n   set.\n\n   You can use breakpoint commands to start your program up again.\n   Simply use the continue command, or step, or any other command that\n   resumes execution.\n\n   Specifying any command resuming execution (currently continue,\n   step, next, return, jump, quit and their abbreviations) terminates\n   the command list (as if that command was immediately followed by\n   end). This is because any time you resume execution (even with a\n   simple next or step), you may encounter another breakpoint--which\n   could have its own command list, leading to ambiguities about which\n   list to execute.\n\n   If you use the \'silent\' command in the command list, the usual\n   message about stopping at a breakpoint is not printed.  This may be\n   desirable for breakpoints that are to print a specific message and\n   then continue.  If none of the other commands print anything, you\n   see no sign that the breakpoint was reached.\n\ns(tep)\n\n   Execute the current line, stop at the first possible occasion\n   (either in a function that is called or on the next line in the\n   current function).\n\nn(ext)\n\n   Continue execution until the next line in the current function is\n   reached or it returns.  (The difference between ``next`` and\n   ``step`` is that ``step`` stops inside a called function, while\n   ``next`` executes called functions at (nearly) full speed, only\n   stopping at the next line in the current function.)\n\nunt(il) [lineno]\n\n   Without argument, continue execution until the line with a number\n   greater than the current one is reached.\n\n   With a line number, continue execution until a line with a number\n   greater or equal to that is reached.  In both cases, also stop when\n   the current frame returns.\n\n   Changed in version 3.2: Allow giving an explicit line number.\n\nr(eturn)\n\n   Continue execution until the current function returns.\n\nc(ont(inue))\n\n   Continue execution, only stop when a breakpoint is encountered.\n\nj(ump) lineno\n\n   Set the next line that will be executed.  Only available in the\n   bottom-most frame.  This lets you jump back and execute code again,\n   or jump forward to skip code that you don\'t want to run.\n\n   It should be noted that not all jumps are allowed -- for instance\n   it is not possible to jump into the middle of a ``for`` loop or out\n   of a ``finally`` clause.\n\nl(ist) [first[, last]]\n\n   List source code for the current file.  Without arguments, list 11\n   lines around the current line or continue the previous listing.\n   With ``.`` as argument, list 11 lines around the current line.\n   With one argument, list 11 lines around at that line.  With two\n   arguments, list the given range; if the second argument is less\n   than the first, it is interpreted as a count.\n\n   The current line in the current frame is indicated by ``->``.  If\n   an exception is being debugged, the line where the exception was\n   originally raised or propagated is indicated by ``>>``, if it\n   differs from the current line.\n\n   New in version 3.2: The ``>>`` marker.\n\nll | longlist\n\n   List all source code for the current function or frame.\n   Interesting lines are marked as for ``list``.\n\n   New in version 3.2.\n\na(rgs)\n\n   Print the argument list of the current function.\n\np(rint) expression\n\n   Evaluate the *expression* in the current context and print its\n   value.\n\npp expression\n\n   Like the ``print`` command, except the value of the expression is\n   pretty-printed using the ``pprint`` module.\n\nwhatis expression\n\n   Print the type of the *expression*.\n\nsource expression\n\n   Try to get source code for the given object and display it.\n\n   New in version 3.2.\n\ndisplay [expression]\n\n   Display the value of the expression if it changed, each time\n   execution stops in the current frame.\n\n   Without expression, list all display expressions for the current\n   frame.\n\n   New in version 3.2.\n\nundisplay [expression]\n\n   Do not display the expression any more in the current frame.\n   Without expression, clear all display expressions for the current\n   frame.\n\n   New in version 3.2.\n\ninteract\n\n   Start an interative interpreter (using the ``code`` module) whose\n   global namespace contains all the (global and local) names found in\n   the current scope.\n\n   New in version 3.2.\n\nalias [name [command]]\n\n   Create an alias called *name* that executes *command*.  The command\n   must *not* be enclosed in quotes.  Replaceable parameters can be\n   indicated by ``%1``, ``%2``, and so on, while ``%*`` is replaced by\n   all the parameters. If no command is given, the current alias for\n   *name* is shown. If no arguments are given, all aliases are listed.\n\n   Aliases may be nested and can contain anything that can be legally\n   typed at the pdb prompt.  Note that internal pdb commands *can* be\n   overridden by aliases.  Such a command is then hidden until the\n   alias is removed.  Aliasing is recursively applied to the first\n   word of the command line; all other words in the line are left\n   alone.\n\n   As an example, here are two useful aliases (especially when placed\n   in the ``.pdbrc`` file):\n\n      # Print instance variables (usage "pi classInst")\n      alias pi for k in %1.__dict__.keys(): print("%1.",k,"=",%1.__dict__[k])\n      # Print instance variables in self\n      alias ps pi self\n\nunalias name\n\n   Delete the specified alias.\n\n! statement\n\n   Execute the (one-line) *statement* in the context of the current\n   stack frame. The exclamation point can be omitted unless the first\n   word of the statement resembles a debugger command.  To set a\n   global variable, you can prefix the assignment command with a\n   ``global`` statement on the same line, e.g.:\n\n      (Pdb) global list_options; list_options = [\'-l\']\n      (Pdb)\n\nrun [args ...]\nrestart [args ...]\n\n   Restart the debugged Python program.  If an argument is supplied,\n   it is split with ``shlex`` and the result is used as the new\n   ``sys.argv``. History, breakpoints, actions and debugger options\n   are preserved. ``restart`` is an alias for ``run``.\n\nq(uit)\n\n   Quit from the debugger.  The program being executed is aborted.\n\n-[ Footnotes ]-\n\n[1] Whether a frame is considered to originate in a certain module is\n    determined by the ``__name__`` in the frame globals.\n',
  'del': '\nThe ``del`` statement\n*********************\n\n   del_stmt ::= "del" target_list\n\nDeletion is recursively defined very similar to the way assignment is\ndefined. Rather than spelling it out in full details, here are some\nhints.\n\nDeletion of a target list recursively deletes each target, from left\nto right.\n\nDeletion of a name removes the binding of that name from the local or\nglobal namespace, depending on whether the name occurs in a ``global``\nstatement in the same code block.  If the name is unbound, a\n``NameError`` exception will be raised.\n\nDeletion of attribute references, subscriptions and slicings is passed\nto the primary object involved; deletion of a slicing is in general\nequivalent to assignment of an empty slice of the right type (but even\nthis is determined by the sliced object).\n\nChanged in version 3.2: Previously it was illegal to delete a name\nfrom the local namespace if it occurs as a free variable in a nested\nblock.\n',
  'dict': '\nDictionary displays\n*******************\n\nA dictionary display is a possibly empty series of key/datum pairs\nenclosed in curly braces:\n\n   dict_display       ::= "{" [key_datum_list | dict_comprehension] "}"\n   key_datum_list     ::= key_datum ("," key_datum)* [","]\n   key_datum          ::= expression ":" expression\n   dict_comprehension ::= expression ":" expression comp_for\n\nA dictionary display yields a new dictionary object.\n\nIf a comma-separated sequence of key/datum pairs is given, they are\nevaluated from left to right to define the entries of the dictionary:\neach key object is used as a key into the dictionary to store the\ncorresponding datum.  This means that you can specify the same key\nmultiple times in the key/datum list, and the final dictionary\'s value\nfor that key will be the last one given.\n\nA dict comprehension, in contrast to list and set comprehensions,\nneeds two expressions separated with a colon followed by the usual\n"for" and "if" clauses. When the comprehension is run, the resulting\nkey and value elements are inserted in the new dictionary in the order\nthey are produced.\n\nRestrictions on the types of the key values are listed earlier in\nsection *The standard type hierarchy*.  (To summarize, the key type\nshould be *hashable*, which excludes all mutable objects.)  Clashes\nbetween duplicate keys are not detected; the last datum (textually\nrightmost in the display) stored for a given key value prevails.\n',
@@ -34,14 +34,14 @@
  'exprlists': '\nExpression lists\n****************\n\n   expression_list ::= expression ( "," expression )* [","]\n\nAn expression list containing at least one comma yields a tuple.  The\nlength of the tuple is the number of expressions in the list.  The\nexpressions are evaluated from left to right.\n\nThe trailing comma is required only to create a single tuple (a.k.a. a\n*singleton*); it is optional in all other cases.  A single expression\nwithout a trailing comma doesn\'t create a tuple, but rather yields the\nvalue of that expression. (To create an empty tuple, use an empty pair\nof parentheses: ``()``.)\n',
  'floating': '\nFloating point literals\n***********************\n\nFloating point literals are described by the following lexical\ndefinitions:\n\n   floatnumber   ::= pointfloat | exponentfloat\n   pointfloat    ::= [intpart] fraction | intpart "."\n   exponentfloat ::= (intpart | pointfloat) exponent\n   intpart       ::= digit+\n   fraction      ::= "." digit+\n   exponent      ::= ("e" | "E") ["+" | "-"] digit+\n\nNote that the integer and exponent parts are always interpreted using\nradix 10. For example, ``077e010`` is legal, and denotes the same\nnumber as ``77e10``. The allowed range of floating point literals is\nimplementation-dependent. Some examples of floating point literals:\n\n   3.14    10.    .001    1e100    3.14e-10    0e0\n\nNote that numeric literals do not include a sign; a phrase like ``-1``\nis actually an expression composed of the unary operator ``-`` and the\nliteral ``1``.\n',
  'for': '\nThe ``for`` statement\n*********************\n\nThe ``for`` statement is used to iterate over the elements of a\nsequence (such as a string, tuple or list) or other iterable object:\n\n   for_stmt ::= "for" target_list "in" expression_list ":" suite\n                ["else" ":" suite]\n\nThe expression list is evaluated once; it should yield an iterable\nobject.  An iterator is created for the result of the\n``expression_list``.  The suite is then executed once for each item\nprovided by the iterator, in the order of ascending indices.  Each\nitem in turn is assigned to the target list using the standard rules\nfor assignments (see *Assignment statements*), and then the suite is\nexecuted.  When the items are exhausted (which is immediately when the\nsequence is empty or an iterator raises a ``StopIteration``\nexception), the suite in the ``else`` clause, if present, is executed,\nand the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ncontinues with the next item, or with the ``else`` clause if there was\nno next item.\n\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\n\nNames in the target list are not deleted when the loop is finished,\nbut if the sequence is empty, it will not have been assigned to at all\nby the loop.  Hint: the built-in function ``range()`` returns an\niterator of integers suitable to emulate the effect of Pascal\'s ``for\ni := a to b do``; e.g., ``list(range(3))`` returns the list ``[0, 1,\n2]``.\n\nNote: There is a subtlety when the sequence is being modified by the loop\n  (this can only occur for mutable sequences, i.e. lists).  An\n  internal counter is used to keep track of which item is used next,\n  and this is incremented on each iteration.  When this counter has\n  reached the length of the sequence the loop terminates.  This means\n  that if the suite deletes the current (or a previous) item from the\n  sequence, the next item will be skipped (since it gets the index of\n  the current item which has already been treated).  Likewise, if the\n  suite inserts an item in the sequence before the current item, the\n  current item will be treated again the next time through the loop.\n  This can lead to nasty bugs that can be avoided by making a\n  temporary copy using a slice of the whole sequence, e.g.,\n\n     for x in a[:]:\n         if x < 0: a.remove(x)\n',
- 'formatstrings': '\nFormat String Syntax\n********************\n\nThe ``str.format()`` method and the ``Formatter`` class share the same\nsyntax for format strings (although in the case of ``Formatter``,\nsubclasses can define their own format string syntax).\n\nFormat strings contain "replacement fields" surrounded by curly braces\n``{}``. Anything that is not contained in braces is considered literal\ntext, which is copied unchanged to the output.  If you need to include\na brace character in the literal text, it can be escaped by doubling:\n``{{`` and ``}}``.\n\nThe grammar for a replacement field is as follows:\n\n      replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"\n      field_name        ::= arg_name ("." attribute_name | "[" element_index "]")*\n      arg_name          ::= [identifier | integer]\n      attribute_name    ::= identifier\n      element_index     ::= integer | index_string\n      index_string      ::= <any source character except "]"> +\n      conversion        ::= "r" | "s" | "a"\n      format_spec       ::= <described in the next section>\n\nIn less formal terms, the replacement field can start with a\n*field_name* that specifies the object whose value is to be formatted\nand inserted into the output instead of the replacement field. The\n*field_name* is optionally followed by a  *conversion* field, which is\npreceded by an exclamation point ``\'!\'``, and a *format_spec*, which\nis preceded by a colon ``\':\'``.  These specify a non-default format\nfor the replacement value.\n\nSee also the *Format Specification Mini-Language* section.\n\nThe *field_name* itself begins with an *arg_name* that is either a\nnumber or a keyword.  If it\'s a number, it refers to a positional\nargument, and if it\'s a keyword, it refers to a named keyword\nargument.  If the numerical arg_names in a format string are 0, 1, 2,\n... in sequence, they can all be omitted (not just some) and the\nnumbers 0, 1, 2, ... will be automatically inserted in that order.\nBecause *arg_name* is not quote-delimited, it is not possible to\nspecify arbitrary dictionary keys (e.g., the strings ``\'10\'`` or\n``\':-]\'``) within a format string. The *arg_name* can be followed by\nany number of index or attribute expressions. An expression of the\nform ``\'.name\'`` selects the named attribute using ``getattr()``,\nwhile an expression of the form ``\'[index]\'`` does an index lookup\nusing ``__getitem__()``.\n\nChanged in version 3.1: The positional argument specifiers can be\nomitted, so ``\'{} {}\'`` is equivalent to ``\'{0} {1}\'``.\n\nSome simple format string examples:\n\n   "First, thou shalt count to {0}" # References first positional argument\n   "Bring me a {}"                  # Implicitly references the first positional argument\n   "From {} to {}"                  # Same as "From {0} to {1}"\n   "My quest is {name}"             # References keyword argument \'name\'\n   "Weight in tons {0.weight}"      # \'weight\' attribute of first positional arg\n   "Units destroyed: {players[0]}"  # First element of keyword argument \'players\'.\n\nThe *conversion* field causes a type coercion before formatting.\nNormally, the job of formatting a value is done by the\n``__format__()`` method of the value itself.  However, in some cases\nit is desirable to force a type to be formatted as a string,\noverriding its own definition of formatting.  By converting the value\nto a string before calling ``__format__()``, the normal formatting\nlogic is bypassed.\n\nThree conversion flags are currently supported: ``\'!s\'`` which calls\n``str()`` on the value, ``\'!r\'`` which calls ``repr()`` and ``\'!a\'``\nwhich calls ``ascii()``.\n\nSome examples:\n\n   "Harold\'s a clever {0!s}"        # Calls str() on the argument first\n   "Bring out the holy {name!r}"    # Calls repr() on the argument first\n   "More {!a}"                      # Calls ascii() on the argument first\n\nThe *format_spec* field contains a specification of how the value\nshould be presented, including such details as field width, alignment,\npadding, decimal precision and so on.  Each value type can define its\nown "formatting mini-language" or interpretation of the *format_spec*.\n\nMost built-in types support a common formatting mini-language, which\nis described in the next section.\n\nA *format_spec* field can also include nested replacement fields\nwithin it. These nested replacement fields can contain only a field\nname; conversion flags and format specifications are not allowed.  The\nreplacement fields within the format_spec are substituted before the\n*format_spec* string is interpreted. This allows the formatting of a\nvalue to be dynamically specified.\n\nSee the *Format examples* section for some examples.\n\n\nFormat Specification Mini-Language\n==================================\n\n"Format specifications" are used within replacement fields contained\nwithin a format string to define how individual values are presented\n(see *Format String Syntax*).  They can also be passed directly to the\nbuilt-in ``format()`` function.  Each formattable type may define how\nthe format specification is to be interpreted.\n\nMost built-in types implement the following options for format\nspecifications, although some of the formatting options are only\nsupported by the numeric types.\n\nA general convention is that an empty format string (``""``) produces\nthe same result as if you had called ``str()`` on the value. A non-\nempty format string typically modifies the result.\n\nThe general form of a *standard format specifier* is:\n\n   format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]\n   fill        ::= <a character other than \'{\' or \'}\'>\n   align       ::= "<" | ">" | "=" | "^"\n   sign        ::= "+" | "-" | " "\n   width       ::= integer\n   precision   ::= integer\n   type        ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"\n\nThe *fill* character can be any character other than \'{\' or \'}\'.  The\npresence of a fill character is signaled by the character following\nit, which must be one of the alignment options.  If the second\ncharacter of *format_spec* is not a valid alignment option, then it is\nassumed that both the fill character and the alignment option are\nabsent.\n\nThe meaning of the various alignment options is as follows:\n\n   +-----------+------------------------------------------------------------+\n   | Option    | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'<\'``   | Forces the field to be left-aligned within the available   |\n   |           | space (this is the default for most objects).              |\n   +-----------+------------------------------------------------------------+\n   | ``\'>\'``   | Forces the field to be right-aligned within the available  |\n   |           | space (this is the default for numbers).                   |\n   +-----------+------------------------------------------------------------+\n   | ``\'=\'``   | Forces the padding to be placed after the sign (if any)    |\n   |           | but before the digits.  This is used for printing fields   |\n   |           | in the form \'+000000120\'. This alignment option is only    |\n   |           | valid for numeric types.                                   |\n   +-----------+------------------------------------------------------------+\n   | ``\'^\'``   | Forces the field to be centered within the available       |\n   |           | space.                                                     |\n   +-----------+------------------------------------------------------------+\n\nNote that unless a minimum field width is defined, the field width\nwill always be the same size as the data to fill it, so that the\nalignment option has no meaning in this case.\n\nThe *sign* option is only valid for number types, and can be one of\nthe following:\n\n   +-----------+------------------------------------------------------------+\n   | Option    | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'+\'``   | indicates that a sign should be used for both positive as  |\n   |           | well as negative numbers.                                  |\n   +-----------+------------------------------------------------------------+\n   | ``\'-\'``   | indicates that a sign should be used only for negative     |\n   |           | numbers (this is the default behavior).                    |\n   +-----------+------------------------------------------------------------+\n   | space     | indicates that a leading space should be used on positive  |\n   |           | numbers, and a minus sign on negative numbers.             |\n   +-----------+------------------------------------------------------------+\n\nThe ``\'#\'`` option causes the "alternate form" to be used for the\nconversion.  The alternate form is defined differently for different\ntypes.  This option is only valid for integer, float, complex and\nDecimal types. For integers, when binary, octal, or hexadecimal output\nis used, this option adds the prefix respective ``\'0b\'``, ``\'0o\'``, or\n``\'0x\'`` to the output value. For floats, complex and Decimal the\nalternate form causes the result of the conversion to always contain a\ndecimal-point character, even if no digits follow it. Normally, a\ndecimal-point character appears in the result of these conversions\nonly if a digit follows it. In addition, for ``\'g\'`` and ``\'G\'``\nconversions, trailing zeros are not removed from the result.\n\nThe ``\',\'`` option signals the use of a comma for a thousands\nseparator. For a locale aware separator, use the ``\'n\'`` integer\npresentation type instead.\n\nChanged in version 3.1: Added the ``\',\'`` option (see also **PEP\n378**).\n\n*width* is a decimal integer defining the minimum field width.  If not\nspecified, then the field width will be determined by the content.\n\nPreceding the *width* field by a zero (``\'0\'``) character enables\nsign-aware zero-padding for numeric types.  This is equivalent to a\n*fill* character of ``\'0\'`` with an *alignment* type of ``\'=\'``.\n\nThe *precision* is a decimal number indicating how many digits should\nbe displayed after the decimal point for a floating point value\nformatted with ``\'f\'`` and ``\'F\'``, or before and after the decimal\npoint for a floating point value formatted with ``\'g\'`` or ``\'G\'``.\nFor non-number types the field indicates the maximum field size - in\nother words, how many characters will be used from the field content.\nThe *precision* is not allowed for integer values.\n\nFinally, the *type* determines how the data should be presented.\n\nThe available string presentation types are:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'s\'``   | String format. This is the default type for strings and    |\n   |           | may be omitted.                                            |\n   +-----------+------------------------------------------------------------+\n   | None      | The same as ``\'s\'``.                                       |\n   +-----------+------------------------------------------------------------+\n\nThe available integer presentation types are:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'b\'``   | Binary format. Outputs the number in base 2.               |\n   +-----------+------------------------------------------------------------+\n   | ``\'c\'``   | Character. Converts the integer to the corresponding       |\n   |           | unicode character before printing.                         |\n   +-----------+------------------------------------------------------------+\n   | ``\'d\'``   | Decimal Integer. Outputs the number in base 10.            |\n   +-----------+------------------------------------------------------------+\n   | ``\'o\'``   | Octal format. Outputs the number in base 8.                |\n   +-----------+------------------------------------------------------------+\n   | ``\'x\'``   | Hex format. Outputs the number in base 16, using lower-    |\n   |           | case letters for the digits above 9.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'X\'``   | Hex format. Outputs the number in base 16, using upper-    |\n   |           | case letters for the digits above 9.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'n\'``   | Number. This is the same as ``\'d\'``, except that it uses   |\n   |           | the current locale setting to insert the appropriate       |\n   |           | number separator characters.                               |\n   +-----------+------------------------------------------------------------+\n   | None      | The same as ``\'d\'``.                                       |\n   +-----------+------------------------------------------------------------+\n\nIn addition to the above presentation types, integers can be formatted\nwith the floating point presentation types listed below (except\n``\'n\'`` and None). When doing so, ``float()`` is used to convert the\ninteger to a floating point number before formatting.\n\nThe available presentation types for floating point and decimal values\nare:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'e\'``   | Exponent notation. Prints the number in scientific         |\n   |           | notation using the letter \'e\' to indicate the exponent.    |\n   |           | The default precision is ``6``.                            |\n   +-----------+------------------------------------------------------------+\n   | ``\'E\'``   | Exponent notation. Same as ``\'e\'`` except it uses an upper |\n   |           | case \'E\' as the separator character.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'f\'``   | Fixed point. Displays the number as a fixed-point number.  |\n   |           | The default precision is ``6``.                            |\n   +-----------+------------------------------------------------------------+\n   | ``\'F\'``   | Fixed point. Same as ``\'f\'``, but converts ``nan`` to      |\n   |           | ``NAN`` and ``inf`` to ``INF``.                            |\n   +-----------+------------------------------------------------------------+\n   | ``\'g\'``   | General format.  For a given precision ``p >= 1``, this    |\n   |           | rounds the number to ``p`` significant digits and then     |\n   |           | formats the result in either fixed-point format or in      |\n   |           | scientific notation, depending on its magnitude.  The      |\n   |           | precise rules are as follows: suppose that the result      |\n   |           | formatted with presentation type ``\'e\'`` and precision     |\n   |           | ``p-1`` would have exponent ``exp``.  Then if ``-4 <= exp  |\n   |           | < p``, the number is formatted with presentation type      |\n   |           | ``\'f\'`` and precision ``p-1-exp``. Otherwise, the number   |\n   |           | is formatted with presentation type ``\'e\'`` and precision  |\n   |           | ``p-1``. In both cases insignificant trailing zeros are    |\n   |           | removed from the significand, and the decimal point is     |\n   |           | also removed if there are no remaining digits following    |\n   |           | it.  Positive and negative infinity, positive and negative |\n   |           | zero, and nans, are formatted as ``inf``, ``-inf``, ``0``, |\n   |           | ``-0`` and ``nan`` respectively, regardless of the         |\n   |           | precision.  A precision of ``0`` is treated as equivalent  |\n   |           | to a precision of ``1``.  The default precision is ``6``.  |\n   +-----------+------------------------------------------------------------+\n   | ``\'G\'``   | General format. Same as ``\'g\'`` except switches to ``\'E\'`` |\n   |           | if the number gets too large. The representations of       |\n   |           | infinity and NaN are uppercased, too.                      |\n   +-----------+------------------------------------------------------------+\n   | ``\'n\'``   | Number. This is the same as ``\'g\'``, except that it uses   |\n   |           | the current locale setting to insert the appropriate       |\n   |           | number separator characters.                               |\n   +-----------+------------------------------------------------------------+\n   | ``\'%\'``   | Percentage. Multiplies the number by 100 and displays in   |\n   |           | fixed (``\'f\'``) format, followed by a percent sign.        |\n   +-----------+------------------------------------------------------------+\n   | None      | Similar to ``\'g\'``, except with at least one digit past    |\n   |           | the decimal point and a default precision of 12. This is   |\n   |           | intended to match ``str()``, except you can add the other  |\n   |           | format modifiers.                                          |\n   +-----------+------------------------------------------------------------+\n\n\nFormat examples\n===============\n\nThis section contains examples of the new format syntax and comparison\nwith the old ``%``-formatting.\n\nIn most of the cases the syntax is similar to the old\n``%``-formatting, with the addition of the ``{}`` and with ``:`` used\ninstead of ``%``. For example, ``\'%03.2f\'`` can be translated to\n``\'{:03.2f}\'``.\n\nThe new format syntax also supports new and different options, shown\nin the follow examples.\n\nAccessing arguments by position:\n\n   >>> \'{0}, {1}, {2}\'.format(\'a\', \'b\', \'c\')\n   \'a, b, c\'\n   >>> \'{}, {}, {}\'.format(\'a\', \'b\', \'c\')  # 3.1+ only\n   \'a, b, c\'\n   >>> \'{2}, {1}, {0}\'.format(\'a\', \'b\', \'c\')\n   \'c, b, a\'\n   >>> \'{2}, {1}, {0}\'.format(*\'abc\')      # unpacking argument sequence\n   \'c, b, a\'\n   >>> \'{0}{1}{0}\'.format(\'abra\', \'cad\')   # arguments\' indices can be repeated\n   \'abracadabra\'\n\nAccessing arguments by name:\n\n   >>> \'Coordinates: {latitude}, {longitude}\'.format(latitude=\'37.24N\', longitude=\'-115.81W\')\n   \'Coordinates: 37.24N, -115.81W\'\n   >>> coord = {\'latitude\': \'37.24N\', \'longitude\': \'-115.81W\'}\n   >>> \'Coordinates: {latitude}, {longitude}\'.format(**coord)\n   \'Coordinates: 37.24N, -115.81W\'\n\nAccessing arguments\' attributes:\n\n   >>> c = 3-5j\n   >>> (\'The complex number {0} is formed from the real part {0.real} \'\n   ...  \'and the imaginary part {0.imag}.\').format(c)\n   \'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.\'\n   >>> class Point:\n   ...     def __init__(self, x, y):\n   ...         self.x, self.y = x, y\n   ...     def __str__(self):\n   ...         return \'Point({self.x}, {self.y})\'.format(self=self)\n   ...\n   >>> str(Point(4, 2))\n   \'Point(4, 2)\'\n\nAccessing arguments\' items:\n\n   >>> coord = (3, 5)\n   >>> \'X: {0[0]};  Y: {0[1]}\'.format(coord)\n   \'X: 3;  Y: 5\'\n\nReplacing ``%s`` and ``%r``:\n\n   >>> "repr() shows quotes: {!r}; str() doesn\'t: {!s}".format(\'test1\', \'test2\')\n   "repr() shows quotes: \'test1\'; str() doesn\'t: test2"\n\nAligning the text and specifying a width:\n\n   >>> \'{:<30}\'.format(\'left aligned\')\n   \'left aligned                  \'\n   >>> \'{:>30}\'.format(\'right aligned\')\n   \'                 right aligned\'\n   >>> \'{:^30}\'.format(\'centered\')\n   \'           centered           \'\n   >>> \'{:*^30}\'.format(\'centered\')  # use \'*\' as a fill char\n   \'***********centered***********\'\n\nReplacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign:\n\n   >>> \'{:+f}; {:+f}\'.format(3.14, -3.14)  # show it always\n   \'+3.140000; -3.140000\'\n   >>> \'{: f}; {: f}\'.format(3.14, -3.14)  # show a space for positive numbers\n   \' 3.140000; -3.140000\'\n   >>> \'{:-f}; {:-f}\'.format(3.14, -3.14)  # show only the minus -- same as \'{:f}; {:f}\'\n   \'3.140000; -3.140000\'\n\nReplacing ``%x`` and ``%o`` and converting the value to different\nbases:\n\n   >>> # format also supports binary numbers\n   >>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)\n   \'int: 42;  hex: 2a;  oct: 52;  bin: 101010\'\n   >>> # with 0x, 0o, or 0b as prefix:\n   >>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)\n   \'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010\'\n\nUsing the comma as a thousands separator:\n\n   >>> \'{:,}\'.format(1234567890)\n   \'1,234,567,890\'\n\nExpressing a percentage:\n\n   >>> points = 19\n   >>> total = 22\n   >>> \'Correct answers: {:.2%}\'.format(points/total)\n   \'Correct answers: 86.36%\'\n\nUsing type-specific formatting:\n\n   >>> import datetime\n   >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n   >>> \'{:%Y-%m-%d %H:%M:%S}\'.format(d)\n   \'2010-07-04 12:15:58\'\n\nNesting arguments and more complex examples:\n\n   >>> for align, text in zip(\'<^>\', [\'left\', \'center\', \'right\']):\n   ...     \'{0:{fill}{align}16}\'.format(text, fill=align, align=align)\n   ...\n   \'left<<<<<<<<<<<<\'\n   \'^^^^^center^^^^^\'\n   \'>>>>>>>>>>>right\'\n   >>>\n   >>> octets = [192, 168, 0, 1]\n   >>> \'{:02X}{:02X}{:02X}{:02X}\'.format(*octets)\n   \'C0A80001\'\n   >>> int(_, 16)\n   3232235521\n   >>>\n   >>> width = 5\n   >>> for num in range(5,12): #doctest: +NORMALIZE_WHITESPACE\n   ...     for base in \'dXob\':\n   ...         print(\'{0:{width}{base}}\'.format(num, base=base, width=width), end=\' \')\n   ...     print()\n   ...\n       5     5     5   101\n       6     6     6   110\n       7     7     7   111\n       8     8    10  1000\n       9     9    11  1001\n      10     A    12  1010\n      11     B    13  1011\n',
- 'function': '\nFunction definitions\n********************\n\nA function definition defines a user-defined function object (see\nsection *The standard type hierarchy*):\n\n   funcdef        ::= [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite\n   decorators     ::= decorator+\n   decorator      ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE\n   dotted_name    ::= identifier ("." identifier)*\n   parameter_list ::= (defparameter ",")*\n                      ( "*" [parameter] ("," defparameter)* ["," "**" parameter]\n                      | "**" parameter\n                      | defparameter [","] )\n   parameter      ::= identifier [":" expression]\n   defparameter   ::= parameter ["=" expression]\n   funcname       ::= identifier\n\nA function definition is an executable statement.  Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function).  This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition.  The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object.  Multiple decorators are applied in\nnested fashion. For example, the following code\n\n   @f1(arg)\n   @f2\n   def func(): pass\n\nis equivalent to\n\n   def func(): pass\n   func = f1(arg)(f2(func))\n\nWhen one or more *parameters* have the form *parameter* ``=``\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted.  If a parameter has a default value, all following\nparameters up until the "``*``" must also have a default value ---\nthis is a syntactic restriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated from left to right when the\nfunction definition is executed.** This means that the expression is\nevaluated once, when the function is defined, and that the same "pre-\ncomputed" value is used for each call.  This is especially important\nto understand when a default parameter is a mutable object, such as a\nlist or a dictionary: if the function modifies the object (e.g. by\nappending an item to a list), the default value is in effect modified.\nThis is generally not what was intended.  A way around this is to use\n``None`` as the default, and explicitly test for it in the body of the\nfunction, e.g.:\n\n   def whats_on_the_telly(penguin=None):\n       if penguin is None:\n           penguin = []\n       penguin.append("property of the zoo")\n       return penguin\n\nFunction call semantics are described in more detail in section\n*Calls*. A function call always assigns values to all parameters\nmentioned in the parameter list, either from position arguments, from\nkeyword arguments, or from default values.  If the form\n"``*identifier``" is present, it is initialized to a tuple receiving\nany excess positional parameters, defaulting to the empty tuple.  If\nthe form "``**identifier``" is present, it is initialized to a new\ndictionary receiving any excess keyword arguments, defaulting to a new\nempty dictionary. Parameters after "``*``" or "``*identifier``" are\nkeyword-only parameters and may only be passed used keyword arguments.\n\nParameters may have annotations of the form "``: expression``"\nfollowing the parameter name.  Any parameter may have an annotation\neven those of the form ``*identifier`` or ``**identifier``.  Functions\nmay have "return" annotation of the form "``-> expression``" after the\nparameter list.  These annotations can be any valid Python expression\nand are evaluated when the function definition is executed.\nAnnotations may be evaluated in a different order than they appear in\nthe source code.  The presence of annotations does not change the\nsemantics of a function.  The annotation values are available as\nvalues of a dictionary keyed by the parameters\' names in the\n``__annotations__`` attribute of the function object.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions.  This uses lambda forms,\ndescribed in section *Lambdas*.  Note that the lambda form is merely a\nshorthand for a simplified function definition; a function defined in\na "``def``" statement can be passed around or assigned to another name\njust like a function defined by a lambda form.  The "``def``" form is\nactually more powerful since it allows the execution of multiple\nstatements and annotations.\n\n**Programmer\'s note:** Functions are first-class objects.  A "``def``"\nform executed inside a function definition defines a local function\nthat can be returned or passed around.  Free variables used in the\nnested function can access the local variables of the function\ncontaining the def.  See section *Naming and binding* for details.\n\nSee also:\n\n   **PEP 3107** - Function Annotations\n      The original specification for function annotations.\n',
+ 'formatstrings': '\nFormat String Syntax\n********************\n\nThe ``str.format()`` method and the ``Formatter`` class share the same\nsyntax for format strings (although in the case of ``Formatter``,\nsubclasses can define their own format string syntax).\n\nFormat strings contain "replacement fields" surrounded by curly braces\n``{}``. Anything that is not contained in braces is considered literal\ntext, which is copied unchanged to the output.  If you need to include\na brace character in the literal text, it can be escaped by doubling:\n``{{`` and ``}}``.\n\nThe grammar for a replacement field is as follows:\n\n      replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"\n      field_name        ::= arg_name ("." attribute_name | "[" element_index "]")*\n      arg_name          ::= [identifier | integer]\n      attribute_name    ::= identifier\n      element_index     ::= integer | index_string\n      index_string      ::= <any source character except "]"> +\n      conversion        ::= "r" | "s" | "a"\n      format_spec       ::= <described in the next section>\n\nIn less formal terms, the replacement field can start with a\n*field_name* that specifies the object whose value is to be formatted\nand inserted into the output instead of the replacement field. The\n*field_name* is optionally followed by a  *conversion* field, which is\npreceded by an exclamation point ``\'!\'``, and a *format_spec*, which\nis preceded by a colon ``\':\'``.  These specify a non-default format\nfor the replacement value.\n\nSee also the *Format Specification Mini-Language* section.\n\nThe *field_name* itself begins with an *arg_name* that is either a\nnumber or a keyword.  If it\'s a number, it refers to a positional\nargument, and if it\'s a keyword, it refers to a named keyword\nargument.  If the numerical arg_names in a format string are 0, 1, 2,\n... in sequence, they can all be omitted (not just some) and the\nnumbers 0, 1, 2, ... will be automatically inserted in that order.\nBecause *arg_name* is not quote-delimited, it is not possible to\nspecify arbitrary dictionary keys (e.g., the strings ``\'10\'`` or\n``\':-]\'``) within a format string. The *arg_name* can be followed by\nany number of index or attribute expressions. An expression of the\nform ``\'.name\'`` selects the named attribute using ``getattr()``,\nwhile an expression of the form ``\'[index]\'`` does an index lookup\nusing ``__getitem__()``.\n\nChanged in version 3.1: The positional argument specifiers can be\nomitted, so ``\'{} {}\'`` is equivalent to ``\'{0} {1}\'``.\n\nSome simple format string examples:\n\n   "First, thou shalt count to {0}" # References first positional argument\n   "Bring me a {}"                  # Implicitly references the first positional argument\n   "From {} to {}"                  # Same as "From {0} to {1}"\n   "My quest is {name}"             # References keyword argument \'name\'\n   "Weight in tons {0.weight}"      # \'weight\' attribute of first positional arg\n   "Units destroyed: {players[0]}"  # First element of keyword argument \'players\'.\n\nThe *conversion* field causes a type coercion before formatting.\nNormally, the job of formatting a value is done by the\n``__format__()`` method of the value itself.  However, in some cases\nit is desirable to force a type to be formatted as a string,\noverriding its own definition of formatting.  By converting the value\nto a string before calling ``__format__()``, the normal formatting\nlogic is bypassed.\n\nThree conversion flags are currently supported: ``\'!s\'`` which calls\n``str()`` on the value, ``\'!r\'`` which calls ``repr()`` and ``\'!a\'``\nwhich calls ``ascii()``.\n\nSome examples:\n\n   "Harold\'s a clever {0!s}"        # Calls str() on the argument first\n   "Bring out the holy {name!r}"    # Calls repr() on the argument first\n   "More {!a}"                      # Calls ascii() on the argument first\n\nThe *format_spec* field contains a specification of how the value\nshould be presented, including such details as field width, alignment,\npadding, decimal precision and so on.  Each value type can define its\nown "formatting mini-language" or interpretation of the *format_spec*.\n\nMost built-in types support a common formatting mini-language, which\nis described in the next section.\n\nA *format_spec* field can also include nested replacement fields\nwithin it. These nested replacement fields can contain only a field\nname; conversion flags and format specifications are not allowed.  The\nreplacement fields within the format_spec are substituted before the\n*format_spec* string is interpreted. This allows the formatting of a\nvalue to be dynamically specified.\n\nSee the *Format examples* section for some examples.\n\n\nFormat Specification Mini-Language\n==================================\n\n"Format specifications" are used within replacement fields contained\nwithin a format string to define how individual values are presented\n(see *Format String Syntax*).  They can also be passed directly to the\nbuilt-in ``format()`` function.  Each formattable type may define how\nthe format specification is to be interpreted.\n\nMost built-in types implement the following options for format\nspecifications, although some of the formatting options are only\nsupported by the numeric types.\n\nA general convention is that an empty format string (``""``) produces\nthe same result as if you had called ``str()`` on the value. A non-\nempty format string typically modifies the result.\n\nThe general form of a *standard format specifier* is:\n\n   format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]\n   fill        ::= <a character other than \'{\' or \'}\'>\n   align       ::= "<" | ">" | "=" | "^"\n   sign        ::= "+" | "-" | " "\n   width       ::= integer\n   precision   ::= integer\n   type        ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"\n\nThe *fill* character can be any character other than \'{\' or \'}\'.  The\npresence of a fill character is signaled by the character following\nit, which must be one of the alignment options.  If the second\ncharacter of *format_spec* is not a valid alignment option, then it is\nassumed that both the fill character and the alignment option are\nabsent.\n\nThe meaning of the various alignment options is as follows:\n\n   +-----------+------------------------------------------------------------+\n   | Option    | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'<\'``   | Forces the field to be left-aligned within the available   |\n   |           | space (this is the default for most objects).              |\n   +-----------+------------------------------------------------------------+\n   | ``\'>\'``   | Forces the field to be right-aligned within the available  |\n   |           | space (this is the default for numbers).                   |\n   +-----------+------------------------------------------------------------+\n   | ``\'=\'``   | Forces the padding to be placed after the sign (if any)    |\n   |           | but before the digits.  This is used for printing fields   |\n   |           | in the form \'+000000120\'. This alignment option is only    |\n   |           | valid for numeric types.                                   |\n   +-----------+------------------------------------------------------------+\n   | ``\'^\'``   | Forces the field to be centered within the available       |\n   |           | space.                                                     |\n   +-----------+------------------------------------------------------------+\n\nNote that unless a minimum field width is defined, the field width\nwill always be the same size as the data to fill it, so that the\nalignment option has no meaning in this case.\n\nThe *sign* option is only valid for number types, and can be one of\nthe following:\n\n   +-----------+------------------------------------------------------------+\n   | Option    | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'+\'``   | indicates that a sign should be used for both positive as  |\n   |           | well as negative numbers.                                  |\n   +-----------+------------------------------------------------------------+\n   | ``\'-\'``   | indicates that a sign should be used only for negative     |\n   |           | numbers (this is the default behavior).                    |\n   +-----------+------------------------------------------------------------+\n   | space     | indicates that a leading space should be used on positive  |\n   |           | numbers, and a minus sign on negative numbers.             |\n   +-----------+------------------------------------------------------------+\n\nThe ``\'#\'`` option causes the "alternate form" to be used for the\nconversion.  The alternate form is defined differently for different\ntypes.  This option is only valid for integer, float, complex and\nDecimal types. For integers, when binary, octal, or hexadecimal output\nis used, this option adds the prefix respective ``\'0b\'``, ``\'0o\'``, or\n``\'0x\'`` to the output value. For floats, complex and Decimal the\nalternate form causes the result of the conversion to always contain a\ndecimal-point character, even if no digits follow it. Normally, a\ndecimal-point character appears in the result of these conversions\nonly if a digit follows it. In addition, for ``\'g\'`` and ``\'G\'``\nconversions, trailing zeros are not removed from the result.\n\nThe ``\',\'`` option signals the use of a comma for a thousands\nseparator. For a locale aware separator, use the ``\'n\'`` integer\npresentation type instead.\n\nChanged in version 3.1: Added the ``\',\'`` option (see also **PEP\n378**).\n\n*width* is a decimal integer defining the minimum field width.  If not\nspecified, then the field width will be determined by the content.\n\nPreceding the *width* field by a zero (``\'0\'``) character enables\nsign-aware zero-padding for numeric types.  This is equivalent to a\n*fill* character of ``\'0\'`` with an *alignment* type of ``\'=\'``.\n\nThe *precision* is a decimal number indicating how many digits should\nbe displayed after the decimal point for a floating point value\nformatted with ``\'f\'`` and ``\'F\'``, or before and after the decimal\npoint for a floating point value formatted with ``\'g\'`` or ``\'G\'``.\nFor non-number types the field indicates the maximum field size - in\nother words, how many characters will be used from the field content.\nThe *precision* is not allowed for integer values.\n\nFinally, the *type* determines how the data should be presented.\n\nThe available string presentation types are:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'s\'``   | String format. This is the default type for strings and    |\n   |           | may be omitted.                                            |\n   +-----------+------------------------------------------------------------+\n   | None      | The same as ``\'s\'``.                                       |\n   +-----------+------------------------------------------------------------+\n\nThe available integer presentation types are:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'b\'``   | Binary format. Outputs the number in base 2.               |\n   +-----------+------------------------------------------------------------+\n   | ``\'c\'``   | Character. Converts the integer to the corresponding       |\n   |           | unicode character before printing.                         |\n   +-----------+------------------------------------------------------------+\n   | ``\'d\'``   | Decimal Integer. Outputs the number in base 10.            |\n   +-----------+------------------------------------------------------------+\n   | ``\'o\'``   | Octal format. Outputs the number in base 8.                |\n   +-----------+------------------------------------------------------------+\n   | ``\'x\'``   | Hex format. Outputs the number in base 16, using lower-    |\n   |           | case letters for the digits above 9.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'X\'``   | Hex format. Outputs the number in base 16, using upper-    |\n   |           | case letters for the digits above 9.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'n\'``   | Number. This is the same as ``\'d\'``, except that it uses   |\n   |           | the current locale setting to insert the appropriate       |\n   |           | number separator characters.                               |\n   +-----------+------------------------------------------------------------+\n   | None      | The same as ``\'d\'``.                                       |\n   +-----------+------------------------------------------------------------+\n\nIn addition to the above presentation types, integers can be formatted\nwith the floating point presentation types listed below (except\n``\'n\'`` and None). When doing so, ``float()`` is used to convert the\ninteger to a floating point number before formatting.\n\nThe available presentation types for floating point and decimal values\nare:\n\n   +-----------+------------------------------------------------------------+\n   | Type      | Meaning                                                    |\n   +===========+============================================================+\n   | ``\'e\'``   | Exponent notation. Prints the number in scientific         |\n   |           | notation using the letter \'e\' to indicate the exponent.    |\n   +-----------+------------------------------------------------------------+\n   | ``\'E\'``   | Exponent notation. Same as ``\'e\'`` except it uses an upper |\n   |           | case \'E\' as the separator character.                       |\n   +-----------+------------------------------------------------------------+\n   | ``\'f\'``   | Fixed point. Displays the number as a fixed-point number.  |\n   +-----------+------------------------------------------------------------+\n   | ``\'F\'``   | Fixed point. Same as ``\'f\'``, but converts ``nan`` to      |\n   |           | ``NAN`` and ``inf`` to ``INF``.                            |\n   +-----------+------------------------------------------------------------+\n   | ``\'g\'``   | General format.  For a given precision ``p >= 1``, this    |\n   |           | rounds the number to ``p`` significant digits and then     |\n   |           | formats the result in either fixed-point format or in      |\n   |           | scientific notation, depending on its magnitude.  The      |\n   |           | precise rules are as follows: suppose that the result      |\n   |           | formatted with presentation type ``\'e\'`` and precision     |\n   |           | ``p-1`` would have exponent ``exp``.  Then if ``-4 <= exp  |\n   |           | < p``, the number is formatted with presentation type      |\n   |           | ``\'f\'`` and precision ``p-1-exp``. Otherwise, the number   |\n   |           | is formatted with presentation type ``\'e\'`` and precision  |\n   |           | ``p-1``. In both cases insignificant trailing zeros are    |\n   |           | removed from the significand, and the decimal point is     |\n   |           | also removed if there are no remaining digits following    |\n   |           | it.  Positive and negative infinity, positive and negative |\n   |           | zero, and nans, are formatted as ``inf``, ``-inf``, ``0``, |\n   |           | ``-0`` and ``nan`` respectively, regardless of the         |\n   |           | precision.  A precision of ``0`` is treated as equivalent  |\n   |           | to a precision of ``1``.                                   |\n   +-----------+------------------------------------------------------------+\n   | ``\'G\'``   | General format. Same as ``\'g\'`` except switches to ``\'E\'`` |\n   |           | if the number gets too large. The representations of       |\n   |           | infinity and NaN are uppercased, too.                      |\n   +-----------+------------------------------------------------------------+\n   | ``\'n\'``   | Number. This is the same as ``\'g\'``, except that it uses   |\n   |           | the current locale setting to insert the appropriate       |\n   |           | number separator characters.                               |\n   +-----------+------------------------------------------------------------+\n   | ``\'%\'``   | Percentage. Multiplies the number by 100 and displays in   |\n   |           | fixed (``\'f\'``) format, followed by a percent sign.        |\n   +-----------+------------------------------------------------------------+\n   | None      | Similar to ``\'g\'``, except with at least one digit past    |\n   |           | the decimal point and a default precision of 12. This is   |\n   |           | intended to match ``str()``, except you can add the other  |\n   |           | format modifiers.                                          |\n   +-----------+------------------------------------------------------------+\n\n\nFormat examples\n===============\n\nThis section contains examples of the new format syntax and comparison\nwith the old ``%``-formatting.\n\nIn most of the cases the syntax is similar to the old\n``%``-formatting, with the addition of the ``{}`` and with ``:`` used\ninstead of ``%``. For example, ``\'%03.2f\'`` can be translated to\n``\'{:03.2f}\'``.\n\nThe new format syntax also supports new and different options, shown\nin the follow examples.\n\nAccessing arguments by position:\n\n   >>> \'{0}, {1}, {2}\'.format(\'a\', \'b\', \'c\')\n   \'a, b, c\'\n   >>> \'{}, {}, {}\'.format(\'a\', \'b\', \'c\')  # 3.1+ only\n   \'a, b, c\'\n   >>> \'{2}, {1}, {0}\'.format(\'a\', \'b\', \'c\')\n   \'c, b, a\'\n   >>> \'{2}, {1}, {0}\'.format(*\'abc\')      # unpacking argument sequence\n   \'c, b, a\'\n   >>> \'{0}{1}{0}\'.format(\'abra\', \'cad\')   # arguments\' indices can be repeated\n   \'abracadabra\'\n\nAccessing arguments by name:\n\n   >>> \'Coordinates: {latitude}, {longitude}\'.format(latitude=\'37.24N\', longitude=\'-115.81W\')\n   \'Coordinates: 37.24N, -115.81W\'\n   >>> coord = {\'latitude\': \'37.24N\', \'longitude\': \'-115.81W\'}\n   >>> \'Coordinates: {latitude}, {longitude}\'.format(**coord)\n   \'Coordinates: 37.24N, -115.81W\'\n\nAccessing arguments\' attributes:\n\n   >>> c = 3-5j\n   >>> (\'The complex number {0} is formed from the real part {0.real} \'\n   ...  \'and the imaginary part {0.imag}.\').format(c)\n   \'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.\'\n   >>> class Point:\n   ...     def __init__(self, x, y):\n   ...         self.x, self.y = x, y\n   ...     def __str__(self):\n   ...         return \'Point({self.x}, {self.y})\'.format(self=self)\n   ...\n   >>> str(Point(4, 2))\n   \'Point(4, 2)\'\n\nAccessing arguments\' items:\n\n   >>> coord = (3, 5)\n   >>> \'X: {0[0]};  Y: {0[1]}\'.format(coord)\n   \'X: 3;  Y: 5\'\n\nReplacing ``%s`` and ``%r``:\n\n   >>> "repr() shows quotes: {!r}; str() doesn\'t: {!s}".format(\'test1\', \'test2\')\n   "repr() shows quotes: \'test1\'; str() doesn\'t: test2"\n\nAligning the text and specifying a width:\n\n   >>> \'{:<30}\'.format(\'left aligned\')\n   \'left aligned                  \'\n   >>> \'{:>30}\'.format(\'right aligned\')\n   \'                 right aligned\'\n   >>> \'{:^30}\'.format(\'centered\')\n   \'           centered           \'\n   >>> \'{:*^30}\'.format(\'centered\')  # use \'*\' as a fill char\n   \'***********centered***********\'\n\nReplacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign:\n\n   >>> \'{:+f}; {:+f}\'.format(3.14, -3.14)  # show it always\n   \'+3.140000; -3.140000\'\n   >>> \'{: f}; {: f}\'.format(3.14, -3.14)  # show a space for positive numbers\n   \' 3.140000; -3.140000\'\n   >>> \'{:-f}; {:-f}\'.format(3.14, -3.14)  # show only the minus -- same as \'{:f}; {:f}\'\n   \'3.140000; -3.140000\'\n\nReplacing ``%x`` and ``%o`` and converting the value to different\nbases:\n\n   >>> # format also supports binary numbers\n   >>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)\n   \'int: 42;  hex: 2a;  oct: 52;  bin: 101010\'\n   >>> # with 0x, 0o, or 0b as prefix:\n   >>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)\n   \'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010\'\n\nUsing the comma as a thousands separator:\n\n   >>> \'{:,}\'.format(1234567890)\n   \'1,234,567,890\'\n\nExpressing a percentage:\n\n   >>> points = 19\n   >>> total = 22\n   >>> \'Correct answers: {:.2%}\'.format(points/total)\n   \'Correct answers: 86.36%\'\n\nUsing type-specific formatting:\n\n   >>> import datetime\n   >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n   >>> \'{:%Y-%m-%d %H:%M:%S}\'.format(d)\n   \'2010-07-04 12:15:58\'\n\nNesting arguments and more complex examples:\n\n   >>> for align, text in zip(\'<^>\', [\'left\', \'center\', \'right\']):\n   ...     \'{0:{fill}{align}16}\'.format(text, fill=align, align=align)\n   ...\n   \'left<<<<<<<<<<<<\'\n   \'^^^^^center^^^^^\'\n   \'>>>>>>>>>>>right\'\n   >>>\n   >>> octets = [192, 168, 0, 1]\n   >>> \'{:02X}{:02X}{:02X}{:02X}\'.format(*octets)\n   \'C0A80001\'\n   >>> int(_, 16)\n   3232235521\n   >>>\n   >>> width = 5\n   >>> for num in range(5,12): #doctest: +NORMALIZE_WHITESPACE\n   ...     for base in \'dXob\':\n   ...         print(\'{0:{width}{base}}\'.format(num, base=base, width=width), end=\' \')\n   ...     print()\n   ...\n       5     5     5   101\n       6     6     6   110\n       7     7     7   111\n       8     8    10  1000\n       9     9    11  1001\n      10     A    12  1010\n      11     B    13  1011\n',
+ 'function': '\nFunction definitions\n********************\n\nA function definition defines a user-defined function object (see\nsection *The standard type hierarchy*):\n\n   funcdef        ::= [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite\n   decorators     ::= decorator+\n   decorator      ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE\n   dotted_name    ::= identifier ("." identifier)*\n   parameter_list ::= (defparameter ",")*\n                      ( "*" [parameter] ("," defparameter)* ["," "**" parameter]\n                      | "**" parameter\n                      | defparameter [","] )\n   parameter      ::= identifier [":" expression]\n   defparameter   ::= parameter ["=" expression]\n   funcname       ::= identifier\n\nA function definition is an executable statement.  Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function).  This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition.  The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object.  Multiple decorators are applied in\nnested fashion. For example, the following code\n\n   @f1(arg)\n   @f2\n   def func(): pass\n\nis equivalent to\n\n   def func(): pass\n   func = f1(arg)(f2(func))\n\nWhen one or more *parameters* have the form *parameter* ``=``\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted.  If a parameter has a default value, all following\nparameters up until the "``*``" must also have a default value ---\nthis is a syntactic restriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated when the function definition\nis executed.** This means that the expression is evaluated once, when\nthe function is defined, and that the same "pre-computed" value is\nused for each call.  This is especially important to understand when a\ndefault parameter is a mutable object, such as a list or a dictionary:\nif the function modifies the object (e.g. by appending an item to a\nlist), the default value is in effect modified. This is generally not\nwhat was intended.  A way around this is to use ``None`` as the\ndefault, and explicitly test for it in the body of the function, e.g.:\n\n   def whats_on_the_telly(penguin=None):\n       if penguin is None:\n           penguin = []\n       penguin.append("property of the zoo")\n       return penguin\n\nFunction call semantics are described in more detail in section\n*Calls*. A function call always assigns values to all parameters\nmentioned in the parameter list, either from position arguments, from\nkeyword arguments, or from default values.  If the form\n"``*identifier``" is present, it is initialized to a tuple receiving\nany excess positional parameters, defaulting to the empty tuple.  If\nthe form "``**identifier``" is present, it is initialized to a new\ndictionary receiving any excess keyword arguments, defaulting to a new\nempty dictionary. Parameters after "``*``" or "``*identifier``" are\nkeyword-only parameters and may only be passed used keyword arguments.\n\nParameters may have annotations of the form "``: expression``"\nfollowing the parameter name.  Any parameter may have an annotation\neven those of the form ``*identifier`` or ``**identifier``.  Functions\nmay have "return" annotation of the form "``-> expression``" after the\nparameter list.  These annotations can be any valid Python expression\nand are evaluated when the function definition is executed.\nAnnotations may be evaluated in a different order than they appear in\nthe source code.  The presence of annotations does not change the\nsemantics of a function.  The annotation values are available as\nvalues of a dictionary keyed by the parameters\' names in the\n``__annotations__`` attribute of the function object.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions.  This uses lambda forms,\ndescribed in section *Lambdas*.  Note that the lambda form is merely a\nshorthand for a simplified function definition; a function defined in\na "``def``" statement can be passed around or assigned to another name\njust like a function defined by a lambda form.  The "``def``" form is\nactually more powerful since it allows the execution of multiple\nstatements and annotations.\n\n**Programmer\'s note:** Functions are first-class objects.  A "``def``"\nform executed inside a function definition defines a local function\nthat can be returned or passed around.  Free variables used in the\nnested function can access the local variables of the function\ncontaining the def.  See section *Naming and binding* for details.\n\nSee also:\n\n   **PEP 3107** - Function Annotations\n      The original specification for function annotations.\n',
  'global': '\nThe ``global`` statement\n************************\n\n   global_stmt ::= "global" identifier ("," identifier)*\n\nThe ``global`` statement is a declaration which holds for the entire\ncurrent code block.  It means that the listed identifiers are to be\ninterpreted as globals.  It would be impossible to assign to a global\nvariable without ``global``, although free variables may refer to\nglobals without being declared global.\n\nNames listed in a ``global`` statement must not be used in the same\ncode block textually preceding that ``global`` statement.\n\nNames listed in a ``global`` statement must not be defined as formal\nparameters or in a ``for`` loop control target, ``class`` definition,\nfunction definition, or ``import`` statement.\n\n**CPython implementation detail:** The current implementation does not\nenforce the latter two restrictions, but programs should not abuse\nthis freedom, as future implementations may enforce them or silently\nchange the meaning of the program.\n\n**Programmer\'s note:** the ``global`` is a directive to the parser.\nIt applies only to code parsed at the same time as the ``global``\nstatement. In particular, a ``global`` statement contained in a string\nor code object supplied to the built-in ``exec()`` function does not\naffect the code block *containing* the function call, and code\ncontained in such a string is unaffected by ``global`` statements in\nthe code containing the function call.  The same applies to the\n``eval()`` and ``compile()`` functions.\n',
  'id-classes': '\nReserved classes of identifiers\n*******************************\n\nCertain classes of identifiers (besides keywords) have special\nmeanings.  These classes are identified by the patterns of leading and\ntrailing underscore characters:\n\n``_*``\n   Not imported by ``from module import *``.  The special identifier\n   ``_`` is used in the interactive interpreter to store the result of\n   the last evaluation; it is stored in the ``builtins`` module.  When\n   not in interactive mode, ``_`` has no special meaning and is not\n   defined. See section *The import statement*.\n\n   Note: The name ``_`` is often used in conjunction with\n     internationalization; refer to the documentation for the\n     ``gettext`` module for more information on this convention.\n\n``__*__``\n   System-defined names. These names are defined by the interpreter\n   and its implementation (including the standard library).  Current\n   system names are discussed in the *Special method names* section\n   and elsewhere.  More will likely be defined in future versions of\n   Python.  *Any* use of ``__*__`` names, in any context, that does\n   not follow explicitly documented use, is subject to breakage\n   without warning.\n\n``__*``\n   Class-private names.  Names in this category, when used within the\n   context of a class definition, are re-written to use a mangled form\n   to help avoid name clashes between "private" attributes of base and\n   derived classes. See section *Identifiers (Names)*.\n',
  'identifiers': '\nIdentifiers and keywords\n************************\n\nIdentifiers (also referred to as *names*) are described by the\nfollowing lexical definitions.\n\nThe syntax of identifiers in Python is based on the Unicode standard\nannex UAX-31, with elaboration and changes as defined below; see also\n**PEP 3131** for further details.\n\nWithin the ASCII range (U+0001..U+007F), the valid characters for\nidentifiers are the same as in Python 2.x: the uppercase and lowercase\nletters ``A`` through ``Z``, the underscore ``_`` and, except for the\nfirst character, the digits ``0`` through ``9``.\n\nPython 3.0 introduces additional characters from outside the ASCII\nrange (see **PEP 3131**).  For these characters, the classification\nuses the version of the Unicode Character Database as included in the\n``unicodedata`` module.\n\nIdentifiers are unlimited in length.  Case is significant.\n\n   identifier   ::= xid_start xid_continue*\n   id_start     ::= <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>\n   id_continue  ::= <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>\n   xid_start    ::= <all characters in id_start whose NFKC normalization is in "id_start xid_continue*">\n   xid_continue ::= <all characters in id_continue whose NFKC normalization is in "id_continue*">\n\nThe Unicode category codes mentioned above stand for:\n\n* *Lu* - uppercase letters\n\n* *Ll* - lowercase letters\n\n* *Lt* - titlecase letters\n\n* *Lm* - modifier letters\n\n* *Lo* - other letters\n\n* *Nl* - letter numbers\n\n* *Mn* - nonspacing marks\n\n* *Mc* - spacing combining marks\n\n* *Nd* - decimal numbers\n\n* *Pc* - connector punctuations\n\n* *Other_ID_Start* - explicit list of characters in PropList.txt to\n  support backwards compatibility\n\n* *Other_ID_Continue* - likewise\n\nAll identifiers are converted into the normal form NFKC while parsing;\ncomparison of identifiers is based on NFKC.\n\nA non-normative HTML file listing all valid identifier characters for\nUnicode 4.1 can be found at http://www.dcl.hpi.uni-\npotsdam.de/home/loewis/table-3131.html.\n\n\nKeywords\n========\n\nThe following identifiers are used as reserved words, or *keywords* of\nthe language, and cannot be used as ordinary identifiers.  They must\nbe spelled exactly as written here:\n\n   False      class      finally    is         return\n   None       continue   for        lambda     try\n   True       def        from       nonlocal   while\n   and        del        global     not        with\n   as         elif       if         or         yield\n   assert     else       import     pass\n   break      except     in         raise\n\n\nReserved classes of identifiers\n===============================\n\nCertain classes of identifiers (besides keywords) have special\nmeanings.  These classes are identified by the patterns of leading and\ntrailing underscore characters:\n\n``_*``\n   Not imported by ``from module import *``.  The special identifier\n   ``_`` is used in the interactive interpreter to store the result of\n   the last evaluation; it is stored in the ``builtins`` module.  When\n   not in interactive mode, ``_`` has no special meaning and is not\n   defined. See section *The import statement*.\n\n   Note: The name ``_`` is often used in conjunction with\n     internationalization; refer to the documentation for the\n     ``gettext`` module for more information on this convention.\n\n``__*__``\n   System-defined names. These names are defined by the interpreter\n   and its implementation (including the standard library).  Current\n   system names are discussed in the *Special method names* section\n   and elsewhere.  More will likely be defined in future versions of\n   Python.  *Any* use of ``__*__`` names, in any context, that does\n   not follow explicitly documented use, is subject to breakage\n   without warning.\n\n``__*``\n   Class-private names.  Names in this category, when used within the\n   context of a class definition, are re-written to use a mangled form\n   to help avoid name clashes between "private" attributes of base and\n   derived classes. See section *Identifiers (Names)*.\n',
  'if': '\nThe ``if`` statement\n********************\n\nThe ``if`` statement is used for conditional execution:\n\n   if_stmt ::= "if" expression ":" suite\n               ( "elif" expression ":" suite )*\n               ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section *Boolean operations*\nfor the definition of true and false); then that suite is executed\n(and no other part of the ``if`` statement is executed or evaluated).\nIf all expressions are false, the suite of the ``else`` clause, if\npresent, is executed.\n',
  'imaginary': '\nImaginary literals\n******************\n\nImaginary literals are described by the following lexical definitions:\n\n   imagnumber ::= (floatnumber | intpart) ("j" | "J")\n\nAn imaginary literal yields a complex number with a real part of 0.0.\nComplex numbers are represented as a pair of floating point numbers\nand have the same restrictions on their range.  To create a complex\nnumber with a nonzero real part, add a floating point number to it,\ne.g., ``(3+4j)``.  Some examples of imaginary literals:\n\n   3.14j   10.j    10j     .001j   1e100j  3.14e-10j\n',
- 'import': '\nThe ``import`` statement\n************************\n\n   import_stmt     ::= "import" module ["as" name] ( "," module ["as" name] )*\n                   | "from" relative_module "import" identifier ["as" name]\n                   ( "," identifier ["as" name] )*\n                   | "from" relative_module "import" "(" identifier ["as" name]\n                   ( "," identifier ["as" name] )* [","] ")"\n                   | "from" module "import" "*"\n   module          ::= (identifier ".")* identifier\n   relative_module ::= "."* module | "."+\n   name            ::= identifier\n\nThe basic import statement (no ``from`` clause) is executed in two\nsteps:\n\n1. find a module, loading and initializing it if necessary\n\n2. define a name or names in the local namespace for the scope where\n   the ``import`` statement occurs.\n\nWhen the statement contains multiple clauses (separated by commas) the\ntwo steps are carried out separately for each clause, just as though\nthe clauses had been separated out into individiual import statements.\n\nThe details of the first step, finding and loading modules is\ndescribed in greater detail in the section on the *import system*,\nwhich also describes the various types of packages and modules that\ncan be imported, as well as all the hooks that can be used to\ncustomize the import system. Note that failures in this step may\nindicate either that the module could not be located, *or* that an\nerror occurred while initializing the module, which includes execution\nof the module\'s code.\n\nIf the requested module is retrieved successfully, it will be made\navailable in the local namespace in one of three ways:\n\n* If the module name is followed by ``as``, then the name following\n  ``as`` is bound directly to the imported module.\n\n* If no other name is specified, and the module being imported is a\n  top level module, the module\'s name is bound in the local namespace\n  as a reference to the imported module\n\n* If the module being imported is *not* a top level module, then the\n  name of the top level package that contains the module is bound in\n  the local namespace as a reference to the top level package. The\n  imported module must be accessed using its full qualified name\n  rather than directly\n\nThe ``from`` form uses a slightly more complex process:\n\n1. find the module specified in the ``from`` clause loading and\n   initializing it if necessary;\n\n2. for each of the identifiers specified in the ``import`` clauses:\n\n   1. check if the imported module has an attribute by that name\n\n   2. if not, attempt to import a submodule with that name and then\n      check the imported module again for that attribute\n\n   3. if the attribute is not found, ``ImportError`` is raised.\n\n   4. otherwise, a reference to that value is bound in the local\n      namespace, using the name in the ``as`` clause if it is present,\n      otherwise using the attribute name\n\nExamples:\n\n   import foo                 # foo imported and bound locally\n   import foo.bar.baz         # foo.bar.baz imported, foo bound locally\n   import foo.bar.baz as fbb  # foo.bar.baz imported and bound as fbb\n   from foo.bar import baz    # foo.bar.baz imported and bound as baz\n   from foo import attr       # foo imported and foo.attr bound as attr\n\nIf the list of identifiers is replaced by a star (``\'*\'``), all public\nnames defined in the module are bound in the local namespace for the\nscope where the ``import`` statement occurs.\n\nThe *public names* defined by a module are determined by checking the\nmodule\'s namespace for a variable named ``__all__``; if defined, it\nmust be a sequence of strings which are names defined or imported by\nthat module.  The names given in ``__all__`` are all considered public\nand are required to exist.  If ``__all__`` is not defined, the set of\npublic names includes all names found in the module\'s namespace which\ndo not begin with an underscore character (``\'_\'``).  ``__all__``\nshould contain the entire public API. It is intended to avoid\naccidentally exporting items that are not part of the API (such as\nlibrary modules which were imported and used within the module).\n\nThe ``from`` form with ``*`` may only occur in a module scope.  The\nwild card form of import --- ``import *`` --- is only allowed at the\nmodule level. Attempting to use it in class or function definitions\nwill raise a ``SyntaxError``.\n\nWhen specifying what module to import you do not have to specify the\nabsolute name of the module. When a module or package is contained\nwithin another package it is possible to make a relative import within\nthe same top package without having to mention the package name. By\nusing leading dots in the specified module or package after ``from``\nyou can specify how high to traverse up the current package hierarchy\nwithout specifying exact names. One leading dot means the current\npackage where the module making the import exists. Two dots means up\none package level. Three dots is up two levels, etc. So if you execute\n``from . import mod`` from a module in the ``pkg`` package then you\nwill end up importing ``pkg.mod``. If you execute ``from ..subpkg2\nimport mod`` from within ``pkg.subpkg1`` you will import\n``pkg.subpkg2.mod``. The specification for relative imports is\ncontained within **PEP 328**.\n\n``importlib.import_module()`` is provided to support applications that\ndetermine which modules need to be loaded dynamically.\n\n\nFuture statements\n=================\n\nA *future statement* is a directive to the compiler that a particular\nmodule should be compiled using syntax or semantics that will be\navailable in a specified future release of Python.  The future\nstatement is intended to ease migration to future versions of Python\nthat introduce incompatible changes to the language.  It allows use of\nthe new features on a per-module basis before the release in which the\nfeature becomes standard.\n\n   future_statement ::= "from" "__future__" "import" feature ["as" name]\n                        ("," feature ["as" name])*\n                        | "from" "__future__" "import" "(" feature ["as" name]\n                        ("," feature ["as" name])* [","] ")"\n   feature          ::= identifier\n   name             ::= identifier\n\nA future statement must appear near the top of the module.  The only\nlines that can appear before a future statement are:\n\n* the module docstring (if any),\n\n* comments,\n\n* blank lines, and\n\n* other future statements.\n\nThe features recognized by Python 3.0 are ``absolute_import``,\n``division``, ``generators``, ``unicode_literals``,\n``print_function``, ``nested_scopes`` and ``with_statement``.  They\nare all redundant because they are always enabled, and only kept for\nbackwards compatibility.\n\nA future statement is recognized and treated specially at compile\ntime: Changes to the semantics of core constructs are often\nimplemented by generating different code.  It may even be the case\nthat a new feature introduces new incompatible syntax (such as a new\nreserved word), in which case the compiler may need to parse the\nmodule differently.  Such decisions cannot be pushed off until\nruntime.\n\nFor any given release, the compiler knows which feature names have\nbeen defined, and raises a compile-time error if a future statement\ncontains a feature not known to it.\n\nThe direct runtime semantics are the same as for any import statement:\nthere is a standard module ``__future__``, described later, and it\nwill be imported in the usual way at the time the future statement is\nexecuted.\n\nThe interesting runtime semantics depend on the specific feature\nenabled by the future statement.\n\nNote that there is nothing special about the statement:\n\n   import __future__ [as name]\n\nThat is not a future statement; it\'s an ordinary import statement with\nno special semantics or syntax restrictions.\n\nCode compiled by calls to the built-in functions ``exec()`` and\n``compile()`` that occur in a module ``M`` containing a future\nstatement will, by default, use the new syntax or semantics associated\nwith the future statement.  This can be controlled by optional\narguments to ``compile()`` --- see the documentation of that function\nfor details.\n\nA future statement typed at an interactive interpreter prompt will\ntake effect for the rest of the interpreter session.  If an\ninterpreter is started with the *-i* option, is passed a script name\nto execute, and the script includes a future statement, it will be in\neffect in the interactive session started after the script is\nexecuted.\n\nSee also:\n\n   **PEP 236** - Back to the __future__\n      The original proposal for the __future__ mechanism.\n',
+ 'import': '\nThe ``import`` statement\n************************\n\n   import_stmt     ::= "import" module ["as" name] ( "," module ["as" name] )*\n                   | "from" relative_module "import" identifier ["as" name]\n                   ( "," identifier ["as" name] )*\n                   | "from" relative_module "import" "(" identifier ["as" name]\n                   ( "," identifier ["as" name] )* [","] ")"\n                   | "from" module "import" "*"\n   module          ::= (identifier ".")* identifier\n   relative_module ::= "."* module | "."+\n   name            ::= identifier\n\nThe basic import statement (no ``from`` clause) is executed in two\nsteps:\n\n1. find a module, loading and initializing it if necessary\n\n2. define a name or names in the local namespace for the scope where\n   the ``import`` statement occurs.\n\nWhen the statement contains multiple clauses (separated by commas) the\ntwo steps are carried out separately for each clause, just as though\nthe clauses had been separated out into individiual import statements.\n\nThe details of the first step, finding and loading modules is\ndescribed in greater detail in the section on the *import system*,\nwhich also describes the various types of packages and modules that\ncan be imported, as well as all the hooks that can be used to\ncustomize the import system. Note that failures in this step may\nindicate either that the module could not be located, *or* that an\nerror occurred while initializing the module, which includes execution\nof the module\'s code.\n\nIf the requested module is retrieved successfully, it will be made\navailable in the local namespace in one of three ways:\n\n* If the module name is followed by ``as``, then the name following\n  ``as`` is bound directly to the imported module.\n\n* If no other name is specified, and the module being imported is a\n  top level module, the module\'s name is bound in the local namespace\n  as a reference to the imported module\n\n* If the module being imported is *not* a top level module, then the\n  name of the top level package that contains the module is bound in\n  the local namespace as a reference to the top level package. The\n  imported module must be accessed using its full qualified name\n  rather than directly\n\nThe ``from`` form uses a slightly more complex process:\n\n1. find the module specified in the ``from`` clause loading and\n   initializing it if necessary;\n\n2. for each of the identifiers specified in the ``import`` clauses:\n\n   1. check if the imported module has an attribute by that name\n\n   2. if not, attempt to import a submodule with that name and then\n      check the imported module again for that attribute\n\n   3. if the attribute is not found, ``ImportError`` is raised.\n\n   4. otherwise, a reference to that value is bound in the local\n      namespace, using the name in the ``as`` clause if it is present,\n      otherwise using the attribute name\n\nExamples:\n\n   import foo                 # foo imported and bound locally\n   import foo.bar.baz         # foo.bar.baz imported, foo bound locally\n   import foo.bar.baz as fbb  # foo.bar.baz imported and bound as fbb\n   from foo.bar import baz    # foo.bar.baz imported and bound as baz\n   from foo import attr       # foo imported and foo.attr bound as attr\n\nIf the list of identifiers is replaced by a star (``\'*\'``), all public\nnames defined in the module are bound in the local namespace for the\nscope where the ``import`` statement occurs.\n\nThe *public names* defined by a module are determined by checking the\nmodule\'s namespace for a variable named ``__all__``; if defined, it\nmust be a sequence of strings which are names defined or imported by\nthat module.  The names given in ``__all__`` are all considered public\nand are required to exist.  If ``__all__`` is not defined, the set of\npublic names includes all names found in the module\'s namespace which\ndo not begin with an underscore character (``\'_\'``).  ``__all__``\nshould contain the entire public API. It is intended to avoid\naccidentally exporting items that are not part of the API (such as\nlibrary modules which were imported and used within the module).\n\nThe ``from`` form with ``*`` may only occur in a module scope.\nAttempting to use it in class or function definitions will raise a\n``SyntaxError``.\n\nThe *public names* defined by a module are determined by checking the\nmodule\'s namespace for a variable named ``__all__``; if defined, it\nmust be a sequence of strings which are names defined or imported by\nthat module.  The names given in ``__all__`` are all considered public\nand are required to exist.  If ``__all__`` is not defined, the set of\npublic names includes all names found in the module\'s namespace which\ndo not begin with an underscore character (``\'_\'``).  ``__all__``\nshould contain the entire public API. It is intended to avoid\naccidentally exporting items that are not part of the API (such as\nlibrary modules which were imported and used within the module).\n\nThe ``from`` form with ``*`` may only occur in a module scope.  The\nwild card form of import --- ``import *`` --- is only allowed at the\nmodule level. Attempting to use it in class or function definitions\nwill raise a ``SyntaxError``.\n\nWhen specifying what module to import you do not have to specify the\nabsolute name of the module. When a module or package is contained\nwithin another package it is possible to make a relative import within\nthe same top package without having to mention the package name. By\nusing leading dots in the specified module or package after ``from``\nyou can specify how high to traverse up the current package hierarchy\nwithout specifying exact names. One leading dot means the current\npackage where the module making the import exists. Two dots means up\none package level. Three dots is up two levels, etc. So if you execute\n``from . import mod`` from a module in the ``pkg`` package then you\nwill end up importing ``pkg.mod``. If you execute ``from ..subpkg2\nimport mod`` from within ``pkg.subpkg1`` you will import\n``pkg.subpkg2.mod``. The specification for relative imports is\ncontained within **PEP 328**.\n\n``importlib.import_module()`` is provided to support applications that\ndetermine which modules need to be loaded dynamically.\n\n\nFuture statements\n=================\n\nA *future statement* is a directive to the compiler that a particular\nmodule should be compiled using syntax or semantics that will be\navailable in a specified future release of Python.  The future\nstatement is intended to ease migration to future versions of Python\nthat introduce incompatible changes to the language.  It allows use of\nthe new features on a per-module basis before the release in which the\nfeature becomes standard.\n\n   future_statement ::= "from" "__future__" "import" feature ["as" name]\n                        ("," feature ["as" name])*\n                        | "from" "__future__" "import" "(" feature ["as" name]\n                        ("," feature ["as" name])* [","] ")"\n   feature          ::= identifier\n   name             ::= identifier\n\nA future statement must appear near the top of the module.  The only\nlines that can appear before a future statement are:\n\n* the module docstring (if any),\n\n* comments,\n\n* blank lines, and\n\n* other future statements.\n\nThe features recognized by Python 3.0 are ``absolute_import``,\n``division``, ``generators``, ``unicode_literals``,\n``print_function``, ``nested_scopes`` and ``with_statement``.  They\nare all redundant because they are always enabled, and only kept for\nbackwards compatibility.\n\nA future statement is recognized and treated specially at compile\ntime: Changes to the semantics of core constructs are often\nimplemented by generating different code.  It may even be the case\nthat a new feature introduces new incompatible syntax (such as a new\nreserved word), in which case the compiler may need to parse the\nmodule differently.  Such decisions cannot be pushed off until\nruntime.\n\nFor any given release, the compiler knows which feature names have\nbeen defined, and raises a compile-time error if a future statement\ncontains a feature not known to it.\n\nThe direct runtime semantics are the same as for any import statement:\nthere is a standard module ``__future__``, described later, and it\nwill be imported in the usual way at the time the future statement is\nexecuted.\n\nThe interesting runtime semantics depend on the specific feature\nenabled by the future statement.\n\nNote that there is nothing special about the statement:\n\n   import __future__ [as name]\n\nThat is not a future statement; it\'s an ordinary import statement with\nno special semantics or syntax restrictions.\n\nCode compiled by calls to the built-in functions ``exec()`` and\n``compile()`` that occur in a module ``M`` containing a future\nstatement will, by default, use the new syntax or semantics associated\nwith the future statement.  This can be controlled by optional\narguments to ``compile()`` --- see the documentation of that function\nfor details.\n\nA future statement typed at an interactive interpreter prompt will\ntake effect for the rest of the interpreter session.  If an\ninterpreter is started with the *-i* option, is passed a script name\nto execute, and the script includes a future statement, it will be in\neffect in the interactive session started after the script is\nexecuted.\n\nSee also:\n\n   **PEP 236** - Back to the __future__\n      The original proposal for the __future__ mechanism.\n',
  'in': '\nComparisons\n***********\n\nUnlike C, all comparison operations in Python have the same priority,\nwhich is lower than that of any arithmetic, shifting or bitwise\noperation.  Also unlike C, expressions like ``a < b < c`` have the\ninterpretation that is conventional in mathematics:\n\n   comparison    ::= or_expr ( comp_operator or_expr )*\n   comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="\n                     | "is" ["not"] | ["not"] "in"\n\nComparisons yield boolean values: ``True`` or ``False``.\n\nComparisons can be chained arbitrarily, e.g., ``x < y <= z`` is\nequivalent to ``x < y and y <= z``, except that ``y`` is evaluated\nonly once (but in both cases ``z`` is not evaluated at all when ``x <\ny`` is found to be false).\n\nFormally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*,\n*op2*, ..., *opN* are comparison operators, then ``a op1 b op2 c ... y\nopN z`` is equivalent to ``a op1 b and b op2 c and ... y opN z``,\nexcept that each expression is evaluated at most once.\n\nNote that ``a op1 b op2 c`` doesn\'t imply any kind of comparison\nbetween *a* and *c*, so that, e.g., ``x < y > z`` is perfectly legal\n(though perhaps not pretty).\n\nThe operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare\nthe values of two objects.  The objects need not have the same type.\nIf both are numbers, they are converted to a common type.  Otherwise,\nthe ``==`` and ``!=`` operators *always* consider objects of different\ntypes to be unequal, while the ``<``, ``>``, ``>=`` and ``<=``\noperators raise a ``TypeError`` when comparing objects of different\ntypes that do not implement these operators for the given pair of\ntypes.  You can control comparison behavior of objects of non-built-in\ntypes by defining rich comparison methods like ``__gt__()``, described\nin section *Basic customization*.\n\nComparison of objects of the same type depends on the type:\n\n* Numbers are compared arithmetically.\n\n* The values ``float(\'NaN\')`` and ``Decimal(\'NaN\')`` are special. The\n  are identical to themselves, ``x is x`` but are not equal to\n  themselves, ``x != x``.  Additionally, comparing any value to a\n  not-a-number value will return ``False``.  For example, both ``3 <\n  float(\'NaN\')`` and ``float(\'NaN\') < 3`` will return ``False``.\n\n* Bytes objects are compared lexicographically using the numeric\n  values of their elements.\n\n* Strings are compared lexicographically using the numeric equivalents\n  (the result of the built-in function ``ord()``) of their characters.\n  [3] String and bytes object can\'t be compared!\n\n* Tuples and lists are compared lexicographically using comparison of\n  corresponding elements.  This means that to compare equal, each\n  element must compare equal and the two sequences must be of the same\n  type and have the same length.\n\n  If not equal, the sequences are ordered the same as their first\n  differing elements.  For example, ``[1,2,x] <= [1,2,y]`` has the\n  same value as ``x <= y``.  If the corresponding element does not\n  exist, the shorter sequence is ordered first (for example, ``[1,2] <\n  [1,2,3]``).\n\n* Mappings (dictionaries) compare equal if and only if they have the\n  same ``(key, value)`` pairs. Order comparisons ``(\'<\', \'<=\', \'>=\',\n  \'>\')`` raise ``TypeError``.\n\n* Sets and frozensets define comparison operators to mean subset and\n  superset tests.  Those relations do not define total orderings (the\n  two sets ``{1,2}`` and {2,3} are not equal, nor subsets of one\n  another, nor supersets of one another).  Accordingly, sets are not\n  appropriate arguments for functions which depend on total ordering.\n  For example, ``min()``, ``max()``, and ``sorted()`` produce\n  undefined results given a list of sets as inputs.\n\n* Most other objects of built-in types compare unequal unless they are\n  the same object; the choice whether one object is considered smaller\n  or larger than another one is made arbitrarily but consistently\n  within one execution of a program.\n\nComparison of objects of the differing types depends on whether either\nof the types provide explicit support for the comparison.  Most\nnumeric types can be compared with one another.  When cross-type\ncomparison is not supported, the comparison method returns\n``NotImplemented``.\n\nThe operators ``in`` and ``not in`` test for membership.  ``x in s``\nevaluates to true if *x* is a member of *s*, and false otherwise.  ``x\nnot in s`` returns the negation of ``x in s``.  All built-in sequences\nand set types support this as well as dictionary, for which ``in``\ntests whether a the dictionary has a given key. For container types\nsuch as list, tuple, set, frozenset, dict, or collections.deque, the\nexpression ``x in y`` is equivalent to ``any(x is e or x == e for e in\ny)``.\n\nFor the string and bytes types, ``x in y`` is true if and only if *x*\nis a substring of *y*.  An equivalent test is ``y.find(x) != -1``.\nEmpty strings are always considered to be a substring of any other\nstring, so ``"" in "abc"`` will return ``True``.\n\nFor user-defined classes which define the ``__contains__()`` method,\n``x in y`` is true if and only if ``y.__contains__(x)`` is true.\n\nFor user-defined classes which do not define ``__contains__()`` but do\ndefine ``__iter__()``, ``x in y`` is true if some value ``z`` with ``x\n== z`` is produced while iterating over ``y``.  If an exception is\nraised during the iteration, it is as if ``in`` raised that exception.\n\nLastly, the old-style iteration protocol is tried: if a class defines\n``__getitem__()``, ``x in y`` is true if and only if there is a non-\nnegative integer index *i* such that ``x == y[i]``, and all lower\ninteger indices do not raise ``IndexError`` exception.  (If any other\nexception is raised, it is as if ``in`` raised that exception).\n\nThe operator ``not in`` is defined to have the inverse true value of\n``in``.\n\nThe operators ``is`` and ``is not`` test for object identity: ``x is\ny`` is true if and only if *x* and *y* are the same object.  ``x is\nnot y`` yields the inverse truth value. [4]\n',
  'integers': '\nInteger literals\n****************\n\nInteger literals are described by the following lexical definitions:\n\n   integer        ::= decimalinteger | octinteger | hexinteger | bininteger\n   decimalinteger ::= nonzerodigit digit* | "0"+\n   nonzerodigit   ::= "1"..."9"\n   digit          ::= "0"..."9"\n   octinteger     ::= "0" ("o" | "O") octdigit+\n   hexinteger     ::= "0" ("x" | "X") hexdigit+\n   bininteger     ::= "0" ("b" | "B") bindigit+\n   octdigit       ::= "0"..."7"\n   hexdigit       ::= digit | "a"..."f" | "A"..."F"\n   bindigit       ::= "0" | "1"\n\nThere is no limit for the length of integer literals apart from what\ncan be stored in available memory.\n\nNote that leading zeros in a non-zero decimal number are not allowed.\nThis is for disambiguation with C-style octal literals, which Python\nused before version 3.0.\n\nSome examples of integer literals:\n\n   7     2147483647                        0o177    0b100110111\n   3     79228162514264337593543950336     0o377    0x100000000\n         79228162514264337593543950336              0xdeadbeef\n',
  'lambda': '\nLambdas\n*******\n\n   lambda_form        ::= "lambda" [parameter_list]: expression\n   lambda_form_nocond ::= "lambda" [parameter_list]: expression_nocond\n\nLambda forms (lambda expressions) have the same syntactic position as\nexpressions.  They are a shorthand to create anonymous functions; the\nexpression ``lambda arguments: expression`` yields a function object.\nThe unnamed object behaves like a function object defined with\n\n   def <lambda>(arguments):\n       return expression\n\nSee section *Function definitions* for the syntax of parameter lists.\nNote that functions created with lambda forms cannot contain\nstatements or annotations.\n',
@@ -51,17 +51,17 @@
  'numbers': "\nNumeric literals\n****************\n\nThere are three types of numeric literals: integers, floating point\nnumbers, and imaginary numbers.  There are no complex literals\n(complex numbers can be formed by adding a real number and an\nimaginary number).\n\nNote that numeric literals do not include a sign; a phrase like ``-1``\nis actually an expression composed of the unary operator '``-``' and\nthe literal ``1``.\n",
  'numeric-types': "\nEmulating numeric types\n***********************\n\nThe following methods can be defined to emulate numeric objects.\nMethods corresponding to operations that are not supported by the\nparticular kind of number implemented (e.g., bitwise operations for\nnon-integral numbers) should be left undefined.\n\nobject.__add__(self, other)\nobject.__sub__(self, other)\nobject.__mul__(self, other)\nobject.__truediv__(self, other)\nobject.__floordiv__(self, other)\nobject.__mod__(self, other)\nobject.__divmod__(self, other)\nobject.__pow__(self, other[, modulo])\nobject.__lshift__(self, other)\nobject.__rshift__(self, other)\nobject.__and__(self, other)\nobject.__xor__(self, other)\nobject.__or__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``).  For instance, to evaluate the expression ``x + y``, where\n   *x* is an instance of a class that has an ``__add__()`` method,\n   ``x.__add__(y)`` is called.  The ``__divmod__()`` method should be\n   the equivalent to using ``__floordiv__()`` and ``__mod__()``; it\n   should not be related to ``__truediv__()``.  Note that\n   ``__pow__()`` should be defined to accept an optional third\n   argument if the ternary version of the built-in ``pow()`` function\n   is to be supported.\n\n   If one of those methods does not support the operation with the\n   supplied arguments, it should return ``NotImplemented``.\n\nobject.__radd__(self, other)\nobject.__rsub__(self, other)\nobject.__rmul__(self, other)\nobject.__rtruediv__(self, other)\nobject.__rfloordiv__(self, other)\nobject.__rmod__(self, other)\nobject.__rdivmod__(self, other)\nobject.__rpow__(self, other)\nobject.__rlshift__(self, other)\nobject.__rrshift__(self, other)\nobject.__rand__(self, other)\nobject.__rxor__(self, other)\nobject.__ror__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``) with reflected (swapped) operands. These functions are only\n   called if the left operand does not support the corresponding\n   operation and the operands are of different types. [2]  For\n   instance, to evaluate the expression ``x - y``, where *y* is an\n   instance of a class that has an ``__rsub__()`` method,\n   ``y.__rsub__(x)`` is called if ``x.__sub__(y)`` returns\n   *NotImplemented*.\n\n   Note that ternary ``pow()`` will not try calling ``__rpow__()``\n   (the coercion rules would become too complicated).\n\n   Note: If the right operand's type is a subclass of the left operand's\n     type and that subclass provides the reflected method for the\n     operation, this method will be called before the left operand's\n     non-reflected method.  This behavior allows subclasses to\n     override their ancestors' operations.\n\nobject.__iadd__(self, other)\nobject.__isub__(self, other)\nobject.__imul__(self, other)\nobject.__itruediv__(self, other)\nobject.__ifloordiv__(self, other)\nobject.__imod__(self, other)\nobject.__ipow__(self, other[, modulo])\nobject.__ilshift__(self, other)\nobject.__irshift__(self, other)\nobject.__iand__(self, other)\nobject.__ixor__(self, other)\nobject.__ior__(self, other)\n\n   These methods are called to implement the augmented arithmetic\n   assignments (``+=``, ``-=``, ``*=``, ``/=``, ``//=``, ``%=``,\n   ``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``).  These methods\n   should attempt to do the operation in-place (modifying *self*) and\n   return the result (which could be, but does not have to be,\n   *self*).  If a specific method is not defined, the augmented\n   assignment falls back to the normal methods.  For instance, to\n   execute the statement ``x += y``, where *x* is an instance of a\n   class that has an ``__iadd__()`` method, ``x.__iadd__(y)`` is\n   called.  If *x* is an instance of a class that does not define a\n   ``__iadd__()`` method, ``x.__add__(y)`` and ``y.__radd__(x)`` are\n   considered, as with the evaluation of ``x + y``.\n\nobject.__neg__(self)\nobject.__pos__(self)\nobject.__abs__(self)\nobject.__invert__(self)\n\n   Called to implement the unary arithmetic operations (``-``, ``+``,\n   ``abs()`` and ``~``).\n\nobject.__complex__(self)\nobject.__int__(self)\nobject.__float__(self)\nobject.__round__(self[, n])\n\n   Called to implement the built-in functions ``complex()``,\n   ``int()``, ``float()`` and ``round()``.  Should return a value of\n   the appropriate type.\n\nobject.__index__(self)\n\n   Called to implement ``operator.index()``.  Also called whenever\n   Python needs an integer object (such as in slicing, or in the\n   built-in ``bin()``, ``hex()`` and ``oct()`` functions). Must return\n   an integer.\n",
  'objects': '\nObjects, values and types\n*************************\n\n*Objects* are Python\'s abstraction for data.  All data in a Python\nprogram is represented by objects or by relations between objects. (In\na sense, and in conformance to Von Neumann\'s model of a "stored\nprogram computer," code is also represented by objects.)\n\nEvery object has an identity, a type and a value.  An object\'s\n*identity* never changes once it has been created; you may think of it\nas the object\'s address in memory.  The \'``is``\' operator compares the\nidentity of two objects; the ``id()`` function returns an integer\nrepresenting its identity.\n\n**CPython implementation detail:** For CPython, ``id(x)`` is the\nmemory address where ``x`` is stored.\n\nAn object\'s type determines the operations that the object supports\n(e.g., "does it have a length?") and also defines the possible values\nfor objects of that type.  The ``type()`` function returns an object\'s\ntype (which is an object itself).  Like its identity, an object\'s\n*type* is also unchangeable. [1]\n\nThe *value* of some objects can change.  Objects whose value can\nchange are said to be *mutable*; objects whose value is unchangeable\nonce they are created are called *immutable*. (The value of an\nimmutable container object that contains a reference to a mutable\nobject can change when the latter\'s value is changed; however the\ncontainer is still considered immutable, because the collection of\nobjects it contains cannot be changed.  So, immutability is not\nstrictly the same as having an unchangeable value, it is more subtle.)\nAn object\'s mutability is determined by its type; for instance,\nnumbers, strings and tuples are immutable, while dictionaries and\nlists are mutable.\n\nObjects are never explicitly destroyed; however, when they become\nunreachable they may be garbage-collected.  An implementation is\nallowed to postpone garbage collection or omit it altogether --- it is\na matter of implementation quality how garbage collection is\nimplemented, as long as no objects are collected that are still\nreachable.\n\n**CPython implementation detail:** CPython currently uses a reference-\ncounting scheme with (optional) delayed detection of cyclically linked\ngarbage, which collects most objects as soon as they become\nunreachable, but is not guaranteed to collect garbage containing\ncircular references.  See the documentation of the ``gc`` module for\ninformation on controlling the collection of cyclic garbage. Other\nimplementations act differently and CPython may change. Do not depend\non immediate finalization of objects when they become unreachable (ex:\nalways close files).\n\nNote that the use of the implementation\'s tracing or debugging\nfacilities may keep objects alive that would normally be collectable.\nAlso note that catching an exception with a \'``try``...``except``\'\nstatement may keep objects alive.\n\nSome objects contain references to "external" resources such as open\nfiles or windows.  It is understood that these resources are freed\nwhen the object is garbage-collected, but since garbage collection is\nnot guaranteed to happen, such objects also provide an explicit way to\nrelease the external resource, usually a ``close()`` method. Programs\nare strongly recommended to explicitly close such objects.  The\n\'``try``...``finally``\' statement and the \'``with``\' statement provide\nconvenient ways to do this.\n\nSome objects contain references to other objects; these are called\n*containers*. Examples of containers are tuples, lists and\ndictionaries.  The references are part of a container\'s value.  In\nmost cases, when we talk about the value of a container, we imply the\nvalues, not the identities of the contained objects; however, when we\ntalk about the mutability of a container, only the identities of the\nimmediately contained objects are implied.  So, if an immutable\ncontainer (like a tuple) contains a reference to a mutable object, its\nvalue changes if that mutable object is changed.\n\nTypes affect almost all aspects of object behavior.  Even the\nimportance of object identity is affected in some sense: for immutable\ntypes, operations that compute new values may actually return a\nreference to any existing object with the same type and value, while\nfor mutable objects this is not allowed.  E.g., after ``a = 1; b =\n1``, ``a`` and ``b`` may or may not refer to the same object with the\nvalue one, depending on the implementation, but after ``c = []; d =\n[]``, ``c`` and ``d`` are guaranteed to refer to two different,\nunique, newly created empty lists. (Note that ``c = d = []`` assigns\nthe same object to both ``c`` and ``d``.)\n',
- 'operator-summary': '\nOperator precedence\n*******************\n\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding).  Operators in the same box have the same precedence.  Unless\nthe syntax is explicitly given, operators are binary.  Operators in\nthe same box group left to right (except for comparisons, including\ntests, which all have the same precedence and chain from left to right\n--- see section *Comparisons* --- and exponentiation, which groups\nfrom right to left).\n\n+-------------------------------------------------+---------------------------------------+\n| Operator                                        | Description                           |\n+=================================================+=======================================+\n| ``lambda``                                      | Lambda expression                     |\n+-------------------------------------------------+---------------------------------------+\n| ``if`` -- ``else``                              | Conditional expression                |\n+-------------------------------------------------+---------------------------------------+\n| ``or``                                          | Boolean OR                            |\n+-------------------------------------------------+---------------------------------------+\n| ``and``                                         | Boolean AND                           |\n+-------------------------------------------------+---------------------------------------+\n| ``not`` ``x``                                   | Boolean NOT                           |\n+-------------------------------------------------+---------------------------------------+\n| ``in``, ``not in``, ``is``, ``is not``, ``<``,  | Comparisons, including membership     |\n| ``<=``, ``>``, ``>=``, ``!=``, ``==``           | tests and identity tests              |\n+-------------------------------------------------+---------------------------------------+\n| ``|``                                           | Bitwise OR                            |\n+-------------------------------------------------+---------------------------------------+\n| ``^``                                           | Bitwise XOR                           |\n+-------------------------------------------------+---------------------------------------+\n| ``&``                                           | Bitwise AND                           |\n+-------------------------------------------------+---------------------------------------+\n| ``<<``, ``>>``                                  | Shifts                                |\n+-------------------------------------------------+---------------------------------------+\n| ``+``, ``-``                                    | Addition and subtraction              |\n+-------------------------------------------------+---------------------------------------+\n| ``*``, ``/``, ``//``, ``%``                     | Multiplication, division, remainder   |\n|                                                 | [5]                                   |\n+-------------------------------------------------+---------------------------------------+\n| ``+x``, ``-x``, ``~x``                          | Positive, negative, bitwise NOT       |\n+-------------------------------------------------+---------------------------------------+\n| ``**``                                          | Exponentiation [6]                    |\n+-------------------------------------------------+---------------------------------------+\n| ``x[index]``, ``x[index:index]``,               | Subscription, slicing, call,          |\n| ``x(arguments...)``, ``x.attribute``            | attribute reference                   |\n+-------------------------------------------------+---------------------------------------+\n| ``(expressions...)``, ``[expressions...]``,     | Binding or tuple display, list        |\n| ``{key: value...}``, ``{expressions...}``       | display, dictionary display, set      |\n|                                                 | display                               |\n+-------------------------------------------------+---------------------------------------+\n\n-[ Footnotes ]-\n\n[1] While ``abs(x%y) < abs(y)`` is true mathematically, for floats it\n    may not be true numerically due to roundoff.  For example, and\n    assuming a platform on which a Python float is an IEEE 754 double-\n    precision number, in order that ``-1e-100 % 1e100`` have the same\n    sign as ``1e100``, the computed result is ``-1e-100 + 1e100``,\n    which is numerically exactly equal to ``1e100``.  The function\n    ``math.fmod()`` returns a result whose sign matches the sign of\n    the first argument instead, and so returns ``-1e-100`` in this\n    case. Which approach is more appropriate depends on the\n    application.\n\n[2] If x is very close to an exact integer multiple of y, it\'s\n    possible for ``x//y`` to be one larger than ``(x-x%y)//y`` due to\n    rounding.  In such cases, Python returns the latter result, in\n    order to preserve that ``divmod(x,y)[0] * y + x % y`` be very\n    close to ``x``.\n\n[3] While comparisons between strings make sense at the byte level,\n    they may be counter-intuitive to users.  For example, the strings\n    ``"\\u00C7"`` and ``"\\u0327\\u0043"`` compare differently, even\n    though they both represent the same unicode character (LATIN\n    CAPITAL LETTER C WITH CEDILLA).  To compare strings in a human\n    recognizable way, compare using ``unicodedata.normalize()``.\n\n[4] Due to automatic garbage-collection, free lists, and the dynamic\n    nature of descriptors, you may notice seemingly unusual behaviour\n    in certain uses of the ``is`` operator, like those involving\n    comparisons between instance methods, or constants.  Check their\n    documentation for more info.\n\n[5] The ``%`` operator is also used for string formatting; the same\n    precedence applies.\n\n[6] The power operator ``**`` binds less tightly than an arithmetic or\n    bitwise unary operator on its right, that is, ``2**-1`` is\n    ``0.5``.\n',
+ 'operator-summary': '\nOperator precedence\n*******************\n\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding).  Operators in the same box have the same precedence.  Unless\nthe syntax is explicitly given, operators are binary.  Operators in\nthe same box group left to right (except for comparisons, including\ntests, which all have the same precedence and chain from left to right\n--- see section *Comparisons* --- and exponentiation, which groups\nfrom right to left).\n\n+-------------------------------------------------+---------------------------------------+\n| Operator                                        | Description                           |\n+=================================================+=======================================+\n| ``lambda``                                      | Lambda expression                     |\n+-------------------------------------------------+---------------------------------------+\n| ``if`` -- ``else``                              | Conditional expression                |\n+-------------------------------------------------+---------------------------------------+\n| ``or``                                          | Boolean OR                            |\n+-------------------------------------------------+---------------------------------------+\n| ``and``                                         | Boolean AND                           |\n+-------------------------------------------------+---------------------------------------+\n| ``not`` ``x``                                   | Boolean NOT                           |\n+-------------------------------------------------+---------------------------------------+\n| ``in``, ``not in``, ``is``, ``is not``, ``<``,  | Comparisons, including membership     |\n| ``<=``, ``>``, ``>=``, ``!=``, ``==``           | tests and identity tests,             |\n+-------------------------------------------------+---------------------------------------+\n| ``|``                                           | Bitwise OR                            |\n+-------------------------------------------------+---------------------------------------+\n| ``^``                                           | Bitwise XOR                           |\n+-------------------------------------------------+---------------------------------------+\n| ``&``                                           | Bitwise AND                           |\n+-------------------------------------------------+---------------------------------------+\n| ``<<``, ``>>``                                  | Shifts                                |\n+-------------------------------------------------+---------------------------------------+\n| ``+``, ``-``                                    | Addition and subtraction              |\n+-------------------------------------------------+---------------------------------------+\n| ``*``, ``/``, ``//``, ``%``                     | Multiplication, division, remainder   |\n|                                                 | [5]                                   |\n+-------------------------------------------------+---------------------------------------+\n| ``+x``, ``-x``, ``~x``                          | Positive, negative, bitwise NOT       |\n+-------------------------------------------------+---------------------------------------+\n| ``**``                                          | Exponentiation [6]                    |\n+-------------------------------------------------+---------------------------------------+\n| ``x[index]``, ``x[index:index]``,               | Subscription, slicing, call,          |\n| ``x(arguments...)``, ``x.attribute``            | attribute reference                   |\n+-------------------------------------------------+---------------------------------------+\n| ``(expressions...)``, ``[expressions...]``,     | Binding or tuple display, list        |\n| ``{key: value...}``, ``{expressions...}``       | display, dictionary display, set      |\n|                                                 | display                               |\n+-------------------------------------------------+---------------------------------------+\n\n-[ Footnotes ]-\n\n[1] While ``abs(x%y) < abs(y)`` is true mathematically, for floats it\n    may not be true numerically due to roundoff.  For example, and\n    assuming a platform on which a Python float is an IEEE 754 double-\n    precision number, in order that ``-1e-100 % 1e100`` have the same\n    sign as ``1e100``, the computed result is ``-1e-100 + 1e100``,\n    which is numerically exactly equal to ``1e100``.  The function\n    ``math.fmod()`` returns a result whose sign matches the sign of\n    the first argument instead, and so returns ``-1e-100`` in this\n    case. Which approach is more appropriate depends on the\n    application.\n\n[2] If x is very close to an exact integer multiple of y, it\'s\n    possible for ``x//y`` to be one larger than ``(x-x%y)//y`` due to\n    rounding.  In such cases, Python returns the latter result, in\n    order to preserve that ``divmod(x,y)[0] * y + x % y`` be very\n    close to ``x``.\n\n[3] While comparisons between strings make sense at the byte level,\n    they may be counter-intuitive to users.  For example, the strings\n    ``"\\u00C7"`` and ``"\\u0327\\u0043"`` compare differently, even\n    though they both represent the same unicode character (LATIN\n    CAPITAL LETTER C WITH CEDILLA).  To compare strings in a human\n    recognizable way, compare using ``unicodedata.normalize()``.\n\n[4] Due to automatic garbage-collection, free lists, and the dynamic\n    nature of descriptors, you may notice seemingly unusual behaviour\n    in certain uses of the ``is`` operator, like those involving\n    comparisons between instance methods, or constants.  Check their\n    documentation for more info.\n\n[5] The ``%`` operator is also used for string formatting; the same\n    precedence applies.\n\n[6] The power operator ``**`` binds less tightly than an arithmetic or\n    bitwise unary operator on its right, that is, ``2**-1`` is\n    ``0.5``.\n',
  'pass': '\nThe ``pass`` statement\n**********************\n\n   pass_stmt ::= "pass"\n\n``pass`` is a null operation --- when it is executed, nothing happens.\nIt is useful as a placeholder when a statement is required\nsyntactically, but no code needs to be executed, for example:\n\n   def f(arg): pass    # a function that does nothing (yet)\n\n   class C: pass       # a class with no methods (yet)\n',
  'power': '\nThe power operator\n******************\n\nThe power operator binds more tightly than unary operators on its\nleft; it binds less tightly than unary operators on its right.  The\nsyntax is:\n\n   power ::= primary ["**" u_expr]\n\nThus, in an unparenthesized sequence of power and unary operators, the\noperators are evaluated from right to left (this does not constrain\nthe evaluation order for the operands): ``-1**2`` results in ``-1``.\n\nThe power operator has the same semantics as the built-in ``pow()``\nfunction, when called with two arguments: it yields its left argument\nraised to the power of its right argument.  The numeric arguments are\nfirst converted to a common type, and the result is of that type.\n\nFor int operands, the result has the same type as the operands unless\nthe second argument is negative; in that case, all arguments are\nconverted to float and a float result is delivered. For example,\n``10**2`` returns ``100``, but ``10**-2`` returns ``0.01``.\n\nRaising ``0.0`` to a negative power results in a\n``ZeroDivisionError``. Raising a negative number to a fractional power\nresults in a ``complex`` number. (In earlier versions it raised a\n``ValueError``.)\n',
  'raise': '\nThe ``raise`` statement\n***********************\n\n   raise_stmt ::= "raise" [expression ["from" expression]]\n\nIf no expressions are present, ``raise`` re-raises the last exception\nthat was active in the current scope.  If no exception is active in\nthe current scope, a ``RuntimeError`` exception is raised indicating\nthat this is an error.\n\nOtherwise, ``raise`` evaluates the first expression as the exception\nobject.  It must be either a subclass or an instance of\n``BaseException``. If it is a class, the exception instance will be\nobtained when needed by instantiating the class with no arguments.\n\nThe *type* of the exception is the exception instance\'s class, the\n*value* is the instance itself.\n\nA traceback object is normally created automatically when an exception\nis raised and attached to it as the ``__traceback__`` attribute, which\nis writable. You can create an exception and set your own traceback in\none step using the ``with_traceback()`` exception method (which\nreturns the same exception instance, with its traceback set to its\nargument), like so:\n\n   raise Exception("foo occurred").with_traceback(tracebackobj)\n\nThe ``from`` clause is used for exception chaining: if given, the\nsecond *expression* must be another exception class or instance, which\nwill then be attached to the raised exception as the ``__cause__``\nattribute (which is writable).  If the raised exception is not\nhandled, both exceptions will be printed:\n\n   >>> try:\n   ...     print(1 / 0)\n   ... except Exception as exc:\n   ...     raise RuntimeError("Something bad happened") from exc\n   ...\n   Traceback (most recent call last):\n     File "<stdin>", line 2, in <module>\n   ZeroDivisionError: int division or modulo by zero\n\n   The above exception was the direct cause of the following exception:\n\n   Traceback (most recent call last):\n     File "<stdin>", line 4, in <module>\n   RuntimeError: Something bad happened\n\nA similar mechanism works implicitly if an exception is raised inside\nan exception handler: the previous exception is then attached as the\nnew exception\'s ``__context__`` attribute:\n\n   >>> try:\n   ...     print(1 / 0)\n   ... except:\n   ...     raise RuntimeError("Something bad happened")\n   ...\n   Traceback (most recent call last):\n     File "<stdin>", line 2, in <module>\n   ZeroDivisionError: int division or modulo by zero\n\n   During handling of the above exception, another exception occurred:\n\n   Traceback (most recent call last):\n     File "<stdin>", line 4, in <module>\n   RuntimeError: Something bad happened\n\nAdditional information on exceptions can be found in section\n*Exceptions*, and information about handling exceptions is in section\n*The try statement*.\n',
  'return': '\nThe ``return`` statement\n************************\n\n   return_stmt ::= "return" [expression_list]\n\n``return`` may only occur syntactically nested in a function\ndefinition, not within a nested class definition.\n\nIf an expression list is present, it is evaluated, else ``None`` is\nsubstituted.\n\n``return`` leaves the current function call with the expression list\n(or ``None``) as return value.\n\nWhen ``return`` passes control out of a ``try`` statement with a\n``finally`` clause, that ``finally`` clause is executed before really\nleaving the function.\n\nIn a generator function, the ``return`` statement indicates that the\ngenerator is done and will cause ``StopIteration`` to be raised. The\nreturned value (if any) is used as an argument to construct\n``StopIteration`` and becomes the ``StopIteration.value`` attribute.\n',
- 'sequence-types': "\nEmulating container types\n*************************\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well.  The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which ``0 <= k < N``\nwhere *N* is the length of the sequence, or slice objects, which\ndefine a range of items.  It is also recommended that mappings provide\nthe methods ``keys()``, ``values()``, ``items()``, ``get()``,\n``clear()``, ``setdefault()``, ``pop()``, ``popitem()``, ``copy()``,\nand ``update()`` behaving similar to those for Python's standard\ndictionary objects.  The ``collections`` module provides a\n``MutableMapping`` abstract base class to help create those methods\nfrom a base set of ``__getitem__()``, ``__setitem__()``,\n``__delitem__()``, and ``keys()``. Mutable sequences should provide\nmethods ``append()``, ``count()``, ``index()``, ``extend()``,\n``insert()``, ``pop()``, ``remove()``, ``reverse()`` and ``sort()``,\nlike Python standard list objects.  Finally, sequence types should\nimplement addition (meaning concatenation) and multiplication (meaning\nrepetition) by defining the methods ``__add__()``, ``__radd__()``,\n``__iadd__()``, ``__mul__()``, ``__rmul__()`` and ``__imul__()``\ndescribed below; they should not define other numerical operators.  It\nis recommended that both mappings and sequences implement the\n``__contains__()`` method to allow efficient use of the ``in``\noperator; for mappings, ``in`` should search the mapping's keys; for\nsequences, it should search through the values.  It is further\nrecommended that both mappings and sequences implement the\n``__iter__()`` method to allow efficient iteration through the\ncontainer; for mappings, ``__iter__()`` should be the same as\n``keys()``; for sequences, it should iterate through the values.\n\nobject.__len__(self)\n\n   Called to implement the built-in function ``len()``.  Should return\n   the length of the object, an integer ``>=`` 0.  Also, an object\n   that doesn't define a ``__bool__()`` method and whose ``__len__()``\n   method returns zero is considered to be false in a Boolean context.\n\nobject.__length_hint__(self)\n\n   Called to implement ``operator.length_hint()``. Should return an\n   estimated length for the object (which may be greater or less than\n   the actual length). The length must be an integer ``>=`` 0. This\n   method is purely an optimization and is never required for\n   correctness.\n\n   New in version 3.4.\n\nNote: Slicing is done exclusively with the following three methods.  A\n  call like\n\n     a[1:2] = b\n\n  is translated to\n\n     a[slice(1, 2, None)] = b\n\n  and so forth.  Missing slice items are always filled in with\n  ``None``.\n\nobject.__getitem__(self, key)\n\n   Called to implement evaluation of ``self[key]``. For sequence\n   types, the accepted keys should be integers and slice objects.\n   Note that the special interpretation of negative indexes (if the\n   class wishes to emulate a sequence type) is up to the\n   ``__getitem__()`` method. If *key* is of an inappropriate type,\n   ``TypeError`` may be raised; if of a value outside the set of\n   indexes for the sequence (after any special interpretation of\n   negative values), ``IndexError`` should be raised. For mapping\n   types, if *key* is missing (not in the container), ``KeyError``\n   should be raised.\n\n   Note: ``for`` loops expect that an ``IndexError`` will be raised for\n     illegal indexes to allow proper detection of the end of the\n     sequence.\n\nobject.__setitem__(self, key, value)\n\n   Called to implement assignment to ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support changes to the values for keys, or if new keys\n   can be added, or for sequences if elements can be replaced.  The\n   same exceptions should be raised for improper *key* values as for\n   the ``__getitem__()`` method.\n\nobject.__delitem__(self, key)\n\n   Called to implement deletion of ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support removal of keys, or for sequences if elements\n   can be removed from the sequence.  The same exceptions should be\n   raised for improper *key* values as for the ``__getitem__()``\n   method.\n\nobject.__iter__(self)\n\n   This method is called when an iterator is required for a container.\n   This method should return a new iterator object that can iterate\n   over all the objects in the container.  For mappings, it should\n   iterate over the keys of the container, and should also be made\n   available as the method ``keys()``.\n\n   Iterator objects also need to implement this method; they are\n   required to return themselves.  For more information on iterator\n   objects, see *Iterator Types*.\n\nobject.__reversed__(self)\n\n   Called (if present) by the ``reversed()`` built-in to implement\n   reverse iteration.  It should return a new iterator object that\n   iterates over all the objects in the container in reverse order.\n\n   If the ``__reversed__()`` method is not provided, the\n   ``reversed()`` built-in will fall back to using the sequence\n   protocol (``__len__()`` and ``__getitem__()``).  Objects that\n   support the sequence protocol should only provide\n   ``__reversed__()`` if they can provide an implementation that is\n   more efficient than the one provided by ``reversed()``.\n\nThe membership test operators (``in`` and ``not in``) are normally\nimplemented as an iteration through a sequence.  However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n   Called to implement membership test operators.  Should return true\n   if *item* is in *self*, false otherwise.  For mapping objects, this\n   should consider the keys of the mapping rather than the values or\n   the key-item pairs.\n\n   For objects that don't define ``__contains__()``, the membership\n   test first tries iteration via ``__iter__()``, then the old\n   sequence iteration protocol via ``__getitem__()``, see *this\n   section in the language reference*.\n",
+ 'sequence-types': "\nEmulating container types\n*************************\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well.  The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which ``0 <= k < N``\nwhere *N* is the length of the sequence, or slice objects, which\ndefine a range of items.  It is also recommended that mappings provide\nthe methods ``keys()``, ``values()``, ``items()``, ``get()``,\n``clear()``, ``setdefault()``, ``pop()``, ``popitem()``, ``copy()``,\nand ``update()`` behaving similar to those for Python's standard\ndictionary objects.  The ``collections`` module provides a\n``MutableMapping`` abstract base class to help create those methods\nfrom a base set of ``__getitem__()``, ``__setitem__()``,\n``__delitem__()``, and ``keys()``. Mutable sequences should provide\nmethods ``append()``, ``count()``, ``index()``, ``extend()``,\n``insert()``, ``pop()``, ``remove()``, ``reverse()`` and ``sort()``,\nlike Python standard list objects.  Finally, sequence types should\nimplement addition (meaning concatenation) and multiplication (meaning\nrepetition) by defining the methods ``__add__()``, ``__radd__()``,\n``__iadd__()``, ``__mul__()``, ``__rmul__()`` and ``__imul__()``\ndescribed below; they should not define other numerical operators.  It\nis recommended that both mappings and sequences implement the\n``__contains__()`` method to allow efficient use of the ``in``\noperator; for mappings, ``in`` should search the mapping's keys; for\nsequences, it should search through the values.  It is further\nrecommended that both mappings and sequences implement the\n``__iter__()`` method to allow efficient iteration through the\ncontainer; for mappings, ``__iter__()`` should be the same as\n``keys()``; for sequences, it should iterate through the values.\n\nobject.__len__(self)\n\n   Called to implement the built-in function ``len()``.  Should return\n   the length of the object, an integer ``>=`` 0.  Also, an object\n   that doesn't define a ``__bool__()`` method and whose ``__len__()``\n   method returns zero is considered to be false in a Boolean context.\n\nNote: Slicing is done exclusively with the following three methods.  A\n  call like\n\n     a[1:2] = b\n\n  is translated to\n\n     a[slice(1, 2, None)] = b\n\n  and so forth.  Missing slice items are always filled in with\n  ``None``.\n\nobject.__getitem__(self, key)\n\n   Called to implement evaluation of ``self[key]``. For sequence\n   types, the accepted keys should be integers and slice objects.\n   Note that the special interpretation of negative indexes (if the\n   class wishes to emulate a sequence type) is up to the\n   ``__getitem__()`` method. If *key* is of an inappropriate type,\n   ``TypeError`` may be raised; if of a value outside the set of\n   indexes for the sequence (after any special interpretation of\n   negative values), ``IndexError`` should be raised. For mapping\n   types, if *key* is missing (not in the container), ``KeyError``\n   should be raised.\n\n   Note: ``for`` loops expect that an ``IndexError`` will be raised for\n     illegal indexes to allow proper detection of the end of the\n     sequence.\n\nobject.__setitem__(self, key, value)\n\n   Called to implement assignment to ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support changes to the values for keys, or if new keys\n   can be added, or for sequences if elements can be replaced.  The\n   same exceptions should be raised for improper *key* values as for\n   the ``__getitem__()`` method.\n\nobject.__delitem__(self, key)\n\n   Called to implement deletion of ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support removal of keys, or for sequences if elements\n   can be removed from the sequence.  The same exceptions should be\n   raised for improper *key* values as for the ``__getitem__()``\n   method.\n\nobject.__iter__(self)\n\n   This method is called when an iterator is required for a container.\n   This method should return a new iterator object that can iterate\n   over all the objects in the container.  For mappings, it should\n   iterate over the keys of the container, and should also be made\n   available as the method ``keys()``.\n\n   Iterator objects also need to implement this method; they are\n   required to return themselves.  For more information on iterator\n   objects, see *Iterator Types*.\n\nobject.__reversed__(self)\n\n   Called (if present) by the ``reversed()`` built-in to implement\n   reverse iteration.  It should return a new iterator object that\n   iterates over all the objects in the container in reverse order.\n\n   If the ``__reversed__()`` method is not provided, the\n   ``reversed()`` built-in will fall back to using the sequence\n   protocol (``__len__()`` and ``__getitem__()``).  Objects that\n   support the sequence protocol should only provide\n   ``__reversed__()`` if they can provide an implementation that is\n   more efficient than the one provided by ``reversed()``.\n\nThe membership test operators (``in`` and ``not in``) are normally\nimplemented as an iteration through a sequence.  However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n   Called to implement membership test operators.  Should return true\n   if *item* is in *self*, false otherwise.  For mapping objects, this\n   should consider the keys of the mapping rather than the values or\n   the key-item pairs.\n\n   For objects that don't define ``__contains__()``, the membership\n   test first tries iteration via ``__iter__()``, then the old\n   sequence iteration protocol via ``__getitem__()``, see *this\n   section in the language reference*.\n",
  'shifting': '\nShifting operations\n*******************\n\nThe shifting operations have lower priority than the arithmetic\noperations:\n\n   shift_expr ::= a_expr | shift_expr ( "<<" | ">>" ) a_expr\n\nThese operators accept integers as arguments.  They shift the first\nargument to the left or right by the number of bits given by the\nsecond argument.\n\nA right shift by *n* bits is defined as division by ``pow(2,n)``.  A\nleft shift by *n* bits is defined as multiplication with ``pow(2,n)``.\n\nNote: In the current implementation, the right-hand operand is required to\n  be at most ``sys.maxsize``.  If the right-hand operand is larger\n  than ``sys.maxsize`` an ``OverflowError`` exception is raised.\n',
  'slicings': '\nSlicings\n********\n\nA slicing selects a range of items in a sequence object (e.g., a\nstring, tuple or list).  Slicings may be used as expressions or as\ntargets in assignment or ``del`` statements.  The syntax for a\nslicing:\n\n   slicing      ::= primary "[" slice_list "]"\n   slice_list   ::= slice_item ("," slice_item)* [","]\n   slice_item   ::= expression | proper_slice\n   proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]\n   lower_bound  ::= expression\n   upper_bound  ::= expression\n   stride       ::= expression\n\nThere is ambiguity in the formal syntax here: anything that looks like\nan expression list also looks like a slice list, so any subscription\ncan be interpreted as a slicing.  Rather than further complicating the\nsyntax, this is disambiguated by defining that in this case the\ninterpretation as a subscription takes priority over the\ninterpretation as a slicing (this is the case if the slice list\ncontains no proper slice).\n\nThe semantics for a slicing are as follows.  The primary must evaluate\nto a mapping object, and it is indexed (using the same\n``__getitem__()`` method as normal subscription) with a key that is\nconstructed from the slice list, as follows.  If the slice list\ncontains at least one comma, the key is a tuple containing the\nconversion of the slice items; otherwise, the conversion of the lone\nslice item is the key.  The conversion of a slice item that is an\nexpression is that expression.  The conversion of a proper slice is a\nslice object (see section *The standard type hierarchy*) whose\n``start``, ``stop`` and ``step`` attributes are the values of the\nexpressions given as lower bound, upper bound and stride,\nrespectively, substituting ``None`` for missing expressions.\n',
  'specialattrs': '\nSpecial Attributes\n******************\n\nThe implementation adds a few special read-only attributes to several\nobject types, where they are relevant.  Some of these are not reported\nby the ``dir()`` built-in function.\n\nobject.__dict__\n\n   A dictionary or other mapping object used to store an object\'s\n   (writable) attributes.\n\ninstance.__class__\n\n   The class to which a class instance belongs.\n\nclass.__bases__\n\n   The tuple of base classes of a class object.\n\nclass.__name__\n\n   The name of the class or type.\n\nclass.__qualname__\n\n   The *qualified name* of the class or type.\n\n   New in version 3.3.\n\nclass.__mro__\n\n   This attribute is a tuple of classes that are considered when\n   looking for base classes during method resolution.\n\nclass.mro()\n\n   This method can be overridden by a metaclass to customize the\n   method resolution order for its instances.  It is called at class\n   instantiation, and its result is stored in ``__mro__``.\n\nclass.__subclasses__()\n\n   Each class keeps a list of weak references to its immediate\n   subclasses.  This method returns a list of all those references\n   still alive. Example:\n\n      >>> int.__subclasses__()\n      [<class \'bool\'>]\n\n-[ Footnotes ]-\n\n[1] Additional information on these special methods may be found in\n    the Python Reference Manual (*Basic customization*).\n\n[2] As a consequence, the list ``[1, 2]`` is considered equal to\n    ``[1.0, 2.0]``, and similarly for tuples.\n\n[3] They must have since the parser can\'t tell the type of the\n    operands.\n\n[4] Cased characters are those with general category property being\n    one of "Lu" (Letter, uppercase), "Ll" (Letter, lowercase), or "Lt"\n    (Letter, titlecase).\n\n[5] To format only a tuple you should therefore provide a singleton\n    tuple whose only element is the tuple to be formatted.\n',
- 'specialnames': '\nSpecial method names\n********************\n\nA class can implement certain operations that are invoked by special\nsyntax (such as arithmetic operations or subscripting and slicing) by\ndefining methods with special names. This is Python\'s approach to\n*operator overloading*, allowing classes to define their own behavior\nwith respect to language operators.  For instance, if a class defines\na method named ``__getitem__()``, and ``x`` is an instance of this\nclass, then ``x[i]`` is roughly equivalent to ``type(x).__getitem__(x,\ni)``.  Except where mentioned, attempts to execute an operation raise\nan exception when no appropriate method is defined (typically\n``AttributeError`` or ``TypeError``).\n\nWhen implementing a class that emulates any built-in type, it is\nimportant that the emulation only be implemented to the degree that it\nmakes sense for the object being modelled.  For example, some\nsequences may work well with retrieval of individual elements, but\nextracting a slice may not make sense.  (One example of this is the\n``NodeList`` interface in the W3C\'s Document Object Model.)\n\n\nBasic customization\n===================\n\nobject.__new__(cls[, ...])\n\n   Called to create a new instance of class *cls*.  ``__new__()`` is a\n   static method (special-cased so you need not declare it as such)\n   that takes the class of which an instance was requested as its\n   first argument.  The remaining arguments are those passed to the\n   object constructor expression (the call to the class).  The return\n   value of ``__new__()`` should be the new object instance (usually\n   an instance of *cls*).\n\n   Typical implementations create a new instance of the class by\n   invoking the superclass\'s ``__new__()`` method using\n   ``super(currentclass, cls).__new__(cls[, ...])`` with appropriate\n   arguments and then modifying the newly-created instance as\n   necessary before returning it.\n\n   If ``__new__()`` returns an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will be invoked like\n   ``__init__(self[, ...])``, where *self* is the new instance and the\n   remaining arguments are the same as were passed to ``__new__()``.\n\n   If ``__new__()`` does not return an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will not be invoked.\n\n   ``__new__()`` is intended mainly to allow subclasses of immutable\n   types (like int, str, or tuple) to customize instance creation.  It\n   is also commonly overridden in custom metaclasses in order to\n   customize class creation.\n\nobject.__init__(self[, ...])\n\n   Called when the instance is created.  The arguments are those\n   passed to the class constructor expression.  If a base class has an\n   ``__init__()`` method, the derived class\'s ``__init__()`` method,\n   if any, must explicitly call it to ensure proper initialization of\n   the base class part of the instance; for example:\n   ``BaseClass.__init__(self, [args...])``.  As a special constraint\n   on constructors, no value may be returned; doing so will cause a\n   ``TypeError`` to be raised at runtime.\n\nobject.__del__(self)\n\n   Called when the instance is about to be destroyed.  This is also\n   called a destructor.  If a base class has a ``__del__()`` method,\n   the derived class\'s ``__del__()`` method, if any, must explicitly\n   call it to ensure proper deletion of the base class part of the\n   instance.  Note that it is possible (though not recommended!) for\n   the ``__del__()`` method to postpone destruction of the instance by\n   creating a new reference to it.  It may then be called at a later\n   time when this new reference is deleted.  It is not guaranteed that\n   ``__del__()`` methods are called for objects that still exist when\n   the interpreter exits.\n\n   Note: ``del x`` doesn\'t directly call ``x.__del__()`` --- the former\n     decrements the reference count for ``x`` by one, and the latter\n     is only called when ``x``\'s reference count reaches zero.  Some\n     common situations that may prevent the reference count of an\n     object from going to zero include: circular references between\n     objects (e.g., a doubly-linked list or a tree data structure with\n     parent and child pointers); a reference to the object on the\n     stack frame of a function that caught an exception (the traceback\n     stored in ``sys.exc_info()[2]`` keeps the stack frame alive); or\n     a reference to the object on the stack frame that raised an\n     unhandled exception in interactive mode (the traceback stored in\n     ``sys.last_traceback`` keeps the stack frame alive).  The first\n     situation can only be remedied by explicitly breaking the cycles;\n     the latter two situations can be resolved by storing ``None`` in\n     ``sys.last_traceback``. Circular references which are garbage are\n     detected and cleaned up when the cyclic garbage collector is\n     enabled (it\'s on by default). Refer to the documentation for the\n     ``gc`` module for more information about this topic.\n\n   Warning: Due to the precarious circumstances under which ``__del__()``\n     methods are invoked, exceptions that occur during their execution\n     are ignored, and a warning is printed to ``sys.stderr`` instead.\n     Also, when ``__del__()`` is invoked in response to a module being\n     deleted (e.g., when execution of the program is done), other\n     globals referenced by the ``__del__()`` method may already have\n     been deleted or in the process of being torn down (e.g. the\n     import machinery shutting down).  For this reason, ``__del__()``\n     methods should do the absolute minimum needed to maintain\n     external invariants.  Starting with version 1.5, Python\n     guarantees that globals whose name begins with a single\n     underscore are deleted from their module before other globals are\n     deleted; if no other references to such globals exist, this may\n     help in assuring that imported modules are still available at the\n     time when the ``__del__()`` method is called.\n\nobject.__repr__(self)\n\n   Called by the ``repr()`` built-in function to compute the\n   "official" string representation of an object.  If at all possible,\n   this should look like a valid Python expression that could be used\n   to recreate an object with the same value (given an appropriate\n   environment).  If this is not possible, a string of the form\n   ``<...some useful description...>`` should be returned. The return\n   value must be a string object. If a class defines ``__repr__()``\n   but not ``__str__()``, then ``__repr__()`` is also used when an\n   "informal" string representation of instances of that class is\n   required.\n\n   This is typically used for debugging, so it is important that the\n   representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n   Called by ``str(object)`` and the built-in functions ``format()``\n   and ``print()`` to compute the "informal" or nicely printable\n   string representation of an object.  The return value must be a\n   *string* object.\n\n   This method differs from ``object.__repr__()`` in that there is no\n   expectation that ``__str__()`` return a valid Python expression: a\n   more convenient or concise representation can be used.\n\n   The default implementation defined by the built-in type ``object``\n   calls ``object.__repr__()``.\n\nobject.__bytes__(self)\n\n   Called by ``bytes()`` to compute a byte-string representation of an\n   object. This should return a ``bytes`` object.\n\nobject.__format__(self, format_spec)\n\n   Called by the ``format()`` built-in function (and by extension, the\n   ``str.format()`` method of class ``str``) to produce a "formatted"\n   string representation of an object. The ``format_spec`` argument is\n   a string that contains a description of the formatting options\n   desired. The interpretation of the ``format_spec`` argument is up\n   to the type implementing ``__format__()``, however most classes\n   will either delegate formatting to one of the built-in types, or\n   use a similar formatting option syntax.\n\n   See *Format Specification Mini-Language* for a description of the\n   standard formatting syntax.\n\n   The return value must be a string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n   These are the so-called "rich comparison" methods. The\n   correspondence between operator symbols and method names is as\n   follows: ``x<y`` calls ``x.__lt__(y)``, ``x<=y`` calls\n   ``x.__le__(y)``, ``x==y`` calls ``x.__eq__(y)``, ``x!=y`` calls\n   ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` calls\n   ``x.__ge__(y)``.\n\n   A rich comparison method may return the singleton\n   ``NotImplemented`` if it does not implement the operation for a\n   given pair of arguments. By convention, ``False`` and ``True`` are\n   returned for a successful comparison. However, these methods can\n   return any value, so if the comparison operator is used in a\n   Boolean context (e.g., in the condition of an ``if`` statement),\n   Python will call ``bool()`` on the value to determine if the result\n   is true or false.\n\n   There are no implied relationships among the comparison operators.\n   The truth of ``x==y`` does not imply that ``x!=y`` is false.\n   Accordingly, when defining ``__eq__()``, one should also define\n   ``__ne__()`` so that the operators will behave as expected.  See\n   the paragraph on ``__hash__()`` for some important notes on\n   creating *hashable* objects which support custom comparison\n   operations and are usable as dictionary keys.\n\n   There are no swapped-argument versions of these methods (to be used\n   when the left argument does not support the operation but the right\n   argument does); rather, ``__lt__()`` and ``__gt__()`` are each\n   other\'s reflection, ``__le__()`` and ``__ge__()`` are each other\'s\n   reflection, and ``__eq__()`` and ``__ne__()`` are their own\n   reflection.\n\n   Arguments to rich comparison methods are never coerced.\n\n   To automatically generate ordering operations from a single root\n   operation, see ``functools.total_ordering()``.\n\nobject.__hash__(self)\n\n   Called by built-in function ``hash()`` and for operations on\n   members of hashed collections including ``set``, ``frozenset``, and\n   ``dict``.  ``__hash__()`` should return an integer.  The only\n   required property is that objects which compare equal have the same\n   hash value; it is advised to somehow mix together (e.g. using\n   exclusive or) the hash values for the components of the object that\n   also play a part in comparison of objects.\n\n   Note: ``hash()`` truncates the value returned from an object\'s custom\n     ``__hash__()`` method to the size of a ``Py_ssize_t``.  This is\n     typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds.\n     If an object\'s   ``__hash__()`` must interoperate on builds of\n     different bit sizes, be sure to check the width on all supported\n     builds.  An easy way to do this is with ``python -c "import sys;\n     print(sys.hash_info.width)"``\n\n   If a class does not define an ``__eq__()`` method it should not\n   define a ``__hash__()`` operation either; if it defines\n   ``__eq__()`` but not ``__hash__()``, its instances will not be\n   usable as items in hashable collections.  If a class defines\n   mutable objects and implements an ``__eq__()`` method, it should\n   not implement ``__hash__()``, since the implementation of hashable\n   collections requires that a key\'s hash value is immutable (if the\n   object\'s hash value changes, it will be in the wrong hash bucket).\n\n   User-defined classes have ``__eq__()`` and ``__hash__()`` methods\n   by default; with them, all objects compare unequal (except with\n   themselves) and ``x.__hash__()`` returns an appropriate value such\n   that ``x == y`` implies both that ``x is y`` and ``hash(x) ==\n   hash(y)``.\n\n   A class that overrides ``__eq__()`` and does not define\n   ``__hash__()`` will have its ``__hash__()`` implicitly set to\n   ``None``.  When the ``__hash__()`` method of a class is ``None``,\n   instances of the class will raise an appropriate ``TypeError`` when\n   a program attempts to retrieve their hash value, and will also be\n   correctly identified as unhashable when checking ``isinstance(obj,\n   collections.Hashable``).\n\n   If a class that overrides ``__eq__()`` needs to retain the\n   implementation of ``__hash__()`` from a parent class, the\n   interpreter must be told this explicitly by setting ``__hash__ =\n   <ParentClass>.__hash__``.\n\n   If a class that does not override ``__eq__()`` wishes to suppress\n   hash support, it should include ``__hash__ = None`` in the class\n   definition. A class which defines its own ``__hash__()`` that\n   explicitly raises a ``TypeError`` would be incorrectly identified\n   as hashable by an ``isinstance(obj, collections.Hashable)`` call.\n\n   Note: By default, the ``__hash__()`` values of str, bytes and datetime\n     objects are "salted" with an unpredictable random value.\n     Although they remain constant within an individual Python\n     process, they are not predictable between repeated invocations of\n     Python.This is intended to provide protection against a denial-\n     of-service caused by carefully-chosen inputs that exploit the\n     worst case performance of a dict insertion, O(n^2) complexity.\n     See http://www.ocert.org/advisories/ocert-2011-003.html for\n     details.Changing hash values affects the iteration order of\n     dicts, sets and other mappings.  Python has never made guarantees\n     about this ordering (and it typically varies between 32-bit and\n     64-bit builds).See also ``PYTHONHASHSEED``.\n\n   Changed in version 3.3: Hash randomization is enabled by default.\n\nobject.__bool__(self)\n\n   Called to implement truth value testing and the built-in operation\n   ``bool()``; should return ``False`` or ``True``.  When this method\n   is not defined, ``__len__()`` is called, if it is defined, and the\n   object is considered true if its result is nonzero.  If a class\n   defines neither ``__len__()`` nor ``__bool__()``, all its instances\n   are considered true.\n\n\nCustomizing attribute access\n============================\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of ``x.name``)\nfor class instances.\n\nobject.__getattr__(self, name)\n\n   Called when an attribute lookup has not found the attribute in the\n   usual places (i.e. it is not an instance attribute nor is it found\n   in the class tree for ``self``).  ``name`` is the attribute name.\n   This method should return the (computed) attribute value or raise\n   an ``AttributeError`` exception.\n\n   Note that if the attribute is found through the normal mechanism,\n   ``__getattr__()`` is not called.  (This is an intentional asymmetry\n   between ``__getattr__()`` and ``__setattr__()``.) This is done both\n   for efficiency reasons and because otherwise ``__getattr__()``\n   would have no way to access other attributes of the instance.  Note\n   that at least for instance variables, you can fake total control by\n   not inserting any values in the instance attribute dictionary (but\n   instead inserting them in another object).  See the\n   ``__getattribute__()`` method below for a way to actually get total\n   control over attribute access.\n\nobject.__getattribute__(self, name)\n\n   Called unconditionally to implement attribute accesses for\n   instances of the class. If the class also defines\n   ``__getattr__()``, the latter will not be called unless\n   ``__getattribute__()`` either calls it explicitly or raises an\n   ``AttributeError``. This method should return the (computed)\n   attribute value or raise an ``AttributeError`` exception. In order\n   to avoid infinite recursion in this method, its implementation\n   should always call the base class method with the same name to\n   access any attributes it needs, for example,\n   ``object.__getattribute__(self, name)``.\n\n   Note: This method may still be bypassed when looking up special methods\n     as the result of implicit invocation via language syntax or\n     built-in functions. See *Special method lookup*.\n\nobject.__setattr__(self, name, value)\n\n   Called when an attribute assignment is attempted.  This is called\n   instead of the normal mechanism (i.e. store the value in the\n   instance dictionary). *name* is the attribute name, *value* is the\n   value to be assigned to it.\n\n   If ``__setattr__()`` wants to assign to an instance attribute, it\n   should call the base class method with the same name, for example,\n   ``object.__setattr__(self, name, value)``.\n\nobject.__delattr__(self, name)\n\n   Like ``__setattr__()`` but for attribute deletion instead of\n   assignment.  This should only be implemented if ``del obj.name`` is\n   meaningful for the object.\n\nobject.__dir__(self)\n\n   Called when ``dir()`` is called on the object. A sequence must be\n   returned. ``dir()`` converts the returned sequence to a list and\n   sorts it.\n\n\nImplementing Descriptors\n------------------------\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents).  In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' ``__dict__``.\n\nobject.__get__(self, instance, owner)\n\n   Called to get the attribute of the owner class (class attribute\n   access) or of an instance of that class (instance attribute\n   access). *owner* is always the owner class, while *instance* is the\n   instance that the attribute was accessed through, or ``None`` when\n   the attribute is accessed through the *owner*.  This method should\n   return the (computed) attribute value or raise an\n   ``AttributeError`` exception.\n\nobject.__set__(self, instance, value)\n\n   Called to set the attribute on an instance *instance* of the owner\n   class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n   Called to delete the attribute on an instance *instance* of the\n   owner class.\n\n\nInvoking Descriptors\n--------------------\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol:  ``__get__()``, ``__set__()``, and\n``__delete__()``. If any of those methods are defined for an object,\nit is said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, ``a.x`` has a\nlookup chain starting with ``a.__dict__[\'x\']``, then\n``type(a).__dict__[\'x\']``, and continuing through the base classes of\n``type(a)`` excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead.  Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called.\n\nThe starting point for descriptor invocation is a binding, ``a.x``.\nHow the arguments are assembled depends on ``a``:\n\nDirect Call\n   The simplest and least common call is when user code directly\n   invokes a descriptor method:    ``x.__get__(a)``.\n\nInstance Binding\n   If binding to an object instance, ``a.x`` is transformed into the\n   call: ``type(a).__dict__[\'x\'].__get__(a, type(a))``.\n\nClass Binding\n   If binding to a class, ``A.x`` is transformed into the call:\n   ``A.__dict__[\'x\'].__get__(None, A)``.\n\nSuper Binding\n   If ``a`` is an instance of ``super``, then the binding ``super(B,\n   obj).m()`` searches ``obj.__class__.__mro__`` for the base class\n   ``A`` immediately preceding ``B`` and then invokes the descriptor\n   with the call: ``A.__dict__[\'m\'].__get__(obj, obj.__class__)``.\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined.  A descriptor can define\nany combination of ``__get__()``, ``__set__()`` and ``__delete__()``.\nIf it does not define ``__get__()``, then accessing the attribute will\nreturn the descriptor object itself unless there is a value in the\nobject\'s instance dictionary.  If the descriptor defines ``__set__()``\nand/or ``__delete__()``, it is a data descriptor; if it defines\nneither, it is a non-data descriptor.  Normally, data descriptors\ndefine both ``__get__()`` and ``__set__()``, while non-data\ndescriptors have just the ``__get__()`` method.  Data descriptors with\n``__set__()`` and ``__get__()`` defined always override a redefinition\nin an instance dictionary.  In contrast, non-data descriptors can be\noverridden by instances.\n\nPython methods (including ``staticmethod()`` and ``classmethod()``)\nare implemented as non-data descriptors.  Accordingly, instances can\nredefine and override methods.  This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe ``property()`` function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n---------\n\nBy default, instances of classes have a dictionary for attribute\nstorage.  This wastes space for objects having very few instance\nvariables.  The space consumption can become acute when creating large\nnumbers of instances.\n\nThe default can be overridden by defining *__slots__* in a class\ndefinition. The *__slots__* declaration takes a sequence of instance\nvariables and reserves just enough space in each instance to hold a\nvalue for each variable.  Space is saved because *__dict__* is not\ncreated for each instance.\n\nobject.__slots__\n\n   This class variable can be assigned a string, iterable, or sequence\n   of strings with variable names used by instances.  If defined in a\n   class, *__slots__* reserves space for the declared variables and\n   prevents the automatic creation of *__dict__* and *__weakref__* for\n   each instance.\n\n\nNotes on using *__slots__*\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n  attribute of that class will always be accessible, so a *__slots__*\n  definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n  variables not listed in the *__slots__* definition.  Attempts to\n  assign to an unlisted variable name raises ``AttributeError``. If\n  dynamic assignment of new variables is desired, then add\n  ``\'__dict__\'`` to the sequence of strings in the *__slots__*\n  declaration.\n\n* Without a *__weakref__* variable for each instance, classes defining\n  *__slots__* do not support weak references to its instances. If weak\n  reference support is needed, then add ``\'__weakref__\'`` to the\n  sequence of strings in the *__slots__* declaration.\n\n* *__slots__* are implemented at the class level by creating\n  descriptors (*Implementing Descriptors*) for each variable name.  As\n  a result, class attributes cannot be used to set default values for\n  instance variables defined by *__slots__*; otherwise, the class\n  attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n  where it is defined.  As a result, subclasses will have a *__dict__*\n  unless they also define *__slots__* (which must only contain names\n  of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the instance\n  variable defined by the base class slot is inaccessible (except by\n  retrieving its descriptor directly from the base class). This\n  renders the meaning of the program undefined.  In the future, a\n  check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n  "variable-length" built-in types such as ``int``, ``str`` and\n  ``tuple``.\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings may\n  also be used; however, in the future, special meaning may be\n  assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n  *__slots__*.\n\n\nCustomizing class creation\n==========================\n\nBy default, classes are constructed using ``type()``. The class body\nis executed in a new namespace and the class name is bound locally to\nthe result of ``type(name, bases, namespace)``.\n\nThe class creation process can be customised by passing the\n``metaclass`` keyword argument in the class definition line, or by\ninheriting from an existing class that included such an argument. In\nthe following example, both ``MyClass`` and ``MySubclass`` are\ninstances of ``Meta``:\n\n   class Meta(type):\n       pass\n\n   class MyClass(metaclass=Meta):\n       pass\n\n   class MySubclass(MyClass):\n       pass\n\nAny other keyword arguments that are specified in the class definition\nare passed through to all metaclass operations described below.\n\nWhen a class definition is executed, the following steps occur:\n\n* the appropriate metaclass is determined\n\n* the class namespace is prepared\n\n* the class body is executed\n\n* the class object is created\n\n\nDetermining the appropriate metaclass\n-------------------------------------\n\nThe appropriate metaclass for a class definition is determined as\nfollows:\n\n* if no bases and no explicit metaclass are given, then ``type()`` is\n  used\n\n* if an explicit metaclass is given and it is *not* an instance of\n  ``type()``, then it is used directly as the metaclass\n\n* if an instance of ``type()`` is given as the explicit metaclass, or\n  bases are defined, then the most derived metaclass is used\n\nThe most derived metaclass is selected from the explicitly specified\nmetaclass (if any) and the metaclasses (i.e. ``type(cls)``) of all\nspecified base classes. The most derived metaclass is one which is a\nsubtype of *all* of these candidate metaclasses. If none of the\ncandidate metaclasses meets that criterion, then the class definition\nwill fail with ``TypeError``.\n\n\nPreparing the class namespace\n-----------------------------\n\nOnce the appropriate metaclass has been identified, then the class\nnamespace is prepared. If the metaclass has a ``__prepare__``\nattribute, it is called as ``namespace = metaclass.__prepare__(name,\nbases, **kwds)`` (where the additional keyword arguments, if any, come\nfrom the class definition).\n\nIf the metaclass has no ``__prepare__`` attribute, then the class\nnamespace is initialised as an empty ``dict()`` instance.\n\nSee also:\n\n   **PEP 3115** - Metaclasses in Python 3000\n      Introduced the ``__prepare__`` namespace hook\n\n\nExecuting the class body\n------------------------\n\nThe class body is executed (approximately) as ``exec(body, globals(),\nnamespace)``. The key difference from a normal call to ``exec()`` is\nthat lexical scoping allows the class body (including any methods) to\nreference names from the current and outer scopes when the class\ndefinition occurs inside a function.\n\nHowever, even when the class definition occurs inside the function,\nmethods defined inside the class still cannot see names defined at the\nclass scope. Class variables must be accessed through the first\nparameter of instance or class methods, and cannot be accessed at all\nfrom static methods.\n\n\nCreating the class object\n-------------------------\n\nOnce the class namespace has been populated by executing the class\nbody, the class object is created by calling ``metaclass(name, bases,\nnamespace, **kwds)`` (the additional keywords passed here are the same\nas those passed to ``__prepare__``).\n\nThis class object is the one that will be referenced by the zero-\nargument form of ``super()``. ``__class__`` is an implicit closure\nreference created by the compiler if any methods in a class body refer\nto either ``__class__`` or ``super``. This allows the zero argument\nform of ``super()`` to correctly identify the class being defined\nbased on lexical scoping, while the class or instance that was used to\nmake the current call is identified based on the first argument passed\nto the method.\n\nAfter the class object is created, it is passed to the class\ndecorators included in the class definition (if any) and the resulting\nobject is bound in the local namespace as the defined class.\n\nSee also:\n\n   **PEP 3135** - New super\n      Describes the implicit ``__class__`` closure reference\n\n\nMetaclass example\n-----------------\n\nThe potential uses for metaclasses are boundless. Some ideas that have\nbeen explored include logging, interface checking, automatic\ndelegation, automatic property creation, proxies, frameworks, and\nautomatic resource locking/synchronization.\n\nHere is an example of a metaclass that uses an\n``collections.OrderedDict`` to remember the order that class members\nwere defined:\n\n   class OrderedClass(type):\n\n        @classmethod\n        def __prepare__(metacls, name, bases, **kwds):\n           return collections.OrderedDict()\n\n        def __new__(cls, name, bases, namespace, **kwds):\n           result = type.__new__(cls, name, bases, dict(namespace))\n           result.members = tuple(namespace)\n           return result\n\n   class A(metaclass=OrderedClass):\n       def one(self): pass\n       def two(self): pass\n       def three(self): pass\n       def four(self): pass\n\n   >>> A.members\n   (\'__module__\', \'one\', \'two\', \'three\', \'four\')\n\nWhen the class definition for *A* gets executed, the process begins\nwith calling the metaclass\'s ``__prepare__()`` method which returns an\nempty ``collections.OrderedDict``.  That mapping records the methods\nand attributes of *A* as they are defined within the body of the class\nstatement. Once those definitions are executed, the ordered dictionary\nis fully populated and the metaclass\'s ``__new__()`` method gets\ninvoked.  That method builds the new type and it saves the ordered\ndictionary keys in an attribute called ``members``.\n\n\nCustomizing instance and subclass checks\n========================================\n\nThe following methods are used to override the default behavior of the\n``isinstance()`` and ``issubclass()`` built-in functions.\n\nIn particular, the metaclass ``abc.ABCMeta`` implements these methods\nin order to allow the addition of Abstract Base Classes (ABCs) as\n"virtual base classes" to any class or type (including built-in\ntypes), including other ABCs.\n\nclass.__instancecheck__(self, instance)\n\n   Return true if *instance* should be considered a (direct or\n   indirect) instance of *class*. If defined, called to implement\n   ``isinstance(instance, class)``.\n\nclass.__subclasscheck__(self, subclass)\n\n   Return true if *subclass* should be considered a (direct or\n   indirect) subclass of *class*.  If defined, called to implement\n   ``issubclass(subclass, class)``.\n\nNote that these methods are looked up on the type (metaclass) of a\nclass.  They cannot be defined as class methods in the actual class.\nThis is consistent with the lookup of special methods that are called\non instances, only in this case the instance is itself a class.\n\nSee also:\n\n   **PEP 3119** - Introducing Abstract Base Classes\n      Includes the specification for customizing ``isinstance()`` and\n      ``issubclass()`` behavior through ``__instancecheck__()`` and\n      ``__subclasscheck__()``, with motivation for this functionality\n      in the context of adding Abstract Base Classes (see the ``abc``\n      module) to the language.\n\n\nEmulating callable objects\n==========================\n\nobject.__call__(self[, args...])\n\n   Called when the instance is "called" as a function; if this method\n   is defined, ``x(arg1, arg2, ...)`` is a shorthand for\n   ``x.__call__(arg1, arg2, ...)``.\n\n\nEmulating container types\n=========================\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well.  The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which ``0 <= k < N``\nwhere *N* is the length of the sequence, or slice objects, which\ndefine a range of items.  It is also recommended that mappings provide\nthe methods ``keys()``, ``values()``, ``items()``, ``get()``,\n``clear()``, ``setdefault()``, ``pop()``, ``popitem()``, ``copy()``,\nand ``update()`` behaving similar to those for Python\'s standard\ndictionary objects.  The ``collections`` module provides a\n``MutableMapping`` abstract base class to help create those methods\nfrom a base set of ``__getitem__()``, ``__setitem__()``,\n``__delitem__()``, and ``keys()``. Mutable sequences should provide\nmethods ``append()``, ``count()``, ``index()``, ``extend()``,\n``insert()``, ``pop()``, ``remove()``, ``reverse()`` and ``sort()``,\nlike Python standard list objects.  Finally, sequence types should\nimplement addition (meaning concatenation) and multiplication (meaning\nrepetition) by defining the methods ``__add__()``, ``__radd__()``,\n``__iadd__()``, ``__mul__()``, ``__rmul__()`` and ``__imul__()``\ndescribed below; they should not define other numerical operators.  It\nis recommended that both mappings and sequences implement the\n``__contains__()`` method to allow efficient use of the ``in``\noperator; for mappings, ``in`` should search the mapping\'s keys; for\nsequences, it should search through the values.  It is further\nrecommended that both mappings and sequences implement the\n``__iter__()`` method to allow efficient iteration through the\ncontainer; for mappings, ``__iter__()`` should be the same as\n``keys()``; for sequences, it should iterate through the values.\n\nobject.__len__(self)\n\n   Called to implement the built-in function ``len()``.  Should return\n   the length of the object, an integer ``>=`` 0.  Also, an object\n   that doesn\'t define a ``__bool__()`` method and whose ``__len__()``\n   method returns zero is considered to be false in a Boolean context.\n\nobject.__length_hint__(self)\n\n   Called to implement ``operator.length_hint()``. Should return an\n   estimated length for the object (which may be greater or less than\n   the actual length). The length must be an integer ``>=`` 0. This\n   method is purely an optimization and is never required for\n   correctness.\n\n   New in version 3.4.\n\nNote: Slicing is done exclusively with the following three methods.  A\n  call like\n\n     a[1:2] = b\n\n  is translated to\n\n     a[slice(1, 2, None)] = b\n\n  and so forth.  Missing slice items are always filled in with\n  ``None``.\n\nobject.__getitem__(self, key)\n\n   Called to implement evaluation of ``self[key]``. For sequence\n   types, the accepted keys should be integers and slice objects.\n   Note that the special interpretation of negative indexes (if the\n   class wishes to emulate a sequence type) is up to the\n   ``__getitem__()`` method. If *key* is of an inappropriate type,\n   ``TypeError`` may be raised; if of a value outside the set of\n   indexes for the sequence (after any special interpretation of\n   negative values), ``IndexError`` should be raised. For mapping\n   types, if *key* is missing (not in the container), ``KeyError``\n   should be raised.\n\n   Note: ``for`` loops expect that an ``IndexError`` will be raised for\n     illegal indexes to allow proper detection of the end of the\n     sequence.\n\nobject.__setitem__(self, key, value)\n\n   Called to implement assignment to ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support changes to the values for keys, or if new keys\n   can be added, or for sequences if elements can be replaced.  The\n   same exceptions should be raised for improper *key* values as for\n   the ``__getitem__()`` method.\n\nobject.__delitem__(self, key)\n\n   Called to implement deletion of ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support removal of keys, or for sequences if elements\n   can be removed from the sequence.  The same exceptions should be\n   raised for improper *key* values as for the ``__getitem__()``\n   method.\n\nobject.__iter__(self)\n\n   This method is called when an iterator is required for a container.\n   This method should return a new iterator object that can iterate\n   over all the objects in the container.  For mappings, it should\n   iterate over the keys of the container, and should also be made\n   available as the method ``keys()``.\n\n   Iterator objects also need to implement this method; they are\n   required to return themselves.  For more information on iterator\n   objects, see *Iterator Types*.\n\nobject.__reversed__(self)\n\n   Called (if present) by the ``reversed()`` built-in to implement\n   reverse iteration.  It should return a new iterator object that\n   iterates over all the objects in the container in reverse order.\n\n   If the ``__reversed__()`` method is not provided, the\n   ``reversed()`` built-in will fall back to using the sequence\n   protocol (``__len__()`` and ``__getitem__()``).  Objects that\n   support the sequence protocol should only provide\n   ``__reversed__()`` if they can provide an implementation that is\n   more efficient than the one provided by ``reversed()``.\n\nThe membership test operators (``in`` and ``not in``) are normally\nimplemented as an iteration through a sequence.  However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n   Called to implement membership test operators.  Should return true\n   if *item* is in *self*, false otherwise.  For mapping objects, this\n   should consider the keys of the mapping rather than the values or\n   the key-item pairs.\n\n   For objects that don\'t define ``__contains__()``, the membership\n   test first tries iteration via ``__iter__()``, then the old\n   sequence iteration protocol via ``__getitem__()``, see *this\n   section in the language reference*.\n\n\nEmulating numeric types\n=======================\n\nThe following methods can be defined to emulate numeric objects.\nMethods corresponding to operations that are not supported by the\nparticular kind of number implemented (e.g., bitwise operations for\nnon-integral numbers) should be left undefined.\n\nobject.__add__(self, other)\nobject.__sub__(self, other)\nobject.__mul__(self, other)\nobject.__truediv__(self, other)\nobject.__floordiv__(self, other)\nobject.__mod__(self, other)\nobject.__divmod__(self, other)\nobject.__pow__(self, other[, modulo])\nobject.__lshift__(self, other)\nobject.__rshift__(self, other)\nobject.__and__(self, other)\nobject.__xor__(self, other)\nobject.__or__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``).  For instance, to evaluate the expression ``x + y``, where\n   *x* is an instance of a class that has an ``__add__()`` method,\n   ``x.__add__(y)`` is called.  The ``__divmod__()`` method should be\n   the equivalent to using ``__floordiv__()`` and ``__mod__()``; it\n   should not be related to ``__truediv__()``.  Note that\n   ``__pow__()`` should be defined to accept an optional third\n   argument if the ternary version of the built-in ``pow()`` function\n   is to be supported.\n\n   If one of those methods does not support the operation with the\n   supplied arguments, it should return ``NotImplemented``.\n\nobject.__radd__(self, other)\nobject.__rsub__(self, other)\nobject.__rmul__(self, other)\nobject.__rtruediv__(self, other)\nobject.__rfloordiv__(self, other)\nobject.__rmod__(self, other)\nobject.__rdivmod__(self, other)\nobject.__rpow__(self, other)\nobject.__rlshift__(self, other)\nobject.__rrshift__(self, other)\nobject.__rand__(self, other)\nobject.__rxor__(self, other)\nobject.__ror__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``) with reflected (swapped) operands. These functions are only\n   called if the left operand does not support the corresponding\n   operation and the operands are of different types. [2]  For\n   instance, to evaluate the expression ``x - y``, where *y* is an\n   instance of a class that has an ``__rsub__()`` method,\n   ``y.__rsub__(x)`` is called if ``x.__sub__(y)`` returns\n   *NotImplemented*.\n\n   Note that ternary ``pow()`` will not try calling ``__rpow__()``\n   (the coercion rules would become too complicated).\n\n   Note: If the right operand\'s type is a subclass of the left operand\'s\n     type and that subclass provides the reflected method for the\n     operation, this method will be called before the left operand\'s\n     non-reflected method.  This behavior allows subclasses to\n     override their ancestors\' operations.\n\nobject.__iadd__(self, other)\nobject.__isub__(self, other)\nobject.__imul__(self, other)\nobject.__itruediv__(self, other)\nobject.__ifloordiv__(self, other)\nobject.__imod__(self, other)\nobject.__ipow__(self, other[, modulo])\nobject.__ilshift__(self, other)\nobject.__irshift__(self, other)\nobject.__iand__(self, other)\nobject.__ixor__(self, other)\nobject.__ior__(self, other)\n\n   These methods are called to implement the augmented arithmetic\n   assignments (``+=``, ``-=``, ``*=``, ``/=``, ``//=``, ``%=``,\n   ``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``).  These methods\n   should attempt to do the operation in-place (modifying *self*) and\n   return the result (which could be, but does not have to be,\n   *self*).  If a specific method is not defined, the augmented\n   assignment falls back to the normal methods.  For instance, to\n   execute the statement ``x += y``, where *x* is an instance of a\n   class that has an ``__iadd__()`` method, ``x.__iadd__(y)`` is\n   called.  If *x* is an instance of a class that does not define a\n   ``__iadd__()`` method, ``x.__add__(y)`` and ``y.__radd__(x)`` are\n   considered, as with the evaluation of ``x + y``.\n\nobject.__neg__(self)\nobject.__pos__(self)\nobject.__abs__(self)\nobject.__invert__(self)\n\n   Called to implement the unary arithmetic operations (``-``, ``+``,\n   ``abs()`` and ``~``).\n\nobject.__complex__(self)\nobject.__int__(self)\nobject.__float__(self)\nobject.__round__(self[, n])\n\n   Called to implement the built-in functions ``complex()``,\n   ``int()``, ``float()`` and ``round()``.  Should return a value of\n   the appropriate type.\n\nobject.__index__(self)\n\n   Called to implement ``operator.index()``.  Also called whenever\n   Python needs an integer object (such as in slicing, or in the\n   built-in ``bin()``, ``hex()`` and ``oct()`` functions). Must return\n   an integer.\n\n\nWith Statement Context Managers\n===============================\n\nA *context manager* is an object that defines the runtime context to\nbe established when executing a ``with`` statement. The context\nmanager handles the entry into, and the exit from, the desired runtime\ncontext for the execution of the block of code.  Context managers are\nnormally invoked using the ``with`` statement (described in section\n*The with statement*), but can also be used by directly invoking their\nmethods.\n\nTypical uses of context managers include saving and restoring various\nkinds of global state, locking and unlocking resources, closing opened\nfiles, etc.\n\nFor more information on context managers, see *Context Manager Types*.\n\nobject.__enter__(self)\n\n   Enter the runtime context related to this object. The ``with``\n   statement will bind this method\'s return value to the target(s)\n   specified in the ``as`` clause of the statement, if any.\n\nobject.__exit__(self, exc_type, exc_value, traceback)\n\n   Exit the runtime context related to this object. The parameters\n   describe the exception that caused the context to be exited. If the\n   context was exited without an exception, all three arguments will\n   be ``None``.\n\n   If an exception is supplied, and the method wishes to suppress the\n   exception (i.e., prevent it from being propagated), it should\n   return a true value. Otherwise, the exception will be processed\n   normally upon exit from this method.\n\n   Note that ``__exit__()`` methods should not reraise the passed-in\n   exception; this is the caller\'s responsibility.\n\nSee also:\n\n   **PEP 0343** - The "with" statement\n      The specification, background, and examples for the Python\n      ``with`` statement.\n\n\nSpecial method lookup\n=====================\n\nFor custom classes, implicit invocations of special methods are only\nguaranteed to work correctly if defined on an object\'s type, not in\nthe object\'s instance dictionary.  That behaviour is the reason why\nthe following code raises an exception:\n\n   >>> class C:\n   ...     pass\n   ...\n   >>> c = C()\n   >>> c.__len__ = lambda: 5\n   >>> len(c)\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in <module>\n   TypeError: object of type \'C\' has no len()\n\nThe rationale behind this behaviour lies with a number of special\nmethods such as ``__hash__()`` and ``__repr__()`` that are implemented\nby all objects, including type objects. If the implicit lookup of\nthese methods used the conventional lookup process, they would fail\nwhen invoked on the type object itself:\n\n   >>> 1 .__hash__() == hash(1)\n   True\n   >>> int.__hash__() == hash(int)\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in <module>\n   TypeError: descriptor \'__hash__\' of \'int\' object needs an argument\n\nIncorrectly attempting to invoke an unbound method of a class in this\nway is sometimes referred to as \'metaclass confusion\', and is avoided\nby bypassing the instance when looking up special methods:\n\n   >>> type(1).__hash__(1) == hash(1)\n   True\n   >>> type(int).__hash__(int) == hash(int)\n   True\n\nIn addition to bypassing any instance attributes in the interest of\ncorrectness, implicit special method lookup generally also bypasses\nthe ``__getattribute__()`` method even of the object\'s metaclass:\n\n   >>> class Meta(type):\n   ...    def __getattribute__(*args):\n   ...       print("Metaclass getattribute invoked")\n   ...       return type.__getattribute__(*args)\n   ...\n   >>> class C(object, metaclass=Meta):\n   ...     def __len__(self):\n   ...         return 10\n   ...     def __getattribute__(*args):\n   ...         print("Class getattribute invoked")\n   ...         return object.__getattribute__(*args)\n   ...\n   >>> c = C()\n   >>> c.__len__()                 # Explicit lookup via instance\n   Class getattribute invoked\n   10\n   >>> type(c).__len__(c)          # Explicit lookup via type\n   Metaclass getattribute invoked\n   10\n   >>> len(c)                      # Implicit lookup\n   10\n\nBypassing the ``__getattribute__()`` machinery in this fashion\nprovides significant scope for speed optimisations within the\ninterpreter, at the cost of some flexibility in the handling of\nspecial methods (the special method *must* be set on the class object\nitself in order to be consistently invoked by the interpreter).\n\n-[ Footnotes ]-\n\n[1] It *is* possible in some cases to change an object\'s type, under\n    certain controlled conditions. It generally isn\'t a good idea\n    though, since it can lead to some very strange behaviour if it is\n    handled incorrectly.\n\n[2] For operands of the same type, it is assumed that if the non-\n    reflected method (such as ``__add__()``) fails the operation is\n    not supported, which is why the reflected method is not called.\n',
- 'string-methods': '\nString Methods\n**************\n\nStrings implement all of the *common* sequence operations, along with\nthe additional methods described below.\n\nStrings also support two styles of string formatting, one providing a\nlarge degree of flexibility and customization (see ``str.format()``,\n*Format String Syntax* and *String Formatting*) and the other based on\nC ``printf`` style formatting that handles a narrower range of types\nand is slightly harder to use correctly, but is often faster for the\ncases it can handle (*printf-style String Formatting*).\n\nThe *Text Processing Services* section of the standard library covers\na number of other modules that provide various text related utilities\n(including regular expression support in the ``re`` module).\n\nstr.capitalize()\n\n   Return a copy of the string with its first character capitalized\n   and the rest lowercased.\n\nstr.casefold()\n\n   Return a casefolded copy of the string. Casefolded strings may be\n   used for caseless matching.\n\n   Casefolding is similar to lowercasing but more aggressive because\n   it is intended to remove all case distinctions in a string. For\n   example, the German lowercase letter ``\'\xc3\x9f\'`` is equivalent to\n   ``"ss"``. Since it is already lowercase, ``lower()`` would do\n   nothing to ``\'\xc3\x9f\'``; ``casefold()`` converts it to ``"ss"``.\n\n   The casefolding algorithm is described in section 3.13 of the\n   Unicode Standard.\n\n   New in version 3.3.\n\nstr.center(width[, fillchar])\n\n   Return centered in a string of length *width*. Padding is done\n   using the specified *fillchar* (default is a space).\n\nstr.count(sub[, start[, end]])\n\n   Return the number of non-overlapping occurrences of substring *sub*\n   in the range [*start*, *end*].  Optional arguments *start* and\n   *end* are interpreted as in slice notation.\n\nstr.encode(encoding="utf-8", errors="strict")\n\n   Return an encoded version of the string as a bytes object. Default\n   encoding is ``\'utf-8\'``. *errors* may be given to set a different\n   error handling scheme. The default for *errors* is ``\'strict\'``,\n   meaning that encoding errors raise a ``UnicodeError``. Other\n   possible values are ``\'ignore\'``, ``\'replace\'``,\n   ``\'xmlcharrefreplace\'``, ``\'backslashreplace\'`` and any other name\n   registered via ``codecs.register_error()``, see section *Codec Base\n   Classes*. For a list of possible encodings, see section *Standard\n   Encodings*.\n\n   Changed in version 3.1: Support for keyword arguments added.\n\nstr.endswith(suffix[, start[, end]])\n\n   Return ``True`` if the string ends with the specified *suffix*,\n   otherwise return ``False``.  *suffix* can also be a tuple of\n   suffixes to look for.  With optional *start*, test beginning at\n   that position.  With optional *end*, stop comparing at that\n   position.\n\nstr.expandtabs([tabsize])\n\n   Return a copy of the string where all tab characters are replaced\n   by one or more spaces, depending on the current column and the\n   given tab size.  Tab positions occur every *tabsize* characters\n   (default is 8, giving tab positions at columns 0, 8, 16 and so on).\n   To expand the string, the current column is set to zero and the\n   string is examined character by character.  If the character is a\n   tab (``\\t``), one or more space characters are inserted in the\n   result until the current column is equal to the next tab position.\n   (The tab character itself is not copied.)  If the character is a\n   newline (``\\n``) or return (``\\r``), it is copied and the current\n   column is reset to zero.  Any other character is copied unchanged\n   and the current column is incremented by one regardless of how the\n   character is represented when printed.\n\n   >>> \'01\\t012\\t0123\\t01234\'.expandtabs()\n   \'01      012     0123    01234\'\n   >>> \'01\\t012\\t0123\\t01234\'.expandtabs(4)\n   \'01  012 0123    01234\'\n\nstr.find(sub[, start[, end]])\n\n   Return the lowest index in the string where substring *sub* is\n   found, such that *sub* is contained in the slice ``s[start:end]``.\n   Optional arguments *start* and *end* are interpreted as in slice\n   notation.  Return ``-1`` if *sub* is not found.\n\n   Note: The ``find()`` method should be used only if you need to know the\n     position of *sub*.  To check if *sub* is a substring or not, use\n     the ``in`` operator:\n\n        >>> \'Py\' in \'Python\'\n        True\n\nstr.format(*args, **kwargs)\n\n   Perform a string formatting operation.  The string on which this\n   method is called can contain literal text or replacement fields\n   delimited by braces ``{}``.  Each replacement field contains either\n   the numeric index of a positional argument, or the name of a\n   keyword argument.  Returns a copy of the string where each\n   replacement field is replaced with the string value of the\n   corresponding argument.\n\n   >>> "The sum of 1 + 2 is {0}".format(1+2)\n   \'The sum of 1 + 2 is 3\'\n\n   See *Format String Syntax* for a description of the various\n   formatting options that can be specified in format strings.\n\nstr.format_map(mapping)\n\n   Similar to ``str.format(**mapping)``, except that ``mapping`` is\n   used directly and not copied to a ``dict`` .  This is useful if for\n   example ``mapping`` is a dict subclass:\n\n   >>> class Default(dict):\n   ...     def __missing__(self, key):\n   ...         return key\n   ...\n   >>> \'{name} was born in {country}\'.format_map(Default(name=\'Guido\'))\n   \'Guido was born in country\'\n\n   New in version 3.2.\n\nstr.index(sub[, start[, end]])\n\n   Like ``find()``, but raise ``ValueError`` when the substring is not\n   found.\n\nstr.isalnum()\n\n   Return true if all characters in the string are alphanumeric and\n   there is at least one character, false otherwise.  A character\n   ``c`` is alphanumeric if one of the following returns ``True``:\n   ``c.isalpha()``, ``c.isdecimal()``, ``c.isdigit()``, or\n   ``c.isnumeric()``.\n\nstr.isalpha()\n\n   Return true if all characters in the string are alphabetic and\n   there is at least one character, false otherwise.  Alphabetic\n   characters are those characters defined in the Unicode character\n   database as "Letter", i.e., those with general category property\n   being one of "Lm", "Lt", "Lu", "Ll", or "Lo".  Note that this is\n   different from the "Alphabetic" property defined in the Unicode\n   Standard.\n\nstr.isdecimal()\n\n   Return true if all characters in the string are decimal characters\n   and there is at least one character, false otherwise. Decimal\n   characters are those from general category "Nd". This category\n   includes digit characters, and all characters that can be used to\n   form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO.\n\nstr.isdigit()\n\n   Return true if all characters in the string are digits and there is\n   at least one character, false otherwise.  Digits include decimal\n   characters and digits that need special handling, such as the\n   compatibility superscript digits.  Formally, a digit is a character\n   that has the property value Numeric_Type=Digit or\n   Numeric_Type=Decimal.\n\nstr.isidentifier()\n\n   Return true if the string is a valid identifier according to the\n   language definition, section *Identifiers and keywords*.\n\n   Use ``keyword.iskeyword()`` to test for reserved identifiers such\n   as ``def`` and ``class``.\n\nstr.islower()\n\n   Return true if all cased characters [4] in the string are lowercase\n   and there is at least one cased character, false otherwise.\n\nstr.isnumeric()\n\n   Return true if all characters in the string are numeric characters,\n   and there is at least one character, false otherwise. Numeric\n   characters include digit characters, and all characters that have\n   the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION\n   ONE FIFTH.  Formally, numeric characters are those with the\n   property value Numeric_Type=Digit, Numeric_Type=Decimal or\n   Numeric_Type=Numeric.\n\nstr.isprintable()\n\n   Return true if all characters in the string are printable or the\n   string is empty, false otherwise.  Nonprintable characters are\n   those characters defined in the Unicode character database as\n   "Other" or "Separator", excepting the ASCII space (0x20) which is\n   considered printable.  (Note that printable characters in this\n   context are those which should not be escaped when ``repr()`` is\n   invoked on a string.  It has no bearing on the handling of strings\n   written to ``sys.stdout`` or ``sys.stderr``.)\n\nstr.isspace()\n\n   Return true if there are only whitespace characters in the string\n   and there is at least one character, false otherwise.  Whitespace\n   characters  are those characters defined in the Unicode character\n   database as "Other" or "Separator" and those with bidirectional\n   property being one of "WS", "B", or "S".\n\nstr.istitle()\n\n   Return true if the string is a titlecased string and there is at\n   least one character, for example uppercase characters may only\n   follow uncased characters and lowercase characters only cased ones.\n   Return false otherwise.\n\nstr.isupper()\n\n   Return true if all cased characters [4] in the string are uppercase\n   and there is at least one cased character, false otherwise.\n\nstr.join(iterable)\n\n   Return a string which is the concatenation of the strings in the\n   *iterable* *iterable*.  A ``TypeError`` will be raised if there are\n   any non-string values in *iterable*, including ``bytes`` objects.\n   The separator between elements is the string providing this method.\n\nstr.ljust(width[, fillchar])\n\n   Return the string left justified in a string of length *width*.\n   Padding is done using the specified *fillchar* (default is a\n   space).  The original string is returned if *width* is less than or\n   equal to ``len(s)``.\n\nstr.lower()\n\n   Return a copy of the string with all the cased characters [4]\n   converted to lowercase.\n\n   The lowercasing algorithm used is described in section 3.13 of the\n   Unicode Standard.\n\nstr.lstrip([chars])\n\n   Return a copy of the string with leading characters removed.  The\n   *chars* argument is a string specifying the set of characters to be\n   removed.  If omitted or ``None``, the *chars* argument defaults to\n   removing whitespace.  The *chars* argument is not a prefix; rather,\n   all combinations of its values are stripped:\n\n   >>> \'   spacious   \'.lstrip()\n   \'spacious   \'\n   >>> \'www.example.com\'.lstrip(\'cmowz.\')\n   \'example.com\'\n\nstatic str.maketrans(x[, y[, z]])\n\n   This static method returns a translation table usable for\n   ``str.translate()``.\n\n   If there is only one argument, it must be a dictionary mapping\n   Unicode ordinals (integers) or characters (strings of length 1) to\n   Unicode ordinals, strings (of arbitrary lengths) or None.\n   Character keys will then be converted to ordinals.\n\n   If there are two arguments, they must be strings of equal length,\n   and in the resulting dictionary, each character in x will be mapped\n   to the character at the same position in y.  If there is a third\n   argument, it must be a string, whose characters will be mapped to\n   None in the result.\n\nstr.partition(sep)\n\n   Split the string at the first occurrence of *sep*, and return a\n   3-tuple containing the part before the separator, the separator\n   itself, and the part after the separator.  If the separator is not\n   found, return a 3-tuple containing the string itself, followed by\n   two empty strings.\n\nstr.replace(old, new[, count])\n\n   Return a copy of the string with all occurrences of substring *old*\n   replaced by *new*.  If the optional argument *count* is given, only\n   the first *count* occurrences are replaced.\n\nstr.rfind(sub[, start[, end]])\n\n   Return the highest index in the string where substring *sub* is\n   found, such that *sub* is contained within ``s[start:end]``.\n   Optional arguments *start* and *end* are interpreted as in slice\n   notation.  Return ``-1`` on failure.\n\nstr.rindex(sub[, start[, end]])\n\n   Like ``rfind()`` but raises ``ValueError`` when the substring *sub*\n   is not found.\n\nstr.rjust(width[, fillchar])\n\n   Return the string right justified in a string of length *width*.\n   Padding is done using the specified *fillchar* (default is a\n   space). The original string is returned if *width* is less than or\n   equal to ``len(s)``.\n\nstr.rpartition(sep)\n\n   Split the string at the last occurrence of *sep*, and return a\n   3-tuple containing the part before the separator, the separator\n   itself, and the part after the separator.  If the separator is not\n   found, return a 3-tuple containing two empty strings, followed by\n   the string itself.\n\nstr.rsplit(sep=None, maxsplit=-1)\n\n   Return a list of the words in the string, using *sep* as the\n   delimiter string. If *maxsplit* is given, at most *maxsplit* splits\n   are done, the *rightmost* ones.  If *sep* is not specified or\n   ``None``, any whitespace string is a separator.  Except for\n   splitting from the right, ``rsplit()`` behaves like ``split()``\n   which is described in detail below.\n\nstr.rstrip([chars])\n\n   Return a copy of the string with trailing characters removed.  The\n   *chars* argument is a string specifying the set of characters to be\n   removed.  If omitted or ``None``, the *chars* argument defaults to\n   removing whitespace.  The *chars* argument is not a suffix; rather,\n   all combinations of its values are stripped:\n\n   >>> \'   spacious   \'.rstrip()\n   \'   spacious\'\n   >>> \'mississippi\'.rstrip(\'ipz\')\n   \'mississ\'\n\nstr.split(sep=None, maxsplit=-1)\n\n   Return a list of the words in the string, using *sep* as the\n   delimiter string.  If *maxsplit* is given, at most *maxsplit*\n   splits are done (thus, the list will have at most ``maxsplit+1``\n   elements).  If *maxsplit* is not specified or ``-1``, then there is\n   no limit on the number of splits (all possible splits are made).\n\n   If *sep* is given, consecutive delimiters are not grouped together\n   and are deemed to delimit empty strings (for example,\n   ``\'1,,2\'.split(\',\')`` returns ``[\'1\', \'\', \'2\']``).  The *sep*\n   argument may consist of multiple characters (for example,\n   ``\'1<>2<>3\'.split(\'<>\')`` returns ``[\'1\', \'2\', \'3\']``). Splitting\n   an empty string with a specified separator returns ``[\'\']``.\n\n   If *sep* is not specified or is ``None``, a different splitting\n   algorithm is applied: runs of consecutive whitespace are regarded\n   as a single separator, and the result will contain no empty strings\n   at the start or end if the string has leading or trailing\n   whitespace.  Consequently, splitting an empty string or a string\n   consisting of just whitespace with a ``None`` separator returns\n   ``[]``.\n\n   For example, ``\' 1  2   3  \'.split()`` returns ``[\'1\', \'2\', \'3\']``,\n   and ``\'  1  2   3  \'.split(None, 1)`` returns ``[\'1\', \'2   3  \']``.\n\nstr.splitlines([keepends])\n\n   Return a list of the lines in the string, breaking at line\n   boundaries. This method uses the *universal newlines* approach to\n   splitting lines. Line breaks are not included in the resulting list\n   unless *keepends* is given and true.\n\n   For example, ``\'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines()`` returns\n   ``[\'ab c\', \'\', \'de fg\', \'kl\']``, while the same call with\n   ``splitlines(True)`` returns ``[\'ab c\\n\', \'\\n\', \'de fg\\r\',\n   \'kl\\r\\n\']``.\n\n   Unlike ``split()`` when a delimiter string *sep* is given, this\n   method returns an empty list for the empty string, and a terminal\n   line break does not result in an extra line.\n\nstr.startswith(prefix[, start[, end]])\n\n   Return ``True`` if string starts with the *prefix*, otherwise\n   return ``False``. *prefix* can also be a tuple of prefixes to look\n   for.  With optional *start*, test string beginning at that\n   position.  With optional *end*, stop comparing string at that\n   position.\n\nstr.strip([chars])\n\n   Return a copy of the string with the leading and trailing\n   characters removed. The *chars* argument is a string specifying the\n   set of characters to be removed. If omitted or ``None``, the\n   *chars* argument defaults to removing whitespace. The *chars*\n   argument is not a prefix or suffix; rather, all combinations of its\n   values are stripped:\n\n   >>> \'   spacious   \'.strip()\n   \'spacious\'\n   >>> \'www.example.com\'.strip(\'cmowz.\')\n   \'example\'\n\nstr.swapcase()\n\n   Return a copy of the string with uppercase characters converted to\n   lowercase and vice versa. Note that it is not necessarily true that\n   ``s.swapcase().swapcase() == s``.\n\nstr.title()\n\n   Return a titlecased version of the string where words start with an\n   uppercase character and the remaining characters are lowercase.\n\n   The algorithm uses a simple language-independent definition of a\n   word as groups of consecutive letters.  The definition works in\n   many contexts but it means that apostrophes in contractions and\n   possessives form word boundaries, which may not be the desired\n   result:\n\n      >>> "they\'re bill\'s friends from the UK".title()\n      "They\'Re Bill\'S Friends From The Uk"\n\n   A workaround for apostrophes can be constructed using regular\n   expressions:\n\n      >>> import re\n      >>> def titlecase(s):\n      ...     return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n      ...                   lambda mo: mo.group(0)[0].upper() +\n      ...                              mo.group(0)[1:].lower(),\n      ...                   s)\n      ...\n      >>> titlecase("they\'re bill\'s friends.")\n      "They\'re Bill\'s Friends."\n\nstr.translate(map)\n\n   Return a copy of the *s* where all characters have been mapped\n   through the *map* which must be a dictionary of Unicode ordinals\n   (integers) to Unicode ordinals, strings or ``None``.  Unmapped\n   characters are left untouched. Characters mapped to ``None`` are\n   deleted.\n\n   You can use ``str.maketrans()`` to create a translation map from\n   character-to-character mappings in different formats.\n\n   Note: An even more flexible approach is to create a custom character\n     mapping codec using the ``codecs`` module (see\n     ``encodings.cp1251`` for an example).\n\nstr.upper()\n\n   Return a copy of the string with all the cased characters [4]\n   converted to uppercase.  Note that ``str.upper().isupper()`` might\n   be ``False`` if ``s`` contains uncased characters or if the Unicode\n   category of the resulting character(s) is not "Lu" (Letter,\n   uppercase), but e.g. "Lt" (Letter, titlecase).\n\n   The uppercasing algorithm used is described in section 3.13 of the\n   Unicode Standard.\n\nstr.zfill(width)\n\n   Return the numeric string left filled with zeros in a string of\n   length *width*.  A sign prefix is handled correctly.  The original\n   string is returned if *width* is less than or equal to ``len(s)``.\n',
+ 'specialnames': '\nSpecial method names\n********************\n\nA class can implement certain operations that are invoked by special\nsyntax (such as arithmetic operations or subscripting and slicing) by\ndefining methods with special names. This is Python\'s approach to\n*operator overloading*, allowing classes to define their own behavior\nwith respect to language operators.  For instance, if a class defines\na method named ``__getitem__()``, and ``x`` is an instance of this\nclass, then ``x[i]`` is roughly equivalent to ``type(x).__getitem__(x,\ni)``.  Except where mentioned, attempts to execute an operation raise\nan exception when no appropriate method is defined (typically\n``AttributeError`` or ``TypeError``).\n\nWhen implementing a class that emulates any built-in type, it is\nimportant that the emulation only be implemented to the degree that it\nmakes sense for the object being modelled.  For example, some\nsequences may work well with retrieval of individual elements, but\nextracting a slice may not make sense.  (One example of this is the\n``NodeList`` interface in the W3C\'s Document Object Model.)\n\n\nBasic customization\n===================\n\nobject.__new__(cls[, ...])\n\n   Called to create a new instance of class *cls*.  ``__new__()`` is a\n   static method (special-cased so you need not declare it as such)\n   that takes the class of which an instance was requested as its\n   first argument.  The remaining arguments are those passed to the\n   object constructor expression (the call to the class).  The return\n   value of ``__new__()`` should be the new object instance (usually\n   an instance of *cls*).\n\n   Typical implementations create a new instance of the class by\n   invoking the superclass\'s ``__new__()`` method using\n   ``super(currentclass, cls).__new__(cls[, ...])`` with appropriate\n   arguments and then modifying the newly-created instance as\n   necessary before returning it.\n\n   If ``__new__()`` returns an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will be invoked like\n   ``__init__(self[, ...])``, where *self* is the new instance and the\n   remaining arguments are the same as were passed to ``__new__()``.\n\n   If ``__new__()`` does not return an instance of *cls*, then the new\n   instance\'s ``__init__()`` method will not be invoked.\n\n   ``__new__()`` is intended mainly to allow subclasses of immutable\n   types (like int, str, or tuple) to customize instance creation.  It\n   is also commonly overridden in custom metaclasses in order to\n   customize class creation.\n\nobject.__init__(self[, ...])\n\n   Called when the instance is created.  The arguments are those\n   passed to the class constructor expression.  If a base class has an\n   ``__init__()`` method, the derived class\'s ``__init__()`` method,\n   if any, must explicitly call it to ensure proper initialization of\n   the base class part of the instance; for example:\n   ``BaseClass.__init__(self, [args...])``.  As a special constraint\n   on constructors, no value may be returned; doing so will cause a\n   ``TypeError`` to be raised at runtime.\n\nobject.__del__(self)\n\n   Called when the instance is about to be destroyed.  This is also\n   called a destructor.  If a base class has a ``__del__()`` method,\n   the derived class\'s ``__del__()`` method, if any, must explicitly\n   call it to ensure proper deletion of the base class part of the\n   instance.  Note that it is possible (though not recommended!) for\n   the ``__del__()`` method to postpone destruction of the instance by\n   creating a new reference to it.  It may then be called at a later\n   time when this new reference is deleted.  It is not guaranteed that\n   ``__del__()`` methods are called for objects that still exist when\n   the interpreter exits.\n\n   Note: ``del x`` doesn\'t directly call ``x.__del__()`` --- the former\n     decrements the reference count for ``x`` by one, and the latter\n     is only called when ``x``\'s reference count reaches zero.  Some\n     common situations that may prevent the reference count of an\n     object from going to zero include: circular references between\n     objects (e.g., a doubly-linked list or a tree data structure with\n     parent and child pointers); a reference to the object on the\n     stack frame of a function that caught an exception (the traceback\n     stored in ``sys.exc_info()[2]`` keeps the stack frame alive); or\n     a reference to the object on the stack frame that raised an\n     unhandled exception in interactive mode (the traceback stored in\n     ``sys.last_traceback`` keeps the stack frame alive).  The first\n     situation can only be remedied by explicitly breaking the cycles;\n     the latter two situations can be resolved by storing ``None`` in\n     ``sys.last_traceback``. Circular references which are garbage are\n     detected when the option cycle detector is enabled (it\'s on by\n     default), but can only be cleaned up if there are no Python-\n     level ``__del__()`` methods involved. Refer to the documentation\n     for the ``gc`` module for more information about how\n     ``__del__()`` methods are handled by the cycle detector,\n     particularly the description of the ``garbage`` value.\n\n   Warning: Due to the precarious circumstances under which ``__del__()``\n     methods are invoked, exceptions that occur during their execution\n     are ignored, and a warning is printed to ``sys.stderr`` instead.\n     Also, when ``__del__()`` is invoked in response to a module being\n     deleted (e.g., when execution of the program is done), other\n     globals referenced by the ``__del__()`` method may already have\n     been deleted or in the process of being torn down (e.g. the\n     import machinery shutting down).  For this reason, ``__del__()``\n     methods should do the absolute minimum needed to maintain\n     external invariants.  Starting with version 1.5, Python\n     guarantees that globals whose name begins with a single\n     underscore are deleted from their module before other globals are\n     deleted; if no other references to such globals exist, this may\n     help in assuring that imported modules are still available at the\n     time when the ``__del__()`` method is called.\n\nobject.__repr__(self)\n\n   Called by the ``repr()`` built-in function to compute the\n   "official" string representation of an object.  If at all possible,\n   this should look like a valid Python expression that could be used\n   to recreate an object with the same value (given an appropriate\n   environment).  If this is not possible, a string of the form\n   ``<...some useful description...>`` should be returned. The return\n   value must be a string object. If a class defines ``__repr__()``\n   but not ``__str__()``, then ``__repr__()`` is also used when an\n   "informal" string representation of instances of that class is\n   required.\n\n   This is typically used for debugging, so it is important that the\n   representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n   Called by ``str(object)`` and the built-in functions ``format()``\n   and ``print()`` to compute the "informal" or nicely printable\n   string representation of an object.  The return value must be a\n   *string* object.\n\n   This method differs from ``object.__repr__()`` in that there is no\n   expectation that ``__str__()`` return a valid Python expression: a\n   more convenient or concise representation can be used.\n\n   The default implementation defined by the built-in type ``object``\n   calls ``object.__repr__()``.\n\nobject.__bytes__(self)\n\n   Called by ``bytes()`` to compute a byte-string representation of an\n   object. This should return a ``bytes`` object.\n\nobject.__format__(self, format_spec)\n\n   Called by the ``format()`` built-in function (and by extension, the\n   ``str.format()`` method of class ``str``) to produce a "formatted"\n   string representation of an object. The ``format_spec`` argument is\n   a string that contains a description of the formatting options\n   desired. The interpretation of the ``format_spec`` argument is up\n   to the type implementing ``__format__()``, however most classes\n   will either delegate formatting to one of the built-in types, or\n   use a similar formatting option syntax.\n\n   See *Format Specification Mini-Language* for a description of the\n   standard formatting syntax.\n\n   The return value must be a string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n   These are the so-called "rich comparison" methods. The\n   correspondence between operator symbols and method names is as\n   follows: ``x<y`` calls ``x.__lt__(y)``, ``x<=y`` calls\n   ``x.__le__(y)``, ``x==y`` calls ``x.__eq__(y)``, ``x!=y`` calls\n   ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` calls\n   ``x.__ge__(y)``.\n\n   A rich comparison method may return the singleton\n   ``NotImplemented`` if it does not implement the operation for a\n   given pair of arguments. By convention, ``False`` and ``True`` are\n   returned for a successful comparison. However, these methods can\n   return any value, so if the comparison operator is used in a\n   Boolean context (e.g., in the condition of an ``if`` statement),\n   Python will call ``bool()`` on the value to determine if the result\n   is true or false.\n\n   There are no implied relationships among the comparison operators.\n   The truth of ``x==y`` does not imply that ``x!=y`` is false.\n   Accordingly, when defining ``__eq__()``, one should also define\n   ``__ne__()`` so that the operators will behave as expected.  See\n   the paragraph on ``__hash__()`` for some important notes on\n   creating *hashable* objects which support custom comparison\n   operations and are usable as dictionary keys.\n\n   There are no swapped-argument versions of these methods (to be used\n   when the left argument does not support the operation but the right\n   argument does); rather, ``__lt__()`` and ``__gt__()`` are each\n   other\'s reflection, ``__le__()`` and ``__ge__()`` are each other\'s\n   reflection, and ``__eq__()`` and ``__ne__()`` are their own\n   reflection.\n\n   Arguments to rich comparison methods are never coerced.\n\n   To automatically generate ordering operations from a single root\n   operation, see ``functools.total_ordering()``.\n\nobject.__hash__(self)\n\n   Called by built-in function ``hash()`` and for operations on\n   members of hashed collections including ``set``, ``frozenset``, and\n   ``dict``.  ``__hash__()`` should return an integer.  The only\n   required property is that objects which compare equal have the same\n   hash value; it is advised to somehow mix together (e.g. using\n   exclusive or) the hash values for the components of the object that\n   also play a part in comparison of objects.\n\n   If a class does not define an ``__eq__()`` method it should not\n   define a ``__hash__()`` operation either; if it defines\n   ``__eq__()`` but not ``__hash__()``, its instances will not be\n   usable as items in hashable collections.  If a class defines\n   mutable objects and implements an ``__eq__()`` method, it should\n   not implement ``__hash__()``, since the implementation of hashable\n   collections requires that a key\'s hash value is immutable (if the\n   object\'s hash value changes, it will be in the wrong hash bucket).\n\n   User-defined classes have ``__eq__()`` and ``__hash__()`` methods\n   by default; with them, all objects compare unequal (except with\n   themselves) and ``x.__hash__()`` returns an appropriate value such\n   that ``x == y`` implies both that ``x is y`` and ``hash(x) ==\n   hash(y)``.\n\n   A class that overrides ``__eq__()`` and does not define\n   ``__hash__()`` will have its ``__hash__()`` implicitly set to\n   ``None``.  When the ``__hash__()`` method of a class is ``None``,\n   instances of the class will raise an appropriate ``TypeError`` when\n   a program attempts to retrieve their hash value, and will also be\n   correctly identified as unhashable when checking ``isinstance(obj,\n   collections.Hashable``).\n\n   If a class that overrides ``__eq__()`` needs to retain the\n   implementation of ``__hash__()`` from a parent class, the\n   interpreter must be told this explicitly by setting ``__hash__ =\n   <ParentClass>.__hash__``.\n\n   If a class that does not override ``__eq__()`` wishes to suppress\n   hash support, it should include ``__hash__ = None`` in the class\n   definition. A class which defines its own ``__hash__()`` that\n   explicitly raises a ``TypeError`` would be incorrectly identified\n   as hashable by an ``isinstance(obj, collections.Hashable)`` call.\n\n   Note: By default, the ``__hash__()`` values of str, bytes and datetime\n     objects are "salted" with an unpredictable random value.\n     Although they remain constant within an individual Python\n     process, they are not predictable between repeated invocations of\n     Python.This is intended to provide protection against a denial-\n     of-service caused by carefully-chosen inputs that exploit the\n     worst case performance of a dict insertion, O(n^2) complexity.\n     See http://www.ocert.org/advisories/ocert-2011-003.html for\n     details.Changing hash values affects the iteration order of\n     dicts, sets and other mappings.  Python has never made guarantees\n     about this ordering (and it typically varies between 32-bit and\n     64-bit builds).See also ``PYTHONHASHSEED``.\n\n   Changed in version 3.3: Hash randomization is enabled by default.\n\nobject.__bool__(self)\n\n   Called to implement truth value testing and the built-in operation\n   ``bool()``; should return ``False`` or ``True``.  When this method\n   is not defined, ``__len__()`` is called, if it is defined, and the\n   object is considered true if its result is nonzero.  If a class\n   defines neither ``__len__()`` nor ``__bool__()``, all its instances\n   are considered true.\n\n\nCustomizing attribute access\n============================\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of ``x.name``)\nfor class instances.\n\nobject.__getattr__(self, name)\n\n   Called when an attribute lookup has not found the attribute in the\n   usual places (i.e. it is not an instance attribute nor is it found\n   in the class tree for ``self``).  ``name`` is the attribute name.\n   This method should return the (computed) attribute value or raise\n   an ``AttributeError`` exception.\n\n   Note that if the attribute is found through the normal mechanism,\n   ``__getattr__()`` is not called.  (This is an intentional asymmetry\n   between ``__getattr__()`` and ``__setattr__()``.) This is done both\n   for efficiency reasons and because otherwise ``__getattr__()``\n   would have no way to access other attributes of the instance.  Note\n   that at least for instance variables, you can fake total control by\n   not inserting any values in the instance attribute dictionary (but\n   instead inserting them in another object).  See the\n   ``__getattribute__()`` method below for a way to actually get total\n   control over attribute access.\n\nobject.__getattribute__(self, name)\n\n   Called unconditionally to implement attribute accesses for\n   instances of the class. If the class also defines\n   ``__getattr__()``, the latter will not be called unless\n   ``__getattribute__()`` either calls it explicitly or raises an\n   ``AttributeError``. This method should return the (computed)\n   attribute value or raise an ``AttributeError`` exception. In order\n   to avoid infinite recursion in this method, its implementation\n   should always call the base class method with the same name to\n   access any attributes it needs, for example,\n   ``object.__getattribute__(self, name)``.\n\n   Note: This method may still be bypassed when looking up special methods\n     as the result of implicit invocation via language syntax or\n     built-in functions. See *Special method lookup*.\n\nobject.__setattr__(self, name, value)\n\n   Called when an attribute assignment is attempted.  This is called\n   instead of the normal mechanism (i.e. store the value in the\n   instance dictionary). *name* is the attribute name, *value* is the\n   value to be assigned to it.\n\n   If ``__setattr__()`` wants to assign to an instance attribute, it\n   should call the base class method with the same name, for example,\n   ``object.__setattr__(self, name, value)``.\n\nobject.__delattr__(self, name)\n\n   Like ``__setattr__()`` but for attribute deletion instead of\n   assignment.  This should only be implemented if ``del obj.name`` is\n   meaningful for the object.\n\nobject.__dir__(self)\n\n   Called when ``dir()`` is called on the object. A sequence must be\n   returned. ``dir()`` converts the returned sequence to a list and\n   sorts it.\n\n\nImplementing Descriptors\n------------------------\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents).  In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' ``__dict__``.\n\nobject.__get__(self, instance, owner)\n\n   Called to get the attribute of the owner class (class attribute\n   access) or of an instance of that class (instance attribute\n   access). *owner* is always the owner class, while *instance* is the\n   instance that the attribute was accessed through, or ``None`` when\n   the attribute is accessed through the *owner*.  This method should\n   return the (computed) attribute value or raise an\n   ``AttributeError`` exception.\n\nobject.__set__(self, instance, value)\n\n   Called to set the attribute on an instance *instance* of the owner\n   class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n   Called to delete the attribute on an instance *instance* of the\n   owner class.\n\n\nInvoking Descriptors\n--------------------\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol:  ``__get__()``, ``__set__()``, and\n``__delete__()``. If any of those methods are defined for an object,\nit is said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, ``a.x`` has a\nlookup chain starting with ``a.__dict__[\'x\']``, then\n``type(a).__dict__[\'x\']``, and continuing through the base classes of\n``type(a)`` excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead.  Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called.\n\nThe starting point for descriptor invocation is a binding, ``a.x``.\nHow the arguments are assembled depends on ``a``:\n\nDirect Call\n   The simplest and least common call is when user code directly\n   invokes a descriptor method:    ``x.__get__(a)``.\n\nInstance Binding\n   If binding to an object instance, ``a.x`` is transformed into the\n   call: ``type(a).__dict__[\'x\'].__get__(a, type(a))``.\n\nClass Binding\n   If binding to a class, ``A.x`` is transformed into the call:\n   ``A.__dict__[\'x\'].__get__(None, A)``.\n\nSuper Binding\n   If ``a`` is an instance of ``super``, then the binding ``super(B,\n   obj).m()`` searches ``obj.__class__.__mro__`` for the base class\n   ``A`` immediately preceding ``B`` and then invokes the descriptor\n   with the call: ``A.__dict__[\'m\'].__get__(obj, obj.__class__)``.\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined.  A descriptor can define\nany combination of ``__get__()``, ``__set__()`` and ``__delete__()``.\nIf it does not define ``__get__()``, then accessing the attribute will\nreturn the descriptor object itself unless there is a value in the\nobject\'s instance dictionary.  If the descriptor defines ``__set__()``\nand/or ``__delete__()``, it is a data descriptor; if it defines\nneither, it is a non-data descriptor.  Normally, data descriptors\ndefine both ``__get__()`` and ``__set__()``, while non-data\ndescriptors have just the ``__get__()`` method.  Data descriptors with\n``__set__()`` and ``__get__()`` defined always override a redefinition\nin an instance dictionary.  In contrast, non-data descriptors can be\noverridden by instances.\n\nPython methods (including ``staticmethod()`` and ``classmethod()``)\nare implemented as non-data descriptors.  Accordingly, instances can\nredefine and override methods.  This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe ``property()`` function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n---------\n\nBy default, instances of classes have a dictionary for attribute\nstorage.  This wastes space for objects having very few instance\nvariables.  The space consumption can become acute when creating large\nnumbers of instances.\n\nThe default can be overridden by defining *__slots__* in a class\ndefinition. The *__slots__* declaration takes a sequence of instance\nvariables and reserves just enough space in each instance to hold a\nvalue for each variable.  Space is saved because *__dict__* is not\ncreated for each instance.\n\nobject.__slots__\n\n   This class variable can be assigned a string, iterable, or sequence\n   of strings with variable names used by instances.  If defined in a\n   class, *__slots__* reserves space for the declared variables and\n   prevents the automatic creation of *__dict__* and *__weakref__* for\n   each instance.\n\n\nNotes on using *__slots__*\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n  attribute of that class will always be accessible, so a *__slots__*\n  definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n  variables not listed in the *__slots__* definition.  Attempts to\n  assign to an unlisted variable name raises ``AttributeError``. If\n  dynamic assignment of new variables is desired, then add\n  ``\'__dict__\'`` to the sequence of strings in the *__slots__*\n  declaration.\n\n* Without a *__weakref__* variable for each instance, classes defining\n  *__slots__* do not support weak references to its instances. If weak\n  reference support is needed, then add ``\'__weakref__\'`` to the\n  sequence of strings in the *__slots__* declaration.\n\n* *__slots__* are implemented at the class level by creating\n  descriptors (*Implementing Descriptors*) for each variable name.  As\n  a result, class attributes cannot be used to set default values for\n  instance variables defined by *__slots__*; otherwise, the class\n  attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n  where it is defined.  As a result, subclasses will have a *__dict__*\n  unless they also define *__slots__* (which must only contain names\n  of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the instance\n  variable defined by the base class slot is inaccessible (except by\n  retrieving its descriptor directly from the base class). This\n  renders the meaning of the program undefined.  In the future, a\n  check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n  "variable-length" built-in types such as ``int``, ``str`` and\n  ``tuple``.\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings may\n  also be used; however, in the future, special meaning may be\n  assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n  *__slots__*.\n\n\nCustomizing class creation\n==========================\n\nBy default, classes are constructed using ``type()``. The class body\nis executed in a new namespace and the class name is bound locally to\nthe result of ``type(name, bases, namespace)``.\n\nThe class creation process can be customised by passing the\n``metaclass`` keyword argument in the class definition line, or by\ninheriting from an existing class that included such an argument. In\nthe following example, both ``MyClass`` and ``MySubclass`` are\ninstances of ``Meta``:\n\n   class Meta(type):\n       pass\n\n   class MyClass(metaclass=Meta):\n       pass\n\n   class MySubclass(MyClass):\n       pass\n\nAny other keyword arguments that are specified in the class definition\nare passed through to all metaclass operations described below.\n\nWhen a class definition is executed, the following steps occur:\n\n* the appropriate metaclass is determined\n\n* the class namespace is prepared\n\n* the class body is executed\n\n* the class object is created\n\n\nDetermining the appropriate metaclass\n-------------------------------------\n\nThe appropriate metaclass for a class definition is determined as\nfollows:\n\n* if no bases and no explicit metaclass are given, then ``type()`` is\n  used\n\n* if an explicit metaclass is given and it is *not* an instance of\n  ``type()``, then it is used directly as the metaclass\n\n* if an instance of ``type()`` is given as the explicit metaclass, or\n  bases are defined, then the most derived metaclass is used\n\nThe most derived metaclass is selected from the explicitly specified\nmetaclass (if any) and the metaclasses (i.e. ``type(cls)``) of all\nspecified base classes. The most derived metaclass is one which is a\nsubtype of *all* of these candidate metaclasses. If none of the\ncandidate metaclasses meets that criterion, then the class definition\nwill fail with ``TypeError``.\n\n\nPreparing the class namespace\n-----------------------------\n\nOnce the appropriate metaclass has been identified, then the class\nnamespace is prepared. If the metaclass has a ``__prepare__``\nattribute, it is called as ``namespace = metaclass.__prepare__(name,\nbases, **kwds)`` (where the additional keyword arguments, if any, come\nfrom the class definition).\n\nIf the metaclass has no ``__prepare__`` attribute, then the class\nnamespace is initialised as an empty ``dict()`` instance.\n\nSee also:\n\n   **PEP 3115** - Metaclasses in Python 3000\n      Introduced the ``__prepare__`` namespace hook\n\n\nExecuting the class body\n------------------------\n\nThe class body is executed (approximately) as ``exec(body, globals(),\nnamespace)``. The key difference from a normal call to ``exec()`` is\nthat lexical scoping allows the class body (including any methods) to\nreference names from the current and outer scopes when the class\ndefinition occurs inside a function.\n\nHowever, even when the class definition occurs inside the function,\nmethods defined inside the class still cannot see names defined at the\nclass scope. Class variables must be accessed through the first\nparameter of instance or class methods, and cannot be accessed at all\nfrom static methods.\n\n\nCreating the class object\n-------------------------\n\nOnce the class namespace has been populated by executing the class\nbody, the class object is created by calling ``metaclass(name, bases,\nnamespace, **kwds)`` (the additional keywords passed here are the same\nas those passed to ``__prepare__``).\n\nThis class object is the one that will be referenced by the zero-\nargument form of ``super()``. ``__class__`` is an implicit closure\nreference created by the compiler if any methods in a class body refer\nto either ``__class__`` or ``super``. This allows the zero argument\nform of ``super()`` to correctly identify the class being defined\nbased on lexical scoping, while the class or instance that was used to\nmake the current call is identified based on the first argument passed\nto the method.\n\nAfter the class object is created, it is passed to the class\ndecorators included in the class definition (if any) and the resulting\nobject is bound in the local namespace as the defined class.\n\nSee also:\n\n   **PEP 3135** - New super\n      Describes the implicit ``__class__`` closure reference\n\n\nMetaclass example\n-----------------\n\nThe potential uses for metaclasses are boundless. Some ideas that have\nbeen explored include logging, interface checking, automatic\ndelegation, automatic property creation, proxies, frameworks, and\nautomatic resource locking/synchronization.\n\nHere is an example of a metaclass that uses an\n``collections.OrderedDict`` to remember the order that class members\nwere defined:\n\n   class OrderedClass(type):\n\n        @classmethod\n        def __prepare__(metacls, name, bases, **kwds):\n           return collections.OrderedDict()\n\n        def __new__(cls, name, bases, namespace, **kwds):\n           result = type.__new__(cls, name, bases, dict(namespace))\n           result.members = tuple(namespace)\n           return result\n\n   class A(metaclass=OrderedClass):\n       def one(self): pass\n       def two(self): pass\n       def three(self): pass\n       def four(self): pass\n\n   >>> A.members\n   (\'__module__\', \'one\', \'two\', \'three\', \'four\')\n\nWhen the class definition for *A* gets executed, the process begins\nwith calling the metaclass\'s ``__prepare__()`` method which returns an\nempty ``collections.OrderedDict``.  That mapping records the methods\nand attributes of *A* as they are defined within the body of the class\nstatement. Once those definitions are executed, the ordered dictionary\nis fully populated and the metaclass\'s ``__new__()`` method gets\ninvoked.  That method builds the new type and it saves the ordered\ndictionary keys in an attribute called ``members``.\n\n\nCustomizing instance and subclass checks\n========================================\n\nThe following methods are used to override the default behavior of the\n``isinstance()`` and ``issubclass()`` built-in functions.\n\nIn particular, the metaclass ``abc.ABCMeta`` implements these methods\nin order to allow the addition of Abstract Base Classes (ABCs) as\n"virtual base classes" to any class or type (including built-in\ntypes), including other ABCs.\n\nclass.__instancecheck__(self, instance)\n\n   Return true if *instance* should be considered a (direct or\n   indirect) instance of *class*. If defined, called to implement\n   ``isinstance(instance, class)``.\n\nclass.__subclasscheck__(self, subclass)\n\n   Return true if *subclass* should be considered a (direct or\n   indirect) subclass of *class*.  If defined, called to implement\n   ``issubclass(subclass, class)``.\n\nNote that these methods are looked up on the type (metaclass) of a\nclass.  They cannot be defined as class methods in the actual class.\nThis is consistent with the lookup of special methods that are called\non instances, only in this case the instance is itself a class.\n\nSee also:\n\n   **PEP 3119** - Introducing Abstract Base Classes\n      Includes the specification for customizing ``isinstance()`` and\n      ``issubclass()`` behavior through ``__instancecheck__()`` and\n      ``__subclasscheck__()``, with motivation for this functionality\n      in the context of adding Abstract Base Classes (see the ``abc``\n      module) to the language.\n\n\nEmulating callable objects\n==========================\n\nobject.__call__(self[, args...])\n\n   Called when the instance is "called" as a function; if this method\n   is defined, ``x(arg1, arg2, ...)`` is a shorthand for\n   ``x.__call__(arg1, arg2, ...)``.\n\n\nEmulating container types\n=========================\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well.  The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which ``0 <= k < N``\nwhere *N* is the length of the sequence, or slice objects, which\ndefine a range of items.  It is also recommended that mappings provide\nthe methods ``keys()``, ``values()``, ``items()``, ``get()``,\n``clear()``, ``setdefault()``, ``pop()``, ``popitem()``, ``copy()``,\nand ``update()`` behaving similar to those for Python\'s standard\ndictionary objects.  The ``collections`` module provides a\n``MutableMapping`` abstract base class to help create those methods\nfrom a base set of ``__getitem__()``, ``__setitem__()``,\n``__delitem__()``, and ``keys()``. Mutable sequences should provide\nmethods ``append()``, ``count()``, ``index()``, ``extend()``,\n``insert()``, ``pop()``, ``remove()``, ``reverse()`` and ``sort()``,\nlike Python standard list objects.  Finally, sequence types should\nimplement addition (meaning concatenation) and multiplication (meaning\nrepetition) by defining the methods ``__add__()``, ``__radd__()``,\n``__iadd__()``, ``__mul__()``, ``__rmul__()`` and ``__imul__()``\ndescribed below; they should not define other numerical operators.  It\nis recommended that both mappings and sequences implement the\n``__contains__()`` method to allow efficient use of the ``in``\noperator; for mappings, ``in`` should search the mapping\'s keys; for\nsequences, it should search through the values.  It is further\nrecommended that both mappings and sequences implement the\n``__iter__()`` method to allow efficient iteration through the\ncontainer; for mappings, ``__iter__()`` should be the same as\n``keys()``; for sequences, it should iterate through the values.\n\nobject.__len__(self)\n\n   Called to implement the built-in function ``len()``.  Should return\n   the length of the object, an integer ``>=`` 0.  Also, an object\n   that doesn\'t define a ``__bool__()`` method and whose ``__len__()``\n   method returns zero is considered to be false in a Boolean context.\n\nNote: Slicing is done exclusively with the following three methods.  A\n  call like\n\n     a[1:2] = b\n\n  is translated to\n\n     a[slice(1, 2, None)] = b\n\n  and so forth.  Missing slice items are always filled in with\n  ``None``.\n\nobject.__getitem__(self, key)\n\n   Called to implement evaluation of ``self[key]``. For sequence\n   types, the accepted keys should be integers and slice objects.\n   Note that the special interpretation of negative indexes (if the\n   class wishes to emulate a sequence type) is up to the\n   ``__getitem__()`` method. If *key* is of an inappropriate type,\n   ``TypeError`` may be raised; if of a value outside the set of\n   indexes for the sequence (after any special interpretation of\n   negative values), ``IndexError`` should be raised. For mapping\n   types, if *key* is missing (not in the container), ``KeyError``\n   should be raised.\n\n   Note: ``for`` loops expect that an ``IndexError`` will be raised for\n     illegal indexes to allow proper detection of the end of the\n     sequence.\n\nobject.__setitem__(self, key, value)\n\n   Called to implement assignment to ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support changes to the values for keys, or if new keys\n   can be added, or for sequences if elements can be replaced.  The\n   same exceptions should be raised for improper *key* values as for\n   the ``__getitem__()`` method.\n\nobject.__delitem__(self, key)\n\n   Called to implement deletion of ``self[key]``.  Same note as for\n   ``__getitem__()``.  This should only be implemented for mappings if\n   the objects support removal of keys, or for sequences if elements\n   can be removed from the sequence.  The same exceptions should be\n   raised for improper *key* values as for the ``__getitem__()``\n   method.\n\nobject.__iter__(self)\n\n   This method is called when an iterator is required for a container.\n   This method should return a new iterator object that can iterate\n   over all the objects in the container.  For mappings, it should\n   iterate over the keys of the container, and should also be made\n   available as the method ``keys()``.\n\n   Iterator objects also need to implement this method; they are\n   required to return themselves.  For more information on iterator\n   objects, see *Iterator Types*.\n\nobject.__reversed__(self)\n\n   Called (if present) by the ``reversed()`` built-in to implement\n   reverse iteration.  It should return a new iterator object that\n   iterates over all the objects in the container in reverse order.\n\n   If the ``__reversed__()`` method is not provided, the\n   ``reversed()`` built-in will fall back to using the sequence\n   protocol (``__len__()`` and ``__getitem__()``).  Objects that\n   support the sequence protocol should only provide\n   ``__reversed__()`` if they can provide an implementation that is\n   more efficient than the one provided by ``reversed()``.\n\nThe membership test operators (``in`` and ``not in``) are normally\nimplemented as an iteration through a sequence.  However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n   Called to implement membership test operators.  Should return true\n   if *item* is in *self*, false otherwise.  For mapping objects, this\n   should consider the keys of the mapping rather than the values or\n   the key-item pairs.\n\n   For objects that don\'t define ``__contains__()``, the membership\n   test first tries iteration via ``__iter__()``, then the old\n   sequence iteration protocol via ``__getitem__()``, see *this\n   section in the language reference*.\n\n\nEmulating numeric types\n=======================\n\nThe following methods can be defined to emulate numeric objects.\nMethods corresponding to operations that are not supported by the\nparticular kind of number implemented (e.g., bitwise operations for\nnon-integral numbers) should be left undefined.\n\nobject.__add__(self, other)\nobject.__sub__(self, other)\nobject.__mul__(self, other)\nobject.__truediv__(self, other)\nobject.__floordiv__(self, other)\nobject.__mod__(self, other)\nobject.__divmod__(self, other)\nobject.__pow__(self, other[, modulo])\nobject.__lshift__(self, other)\nobject.__rshift__(self, other)\nobject.__and__(self, other)\nobject.__xor__(self, other)\nobject.__or__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``).  For instance, to evaluate the expression ``x + y``, where\n   *x* is an instance of a class that has an ``__add__()`` method,\n   ``x.__add__(y)`` is called.  The ``__divmod__()`` method should be\n   the equivalent to using ``__floordiv__()`` and ``__mod__()``; it\n   should not be related to ``__truediv__()``.  Note that\n   ``__pow__()`` should be defined to accept an optional third\n   argument if the ternary version of the built-in ``pow()`` function\n   is to be supported.\n\n   If one of those methods does not support the operation with the\n   supplied arguments, it should return ``NotImplemented``.\n\nobject.__radd__(self, other)\nobject.__rsub__(self, other)\nobject.__rmul__(self, other)\nobject.__rtruediv__(self, other)\nobject.__rfloordiv__(self, other)\nobject.__rmod__(self, other)\nobject.__rdivmod__(self, other)\nobject.__rpow__(self, other)\nobject.__rlshift__(self, other)\nobject.__rrshift__(self, other)\nobject.__rand__(self, other)\nobject.__rxor__(self, other)\nobject.__ror__(self, other)\n\n   These methods are called to implement the binary arithmetic\n   operations (``+``, ``-``, ``*``, ``/``, ``//``, ``%``,\n   ``divmod()``, ``pow()``, ``**``, ``<<``, ``>>``, ``&``, ``^``,\n   ``|``) with reflected (swapped) operands. These functions are only\n   called if the left operand does not support the corresponding\n   operation and the operands are of different types. [2]  For\n   instance, to evaluate the expression ``x - y``, where *y* is an\n   instance of a class that has an ``__rsub__()`` method,\n   ``y.__rsub__(x)`` is called if ``x.__sub__(y)`` returns\n   *NotImplemented*.\n\n   Note that ternary ``pow()`` will not try calling ``__rpow__()``\n   (the coercion rules would become too complicated).\n\n   Note: If the right operand\'s type is a subclass of the left operand\'s\n     type and that subclass provides the reflected method for the\n     operation, this method will be called before the left operand\'s\n     non-reflected method.  This behavior allows subclasses to\n     override their ancestors\' operations.\n\nobject.__iadd__(self, other)\nobject.__isub__(self, other)\nobject.__imul__(self, other)\nobject.__itruediv__(self, other)\nobject.__ifloordiv__(self, other)\nobject.__imod__(self, other)\nobject.__ipow__(self, other[, modulo])\nobject.__ilshift__(self, other)\nobject.__irshift__(self, other)\nobject.__iand__(self, other)\nobject.__ixor__(self, other)\nobject.__ior__(self, other)\n\n   These methods are called to implement the augmented arithmetic\n   assignments (``+=``, ``-=``, ``*=``, ``/=``, ``//=``, ``%=``,\n   ``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``).  These methods\n   should attempt to do the operation in-place (modifying *self*) and\n   return the result (which could be, but does not have to be,\n   *self*).  If a specific method is not defined, the augmented\n   assignment falls back to the normal methods.  For instance, to\n   execute the statement ``x += y``, where *x* is an instance of a\n   class that has an ``__iadd__()`` method, ``x.__iadd__(y)`` is\n   called.  If *x* is an instance of a class that does not define a\n   ``__iadd__()`` method, ``x.__add__(y)`` and ``y.__radd__(x)`` are\n   considered, as with the evaluation of ``x + y``.\n\nobject.__neg__(self)\nobject.__pos__(self)\nobject.__abs__(self)\nobject.__invert__(self)\n\n   Called to implement the unary arithmetic operations (``-``, ``+``,\n   ``abs()`` and ``~``).\n\nobject.__complex__(self)\nobject.__int__(self)\nobject.__float__(self)\nobject.__round__(self[, n])\n\n   Called to implement the built-in functions ``complex()``,\n   ``int()``, ``float()`` and ``round()``.  Should return a value of\n   the appropriate type.\n\nobject.__index__(self)\n\n   Called to implement ``operator.index()``.  Also called whenever\n   Python needs an integer object (such as in slicing, or in the\n   built-in ``bin()``, ``hex()`` and ``oct()`` functions). Must return\n   an integer.\n\n\nWith Statement Context Managers\n===============================\n\nA *context manager* is an object that defines the runtime context to\nbe established when executing a ``with`` statement. The context\nmanager handles the entry into, and the exit from, the desired runtime\ncontext for the execution of the block of code.  Context managers are\nnormally invoked using the ``with`` statement (described in section\n*The with statement*), but can also be used by directly invoking their\nmethods.\n\nTypical uses of context managers include saving and restoring various\nkinds of global state, locking and unlocking resources, closing opened\nfiles, etc.\n\nFor more information on context managers, see *Context Manager Types*.\n\nobject.__enter__(self)\n\n   Enter the runtime context related to this object. The ``with``\n   statement will bind this method\'s return value to the target(s)\n   specified in the ``as`` clause of the statement, if any.\n\nobject.__exit__(self, exc_type, exc_value, traceback)\n\n   Exit the runtime context related to this object. The parameters\n   describe the exception that caused the context to be exited. If the\n   context was exited without an exception, all three arguments will\n   be ``None``.\n\n   If an exception is supplied, and the method wishes to suppress the\n   exception (i.e., prevent it from being propagated), it should\n   return a true value. Otherwise, the exception will be processed\n   normally upon exit from this method.\n\n   Note that ``__exit__()`` methods should not reraise the passed-in\n   exception; this is the caller\'s responsibility.\n\nSee also:\n\n   **PEP 0343** - The "with" statement\n      The specification, background, and examples for the Python\n      ``with`` statement.\n\n\nSpecial method lookup\n=====================\n\nFor custom classes, implicit invocations of special methods are only\nguaranteed to work correctly if defined on an object\'s type, not in\nthe object\'s instance dictionary.  That behaviour is the reason why\nthe following code raises an exception:\n\n   >>> class C:\n   ...     pass\n   ...\n   >>> c = C()\n   >>> c.__len__ = lambda: 5\n   >>> len(c)\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in <module>\n   TypeError: object of type \'C\' has no len()\n\nThe rationale behind this behaviour lies with a number of special\nmethods such as ``__hash__()`` and ``__repr__()`` that are implemented\nby all objects, including type objects. If the implicit lookup of\nthese methods used the conventional lookup process, they would fail\nwhen invoked on the type object itself:\n\n   >>> 1 .__hash__() == hash(1)\n   True\n   >>> int.__hash__() == hash(int)\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in <module>\n   TypeError: descriptor \'__hash__\' of \'int\' object needs an argument\n\nIncorrectly attempting to invoke an unbound method of a class in this\nway is sometimes referred to as \'metaclass confusion\', and is avoided\nby bypassing the instance when looking up special methods:\n\n   >>> type(1).__hash__(1) == hash(1)\n   True\n   >>> type(int).__hash__(int) == hash(int)\n   True\n\nIn addition to bypassing any instance attributes in the interest of\ncorrectness, implicit special method lookup generally also bypasses\nthe ``__getattribute__()`` method even of the object\'s metaclass:\n\n   >>> class Meta(type):\n   ...    def __getattribute__(*args):\n   ...       print("Metaclass getattribute invoked")\n   ...       return type.__getattribute__(*args)\n   ...\n   >>> class C(object, metaclass=Meta):\n   ...     def __len__(self):\n   ...         return 10\n   ...     def __getattribute__(*args):\n   ...         print("Class getattribute invoked")\n   ...         return object.__getattribute__(*args)\n   ...\n   >>> c = C()\n   >>> c.__len__()                 # Explicit lookup via instance\n   Class getattribute invoked\n   10\n   >>> type(c).__len__(c)          # Explicit lookup via type\n   Metaclass getattribute invoked\n   10\n   >>> len(c)                      # Implicit lookup\n   10\n\nBypassing the ``__getattribute__()`` machinery in this fashion\nprovides significant scope for speed optimisations within the\ninterpreter, at the cost of some flexibility in the handling of\nspecial methods (the special method *must* be set on the class object\nitself in order to be consistently invoked by the interpreter).\n\n-[ Footnotes ]-\n\n[1] It *is* possible in some cases to change an object\'s type, under\n    certain controlled conditions. It generally isn\'t a good idea\n    though, since it can lead to some very strange behaviour if it is\n    handled incorrectly.\n\n[2] For operands of the same type, it is assumed that if the non-\n    reflected method (such as ``__add__()``) fails the operation is\n    not supported, which is why the reflected method is not called.\n',
+ 'string-methods': '\nString Methods\n**************\n\nStrings implement all of the *common* sequence operations, along with\nthe additional methods described below.\n\nStrings also support two styles of string formatting, one providing a\nlarge degree of flexibility and customization (see ``str.format()``,\n*Format String Syntax* and *String Formatting*) and the other based on\nC ``printf`` style formatting that handles a narrower range of types\nand is slightly harder to use correctly, but is often faster for the\ncases it can handle (*printf-style String Formatting*).\n\nThe *Text Processing Services* section of the standard library covers\na number of other modules that provide various text related utilities\n(including regular expression support in the ``re`` module).\n\nstr.capitalize()\n\n   Return a copy of the string with its first character capitalized\n   and the rest lowercased.\n\nstr.casefold()\n\n   Return a casefolded copy of the string. Casefolded strings may be\n   used for caseless matching.\n\n   Casefolding is similar to lowercasing but more aggressive because\n   it is intended to remove all case distinctions in a string. For\n   example, the German lowercase letter ``\'\xc3\x9f\'`` is equivalent to\n   ``"ss"``. Since it is already lowercase, ``lower()`` would do\n   nothing to ``\'\xc3\x9f\'``; ``casefold()`` converts it to ``"ss"``.\n\n   The casefolding algorithm is described in section 3.13 of the\n   Unicode Standard.\n\n   New in version 3.3.\n\nstr.center(width[, fillchar])\n\n   Return centered in a string of length *width*. Padding is done\n   using the specified *fillchar* (default is a space).\n\nstr.count(sub[, start[, end]])\n\n   Return the number of non-overlapping occurrences of substring *sub*\n   in the range [*start*, *end*].  Optional arguments *start* and\n   *end* are interpreted as in slice notation.\n\nstr.encode(encoding="utf-8", errors="strict")\n\n   Return an encoded version of the string as a bytes object. Default\n   encoding is ``\'utf-8\'``. *errors* may be given to set a different\n   error handling scheme. The default for *errors* is ``\'strict\'``,\n   meaning that encoding errors raise a ``UnicodeError``. Other\n   possible values are ``\'ignore\'``, ``\'replace\'``,\n   ``\'xmlcharrefreplace\'``, ``\'backslashreplace\'`` and any other name\n   registered via ``codecs.register_error()``, see section *Codec Base\n   Classes*. For a list of possible encodings, see section *Standard\n   Encodings*.\n\n   Changed in version 3.1: Support for keyword arguments added.\n\nstr.endswith(suffix[, start[, end]])\n\n   Return ``True`` if the string ends with the specified *suffix*,\n   otherwise return ``False``.  *suffix* can also be a tuple of\n   suffixes to look for.  With optional *start*, test beginning at\n   that position.  With optional *end*, stop comparing at that\n   position.\n\nstr.expandtabs([tabsize])\n\n   Return a copy of the string where all tab characters are replaced\n   by zero or more spaces, depending on the current column and the\n   given tab size.  The column number is reset to zero after each\n   newline occurring in the string. If *tabsize* is not given, a tab\n   size of ``8`` characters is assumed.  This doesn\'t understand other\n   non-printing characters or escape sequences.\n\nstr.find(sub[, start[, end]])\n\n   Return the lowest index in the string where substring *sub* is\n   found, such that *sub* is contained in the slice ``s[start:end]``.\n   Optional arguments *start* and *end* are interpreted as in slice\n   notation.  Return ``-1`` if *sub* is not found.\n\n   Note: The ``find()`` method should be used only if you need to know the\n     position of *sub*.  To check if *sub* is a substring or not, use\n     the ``in`` operator:\n\n        >>> \'Py\' in \'Python\'\n        True\n\nstr.format(*args, **kwargs)\n\n   Perform a string formatting operation.  The string on which this\n   method is called can contain literal text or replacement fields\n   delimited by braces ``{}``.  Each replacement field contains either\n   the numeric index of a positional argument, or the name of a\n   keyword argument.  Returns a copy of the string where each\n   replacement field is replaced with the string value of the\n   corresponding argument.\n\n   >>> "The sum of 1 + 2 is {0}".format(1+2)\n   \'The sum of 1 + 2 is 3\'\n\n   See *Format String Syntax* for a description of the various\n   formatting options that can be specified in format strings.\n\nstr.format_map(mapping)\n\n   Similar to ``str.format(**mapping)``, except that ``mapping`` is\n   used directly and not copied to a ``dict`` .  This is useful if for\n   example ``mapping`` is a dict subclass:\n\n   >>> class Default(dict):\n   ...     def __missing__(self, key):\n   ...         return key\n   ...\n   >>> \'{name} was born in {country}\'.format_map(Default(name=\'Guido\'))\n   \'Guido was born in country\'\n\n   New in version 3.2.\n\nstr.index(sub[, start[, end]])\n\n   Like ``find()``, but raise ``ValueError`` when the substring is not\n   found.\n\nstr.isalnum()\n\n   Return true if all characters in the string are alphanumeric and\n   there is at least one character, false otherwise.  A character\n   ``c`` is alphanumeric if one of the following returns ``True``:\n   ``c.isalpha()``, ``c.isdecimal()``, ``c.isdigit()``, or\n   ``c.isnumeric()``.\n\nstr.isalpha()\n\n   Return true if all characters in the string are alphabetic and\n   there is at least one character, false otherwise.  Alphabetic\n   characters are those characters defined in the Unicode character\n   database as "Letter", i.e., those with general category property\n   being one of "Lm", "Lt", "Lu", "Ll", or "Lo".  Note that this is\n   different from the "Alphabetic" property defined in the Unicode\n   Standard.\n\nstr.isdecimal()\n\n   Return true if all characters in the string are decimal characters\n   and there is at least one character, false otherwise. Decimal\n   characters are those from general category "Nd". This category\n   includes digit characters, and all characters that can be used to\n   form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO.\n\nstr.isdigit()\n\n   Return true if all characters in the string are digits and there is\n   at least one character, false otherwise.  Digits include decimal\n   characters and digits that need special handling, such as the\n   compatibility superscript digits.  Formally, a digit is a character\n   that has the property value Numeric_Type=Digit or\n   Numeric_Type=Decimal.\n\nstr.isidentifier()\n\n   Return true if the string is a valid identifier according to the\n   language definition, section *Identifiers and keywords*.\n\nstr.islower()\n\n   Return true if all cased characters [4] in the string are lowercase\n   and there is at least one cased character, false otherwise.\n\nstr.isnumeric()\n\n   Return true if all characters in the string are numeric characters,\n   and there is at least one character, false otherwise. Numeric\n   characters include digit characters, and all characters that have\n   the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION\n   ONE FIFTH.  Formally, numeric characters are those with the\n   property value Numeric_Type=Digit, Numeric_Type=Decimal or\n   Numeric_Type=Numeric.\n\nstr.isprintable()\n\n   Return true if all characters in the string are printable or the\n   string is empty, false otherwise.  Nonprintable characters are\n   those characters defined in the Unicode character database as\n   "Other" or "Separator", excepting the ASCII space (0x20) which is\n   considered printable.  (Note that printable characters in this\n   context are those which should not be escaped when ``repr()`` is\n   invoked on a string.  It has no bearing on the handling of strings\n   written to ``sys.stdout`` or ``sys.stderr``.)\n\nstr.isspace()\n\n   Return true if there are only whitespace characters in the string\n   and there is at least one character, false otherwise.  Whitespace\n   characters  are those characters defined in the Unicode character\n   database as "Other" or "Separator" and those with bidirectional\n   property being one of "WS", "B", or "S".\n\nstr.istitle()\n\n   Return true if the string is a titlecased string and there is at\n   least one character, for example uppercase characters may only\n   follow uncased characters and lowercase characters only cased ones.\n   Return false otherwise.\n\nstr.isupper()\n\n   Return true if all cased characters [4] in the string are uppercase\n   and there is at least one cased character, false otherwise.\n\nstr.join(iterable)\n\n   Return a string which is the concatenation of the strings in the\n   *iterable* *iterable*.  A ``TypeError`` will be raised if there are\n   any non-string values in *iterable*, including ``bytes`` objects.\n   The separator between elements is the string providing this method.\n\nstr.ljust(width[, fillchar])\n\n   Return the string left justified in a string of length *width*.\n   Padding is done using the specified *fillchar* (default is a\n   space).  The original string is returned if *width* is less than or\n   equal to ``len(s)``.\n\nstr.lower()\n\n   Return a copy of the string with all the cased characters [4]\n   converted to lowercase.\n\n   The lowercasing algorithm used is described in section 3.13 of the\n   Unicode Standard.\n\nstr.lstrip([chars])\n\n   Return a copy of the string with leading characters removed.  The\n   *chars* argument is a string specifying the set of characters to be\n   removed.  If omitted or ``None``, the *chars* argument defaults to\n   removing whitespace.  The *chars* argument is not a prefix; rather,\n   all combinations of its values are stripped:\n\n   >>> \'   spacious   \'.lstrip()\n   \'spacious   \'\n   >>> \'www.example.com\'.lstrip(\'cmowz.\')\n   \'example.com\'\n\nstatic str.maketrans(x[, y[, z]])\n\n   This static method returns a translation table usable for\n   ``str.translate()``.\n\n   If there is only one argument, it must be a dictionary mapping\n   Unicode ordinals (integers) or characters (strings of length 1) to\n   Unicode ordinals, strings (of arbitrary lengths) or None.\n   Character keys will then be converted to ordinals.\n\n   If there are two arguments, they must be strings of equal length,\n   and in the resulting dictionary, each character in x will be mapped\n   to the character at the same position in y.  If there is a third\n   argument, it must be a string, whose characters will be mapped to\n   None in the result.\n\nstr.partition(sep)\n\n   Split the string at the first occurrence of *sep*, and return a\n   3-tuple containing the part before the separator, the separator\n   itself, and the part after the separator.  If the separator is not\n   found, return a 3-tuple containing the string itself, followed by\n   two empty strings.\n\nstr.replace(old, new[, count])\n\n   Return a copy of the string with all occurrences of substring *old*\n   replaced by *new*.  If the optional argument *count* is given, only\n   the first *count* occurrences are replaced.\n\nstr.rfind(sub[, start[, end]])\n\n   Return the highest index in the string where substring *sub* is\n   found, such that *sub* is contained within ``s[start:end]``.\n   Optional arguments *start* and *end* are interpreted as in slice\n   notation.  Return ``-1`` on failure.\n\nstr.rindex(sub[, start[, end]])\n\n   Like ``rfind()`` but raises ``ValueError`` when the substring *sub*\n   is not found.\n\nstr.rjust(width[, fillchar])\n\n   Return the string right justified in a string of length *width*.\n   Padding is done using the specified *fillchar* (default is a\n   space). The original string is returned if *width* is less than or\n   equal to ``len(s)``.\n\nstr.rpartition(sep)\n\n   Split the string at the last occurrence of *sep*, and return a\n   3-tuple containing the part before the separator, the separator\n   itself, and the part after the separator.  If the separator is not\n   found, return a 3-tuple containing two empty strings, followed by\n   the string itself.\n\nstr.rsplit(sep=None, maxsplit=-1)\n\n   Return a list of the words in the string, using *sep* as the\n   delimiter string. If *maxsplit* is given, at most *maxsplit* splits\n   are done, the *rightmost* ones.  If *sep* is not specified or\n   ``None``, any whitespace string is a separator.  Except for\n   splitting from the right, ``rsplit()`` behaves like ``split()``\n   which is described in detail below.\n\nstr.rstrip([chars])\n\n   Return a copy of the string with trailing characters removed.  The\n   *chars* argument is a string specifying the set of characters to be\n   removed.  If omitted or ``None``, the *chars* argument defaults to\n   removing whitespace.  The *chars* argument is not a suffix; rather,\n   all combinations of its values are stripped:\n\n   >>> \'   spacious   \'.rstrip()\n   \'   spacious\'\n   >>> \'mississippi\'.rstrip(\'ipz\')\n   \'mississ\'\n\nstr.split(sep=None, maxsplit=-1)\n\n   Return a list of the words in the string, using *sep* as the\n   delimiter string.  If *maxsplit* is given, at most *maxsplit*\n   splits are done (thus, the list will have at most ``maxsplit+1``\n   elements).  If *maxsplit* is not specified or ``-1``, then there is\n   no limit on the number of splits (all possible splits are made).\n\n   If *sep* is given, consecutive delimiters are not grouped together\n   and are deemed to delimit empty strings (for example,\n   ``\'1,,2\'.split(\',\')`` returns ``[\'1\', \'\', \'2\']``).  The *sep*\n   argument may consist of multiple characters (for example,\n   ``\'1<>2<>3\'.split(\'<>\')`` returns ``[\'1\', \'2\', \'3\']``). Splitting\n   an empty string with a specified separator returns ``[\'\']``.\n\n   If *sep* is not specified or is ``None``, a different splitting\n   algorithm is applied: runs of consecutive whitespace are regarded\n   as a single separator, and the result will contain no empty strings\n   at the start or end if the string has leading or trailing\n   whitespace.  Consequently, splitting an empty string or a string\n   consisting of just whitespace with a ``None`` separator returns\n   ``[]``.\n\n   For example, ``\' 1  2   3  \'.split()`` returns ``[\'1\', \'2\', \'3\']``,\n   and ``\'  1  2   3  \'.split(None, 1)`` returns ``[\'1\', \'2   3  \']``.\n\nstr.splitlines([keepends])\n\n   Return a list of the lines in the string, breaking at line\n   boundaries. This method uses the *universal newlines* approach to\n   splitting lines. Line breaks are not included in the resulting list\n   unless *keepends* is given and true.\n\n   For example, ``\'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines()`` returns\n   ``[\'ab c\', \'\', \'de fg\', \'kl\']``, while the same call with\n   ``splitlines(True)`` returns ``[\'ab c\\n\', \'\\n\', \'de fg\\r\',\n   \'kl\\r\\n\']``.\n\n   Unlike ``split()`` when a delimiter string *sep* is given, this\n   method returns an empty list for the empty string, and a terminal\n   line break does not result in an extra line.\n\nstr.startswith(prefix[, start[, end]])\n\n   Return ``True`` if string starts with the *prefix*, otherwise\n   return ``False``. *prefix* can also be a tuple of prefixes to look\n   for.  With optional *start*, test string beginning at that\n   position.  With optional *end*, stop comparing string at that\n   position.\n\nstr.strip([chars])\n\n   Return a copy of the string with the leading and trailing\n   characters removed. The *chars* argument is a string specifying the\n   set of characters to be removed. If omitted or ``None``, the\n   *chars* argument defaults to removing whitespace. The *chars*\n   argument is not a prefix or suffix; rather, all combinations of its\n   values are stripped:\n\n   >>> \'   spacious   \'.strip()\n   \'spacious\'\n   >>> \'www.example.com\'.strip(\'cmowz.\')\n   \'example\'\n\nstr.swapcase()\n\n   Return a copy of the string with uppercase characters converted to\n   lowercase and vice versa. Note that it is not necessarily true that\n   ``s.swapcase().swapcase() == s``.\n\nstr.title()\n\n   Return a titlecased version of the string where words start with an\n   uppercase character and the remaining characters are lowercase.\n\n   The algorithm uses a simple language-independent definition of a\n   word as groups of consecutive letters.  The definition works in\n   many contexts but it means that apostrophes in contractions and\n   possessives form word boundaries, which may not be the desired\n   result:\n\n      >>> "they\'re bill\'s friends from the UK".title()\n      "They\'Re Bill\'S Friends From The Uk"\n\n   A workaround for apostrophes can be constructed using regular\n   expressions:\n\n      >>> import re\n      >>> def titlecase(s):\n      ...     return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n      ...                   lambda mo: mo.group(0)[0].upper() +\n      ...                              mo.group(0)[1:].lower(),\n      ...                   s)\n      ...\n      >>> titlecase("they\'re bill\'s friends.")\n      "They\'re Bill\'s Friends."\n\nstr.translate(map)\n\n   Return a copy of the *s* where all characters have been mapped\n   through the *map* which must be a dictionary of Unicode ordinals\n   (integers) to Unicode ordinals, strings or ``None``.  Unmapped\n   characters are left untouched. Characters mapped to ``None`` are\n   deleted.\n\n   You can use ``str.maketrans()`` to create a translation map from\n   character-to-character mappings in different formats.\n\n   Note: An even more flexible approach is to create a custom character\n     mapping codec using the ``codecs`` module (see\n     ``encodings.cp1251`` for an example).\n\nstr.upper()\n\n   Return a copy of the string with all the cased characters [4]\n   converted to uppercase.  Note that ``str.upper().isupper()`` might\n   be ``False`` if ``s`` contains uncased characters or if the Unicode\n   category of the resulting character(s) is not "Lu" (Letter,\n   uppercase), but e.g. "Lt" (Letter, titlecase).\n\n   The uppercasing algorithm used is described in section 3.13 of the\n   Unicode Standard.\n\nstr.zfill(width)\n\n   Return the numeric string left filled with zeros in a string of\n   length *width*.  A sign prefix is handled correctly.  The original\n   string is returned if *width* is less than or equal to ``len(s)``.\n',
  'strings': '\nString and Bytes literals\n*************************\n\nString literals are described by the following lexical definitions:\n\n   stringliteral   ::= [stringprefix](shortstring | longstring)\n   stringprefix    ::= "r" | "u" | "R" | "U"\n   shortstring     ::= "\'" shortstringitem* "\'" | \'"\' shortstringitem* \'"\'\n   longstring      ::= "\'\'\'" longstringitem* "\'\'\'" | \'"""\' longstringitem* \'"""\'\n   shortstringitem ::= shortstringchar | stringescapeseq\n   longstringitem  ::= longstringchar | stringescapeseq\n   shortstringchar ::= <any source character except "\\" or newline or the quote>\n   longstringchar  ::= <any source character except "\\">\n   stringescapeseq ::= "\\" <any source character>\n\n   bytesliteral   ::= bytesprefix(shortbytes | longbytes)\n   bytesprefix    ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"\n   shortbytes     ::= "\'" shortbytesitem* "\'" | \'"\' shortbytesitem* \'"\'\n   longbytes      ::= "\'\'\'" longbytesitem* "\'\'\'" | \'"""\' longbytesitem* \'"""\'\n   shortbytesitem ::= shortbyteschar | bytesescapeseq\n   longbytesitem  ::= longbyteschar | bytesescapeseq\n   shortbyteschar ::= <any ASCII character except "\\" or newline or the quote>\n   longbyteschar  ::= <any ASCII character except "\\">\n   bytesescapeseq ::= "\\" <any ASCII character>\n\nOne syntactic restriction not indicated by these productions is that\nwhitespace is not allowed between the ``stringprefix`` or\n``bytesprefix`` and the rest of the literal. The source character set\nis defined by the encoding declaration; it is UTF-8 if no encoding\ndeclaration is given in the source file; see section *Encoding\ndeclarations*.\n\nIn plain English: Both types of literals can be enclosed in matching\nsingle quotes (``\'``) or double quotes (``"``).  They can also be\nenclosed in matching groups of three single or double quotes (these\nare generally referred to as *triple-quoted strings*).  The backslash\n(``\\``) character is used to escape characters that otherwise have a\nspecial meaning, such as newline, backslash itself, or the quote\ncharacter.\n\nBytes literals are always prefixed with ``\'b\'`` or ``\'B\'``; they\nproduce an instance of the ``bytes`` type instead of the ``str`` type.\nThey may only contain ASCII characters; bytes with a numeric value of\n128 or greater must be expressed with escapes.\n\nAs of Python 3.3 it is possible again to prefix unicode strings with a\n``u`` prefix to simplify maintenance of dual 2.x and 3.x codebases.\n\nBoth string and bytes literals may optionally be prefixed with a\nletter ``\'r\'`` or ``\'R\'``; such strings are called *raw strings* and\ntreat backslashes as literal characters.  As a result, in string\nliterals, ``\'\\U\'`` and ``\'\\u\'`` escapes in raw strings are not treated\nspecially. Given that Python 2.x\'s raw unicode literals behave\ndifferently than Python 3.x\'s the ``\'ur\'`` syntax is not supported.\n\n   New in version 3.3: The ``\'rb\'`` prefix of raw bytes literals has\n   been added as a synonym of ``\'br\'``.\n\n   New in version 3.3: Support for the unicode legacy literal\n   (``u\'value\'``) was reintroduced to simplify the maintenance of dual\n   Python 2.x and 3.x codebases. See **PEP 414** for more information.\n\nIn triple-quoted strings, unescaped newlines and quotes are allowed\n(and are retained), except that three unescaped quotes in a row\nterminate the string.  (A "quote" is the character used to open the\nstring, i.e. either ``\'`` or ``"``.)\n\nUnless an ``\'r\'`` or ``\'R\'`` prefix is present, escape sequences in\nstrings are interpreted according to rules similar to those used by\nStandard C.  The recognized escape sequences are:\n\n+-------------------+-----------------------------------+---------+\n| Escape Sequence   | Meaning                           | Notes   |\n+===================+===================================+=========+\n| ``\\newline``      | Backslash and newline ignored     |         |\n+-------------------+-----------------------------------+---------+\n| ``\\\\``            | Backslash (``\\``)                 |         |\n+-------------------+-----------------------------------+---------+\n| ``\\\'``            | Single quote (``\'``)              |         |\n+-------------------+-----------------------------------+---------+\n| ``\\"``            | Double quote (``"``)              |         |\n+-------------------+-----------------------------------+---------+\n| ``\\a``            | ASCII Bell (BEL)                  |         |\n+-------------------+-----------------------------------+---------+\n| ``\\b``            | ASCII Backspace (BS)              |         |\n+-------------------+-----------------------------------+---------+\n| ``\\f``            | ASCII Formfeed (FF)               |         |\n+-------------------+-----------------------------------+---------+\n| ``\\n``            | ASCII Linefeed (LF)               |         |\n+-------------------+-----------------------------------+---------+\n| ``\\r``            | ASCII Carriage Return (CR)        |         |\n+-------------------+-----------------------------------+---------+\n| ``\\t``            | ASCII Horizontal Tab (TAB)        |         |\n+-------------------+-----------------------------------+---------+\n| ``\\v``            | ASCII Vertical Tab (VT)           |         |\n+-------------------+-----------------------------------+---------+\n| ``\\ooo``          | Character with octal value *ooo*  | (1,3)   |\n+-------------------+-----------------------------------+---------+\n| ``\\xhh``          | Character with hex value *hh*     | (2,3)   |\n+-------------------+-----------------------------------+---------+\n\nEscape sequences only recognized in string literals are:\n\n+-------------------+-----------------------------------+---------+\n| Escape Sequence   | Meaning                           | Notes   |\n+===================+===================================+=========+\n| ``\\N{name}``      | Character named *name* in the     | (4)     |\n|                   | Unicode database                  |         |\n+-------------------+-----------------------------------+---------+\n| ``\\uxxxx``        | Character with 16-bit hex value   | (5)     |\n|                   | *xxxx*                            |         |\n+-------------------+-----------------------------------+---------+\n| ``\\Uxxxxxxxx``    | Character with 32-bit hex value   | (6)     |\n|                   | *xxxxxxxx*                        |         |\n+-------------------+-----------------------------------+---------+\n\nNotes:\n\n1. As in Standard C, up to three octal digits are accepted.\n\n2. Unlike in Standard C, exactly two hex digits are required.\n\n3. In a bytes literal, hexadecimal and octal escapes denote the byte\n   with the given value. In a string literal, these escapes denote a\n   Unicode character with the given value.\n\n4. Changed in version 3.3: Support for name aliases [1] has been\n   added.\n\n5. Individual code units which form parts of a surrogate pair can be\n   encoded using this escape sequence.  Exactly four hex digits are\n   required.\n\n6. Any Unicode character can be encoded this way.  Exactly eight hex\n   digits are required.\n\nUnlike Standard C, all unrecognized escape sequences are left in the\nstring unchanged, i.e., *the backslash is left in the string*.  (This\nbehavior is useful when debugging: if an escape sequence is mistyped,\nthe resulting output is more easily recognized as broken.)  It is also\nimportant to note that the escape sequences only recognized in string\nliterals fall into the category of unrecognized escapes for bytes\nliterals.\n\nEven in a raw string, string quotes can be escaped with a backslash,\nbut the backslash remains in the string; for example, ``r"\\""`` is a\nvalid string literal consisting of two characters: a backslash and a\ndouble quote; ``r"\\"`` is not a valid string literal (even a raw\nstring cannot end in an odd number of backslashes).  Specifically, *a\nraw string cannot end in a single backslash* (since the backslash\nwould escape the following quote character).  Note also that a single\nbackslash followed by a newline is interpreted as those two characters\nas part of the string, *not* as a line continuation.\n',
  'subscriptions': '\nSubscriptions\n*************\n\nA subscription selects an item of a sequence (string, tuple or list)\nor mapping (dictionary) object:\n\n   subscription ::= primary "[" expression_list "]"\n\nThe primary must evaluate to an object that supports subscription,\ne.g. a list or dictionary.  User-defined objects can support\nsubscription by defining a ``__getitem__()`` method.\n\nFor built-in objects, there are two types of objects that support\nsubscription:\n\nIf the primary is a mapping, the expression list must evaluate to an\nobject whose value is one of the keys of the mapping, and the\nsubscription selects the value in the mapping that corresponds to that\nkey.  (The expression list is a tuple except if it has exactly one\nitem.)\n\nIf the primary is a sequence, the expression (list) must evaluate to\nan integer or a slice (as discussed in the following section).\n\nThe formal syntax makes no special provision for negative indices in\nsequences; however, built-in sequences all provide a ``__getitem__()``\nmethod that interprets negative indices by adding the length of the\nsequence to the index (so that ``x[-1]`` selects the last item of\n``x``).  The resulting value must be a nonnegative integer less than\nthe number of items in the sequence, and the subscription selects the\nitem whose index is that value (counting from zero). Since the support\nfor negative indices and slicing occurs in the object\'s\n``__getitem__()`` method, subclasses overriding this method will need\nto explicitly add that support.\n\nA string\'s items are characters.  A character is not a separate data\ntype but a string of exactly one character.\n',
  'truth': "\nTruth Value Testing\n*******************\n\nAny object can be tested for truth value, for use in an ``if`` or\n``while`` condition or as operand of the Boolean operations below. The\nfollowing values are considered false:\n\n* ``None``\n\n* ``False``\n\n* zero of any numeric type, for example, ``0``, ``0.0``, ``0j``.\n\n* any empty sequence, for example, ``''``, ``()``, ``[]``.\n\n* any empty mapping, for example, ``{}``.\n\n* instances of user-defined classes, if the class defines a\n  ``__bool__()`` or ``__len__()`` method, when that method returns the\n  integer zero or ``bool`` value ``False``. [1]\n\nAll other values are considered true --- so objects of many types are\nalways true.\n\nOperations and built-in functions that have a Boolean result always\nreturn ``0`` or ``False`` for false and ``1`` or ``True`` for true,\nunless otherwise stated. (Important exception: the Boolean operations\n``or`` and ``and`` always return one of their operands.)\n",
@@ -71,7 +71,7 @@
  'typesmapping': '\nMapping Types --- ``dict``\n**************************\n\nA *mapping* object maps *hashable* values to arbitrary objects.\nMappings are mutable objects.  There is currently only one standard\nmapping type, the *dictionary*.  (For other containers see the built-\nin ``list``, ``set``, and ``tuple`` classes, and the ``collections``\nmodule.)\n\nA dictionary\'s keys are *almost* arbitrary values.  Values that are\nnot *hashable*, that is, values containing lists, dictionaries or\nother mutable types (that are compared by value rather than by object\nidentity) may not be used as keys.  Numeric types used for keys obey\nthe normal rules for numeric comparison: if two numbers compare equal\n(such as ``1`` and ``1.0``) then they can be used interchangeably to\nindex the same dictionary entry.  (Note however, that since computers\nstore floating-point numbers as approximations it is usually unwise to\nuse them as dictionary keys.)\n\nDictionaries can be created by placing a comma-separated list of\n``key: value`` pairs within braces, for example: ``{\'jack\': 4098,\n\'sjoerd\': 4127}`` or ``{4098: \'jack\', 4127: \'sjoerd\'}``, or by the\n``dict`` constructor.\n\nclass class dict(**kwarg)\nclass class dict(mapping, **kwarg)\nclass class dict(iterable, **kwarg)\n\n   Return a new dictionary initialized from an optional positional\n   argument and a possibly empty set of keyword arguments.\n\n   If no positional argument is given, an empty dictionary is created.\n   If a positional argument is given and it is a mapping object, a\n   dictionary is created with the same key-value pairs as the mapping\n   object.  Otherwise, the positional argument must be an *iterator*\n   object.  Each item in the iterable must itself be an iterator with\n   exactly two objects.  The first object of each item becomes a key\n   in the new dictionary, and the second object the corresponding\n   value.  If a key occurs more than once, the last value for that key\n   becomes the corresponding value in the new dictionary.\n\n   If keyword arguments are given, the keyword arguments and their\n   values are added to the dictionary created from the positional\n   argument.  If a key being added is already present, the value from\n   the keyword argument replaces the value from the positional\n   argument.\n\n   To illustrate, the following examples all return a dictionary equal\n   to ``{"one": 1, "two": 2, "three": 3}``:\n\n      >>> a = dict(one=1, two=2, three=3)\n      >>> b = {\'one\': 1, \'two\': 2, \'three\': 3}\n      >>> c = dict(zip([\'one\', \'two\', \'three\'], [1, 2, 3]))\n      >>> d = dict([(\'two\', 2), (\'one\', 1), (\'three\', 3)])\n      >>> e = dict({\'three\': 3, \'one\': 1, \'two\': 2})\n      >>> a == b == c == d == e\n      True\n\n   Providing keyword arguments as in the first example only works for\n   keys that are valid Python identifiers.  Otherwise, any valid keys\n   can be used.\n\n   These are the operations that dictionaries support (and therefore,\n   custom mapping types should support too):\n\n   len(d)\n\n      Return the number of items in the dictionary *d*.\n\n   d[key]\n\n      Return the item of *d* with key *key*.  Raises a ``KeyError`` if\n      *key* is not in the map.\n\n      If a subclass of dict defines a method ``__missing__()``, if the\n      key *key* is not present, the ``d[key]`` operation calls that\n      method with the key *key* as argument.  The ``d[key]`` operation\n      then returns or raises whatever is returned or raised by the\n      ``__missing__(key)`` call if the key is not present. No other\n      operations or methods invoke ``__missing__()``. If\n      ``__missing__()`` is not defined, ``KeyError`` is raised.\n      ``__missing__()`` must be a method; it cannot be an instance\n      variable:\n\n         >>> class Counter(dict):\n         ...     def __missing__(self, key):\n         ...         return 0\n         >>> c = Counter()\n         >>> c[\'red\']\n         0\n         >>> c[\'red\'] += 1\n         >>> c[\'red\']\n         1\n\n      See ``collections.Counter`` for a complete implementation\n      including other methods helpful for accumulating and managing\n      tallies.\n\n   d[key] = value\n\n      Set ``d[key]`` to *value*.\n\n   del d[key]\n\n      Remove ``d[key]`` from *d*.  Raises a ``KeyError`` if *key* is\n      not in the map.\n\n   key in d\n\n      Return ``True`` if *d* has a key *key*, else ``False``.\n\n   key not in d\n\n      Equivalent to ``not key in d``.\n\n   iter(d)\n\n      Return an iterator over the keys of the dictionary.  This is a\n      shortcut for ``iter(d.keys())``.\n\n   clear()\n\n      Remove all items from the dictionary.\n\n   copy()\n\n      Return a shallow copy of the dictionary.\n\n   classmethod fromkeys(seq[, value])\n\n      Create a new dictionary with keys from *seq* and values set to\n      *value*.\n\n      ``fromkeys()`` is a class method that returns a new dictionary.\n      *value* defaults to ``None``.\n\n   get(key[, default])\n\n      Return the value for *key* if *key* is in the dictionary, else\n      *default*. If *default* is not given, it defaults to ``None``,\n      so that this method never raises a ``KeyError``.\n\n   items()\n\n      Return a new view of the dictionary\'s items (``(key, value)``\n      pairs). See the *documentation of view objects*.\n\n   keys()\n\n      Return a new view of the dictionary\'s keys.  See the\n      *documentation of view objects*.\n\n   pop(key[, default])\n\n      If *key* is in the dictionary, remove it and return its value,\n      else return *default*.  If *default* is not given and *key* is\n      not in the dictionary, a ``KeyError`` is raised.\n\n   popitem()\n\n      Remove and return an arbitrary ``(key, value)`` pair from the\n      dictionary.\n\n      ``popitem()`` is useful to destructively iterate over a\n      dictionary, as often used in set algorithms.  If the dictionary\n      is empty, calling ``popitem()`` raises a ``KeyError``.\n\n   setdefault(key[, default])\n\n      If *key* is in the dictionary, return its value.  If not, insert\n      *key* with a value of *default* and return *default*.  *default*\n      defaults to ``None``.\n\n   update([other])\n\n      Update the dictionary with the key/value pairs from *other*,\n      overwriting existing keys.  Return ``None``.\n\n      ``update()`` accepts either another dictionary object or an\n      iterable of key/value pairs (as tuples or other iterables of\n      length two).  If keyword arguments are specified, the dictionary\n      is then updated with those key/value pairs: ``d.update(red=1,\n      blue=2)``.\n\n   values()\n\n      Return a new view of the dictionary\'s values.  See the\n      *documentation of view objects*.\n\nSee also:\n\n   ``types.MappingProxyType`` can be used to create a read-only view\n   of a ``dict``.\n\n\nDictionary view objects\n=======================\n\nThe objects returned by ``dict.keys()``, ``dict.values()`` and\n``dict.items()`` are *view objects*.  They provide a dynamic view on\nthe dictionary\'s entries, which means that when the dictionary\nchanges, the view reflects these changes.\n\nDictionary views can be iterated over to yield their respective data,\nand support membership tests:\n\nlen(dictview)\n\n   Return the number of entries in the dictionary.\n\niter(dictview)\n\n   Return an iterator over the keys, values or items (represented as\n   tuples of ``(key, value)``) in the dictionary.\n\n   Keys and values are iterated over in an arbitrary order which is\n   non-random, varies across Python implementations, and depends on\n   the dictionary\'s history of insertions and deletions. If keys,\n   values and items views are iterated over with no intervening\n   modifications to the dictionary, the order of items will directly\n   correspond.  This allows the creation of ``(value, key)`` pairs\n   using ``zip()``: ``pairs = zip(d.values(), d.keys())``.  Another\n   way to create the same list is ``pairs = [(v, k) for (k, v) in\n   d.items()]``.\n\n   Iterating views while adding or deleting entries in the dictionary\n   may raise a ``RuntimeError`` or fail to iterate over all entries.\n\nx in dictview\n\n   Return ``True`` if *x* is in the underlying dictionary\'s keys,\n   values or items (in the latter case, *x* should be a ``(key,\n   value)`` tuple).\n\nKeys views are set-like since their entries are unique and hashable.\nIf all values are hashable, so that ``(key, value)`` pairs are unique\nand hashable, then the items view is also set-like.  (Values views are\nnot treated as set-like since the entries are generally not unique.)\nFor set-like views, all of the operations defined for the abstract\nbase class ``collections.abc.Set`` are available (for example, ``==``,\n``<``, or ``^``).\n\nAn example of dictionary view usage:\n\n   >>> dishes = {\'eggs\': 2, \'sausage\': 1, \'bacon\': 1, \'spam\': 500}\n   >>> keys = dishes.keys()\n   >>> values = dishes.values()\n\n   >>> # iteration\n   >>> n = 0\n   >>> for val in values:\n   ...     n += val\n   >>> print(n)\n   504\n\n   >>> # keys and values are iterated over in the same order\n   >>> list(keys)\n   [\'eggs\', \'bacon\', \'sausage\', \'spam\']\n   >>> list(values)\n   [2, 1, 1, 500]\n\n   >>> # view objects are dynamic and reflect dict changes\n   >>> del dishes[\'eggs\']\n   >>> del dishes[\'sausage\']\n   >>> list(keys)\n   [\'spam\', \'bacon\']\n\n   >>> # set operations\n   >>> keys & {\'eggs\', \'bacon\', \'salad\'}\n   {\'bacon\'}\n   >>> keys ^ {\'sausage\', \'juice\'}\n   {\'juice\', \'sausage\', \'bacon\', \'spam\'}\n',
  'typesmethods': '\nMethods\n*******\n\nMethods are functions that are called using the attribute notation.\nThere are two flavors: built-in methods (such as ``append()`` on\nlists) and class instance methods.  Built-in methods are described\nwith the types that support them.\n\nIf you access a method (a function defined in a class namespace)\nthrough an instance, you get a special object: a *bound method* (also\ncalled *instance method*) object. When called, it will add the\n``self`` argument to the argument list.  Bound methods have two\nspecial read-only attributes: ``m.__self__`` is the object on which\nthe method operates, and ``m.__func__`` is the function implementing\nthe method.  Calling ``m(arg-1, arg-2, ..., arg-n)`` is completely\nequivalent to calling ``m.__func__(m.__self__, arg-1, arg-2, ...,\narg-n)``.\n\nLike function objects, bound method objects support getting arbitrary\nattributes.  However, since method attributes are actually stored on\nthe underlying function object (``meth.__func__``), setting method\nattributes on bound methods is disallowed.  Attempting to set an\nattribute on a method results in an ``AttributeError`` being raised.\nIn order to set a method attribute, you need to explicitly set it on\nthe underlying function object:\n\n   >>> class C:\n   ...     def method(self):\n   ...         pass\n   ...\n   >>> c = C()\n   >>> c.method.whoami = \'my name is method\'  # can\'t set on the method\n   Traceback (most recent call last):\n     File "<stdin>", line 1, in <module>\n   AttributeError: \'method\' object has no attribute \'whoami\'\n   >>> c.method.__func__.whoami = \'my name is method\'\n   >>> c.method.whoami\n   \'my name is method\'\n\nSee *The standard type hierarchy* for more information.\n',
  'typesmodules': "\nModules\n*******\n\nThe only special operation on a module is attribute access:\n``m.name``, where *m* is a module and *name* accesses a name defined\nin *m*'s symbol table. Module attributes can be assigned to.  (Note\nthat the ``import`` statement is not, strictly speaking, an operation\non a module object; ``import foo`` does not require a module object\nnamed *foo* to exist, rather it requires an (external) *definition*\nfor a module named *foo* somewhere.)\n\nA special attribute of every module is ``__dict__``. This is the\ndictionary containing the module's symbol table. Modifying this\ndictionary will actually change the module's symbol table, but direct\nassignment to the ``__dict__`` attribute is not possible (you can\nwrite ``m.__dict__['a'] = 1``, which defines ``m.a`` to be ``1``, but\nyou can't write ``m.__dict__ = {}``).  Modifying ``__dict__`` directly\nis not recommended.\n\nModules built into the interpreter are written like this: ``<module\n'sys' (built-in)>``.  If loaded from a file, they are written as\n``<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>``.\n",
- 'typesseq': '\nSequence Types --- ``list``, ``tuple``, ``range``\n*************************************************\n\nThere are three basic sequence types: lists, tuples, and range\nobjects. Additional sequence types tailored for processing of *binary\ndata* and *text strings* are described in dedicated sections.\n\n\nCommon Sequence Operations\n==========================\n\nThe operations in the following table are supported by most sequence\ntypes, both mutable and immutable. The ``collections.abc.Sequence``\nABC is provided to make it easier to correctly implement these\noperations on custom sequence types.\n\nThis table lists the sequence operations sorted in ascending priority\n(operations in the same box have the same priority).  In the table,\n*s* and *t* are sequences of the same type, *n*, *i*, *j* and *k* are\nintegers and *x* is an arbitrary object that meets any type and value\nrestrictions imposed by *s*.\n\nThe ``in`` and ``not in`` operations have the same priorities as the\ncomparison operations. The ``+`` (concatenation) and ``*``\n(repetition) operations have the same priority as the corresponding\nnumeric operations.\n\n+----------------------------+----------------------------------+------------+\n| Operation                  | Result                           | Notes      |\n+============================+==================================+============+\n| ``x in s``                 | ``True`` if an item of *s* is    | (1)        |\n|                            | equal to *x*, else ``False``     |            |\n+----------------------------+----------------------------------+------------+\n| ``x not in s``             | ``False`` if an item of *s* is   | (1)        |\n|                            | equal to *x*, else ``True``      |            |\n+----------------------------+----------------------------------+------------+\n| ``s + t``                  | the concatenation of *s* and *t* | (6)(7)     |\n+----------------------------+----------------------------------+------------+\n| ``s * n`` or ``n * s``     | *n* shallow copies of *s*        | (2)(7)     |\n|                            | concatenated                     |            |\n+----------------------------+----------------------------------+------------+\n| ``s[i]``                   | *i*th item of *s*, origin 0      | (3)        |\n+----------------------------+----------------------------------+------------+\n| ``s[i:j]``                 | slice of *s* from *i* to *j*     | (3)(4)     |\n+----------------------------+----------------------------------+------------+\n| ``s[i:j:k]``               | slice of *s* from *i* to *j*     | (3)(5)     |\n|                            | with step *k*                    |            |\n+----------------------------+----------------------------------+------------+\n| ``len(s)``                 | length of *s*                    |            |\n+----------------------------+----------------------------------+------------+\n| ``min(s)``                 | smallest item of *s*             |            |\n+----------------------------+----------------------------------+------------+\n| ``max(s)``                 | largest item of *s*              |            |\n+----------------------------+----------------------------------+------------+\n| ``s.index(x[, i[, j]])``   | index of the first occurrence of | (8)        |\n|                            | *x* in *s* (at or after index    |            |\n|                            | *i* and before index *j*)        |            |\n+----------------------------+----------------------------------+------------+\n| ``s.count(x)``             | total number of occurrences of   |            |\n|                            | *x* in *s*                       |            |\n+----------------------------+----------------------------------+------------+\n\nSequences of the same type also support comparisons.  In particular,\ntuples and lists are compared lexicographically by comparing\ncorresponding elements. This means that to compare equal, every\nelement must compare equal and the two sequences must be of the same\ntype and have the same length.  (For full details see *Comparisons* in\nthe language reference.)\n\nNotes:\n\n1. While the ``in`` and ``not in`` operations are used only for simple\n   containment testing in the general case, some specialised sequences\n   (such as ``str``, ``bytes`` and ``bytearray``) also use them for\n   subsequence testing:\n\n      >>> "gg" in "eggs"\n      True\n\n2. Values of *n* less than ``0`` are treated as ``0`` (which yields an\n   empty sequence of the same type as *s*).  Note also that the copies\n   are shallow; nested structures are not copied.  This often haunts\n   new Python programmers; consider:\n\n      >>> lists = [[]] * 3\n      >>> lists\n      [[], [], []]\n      >>> lists[0].append(3)\n      >>> lists\n      [[3], [3], [3]]\n\n   What has happened is that ``[[]]`` is a one-element list containing\n   an empty list, so all three elements of ``[[]] * 3`` are (pointers\n   to) this single empty list.  Modifying any of the elements of\n   ``lists`` modifies this single list. You can create a list of\n   different lists this way:\n\n      >>> lists = [[] for i in range(3)]\n      >>> lists[0].append(3)\n      >>> lists[1].append(5)\n      >>> lists[2].append(7)\n      >>> lists\n      [[3], [5], [7]]\n\n3. If *i* or *j* is negative, the index is relative to the end of the\n   string: ``len(s) + i`` or ``len(s) + j`` is substituted.  But note\n   that ``-0`` is still ``0``.\n\n4. The slice of *s* from *i* to *j* is defined as the sequence of\n   items with index *k* such that ``i <= k < j``.  If *i* or *j* is\n   greater than ``len(s)``, use ``len(s)``.  If *i* is omitted or\n   ``None``, use ``0``.  If *j* is omitted or ``None``, use\n   ``len(s)``.  If *i* is greater than or equal to *j*, the slice is\n   empty.\n\n5. The slice of *s* from *i* to *j* with step *k* is defined as the\n   sequence of items with index  ``x = i + n*k`` such that ``0 <= n <\n   (j-i)/k``.  In other words, the indices are ``i``, ``i+k``,\n   ``i+2*k``, ``i+3*k`` and so on, stopping when *j* is reached (but\n   never including *j*).  If *i* or *j* is greater than ``len(s)``,\n   use ``len(s)``.  If *i* or *j* are omitted or ``None``, they become\n   "end" values (which end depends on the sign of *k*).  Note, *k*\n   cannot be zero. If *k* is ``None``, it is treated like ``1``.\n\n6. Concatenating immutable sequences always results in a new object.\n   This means that building up a sequence by repeated concatenation\n   will have a quadratic runtime cost in the total sequence length.\n   To get a linear runtime cost, you must switch to one of the\n   alternatives below:\n\n   * if concatenating ``str`` objects, you can build a list and use\n     ``str.join()`` at the end or else write to a ``io.StringIO``\n     instance and retrieve its value when complete\n\n   * if concatenating ``bytes`` objects, you can similarly use\n     ``bytes.join()`` or ``io.BytesIO``, or you can do in-place\n     concatenation with a ``bytearray`` object.  ``bytearray`` objects\n     are mutable and have an efficient overallocation mechanism\n\n   * if concatenating ``tuple`` objects, extend a ``list`` instead\n\n   * for other types, investigate the relevant class documentation\n\n7. Some sequence types (such as ``range``) only support item sequences\n   that follow specific patterns, and hence don\'t support sequence\n   concatenation or repetition.\n\n8. ``index`` raises ``ValueError`` when *x* is not found in *s*. When\n   supported, the additional arguments to the index method allow\n   efficient searching of subsections of the sequence. Passing the\n   extra arguments is roughly equivalent to using ``s[i:j].index(x)``,\n   only without copying any data and with the returned index being\n   relative to the start of the sequence rather than the start of the\n   slice.\n\n\nImmutable Sequence Types\n========================\n\nThe only operation that immutable sequence types generally implement\nthat is not also implemented by mutable sequence types is support for\nthe ``hash()`` built-in.\n\nThis support allows immutable sequences, such as ``tuple`` instances,\nto be used as ``dict`` keys and stored in ``set`` and ``frozenset``\ninstances.\n\nAttempting to hash an immutable sequence that contains unhashable\nvalues will result in ``TypeError``.\n\n\nMutable Sequence Types\n======================\n\nThe operations in the following table are defined on mutable sequence\ntypes. The ``collections.abc.MutableSequence`` ABC is provided to make\nit easier to correctly implement these operations on custom sequence\ntypes.\n\nIn the table *s* is an instance of a mutable sequence type, *t* is any\niterable object and *x* is an arbitrary object that meets any type and\nvalue restrictions imposed by *s* (for example, ``bytearray`` only\naccepts integers that meet the value restriction ``0 <= x <= 255``).\n\n+--------------------------------+----------------------------------+-----------------------+\n| Operation                      | Result                           | Notes                 |\n+================================+==================================+=======================+\n| ``s[i] = x``                   | item *i* of *s* is replaced by   |                       |\n|                                | *x*                              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j] = t``                 | slice of *s* from *i* to *j* is  |                       |\n|                                | replaced by the contents of the  |                       |\n|                                | iterable *t*                     |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j]``                 | same as ``s[i:j] = []``          |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j:k] = t``               | the elements of ``s[i:j:k]`` are | (1)                   |\n|                                | replaced by those of *t*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j:k]``               | removes the elements of          |                       |\n|                                | ``s[i:j:k]`` from the list       |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.append(x)``                | appends *x* to the end of the    |                       |\n|                                | sequence (same as                |                       |\n|                                | ``s[len(s):len(s)] = [x]``)      |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.clear()``                  | removes all items from ``s``     | (5)                   |\n|                                | (same as ``del s[:]``)           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.copy()``                   | creates a shallow copy of ``s``  | (5)                   |\n|                                | (same as ``s[:]``)               |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.extend(t)``                | extends *s* with the contents of |                       |\n|                                | *t* (same as ``s[len(s):len(s)]  |                       |\n|                                | = t``)                           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.insert(i, x)``             | inserts *x* into *s* at the      |                       |\n|                                | index given by *i* (same as      |                       |\n|                                | ``s[i:i] = [x]``)                |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.pop([i])``                 | retrieves the item at *i* and    | (2)                   |\n|                                | also removes it from *s*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.remove(x)``                | remove the first item from *s*   | (3)                   |\n|                                | where ``s[i] == x``              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.reverse()``                | reverses the items of *s* in     | (4)                   |\n|                                | place                            |                       |\n+--------------------------------+----------------------------------+-----------------------+\n\nNotes:\n\n1. *t* must have the same length as the slice it is replacing.\n\n2. The optional argument *i* defaults to ``-1``, so that by default\n   the last item is removed and returned.\n\n3. ``remove`` raises ``ValueError`` when *x* is not found in *s*.\n\n4. The ``reverse()`` method modifies the sequence in place for economy\n   of space when reversing a large sequence.  To remind users that it\n   operates by side effect, it does not return the reversed sequence.\n\n5. ``clear()`` and ``copy()`` are included for consistency with the\n   interfaces of mutable containers that don\'t support slicing\n   operations (such as ``dict`` and ``set``)\n\n   New in version 3.3: ``clear()`` and ``copy()`` methods.\n\n\nLists\n=====\n\nLists are mutable sequences, typically used to store collections of\nhomogeneous items (where the precise degree of similarity will vary by\napplication).\n\nclass class list([iterable])\n\n   Lists may be constructed in several ways:\n\n   * Using a pair of square brackets to denote the empty list: ``[]``\n\n   * Using square brackets, separating items with commas: ``[a]``,\n     ``[a, b, c]``\n\n   * Using a list comprehension: ``[x for x in iterable]``\n\n   * Using the type constructor: ``list()`` or ``list(iterable)``\n\n   The constructor builds a list whose items are the same and in the\n   same order as *iterable*\'s items.  *iterable* may be either a\n   sequence, a container that supports iteration, or an iterator\n   object.  If *iterable* is already a list, a copy is made and\n   returned, similar to ``iterable[:]``. For example, ``list(\'abc\')``\n   returns ``[\'a\', \'b\', \'c\']`` and ``list( (1, 2, 3) )`` returns ``[1,\n   2, 3]``. If no argument is given, the constructor creates a new\n   empty list, ``[]``.\n\n   Many other operations also produce lists, including the\n   ``sorted()`` built-in.\n\n   Lists implement all of the *common* and *mutable* sequence\n   operations. Lists also provide the following additional method:\n\n   sort(*, key=None, reverse=None)\n\n      This method sorts the list in place, using only ``<``\n      comparisons between items. Exceptions are not suppressed - if\n      any comparison operations fail, the entire sort operation will\n      fail (and the list will likely be left in a partially modified\n      state).\n\n      *key* specifies a function of one argument that is used to\n      extract a comparison key from each list element (for example,\n      ``key=str.lower``). The key corresponding to each item in the\n      list is calculated once and then used for the entire sorting\n      process. The default value of ``None`` means that list items are\n      sorted directly without calculating a separate key value.\n\n      The ``functools.cmp_to_key()`` utility is available to convert a\n      2.x style *cmp* function to a *key* function.\n\n      *reverse* is a boolean value.  If set to ``True``, then the list\n      elements are sorted as if each comparison were reversed.\n\n      This method modifies the sequence in place for economy of space\n      when sorting a large sequence.  To remind users that it operates\n      by side effect, it does not return the sorted sequence (use\n      ``sorted()`` to explicitly request a new sorted list instance).\n\n      The ``sort()`` method is guaranteed to be stable.  A sort is\n      stable if it guarantees not to change the relative order of\n      elements that compare equal --- this is helpful for sorting in\n      multiple passes (for example, sort by department, then by salary\n      grade).\n\n      **CPython implementation detail:** While a list is being sorted,\n      the effect of attempting to mutate, or even inspect, the list is\n      undefined.  The C implementation of Python makes the list appear\n      empty for the duration, and raises ``ValueError`` if it can\n      detect that the list has been mutated during a sort.\n\n\nTuples\n======\n\nTuples are immutable sequences, typically used to store collections of\nheterogeneous data (such as the 2-tuples produced by the\n``enumerate()`` built-in). Tuples are also used for cases where an\nimmutable sequence of homogeneous data is needed (such as allowing\nstorage in a ``set`` or ``dict`` instance).\n\nclass class tuple([iterable])\n\n   Tuples may be constructed in a number of ways:\n\n   * Using a pair of parentheses to denote the empty tuple: ``()``\n\n   * Using a trailing comma for a singleton tuple: ``a,`` or ``(a,)``\n\n   * Separating items with commas: ``a, b, c`` or ``(a, b, c)``\n\n   * Using the ``tuple()`` built-in: ``tuple()`` or\n     ``tuple(iterable)``\n\n   The constructor builds a tuple whose items are the same and in the\n   same order as *iterable*\'s items.  *iterable* may be either a\n   sequence, a container that supports iteration, or an iterator\n   object.  If *iterable* is already a tuple, it is returned\n   unchanged. For example, ``tuple(\'abc\')`` returns ``(\'a\', \'b\',\n   \'c\')`` and ``tuple( [1, 2, 3] )`` returns ``(1, 2, 3)``. If no\n   argument is given, the constructor creates a new empty tuple,\n   ``()``.\n\n   Note that it is actually the comma which makes a tuple, not the\n   parentheses. The parentheses are optional, except in the empty\n   tuple case, or when they are needed to avoid syntactic ambiguity.\n   For example, ``f(a, b, c)`` is a function call with three\n   arguments, while ``f((a, b, c))`` is a function call with a 3-tuple\n   as the sole argument.\n\n   Tuples implement all of the *common* sequence operations.\n\nFor heterogeneous collections of data where access by name is clearer\nthan access by index, ``collections.namedtuple()`` may be a more\nappropriate choice than a simple tuple object.\n\n\nRanges\n======\n\nThe ``range`` type represents an immutable sequence of numbers and is\ncommonly used for looping a specific number of times in ``for`` loops.\n\nclass class range(stop)\nclass class range(start, stop[, step])\n\n   The arguments to the range constructor must be integers (either\n   built-in ``int`` or any object that implements the ``__index__``\n   special method).  If the *step* argument is omitted, it defaults to\n   ``1``. If the *start* argument is omitted, it defaults to ``0``. If\n   *step* is zero, ``ValueError`` is raised.\n\n   For a positive *step*, the contents of a range ``r`` are determined\n   by the formula ``r[i] = start + step*i`` where ``i >= 0`` and\n   ``r[i] < stop``.\n\n   For a negative *step*, the contents of the range are still\n   determined by the formula ``r[i] = start + step*i``, but the\n   constraints are ``i >= 0`` and ``r[i] > stop``.\n\n   A range object will be empty if ``r[0]`` does not meet the value\n   constraint. Ranges do support negative indices, but these are\n   interpreted as indexing from the end of the sequence determined by\n   the positive indices.\n\n   Ranges containing absolute values larger than ``sys.maxsize`` are\n   permitted but some features (such as ``len()``) may raise\n   ``OverflowError``.\n\n   Range examples:\n\n      >>> list(range(10))\n      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n      >>> list(range(1, 11))\n      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n      >>> list(range(0, 30, 5))\n      [0, 5, 10, 15, 20, 25]\n      >>> list(range(0, 10, 3))\n      [0, 3, 6, 9]\n      >>> list(range(0, -10, -1))\n      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n      >>> list(range(0))\n      []\n      >>> list(range(1, 0))\n      []\n\n   Ranges implement all of the *common* sequence operations except\n   concatenation and repetition (due to the fact that range objects\n   can only represent sequences that follow a strict pattern and\n   repetition and concatenation will usually violate that pattern).\n\nThe advantage of the ``range`` type over a regular ``list`` or\n``tuple`` is that a ``range`` object will always take the same (small)\namount of memory, no matter the size of the range it represents (as it\nonly stores the ``start``, ``stop`` and ``step`` values, calculating\nindividual items and subranges as needed).\n\nRange objects implement the ``collections.Sequence`` ABC, and provide\nfeatures such as containment tests, element index lookup, slicing and\nsupport for negative indices (see *Sequence Types --- list, tuple,\nrange*):\n\n>>> r = range(0, 20, 2)\n>>> r\nrange(0, 20, 2)\n>>> 11 in r\nFalse\n>>> 10 in r\nTrue\n>>> r.index(10)\n5\n>>> r[5]\n10\n>>> r[:5]\nrange(0, 10, 2)\n>>> r[-1]\n18\n\nTesting range objects for equality with ``==`` and ``!=`` compares\nthem as sequences.  That is, two range objects are considered equal if\nthey represent the same sequence of values.  (Note that two range\nobjects that compare equal might have different ``start``, ``stop``\nand ``step`` attributes, for example ``range(0) == range(2, 1, 3)`` or\n``range(0, 3, 2) == range(0, 4, 2)``.)\n\nChanged in version 3.2: Implement the Sequence ABC. Support slicing\nand negative indices. Test ``int`` objects for membership in constant\ntime instead of iterating through all items.\n\nChanged in version 3.3: Define \'==\' and \'!=\' to compare range objects\nbased on the sequence of values they define (instead of comparing\nbased on object identity).\n\nNew in version 3.3: The ``start``, ``stop`` and ``step`` attributes.\n',
+ 'typesseq': '\nSequence Types --- ``list``, ``tuple``, ``range``\n*************************************************\n\nThere are three basic sequence types: lists, tuples, and range\nobjects. Additional sequence types tailored for processing of *binary\ndata* and *text strings* are described in dedicated sections.\n\n\nCommon Sequence Operations\n==========================\n\nThe operations in the following table are supported by most sequence\ntypes, both mutable and immutable. The ``collections.abc.Sequence``\nABC is provided to make it easier to correctly implement these\noperations on custom sequence types.\n\nThis table lists the sequence operations sorted in ascending priority\n(operations in the same box have the same priority).  In the table,\n*s* and *t* are sequences of the same type, *n*, *i*, *j* and *k* are\nintegers and *x* is an arbitrary object that meets any type and value\nrestrictions imposed by *s*.\n\nThe ``in`` and ``not in`` operations have the same priorities as the\ncomparison operations. The ``+`` (concatenation) and ``*``\n(repetition) operations have the same priority as the corresponding\nnumeric operations.\n\n+----------------------------+----------------------------------+------------+\n| Operation                  | Result                           | Notes      |\n+============================+==================================+============+\n| ``x in s``                 | ``True`` if an item of *s* is    | (1)        |\n|                            | equal to *x*, else ``False``     |            |\n+----------------------------+----------------------------------+------------+\n| ``x not in s``             | ``False`` if an item of *s* is   | (1)        |\n|                            | equal to *x*, else ``True``      |            |\n+----------------------------+----------------------------------+------------+\n| ``s + t``                  | the concatenation of *s* and *t* | (6)(7)     |\n+----------------------------+----------------------------------+------------+\n| ``s * n`` or ``n * s``     | *n* shallow copies of *s*        | (2)(7)     |\n|                            | concatenated                     |            |\n+----------------------------+----------------------------------+------------+\n| ``s[i]``                   | *i*th item of *s*, origin 0      | (3)        |\n+----------------------------+----------------------------------+------------+\n| ``s[i:j]``                 | slice of *s* from *i* to *j*     | (3)(4)     |\n+----------------------------+----------------------------------+------------+\n| ``s[i:j:k]``               | slice of *s* from *i* to *j*     | (3)(5)     |\n|                            | with step *k*                    |            |\n+----------------------------+----------------------------------+------------+\n| ``len(s)``                 | length of *s*                    |            |\n+----------------------------+----------------------------------+------------+\n| ``min(s)``                 | smallest item of *s*             |            |\n+----------------------------+----------------------------------+------------+\n| ``max(s)``                 | largest item of *s*              |            |\n+----------------------------+----------------------------------+------------+\n| ``s.index(x[, i[, j]])``   | index of the first occurence of  | (8)        |\n|                            | *x* in *s* (at or after index    |            |\n|                            | *i* and before index *j*)        |            |\n+----------------------------+----------------------------------+------------+\n| ``s.count(x)``             | total number of occurences of    |            |\n|                            | *x* in *s*                       |            |\n+----------------------------+----------------------------------+------------+\n\nSequences of the same type also support comparisons.  In particular,\ntuples and lists are compared lexicographically by comparing\ncorresponding elements. This means that to compare equal, every\nelement must compare equal and the two sequences must be of the same\ntype and have the same length.  (For full details see *Comparisons* in\nthe language reference.)\n\nNotes:\n\n1. While the ``in`` and ``not in`` operations are used only for simple\n   containment testing in the general case, some specialised sequences\n   (such as ``str``, ``bytes`` and ``bytearray``) also use them for\n   subsequence testing:\n\n      >>> "gg" in "eggs"\n      True\n\n2. Values of *n* less than ``0`` are treated as ``0`` (which yields an\n   empty sequence of the same type as *s*).  Note also that the copies\n   are shallow; nested structures are not copied.  This often haunts\n   new Python programmers; consider:\n\n      >>> lists = [[]] * 3\n      >>> lists\n      [[], [], []]\n      >>> lists[0].append(3)\n      >>> lists\n      [[3], [3], [3]]\n\n   What has happened is that ``[[]]`` is a one-element list containing\n   an empty list, so all three elements of ``[[]] * 3`` are (pointers\n   to) this single empty list.  Modifying any of the elements of\n   ``lists`` modifies this single list. You can create a list of\n   different lists this way:\n\n      >>> lists = [[] for i in range(3)]\n      >>> lists[0].append(3)\n      >>> lists[1].append(5)\n      >>> lists[2].append(7)\n      >>> lists\n      [[3], [5], [7]]\n\n3. If *i* or *j* is negative, the index is relative to the end of the\n   string: ``len(s) + i`` or ``len(s) + j`` is substituted.  But note\n   that ``-0`` is still ``0``.\n\n4. The slice of *s* from *i* to *j* is defined as the sequence of\n   items with index *k* such that ``i <= k < j``.  If *i* or *j* is\n   greater than ``len(s)``, use ``len(s)``.  If *i* is omitted or\n   ``None``, use ``0``.  If *j* is omitted or ``None``, use\n   ``len(s)``.  If *i* is greater than or equal to *j*, the slice is\n   empty.\n\n5. The slice of *s* from *i* to *j* with step *k* is defined as the\n   sequence of items with index  ``x = i + n*k`` such that ``0 <= n <\n   (j-i)/k``.  In other words, the indices are ``i``, ``i+k``,\n   ``i+2*k``, ``i+3*k`` and so on, stopping when *j* is reached (but\n   never including *j*).  If *i* or *j* is greater than ``len(s)``,\n   use ``len(s)``.  If *i* or *j* are omitted or ``None``, they become\n   "end" values (which end depends on the sign of *k*).  Note, *k*\n   cannot be zero. If *k* is ``None``, it is treated like ``1``.\n\n6. Concatenating immutable sequences always results in a new object.\n   This means that building up a sequence by repeated concatenation\n   will have a quadratic runtime cost in the total sequence length.\n   To get a linear runtime cost, you must switch to one of the\n   alternatives below:\n\n   * if concatenating ``str`` objects, you can build a list and use\n     ``str.join()`` at the end or else write to a ``io.StringIO``\n     instance and retrieve its value when complete\n\n   * if concatenating ``bytes`` objects, you can similarly use\n     ``bytes.join()`` or ``io.BytesIO``, or you can do in-place\n     concatenation with a ``bytearray`` object.  ``bytearray`` objects\n     are mutable and have an efficient overallocation mechanism\n\n   * if concatenating ``tuple`` objects, extend a ``list`` instead\n\n   * for other types, investigate the relevant class documentation\n\n7. Some sequence types (such as ``range``) only support item sequences\n   that follow specific patterns, and hence don\'t support sequence\n   concatenation or repetition.\n\n8. ``index`` raises ``ValueError`` when *x* is not found in *s*. When\n   supported, the additional arguments to the index method allow\n   efficient searching of subsections of the sequence. Passing the\n   extra arguments is roughly equivalent to using ``s[i:j].index(x)``,\n   only without copying any data and with the returned index being\n   relative to the start of the sequence rather than the start of the\n   slice.\n\n\nImmutable Sequence Types\n========================\n\nThe only operation that immutable sequence types generally implement\nthat is not also implemented by mutable sequence types is support for\nthe ``hash()`` built-in.\n\nThis support allows immutable sequences, such as ``tuple`` instances,\nto be used as ``dict`` keys and stored in ``set`` and ``frozenset``\ninstances.\n\nAttempting to hash an immutable sequence that contains unhashable\nvalues will result in ``TypeError``.\n\n\nMutable Sequence Types\n======================\n\nThe operations in the following table are defined on mutable sequence\ntypes. The ``collections.abc.MutableSequence`` ABC is provided to make\nit easier to correctly implement these operations on custom sequence\ntypes.\n\nIn the table *s* is an instance of a mutable sequence type, *t* is any\niterable object and *x* is an arbitrary object that meets any type and\nvalue restrictions imposed by *s* (for example, ``bytearray`` only\naccepts integers that meet the value restriction ``0 <= x <= 255``).\n\n+--------------------------------+----------------------------------+-----------------------+\n| Operation                      | Result                           | Notes                 |\n+================================+==================================+=======================+\n| ``s[i] = x``                   | item *i* of *s* is replaced by   |                       |\n|                                | *x*                              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j] = t``                 | slice of *s* from *i* to *j* is  |                       |\n|                                | replaced by the contents of the  |                       |\n|                                | iterable *t*                     |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j]``                 | same as ``s[i:j] = []``          |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j:k] = t``               | the elements of ``s[i:j:k]`` are | (1)                   |\n|                                | replaced by those of *t*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j:k]``               | removes the elements of          |                       |\n|                                | ``s[i:j:k]`` from the list       |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.append(x)``                | appends *x* to the end of the    |                       |\n|                                | sequence (same as                |                       |\n|                                | ``s[len(s):len(s)] = [x]``)      |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.clear()``                  | removes all items from ``s``     | (5)                   |\n|                                | (same as ``del s[:]``)           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.copy()``                   | creates a shallow copy of ``s``  | (5)                   |\n|                                | (same as ``s[:]``)               |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.extend(t)``                | extends *s* with the contents of |                       |\n|                                | *t* (same as ``s[len(s):len(s)]  |                       |\n|                                | = t``)                           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.insert(i, x)``             | inserts *x* into *s* at the      |                       |\n|                                | index given by *i* (same as      |                       |\n|                                | ``s[i:i] = [x]``)                |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.pop([i])``                 | retrieves the item at *i* and    | (2)                   |\n|                                | also removes it from *s*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.remove(x)``                | remove the first item from *s*   | (3)                   |\n|                                | where ``s[i] == x``              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.reverse()``                | reverses the items of *s* in     | (4)                   |\n|                                | place                            |                       |\n+--------------------------------+----------------------------------+-----------------------+\n\nNotes:\n\n1. *t* must have the same length as the slice it is replacing.\n\n2. The optional argument *i* defaults to ``-1``, so that by default\n   the last item is removed and returned.\n\n3. ``remove`` raises ``ValueError`` when *x* is not found in *s*.\n\n4. The ``reverse()`` method modifies the sequence in place for economy\n   of space when reversing a large sequence.  To remind users that it\n   operates by side effect, it does not return the reversed sequence.\n\n5. ``clear()`` and ``copy()`` are included for consistency with the\n   interfaces of mutable containers that don\'t support slicing\n   operations (such as ``dict`` and ``set``)\n\n   New in version 3.3: ``clear()`` and ``copy()`` methods.\n\n\nLists\n=====\n\nLists are mutable sequences, typically used to store collections of\nhomogeneous items (where the precise degree of similarity will vary by\napplication).\n\nclass class list([iterable])\n\n   Lists may be constructed in several ways:\n\n   * Using a pair of square brackets to denote the empty list: ``[]``\n\n   * Using square brackets, separating items with commas: ``[a]``,\n     ``[a, b, c]``\n\n   * Using a list comprehension: ``[x for x in iterable]``\n\n   * Using the type constructor: ``list()`` or ``list(iterable)``\n\n   The constructor builds a list whose items are the same and in the\n   same order as *iterable*\'s items.  *iterable* may be either a\n   sequence, a container that supports iteration, or an iterator\n   object.  If *iterable* is already a list, a copy is made and\n   returned, similar to ``iterable[:]``. For example, ``list(\'abc\')``\n   returns ``[\'a\', \'b\', \'c\']`` and ``list( (1, 2, 3) )`` returns ``[1,\n   2, 3]``. If no argument is given, the constructor creates a new\n   empty list, ``[]``.\n\n   Many other operations also produce lists, including the\n   ``sorted()`` built-in.\n\n   Lists implement all of the *common* and *mutable* sequence\n   operations. Lists also provide the following additional method:\n\n   sort(*, key=None, reverse=None)\n\n      This method sorts the list in place, using only ``<``\n      comparisons between items. Exceptions are not suppressed - if\n      any comparison operations fail, the entire sort operation will\n      fail (and the list will likely be left in a partially modified\n      state).\n\n      *key* specifies a function of one argument that is used to\n      extract a comparison key from each list element (for example,\n      ``key=str.lower``). The key corresponding to each item in the\n      list is calculated once and then used for the entire sorting\n      process. The default value of ``None`` means that list items are\n      sorted directly without calculating a separate key value.\n\n      The ``functools.cmp_to_key()`` utility is available to convert a\n      2.x style *cmp* function to a *key* function.\n\n      *reverse* is a boolean value.  If set to ``True``, then the list\n      elements are sorted as if each comparison were reversed.\n\n      This method modifies the sequence in place for economy of space\n      when sorting a large sequence.  To remind users that it operates\n      by side effect, it does not return the sorted sequence (use\n      ``sorted()`` to explicitly request a new sorted list instance).\n\n      The ``sort()`` method is guaranteed to be stable.  A sort is\n      stable if it guarantees not to change the relative order of\n      elements that compare equal --- this is helpful for sorting in\n      multiple passes (for example, sort by department, then by salary\n      grade).\n\n      **CPython implementation detail:** While a list is being sorted,\n      the effect of attempting to mutate, or even inspect, the list is\n      undefined.  The C implementation of Python makes the list appear\n      empty for the duration, and raises ``ValueError`` if it can\n      detect that the list has been mutated during a sort.\n\n\nTuples\n======\n\nTuples are immutable sequences, typically used to store collections of\nheterogeneous data (such as the 2-tuples produced by the\n``enumerate()`` built-in). Tuples are also used for cases where an\nimmutable sequence of homogeneous data is needed (such as allowing\nstorage in a ``set`` or ``dict`` instance).\n\nclass class tuple([iterable])\n\n   Tuples may be constructed in a number of ways:\n\n   * Using a pair of parentheses to denote the empty tuple: ``()``\n\n   * Using a trailing comma for a singleton tuple: ``a,`` or ``(a,)``\n\n   * Separating items with commas: ``a, b, c`` or ``(a, b, c)``\n\n   * Using the ``tuple()`` built-in: ``tuple()`` or\n     ``tuple(iterable)``\n\n   The constructor builds a tuple whose items are the same and in the\n   same order as *iterable*\'s items.  *iterable* may be either a\n   sequence, a container that supports iteration, or an iterator\n   object.  If *iterable* is already a tuple, it is returned\n   unchanged. For example, ``tuple(\'abc\')`` returns ``(\'a\', \'b\',\n   \'c\')`` and ``tuple( [1, 2, 3] )`` returns ``(1, 2, 3)``. If no\n   argument is given, the constructor creates a new empty tuple,\n   ``()``.\n\n   Note that it is actually the comma which makes a tuple, not the\n   parentheses. The parentheses are optional, except in the empty\n   tuple case, or when they are needed to avoid syntactic ambiguity.\n   For example, ``f(a, b, c)`` is a function call with three\n   arguments, while ``f((a, b, c))`` is a function call with a 3-tuple\n   as the sole argument.\n\n   Tuples implement all of the *common* sequence operations.\n\nFor heterogeneous collections of data where access by name is clearer\nthan access by index, ``collections.namedtuple()`` may be a more\nappropriate choice than a simple tuple object.\n\n\nRanges\n======\n\nThe ``range`` type represents an immutable sequence of numbers and is\ncommonly used for looping a specific number of times in ``for`` loops.\n\nclass class range(stop)\nclass class range(start, stop[, step])\n\n   The arguments to the range constructor must be integers (either\n   built-in ``int`` or any object that implements the ``__index__``\n   special method).  If the *step* argument is omitted, it defaults to\n   ``1``. If the *start* argument is omitted, it defaults to ``0``. If\n   *step* is zero, ``ValueError`` is raised.\n\n   For a positive *step*, the contents of a range ``r`` are determined\n   by the formula ``r[i] = start + step*i`` where ``i >= 0`` and\n   ``r[i] < stop``.\n\n   For a negative *step*, the contents of the range are still\n   determined by the formula ``r[i] = start + step*i``, but the\n   constraints are ``i >= 0`` and ``r[i] > stop``.\n\n   A range object will be empty if ``r[0]`` does not meet the value\n   constraint. Ranges do support negative indices, but these are\n   interpreted as indexing from the end of the sequence determined by\n   the positive indices.\n\n   Ranges containing absolute values larger than ``sys.maxsize`` are\n   permitted but some features (such as ``len()``) may raise\n   ``OverflowError``.\n\n   Range examples:\n\n      >>> list(range(10))\n      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n      >>> list(range(1, 11))\n      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n      >>> list(range(0, 30, 5))\n      [0, 5, 10, 15, 20, 25]\n      >>> list(range(0, 10, 3))\n      [0, 3, 6, 9]\n      >>> list(range(0, -10, -1))\n      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n      >>> list(range(0))\n      []\n      >>> list(range(1, 0))\n      []\n\n   Ranges implement all of the *common* sequence operations except\n   concatenation and repetition (due to the fact that range objects\n   can only represent sequences that follow a strict pattern and\n   repetition and concatenation will usually violate that pattern).\n\nThe advantage of the ``range`` type over a regular ``list`` or\n``tuple`` is that a ``range`` object will always take the same (small)\namount of memory, no matter the size of the range it represents (as it\nonly stores the ``start``, ``stop`` and ``step`` values, calculating\nindividual items and subranges as needed).\n\nRange objects implement the ``collections.Sequence`` ABC, and provide\nfeatures such as containment tests, element index lookup, slicing and\nsupport for negative indices (see *Sequence Types --- list, tuple,\nrange*):\n\n>>> r = range(0, 20, 2)\n>>> r\nrange(0, 20, 2)\n>>> 11 in r\nFalse\n>>> 10 in r\nTrue\n>>> r.index(10)\n5\n>>> r[5]\n10\n>>> r[:5]\nrange(0, 10, 2)\n>>> r[-1]\n18\n\nTesting range objects for equality with ``==`` and ``!=`` compares\nthem as sequences.  That is, two range objects are considered equal if\nthey represent the same sequence of values.  (Note that two range\nobjects that compare equal might have different ``start``, ``stop``\nand ``step`` attributes, for example ``range(0) == range(2, 1, 3)`` or\n``range(0, 3, 2) == range(0, 4, 2)``.)\n\nChanged in version 3.2: Implement the Sequence ABC. Support slicing\nand negative indices. Test ``int`` objects for membership in constant\ntime instead of iterating through all items.\n\nChanged in version 3.3: Define \'==\' and \'!=\' to compare range objects\nbased on the sequence of values they define (instead of comparing\nbased on object identity).\n\nNew in version 3.3: The ``start``, ``stop`` and ``step`` attributes.\n',
  'typesseq-mutable': "\nMutable Sequence Types\n**********************\n\nThe operations in the following table are defined on mutable sequence\ntypes. The ``collections.abc.MutableSequence`` ABC is provided to make\nit easier to correctly implement these operations on custom sequence\ntypes.\n\nIn the table *s* is an instance of a mutable sequence type, *t* is any\niterable object and *x* is an arbitrary object that meets any type and\nvalue restrictions imposed by *s* (for example, ``bytearray`` only\naccepts integers that meet the value restriction ``0 <= x <= 255``).\n\n+--------------------------------+----------------------------------+-----------------------+\n| Operation                      | Result                           | Notes                 |\n+================================+==================================+=======================+\n| ``s[i] = x``                   | item *i* of *s* is replaced by   |                       |\n|                                | *x*                              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j] = t``                 | slice of *s* from *i* to *j* is  |                       |\n|                                | replaced by the contents of the  |                       |\n|                                | iterable *t*                     |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j]``                 | same as ``s[i:j] = []``          |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s[i:j:k] = t``               | the elements of ``s[i:j:k]`` are | (1)                   |\n|                                | replaced by those of *t*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``del s[i:j:k]``               | removes the elements of          |                       |\n|                                | ``s[i:j:k]`` from the list       |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.append(x)``                | appends *x* to the end of the    |                       |\n|                                | sequence (same as                |                       |\n|                                | ``s[len(s):len(s)] = [x]``)      |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.clear()``                  | removes all items from ``s``     | (5)                   |\n|                                | (same as ``del s[:]``)           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.copy()``                   | creates a shallow copy of ``s``  | (5)                   |\n|                                | (same as ``s[:]``)               |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.extend(t)``                | extends *s* with the contents of |                       |\n|                                | *t* (same as ``s[len(s):len(s)]  |                       |\n|                                | = t``)                           |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.insert(i, x)``             | inserts *x* into *s* at the      |                       |\n|                                | index given by *i* (same as      |                       |\n|                                | ``s[i:i] = [x]``)                |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.pop([i])``                 | retrieves the item at *i* and    | (2)                   |\n|                                | also removes it from *s*         |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.remove(x)``                | remove the first item from *s*   | (3)                   |\n|                                | where ``s[i] == x``              |                       |\n+--------------------------------+----------------------------------+-----------------------+\n| ``s.reverse()``                | reverses the items of *s* in     | (4)                   |\n|                                | place                            |                       |\n+--------------------------------+----------------------------------+-----------------------+\n\nNotes:\n\n1. *t* must have the same length as the slice it is replacing.\n\n2. The optional argument *i* defaults to ``-1``, so that by default\n   the last item is removed and returned.\n\n3. ``remove`` raises ``ValueError`` when *x* is not found in *s*.\n\n4. The ``reverse()`` method modifies the sequence in place for economy\n   of space when reversing a large sequence.  To remind users that it\n   operates by side effect, it does not return the reversed sequence.\n\n5. ``clear()`` and ``copy()`` are included for consistency with the\n   interfaces of mutable containers that don't support slicing\n   operations (such as ``dict`` and ``set``)\n\n   New in version 3.3: ``clear()`` and ``copy()`` methods.\n",
  'unary': '\nUnary arithmetic and bitwise operations\n***************************************\n\nAll unary arithmetic and bitwise operations have the same priority:\n\n   u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr\n\nThe unary ``-`` (minus) operator yields the negation of its numeric\nargument.\n\nThe unary ``+`` (plus) operator yields its numeric argument unchanged.\n\nThe unary ``~`` (invert) operator yields the bitwise inversion of its\ninteger argument.  The bitwise inversion of ``x`` is defined as\n``-(x+1)``.  It only applies to integral numbers.\n\nIn all three cases, if the argument does not have the proper type, a\n``TypeError`` exception is raised.\n',
  'while': '\nThe ``while`` statement\n***********************\n\nThe ``while`` statement is used for repeated execution as long as an\nexpression is true:\n\n   while_stmt ::= "while" expression ":" suite\n                  ["else" ":" suite]\n\nThis repeatedly tests the expression and, if it is true, executes the\nfirst suite; if the expression is false (which may be the first time\nit is tested) the suite of the ``else`` clause, if present, is\nexecuted and the loop terminates.\n\nA ``break`` statement executed in the first suite terminates the loop\nwithout executing the ``else`` clause\'s suite.  A ``continue``\nstatement executed in the first suite skips the rest of the suite and\ngoes back to testing the expression.\n',
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/queue.py
--- a/Lib/queue.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/queue.py	Mon Aug 12 02:18:40 2013 +0200
@@ -120,7 +120,7 @@
 
         If optional args 'block' is true and 'timeout' is None (the default),
         block if necessary until a free slot is available. If 'timeout' is
-        a non-negative number, it blocks at most 'timeout' seconds and raises
+        a positive number, it blocks at most 'timeout' seconds and raises
         the Full exception if no free slot was available within that time.
         Otherwise ('block' is false), put an item on the queue if a free slot
         is immediately available, else raise the Full exception ('timeout'
@@ -135,7 +135,7 @@
                     while self._qsize() >= self.maxsize:
                         self.not_full.wait()
                 elif timeout < 0:
-                    raise ValueError("'timeout' must be a non-negative number")
+                    raise ValueError("'timeout' must be a positive number")
                 else:
                     endtime = time() + timeout
                     while self._qsize() >= self.maxsize:
@@ -152,7 +152,7 @@
 
         If optional args 'block' is true and 'timeout' is None (the default),
         block if necessary until an item is available. If 'timeout' is
-        a non-negative number, it blocks at most 'timeout' seconds and raises
+        a positive number, it blocks at most 'timeout' seconds and raises
         the Empty exception if no item was available within that time.
         Otherwise ('block' is false), return an item if one is immediately
         available, else raise the Empty exception ('timeout' is ignored
@@ -166,7 +166,7 @@
                 while not self._qsize():
                     self.not_empty.wait()
             elif timeout < 0:
-                raise ValueError("'timeout' must be a non-negative number")
+                raise ValueError("'timeout' must be a positive number")
             else:
                 endtime = time() + timeout
                 while not self._qsize():
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/rlcompleter.py
--- a/Lib/rlcompleter.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/rlcompleter.py	Mon Aug 12 02:18:40 2013 +0200
@@ -29,7 +29,6 @@
 
 """
 
-import atexit
 import builtins
 import __main__
 
@@ -159,7 +158,3 @@
     pass
 else:
     readline.set_completer(Completer().complete)
-    # Release references early at shutdown (the readline module's
-    # contents are quasi-immortal, and the completer function holds a
-    # reference to globals).
-    atexit.register(lambda: readline.set_completer(None))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/site.py
--- a/Lib/site.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/site.py	Mon Aug 12 02:18:40 2013 +0200
@@ -72,7 +72,6 @@
 import os
 import re
 import builtins
-import _sitebuiltins
 
 # Prefixes for site-packages; add additional prefixes like /usr/local here
 PREFIXES = [sys.prefix, sys.exec_prefix]
@@ -345,30 +344,116 @@
     else:
         eof = 'Ctrl-D (i.e. EOF)'
 
-    builtins.quit = _sitebuiltins.Quitter('quit', eof)
-    builtins.exit = _sitebuiltins.Quitter('exit', eof)
+    class Quitter(object):
+        def __init__(self, name):
+            self.name = name
+        def __repr__(self):
+            return 'Use %s() or %s to exit' % (self.name, eof)
+        def __call__(self, code=None):
+            # Shells like IDLE catch the SystemExit, but listen when their
+            # stdin wrapper is closed.
+            try:
+                sys.stdin.close()
+            except:
+                pass
+            raise SystemExit(code)
+    builtins.quit = Quitter('quit')
+    builtins.exit = Quitter('exit')
 
 
+class _Printer(object):
+    """interactive prompt objects for printing the license text, a list of
+    contributors and the copyright notice."""
+
+    MAXLINES = 23
+
+    def __init__(self, name, data, files=(), dirs=()):
+        self.__name = name
+        self.__data = data
+        self.__files = files
+        self.__dirs = dirs
+        self.__lines = None
+
+    def __setup(self):
+        if self.__lines:
+            return
+        data = None
+        for dir in self.__dirs:
+            for filename in self.__files:
+                filename = os.path.join(dir, filename)
+                try:
+                    with open(filename, "r") as fp:
+                        data = fp.read()
+                    break
+                except OSError:
+                    pass
+            if data:
+                break
+        if not data:
+            data = self.__data
+        self.__lines = data.split('\n')
+        self.__linecnt = len(self.__lines)
+
+    def __repr__(self):
+        self.__setup()
+        if len(self.__lines) <= self.MAXLINES:
+            return "\n".join(self.__lines)
+        else:
+            return "Type %s() to see the full %s text" % ((self.__name,)*2)
+
+    def __call__(self):
+        self.__setup()
+        prompt = 'Hit Return for more, or q (and Return) to quit: '
+        lineno = 0
+        while 1:
+            try:
+                for i in range(lineno, lineno + self.MAXLINES):
+                    print(self.__lines[i])
+            except IndexError:
+                break
+            else:
+                lineno += self.MAXLINES
+                key = None
+                while key is None:
+                    key = input(prompt)
+                    if key not in ('', 'q'):
+                        key = None
+                if key == 'q':
+                    break
+
 def setcopyright():
     """Set 'copyright' and 'credits' in builtins"""
-    builtins.copyright = _sitebuiltins._Printer("copyright", sys.copyright)
+    builtins.copyright = _Printer("copyright", sys.copyright)
     if sys.platform[:4] == 'java':
-        builtins.credits = _sitebuiltins._Printer(
+        builtins.credits = _Printer(
             "credits",
             "Jython is maintained by the Jython developers (www.jython.org).")
     else:
-        builtins.credits = _sitebuiltins._Printer("credits", """\
+        builtins.credits = _Printer("credits", """\
     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
     for supporting Python development.  See www.python.org for more information.""")
     here = os.path.dirname(os.__file__)
-    builtins.license = _sitebuiltins._Printer(
+    builtins.license = _Printer(
         "license", "See http://www.python.org/%.3s/license.html" % sys.version,
         ["LICENSE.txt", "LICENSE"],
         [os.path.join(here, os.pardir), here, os.curdir])
 
 
+class _Helper(object):
+    """Define the builtin 'help'.
+    This is a wrapper around pydoc.help (with a twist).
+
+    """
+
+    def __repr__(self):
+        return "Type help() for interactive help, " \
+               "or help(object) for help about object."
+    def __call__(self, *args, **kwds):
+        import pydoc
+        return pydoc.help(*args, **kwds)
+
 def sethelper():
-    builtins.help = _sitebuiltins._Helper()
+    builtins.help = _Helper()
 
 def enablerlcompleter():
     """Enable default readline configuration on interactive prompts, by
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/socket.py
--- a/Lib/socket.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/socket.py	Mon Aug 12 02:18:40 2013 +0200
@@ -137,7 +137,8 @@
     def dup(self):
         """dup() -> socket object
 
-        Return a new socket object connected to the same system resource.
+        Duplicate the socket. Return a new socket object connected to the same
+        system resource. The new socket is non-inheritable.
         """
         fd = dup(self.fileno())
         sock = self.__class__(self.family, self.type, self.proto, fileno=fd)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/sre_compile.py
--- a/Lib/sre_compile.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/sre_compile.py	Mon Aug 12 02:18:40 2013 +0200
@@ -351,8 +351,8 @@
 def _simple(av):
     # check if av is a "simple" operator
     lo, hi = av[2].getwidth()
-    #if lo == 0 and hi == MAXREPEAT:
-    #    raise error("nothing to repeat")
+    if lo == 0 and hi == MAXREPEAT:
+        raise error("nothing to repeat")
     return lo == hi == 1 and av[2][0][0] != SUBPATTERN
 
 def _compile_info(code, pattern, flags):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/subprocess.py
--- a/Lib/subprocess.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/subprocess.py	Mon Aug 12 02:18:40 2013 +0200
@@ -405,7 +405,6 @@
     import select
     _has_poll = hasattr(select, 'poll')
     import _posixsubprocess
-    _create_pipe = _posixsubprocess.cloexec_pipe
 
     # When select or poll has indicated that the file is writable,
     # we can write up to _PIPE_BUF bytes without risk of blocking.
@@ -1258,7 +1257,7 @@
             if stdin is None:
                 pass
             elif stdin == PIPE:
-                p2cread, p2cwrite = _create_pipe()
+                p2cread, p2cwrite = os.pipe()
             elif stdin == DEVNULL:
                 p2cread = self._get_devnull()
             elif isinstance(stdin, int):
@@ -1270,7 +1269,7 @@
             if stdout is None:
                 pass
             elif stdout == PIPE:
-                c2pread, c2pwrite = _create_pipe()
+                c2pread, c2pwrite = os.pipe()
             elif stdout == DEVNULL:
                 c2pwrite = self._get_devnull()
             elif isinstance(stdout, int):
@@ -1282,7 +1281,7 @@
             if stderr is None:
                 pass
             elif stderr == PIPE:
-                errread, errwrite = _create_pipe()
+                errread, errwrite = os.pipe()
             elif stderr == STDOUT:
                 errwrite = c2pwrite
             elif stderr == DEVNULL:
@@ -1334,7 +1333,7 @@
             # For transferring possible exec failure from child to parent.
             # Data format: "exception name:hex errno:description"
             # Pickle is not used; it is complex and involves memory allocation.
-            errpipe_read, errpipe_write = _create_pipe()
+            errpipe_read, errpipe_write = os.pipe()
             try:
                 try:
                     # We must avoid complex work that could involve
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/tempfile.py
--- a/Lib/tempfile.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/tempfile.py	Mon Aug 12 02:18:40 2013 +0200
@@ -35,33 +35,12 @@
 from random import Random as _Random
 
 try:
-    import fcntl as _fcntl
-except ImportError:
-    def _set_cloexec(fd):
-        pass
-else:
-    def _set_cloexec(fd):
-        try:
-            flags = _fcntl.fcntl(fd, _fcntl.F_GETFD, 0)
-        except OSError:
-            pass
-        else:
-            # flags read successfully, modify
-            flags |= _fcntl.FD_CLOEXEC
-            _fcntl.fcntl(fd, _fcntl.F_SETFD, flags)
-
-
-try:
     import _thread
 except ImportError:
     import _dummy_thread as _thread
 _allocate_lock = _thread.allocate_lock
 
 _text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL
-if hasattr(_os, 'O_CLOEXEC'):
-    _text_openflags |= _os.O_CLOEXEC
-if hasattr(_os, 'O_NOINHERIT'):
-    _text_openflags |= _os.O_NOINHERIT
 if hasattr(_os, 'O_NOFOLLOW'):
     _text_openflags |= _os.O_NOFOLLOW
 
@@ -90,8 +69,8 @@
     # Fallback.  All we need is something that raises OSError if the
     # file doesn't exist.
     def _stat(fn):
-        f = open(fn)
-        f.close()
+        fd = _os.open(fn, _os.O_RDONLY)
+        os.close(fd)
 
 def _exists(fn):
     try:
@@ -217,7 +196,6 @@
         file = _os.path.join(dir, pre + name + suf)
         try:
             fd = _os.open(file, flags, 0o600)
-            _set_cloexec(fd)
             return (fd, _os.path.abspath(file))
         except FileExistsError:
             continue    # try again
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/datetimetester.py
--- a/Lib/test/datetimetester.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/datetimetester.py	Mon Aug 12 02:18:40 2013 +0200
@@ -619,10 +619,6 @@
         eq(td(hours=-.2/us_per_hour), td(0))
         eq(td(days=-.4/us_per_day, hours=-.2/us_per_hour), td(microseconds=-1))
 
-        # Test for a patch in Issue 8860
-        eq(td(microseconds=0.5), 0.5*td(microseconds=1.0))
-        eq(td(microseconds=0.5)//td.resolution, 0.5*td.resolution//td.resolution)
-
     def test_massive_normalization(self):
         td = timedelta(microseconds=-1)
         self.assertEqual((td.days, td.seconds, td.microseconds),
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/final_a.py
--- a/Lib/test/final_a.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-"""
-Fodder for module finalization tests in test_module.
-"""
-
-import shutil
-import test.final_b
-
-x = 'a'
-
-class C:
-    def __del__(self):
-        # Inspect module globals and builtins
-        print("x =", x)
-        print("final_b.x =", test.final_b.x)
-        print("shutil.rmtree =", getattr(shutil.rmtree, '__name__', None))
-        print("len =", getattr(len, '__name__', None))
-
-c = C()
-_underscored = C()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/final_b.py
--- a/Lib/test/final_b.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-"""
-Fodder for module finalization tests in test_module.
-"""
-
-import shutil
-import test.final_a
-
-x = 'b'
-
-class C:
-    def __del__(self):
-        # Inspect module globals and builtins
-        print("x =", x)
-        print("final_a.x =", test.final_a.x)
-        print("shutil.rmtree =", getattr(shutil.rmtree, '__name__', None))
-        print("len =", getattr(len, '__name__', None))
-
-c = C()
-_underscored = C()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/__init__.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/__init__.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,73 @@
+import os
+import sys
+import json
+import doctest
+import unittest
+
+from test import support
+
+# import json with and without accelerations
+cjson = support.import_fresh_module('json', fresh=['_json'])
+pyjson = support.import_fresh_module('json', blocked=['_json'])
+
+# create two base classes that will be used by the other tests
+class PyTest(unittest.TestCase):
+    json = pyjson
+    loads = staticmethod(pyjson.loads)
+    dumps = staticmethod(pyjson.dumps)
+
+@unittest.skipUnless(cjson, 'requires _json')
+class CTest(unittest.TestCase):
+    if cjson is not None:
+        json = cjson
+        loads = staticmethod(cjson.loads)
+        dumps = staticmethod(cjson.dumps)
+
+# test PyTest and CTest checking if the functions come from the right module
+class TestPyTest(PyTest):
+    def test_pyjson(self):
+        self.assertEqual(self.json.scanner.make_scanner.__module__,
+                         'json.scanner')
+        self.assertEqual(self.json.decoder.scanstring.__module__,
+                         'json.decoder')
+        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
+                         'json.encoder')
+
+class TestCTest(CTest):
+    def test_cjson(self):
+        self.assertEqual(self.json.scanner.make_scanner.__module__, '_json')
+        self.assertEqual(self.json.decoder.scanstring.__module__, '_json')
+        self.assertEqual(self.json.encoder.c_make_encoder.__module__, '_json')
+        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
+                         '_json')
+
+
+here = os.path.dirname(__file__)
+
+def test_suite():
+    suite = additional_tests()
+    loader = unittest.TestLoader()
+    for fn in os.listdir(here):
+        if fn.startswith("test") and fn.endswith(".py"):
+            modname = "test.json_tests." + fn[:-3]
+            __import__(modname)
+            module = sys.modules[modname]
+            suite.addTests(loader.loadTestsFromModule(module))
+    return suite
+
+def additional_tests():
+    suite = unittest.TestSuite()
+    for mod in (json, json.encoder, json.decoder):
+        suite.addTest(doctest.DocTestSuite(mod))
+    suite.addTest(TestPyTest('test_pyjson'))
+    suite.addTest(TestCTest('test_cjson'))
+    return suite
+
+def main():
+    suite = test_suite()
+    runner = unittest.TextTestRunner()
+    runner.run(suite)
+
+if __name__ == '__main__':
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_decode.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_decode.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,74 @@
+import decimal
+from io import StringIO
+from collections import OrderedDict
+from test.json_tests import PyTest, CTest
+
+
+class TestDecode:
+    def test_decimal(self):
+        rval = self.loads('1.1', parse_float=decimal.Decimal)
+        self.assertTrue(isinstance(rval, decimal.Decimal))
+        self.assertEqual(rval, decimal.Decimal('1.1'))
+
+    def test_float(self):
+        rval = self.loads('1', parse_int=float)
+        self.assertTrue(isinstance(rval, float))
+        self.assertEqual(rval, 1.0)
+
+    def test_empty_objects(self):
+        self.assertEqual(self.loads('{}'), {})
+        self.assertEqual(self.loads('[]'), [])
+        self.assertEqual(self.loads('""'), "")
+
+    def test_object_pairs_hook(self):
+        s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
+        p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4),
+             ("qrt", 5), ("pad", 6), ("hoy", 7)]
+        self.assertEqual(self.loads(s), eval(s))
+        self.assertEqual(self.loads(s, object_pairs_hook=lambda x: x), p)
+        self.assertEqual(self.json.load(StringIO(s),
+                                        object_pairs_hook=lambda x: x), p)
+        od = self.loads(s, object_pairs_hook=OrderedDict)
+        self.assertEqual(od, OrderedDict(p))
+        self.assertEqual(type(od), OrderedDict)
+        # the object_pairs_hook takes priority over the object_hook
+        self.assertEqual(self.loads(s, object_pairs_hook=OrderedDict,
+                                    object_hook=lambda x: None),
+                         OrderedDict(p))
+        # check that empty objects literals work (see #17368)
+        self.assertEqual(self.loads('{}', object_pairs_hook=OrderedDict),
+                         OrderedDict())
+        self.assertEqual(self.loads('{"empty": {}}',
+                                    object_pairs_hook=OrderedDict),
+                         OrderedDict([('empty', OrderedDict())]))
+
+    def test_decoder_optimizations(self):
+        # Several optimizations were made that skip over calls to
+        # the whitespace regex, so this test is designed to try and
+        # exercise the uncommon cases. The array cases are already covered.
+        rval = self.loads('{   "key"    :    "value"    ,  "k":"v"    }')
+        self.assertEqual(rval, {"key":"value", "k":"v"})
+
+    def check_keys_reuse(self, source, loads):
+        rval = loads(source)
+        (a, b), (c, d) = sorted(rval[0]), sorted(rval[1])
+        self.assertIs(a, c)
+        self.assertIs(b, d)
+
+    def test_keys_reuse(self):
+        s = '[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]'
+        self.check_keys_reuse(s, self.loads)
+        self.check_keys_reuse(s, self.json.decoder.JSONDecoder().decode)
+
+    def test_extra_data(self):
+        s = '[1, 2, 3]5'
+        msg = 'Extra data'
+        self.assertRaisesRegex(ValueError, msg, self.loads, s)
+
+    def test_invalid_escape(self):
+        s = '["abc\\y"]'
+        msg = 'escape'
+        self.assertRaisesRegex(ValueError, msg, self.loads, s)
+
+class TestPyDecode(TestDecode, PyTest): pass
+class TestCDecode(TestDecode, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_default.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_default.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,12 @@
+from test.json_tests import PyTest, CTest
+
+
+class TestDefault:
+    def test_default(self):
+        self.assertEqual(
+            self.dumps(type, default=repr),
+            self.dumps(repr(type)))
+
+
+class TestPyDefault(TestDefault, PyTest): pass
+class TestCDefault(TestDefault, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_dump.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_dump.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,49 @@
+from io import StringIO
+from test.json_tests import PyTest, CTest
+
+from test.support import bigmemtest, _1G
+
+class TestDump:
+    def test_dump(self):
+        sio = StringIO()
+        self.json.dump({}, sio)
+        self.assertEqual(sio.getvalue(), '{}')
+
+    def test_dumps(self):
+        self.assertEqual(self.dumps({}), '{}')
+
+    def test_encode_truefalse(self):
+        self.assertEqual(self.dumps(
+                 {True: False, False: True}, sort_keys=True),
+                 '{"false": true, "true": false}')
+        self.assertEqual(self.dumps(
+                {2: 3.0, 4.0: 5, False: 1, 6: True}, sort_keys=True),
+                '{"false": 1, "2": 3.0, "4.0": 5, "6": true}')
+
+    # Issue 16228: Crash on encoding resized list
+    def test_encode_mutated(self):
+        a = [object()] * 10
+        def crasher(obj):
+            del a[-1]
+        self.assertEqual(self.dumps(a, default=crasher),
+                 '[null, null, null, null, null]')
+
+
+class TestPyDump(TestDump, PyTest): pass
+
+class TestCDump(TestDump, CTest):
+
+    # The size requirement here is hopefully over-estimated (actual
+    # memory consumption depending on implementation details, and also
+    # system memory management, since this may allocate a lot of
+    # small objects).
+
+    @bigmemtest(size=_1G, memuse=1)
+    def test_large_list(self, size):
+        N = int(30 * 1024 * 1024 * (size / _1G))
+        l = [1] * N
+        encoded = self.dumps(l)
+        self.assertEqual(len(encoded), N * 3)
+        self.assertEqual(encoded[:1], "[")
+        self.assertEqual(encoded[-2:], "1]")
+        self.assertEqual(encoded[1:-2], "1, " * (N - 1))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_encode_basestring_ascii.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_encode_basestring_ascii.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,44 @@
+from collections import OrderedDict
+from test.json_tests import PyTest, CTest
+
+
+CASES = [
+    ('/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?', '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'),
+    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
+    ('controls', '"controls"'),
+    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    ('{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
+    (' s p a c e d ', '" s p a c e d "'),
+    ('\U0001d120', '"\\ud834\\udd20"'),
+    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
+    ("`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
+    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
+]
+
+class TestEncodeBasestringAscii:
+    def test_encode_basestring_ascii(self):
+        fname = self.json.encoder.encode_basestring_ascii.__name__
+        for input_string, expect in CASES:
+            result = self.json.encoder.encode_basestring_ascii(input_string)
+            self.assertEqual(result, expect,
+                '{0!r} != {1!r} for {2}({3!r})'.format(
+                    result, expect, fname, input_string))
+
+    def test_ordered_dict(self):
+        # See issue 6105
+        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
+        s = self.dumps(OrderedDict(items))
+        self.assertEqual(s, '{"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}')
+
+    def test_sorted_dict(self):
+        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
+        s = self.dumps(dict(items), sort_keys=True)
+        self.assertEqual(s, '{"five": 5, "four": 4, "one": 1, "three": 3, "two": 2}')
+
+
+class TestPyEncodeBasestringAscii(TestEncodeBasestringAscii, PyTest): pass
+class TestCEncodeBasestringAscii(TestEncodeBasestringAscii, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_fail.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_fail.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,194 @@
+from test.json_tests import PyTest, CTest
+import re
+
+# 2007-10-05
+JSONDOCS = [
+    # http://json.org/JSON_checker/test/fail1.json
+    '"A JSON payload should be an object or array, not a string."',
+    # http://json.org/JSON_checker/test/fail2.json
+    '["Unclosed array"',
+    # http://json.org/JSON_checker/test/fail3.json
+    '{unquoted_key: "keys must be quoted"}',
+    # http://json.org/JSON_checker/test/fail4.json
+    '["extra comma",]',
+    # http://json.org/JSON_checker/test/fail5.json
+    '["double extra comma",,]',
+    # http://json.org/JSON_checker/test/fail6.json
+    '[   , "<-- missing value"]',
+    # http://json.org/JSON_checker/test/fail7.json
+    '["Comma after the close"],',
+    # http://json.org/JSON_checker/test/fail8.json
+    '["Extra close"]]',
+    # http://json.org/JSON_checker/test/fail9.json
+    '{"Extra comma": true,}',
+    # http://json.org/JSON_checker/test/fail10.json
+    '{"Extra value after close": true} "misplaced quoted value"',
+    # http://json.org/JSON_checker/test/fail11.json
+    '{"Illegal expression": 1 + 2}',
+    # http://json.org/JSON_checker/test/fail12.json
+    '{"Illegal invocation": alert()}',
+    # http://json.org/JSON_checker/test/fail13.json
+    '{"Numbers cannot have leading zeroes": 013}',
+    # http://json.org/JSON_checker/test/fail14.json
+    '{"Numbers cannot be hex": 0x14}',
+    # http://json.org/JSON_checker/test/fail15.json
+    '["Illegal backslash escape: \\x15"]',
+    # http://json.org/JSON_checker/test/fail16.json
+    '[\\naked]',
+    # http://json.org/JSON_checker/test/fail17.json
+    '["Illegal backslash escape: \\017"]',
+    # http://json.org/JSON_checker/test/fail18.json
+    '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
+    # http://json.org/JSON_checker/test/fail19.json
+    '{"Missing colon" null}',
+    # http://json.org/JSON_checker/test/fail20.json
+    '{"Double colon":: null}',
+    # http://json.org/JSON_checker/test/fail21.json
+    '{"Comma instead of colon", null}',
+    # http://json.org/JSON_checker/test/fail22.json
+    '["Colon instead of comma": false]',
+    # http://json.org/JSON_checker/test/fail23.json
+    '["Bad value", truth]',
+    # http://json.org/JSON_checker/test/fail24.json
+    "['single quote']",
+    # http://json.org/JSON_checker/test/fail25.json
+    '["\ttab\tcharacter\tin\tstring\t"]',
+    # http://json.org/JSON_checker/test/fail26.json
+    '["tab\\   character\\   in\\  string\\  "]',
+    # http://json.org/JSON_checker/test/fail27.json
+    '["line\nbreak"]',
+    # http://json.org/JSON_checker/test/fail28.json
+    '["line\\\nbreak"]',
+    # http://json.org/JSON_checker/test/fail29.json
+    '[0e]',
+    # http://json.org/JSON_checker/test/fail30.json
+    '[0e+]',
+    # http://json.org/JSON_checker/test/fail31.json
+    '[0e+-1]',
+    # http://json.org/JSON_checker/test/fail32.json
+    '{"Comma instead if closing brace": true,',
+    # http://json.org/JSON_checker/test/fail33.json
+    '["mismatch"}',
+    # http://code.google.com/p/simplejson/issues/detail?id=3
+    '["A\u001FZ control characters in string"]',
+]
+
+SKIPS = {
+    1: "why not have a string payload?",
+    18: "spec doesn't specify any nesting limitations",
+}
+
+class TestFail:
+    def test_failures(self):
+        for idx, doc in enumerate(JSONDOCS):
+            idx = idx + 1
+            if idx in SKIPS:
+                self.loads(doc)
+                continue
+            try:
+                self.loads(doc)
+            except ValueError:
+                pass
+            else:
+                self.fail("Expected failure for fail{0}.json: {1!r}".format(idx, doc))
+
+    def test_non_string_keys_dict(self):
+        data = {'a' : 1, (1, 2) : 2}
+
+        #This is for c encoder
+        self.assertRaises(TypeError, self.dumps, data)
+
+        #This is for python encoder
+        self.assertRaises(TypeError, self.dumps, data, indent=True)
+
+    def test_truncated_input(self):
+        test_cases = [
+            ('', 'Expecting value', 0),
+            ('[', 'Expecting value', 1),
+            ('[42', "Expecting ',' delimiter", 3),
+            ('[42,', 'Expecting value', 4),
+            ('["', 'Unterminated string starting at', 1),
+            ('["spam', 'Unterminated string starting at', 1),
+            ('["spam"', "Expecting ',' delimiter", 7),
+            ('["spam",', 'Expecting value', 8),
+            ('{', 'Expecting property name enclosed in double quotes', 1),
+            ('{"', 'Unterminated string starting at', 1),
+            ('{"spam', 'Unterminated string starting at', 1),
+            ('{"spam"', "Expecting ':' delimiter", 7),
+            ('{"spam":', 'Expecting value', 8),
+            ('{"spam":42', "Expecting ',' delimiter", 10),
+            ('{"spam":42,', 'Expecting property name enclosed in double quotes', 11),
+        ]
+        test_cases += [
+            ('"', 'Unterminated string starting at', 0),
+            ('"spam', 'Unterminated string starting at', 0),
+        ]
+        for data, msg, idx in test_cases:
+            self.assertRaisesRegex(ValueError,
+                r'^{0}: line 1 column {1} \(char {2}\)'.format(
+                    re.escape(msg), idx + 1, idx),
+                self.loads, data)
+
+    def test_unexpected_data(self):
+        test_cases = [
+            ('[,', 'Expecting value', 1),
+            ('{"spam":[}', 'Expecting value', 9),
+            ('[42:', "Expecting ',' delimiter", 3),
+            ('[42 "spam"', "Expecting ',' delimiter", 4),
+            ('[42,]', 'Expecting value', 4),
+            ('{"spam":[42}', "Expecting ',' delimiter", 11),
+            ('["]', 'Unterminated string starting at', 1),
+            ('["spam":', "Expecting ',' delimiter", 7),
+            ('["spam",]', 'Expecting value', 8),
+            ('{:', 'Expecting property name enclosed in double quotes', 1),
+            ('{,', 'Expecting property name enclosed in double quotes', 1),
+            ('{42', 'Expecting property name enclosed in double quotes', 1),
+            ('[{]', 'Expecting property name enclosed in double quotes', 2),
+            ('{"spam",', "Expecting ':' delimiter", 7),
+            ('{"spam"}', "Expecting ':' delimiter", 7),
+            ('[{"spam"]', "Expecting ':' delimiter", 8),
+            ('{"spam":}', 'Expecting value', 8),
+            ('[{"spam":]', 'Expecting value', 9),
+            ('{"spam":42 "ham"', "Expecting ',' delimiter", 11),
+            ('[{"spam":42]', "Expecting ',' delimiter", 11),
+            ('{"spam":42,}', 'Expecting property name enclosed in double quotes', 11),
+        ]
+        for data, msg, idx in test_cases:
+            self.assertRaisesRegex(ValueError,
+                r'^{0}: line 1 column {1} \(char {2}\)'.format(
+                    re.escape(msg), idx + 1, idx),
+                self.loads, data)
+
+    def test_extra_data(self):
+        test_cases = [
+            ('[]]', 'Extra data', 2),
+            ('{}}', 'Extra data', 2),
+            ('[],[]', 'Extra data', 2),
+            ('{},{}', 'Extra data', 2),
+        ]
+        test_cases += [
+            ('42,"spam"', 'Extra data', 2),
+            ('"spam",42', 'Extra data', 6),
+        ]
+        for data, msg, idx in test_cases:
+            self.assertRaisesRegex(ValueError,
+                r'^{0}: line 1 column {1} - line 1 column {2}'
+                r' \(char {3} - {4}\)'.format(
+                    re.escape(msg), idx + 1, len(data) + 1, idx, len(data)),
+                self.loads, data)
+
+    def test_linecol(self):
+        test_cases = [
+            ('!', 1, 1, 0),
+            (' !', 1, 2, 1),
+            ('\n!', 2, 1, 1),
+            ('\n  \n\n     !', 4, 6, 10),
+        ]
+        for data, line, col, idx in test_cases:
+            self.assertRaisesRegex(ValueError,
+                r'^Expecting value: line {0} column {1}'
+                r' \(char {2}\)$'.format(line, col, idx),
+                self.loads, data)
+
+class TestPyFail(TestFail, PyTest): pass
+class TestCFail(TestFail, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_float.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_float.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,33 @@
+import math
+from test.json_tests import PyTest, CTest
+
+
+class TestFloat:
+    def test_floats(self):
+        for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]:
+            self.assertEqual(float(self.dumps(num)), num)
+            self.assertEqual(self.loads(self.dumps(num)), num)
+
+    def test_ints(self):
+        for num in [1, 1<<32, 1<<64]:
+            self.assertEqual(self.dumps(num), str(num))
+            self.assertEqual(int(self.dumps(num)), num)
+
+    def test_out_of_range(self):
+        self.assertEqual(self.loads('[23456789012E666]'), [float('inf')])
+        self.assertEqual(self.loads('[-23456789012E666]'), [float('-inf')])
+
+    def test_allow_nan(self):
+        for val in (float('inf'), float('-inf'), float('nan')):
+            out = self.dumps([val])
+            if val == val:  # inf
+                self.assertEqual(self.loads(out), [val])
+            else:  # nan
+                res = self.loads(out)
+                self.assertEqual(len(res), 1)
+                self.assertNotEqual(res[0], res[0])
+            self.assertRaises(ValueError, self.dumps, [val], allow_nan=False)
+
+
+class TestPyFloat(TestFloat, PyTest): pass
+class TestCFloat(TestFloat, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_indent.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_indent.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,67 @@
+import textwrap
+from io import StringIO
+from test.json_tests import PyTest, CTest
+
+
+class TestIndent:
+    def test_indent(self):
+        h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth',
+             {'nifty': 87}, {'field': 'yes', 'morefield': False} ]
+
+        expect = textwrap.dedent("""\
+        [
+        \t[
+        \t\t"blorpie"
+        \t],
+        \t[
+        \t\t"whoops"
+        \t],
+        \t[],
+        \t"d-shtaeou",
+        \t"d-nthiouh",
+        \t"i-vhbjkhnth",
+        \t{
+        \t\t"nifty": 87
+        \t},
+        \t{
+        \t\t"field": "yes",
+        \t\t"morefield": false
+        \t}
+        ]""")
+
+        d1 = self.dumps(h)
+        d2 = self.dumps(h, indent=2, sort_keys=True, separators=(',', ': '))
+        d3 = self.dumps(h, indent='\t', sort_keys=True, separators=(',', ': '))
+        d4 = self.dumps(h, indent=2, sort_keys=True)
+        d5 = self.dumps(h, indent='\t', sort_keys=True)
+
+        h1 = self.loads(d1)
+        h2 = self.loads(d2)
+        h3 = self.loads(d3)
+
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(h3, h)
+        self.assertEqual(d2, expect.expandtabs(2))
+        self.assertEqual(d3, expect)
+        self.assertEqual(d4, d2)
+        self.assertEqual(d5, d3)
+
+    def test_indent0(self):
+        h = {3: 1}
+        def check(indent, expected):
+            d1 = self.dumps(h, indent=indent)
+            self.assertEqual(d1, expected)
+
+            sio = StringIO()
+            self.json.dump(h, sio, indent=indent)
+            self.assertEqual(sio.getvalue(), expected)
+
+        # indent=0 should emit newlines
+        check(0, '{\n"3": 1\n}')
+        # indent=None is more compact
+        check(None, '{"3": 1}')
+
+
+class TestPyIndent(TestIndent, PyTest): pass
+class TestCIndent(TestIndent, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_pass1.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_pass1.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,75 @@
+from test.json_tests import PyTest, CTest
+
+
+# from http://json.org/JSON_checker/test/pass1.json
+JSON = r'''
+[
+    "JSON Test Pattern pass1",
+    {"object with 1 member":["array with 1 element"]},
+    {},
+    [],
+    -42,
+    true,
+    false,
+    null,
+    {
+        "integer": 1234567890,
+        "real": -9876.543210,
+        "e": 0.123456789e-12,
+        "E": 1.234567890E+34,
+        "":  23456789012E66,
+        "zero": 0,
+        "one": 1,
+        "space": " ",
+        "quote": "\"",
+        "backslash": "\\",
+        "controls": "\b\f\n\r\t",
+        "slash": "/ & \/",
+        "alpha": "abcdefghijklmnopqrstuvwyz",
+        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+        "digit": "0123456789",
+        "0123456789": "digit",
+        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+        "true": true,
+        "false": false,
+        "null": null,
+        "array":[  ],
+        "object":{  },
+        "address": "50 St. James Street",
+        "url": "http://www.JSON.org/",
+        "comment": "// /* <!-- --",
+        "# -- --> */": " ",
+        " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5        ,          6           ,7        ],"compact":[1,2,3,4,5,6,7],
+        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
+        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+    },
+    0.5 ,98.6
+,
+99.44
+,
+
+1066,
+1e1,
+0.1e1,
+1e-1,
+1e00,2e+00,2e-00
+,"rosebud"]
+'''
+
+class TestPass1:
+    def test_parse(self):
+        # test in/out equivalence and parsing
+        res = self.loads(JSON)
+        out = self.dumps(res)
+        self.assertEqual(res, self.loads(out))
+
+
+class TestPyPass1(TestPass1, PyTest): pass
+class TestCPass1(TestPass1, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_pass2.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_pass2.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,18 @@
+from test.json_tests import PyTest, CTest
+
+
+# from http://json.org/JSON_checker/test/pass2.json
+JSON = r'''
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
+'''
+
+class TestPass2:
+    def test_parse(self):
+        # test in/out equivalence and parsing
+        res = self.loads(JSON)
+        out = self.dumps(res)
+        self.assertEqual(res, self.loads(out))
+
+
+class TestPyPass2(TestPass2, PyTest): pass
+class TestCPass2(TestPass2, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_pass3.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_pass3.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,24 @@
+from test.json_tests import PyTest, CTest
+
+
+# from http://json.org/JSON_checker/test/pass3.json
+JSON = r'''
+{
+    "JSON Test Pattern pass3": {
+        "The outermost value": "must be an object or array.",
+        "In this test": "It is an object."
+    }
+}
+'''
+
+
+class TestPass3:
+    def test_parse(self):
+        # test in/out equivalence and parsing
+        res = self.loads(JSON)
+        out = self.dumps(res)
+        self.assertEqual(res, self.loads(out))
+
+
+class TestPyPass3(TestPass3, PyTest): pass
+class TestCPass3(TestPass3, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_recursion.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_recursion.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,100 @@
+from test.json_tests import PyTest, CTest
+
+
+class JSONTestObject:
+    pass
+
+
+class TestRecursion:
+    def test_listrecursion(self):
+        x = []
+        x.append(x)
+        try:
+            self.dumps(x)
+        except ValueError:
+            pass
+        else:
+            self.fail("didn't raise ValueError on list recursion")
+        x = []
+        y = [x]
+        x.append(y)
+        try:
+            self.dumps(x)
+        except ValueError:
+            pass
+        else:
+            self.fail("didn't raise ValueError on alternating list recursion")
+        y = []
+        x = [y, y]
+        # ensure that the marker is cleared
+        self.dumps(x)
+
+    def test_dictrecursion(self):
+        x = {}
+        x["test"] = x
+        try:
+            self.dumps(x)
+        except ValueError:
+            pass
+        else:
+            self.fail("didn't raise ValueError on dict recursion")
+        x = {}
+        y = {"a": x, "b": x}
+        # ensure that the marker is cleared
+        self.dumps(x)
+
+    def test_defaultrecursion(self):
+        class RecursiveJSONEncoder(self.json.JSONEncoder):
+            recurse = False
+            def default(self, o):
+                if o is JSONTestObject:
+                    if self.recurse:
+                        return [JSONTestObject]
+                    else:
+                        return 'JSONTestObject'
+                return pyjson.JSONEncoder.default(o)
+
+        enc = RecursiveJSONEncoder()
+        self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"')
+        enc.recurse = True
+        try:
+            enc.encode(JSONTestObject)
+        except ValueError:
+            pass
+        else:
+            self.fail("didn't raise ValueError on default recursion")
+
+
+    def test_highly_nested_objects_decoding(self):
+        # test that loading highly-nested objects doesn't segfault when C
+        # accelerations are used. See #12017
+        with self.assertRaises(RuntimeError):
+            self.loads('{"a":' * 100000 + '1' + '}' * 100000)
+        with self.assertRaises(RuntimeError):
+            self.loads('{"a":' * 100000 + '[1]' + '}' * 100000)
+        with self.assertRaises(RuntimeError):
+            self.loads('[' * 100000 + '1' + ']' * 100000)
+
+    def test_highly_nested_objects_encoding(self):
+        # See #12051
+        l, d = [], {}
+        for x in range(100000):
+            l, d = [l], {'k':d}
+        with self.assertRaises(RuntimeError):
+            self.dumps(l)
+        with self.assertRaises(RuntimeError):
+            self.dumps(d)
+
+    def test_endless_recursion(self):
+        # See #12051
+        class EndlessJSONEncoder(self.json.JSONEncoder):
+            def default(self, o):
+                """If check_circular is False, this will keep adding another list."""
+                return [o]
+
+        with self.assertRaises(RuntimeError):
+            EndlessJSONEncoder(check_circular=False).encode(5j)
+
+
+class TestPyRecursion(TestRecursion, PyTest): pass
+class TestCRecursion(TestRecursion, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_scanstring.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_scanstring.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,98 @@
+import sys
+from test.json_tests import PyTest, CTest
+
+
+class TestScanstring:
+    def test_scanstring(self):
+        scanstring = self.json.decoder.scanstring
+        self.assertEqual(
+            scanstring('"z\\ud834\\udd20x"', 1, True),
+            ('z\U0001d120x', 16))
+
+        self.assertEqual(
+            scanstring('"z\U0001d120x"', 1, True),
+            ('z\U0001d120x', 5))
+
+        self.assertEqual(
+            scanstring('"\\u007b"', 1, True),
+            ('{', 8))
+
+        self.assertEqual(
+            scanstring('"A JSON payload should be an object or array, not a string."', 1, True),
+            ('A JSON payload should be an object or array, not a string.', 60))
+
+        self.assertEqual(
+            scanstring('["Unclosed array"', 2, True),
+            ('Unclosed array', 17))
+
+        self.assertEqual(
+            scanstring('["extra comma",]', 2, True),
+            ('extra comma', 14))
+
+        self.assertEqual(
+            scanstring('["double extra comma",,]', 2, True),
+            ('double extra comma', 21))
+
+        self.assertEqual(
+            scanstring('["Comma after the close"],', 2, True),
+            ('Comma after the close', 24))
+
+        self.assertEqual(
+            scanstring('["Extra close"]]', 2, True),
+            ('Extra close', 14))
+
+        self.assertEqual(
+            scanstring('{"Extra comma": true,}', 2, True),
+            ('Extra comma', 14))
+
+        self.assertEqual(
+            scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, True),
+            ('Extra value after close', 26))
+
+        self.assertEqual(
+            scanstring('{"Illegal expression": 1 + 2}', 2, True),
+            ('Illegal expression', 21))
+
+        self.assertEqual(
+            scanstring('{"Illegal invocation": alert()}', 2, True),
+            ('Illegal invocation', 21))
+
+        self.assertEqual(
+            scanstring('{"Numbers cannot have leading zeroes": 013}', 2, True),
+            ('Numbers cannot have leading zeroes', 37))
+
+        self.assertEqual(
+            scanstring('{"Numbers cannot be hex": 0x14}', 2, True),
+            ('Numbers cannot be hex', 24))
+
+        self.assertEqual(
+            scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, True),
+            ('Too deep', 30))
+
+        self.assertEqual(
+            scanstring('{"Missing colon" null}', 2, True),
+            ('Missing colon', 16))
+
+        self.assertEqual(
+            scanstring('{"Double colon":: null}', 2, True),
+            ('Double colon', 15))
+
+        self.assertEqual(
+            scanstring('{"Comma instead of colon", null}', 2, True),
+            ('Comma instead of colon', 25))
+
+        self.assertEqual(
+            scanstring('["Colon instead of comma": false]', 2, True),
+            ('Colon instead of comma', 25))
+
+        self.assertEqual(
+            scanstring('["Bad value", truth]', 2, True),
+            ('Bad value', 12))
+
+    def test_overflow(self):
+        with self.assertRaises(OverflowError):
+            self.json.decoder.scanstring(b"xxx", sys.maxsize+1)
+
+
+class TestPyScanstring(TestScanstring, PyTest): pass
+class TestCScanstring(TestScanstring, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_separators.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_separators.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,44 @@
+import textwrap
+from test.json_tests import PyTest, CTest
+
+
+class TestSeparators:
+    def test_separators(self):
+        h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth',
+             {'nifty': 87}, {'field': 'yes', 'morefield': False} ]
+
+        expect = textwrap.dedent("""\
+        [
+          [
+            "blorpie"
+          ] ,
+          [
+            "whoops"
+          ] ,
+          [] ,
+          "d-shtaeou" ,
+          "d-nthiouh" ,
+          "i-vhbjkhnth" ,
+          {
+            "nifty" : 87
+          } ,
+          {
+            "field" : "yes" ,
+            "morefield" : false
+          }
+        ]""")
+
+
+        d1 = self.dumps(h)
+        d2 = self.dumps(h, indent=2, sort_keys=True, separators=(' ,', ' : '))
+
+        h1 = self.loads(d1)
+        h2 = self.loads(d2)
+
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(d2, expect)
+
+
+class TestPySeparators(TestSeparators, PyTest): pass
+class TestCSeparators(TestSeparators, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_speedups.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_speedups.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,24 @@
+from test.json_tests import CTest
+
+
+class TestSpeedups(CTest):
+    def test_scanstring(self):
+        self.assertEqual(self.json.decoder.scanstring.__module__, "_json")
+        self.assertIs(self.json.decoder.scanstring, self.json.decoder.c_scanstring)
+
+    def test_encode_basestring_ascii(self):
+        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
+                         "_json")
+        self.assertIs(self.json.encoder.encode_basestring_ascii,
+                      self.json.encoder.c_encode_basestring_ascii)
+
+
+class TestDecode(CTest):
+    def test_make_scanner(self):
+        self.assertRaises(AttributeError, self.json.scanner.c_make_scanner, 1)
+
+    def test_make_encoder(self):
+        self.assertRaises(TypeError, self.json.encoder.c_make_encoder,
+            (True, False),
+            b"\xCD\x7D\x3D\x4E\x12\x4C\xF9\x79\xD7\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75",
+            None)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_tool.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_tool.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,69 @@
+import os
+import sys
+import textwrap
+import unittest
+import subprocess
+from test import support
+from test.script_helper import assert_python_ok
+
+class TestTool(unittest.TestCase):
+    data = """
+
+        [["blorpie"],[ "whoops" ] , [
+                                 ],\t"d-shtaeou",\r"d-nthiouh",
+        "i-vhbjkhnth", {"nifty":87}, {"morefield" :\tfalse,"field"
+            :"yes"}  ]
+           """
+
+    expect = textwrap.dedent("""\
+    [
+        [
+            "blorpie"
+        ],
+        [
+            "whoops"
+        ],
+        [],
+        "d-shtaeou",
+        "d-nthiouh",
+        "i-vhbjkhnth",
+        {
+            "nifty": 87
+        },
+        {
+            "field": "yes",
+            "morefield": false
+        }
+    ]
+    """)
+
+    def test_stdin_stdout(self):
+        with subprocess.Popen(
+                (sys.executable, '-m', 'json.tool'),
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE) as proc:
+            out, err = proc.communicate(self.data.encode())
+        self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
+        self.assertEqual(err, None)
+
+    def _create_infile(self):
+        infile = support.TESTFN
+        with open(infile, "w") as fp:
+            self.addCleanup(os.remove, infile)
+            fp.write(self.data)
+        return infile
+
+    def test_infile_stdout(self):
+        infile = self._create_infile()
+        rc, out, err = assert_python_ok('-m', 'json.tool', infile)
+        self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
+        self.assertEqual(err, b'')
+
+    def test_infile_outfile(self):
+        infile = self._create_infile()
+        outfile = support.TESTFN + '.out'
+        rc, out, err = assert_python_ok('-m', 'json.tool', infile, outfile)
+        self.addCleanup(os.remove, outfile)
+        with open(outfile, "r") as fp:
+            self.assertEqual(fp.read(), self.expect)
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/json_tests/test_unicode.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/json_tests/test_unicode.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,75 @@
+from collections import OrderedDict
+from test.json_tests import PyTest, CTest
+
+
+class TestUnicode:
+    # test_encoding1 and test_encoding2 from 2.x are irrelevant (only str
+    # is supported as input, not bytes).
+
+    def test_encoding3(self):
+        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
+        j = self.dumps(u)
+        self.assertEqual(j, '"\\u03b1\\u03a9"')
+
+    def test_encoding4(self):
+        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
+        j = self.dumps([u])
+        self.assertEqual(j, '["\\u03b1\\u03a9"]')
+
+    def test_encoding5(self):
+        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
+        j = self.dumps(u, ensure_ascii=False)
+        self.assertEqual(j, '"{0}"'.format(u))
+
+    def test_encoding6(self):
+        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
+        j = self.dumps([u], ensure_ascii=False)
+        self.assertEqual(j, '["{0}"]'.format(u))
+
+    def test_big_unicode_encode(self):
+        u = '\U0001d120'
+        self.assertEqual(self.dumps(u), '"\\ud834\\udd20"')
+        self.assertEqual(self.dumps(u, ensure_ascii=False), '"\U0001d120"')
+
+    def test_big_unicode_decode(self):
+        u = 'z\U0001d120x'
+        self.assertEqual(self.loads('"' + u + '"'), u)
+        self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u)
+
+    def test_unicode_decode(self):
+        for i in range(0, 0xd7ff):
+            u = chr(i)
+            s = '"\\u{0:04x}"'.format(i)
+            self.assertEqual(self.loads(s), u)
+
+    def test_unicode_preservation(self):
+        self.assertEqual(type(self.loads('""')), str)
+        self.assertEqual(type(self.loads('"a"')), str)
+        self.assertEqual(type(self.loads('["a"]')[0]), str)
+
+    def test_bytes_encode(self):
+        self.assertRaises(TypeError, self.dumps, b"hi")
+        self.assertRaises(TypeError, self.dumps, [b"hi"])
+
+    def test_bytes_decode(self):
+        self.assertRaises(TypeError, self.loads, b'"hi"')
+        self.assertRaises(TypeError, self.loads, b'["hi"]')
+
+
+    def test_object_pairs_hook_with_unicode(self):
+        s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
+        p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4),
+             ("qrt", 5), ("pad", 6), ("hoy", 7)]
+        self.assertEqual(self.loads(s), eval(s))
+        self.assertEqual(self.loads(s, object_pairs_hook = lambda x: x), p)
+        od = self.loads(s, object_pairs_hook = OrderedDict)
+        self.assertEqual(od, OrderedDict(p))
+        self.assertEqual(type(od), OrderedDict)
+        # the object_pairs_hook takes priority over the object_hook
+        self.assertEqual(self.loads(s, object_pairs_hook = OrderedDict,
+                                    object_hook = lambda x: None),
+                         OrderedDict(p))
+
+
+class TestPyUnicode(TestUnicode, PyTest): pass
+class TestCUnicode(TestUnicode, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/lock_tests.py
--- a/Lib/test/lock_tests.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/lock_tests.py	Mon Aug 12 02:18:40 2013 +0200
@@ -80,11 +80,6 @@
         lock = self.locktype()
         del lock
 
-    def test_repr(self):
-        lock = self.locktype()
-        repr(lock)
-        del lock
-
     def test_acquire_destroy(self):
         lock = self.locktype()
         lock.acquire()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/script_helper.py
--- a/Lib/test/script_helper.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/script_helper.py	Mon Aug 12 02:18:40 2013 +0200
@@ -13,7 +13,7 @@
 import zipfile
 
 from importlib.util import source_from_cache
-from test.support import make_legacy_pyc, strip_python_stderr, temp_dir
+from test.support import make_legacy_pyc, strip_python_stderr
 
 # Executing the interpreter in a subprocess
 def _assert_python(expected_success, *args, **env_vars):
@@ -39,7 +39,7 @@
         p.stdout.close()
         p.stderr.close()
     rc = p.returncode
-    err = strip_python_stderr(err)
+    err =  strip_python_stderr(err)
     if (rc and expected_success) or (not rc and not expected_success):
         raise AssertionError(
             "Process return code is %d, "
@@ -49,25 +49,18 @@
 def assert_python_ok(*args, **env_vars):
     """
     Assert that running the interpreter with `args` and optional environment
-    variables `env_vars` succeeds (rc == 0) and return a (return code, stdout,
-    stderr) tuple.
+    variables `env_vars` is ok and return a (return code, stdout, stderr) tuple.
     """
     return _assert_python(True, *args, **env_vars)
 
 def assert_python_failure(*args, **env_vars):
     """
     Assert that running the interpreter with `args` and optional environment
-    variables `env_vars` fails (rc != 0) and return a (return code, stdout,
-    stderr) tuple.
+    variables `env_vars` fails and return a (return code, stdout, stderr) tuple.
     """
     return _assert_python(False, *args, **env_vars)
 
 def spawn_python(*args, **kw):
-    """Run a Python subprocess with the given arguments.
-
-    kw is extra keyword args to pass to subprocess.Popen. Returns a Popen
-    object.
-    """
     cmd_line = [sys.executable, '-E']
     cmd_line.extend(args)
     return subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
@@ -75,7 +68,6 @@
                             **kw)
 
 def kill_python(p):
-    """Run the given Popen process until completion and return stdout."""
     p.stdin.close()
     data = p.stdout.read()
     p.stdout.close()
@@ -85,6 +77,16 @@
     subprocess._cleanup()
     return data
 
+# Script creation utilities
+@contextlib.contextmanager
+def temp_dir():
+    dirname = tempfile.mkdtemp()
+    dirname = os.path.realpath(dirname)
+    try:
+        yield dirname
+    finally:
+        shutil.rmtree(dirname)
+
 def make_script(script_dir, script_basename, source):
     script_filename = script_basename+os.extsep+'py'
     script_name = os.path.join(script_dir, script_filename)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/subprocessdata/fd_status.py
--- a/Lib/test/subprocessdata/fd_status.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/subprocessdata/fd_status.py	Mon Aug 12 02:18:40 2013 +0200
@@ -3,6 +3,7 @@
 
 import errno
 import os
+import stat
 
 try:
     _MAXFD = os.sysconf("SC_OPEN_MAX")
@@ -19,6 +20,6 @@
                 continue
             raise
         # Ignore Solaris door files
-        if st.st_mode & 0xF000 != 0xd000:
+        if not stat.S_ISDOOR(st.st_mode):
             fds.append(fd)
     print(','.join(map(str, fds)))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/subprocessdata/inherited.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/subprocessdata/inherited.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,22 @@
+"""Similar to fd_status.py, but only checks file descriptors passed on the
+command line."""
+
+import errno
+import os
+import sys
+import stat
+
+if __name__ == "__main__":
+    fds = map(int, sys.argv[1:])
+    inherited = []
+    for fd in fds:
+        try:
+            st = os.fstat(fd)
+        except OSError as e:
+            if e.errno == errno.EBADF:
+                continue
+            raise
+        # Ignore Solaris door files
+        if not stat.S_ISDOOR(st.st_mode):
+            inherited.append(fd)
+    print(','.join(map(str, inherited)))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/support.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/support.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,1989 @@
+"""Supporting definitions for the Python regression tests."""
+
+if __name__ != 'test.support':
+    raise ImportError('support must be imported from the test package')
+
+import contextlib
+import errno
+import functools
+import gc
+import socket
+import sys
+import os
+import platform
+import shutil
+import warnings
+import unittest
+import importlib
+import importlib.util
+import collections.abc
+import re
+import subprocess
+import time
+import sysconfig
+import fnmatch
+import logging.handlers
+import struct
+import tempfile
+import _testcapi
+
+try:
+    import _thread, threading
+except ImportError:
+    _thread = None
+    threading = None
+try:
+    import multiprocessing.process
+except ImportError:
+    multiprocessing = None
+
+try:
+    import zlib
+except ImportError:
+    zlib = None
+
+try:
+    import gzip
+except ImportError:
+    gzip = None
+
+try:
+    import bz2
+except ImportError:
+    bz2 = None
+
+try:
+    import lzma
+except ImportError:
+    lzma = None
+
+__all__ = [
+    "Error", "TestFailed", "ResourceDenied", "import_module", "verbose",
+    "use_resources", "max_memuse", "record_original_stdout",
+    "get_original_stdout", "unload", "unlink", "rmtree", "forget",
+    "is_resource_enabled", "requires", "requires_freebsd_version",
+    "requires_linux_version", "requires_mac_ver", "find_unused_port",
+    "bind_port", "IPV6_ENABLED", "is_jython", "TESTFN", "HOST", "SAVEDCWD",
+    "temp_cwd", "findfile", "create_empty_file", "sortdict",
+    "check_syntax_error", "open_urlresource", "check_warnings", "CleanImport",
+    "EnvironmentVarGuard", "TransientResource", "captured_stdout",
+    "captured_stdin", "captured_stderr", "time_out", "socket_peer_reset",
+    "ioerror_peer_reset", "run_with_locale", 'temp_umask',
+    "transient_internet", "set_memlimit", "bigmemtest", "bigaddrspacetest",
+    "BasicTestRunner", "run_unittest", "run_doctest", "threading_setup",
+    "threading_cleanup", "reap_children", "cpython_only", "check_impl_detail",
+    "get_attribute", "swap_item", "swap_attr", "requires_IEEE_754",
+    "TestHandler", "Matcher", "can_symlink", "skip_unless_symlink",
+    "skip_unless_xattr", "import_fresh_module", "requires_zlib",
+    "PIPE_MAX_SIZE", "failfast", "anticipate_failure", "run_with_tz",
+    "requires_gzip", "requires_bz2", "requires_lzma", "suppress_crash_popup",
+    ]
+
+class Error(Exception):
+    """Base class for regression test exceptions."""
+
+class TestFailed(Error):
+    """Test failed."""
+
+class ResourceDenied(unittest.SkipTest):
+    """Test skipped because it requested a disallowed resource.
+
+    This is raised when a test calls requires() for a resource that
+    has not be enabled.  It is used to distinguish between expected
+    and unexpected skips.
+    """
+
+@contextlib.contextmanager
+def _ignore_deprecated_imports(ignore=True):
+    """Context manager to suppress package and module deprecation
+    warnings when importing them.
+
+    If ignore is False, this context manager has no effect.
+    """
+    if ignore:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", ".+ (module|package)",
+                                    DeprecationWarning)
+            yield
+    else:
+        yield
+
+
+def import_module(name, deprecated=False, *, required_on=()):
+    """Import and return the module to be tested, raising SkipTest if
+    it is not available.
+
+    If deprecated is True, any module or package deprecation messages
+    will be suppressed. If a module is required on a platform but optional for
+    others, set required_on to an iterable of platform prefixes which will be
+    compared against sys.platform.
+    """
+    with _ignore_deprecated_imports(deprecated):
+        try:
+            return importlib.import_module(name)
+        except ImportError as msg:
+            if sys.platform.startswith(tuple(required_on)):
+                raise
+            raise unittest.SkipTest(str(msg))
+
+
+def _save_and_remove_module(name, orig_modules):
+    """Helper function to save and remove a module from sys.modules
+
+       Raise ImportError if the module can't be imported.
+       """
+    # try to import the module and raise an error if it can't be imported
+    if name not in sys.modules:
+        __import__(name)
+        del sys.modules[name]
+    for modname in list(sys.modules):
+        if modname == name or modname.startswith(name + '.'):
+            orig_modules[modname] = sys.modules[modname]
+            del sys.modules[modname]
+
+def _save_and_block_module(name, orig_modules):
+    """Helper function to save and block a module in sys.modules
+
+       Return True if the module was in sys.modules, False otherwise."""
+    saved = True
+    try:
+        orig_modules[name] = sys.modules[name]
+    except KeyError:
+        saved = False
+    sys.modules[name] = None
+    return saved
+
+
+def anticipate_failure(condition):
+    """Decorator to mark a test that is known to be broken in some cases
+
+       Any use of this decorator should have a comment identifying the
+       associated tracker issue.
+    """
+    if condition:
+        return unittest.expectedFailure
+    return lambda f: f
+
+
+def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
+    """Imports and returns a module, deliberately bypassing the sys.modules cache
+    and importing a fresh copy of the module. Once the import is complete,
+    the sys.modules cache is restored to its original state.
+
+    Modules named in fresh are also imported anew if needed by the import.
+    If one of these modules can't be imported, None is returned.
+
+    Importing of modules named in blocked is prevented while the fresh import
+    takes place.
+
+    If deprecated is True, any module or package deprecation messages
+    will be suppressed."""
+    # NOTE: test_heapq, test_json and test_warnings include extra sanity checks
+    # to make sure that this utility function is working as expected
+    with _ignore_deprecated_imports(deprecated):
+        # Keep track of modules saved for later restoration as well
+        # as those which just need a blocking entry removed
+        orig_modules = {}
+        names_to_remove = []
+        _save_and_remove_module(name, orig_modules)
+        try:
+            for fresh_name in fresh:
+                _save_and_remove_module(fresh_name, orig_modules)
+            for blocked_name in blocked:
+                if not _save_and_block_module(blocked_name, orig_modules):
+                    names_to_remove.append(blocked_name)
+            fresh_module = importlib.import_module(name)
+        except ImportError:
+            fresh_module = None
+        finally:
+            for orig_name, module in orig_modules.items():
+                sys.modules[orig_name] = module
+            for name_to_remove in names_to_remove:
+                del sys.modules[name_to_remove]
+        return fresh_module
+
+
+def get_attribute(obj, name):
+    """Get an attribute, raising SkipTest if AttributeError is raised."""
+    try:
+        attribute = getattr(obj, name)
+    except AttributeError:
+        raise unittest.SkipTest("object %r has no attribute %r" % (obj, name))
+    else:
+        return attribute
+
+verbose = 1              # Flag set to 0 by regrtest.py
+use_resources = None     # Flag set to [] by regrtest.py
+max_memuse = 0           # Disable bigmem tests (they will still be run with
+                         # small sizes, to make sure they work.)
+real_max_memuse = 0
+failfast = False
+match_tests = None
+
+# _original_stdout is meant to hold stdout at the time regrtest began.
+# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
+# The point is to have some flavor of stdout the user can actually see.
+_original_stdout = None
+def record_original_stdout(stdout):
+    global _original_stdout
+    _original_stdout = stdout
+
+def get_original_stdout():
+    return _original_stdout or sys.stdout
+
+def unload(name):
+    try:
+        del sys.modules[name]
+    except KeyError:
+        pass
+
+if sys.platform.startswith("win"):
+    def _waitfor(func, pathname, waitall=False):
+        # Peform the operation
+        func(pathname)
+        # Now setup the wait loop
+        if waitall:
+            dirname = pathname
+        else:
+            dirname, name = os.path.split(pathname)
+            dirname = dirname or '.'
+        # Check for `pathname` to be removed from the filesystem.
+        # The exponential backoff of the timeout amounts to a total
+        # of ~1 second after which the deletion is probably an error
+        # anyway.
+        # Testing on a i7@4.3GHz shows that usually only 1 iteration is
+        # required when contention occurs.
+        timeout = 0.001
+        while timeout < 1.0:
+            # Note we are only testing for the existance of the file(s) in
+            # the contents of the directory regardless of any security or
+            # access rights.  If we have made it this far, we have sufficient
+            # permissions to do that much using Python's equivalent of the
+            # Windows API FindFirstFile.
+            # Other Windows APIs can fail or give incorrect results when
+            # dealing with files that are pending deletion.
+            L = os.listdir(dirname)
+            if not (L if waitall else name in L):
+                return
+            # Increase the timeout and try again
+            time.sleep(timeout)
+            timeout *= 2
+        warnings.warn('tests may fail, delete still pending for ' + pathname,
+                      RuntimeWarning, stacklevel=4)
+
+    def _unlink(filename):
+        _waitfor(os.unlink, filename)
+
+    def _rmdir(dirname):
+        _waitfor(os.rmdir, dirname)
+
+    def _rmtree(path):
+        def _rmtree_inner(path):
+            for name in os.listdir(path):
+                fullname = os.path.join(path, name)
+                if os.path.isdir(fullname):
+                    _waitfor(_rmtree_inner, fullname, waitall=True)
+                    os.rmdir(fullname)
+                else:
+                    os.unlink(fullname)
+        _waitfor(_rmtree_inner, path, waitall=True)
+        _waitfor(os.rmdir, path)
+else:
+    _unlink = os.unlink
+    _rmdir = os.rmdir
+    _rmtree = shutil.rmtree
+
+def unlink(filename):
+    try:
+        _unlink(filename)
+    except (FileNotFoundError, NotADirectoryError):
+        pass
+
+def rmdir(dirname):
+    try:
+        _rmdir(dirname)
+    except FileNotFoundError:
+        pass
+
+def rmtree(path):
+    try:
+        _rmtree(path)
+    except FileNotFoundError:
+        pass
+
+def make_legacy_pyc(source):
+    """Move a PEP 3147 pyc/pyo file to its legacy pyc/pyo location.
+
+    The choice of .pyc or .pyo extension is done based on the __debug__ flag
+    value.
+
+    :param source: The file system path to the source file.  The source file
+        does not need to exist, however the PEP 3147 pyc file must exist.
+    :return: The file system path to the legacy pyc file.
+    """
+    pyc_file = importlib.util.cache_from_source(source)
+    up_one = os.path.dirname(os.path.abspath(source))
+    legacy_pyc = os.path.join(up_one, source + ('c' if __debug__ else 'o'))
+    os.rename(pyc_file, legacy_pyc)
+    return legacy_pyc
+
+def forget(modname):
+    """'Forget' a module was ever imported.
+
+    This removes the module from sys.modules and deletes any PEP 3147 or
+    legacy .pyc and .pyo files.
+    """
+    unload(modname)
+    for dirname in sys.path:
+        source = os.path.join(dirname, modname + '.py')
+        # It doesn't matter if they exist or not, unlink all possible
+        # combinations of PEP 3147 and legacy pyc and pyo files.
+        unlink(source + 'c')
+        unlink(source + 'o')
+        unlink(importlib.util.cache_from_source(source, debug_override=True))
+        unlink(importlib.util.cache_from_source(source, debug_override=False))
+
+# On some platforms, should not run gui test even if it is allowed
+# in `use_resources'.
+if sys.platform.startswith('win'):
+    import ctypes
+    import ctypes.wintypes
+    def _is_gui_available():
+        UOI_FLAGS = 1
+        WSF_VISIBLE = 0x0001
+        class USEROBJECTFLAGS(ctypes.Structure):
+            _fields_ = [("fInherit", ctypes.wintypes.BOOL),
+                        ("fReserved", ctypes.wintypes.BOOL),
+                        ("dwFlags", ctypes.wintypes.DWORD)]
+        dll = ctypes.windll.user32
+        h = dll.GetProcessWindowStation()
+        if not h:
+            raise ctypes.WinError()
+        uof = USEROBJECTFLAGS()
+        needed = ctypes.wintypes.DWORD()
+        res = dll.GetUserObjectInformationW(h,
+            UOI_FLAGS,
+            ctypes.byref(uof),
+            ctypes.sizeof(uof),
+            ctypes.byref(needed))
+        if not res:
+            raise ctypes.WinError()
+        return bool(uof.dwFlags & WSF_VISIBLE)
+else:
+    def _is_gui_available():
+        return True
+
+def is_resource_enabled(resource):
+    """Test whether a resource is enabled.  Known resources are set by
+    regrtest.py."""
+    return use_resources is not None and resource in use_resources
+
+def requires(resource, msg=None):
+    """Raise ResourceDenied if the specified resource is not available.
+
+    If the caller's module is __main__ then automatically return True.  The
+    possibility of False being returned occurs when regrtest.py is
+    executing.
+    """
+    if resource == 'gui' and not _is_gui_available():
+        raise unittest.SkipTest("Cannot use the 'gui' resource")
+    # see if the caller's module is __main__ - if so, treat as if
+    # the resource was set
+    if sys._getframe(1).f_globals.get("__name__") == "__main__":
+        return
+    if not is_resource_enabled(resource):
+        if msg is None:
+            msg = "Use of the %r resource not enabled" % resource
+        raise ResourceDenied(msg)
+
+def _requires_unix_version(sysname, min_version):
+    """Decorator raising SkipTest if the OS is `sysname` and the version is less
+    than `min_version`.
+
+    For example, @_requires_unix_version('FreeBSD', (7, 2)) raises SkipTest if
+    the FreeBSD version is less than 7.2.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kw):
+            if platform.system() == sysname:
+                version_txt = platform.release().split('-', 1)[0]
+                try:
+                    version = tuple(map(int, version_txt.split('.')))
+                except ValueError:
+                    pass
+                else:
+                    if version < min_version:
+                        min_version_txt = '.'.join(map(str, min_version))
+                        raise unittest.SkipTest(
+                            "%s version %s or higher required, not %s"
+                            % (sysname, min_version_txt, version_txt))
+        return wrapper
+    return decorator
+
+def requires_freebsd_version(*min_version):
+    """Decorator raising SkipTest if the OS is FreeBSD and the FreeBSD version is
+    less than `min_version`.
+
+    For example, @requires_freebsd_version(7, 2) raises SkipTest if the FreeBSD
+    version is less than 7.2.
+    """
+    return _requires_unix_version('FreeBSD', min_version)
+
+def requires_linux_version(*min_version):
+    """Decorator raising SkipTest if the OS is Linux and the Linux version is
+    less than `min_version`.
+
+    For example, @requires_linux_version(2, 6, 32) raises SkipTest if the Linux
+    version is less than 2.6.32.
+    """
+    return _requires_unix_version('Linux', min_version)
+
+def requires_mac_ver(*min_version):
+    """Decorator raising SkipTest if the OS is Mac OS X and the OS X
+    version if less than min_version.
+
+    For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version
+    is lesser than 10.5.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kw):
+            if sys.platform == 'darwin':
+                version_txt = platform.mac_ver()[0]
+                try:
+                    version = tuple(map(int, version_txt.split('.')))
+                except ValueError:
+                    pass
+                else:
+                    if version < min_version:
+                        min_version_txt = '.'.join(map(str, min_version))
+                        raise unittest.SkipTest(
+                            "Mac OS X %s or higher required, not %s"
+                            % (min_version_txt, version_txt))
+            return func(*args, **kw)
+        wrapper.min_version = min_version
+        return wrapper
+    return decorator
+
+
+HOST = 'localhost'
+
+def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM):
+    """Returns an unused port that should be suitable for binding.  This is
+    achieved by creating a temporary socket with the same family and type as
+    the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to
+    the specified host address (defaults to 0.0.0.0) with the port set to 0,
+    eliciting an unused ephemeral port from the OS.  The temporary socket is
+    then closed and deleted, and the ephemeral port is returned.
+
+    Either this method or bind_port() should be used for any tests where a
+    server socket needs to be bound to a particular port for the duration of
+    the test.  Which one to use depends on whether the calling code is creating
+    a python socket, or if an unused port needs to be provided in a constructor
+    or passed to an external program (i.e. the -accept argument to openssl's
+    s_server mode).  Always prefer bind_port() over find_unused_port() where
+    possible.  Hard coded ports should *NEVER* be used.  As soon as a server
+    socket is bound to a hard coded port, the ability to run multiple instances
+    of the test simultaneously on the same host is compromised, which makes the
+    test a ticking time bomb in a buildbot environment. On Unix buildbots, this
+    may simply manifest as a failed test, which can be recovered from without
+    intervention in most cases, but on Windows, the entire python process can
+    completely and utterly wedge, requiring someone to log in to the buildbot
+    and manually kill the affected process.
+
+    (This is easy to reproduce on Windows, unfortunately, and can be traced to
+    the SO_REUSEADDR socket option having different semantics on Windows versus
+    Unix/Linux.  On Unix, you can't have two AF_INET SOCK_STREAM sockets bind,
+    listen and then accept connections on identical host/ports.  An EADDRINUSE
+    OSError will be raised at some point (depending on the platform and
+    the order bind and listen were called on each socket).
+
+    However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE
+    will ever be raised when attempting to bind two identical host/ports. When
+    accept() is called on each socket, the second caller's process will steal
+    the port from the first caller, leaving them both in an awkwardly wedged
+    state where they'll no longer respond to any signals or graceful kills, and
+    must be forcibly killed via OpenProcess()/TerminateProcess().
+
+    The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option
+    instead of SO_REUSEADDR, which effectively affords the same semantics as
+    SO_REUSEADDR on Unix.  Given the propensity of Unix developers in the Open
+    Source world compared to Windows ones, this is a common mistake.  A quick
+    look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when
+    openssl.exe is called with the 's_server' option, for example. See
+    http://bugs.python.org/issue2550 for more info.  The following site also
+    has a very thorough description about the implications of both REUSEADDR
+    and EXCLUSIVEADDRUSE on Windows:
+    http://msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx)
+
+    XXX: although this approach is a vast improvement on previous attempts to
+    elicit unused ports, it rests heavily on the assumption that the ephemeral
+    port returned to us by the OS won't immediately be dished back out to some
+    other process when we close and delete our temporary socket but before our
+    calling code has a chance to bind the returned port.  We can deal with this
+    issue if/when we come across it.
+    """
+
+    tempsock = socket.socket(family, socktype)
+    port = bind_port(tempsock)
+    tempsock.close()
+    del tempsock
+    return port
+
+def bind_port(sock, host=HOST):
+    """Bind the socket to a free port and return the port number.  Relies on
+    ephemeral ports in order to ensure we are using an unbound port.  This is
+    important as many tests may be running simultaneously, especially in a
+    buildbot environment.  This method raises an exception if the sock.family
+    is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
+    or SO_REUSEPORT set on it.  Tests should *never* set these socket options
+    for TCP/IP sockets.  The only case for setting these options is testing
+    multicasting via multiple UDP sockets.
+
+    Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
+    on Windows), it will be set on the socket.  This will prevent anyone else
+    from bind()'ing to our host/port for the duration of the test.
+    """
+
+    if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
+        if hasattr(socket, 'SO_REUSEADDR'):
+            if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
+                raise TestFailed("tests should never set the SO_REUSEADDR "   \
+                                 "socket option on TCP/IP sockets!")
+        if hasattr(socket, 'SO_REUSEPORT'):
+            if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
+                raise TestFailed("tests should never set the SO_REUSEPORT "   \
+                                 "socket option on TCP/IP sockets!")
+        if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+
+    sock.bind((host, 0))
+    port = sock.getsockname()[1]
+    return port
+
+def _is_ipv6_enabled():
+    """Check whether IPv6 is enabled on this host."""
+    if socket.has_ipv6:
+        sock = None
+        try:
+            sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+            sock.bind(('::1', 0))
+            return True
+        except OSError:
+            pass
+        finally:
+            if sock:
+                sock.close()
+    return False
+
+IPV6_ENABLED = _is_ipv6_enabled()
+
+
+# A constant likely larger than the underlying OS pipe buffer size, to
+# make writes blocking.
+# Windows limit seems to be around 512 B, and many Unix kernels have a
+# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.
+# (see issue #17835 for a discussion of this number).
+PIPE_MAX_SIZE = 4 *1024 * 1024 + 1
+
+
+# decorator for skipping tests on non-IEEE 754 platforms
+requires_IEEE_754 = unittest.skipUnless(
+    float.__getformat__("double").startswith("IEEE"),
+    "test requires IEEE 754 doubles")
+
+requires_zlib = unittest.skipUnless(zlib, 'requires zlib')
+
+requires_gzip = unittest.skipUnless(gzip, 'requires gzip')
+
+requires_bz2 = unittest.skipUnless(bz2, 'requires bz2')
+
+requires_lzma = unittest.skipUnless(lzma, 'requires lzma')
+
+is_jython = sys.platform.startswith('java')
+
+# Filename used for testing
+if os.name == 'java':
+    # Jython disallows @ in module names
+    TESTFN = '$test'
+else:
+    TESTFN = '@test'
+
+# Disambiguate TESTFN for parallel testing, while letting it remain a valid
+# module name.
+TESTFN = "{}_{}_tmp".format(TESTFN, os.getpid())
+
+# FS_NONASCII: non-ASCII character encodable by os.fsencode(),
+# or None if there is no such character.
+FS_NONASCII = None
+for character in (
+    # First try printable and common characters to have a readable filename.
+    # For each character, the encoding list are just example of encodings able
+    # to encode the character (the list is not exhaustive).
+
+    # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1
+    '\u00E6',
+    # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3
+    '\u0130',
+    # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257
+    '\u0141',
+    # U+03C6 (Greek Small Letter Phi): cp1253
+    '\u03C6',
+    # U+041A (Cyrillic Capital Letter Ka): cp1251
+    '\u041A',
+    # U+05D0 (Hebrew Letter Alef): Encodable to cp424
+    '\u05D0',
+    # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic
+    '\u060C',
+    # U+062A (Arabic Letter Teh): cp720
+    '\u062A',
+    # U+0E01 (Thai Character Ko Kai): cp874
+    '\u0E01',
+
+    # Then try more "special" characters. "special" because they may be
+    # interpreted or displayed differently depending on the exact locale
+    # encoding and the font.
+
+    # U+00A0 (No-Break Space)
+    '\u00A0',
+    # U+20AC (Euro Sign)
+    '\u20AC',
+):
+    try:
+        os.fsdecode(os.fsencode(character))
+    except UnicodeError:
+        pass
+    else:
+        FS_NONASCII = character
+        break
+
+# TESTFN_UNICODE is a non-ascii filename
+TESTFN_UNICODE = TESTFN + "-\xe0\xf2\u0258\u0141\u011f"
+if sys.platform == 'darwin':
+    # In Mac OS X's VFS API file names are, by definition, canonically
+    # decomposed Unicode, encoded using UTF-8. See QA1173:
+    # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
+    import unicodedata
+    TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE)
+TESTFN_ENCODING = sys.getfilesystemencoding()
+
+# TESTFN_UNENCODABLE is a filename (str type) that should *not* be able to be
+# encoded by the filesystem encoding (in strict mode). It can be None if we
+# cannot generate such filename.
+TESTFN_UNENCODABLE = None
+if os.name in ('nt', 'ce'):
+    # skip win32s (0) or Windows 9x/ME (1)
+    if sys.getwindowsversion().platform >= 2:
+        # Different kinds of characters from various languages to minimize the
+        # probability that the whole name is encodable to MBCS (issue #9819)
+        TESTFN_UNENCODABLE = TESTFN + "-\u5171\u0141\u2661\u0363\uDC80"
+        try:
+            TESTFN_UNENCODABLE.encode(TESTFN_ENCODING)
+        except UnicodeEncodeError:
+            pass
+        else:
+            print('WARNING: The filename %r CAN be encoded by the filesystem encoding (%s). '
+                  'Unicode filename tests may not be effective'
+                  % (TESTFN_UNENCODABLE, TESTFN_ENCODING))
+            TESTFN_UNENCODABLE = None
+# Mac OS X denies unencodable filenames (invalid utf-8)
+elif sys.platform != 'darwin':
+    try:
+        # ascii and utf-8 cannot encode the byte 0xff
+        b'\xff'.decode(TESTFN_ENCODING)
+    except UnicodeDecodeError:
+        # 0xff will be encoded using the surrogate character u+DCFF
+        TESTFN_UNENCODABLE = TESTFN \
+            + b'-\xff'.decode(TESTFN_ENCODING, 'surrogateescape')
+    else:
+        # File system encoding (eg. ISO-8859-* encodings) can encode
+        # the byte 0xff. Skip some unicode filename tests.
+        pass
+
+# TESTFN_UNDECODABLE is a filename (bytes type) that should *not* be able to be
+# decoded from the filesystem encoding (in strict mode). It can be None if we
+# cannot generate such filename (ex: the latin1 encoding can decode any byte
+# sequence). On UNIX, TESTFN_UNDECODABLE can be decoded by os.fsdecode() thanks
+# to the surrogateescape error handler (PEP 383), but not from the filesystem
+# encoding in strict mode.
+TESTFN_UNDECODABLE = None
+for name in (
+    # b'\xff' is not decodable by os.fsdecode() with code page 932. Windows
+    # accepts it to create a file or a directory, or don't accept to enter to
+    # such directory (when the bytes name is used). So test b'\xe7' first: it is
+    # not decodable from cp932.
+    b'\xe7w\xf0',
+    # undecodable from ASCII, UTF-8
+    b'\xff',
+    # undecodable from iso8859-3, iso8859-6, iso8859-7, cp424, iso8859-8, cp856
+    # and cp857
+    b'\xae\xd5'
+    # undecodable from UTF-8 (UNIX and Mac OS X)
+    b'\xed\xb2\x80', b'\xed\xb4\x80',
+    # undecodable from shift_jis, cp869, cp874, cp932, cp1250, cp1251, cp1252,
+    # cp1253, cp1254, cp1255, cp1257, cp1258
+    b'\x81\x98',
+):
+    try:
+        name.decode(TESTFN_ENCODING)
+    except UnicodeDecodeError:
+        TESTFN_UNDECODABLE = os.fsencode(TESTFN) + name
+        break
+
+if FS_NONASCII:
+    TESTFN_NONASCII = TESTFN + '-' + FS_NONASCII
+else:
+    TESTFN_NONASCII = None
+
+# Save the initial cwd
+SAVEDCWD = os.getcwd()
+
+@contextlib.contextmanager
+def temp_cwd(name='tempcwd', quiet=False, path=None):
+    """
+    Context manager that temporarily changes the CWD.
+
+    An existing path may be provided as *path*, in which case this
+    function makes no changes to the file system.
+
+    Otherwise, the new CWD is created in the current directory and it's
+    named *name*. If *quiet* is False (default) and it's not possible to
+    create or change the CWD, an error is raised.  If it's True, only a
+    warning is raised and the original CWD is used.
+    """
+    saved_dir = os.getcwd()
+    is_temporary = False
+    if path is None:
+        path = name
+        try:
+            os.mkdir(name)
+            is_temporary = True
+        except OSError:
+            if not quiet:
+                raise
+            warnings.warn('tests may fail, unable to create temp CWD ' + name,
+                          RuntimeWarning, stacklevel=3)
+    try:
+        os.chdir(path)
+    except OSError:
+        if not quiet:
+            raise
+        warnings.warn('tests may fail, unable to change the CWD to ' + path,
+                      RuntimeWarning, stacklevel=3)
+    try:
+        yield os.getcwd()
+    finally:
+        os.chdir(saved_dir)
+        if is_temporary:
+            rmtree(name)
+
+
+if hasattr(os, "umask"):
+    @contextlib.contextmanager
+    def temp_umask(umask):
+        """Context manager that temporarily sets the process umask."""
+        oldmask = os.umask(umask)
+        try:
+            yield
+        finally:
+            os.umask(oldmask)
+
+
+def findfile(file, here=__file__, subdir=None):
+    """Try to find a file on sys.path and the working directory.  If it is not
+    found the argument passed to the function is returned (this does not
+    necessarily signal failure; could still be the legitimate path)."""
+    if os.path.isabs(file):
+        return file
+    if subdir is not None:
+        file = os.path.join(subdir, file)
+    path = sys.path
+    path = [os.path.dirname(here)] + path
+    for dn in path:
+        fn = os.path.join(dn, file)
+        if os.path.exists(fn): return fn
+    return file
+
+def create_empty_file(filename):
+    """Create an empty file. If the file already exists, truncate it."""
+    fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
+    os.close(fd)
+
+def sortdict(dict):
+    "Like repr(dict), but in sorted order."
+    items = sorted(dict.items())
+    reprpairs = ["%r: %r" % pair for pair in items]
+    withcommas = ", ".join(reprpairs)
+    return "{%s}" % withcommas
+
+def make_bad_fd():
+    """
+    Create an invalid file descriptor by opening and closing a file and return
+    its fd.
+    """
+    file = open(TESTFN, "wb")
+    try:
+        return file.fileno()
+    finally:
+        file.close()
+        unlink(TESTFN)
+
+def check_syntax_error(testcase, statement):
+    testcase.assertRaises(SyntaxError, compile, statement,
+                          '<test string>', 'exec')
+
+def open_urlresource(url, *args, **kw):
+    import urllib.request, urllib.parse
+
+    check = kw.pop('check', None)
+
+    filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
+
+    fn = os.path.join(os.path.dirname(__file__), "data", filename)
+
+    def check_valid_file(fn):
+        f = open(fn, *args, **kw)
+        if check is None:
+            return f
+        elif check(f):
+            f.seek(0)
+            return f
+        f.close()
+
+    if os.path.exists(fn):
+        f = check_valid_file(fn)
+        if f is not None:
+            return f
+        unlink(fn)
+
+    # Verify the requirement before downloading the file
+    requires('urlfetch')
+
+    print('\tfetching %s ...' % url, file=get_original_stdout())
+    f = urllib.request.urlopen(url, timeout=15)
+    try:
+        with open(fn, "wb") as out:
+            s = f.read()
+            while s:
+                out.write(s)
+                s = f.read()
+    finally:
+        f.close()
+
+    f = check_valid_file(fn)
+    if f is not None:
+        return f
+    raise TestFailed('invalid resource %r' % fn)
+
+
+class WarningsRecorder(object):
+    """Convenience wrapper for the warnings list returned on
+       entry to the warnings.catch_warnings() context manager.
+    """
+    def __init__(self, warnings_list):
+        self._warnings = warnings_list
+        self._last = 0
+
+    def __getattr__(self, attr):
+        if len(self._warnings) > self._last:
+            return getattr(self._warnings[-1], attr)
+        elif attr in warnings.WarningMessage._WARNING_DETAILS:
+            return None
+        raise AttributeError("%r has no attribute %r" % (self, attr))
+
+    @property
+    def warnings(self):
+        return self._warnings[self._last:]
+
+    def reset(self):
+        self._last = len(self._warnings)
+
+
+def _filterwarnings(filters, quiet=False):
+    """Catch the warnings, then check if all the expected
+    warnings have been raised and re-raise unexpected warnings.
+    If 'quiet' is True, only re-raise the unexpected warnings.
+    """
+    # Clear the warning registry of the calling module
+    # in order to re-raise the warnings.
+    frame = sys._getframe(2)
+    registry = frame.f_globals.get('__warningregistry__')
+    if registry:
+        registry.clear()
+    with warnings.catch_warnings(record=True) as w:
+        # Set filter "always" to record all warnings.  Because
+        # test_warnings swap the module, we need to look up in
+        # the sys.modules dictionary.
+        sys.modules['warnings'].simplefilter("always")
+        yield WarningsRecorder(w)
+    # Filter the recorded warnings
+    reraise = list(w)
+    missing = []
+    for msg, cat in filters:
+        seen = False
+        for w in reraise[:]:
+            warning = w.message
+            # Filter out the matching messages
+            if (re.match(msg, str(warning), re.I) and
+                issubclass(warning.__class__, cat)):
+                seen = True
+                reraise.remove(w)
+        if not seen and not quiet:
+            # This filter caught nothing
+            missing.append((msg, cat.__name__))
+    if reraise:
+        raise AssertionError("unhandled warning %s" % reraise[0])
+    if missing:
+        raise AssertionError("filter (%r, %s) did not catch any warning" %
+                             missing[0])
+
+
+@contextlib.contextmanager
+def check_warnings(*filters, **kwargs):
+    """Context manager to silence warnings.
+
+    Accept 2-tuples as positional arguments:
+        ("message regexp", WarningCategory)
+
+    Optional argument:
+     - if 'quiet' is True, it does not fail if a filter catches nothing
+        (default True without argument,
+         default False if some filters are defined)
+
+    Without argument, it defaults to:
+        check_warnings(("", Warning), quiet=True)
+    """
+    quiet = kwargs.get('quiet')
+    if not filters:
+        filters = (("", Warning),)
+        # Preserve backward compatibility
+        if quiet is None:
+            quiet = True
+    return _filterwarnings(filters, quiet)
+
+
+class CleanImport(object):
+    """Context manager to force import to return a new module reference.
+
+    This is useful for testing module-level behaviours, such as
+    the emission of a DeprecationWarning on import.
+
+    Use like this:
+
+        with CleanImport("foo"):
+            importlib.import_module("foo") # new reference
+    """
+
+    def __init__(self, *module_names):
+        self.original_modules = sys.modules.copy()
+        for module_name in module_names:
+            if module_name in sys.modules:
+                module = sys.modules[module_name]
+                # It is possible that module_name is just an alias for
+                # another module (e.g. stub for modules renamed in 3.x).
+                # In that case, we also need delete the real module to clear
+                # the import cache.
+                if module.__name__ != module_name:
+                    del sys.modules[module.__name__]
+                del sys.modules[module_name]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        sys.modules.update(self.original_modules)
+
+
+class EnvironmentVarGuard(collections.abc.MutableMapping):
+
+    """Class to help protect the environment variable properly.  Can be used as
+    a context manager."""
+
+    def __init__(self):
+        self._environ = os.environ
+        self._changed = {}
+
+    def __getitem__(self, envvar):
+        return self._environ[envvar]
+
+    def __setitem__(self, envvar, value):
+        # Remember the initial value on the first access
+        if envvar not in self._changed:
+            self._changed[envvar] = self._environ.get(envvar)
+        self._environ[envvar] = value
+
+    def __delitem__(self, envvar):
+        # Remember the initial value on the first access
+        if envvar not in self._changed:
+            self._changed[envvar] = self._environ.get(envvar)
+        if envvar in self._environ:
+            del self._environ[envvar]
+
+    def keys(self):
+        return self._environ.keys()
+
+    def __iter__(self):
+        return iter(self._environ)
+
+    def __len__(self):
+        return len(self._environ)
+
+    def set(self, envvar, value):
+        self[envvar] = value
+
+    def unset(self, envvar):
+        del self[envvar]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        for (k, v) in self._changed.items():
+            if v is None:
+                if k in self._environ:
+                    del self._environ[k]
+            else:
+                self._environ[k] = v
+        os.environ = self._environ
+
+
+class DirsOnSysPath(object):
+    """Context manager to temporarily add directories to sys.path.
+
+    This makes a copy of sys.path, appends any directories given
+    as positional arguments, then reverts sys.path to the copied
+    settings when the context ends.
+
+    Note that *all* sys.path modifications in the body of the
+    context manager, including replacement of the object,
+    will be reverted at the end of the block.
+    """
+
+    def __init__(self, *paths):
+        self.original_value = sys.path[:]
+        self.original_object = sys.path
+        sys.path.extend(paths)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        sys.path = self.original_object
+        sys.path[:] = self.original_value
+
+
+class TransientResource(object):
+
+    """Raise ResourceDenied if an exception is raised while the context manager
+    is in effect that matches the specified exception and attributes."""
+
+    def __init__(self, exc, **kwargs):
+        self.exc = exc
+        self.attrs = kwargs
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type_=None, value=None, traceback=None):
+        """If type_ is a subclass of self.exc and value has attributes matching
+        self.attrs, raise ResourceDenied.  Otherwise let the exception
+        propagate (if any)."""
+        if type_ is not None and issubclass(self.exc, type_):
+            for attr, attr_value in self.attrs.items():
+                if not hasattr(value, attr):
+                    break
+                if getattr(value, attr) != attr_value:
+                    break
+            else:
+                raise ResourceDenied("an optional resource is not available")
+
+# Context managers that raise ResourceDenied when various issues
+# with the Internet connection manifest themselves as exceptions.
+# XXX deprecate these and use transient_internet() instead
+time_out = TransientResource(OSError, errno=errno.ETIMEDOUT)
+socket_peer_reset = TransientResource(OSError, errno=errno.ECONNRESET)
+ioerror_peer_reset = TransientResource(OSError, errno=errno.ECONNRESET)
+
+
+@contextlib.contextmanager
+def transient_internet(resource_name, *, timeout=30.0, errnos=()):
+    """Return a context manager that raises ResourceDenied when various issues
+    with the Internet connection manifest themselves as exceptions."""
+    default_errnos = [
+        ('ECONNREFUSED', 111),
+        ('ECONNRESET', 104),
+        ('EHOSTUNREACH', 113),
+        ('ENETUNREACH', 101),
+        ('ETIMEDOUT', 110),
+    ]
+    default_gai_errnos = [
+        ('EAI_AGAIN', -3),
+        ('EAI_FAIL', -4),
+        ('EAI_NONAME', -2),
+        ('EAI_NODATA', -5),
+        # Encountered when trying to resolve IPv6-only hostnames
+        ('WSANO_DATA', 11004),
+    ]
+
+    denied = ResourceDenied("Resource %r is not available" % resource_name)
+    captured_errnos = errnos
+    gai_errnos = []
+    if not captured_errnos:
+        captured_errnos = [getattr(errno, name, num)
+                           for (name, num) in default_errnos]
+        gai_errnos = [getattr(socket, name, num)
+                      for (name, num) in default_gai_errnos]
+
+    def filter_error(err):
+        n = getattr(err, 'errno', None)
+        if (isinstance(err, socket.timeout) or
+            (isinstance(err, socket.gaierror) and n in gai_errnos) or
+            n in captured_errnos):
+            if not verbose:
+                sys.stderr.write(denied.args[0] + "\n")
+            raise denied from err
+
+    old_timeout = socket.getdefaulttimeout()
+    try:
+        if timeout is not None:
+            socket.setdefaulttimeout(timeout)
+        yield
+    except OSError as err:
+        # urllib can wrap original socket errors multiple times (!), we must
+        # unwrap to get at the original error.
+        while True:
+            a = err.args
+            if len(a) >= 1 and isinstance(a[0], OSError):
+                err = a[0]
+            # The error can also be wrapped as args[1]:
+            #    except socket.error as msg:
+            #        raise OSError('socket error', msg).with_traceback(sys.exc_info()[2])
+            elif len(a) >= 2 and isinstance(a[1], OSError):
+                err = a[1]
+            else:
+                break
+        filter_error(err)
+        raise
+    # XXX should we catch generic exceptions and look for their
+    # __cause__ or __context__?
+    finally:
+        socket.setdefaulttimeout(old_timeout)
+
+
+@contextlib.contextmanager
+def captured_output(stream_name):
+    """Return a context manager used by captured_stdout/stdin/stderr
+    that temporarily replaces the sys stream *stream_name* with a StringIO."""
+    import io
+    orig_stdout = getattr(sys, stream_name)
+    setattr(sys, stream_name, io.StringIO())
+    try:
+        yield getattr(sys, stream_name)
+    finally:
+        setattr(sys, stream_name, orig_stdout)
+
+def captured_stdout():
+    """Capture the output of sys.stdout:
+
+       with captured_stdout() as stdout:
+           print("hello")
+       self.assertEqual(stdout.getvalue(), "hello\n")
+    """
+    return captured_output("stdout")
+
+def captured_stderr():
+    """Capture the output of sys.stderr:
+
+       with captured_stderr() as stderr:
+           print("hello", file=sys.stderr)
+       self.assertEqual(stderr.getvalue(), "hello\n")
+    """
+    return captured_output("stderr")
+
+def captured_stdin():
+    """Capture the input to sys.stdin:
+
+       with captured_stdin() as stdin:
+           stdin.write('hello\n')
+           stdin.seek(0)
+           # call test code that consumes from sys.stdin
+           captured = input()
+       self.assertEqual(captured, "hello")
+    """
+    return captured_output("stdin")
+
+
+def gc_collect():
+    """Force as many objects as possible to be collected.
+
+    In non-CPython implementations of Python, this is needed because timely
+    deallocation is not guaranteed by the garbage collector.  (Even in CPython
+    this can be the case in case of reference cycles.)  This means that __del__
+    methods may be called later than expected and weakrefs may remain alive for
+    longer than expected.  This function tries its best to force all garbage
+    objects to disappear.
+    """
+    gc.collect()
+    if is_jython:
+        time.sleep(0.1)
+    gc.collect()
+    gc.collect()
+
+@contextlib.contextmanager
+def disable_gc():
+    have_gc = gc.isenabled()
+    gc.disable()
+    try:
+        yield
+    finally:
+        if have_gc:
+            gc.enable()
+
+
+def python_is_optimized():
+    """Find if Python was built with optimizations."""
+    cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
+    final_opt = ""
+    for opt in cflags.split():
+        if opt.startswith('-O'):
+            final_opt = opt
+    return final_opt != '' and final_opt != '-O0'
+
+
+_header = 'nP'
+_align = '0n'
+if hasattr(sys, "gettotalrefcount"):
+    _header = '2P' + _header
+    _align = '0P'
+_vheader = _header + 'n'
+
+def calcobjsize(fmt):
+    return struct.calcsize(_header + fmt + _align)
+
+def calcvobjsize(fmt):
+    return struct.calcsize(_vheader + fmt + _align)
+
+
+_TPFLAGS_HAVE_GC = 1<<14
+_TPFLAGS_HEAPTYPE = 1<<9
+
+def check_sizeof(test, o, size):
+    result = sys.getsizeof(o)
+    # add GC header size
+    if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\
+        ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):
+        size += _testcapi.SIZEOF_PYGC_HEAD
+    msg = 'wrong size for %s: got %d, expected %d' \
+            % (type(o), result, size)
+    test.assertEqual(result, size, msg)
+
+#=======================================================================
+# Decorator for running a function in a different locale, correctly resetting
+# it afterwards.
+
+def run_with_locale(catstr, *locales):
+    def decorator(func):
+        def inner(*args, **kwds):
+            try:
+                import locale
+                category = getattr(locale, catstr)
+                orig_locale = locale.setlocale(category)
+            except AttributeError:
+                # if the test author gives us an invalid category string
+                raise
+            except:
+                # cannot retrieve original locale, so do nothing
+                locale = orig_locale = None
+            else:
+                for loc in locales:
+                    try:
+                        locale.setlocale(category, loc)
+                        break
+                    except:
+                        pass
+
+            # now run the function, resetting the locale on exceptions
+            try:
+                return func(*args, **kwds)
+            finally:
+                if locale and orig_locale:
+                    locale.setlocale(category, orig_locale)
+        inner.__name__ = func.__name__
+        inner.__doc__ = func.__doc__
+        return inner
+    return decorator
+
+#=======================================================================
+# Decorator for running a function in a specific timezone, correctly
+# resetting it afterwards.
+
+def run_with_tz(tz):
+    def decorator(func):
+        def inner(*args, **kwds):
+            try:
+                tzset = time.tzset
+            except AttributeError:
+                raise unittest.SkipTest("tzset required")
+            if 'TZ' in os.environ:
+                orig_tz = os.environ['TZ']
+            else:
+                orig_tz = None
+            os.environ['TZ'] = tz
+            tzset()
+
+            # now run the function, resetting the tz on exceptions
+            try:
+                return func(*args, **kwds)
+            finally:
+                if orig_tz is None:
+                    del os.environ['TZ']
+                else:
+                    os.environ['TZ'] = orig_tz
+                time.tzset()
+
+        inner.__name__ = func.__name__
+        inner.__doc__ = func.__doc__
+        return inner
+    return decorator
+
+#=======================================================================
+# Big-memory-test support. Separate from 'resources' because memory use
+# should be configurable.
+
+# Some handy shorthands. Note that these are used for byte-limits as well
+# as size-limits, in the various bigmem tests
+_1M = 1024*1024
+_1G = 1024 * _1M
+_2G = 2 * _1G
+_4G = 4 * _1G
+
+MAX_Py_ssize_t = sys.maxsize
+
+def set_memlimit(limit):
+    global max_memuse
+    global real_max_memuse
+    sizes = {
+        'k': 1024,
+        'm': _1M,
+        'g': _1G,
+        't': 1024*_1G,
+    }
+    m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
+                 re.IGNORECASE | re.VERBOSE)
+    if m is None:
+        raise ValueError('Invalid memory limit %r' % (limit,))
+    memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
+    real_max_memuse = memlimit
+    if memlimit > MAX_Py_ssize_t:
+        memlimit = MAX_Py_ssize_t
+    if memlimit < _2G - 1:
+        raise ValueError('Memory limit %r too low to be useful' % (limit,))
+    max_memuse = memlimit
+
+class _MemoryWatchdog:
+    """An object which periodically watches the process' memory consumption
+    and prints it out.
+    """
+
+    def __init__(self):
+        self.procfile = '/proc/{pid}/statm'.format(pid=os.getpid())
+        self.started = False
+
+    def start(self):
+        try:
+            f = open(self.procfile, 'r')
+        except OSError as e:
+            warnings.warn('/proc not available for stats: {}'.format(e),
+                          RuntimeWarning)
+            sys.stderr.flush()
+            return
+
+        watchdog_script = findfile("memory_watchdog.py")
+        self.mem_watchdog = subprocess.Popen([sys.executable, watchdog_script],
+                                             stdin=f, stderr=subprocess.DEVNULL)
+        f.close()
+        self.started = True
+
+    def stop(self):
+        if self.started:
+            self.mem_watchdog.terminate()
+            self.mem_watchdog.wait()
+
+
+def bigmemtest(size, memuse, dry_run=True):
+    """Decorator for bigmem tests.
+
+    'minsize' is the minimum useful size for the test (in arbitrary,
+    test-interpreted units.) 'memuse' is the number of 'bytes per size' for
+    the test, or a good estimate of it.
+
+    if 'dry_run' is False, it means the test doesn't support dummy runs
+    when -M is not specified.
+    """
+    def decorator(f):
+        def wrapper(self):
+            size = wrapper.size
+            memuse = wrapper.memuse
+            if not real_max_memuse:
+                maxsize = 5147
+            else:
+                maxsize = size
+
+            if ((real_max_memuse or not dry_run)
+                and real_max_memuse < maxsize * memuse):
+                raise unittest.SkipTest(
+                    "not enough memory: %.1fG minimum needed"
+                    % (size * memuse / (1024 ** 3)))
+
+            if real_max_memuse and verbose:
+                print()
+                print(" ... expected peak memory use: {peak:.1f}G"
+                      .format(peak=size * memuse / (1024 ** 3)))
+                watchdog = _MemoryWatchdog()
+                watchdog.start()
+            else:
+                watchdog = None
+
+            try:
+                return f(self, maxsize)
+            finally:
+                if watchdog:
+                    watchdog.stop()
+
+        wrapper.size = size
+        wrapper.memuse = memuse
+        return wrapper
+    return decorator
+
+def bigaddrspacetest(f):
+    """Decorator for tests that fill the address space."""
+    def wrapper(self):
+        if max_memuse < MAX_Py_ssize_t:
+            if MAX_Py_ssize_t >= 2**63 - 1 and max_memuse >= 2**31:
+                raise unittest.SkipTest(
+                    "not enough memory: try a 32-bit build instead")
+            else:
+                raise unittest.SkipTest(
+                    "not enough memory: %.1fG minimum needed"
+                    % (MAX_Py_ssize_t / (1024 ** 3)))
+        else:
+            return f(self)
+    return wrapper
+
+#=======================================================================
+# unittest integration.
+
+class BasicTestRunner:
+    def run(self, test):
+        result = unittest.TestResult()
+        test(result)
+        return result
+
+def _id(obj):
+    return obj
+
+def requires_resource(resource):
+    if resource == 'gui' and not _is_gui_available():
+        return unittest.skip("resource 'gui' is not available")
+    if is_resource_enabled(resource):
+        return _id
+    else:
+        return unittest.skip("resource {0!r} is not enabled".format(resource))
+
+def cpython_only(test):
+    """
+    Decorator for tests only applicable on CPython.
+    """
+    return impl_detail(cpython=True)(test)
+
+def impl_detail(msg=None, **guards):
+    if check_impl_detail(**guards):
+        return _id
+    if msg is None:
+        guardnames, default = _parse_guards(guards)
+        if default:
+            msg = "implementation detail not available on {0}"
+        else:
+            msg = "implementation detail specific to {0}"
+        guardnames = sorted(guardnames.keys())
+        msg = msg.format(' or '.join(guardnames))
+    return unittest.skip(msg)
+
+def _parse_guards(guards):
+    # Returns a tuple ({platform_name: run_me}, default_value)
+    if not guards:
+        return ({'cpython': True}, False)
+    is_true = list(guards.values())[0]
+    assert list(guards.values()) == [is_true] * len(guards)   # all True or all False
+    return (guards, not is_true)
+
+# Use the following check to guard CPython's implementation-specific tests --
+# or to run them only on the implementation(s) guarded by the arguments.
+def check_impl_detail(**guards):
+    """This function returns True or False depending on the host platform.
+       Examples:
+          if check_impl_detail():               # only on CPython (default)
+          if check_impl_detail(jython=True):    # only on Jython
+          if check_impl_detail(cpython=False):  # everywhere except on CPython
+    """
+    guards, default = _parse_guards(guards)
+    return guards.get(platform.python_implementation().lower(), default)
+
+
+def no_tracing(func):
+    """Decorator to temporarily turn off tracing for the duration of a test."""
+    if not hasattr(sys, 'gettrace'):
+        return func
+    else:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            original_trace = sys.gettrace()
+            try:
+                sys.settrace(None)
+                return func(*args, **kwargs)
+            finally:
+                sys.settrace(original_trace)
+        return wrapper
+
+
+def refcount_test(test):
+    """Decorator for tests which involve reference counting.
+
+    To start, the decorator does not run the test if is not run by CPython.
+    After that, any trace function is unset during the test to prevent
+    unexpected refcounts caused by the trace function.
+
+    """
+    return no_tracing(cpython_only(test))
+
+
+def _filter_suite(suite, pred):
+    """Recursively filter test cases in a suite based on a predicate."""
+    newtests = []
+    for test in suite._tests:
+        if isinstance(test, unittest.TestSuite):
+            _filter_suite(test, pred)
+            newtests.append(test)
+        else:
+            if pred(test):
+                newtests.append(test)
+    suite._tests = newtests
+
+def _run_suite(suite):
+    """Run tests from a unittest.TestSuite-derived class."""
+    if verbose:
+        runner = unittest.TextTestRunner(sys.stdout, verbosity=2,
+                                         failfast=failfast)
+    else:
+        runner = BasicTestRunner()
+
+    result = runner.run(suite)
+    if not result.wasSuccessful():
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            err = "multiple errors occurred"
+            if not verbose: err += "; run in verbose mode for details"
+        raise TestFailed(err)
+
+
+def run_unittest(*classes):
+    """Run tests from unittest.TestCase-derived classes."""
+    valid_types = (unittest.TestSuite, unittest.TestCase)
+    suite = unittest.TestSuite()
+    for cls in classes:
+        if isinstance(cls, str):
+            if cls in sys.modules:
+                suite.addTest(unittest.findTestCases(sys.modules[cls]))
+            else:
+                raise ValueError("str arguments must be keys in sys.modules")
+        elif isinstance(cls, valid_types):
+            suite.addTest(cls)
+        else:
+            suite.addTest(unittest.makeSuite(cls))
+    def case_pred(test):
+        if match_tests is None:
+            return True
+        for name in test.id().split("."):
+            if fnmatch.fnmatchcase(name, match_tests):
+                return True
+        return False
+    _filter_suite(suite, case_pred)
+    _run_suite(suite)
+
+#=======================================================================
+# Check for the presence of docstrings.
+
+HAVE_DOCSTRINGS = (check_impl_detail(cpython=False) or
+                   sys.platform == 'win32' or
+                   sysconfig.get_config_var('WITH_DOC_STRINGS'))
+
+requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
+                                          "test requires docstrings")
+
+
+#=======================================================================
+# doctest driver.
+
+def run_doctest(module, verbosity=None, optionflags=0):
+    """Run doctest on the given module.  Return (#failures, #tests).
+
+    If optional argument verbosity is not specified (or is None), pass
+    support's belief about verbosity on to doctest.  Else doctest's
+    usual behavior is used (it searches sys.argv for -v).
+    """
+
+    import doctest
+
+    if verbosity is None:
+        verbosity = verbose
+    else:
+        verbosity = None
+
+    f, t = doctest.testmod(module, verbose=verbosity, optionflags=optionflags)
+    if f:
+        raise TestFailed("%d of %d doctests failed" % (f, t))
+    if verbose:
+        print('doctest (%s) ... %d tests with zero failures' %
+              (module.__name__, t))
+    return f, t
+
+
+#=======================================================================
+# Support for saving and restoring the imported modules.
+
+def modules_setup():
+    return sys.modules.copy(),
+
+def modules_cleanup(oldmodules):
+    # Encoders/decoders are registered permanently within the internal
+    # codec cache. If we destroy the corresponding modules their
+    # globals will be set to None which will trip up the cached functions.
+    encodings = [(k, v) for k, v in sys.modules.items()
+                 if k.startswith('encodings.')]
+    sys.modules.clear()
+    sys.modules.update(encodings)
+    # XXX: This kind of problem can affect more than just encodings. In particular
+    # extension modules (such as _ssl) don't cope with reloading properly.
+    # Really, test modules should be cleaning out the test specific modules they
+    # know they added (ala test_runpy) rather than relying on this function (as
+    # test_importhooks and test_pkg do currently).
+    # Implicitly imported *real* modules should be left alone (see issue 10556).
+    sys.modules.update(oldmodules)
+
+#=======================================================================
+# Threading support to prevent reporting refleaks when running regrtest.py -R
+
+# NOTE: we use thread._count() rather than threading.enumerate() (or the
+# moral equivalent thereof) because a threading.Thread object is still alive
+# until its __bootstrap() method has returned, even after it has been
+# unregistered from the threading module.
+# thread._count(), on the other hand, only gets decremented *after* the
+# __bootstrap() method has returned, which gives us reliable reference counts
+# at the end of a test run.
+
+def threading_setup():
+    if _thread:
+        return _thread._count(), threading._dangling.copy()
+    else:
+        return 1, ()
+
+def threading_cleanup(*original_values):
+    if not _thread:
+        return
+    _MAX_COUNT = 10
+    for count in range(_MAX_COUNT):
+        values = _thread._count(), threading._dangling
+        if values == original_values:
+            break
+        time.sleep(0.1)
+        gc_collect()
+    # XXX print a warning in case of failure?
+
+def reap_threads(func):
+    """Use this function when threads are being used.  This will
+    ensure that the threads are cleaned up even when the test fails.
+    If threading is unavailable this function does nothing.
+    """
+    if not _thread:
+        return func
+
+    @functools.wraps(func)
+    def decorator(*args):
+        key = threading_setup()
+        try:
+            return func(*args)
+        finally:
+            threading_cleanup(*key)
+    return decorator
+
+def reap_children():
+    """Use this function at the end of test_main() whenever sub-processes
+    are started.  This will help ensure that no extra children (zombies)
+    stick around to hog resources and create problems when looking
+    for refleaks.
+    """
+
+    # Reap all our dead child processes so we don't leave zombies around.
+    # These hog resources and might be causing some of the buildbots to die.
+    if hasattr(os, 'waitpid'):
+        any_process = -1
+        while True:
+            try:
+                # This will raise an exception on Windows.  That's ok.
+                pid, status = os.waitpid(any_process, os.WNOHANG)
+                if pid == 0:
+                    break
+            except:
+                break
+
+@contextlib.contextmanager
+def swap_attr(obj, attr, new_val):
+    """Temporary swap out an attribute with a new object.
+
+    Usage:
+        with swap_attr(obj, "attr", 5):
+            ...
+
+        This will set obj.attr to 5 for the duration of the with: block,
+        restoring the old value at the end of the block. If `attr` doesn't
+        exist on `obj`, it will be created and then deleted at the end of the
+        block.
+    """
+    if hasattr(obj, attr):
+        real_val = getattr(obj, attr)
+        setattr(obj, attr, new_val)
+        try:
+            yield
+        finally:
+            setattr(obj, attr, real_val)
+    else:
+        setattr(obj, attr, new_val)
+        try:
+            yield
+        finally:
+            delattr(obj, attr)
+
+@contextlib.contextmanager
+def swap_item(obj, item, new_val):
+    """Temporary swap out an item with a new object.
+
+    Usage:
+        with swap_item(obj, "item", 5):
+            ...
+
+        This will set obj["item"] to 5 for the duration of the with: block,
+        restoring the old value at the end of the block. If `item` doesn't
+        exist on `obj`, it will be created and then deleted at the end of the
+        block.
+    """
+    if item in obj:
+        real_val = obj[item]
+        obj[item] = new_val
+        try:
+            yield
+        finally:
+            obj[item] = real_val
+    else:
+        obj[item] = new_val
+        try:
+            yield
+        finally:
+            del obj[item]
+
+def strip_python_stderr(stderr):
+    """Strip the stderr of a Python process from potential debug output
+    emitted by the interpreter.
+
+    This will typically be run on the result of the communicate() method
+    of a subprocess.Popen object.
+    """
+    stderr = re.sub(br"\[\d+ refs, \d+ blocks\]\r?\n?", b"", stderr).strip()
+    return stderr
+
+def args_from_interpreter_flags():
+    """Return a list of command-line arguments reproducing the current
+    settings in sys.flags and sys.warnoptions."""
+    return subprocess._args_from_interpreter_flags()
+
+#============================================================
+# Support for assertions about logging.
+#============================================================
+
+class TestHandler(logging.handlers.BufferingHandler):
+    def __init__(self, matcher):
+        # BufferingHandler takes a "capacity" argument
+        # so as to know when to flush. As we're overriding
+        # shouldFlush anyway, we can set a capacity of zero.
+        # You can call flush() manually to clear out the
+        # buffer.
+        logging.handlers.BufferingHandler.__init__(self, 0)
+        self.matcher = matcher
+
+    def shouldFlush(self):
+        return False
+
+    def emit(self, record):
+        self.format(record)
+        self.buffer.append(record.__dict__)
+
+    def matches(self, **kwargs):
+        """
+        Look for a saved dict whose keys/values match the supplied arguments.
+        """
+        result = False
+        for d in self.buffer:
+            if self.matcher.matches(d, **kwargs):
+                result = True
+                break
+        return result
+
+class Matcher(object):
+
+    _partial_matches = ('msg', 'message')
+
+    def matches(self, d, **kwargs):
+        """
+        Try to match a single dict with the supplied arguments.
+
+        Keys whose values are strings and which are in self._partial_matches
+        will be checked for partial (i.e. substring) matches. You can extend
+        this scheme to (for example) do regular expression matching, etc.
+        """
+        result = True
+        for k in kwargs:
+            v = kwargs[k]
+            dv = d.get(k)
+            if not self.match_value(k, dv, v):
+                result = False
+                break
+        return result
+
+    def match_value(self, k, dv, v):
+        """
+        Try to match a single stored value (dv) with a supplied value (v).
+        """
+        if type(v) != type(dv):
+            result = False
+        elif type(dv) is not str or k not in self._partial_matches:
+            result = (v == dv)
+        else:
+            result = dv.find(v) >= 0
+        return result
+
+
+_can_symlink = None
+def can_symlink():
+    global _can_symlink
+    if _can_symlink is not None:
+        return _can_symlink
+    symlink_path = TESTFN + "can_symlink"
+    try:
+        os.symlink(TESTFN, symlink_path)
+        can = True
+    except (OSError, NotImplementedError, AttributeError):
+        can = False
+    else:
+        os.remove(symlink_path)
+    _can_symlink = can
+    return can
+
+def skip_unless_symlink(test):
+    """Skip decorator for tests that require functional symlink"""
+    ok = can_symlink()
+    msg = "Requires functional symlink implementation"
+    return test if ok else unittest.skip(msg)(test)
+
+_can_xattr = None
+def can_xattr():
+    global _can_xattr
+    if _can_xattr is not None:
+        return _can_xattr
+    if not hasattr(os, "setxattr"):
+        can = False
+    else:
+        tmp_fp, tmp_name = tempfile.mkstemp()
+        try:
+            with open(TESTFN, "wb") as fp:
+                try:
+                    # TESTFN & tempfile may use different file systems with
+                    # different capabilities
+                    os.setxattr(tmp_fp, b"user.test", b"")
+                    os.setxattr(fp.fileno(), b"user.test", b"")
+                    # Kernels < 2.6.39 don't respect setxattr flags.
+                    kernel_version = platform.release()
+                    m = re.match("2.6.(\d{1,2})", kernel_version)
+                    can = m is None or int(m.group(1)) >= 39
+                except OSError:
+                    can = False
+        finally:
+            unlink(TESTFN)
+            unlink(tmp_name)
+    _can_xattr = can
+    return can
+
+def skip_unless_xattr(test):
+    """Skip decorator for tests that require functional extended attributes"""
+    ok = can_xattr()
+    msg = "no non-broken extended attribute support"
+    return test if ok else unittest.skip(msg)(test)
+
+
+if sys.platform.startswith('win'):
+    @contextlib.contextmanager
+    def suppress_crash_popup():
+        """Disable Windows Error Reporting dialogs using SetErrorMode."""
+        # see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621%28v=vs.85%29.aspx
+        # GetErrorMode is not available on Windows XP and Windows Server 2003,
+        # but SetErrorMode returns the previous value, so we can use that
+        import ctypes
+        k32 = ctypes.windll.kernel32
+        SEM_NOGPFAULTERRORBOX = 0x02
+        old_error_mode = k32.SetErrorMode(SEM_NOGPFAULTERRORBOX)
+        k32.SetErrorMode(old_error_mode | SEM_NOGPFAULTERRORBOX)
+        try:
+            yield
+        finally:
+            k32.SetErrorMode(old_error_mode)
+else:
+    # this is a no-op for other platforms
+    @contextlib.contextmanager
+    def suppress_crash_popup():
+        yield
+
+
+def patch(test_instance, object_to_patch, attr_name, new_value):
+    """Override 'object_to_patch'.'attr_name' with 'new_value'.
+
+    Also, add a cleanup procedure to 'test_instance' to restore
+    'object_to_patch' value for 'attr_name'.
+    The 'attr_name' should be a valid attribute for 'object_to_patch'.
+
+    """
+    # check that 'attr_name' is a real attribute for 'object_to_patch'
+    # will raise AttributeError if it does not exist
+    getattr(object_to_patch, attr_name)
+
+    # keep a copy of the old value
+    attr_is_local = False
+    try:
+        old_value = object_to_patch.__dict__[attr_name]
+    except (AttributeError, KeyError):
+        old_value = getattr(object_to_patch, attr_name, None)
+    else:
+        attr_is_local = True
+
+    # restore the value when the test is done
+    def cleanup():
+        if attr_is_local:
+            setattr(object_to_patch, attr_name, old_value)
+        else:
+            delattr(object_to_patch, attr_name)
+
+    test_instance.addCleanup(cleanup)
+
+    # actually override the attribute
+    setattr(object_to_patch, attr_name, new_value)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/support/__init__.py
--- a/Lib/test/support/__init__.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2045 +0,0 @@
-"""Supporting definitions for the Python regression tests."""
-
-if __name__ != 'test.support':
-    raise ImportError('support must be imported from the test package')
-
-import contextlib
-import errno
-import functools
-import gc
-import socket
-import sys
-import os
-import platform
-import shutil
-import warnings
-import unittest
-import importlib
-import importlib.util
-import collections.abc
-import re
-import subprocess
-import time
-import sysconfig
-import fnmatch
-import logging.handlers
-import struct
-import tempfile
-import _testcapi
-
-try:
-    import _thread, threading
-except ImportError:
-    _thread = None
-    threading = None
-try:
-    import multiprocessing.process
-except ImportError:
-    multiprocessing = None
-
-try:
-    import zlib
-except ImportError:
-    zlib = None
-
-try:
-    import gzip
-except ImportError:
-    gzip = None
-
-try:
-    import bz2
-except ImportError:
-    bz2 = None
-
-try:
-    import lzma
-except ImportError:
-    lzma = None
-
-__all__ = [
-    "Error", "TestFailed", "ResourceDenied", "import_module", "verbose",
-    "use_resources", "max_memuse", "record_original_stdout",
-    "get_original_stdout", "unload", "unlink", "rmtree", "forget",
-    "is_resource_enabled", "requires", "requires_freebsd_version",
-    "requires_linux_version", "requires_mac_ver", "find_unused_port",
-    "bind_port", "IPV6_ENABLED", "is_jython", "TESTFN", "HOST", "SAVEDCWD",
-    "temp_cwd", "findfile", "create_empty_file", "sortdict",
-    "check_syntax_error", "open_urlresource", "check_warnings", "CleanImport",
-    "EnvironmentVarGuard", "TransientResource", "captured_stdout",
-    "captured_stdin", "captured_stderr", "time_out", "socket_peer_reset",
-    "ioerror_peer_reset", "run_with_locale", 'temp_umask',
-    "transient_internet", "set_memlimit", "bigmemtest", "bigaddrspacetest",
-    "BasicTestRunner", "run_unittest", "run_doctest", "threading_setup",
-    "threading_cleanup", "reap_children", "cpython_only", "check_impl_detail",
-    "get_attribute", "swap_item", "swap_attr", "requires_IEEE_754",
-    "TestHandler", "Matcher", "can_symlink", "skip_unless_symlink",
-    "skip_unless_xattr", "import_fresh_module", "requires_zlib",
-    "PIPE_MAX_SIZE", "failfast", "anticipate_failure", "run_with_tz",
-    "requires_gzip", "requires_bz2", "requires_lzma", "suppress_crash_popup",
-    ]
-
-class Error(Exception):
-    """Base class for regression test exceptions."""
-
-class TestFailed(Error):
-    """Test failed."""
-
-class ResourceDenied(unittest.SkipTest):
-    """Test skipped because it requested a disallowed resource.
-
-    This is raised when a test calls requires() for a resource that
-    has not be enabled.  It is used to distinguish between expected
-    and unexpected skips.
-    """
-
-@contextlib.contextmanager
-def _ignore_deprecated_imports(ignore=True):
-    """Context manager to suppress package and module deprecation
-    warnings when importing them.
-
-    If ignore is False, this context manager has no effect.
-    """
-    if ignore:
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", ".+ (module|package)",
-                                    DeprecationWarning)
-            yield
-    else:
-        yield
-
-
-def import_module(name, deprecated=False, *, required_on=()):
-    """Import and return the module to be tested, raising SkipTest if
-    it is not available.
-
-    If deprecated is True, any module or package deprecation messages
-    will be suppressed. If a module is required on a platform but optional for
-    others, set required_on to an iterable of platform prefixes which will be
-    compared against sys.platform.
-    """
-    with _ignore_deprecated_imports(deprecated):
-        try:
-            return importlib.import_module(name)
-        except ImportError as msg:
-            if sys.platform.startswith(tuple(required_on)):
-                raise
-            raise unittest.SkipTest(str(msg))
-
-
-def _save_and_remove_module(name, orig_modules):
-    """Helper function to save and remove a module from sys.modules
-
-    Raise ImportError if the module can't be imported.
-    """
-    # try to import the module and raise an error if it can't be imported
-    if name not in sys.modules:
-        __import__(name)
-        del sys.modules[name]
-    for modname in list(sys.modules):
-        if modname == name or modname.startswith(name + '.'):
-            orig_modules[modname] = sys.modules[modname]
-            del sys.modules[modname]
-
-def _save_and_block_module(name, orig_modules):
-    """Helper function to save and block a module in sys.modules
-
-    Return True if the module was in sys.modules, False otherwise.
-    """
-    saved = True
-    try:
-        orig_modules[name] = sys.modules[name]
-    except KeyError:
-        saved = False
-    sys.modules[name] = None
-    return saved
-
-
-def anticipate_failure(condition):
-    """Decorator to mark a test that is known to be broken in some cases
-
-       Any use of this decorator should have a comment identifying the
-       associated tracker issue.
-    """
-    if condition:
-        return unittest.expectedFailure
-    return lambda f: f
-
-
-def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
-    """Import and return a module, deliberately bypassing sys.modules.
-
-    This function imports and returns a fresh copy of the named Python module
-    by removing the named module from sys.modules before doing the import.
-    Note that unlike reload, the original module is not affected by
-    this operation.
-
-    *fresh* is an iterable of additional module names that are also removed
-    from the sys.modules cache before doing the import.
-
-    *blocked* is an iterable of module names that are replaced with None
-    in the module cache during the import to ensure that attempts to import
-    them raise ImportError.
-
-    The named module and any modules named in the *fresh* and *blocked*
-    parameters are saved before starting the import and then reinserted into
-    sys.modules when the fresh import is complete.
-
-    Module and package deprecation messages are suppressed during this import
-    if *deprecated* is True.
-
-    This function will raise ImportError if the named module cannot be
-    imported.
-    """
-    # NOTE: test_heapq, test_json and test_warnings include extra sanity checks
-    # to make sure that this utility function is working as expected
-    with _ignore_deprecated_imports(deprecated):
-        # Keep track of modules saved for later restoration as well
-        # as those which just need a blocking entry removed
-        orig_modules = {}
-        names_to_remove = []
-        _save_and_remove_module(name, orig_modules)
-        try:
-            for fresh_name in fresh:
-                _save_and_remove_module(fresh_name, orig_modules)
-            for blocked_name in blocked:
-                if not _save_and_block_module(blocked_name, orig_modules):
-                    names_to_remove.append(blocked_name)
-            fresh_module = importlib.import_module(name)
-        except ImportError:
-            fresh_module = None
-        finally:
-            for orig_name, module in orig_modules.items():
-                sys.modules[orig_name] = module
-            for name_to_remove in names_to_remove:
-                del sys.modules[name_to_remove]
-        return fresh_module
-
-
-def get_attribute(obj, name):
-    """Get an attribute, raising SkipTest if AttributeError is raised."""
-    try:
-        attribute = getattr(obj, name)
-    except AttributeError:
-        raise unittest.SkipTest("object %r has no attribute %r" % (obj, name))
-    else:
-        return attribute
-
-verbose = 1              # Flag set to 0 by regrtest.py
-use_resources = None     # Flag set to [] by regrtest.py
-max_memuse = 0           # Disable bigmem tests (they will still be run with
-                         # small sizes, to make sure they work.)
-real_max_memuse = 0
-failfast = False
-match_tests = None
-
-# _original_stdout is meant to hold stdout at the time regrtest began.
-# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
-# The point is to have some flavor of stdout the user can actually see.
-_original_stdout = None
-def record_original_stdout(stdout):
-    global _original_stdout
-    _original_stdout = stdout
-
-def get_original_stdout():
-    return _original_stdout or sys.stdout
-
-def unload(name):
-    try:
-        del sys.modules[name]
-    except KeyError:
-        pass
-
-if sys.platform.startswith("win"):
-    def _waitfor(func, pathname, waitall=False):
-        # Peform the operation
-        func(pathname)
-        # Now setup the wait loop
-        if waitall:
-            dirname = pathname
-        else:
-            dirname, name = os.path.split(pathname)
-            dirname = dirname or '.'
-        # Check for `pathname` to be removed from the filesystem.
-        # The exponential backoff of the timeout amounts to a total
-        # of ~1 second after which the deletion is probably an error
-        # anyway.
-        # Testing on a i7@4.3GHz shows that usually only 1 iteration is
-        # required when contention occurs.
-        timeout = 0.001
-        while timeout < 1.0:
-            # Note we are only testing for the existance of the file(s) in
-            # the contents of the directory regardless of any security or
-            # access rights.  If we have made it this far, we have sufficient
-            # permissions to do that much using Python's equivalent of the
-            # Windows API FindFirstFile.
-            # Other Windows APIs can fail or give incorrect results when
-            # dealing with files that are pending deletion.
-            L = os.listdir(dirname)
-            if not (L if waitall else name in L):
-                return
-            # Increase the timeout and try again
-            time.sleep(timeout)
-            timeout *= 2
-        warnings.warn('tests may fail, delete still pending for ' + pathname,
-                      RuntimeWarning, stacklevel=4)
-
-    def _unlink(filename):
-        _waitfor(os.unlink, filename)
-
-    def _rmdir(dirname):
-        _waitfor(os.rmdir, dirname)
-
-    def _rmtree(path):
-        def _rmtree_inner(path):
-            for name in os.listdir(path):
-                fullname = os.path.join(path, name)
-                if os.path.isdir(fullname):
-                    _waitfor(_rmtree_inner, fullname, waitall=True)
-                    os.rmdir(fullname)
-                else:
-                    os.unlink(fullname)
-        _waitfor(_rmtree_inner, path, waitall=True)
-        _waitfor(os.rmdir, path)
-else:
-    _unlink = os.unlink
-    _rmdir = os.rmdir
-    _rmtree = shutil.rmtree
-
-def unlink(filename):
-    try:
-        _unlink(filename)
-    except (FileNotFoundError, NotADirectoryError):
-        pass
-
-def rmdir(dirname):
-    try:
-        _rmdir(dirname)
-    except FileNotFoundError:
-        pass
-
-def rmtree(path):
-    try:
-        _rmtree(path)
-    except FileNotFoundError:
-        pass
-
-def make_legacy_pyc(source):
-    """Move a PEP 3147 pyc/pyo file to its legacy pyc/pyo location.
-
-    The choice of .pyc or .pyo extension is done based on the __debug__ flag
-    value.
-
-    :param source: The file system path to the source file.  The source file
-        does not need to exist, however the PEP 3147 pyc file must exist.
-    :return: The file system path to the legacy pyc file.
-    """
-    pyc_file = importlib.util.cache_from_source(source)
-    up_one = os.path.dirname(os.path.abspath(source))
-    legacy_pyc = os.path.join(up_one, source + ('c' if __debug__ else 'o'))
-    os.rename(pyc_file, legacy_pyc)
-    return legacy_pyc
-
-def forget(modname):
-    """'Forget' a module was ever imported.
-
-    This removes the module from sys.modules and deletes any PEP 3147 or
-    legacy .pyc and .pyo files.
-    """
-    unload(modname)
-    for dirname in sys.path:
-        source = os.path.join(dirname, modname + '.py')
-        # It doesn't matter if they exist or not, unlink all possible
-        # combinations of PEP 3147 and legacy pyc and pyo files.
-        unlink(source + 'c')
-        unlink(source + 'o')
-        unlink(importlib.util.cache_from_source(source, debug_override=True))
-        unlink(importlib.util.cache_from_source(source, debug_override=False))
-
-# On some platforms, should not run gui test even if it is allowed
-# in `use_resources'.
-if sys.platform.startswith('win'):
-    import ctypes
-    import ctypes.wintypes
-    def _is_gui_available():
-        UOI_FLAGS = 1
-        WSF_VISIBLE = 0x0001
-        class USEROBJECTFLAGS(ctypes.Structure):
-            _fields_ = [("fInherit", ctypes.wintypes.BOOL),
-                        ("fReserved", ctypes.wintypes.BOOL),
-                        ("dwFlags", ctypes.wintypes.DWORD)]
-        dll = ctypes.windll.user32
-        h = dll.GetProcessWindowStation()
-        if not h:
-            raise ctypes.WinError()
-        uof = USEROBJECTFLAGS()
-        needed = ctypes.wintypes.DWORD()
-        res = dll.GetUserObjectInformationW(h,
-            UOI_FLAGS,
-            ctypes.byref(uof),
-            ctypes.sizeof(uof),
-            ctypes.byref(needed))
-        if not res:
-            raise ctypes.WinError()
-        return bool(uof.dwFlags & WSF_VISIBLE)
-else:
-    def _is_gui_available():
-        return True
-
-def is_resource_enabled(resource):
-    """Test whether a resource is enabled.  Known resources are set by
-    regrtest.py."""
-    return use_resources is not None and resource in use_resources
-
-def requires(resource, msg=None):
-    """Raise ResourceDenied if the specified resource is not available.
-
-    If the caller's module is __main__ then automatically return True.  The
-    possibility of False being returned occurs when regrtest.py is
-    executing.
-    """
-    if resource == 'gui' and not _is_gui_available():
-        raise unittest.SkipTest("Cannot use the 'gui' resource")
-    # see if the caller's module is __main__ - if so, treat as if
-    # the resource was set
-    if sys._getframe(1).f_globals.get("__name__") == "__main__":
-        return
-    if not is_resource_enabled(resource):
-        if msg is None:
-            msg = "Use of the %r resource not enabled" % resource
-        raise ResourceDenied(msg)
-
-def _requires_unix_version(sysname, min_version):
-    """Decorator raising SkipTest if the OS is `sysname` and the version is less
-    than `min_version`.
-
-    For example, @_requires_unix_version('FreeBSD', (7, 2)) raises SkipTest if
-    the FreeBSD version is less than 7.2.
-    """
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kw):
-            if platform.system() == sysname:
-                version_txt = platform.release().split('-', 1)[0]
-                try:
-                    version = tuple(map(int, version_txt.split('.')))
-                except ValueError:
-                    pass
-                else:
-                    if version < min_version:
-                        min_version_txt = '.'.join(map(str, min_version))
-                        raise unittest.SkipTest(
-                            "%s version %s or higher required, not %s"
-                            % (sysname, min_version_txt, version_txt))
-        return wrapper
-    return decorator
-
-def requires_freebsd_version(*min_version):
-    """Decorator raising SkipTest if the OS is FreeBSD and the FreeBSD version is
-    less than `min_version`.
-
-    For example, @requires_freebsd_version(7, 2) raises SkipTest if the FreeBSD
-    version is less than 7.2.
-    """
-    return _requires_unix_version('FreeBSD', min_version)
-
-def requires_linux_version(*min_version):
-    """Decorator raising SkipTest if the OS is Linux and the Linux version is
-    less than `min_version`.
-
-    For example, @requires_linux_version(2, 6, 32) raises SkipTest if the Linux
-    version is less than 2.6.32.
-    """
-    return _requires_unix_version('Linux', min_version)
-
-def requires_mac_ver(*min_version):
-    """Decorator raising SkipTest if the OS is Mac OS X and the OS X
-    version if less than min_version.
-
-    For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version
-    is lesser than 10.5.
-    """
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kw):
-            if sys.platform == 'darwin':
-                version_txt = platform.mac_ver()[0]
-                try:
-                    version = tuple(map(int, version_txt.split('.')))
-                except ValueError:
-                    pass
-                else:
-                    if version < min_version:
-                        min_version_txt = '.'.join(map(str, min_version))
-                        raise unittest.SkipTest(
-                            "Mac OS X %s or higher required, not %s"
-                            % (min_version_txt, version_txt))
-            return func(*args, **kw)
-        wrapper.min_version = min_version
-        return wrapper
-    return decorator
-
-
-HOST = 'localhost'
-
-def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM):
-    """Returns an unused port that should be suitable for binding.  This is
-    achieved by creating a temporary socket with the same family and type as
-    the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to
-    the specified host address (defaults to 0.0.0.0) with the port set to 0,
-    eliciting an unused ephemeral port from the OS.  The temporary socket is
-    then closed and deleted, and the ephemeral port is returned.
-
-    Either this method or bind_port() should be used for any tests where a
-    server socket needs to be bound to a particular port for the duration of
-    the test.  Which one to use depends on whether the calling code is creating
-    a python socket, or if an unused port needs to be provided in a constructor
-    or passed to an external program (i.e. the -accept argument to openssl's
-    s_server mode).  Always prefer bind_port() over find_unused_port() where
-    possible.  Hard coded ports should *NEVER* be used.  As soon as a server
-    socket is bound to a hard coded port, the ability to run multiple instances
-    of the test simultaneously on the same host is compromised, which makes the
-    test a ticking time bomb in a buildbot environment. On Unix buildbots, this
-    may simply manifest as a failed test, which can be recovered from without
-    intervention in most cases, but on Windows, the entire python process can
-    completely and utterly wedge, requiring someone to log in to the buildbot
-    and manually kill the affected process.
-
-    (This is easy to reproduce on Windows, unfortunately, and can be traced to
-    the SO_REUSEADDR socket option having different semantics on Windows versus
-    Unix/Linux.  On Unix, you can't have two AF_INET SOCK_STREAM sockets bind,
-    listen and then accept connections on identical host/ports.  An EADDRINUSE
-    OSError will be raised at some point (depending on the platform and
-    the order bind and listen were called on each socket).
-
-    However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE
-    will ever be raised when attempting to bind two identical host/ports. When
-    accept() is called on each socket, the second caller's process will steal
-    the port from the first caller, leaving them both in an awkwardly wedged
-    state where they'll no longer respond to any signals or graceful kills, and
-    must be forcibly killed via OpenProcess()/TerminateProcess().
-
-    The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option
-    instead of SO_REUSEADDR, which effectively affords the same semantics as
-    SO_REUSEADDR on Unix.  Given the propensity of Unix developers in the Open
-    Source world compared to Windows ones, this is a common mistake.  A quick
-    look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when
-    openssl.exe is called with the 's_server' option, for example. See
-    http://bugs.python.org/issue2550 for more info.  The following site also
-    has a very thorough description about the implications of both REUSEADDR
-    and EXCLUSIVEADDRUSE on Windows:
-    http://msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx)
-
-    XXX: although this approach is a vast improvement on previous attempts to
-    elicit unused ports, it rests heavily on the assumption that the ephemeral
-    port returned to us by the OS won't immediately be dished back out to some
-    other process when we close and delete our temporary socket but before our
-    calling code has a chance to bind the returned port.  We can deal with this
-    issue if/when we come across it.
-    """
-
-    tempsock = socket.socket(family, socktype)
-    port = bind_port(tempsock)
-    tempsock.close()
-    del tempsock
-    return port
-
-def bind_port(sock, host=HOST):
-    """Bind the socket to a free port and return the port number.  Relies on
-    ephemeral ports in order to ensure we are using an unbound port.  This is
-    important as many tests may be running simultaneously, especially in a
-    buildbot environment.  This method raises an exception if the sock.family
-    is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
-    or SO_REUSEPORT set on it.  Tests should *never* set these socket options
-    for TCP/IP sockets.  The only case for setting these options is testing
-    multicasting via multiple UDP sockets.
-
-    Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
-    on Windows), it will be set on the socket.  This will prevent anyone else
-    from bind()'ing to our host/port for the duration of the test.
-    """
-
-    if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
-        if hasattr(socket, 'SO_REUSEADDR'):
-            if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
-                raise TestFailed("tests should never set the SO_REUSEADDR "   \
-                                 "socket option on TCP/IP sockets!")
-        if hasattr(socket, 'SO_REUSEPORT'):
-            if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
-                raise TestFailed("tests should never set the SO_REUSEPORT "   \
-                                 "socket option on TCP/IP sockets!")
-        if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
-
-    sock.bind((host, 0))
-    port = sock.getsockname()[1]
-    return port
-
-def _is_ipv6_enabled():
-    """Check whether IPv6 is enabled on this host."""
-    if socket.has_ipv6:
-        sock = None
-        try:
-            sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-            sock.bind(('::1', 0))
-            return True
-        except OSError:
-            pass
-        finally:
-            if sock:
-                sock.close()
-    return False
-
-IPV6_ENABLED = _is_ipv6_enabled()
-
-
-# A constant likely larger than the underlying OS pipe buffer size, to
-# make writes blocking.
-# Windows limit seems to be around 512 B, and many Unix kernels have a
-# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.
-# (see issue #17835 for a discussion of this number).
-PIPE_MAX_SIZE = 4 *1024 * 1024 + 1
-
-
-# decorator for skipping tests on non-IEEE 754 platforms
-requires_IEEE_754 = unittest.skipUnless(
-    float.__getformat__("double").startswith("IEEE"),
-    "test requires IEEE 754 doubles")
-
-requires_zlib = unittest.skipUnless(zlib, 'requires zlib')
-
-requires_gzip = unittest.skipUnless(gzip, 'requires gzip')
-
-requires_bz2 = unittest.skipUnless(bz2, 'requires bz2')
-
-requires_lzma = unittest.skipUnless(lzma, 'requires lzma')
-
-is_jython = sys.platform.startswith('java')
-
-# Filename used for testing
-if os.name == 'java':
-    # Jython disallows @ in module names
-    TESTFN = '$test'
-else:
-    TESTFN = '@test'
-
-# Disambiguate TESTFN for parallel testing, while letting it remain a valid
-# module name.
-TESTFN = "{}_{}_tmp".format(TESTFN, os.getpid())
-
-# FS_NONASCII: non-ASCII character encodable by os.fsencode(),
-# or None if there is no such character.
-FS_NONASCII = None
-for character in (
-    # First try printable and common characters to have a readable filename.
-    # For each character, the encoding list are just example of encodings able
-    # to encode the character (the list is not exhaustive).
-
-    # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1
-    '\u00E6',
-    # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3
-    '\u0130',
-    # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257
-    '\u0141',
-    # U+03C6 (Greek Small Letter Phi): cp1253
-    '\u03C6',
-    # U+041A (Cyrillic Capital Letter Ka): cp1251
-    '\u041A',
-    # U+05D0 (Hebrew Letter Alef): Encodable to cp424
-    '\u05D0',
-    # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic
-    '\u060C',
-    # U+062A (Arabic Letter Teh): cp720
-    '\u062A',
-    # U+0E01 (Thai Character Ko Kai): cp874
-    '\u0E01',
-
-    # Then try more "special" characters. "special" because they may be
-    # interpreted or displayed differently depending on the exact locale
-    # encoding and the font.
-
-    # U+00A0 (No-Break Space)
-    '\u00A0',
-    # U+20AC (Euro Sign)
-    '\u20AC',
-):
-    try:
-        os.fsdecode(os.fsencode(character))
-    except UnicodeError:
-        pass
-    else:
-        FS_NONASCII = character
-        break
-
-# TESTFN_UNICODE is a non-ascii filename
-TESTFN_UNICODE = TESTFN + "-\xe0\xf2\u0258\u0141\u011f"
-if sys.platform == 'darwin':
-    # In Mac OS X's VFS API file names are, by definition, canonically
-    # decomposed Unicode, encoded using UTF-8. See QA1173:
-    # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
-    import unicodedata
-    TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE)
-TESTFN_ENCODING = sys.getfilesystemencoding()
-
-# TESTFN_UNENCODABLE is a filename (str type) that should *not* be able to be
-# encoded by the filesystem encoding (in strict mode). It can be None if we
-# cannot generate such filename.
-TESTFN_UNENCODABLE = None
-if os.name in ('nt', 'ce'):
-    # skip win32s (0) or Windows 9x/ME (1)
-    if sys.getwindowsversion().platform >= 2:
-        # Different kinds of characters from various languages to minimize the
-        # probability that the whole name is encodable to MBCS (issue #9819)
-        TESTFN_UNENCODABLE = TESTFN + "-\u5171\u0141\u2661\u0363\uDC80"
-        try:
-            TESTFN_UNENCODABLE.encode(TESTFN_ENCODING)
-        except UnicodeEncodeError:
-            pass
-        else:
-            print('WARNING: The filename %r CAN be encoded by the filesystem encoding (%s). '
-                  'Unicode filename tests may not be effective'
-                  % (TESTFN_UNENCODABLE, TESTFN_ENCODING))
-            TESTFN_UNENCODABLE = None
-# Mac OS X denies unencodable filenames (invalid utf-8)
-elif sys.platform != 'darwin':
-    try:
-        # ascii and utf-8 cannot encode the byte 0xff
-        b'\xff'.decode(TESTFN_ENCODING)
-    except UnicodeDecodeError:
-        # 0xff will be encoded using the surrogate character u+DCFF
-        TESTFN_UNENCODABLE = TESTFN \
-            + b'-\xff'.decode(TESTFN_ENCODING, 'surrogateescape')
-    else:
-        # File system encoding (eg. ISO-8859-* encodings) can encode
-        # the byte 0xff. Skip some unicode filename tests.
-        pass
-
-# TESTFN_UNDECODABLE is a filename (bytes type) that should *not* be able to be
-# decoded from the filesystem encoding (in strict mode). It can be None if we
-# cannot generate such filename (ex: the latin1 encoding can decode any byte
-# sequence). On UNIX, TESTFN_UNDECODABLE can be decoded by os.fsdecode() thanks
-# to the surrogateescape error handler (PEP 383), but not from the filesystem
-# encoding in strict mode.
-TESTFN_UNDECODABLE = None
-for name in (
-    # b'\xff' is not decodable by os.fsdecode() with code page 932. Windows
-    # accepts it to create a file or a directory, or don't accept to enter to
-    # such directory (when the bytes name is used). So test b'\xe7' first: it is
-    # not decodable from cp932.
-    b'\xe7w\xf0',
-    # undecodable from ASCII, UTF-8
-    b'\xff',
-    # undecodable from iso8859-3, iso8859-6, iso8859-7, cp424, iso8859-8, cp856
-    # and cp857
-    b'\xae\xd5'
-    # undecodable from UTF-8 (UNIX and Mac OS X)
-    b'\xed\xb2\x80', b'\xed\xb4\x80',
-    # undecodable from shift_jis, cp869, cp874, cp932, cp1250, cp1251, cp1252,
-    # cp1253, cp1254, cp1255, cp1257, cp1258
-    b'\x81\x98',
-):
-    try:
-        name.decode(TESTFN_ENCODING)
-    except UnicodeDecodeError:
-        TESTFN_UNDECODABLE = os.fsencode(TESTFN) + name
-        break
-
-if FS_NONASCII:
-    TESTFN_NONASCII = TESTFN + '-' + FS_NONASCII
-else:
-    TESTFN_NONASCII = None
-
-# Save the initial cwd
-SAVEDCWD = os.getcwd()
-
-@contextlib.contextmanager
-def temp_dir(path=None, quiet=False):
-    """Return a context manager that creates a temporary directory.
-
-    Arguments:
-
-      path: the directory to create temporarily.  If omitted or None,
-        defaults to creating a temporary directory using tempfile.mkdtemp.
-
-      quiet: if False (the default), the context manager raises an exception
-        on error.  Otherwise, if the path is specified and cannot be
-        created, only a warning is issued.
-
-    """
-    dir_created = False
-    if path is None:
-        path = tempfile.mkdtemp()
-        dir_created = True
-        path = os.path.realpath(path)
-    else:
-        try:
-            os.mkdir(path)
-            dir_created = True
-        except OSError:
-            if not quiet:
-                raise
-            warnings.warn('tests may fail, unable to create temp dir: ' + path,
-                          RuntimeWarning, stacklevel=3)
-    try:
-        yield path
-    finally:
-        if dir_created:
-            shutil.rmtree(path)
-
-@contextlib.contextmanager
-def change_cwd(path, quiet=False):
-    """Return a context manager that changes the current working directory.
-
-    Arguments:
-
-      path: the directory to use as the temporary current working directory.
-
-      quiet: if False (the default), the context manager raises an exception
-        on error.  Otherwise, it issues only a warning and keeps the current
-        working directory the same.
-
-    """
-    saved_dir = os.getcwd()
-    try:
-        os.chdir(path)
-    except OSError:
-        if not quiet:
-            raise
-        warnings.warn('tests may fail, unable to change CWD to: ' + path,
-                      RuntimeWarning, stacklevel=3)
-    try:
-        yield os.getcwd()
-    finally:
-        os.chdir(saved_dir)
-
-
-@contextlib.contextmanager
-def temp_cwd(name='tempcwd', quiet=False):
-    """
-    Context manager that temporarily creates and changes the CWD.
-
-    The function temporarily changes the current working directory
-    after creating a temporary directory in the current directory with
-    name *name*.  If *name* is None, the temporary directory is
-    created using tempfile.mkdtemp.
-
-    If *quiet* is False (default) and it is not possible to
-    create or change the CWD, an error is raised.  If *quiet* is True,
-    only a warning is raised and the original CWD is used.
-
-    """
-    with temp_dir(path=name, quiet=quiet) as temp_path:
-        with change_cwd(temp_path, quiet=quiet) as cwd_dir:
-            yield cwd_dir
-
-if hasattr(os, "umask"):
-    @contextlib.contextmanager
-    def temp_umask(umask):
-        """Context manager that temporarily sets the process umask."""
-        oldmask = os.umask(umask)
-        try:
-            yield
-        finally:
-            os.umask(oldmask)
-
-# TEST_HOME refers to the top level directory of the "test" package
-# that contains Python's regression test suite
-TEST_HOME = os.path.dirname(os.path.abspath(__file__))
-
-def findfile(file, here=TEST_HOME, subdir=None):
-    """Try to find a file on sys.path or in the test directory.  If it is not
-    found the argument passed to the function is returned (this does not
-    necessarily signal failure; could still be the legitimate path)."""
-    if os.path.isabs(file):
-        return file
-    if subdir is not None:
-        file = os.path.join(subdir, file)
-    path = sys.path
-    path = [os.path.dirname(here)] + path
-    for dn in path:
-        fn = os.path.join(dn, file)
-        if os.path.exists(fn): return fn
-    return file
-
-def create_empty_file(filename):
-    """Create an empty file. If the file already exists, truncate it."""
-    fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
-    os.close(fd)
-
-def sortdict(dict):
-    "Like repr(dict), but in sorted order."
-    items = sorted(dict.items())
-    reprpairs = ["%r: %r" % pair for pair in items]
-    withcommas = ", ".join(reprpairs)
-    return "{%s}" % withcommas
-
-def make_bad_fd():
-    """
-    Create an invalid file descriptor by opening and closing a file and return
-    its fd.
-    """
-    file = open(TESTFN, "wb")
-    try:
-        return file.fileno()
-    finally:
-        file.close()
-        unlink(TESTFN)
-
-def check_syntax_error(testcase, statement):
-    testcase.assertRaises(SyntaxError, compile, statement,
-                          '<test string>', 'exec')
-
-def open_urlresource(url, *args, **kw):
-    import urllib.request, urllib.parse
-
-    check = kw.pop('check', None)
-
-    filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
-
-    fn = os.path.join(os.path.dirname(__file__), "data", filename)
-
-    def check_valid_file(fn):
-        f = open(fn, *args, **kw)
-        if check is None:
-            return f
-        elif check(f):
-            f.seek(0)
-            return f
-        f.close()
-
-    if os.path.exists(fn):
-        f = check_valid_file(fn)
-        if f is not None:
-            return f
-        unlink(fn)
-
-    # Verify the requirement before downloading the file
-    requires('urlfetch')
-
-    print('\tfetching %s ...' % url, file=get_original_stdout())
-    f = urllib.request.urlopen(url, timeout=15)
-    try:
-        with open(fn, "wb") as out:
-            s = f.read()
-            while s:
-                out.write(s)
-                s = f.read()
-    finally:
-        f.close()
-
-    f = check_valid_file(fn)
-    if f is not None:
-        return f
-    raise TestFailed('invalid resource %r' % fn)
-
-
-class WarningsRecorder(object):
-    """Convenience wrapper for the warnings list returned on
-       entry to the warnings.catch_warnings() context manager.
-    """
-    def __init__(self, warnings_list):
-        self._warnings = warnings_list
-        self._last = 0
-
-    def __getattr__(self, attr):
-        if len(self._warnings) > self._last:
-            return getattr(self._warnings[-1], attr)
-        elif attr in warnings.WarningMessage._WARNING_DETAILS:
-            return None
-        raise AttributeError("%r has no attribute %r" % (self, attr))
-
-    @property
-    def warnings(self):
-        return self._warnings[self._last:]
-
-    def reset(self):
-        self._last = len(self._warnings)
-
-
-def _filterwarnings(filters, quiet=False):
-    """Catch the warnings, then check if all the expected
-    warnings have been raised and re-raise unexpected warnings.
-    If 'quiet' is True, only re-raise the unexpected warnings.
-    """
-    # Clear the warning registry of the calling module
-    # in order to re-raise the warnings.
-    frame = sys._getframe(2)
-    registry = frame.f_globals.get('__warningregistry__')
-    if registry:
-        registry.clear()
-    with warnings.catch_warnings(record=True) as w:
-        # Set filter "always" to record all warnings.  Because
-        # test_warnings swap the module, we need to look up in
-        # the sys.modules dictionary.
-        sys.modules['warnings'].simplefilter("always")
-        yield WarningsRecorder(w)
-    # Filter the recorded warnings
-    reraise = list(w)
-    missing = []
-    for msg, cat in filters:
-        seen = False
-        for w in reraise[:]:
-            warning = w.message
-            # Filter out the matching messages
-            if (re.match(msg, str(warning), re.I) and
-                issubclass(warning.__class__, cat)):
-                seen = True
-                reraise.remove(w)
-        if not seen and not quiet:
-            # This filter caught nothing
-            missing.append((msg, cat.__name__))
-    if reraise:
-        raise AssertionError("unhandled warning %s" % reraise[0])
-    if missing:
-        raise AssertionError("filter (%r, %s) did not catch any warning" %
-                             missing[0])
-
-
-@contextlib.contextmanager
-def check_warnings(*filters, **kwargs):
-    """Context manager to silence warnings.
-
-    Accept 2-tuples as positional arguments:
-        ("message regexp", WarningCategory)
-
-    Optional argument:
-     - if 'quiet' is True, it does not fail if a filter catches nothing
-        (default True without argument,
-         default False if some filters are defined)
-
-    Without argument, it defaults to:
-        check_warnings(("", Warning), quiet=True)
-    """
-    quiet = kwargs.get('quiet')
-    if not filters:
-        filters = (("", Warning),)
-        # Preserve backward compatibility
-        if quiet is None:
-            quiet = True
-    return _filterwarnings(filters, quiet)
-
-
-class CleanImport(object):
-    """Context manager to force import to return a new module reference.
-
-    This is useful for testing module-level behaviours, such as
-    the emission of a DeprecationWarning on import.
-
-    Use like this:
-
-        with CleanImport("foo"):
-            importlib.import_module("foo") # new reference
-    """
-
-    def __init__(self, *module_names):
-        self.original_modules = sys.modules.copy()
-        for module_name in module_names:
-            if module_name in sys.modules:
-                module = sys.modules[module_name]
-                # It is possible that module_name is just an alias for
-                # another module (e.g. stub for modules renamed in 3.x).
-                # In that case, we also need delete the real module to clear
-                # the import cache.
-                if module.__name__ != module_name:
-                    del sys.modules[module.__name__]
-                del sys.modules[module_name]
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *ignore_exc):
-        sys.modules.update(self.original_modules)
-
-
-class EnvironmentVarGuard(collections.abc.MutableMapping):
-
-    """Class to help protect the environment variable properly.  Can be used as
-    a context manager."""
-
-    def __init__(self):
-        self._environ = os.environ
-        self._changed = {}
-
-    def __getitem__(self, envvar):
-        return self._environ[envvar]
-
-    def __setitem__(self, envvar, value):
-        # Remember the initial value on the first access
-        if envvar not in self._changed:
-            self._changed[envvar] = self._environ.get(envvar)
-        self._environ[envvar] = value
-
-    def __delitem__(self, envvar):
-        # Remember the initial value on the first access
-        if envvar not in self._changed:
-            self._changed[envvar] = self._environ.get(envvar)
-        if envvar in self._environ:
-            del self._environ[envvar]
-
-    def keys(self):
-        return self._environ.keys()
-
-    def __iter__(self):
-        return iter(self._environ)
-
-    def __len__(self):
-        return len(self._environ)
-
-    def set(self, envvar, value):
-        self[envvar] = value
-
-    def unset(self, envvar):
-        del self[envvar]
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *ignore_exc):
-        for (k, v) in self._changed.items():
-            if v is None:
-                if k in self._environ:
-                    del self._environ[k]
-            else:
-                self._environ[k] = v
-        os.environ = self._environ
-
-
-class DirsOnSysPath(object):
-    """Context manager to temporarily add directories to sys.path.
-
-    This makes a copy of sys.path, appends any directories given
-    as positional arguments, then reverts sys.path to the copied
-    settings when the context ends.
-
-    Note that *all* sys.path modifications in the body of the
-    context manager, including replacement of the object,
-    will be reverted at the end of the block.
-    """
-
-    def __init__(self, *paths):
-        self.original_value = sys.path[:]
-        self.original_object = sys.path
-        sys.path.extend(paths)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *ignore_exc):
-        sys.path = self.original_object
-        sys.path[:] = self.original_value
-
-
-class TransientResource(object):
-
-    """Raise ResourceDenied if an exception is raised while the context manager
-    is in effect that matches the specified exception and attributes."""
-
-    def __init__(self, exc, **kwargs):
-        self.exc = exc
-        self.attrs = kwargs
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type_=None, value=None, traceback=None):
-        """If type_ is a subclass of self.exc and value has attributes matching
-        self.attrs, raise ResourceDenied.  Otherwise let the exception
-        propagate (if any)."""
-        if type_ is not None and issubclass(self.exc, type_):
-            for attr, attr_value in self.attrs.items():
-                if not hasattr(value, attr):
-                    break
-                if getattr(value, attr) != attr_value:
-                    break
-            else:
-                raise ResourceDenied("an optional resource is not available")
-
-# Context managers that raise ResourceDenied when various issues
-# with the Internet connection manifest themselves as exceptions.
-# XXX deprecate these and use transient_internet() instead
-time_out = TransientResource(OSError, errno=errno.ETIMEDOUT)
-socket_peer_reset = TransientResource(OSError, errno=errno.ECONNRESET)
-ioerror_peer_reset = TransientResource(OSError, errno=errno.ECONNRESET)
-
-
-@contextlib.contextmanager
-def transient_internet(resource_name, *, timeout=30.0, errnos=()):
-    """Return a context manager that raises ResourceDenied when various issues
-    with the Internet connection manifest themselves as exceptions."""
-    default_errnos = [
-        ('ECONNREFUSED', 111),
-        ('ECONNRESET', 104),
-        ('EHOSTUNREACH', 113),
-        ('ENETUNREACH', 101),
-        ('ETIMEDOUT', 110),
-    ]
-    default_gai_errnos = [
-        ('EAI_AGAIN', -3),
-        ('EAI_FAIL', -4),
-        ('EAI_NONAME', -2),
-        ('EAI_NODATA', -5),
-        # Encountered when trying to resolve IPv6-only hostnames
-        ('WSANO_DATA', 11004),
-    ]
-
-    denied = ResourceDenied("Resource %r is not available" % resource_name)
-    captured_errnos = errnos
-    gai_errnos = []
-    if not captured_errnos:
-        captured_errnos = [getattr(errno, name, num)
-                           for (name, num) in default_errnos]
-        gai_errnos = [getattr(socket, name, num)
-                      for (name, num) in default_gai_errnos]
-
-    def filter_error(err):
-        n = getattr(err, 'errno', None)
-        if (isinstance(err, socket.timeout) or
-            (isinstance(err, socket.gaierror) and n in gai_errnos) or
-            n in captured_errnos):
-            if not verbose:
-                sys.stderr.write(denied.args[0] + "\n")
-            raise denied from err
-
-    old_timeout = socket.getdefaulttimeout()
-    try:
-        if timeout is not None:
-            socket.setdefaulttimeout(timeout)
-        yield
-    except OSError as err:
-        # urllib can wrap original socket errors multiple times (!), we must
-        # unwrap to get at the original error.
-        while True:
-            a = err.args
-            if len(a) >= 1 and isinstance(a[0], OSError):
-                err = a[0]
-            # The error can also be wrapped as args[1]:
-            #    except socket.error as msg:
-            #        raise OSError('socket error', msg).with_traceback(sys.exc_info()[2])
-            elif len(a) >= 2 and isinstance(a[1], OSError):
-                err = a[1]
-            else:
-                break
-        filter_error(err)
-        raise
-    # XXX should we catch generic exceptions and look for their
-    # __cause__ or __context__?
-    finally:
-        socket.setdefaulttimeout(old_timeout)
-
-
-@contextlib.contextmanager
-def captured_output(stream_name):
-    """Return a context manager used by captured_stdout/stdin/stderr
-    that temporarily replaces the sys stream *stream_name* with a StringIO."""
-    import io
-    orig_stdout = getattr(sys, stream_name)
-    setattr(sys, stream_name, io.StringIO())
-    try:
-        yield getattr(sys, stream_name)
-    finally:
-        setattr(sys, stream_name, orig_stdout)
-
-def captured_stdout():
-    """Capture the output of sys.stdout:
-
-       with captured_stdout() as stdout:
-           print("hello")
-       self.assertEqual(stdout.getvalue(), "hello\n")
-    """
-    return captured_output("stdout")
-
-def captured_stderr():
-    """Capture the output of sys.stderr:
-
-       with captured_stderr() as stderr:
-           print("hello", file=sys.stderr)
-       self.assertEqual(stderr.getvalue(), "hello\n")
-    """
-    return captured_output("stderr")
-
-def captured_stdin():
-    """Capture the input to sys.stdin:
-
-       with captured_stdin() as stdin:
-           stdin.write('hello\n')
-           stdin.seek(0)
-           # call test code that consumes from sys.stdin
-           captured = input()
-       self.assertEqual(captured, "hello")
-    """
-    return captured_output("stdin")
-
-
-def gc_collect():
-    """Force as many objects as possible to be collected.
-
-    In non-CPython implementations of Python, this is needed because timely
-    deallocation is not guaranteed by the garbage collector.  (Even in CPython
-    this can be the case in case of reference cycles.)  This means that __del__
-    methods may be called later than expected and weakrefs may remain alive for
-    longer than expected.  This function tries its best to force all garbage
-    objects to disappear.
-    """
-    gc.collect()
-    if is_jython:
-        time.sleep(0.1)
-    gc.collect()
-    gc.collect()
-
-@contextlib.contextmanager
-def disable_gc():
-    have_gc = gc.isenabled()
-    gc.disable()
-    try:
-        yield
-    finally:
-        if have_gc:
-            gc.enable()
-
-
-def python_is_optimized():
-    """Find if Python was built with optimizations."""
-    cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
-    final_opt = ""
-    for opt in cflags.split():
-        if opt.startswith('-O'):
-            final_opt = opt
-    return final_opt != '' and final_opt != '-O0'
-
-
-_header = 'nP'
-_align = '0n'
-if hasattr(sys, "gettotalrefcount"):
-    _header = '2P' + _header
-    _align = '0P'
-_vheader = _header + 'n'
-
-def calcobjsize(fmt):
-    return struct.calcsize(_header + fmt + _align)
-
-def calcvobjsize(fmt):
-    return struct.calcsize(_vheader + fmt + _align)
-
-
-_TPFLAGS_HAVE_GC = 1<<14
-_TPFLAGS_HEAPTYPE = 1<<9
-
-def check_sizeof(test, o, size):
-    result = sys.getsizeof(o)
-    # add GC header size
-    if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\
-        ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):
-        size += _testcapi.SIZEOF_PYGC_HEAD
-    msg = 'wrong size for %s: got %d, expected %d' \
-            % (type(o), result, size)
-    test.assertEqual(result, size, msg)
-
-#=======================================================================
-# Decorator for running a function in a different locale, correctly resetting
-# it afterwards.
-
-def run_with_locale(catstr, *locales):
-    def decorator(func):
-        def inner(*args, **kwds):
-            try:
-                import locale
-                category = getattr(locale, catstr)
-                orig_locale = locale.setlocale(category)
-            except AttributeError:
-                # if the test author gives us an invalid category string
-                raise
-            except:
-                # cannot retrieve original locale, so do nothing
-                locale = orig_locale = None
-            else:
-                for loc in locales:
-                    try:
-                        locale.setlocale(category, loc)
-                        break
-                    except:
-                        pass
-
-            # now run the function, resetting the locale on exceptions
-            try:
-                return func(*args, **kwds)
-            finally:
-                if locale and orig_locale:
-                    locale.setlocale(category, orig_locale)
-        inner.__name__ = func.__name__
-        inner.__doc__ = func.__doc__
-        return inner
-    return decorator
-
-#=======================================================================
-# Decorator for running a function in a specific timezone, correctly
-# resetting it afterwards.
-
-def run_with_tz(tz):
-    def decorator(func):
-        def inner(*args, **kwds):
-            try:
-                tzset = time.tzset
-            except AttributeError:
-                raise unittest.SkipTest("tzset required")
-            if 'TZ' in os.environ:
-                orig_tz = os.environ['TZ']
-            else:
-                orig_tz = None
-            os.environ['TZ'] = tz
-            tzset()
-
-            # now run the function, resetting the tz on exceptions
-            try:
-                return func(*args, **kwds)
-            finally:
-                if orig_tz is None:
-                    del os.environ['TZ']
-                else:
-                    os.environ['TZ'] = orig_tz
-                time.tzset()
-
-        inner.__name__ = func.__name__
-        inner.__doc__ = func.__doc__
-        return inner
-    return decorator
-
-#=======================================================================
-# Big-memory-test support. Separate from 'resources' because memory use
-# should be configurable.
-
-# Some handy shorthands. Note that these are used for byte-limits as well
-# as size-limits, in the various bigmem tests
-_1M = 1024*1024
-_1G = 1024 * _1M
-_2G = 2 * _1G
-_4G = 4 * _1G
-
-MAX_Py_ssize_t = sys.maxsize
-
-def set_memlimit(limit):
-    global max_memuse
-    global real_max_memuse
-    sizes = {
-        'k': 1024,
-        'm': _1M,
-        'g': _1G,
-        't': 1024*_1G,
-    }
-    m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
-                 re.IGNORECASE | re.VERBOSE)
-    if m is None:
-        raise ValueError('Invalid memory limit %r' % (limit,))
-    memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
-    real_max_memuse = memlimit
-    if memlimit > MAX_Py_ssize_t:
-        memlimit = MAX_Py_ssize_t
-    if memlimit < _2G - 1:
-        raise ValueError('Memory limit %r too low to be useful' % (limit,))
-    max_memuse = memlimit
-
-class _MemoryWatchdog:
-    """An object which periodically watches the process' memory consumption
-    and prints it out.
-    """
-
-    def __init__(self):
-        self.procfile = '/proc/{pid}/statm'.format(pid=os.getpid())
-        self.started = False
-
-    def start(self):
-        try:
-            f = open(self.procfile, 'r')
-        except OSError as e:
-            warnings.warn('/proc not available for stats: {}'.format(e),
-                          RuntimeWarning)
-            sys.stderr.flush()
-            return
-
-        watchdog_script = findfile("memory_watchdog.py")
-        self.mem_watchdog = subprocess.Popen([sys.executable, watchdog_script],
-                                             stdin=f, stderr=subprocess.DEVNULL)
-        f.close()
-        self.started = True
-
-    def stop(self):
-        if self.started:
-            self.mem_watchdog.terminate()
-            self.mem_watchdog.wait()
-
-
-def bigmemtest(size, memuse, dry_run=True):
-    """Decorator for bigmem tests.
-
-    'minsize' is the minimum useful size for the test (in arbitrary,
-    test-interpreted units.) 'memuse' is the number of 'bytes per size' for
-    the test, or a good estimate of it.
-
-    if 'dry_run' is False, it means the test doesn't support dummy runs
-    when -M is not specified.
-    """
-    def decorator(f):
-        def wrapper(self):
-            size = wrapper.size
-            memuse = wrapper.memuse
-            if not real_max_memuse:
-                maxsize = 5147
-            else:
-                maxsize = size
-
-            if ((real_max_memuse or not dry_run)
-                and real_max_memuse < maxsize * memuse):
-                raise unittest.SkipTest(
-                    "not enough memory: %.1fG minimum needed"
-                    % (size * memuse / (1024 ** 3)))
-
-            if real_max_memuse and verbose:
-                print()
-                print(" ... expected peak memory use: {peak:.1f}G"
-                      .format(peak=size * memuse / (1024 ** 3)))
-                watchdog = _MemoryWatchdog()
-                watchdog.start()
-            else:
-                watchdog = None
-
-            try:
-                return f(self, maxsize)
-            finally:
-                if watchdog:
-                    watchdog.stop()
-
-        wrapper.size = size
-        wrapper.memuse = memuse
-        return wrapper
-    return decorator
-
-def bigaddrspacetest(f):
-    """Decorator for tests that fill the address space."""
-    def wrapper(self):
-        if max_memuse < MAX_Py_ssize_t:
-            if MAX_Py_ssize_t >= 2**63 - 1 and max_memuse >= 2**31:
-                raise unittest.SkipTest(
-                    "not enough memory: try a 32-bit build instead")
-            else:
-                raise unittest.SkipTest(
-                    "not enough memory: %.1fG minimum needed"
-                    % (MAX_Py_ssize_t / (1024 ** 3)))
-        else:
-            return f(self)
-    return wrapper
-
-#=======================================================================
-# unittest integration.
-
-class BasicTestRunner:
-    def run(self, test):
-        result = unittest.TestResult()
-        test(result)
-        return result
-
-def _id(obj):
-    return obj
-
-def requires_resource(resource):
-    if resource == 'gui' and not _is_gui_available():
-        return unittest.skip("resource 'gui' is not available")
-    if is_resource_enabled(resource):
-        return _id
-    else:
-        return unittest.skip("resource {0!r} is not enabled".format(resource))
-
-def cpython_only(test):
-    """
-    Decorator for tests only applicable on CPython.
-    """
-    return impl_detail(cpython=True)(test)
-
-def impl_detail(msg=None, **guards):
-    if check_impl_detail(**guards):
-        return _id
-    if msg is None:
-        guardnames, default = _parse_guards(guards)
-        if default:
-            msg = "implementation detail not available on {0}"
-        else:
-            msg = "implementation detail specific to {0}"
-        guardnames = sorted(guardnames.keys())
-        msg = msg.format(' or '.join(guardnames))
-    return unittest.skip(msg)
-
-def _parse_guards(guards):
-    # Returns a tuple ({platform_name: run_me}, default_value)
-    if not guards:
-        return ({'cpython': True}, False)
-    is_true = list(guards.values())[0]
-    assert list(guards.values()) == [is_true] * len(guards)   # all True or all False
-    return (guards, not is_true)
-
-# Use the following check to guard CPython's implementation-specific tests --
-# or to run them only on the implementation(s) guarded by the arguments.
-def check_impl_detail(**guards):
-    """This function returns True or False depending on the host platform.
-       Examples:
-          if check_impl_detail():               # only on CPython (default)
-          if check_impl_detail(jython=True):    # only on Jython
-          if check_impl_detail(cpython=False):  # everywhere except on CPython
-    """
-    guards, default = _parse_guards(guards)
-    return guards.get(platform.python_implementation().lower(), default)
-
-
-def no_tracing(func):
-    """Decorator to temporarily turn off tracing for the duration of a test."""
-    if not hasattr(sys, 'gettrace'):
-        return func
-    else:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            original_trace = sys.gettrace()
-            try:
-                sys.settrace(None)
-                return func(*args, **kwargs)
-            finally:
-                sys.settrace(original_trace)
-        return wrapper
-
-
-def refcount_test(test):
-    """Decorator for tests which involve reference counting.
-
-    To start, the decorator does not run the test if is not run by CPython.
-    After that, any trace function is unset during the test to prevent
-    unexpected refcounts caused by the trace function.
-
-    """
-    return no_tracing(cpython_only(test))
-
-
-def _filter_suite(suite, pred):
-    """Recursively filter test cases in a suite based on a predicate."""
-    newtests = []
-    for test in suite._tests:
-        if isinstance(test, unittest.TestSuite):
-            _filter_suite(test, pred)
-            newtests.append(test)
-        else:
-            if pred(test):
-                newtests.append(test)
-    suite._tests = newtests
-
-def _run_suite(suite):
-    """Run tests from a unittest.TestSuite-derived class."""
-    if verbose:
-        runner = unittest.TextTestRunner(sys.stdout, verbosity=2,
-                                         failfast=failfast)
-    else:
-        runner = BasicTestRunner()
-
-    result = runner.run(suite)
-    if not result.wasSuccessful():
-        if len(result.errors) == 1 and not result.failures:
-            err = result.errors[0][1]
-        elif len(result.failures) == 1 and not result.errors:
-            err = result.failures[0][1]
-        else:
-            err = "multiple errors occurred"
-            if not verbose: err += "; run in verbose mode for details"
-        raise TestFailed(err)
-
-
-def run_unittest(*classes):
-    """Run tests from unittest.TestCase-derived classes."""
-    valid_types = (unittest.TestSuite, unittest.TestCase)
-    suite = unittest.TestSuite()
-    for cls in classes:
-        if isinstance(cls, str):
-            if cls in sys.modules:
-                suite.addTest(unittest.findTestCases(sys.modules[cls]))
-            else:
-                raise ValueError("str arguments must be keys in sys.modules")
-        elif isinstance(cls, valid_types):
-            suite.addTest(cls)
-        else:
-            suite.addTest(unittest.makeSuite(cls))
-    def case_pred(test):
-        if match_tests is None:
-            return True
-        for name in test.id().split("."):
-            if fnmatch.fnmatchcase(name, match_tests):
-                return True
-        return False
-    _filter_suite(suite, case_pred)
-    _run_suite(suite)
-
-#=======================================================================
-# Check for the presence of docstrings.
-
-HAVE_DOCSTRINGS = (check_impl_detail(cpython=False) or
-                   sys.platform == 'win32' or
-                   sysconfig.get_config_var('WITH_DOC_STRINGS'))
-
-requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
-                                          "test requires docstrings")
-
-
-#=======================================================================
-# doctest driver.
-
-def run_doctest(module, verbosity=None, optionflags=0):
-    """Run doctest on the given module.  Return (#failures, #tests).
-
-    If optional argument verbosity is not specified (or is None), pass
-    support's belief about verbosity on to doctest.  Else doctest's
-    usual behavior is used (it searches sys.argv for -v).
-    """
-
-    import doctest
-
-    if verbosity is None:
-        verbosity = verbose
-    else:
-        verbosity = None
-
-    f, t = doctest.testmod(module, verbose=verbosity, optionflags=optionflags)
-    if f:
-        raise TestFailed("%d of %d doctests failed" % (f, t))
-    if verbose:
-        print('doctest (%s) ... %d tests with zero failures' %
-              (module.__name__, t))
-    return f, t
-
-
-#=======================================================================
-# Support for saving and restoring the imported modules.
-
-def modules_setup():
-    return sys.modules.copy(),
-
-def modules_cleanup(oldmodules):
-    # Encoders/decoders are registered permanently within the internal
-    # codec cache. If we destroy the corresponding modules their
-    # globals will be set to None which will trip up the cached functions.
-    encodings = [(k, v) for k, v in sys.modules.items()
-                 if k.startswith('encodings.')]
-    sys.modules.clear()
-    sys.modules.update(encodings)
-    # XXX: This kind of problem can affect more than just encodings. In particular
-    # extension modules (such as _ssl) don't cope with reloading properly.
-    # Really, test modules should be cleaning out the test specific modules they
-    # know they added (ala test_runpy) rather than relying on this function (as
-    # test_importhooks and test_pkg do currently).
-    # Implicitly imported *real* modules should be left alone (see issue 10556).
-    sys.modules.update(oldmodules)
-
-#=======================================================================
-# Threading support to prevent reporting refleaks when running regrtest.py -R
-
-# NOTE: we use thread._count() rather than threading.enumerate() (or the
-# moral equivalent thereof) because a threading.Thread object is still alive
-# until its __bootstrap() method has returned, even after it has been
-# unregistered from the threading module.
-# thread._count(), on the other hand, only gets decremented *after* the
-# __bootstrap() method has returned, which gives us reliable reference counts
-# at the end of a test run.
-
-def threading_setup():
-    if _thread:
-        return _thread._count(), threading._dangling.copy()
-    else:
-        return 1, ()
-
-def threading_cleanup(*original_values):
-    if not _thread:
-        return
-    _MAX_COUNT = 10
-    for count in range(_MAX_COUNT):
-        values = _thread._count(), threading._dangling
-        if values == original_values:
-            break
-        time.sleep(0.1)
-        gc_collect()
-    # XXX print a warning in case of failure?
-
-def reap_threads(func):
-    """Use this function when threads are being used.  This will
-    ensure that the threads are cleaned up even when the test fails.
-    If threading is unavailable this function does nothing.
-    """
-    if not _thread:
-        return func
-
-    @functools.wraps(func)
-    def decorator(*args):
-        key = threading_setup()
-        try:
-            return func(*args)
-        finally:
-            threading_cleanup(*key)
-    return decorator
-
-def reap_children():
-    """Use this function at the end of test_main() whenever sub-processes
-    are started.  This will help ensure that no extra children (zombies)
-    stick around to hog resources and create problems when looking
-    for refleaks.
-    """
-
-    # Reap all our dead child processes so we don't leave zombies around.
-    # These hog resources and might be causing some of the buildbots to die.
-    if hasattr(os, 'waitpid'):
-        any_process = -1
-        while True:
-            try:
-                # This will raise an exception on Windows.  That's ok.
-                pid, status = os.waitpid(any_process, os.WNOHANG)
-                if pid == 0:
-                    break
-            except:
-                break
-
-@contextlib.contextmanager
-def swap_attr(obj, attr, new_val):
-    """Temporary swap out an attribute with a new object.
-
-    Usage:
-        with swap_attr(obj, "attr", 5):
-            ...
-
-        This will set obj.attr to 5 for the duration of the with: block,
-        restoring the old value at the end of the block. If `attr` doesn't
-        exist on `obj`, it will be created and then deleted at the end of the
-        block.
-    """
-    if hasattr(obj, attr):
-        real_val = getattr(obj, attr)
-        setattr(obj, attr, new_val)
-        try:
-            yield
-        finally:
-            setattr(obj, attr, real_val)
-    else:
-        setattr(obj, attr, new_val)
-        try:
-            yield
-        finally:
-            delattr(obj, attr)
-
-@contextlib.contextmanager
-def swap_item(obj, item, new_val):
-    """Temporary swap out an item with a new object.
-
-    Usage:
-        with swap_item(obj, "item", 5):
-            ...
-
-        This will set obj["item"] to 5 for the duration of the with: block,
-        restoring the old value at the end of the block. If `item` doesn't
-        exist on `obj`, it will be created and then deleted at the end of the
-        block.
-    """
-    if item in obj:
-        real_val = obj[item]
-        obj[item] = new_val
-        try:
-            yield
-        finally:
-            obj[item] = real_val
-    else:
-        obj[item] = new_val
-        try:
-            yield
-        finally:
-            del obj[item]
-
-def strip_python_stderr(stderr):
-    """Strip the stderr of a Python process from potential debug output
-    emitted by the interpreter.
-
-    This will typically be run on the result of the communicate() method
-    of a subprocess.Popen object.
-    """
-    stderr = re.sub(br"\[\d+ refs, \d+ blocks\]\r?\n?", b"", stderr).strip()
-    return stderr
-
-def args_from_interpreter_flags():
-    """Return a list of command-line arguments reproducing the current
-    settings in sys.flags and sys.warnoptions."""
-    return subprocess._args_from_interpreter_flags()
-
-#============================================================
-# Support for assertions about logging.
-#============================================================
-
-class TestHandler(logging.handlers.BufferingHandler):
-    def __init__(self, matcher):
-        # BufferingHandler takes a "capacity" argument
-        # so as to know when to flush. As we're overriding
-        # shouldFlush anyway, we can set a capacity of zero.
-        # You can call flush() manually to clear out the
-        # buffer.
-        logging.handlers.BufferingHandler.__init__(self, 0)
-        self.matcher = matcher
-
-    def shouldFlush(self):
-        return False
-
-    def emit(self, record):
-        self.format(record)
-        self.buffer.append(record.__dict__)
-
-    def matches(self, **kwargs):
-        """
-        Look for a saved dict whose keys/values match the supplied arguments.
-        """
-        result = False
-        for d in self.buffer:
-            if self.matcher.matches(d, **kwargs):
-                result = True
-                break
-        return result
-
-class Matcher(object):
-
-    _partial_matches = ('msg', 'message')
-
-    def matches(self, d, **kwargs):
-        """
-        Try to match a single dict with the supplied arguments.
-
-        Keys whose values are strings and which are in self._partial_matches
-        will be checked for partial (i.e. substring) matches. You can extend
-        this scheme to (for example) do regular expression matching, etc.
-        """
-        result = True
-        for k in kwargs:
-            v = kwargs[k]
-            dv = d.get(k)
-            if not self.match_value(k, dv, v):
-                result = False
-                break
-        return result
-
-    def match_value(self, k, dv, v):
-        """
-        Try to match a single stored value (dv) with a supplied value (v).
-        """
-        if type(v) != type(dv):
-            result = False
-        elif type(dv) is not str or k not in self._partial_matches:
-            result = (v == dv)
-        else:
-            result = dv.find(v) >= 0
-        return result
-
-
-_can_symlink = None
-def can_symlink():
-    global _can_symlink
-    if _can_symlink is not None:
-        return _can_symlink
-    symlink_path = TESTFN + "can_symlink"
-    try:
-        os.symlink(TESTFN, symlink_path)
-        can = True
-    except (OSError, NotImplementedError, AttributeError):
-        can = False
-    else:
-        os.remove(symlink_path)
-    _can_symlink = can
-    return can
-
-def skip_unless_symlink(test):
-    """Skip decorator for tests that require functional symlink"""
-    ok = can_symlink()
-    msg = "Requires functional symlink implementation"
-    return test if ok else unittest.skip(msg)(test)
-
-_can_xattr = None
-def can_xattr():
-    global _can_xattr
-    if _can_xattr is not None:
-        return _can_xattr
-    if not hasattr(os, "setxattr"):
-        can = False
-    else:
-        tmp_fp, tmp_name = tempfile.mkstemp()
-        try:
-            with open(TESTFN, "wb") as fp:
-                try:
-                    # TESTFN & tempfile may use different file systems with
-                    # different capabilities
-                    os.setxattr(tmp_fp, b"user.test", b"")
-                    os.setxattr(fp.fileno(), b"user.test", b"")
-                    # Kernels < 2.6.39 don't respect setxattr flags.
-                    kernel_version = platform.release()
-                    m = re.match("2.6.(\d{1,2})", kernel_version)
-                    can = m is None or int(m.group(1)) >= 39
-                except OSError:
-                    can = False
-        finally:
-            unlink(TESTFN)
-            unlink(tmp_name)
-    _can_xattr = can
-    return can
-
-def skip_unless_xattr(test):
-    """Skip decorator for tests that require functional extended attributes"""
-    ok = can_xattr()
-    msg = "no non-broken extended attribute support"
-    return test if ok else unittest.skip(msg)(test)
-
-
-if sys.platform.startswith('win'):
-    @contextlib.contextmanager
-    def suppress_crash_popup():
-        """Disable Windows Error Reporting dialogs using SetErrorMode."""
-        # see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621%28v=vs.85%29.aspx
-        # GetErrorMode is not available on Windows XP and Windows Server 2003,
-        # but SetErrorMode returns the previous value, so we can use that
-        import ctypes
-        k32 = ctypes.windll.kernel32
-        SEM_NOGPFAULTERRORBOX = 0x02
-        old_error_mode = k32.SetErrorMode(SEM_NOGPFAULTERRORBOX)
-        k32.SetErrorMode(old_error_mode | SEM_NOGPFAULTERRORBOX)
-        try:
-            yield
-        finally:
-            k32.SetErrorMode(old_error_mode)
-else:
-    # this is a no-op for other platforms
-    @contextlib.contextmanager
-    def suppress_crash_popup():
-        yield
-
-
-def patch(test_instance, object_to_patch, attr_name, new_value):
-    """Override 'object_to_patch'.'attr_name' with 'new_value'.
-
-    Also, add a cleanup procedure to 'test_instance' to restore
-    'object_to_patch' value for 'attr_name'.
-    The 'attr_name' should be a valid attribute for 'object_to_patch'.
-
-    """
-    # check that 'attr_name' is a real attribute for 'object_to_patch'
-    # will raise AttributeError if it does not exist
-    getattr(object_to_patch, attr_name)
-
-    # keep a copy of the old value
-    attr_is_local = False
-    try:
-        old_value = object_to_patch.__dict__[attr_name]
-    except (AttributeError, KeyError):
-        old_value = getattr(object_to_patch, attr_name, None)
-    else:
-        attr_is_local = True
-
-    # restore the value when the test is done
-    def cleanup():
-        if attr_is_local:
-            setattr(object_to_patch, attr_name, old_value)
-        else:
-            delattr(object_to_patch, attr_name)
-
-    test_instance.addCleanup(cleanup)
-
-    # actually override the attribute
-    setattr(object_to_patch, attr_name, new_value)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_abc.py
--- a/Lib/test/test_abc.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_abc.py	Mon Aug 12 02:18:40 2013 +0200
@@ -65,6 +65,34 @@
         self.assertEqual(D.foo(), 4)
         self.assertEqual(D().foo(), 4)
 
+    def test_abstractmethod_integration(self):
+        for abstractthing in [abc.abstractmethod, abc.abstractproperty,
+                              abc.abstractclassmethod,
+                              abc.abstractstaticmethod]:
+            class C(metaclass=abc.ABCMeta):
+                @abstractthing
+                def foo(self): pass  # abstract
+                def bar(self): pass  # concrete
+            self.assertEqual(C.__abstractmethods__, {"foo"})
+            self.assertRaises(TypeError, C)  # because foo is abstract
+            self.assertTrue(isabstract(C))
+            class D(C):
+                def bar(self): pass  # concrete override of concrete
+            self.assertEqual(D.__abstractmethods__, {"foo"})
+            self.assertRaises(TypeError, D)  # because foo is still abstract
+            self.assertTrue(isabstract(D))
+            class E(D):
+                def foo(self): pass
+            self.assertEqual(E.__abstractmethods__, set())
+            E()  # now foo is concrete, too
+            self.assertFalse(isabstract(E))
+            class F(E):
+                @abstractthing
+                def bar(self): pass  # abstract override of concrete
+            self.assertEqual(F.__abstractmethods__, {"bar"})
+            self.assertRaises(TypeError, F)  # because bar is abstract now
+            self.assertTrue(isabstract(F))
+
 
 class TestABC(unittest.TestCase):
 
@@ -404,5 +432,9 @@
         self.assertEqual(B.counter, 1)
 
 
+def test_main():
+    support.run_unittest(TestABC)
+
+
 if __name__ == "__main__":
     unittest.main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_asyncore.py
--- a/Lib/test/test_asyncore.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_asyncore.py	Mon Aug 12 02:18:40 2013 +0200
@@ -745,7 +745,12 @@
         s.create_socket(self.family)
         self.assertEqual(s.socket.family, self.family)
         SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', 0)
-        self.assertEqual(s.socket.type, socket.SOCK_STREAM | SOCK_NONBLOCK)
+        sock_type = socket.SOCK_STREAM | SOCK_NONBLOCK
+        if hasattr(socket, 'SOCK_CLOEXEC'):
+            self.assertIn(s.socket.type,
+                          (sock_type | socket.SOCK_CLOEXEC, sock_type))
+        else:
+            self.assertEqual(s.socket.type, sock_type)
 
     def test_bind(self):
         if HAS_UNIX_SOCKETS and self.family == socket.AF_UNIX:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_atexit.py
--- a/Lib/test/test_atexit.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_atexit.py	Mon Aug 12 02:18:40 2013 +0200
@@ -2,7 +2,6 @@
 import unittest
 import io
 import atexit
-import _testcapi
 from test import support
 
 ### helpers
@@ -24,9 +23,7 @@
 def raise2():
     raise SystemError
 
-
-class GeneralTest(unittest.TestCase):
-
+class TestCase(unittest.TestCase):
     def setUp(self):
         self.save_stdout = sys.stdout
         self.save_stderr = sys.stderr
@@ -125,43 +122,8 @@
         self.assertEqual(l, [5])
 
 
-class SubinterpreterTest(unittest.TestCase):
-
-    def test_callbacks_leak(self):
-        # This test shows a leak in refleak mode if atexit doesn't
-        # take care to free callbacks in its per-subinterpreter module
-        # state.
-        n = atexit._ncallbacks()
-        code = r"""if 1:
-            import atexit
-            def f():
-                pass
-            atexit.register(f)
-            del atexit
-            """
-        ret = _testcapi.run_in_subinterp(code)
-        self.assertEqual(ret, 0)
-        self.assertEqual(atexit._ncallbacks(), n)
-
-    def test_callbacks_leak_refcycle(self):
-        # Similar to the above, but with a refcycle through the atexit
-        # module.
-        n = atexit._ncallbacks()
-        code = r"""if 1:
-            import atexit
-            def f():
-                pass
-            atexit.register(f)
-            atexit.__atexit = atexit
-            """
-        ret = _testcapi.run_in_subinterp(code)
-        self.assertEqual(ret, 0)
-        self.assertEqual(atexit._ncallbacks(), n)
-
-
 def test_main():
-    support.run_unittest(__name__)
-
+    support.run_unittest(TestCase)
 
 if __name__ == "__main__":
     test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_builtin.py
--- a/Lib/test/test_builtin.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_builtin.py	Mon Aug 12 02:18:40 2013 +0200
@@ -976,29 +976,24 @@
     def write_testfile(self):
         # NB the first 4 lines are also used to test input, below
         fp = open(TESTFN, 'w')
-        try:
+        self.addCleanup(unlink, TESTFN)
+        with fp:
             fp.write('1+1\n')
             fp.write('The quick brown fox jumps over the lazy dog')
             fp.write('.\n')
             fp.write('Dear John\n')
             fp.write('XXX'*100)
             fp.write('YYY'*100)
-        finally:
-            fp.close()
 
     def test_open(self):
         self.write_testfile()
-        fp = open(TESTFN, 'r')
-        try:
+        with open(TESTFN, 'r') as fp:
             self.assertEqual(fp.readline(4), '1+1\n')
             self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
             self.assertEqual(fp.readline(4), 'Dear')
             self.assertEqual(fp.readline(100), ' John\n')
             self.assertEqual(fp.read(300), 'XXX'*100)
             self.assertEqual(fp.read(1000), 'YYY'*100)
-        finally:
-            fp.close()
-            unlink(TESTFN)
 
     def test_open_default_encoding(self):
         old_environ = dict(os.environ)
@@ -1012,16 +1007,20 @@
 
             self.write_testfile()
             current_locale_encoding = locale.getpreferredencoding(False)
-            fp = open(TESTFN, 'w')
-            try:
+            with open(TESTFN, 'w') as fp:
                 self.assertEqual(fp.encoding, current_locale_encoding)
-            finally:
-                fp.close()
-                unlink(TESTFN)
         finally:
             os.environ.clear()
             os.environ.update(old_environ)
 
+    @unittest.skipUnless(hasattr(os, "get_inheritable"),
+                         "need os.get_inheritable()")
+    def test_open_cloexec(self):
+        self.write_testfile()
+        fileobj = open(TESTFN)
+        with fileobj:
+            self.assertEqual(os.get_inheritable(fileobj.fileno()), False)
+
     def test_ord(self):
         self.assertEqual(ord(' '), 32)
         self.assertEqual(ord('A'), 65)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_capi.py
--- a/Lib/test/test_capi.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_capi.py	Mon Aug 12 02:18:40 2013 +0200
@@ -193,9 +193,6 @@
         self.pendingcalls_submit(l, n)
         self.pendingcalls_wait(l, n)
 
-
-class SubinterpreterTest(unittest.TestCase):
-
     def test_subinterps(self):
         import builtins
         r, w = os.pipe()
@@ -211,7 +208,6 @@
             self.assertNotEqual(pickle.load(f), id(sys.modules))
             self.assertNotEqual(pickle.load(f), id(builtins))
 
-
 # Bug #6012
 class Test6012(unittest.TestCase):
     def test(self):
@@ -358,8 +354,7 @@
 
 def test_main():
     support.run_unittest(CAPITest, TestPendingCalls, Test6012,
-                         EmbeddingTest, SkipitemTest, TestThreadState,
-                         SubinterpreterTest)
+                         EmbeddingTest, SkipitemTest, TestThreadState)
 
     for name in dir(_testcapi):
         if name.startswith('test_'):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_cmd_line.py
--- a/Lib/test/test_cmd_line.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_cmd_line.py	Mon Aug 12 02:18:40 2013 +0200
@@ -4,7 +4,6 @@
 
 import test.support, unittest
 import os
-import shutil
 import sys
 import subprocess
 import tempfile
@@ -440,31 +439,6 @@
         self.assertEqual(b'', out)
 
 
-    def test_isolatedmode(self):
-        self.verify_valid_flag('-I')
-        self.verify_valid_flag('-IEs')
-        rc, out, err = assert_python_ok('-I', '-c',
-            'from sys import flags as f; '
-            'print(f.no_user_site, f.ignore_environment, f.isolated)',
-            # dummyvar to prevent extranous -E
-            dummyvar="")
-        self.assertEqual(out.strip(), b'1 1 1')
-        with test.support.temp_cwd() as tmpdir:
-            fake = os.path.join(tmpdir, "uuid.py")
-            main = os.path.join(tmpdir, "main.py")
-            with open(fake, "w") as f:
-                f.write("raise RuntimeError('isolated mode test')\n")
-            with open(main, "w") as f:
-                f.write("import uuid\n")
-                f.write("print('ok')\n")
-            self.assertRaises(subprocess.CalledProcessError,
-                              subprocess.check_output,
-                              [sys.executable, main], cwd=tmpdir,
-                              stderr=subprocess.DEVNULL)
-            out = subprocess.check_output([sys.executable, "-I", main],
-                                          cwd=tmpdir)
-            self.assertEqual(out.strip(), b"ok")
-
 def test_main():
     test.support.run_unittest(CmdLineTest)
     test.support.reap_children()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_cmd_line_script.py
--- a/Lib/test/test_cmd_line_script.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_cmd_line_script.py	Mon Aug 12 02:18:40 2013 +0200
@@ -290,7 +290,7 @@
         # Make sure package __init__ modules see "-m" in sys.argv0 while
         # searching for the module to execute
         with temp_dir() as script_dir:
-            with support.change_cwd(path=script_dir):
+            with support.temp_cwd(path=script_dir):
                 pkg_dir = os.path.join(script_dir, 'test_pkg')
                 make_pkg(pkg_dir, "import sys; print('init_argv0==%r' % sys.argv[0])")
                 script_name = _make_test_script(pkg_dir, 'script')
@@ -307,7 +307,7 @@
         # Make sure a "-c" file in the current directory
         # does not alter the value of sys.path[0]
         with temp_dir() as script_dir:
-            with support.change_cwd(path=script_dir):
+            with support.temp_cwd(path=script_dir):
                 with open("-c", "w") as f:
                     f.write("data")
                     rc, out, err = assert_python_ok('-c',
@@ -322,7 +322,7 @@
         # does not alter the value of sys.path[0]
         with temp_dir() as script_dir:
             script_name = _make_test_script(script_dir, 'other')
-            with support.change_cwd(path=script_dir):
+            with support.temp_cwd(path=script_dir):
                 with open("-m", "w") as f:
                     f.write("data")
                     rc, out, err = assert_python_ok('-m', 'other', *example_args)
@@ -335,7 +335,7 @@
         # and results in an error that the return code to the
         # shell is '1'
         with temp_dir() as script_dir:
-            with support.change_cwd(path=script_dir):
+            with support.temp_cwd(path=script_dir):
                 pkg_dir = os.path.join(script_dir, 'test_pkg')
                 make_pkg(pkg_dir)
                 script_name = _make_test_script(pkg_dir, 'other',
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_colorsys.py
--- a/Lib/test/test_colorsys.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_colorsys.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,4 +1,4 @@
-import unittest
+import unittest, test.support
 import colorsys
 
 def frange(start, stop, step):
@@ -69,32 +69,8 @@
             self.assertTripleEqual(hls, colorsys.rgb_to_hls(*rgb))
             self.assertTripleEqual(rgb, colorsys.hls_to_rgb(*hls))
 
-    def test_yiq_roundtrip(self):
-        for r in frange(0.0, 1.0, 0.2):
-            for g in frange(0.0, 1.0, 0.2):
-                for b in frange(0.0, 1.0, 0.2):
-                    rgb = (r, g, b)
-                    self.assertTripleEqual(
-                        rgb,
-                        colorsys.yiq_to_rgb(*colorsys.rgb_to_yiq(*rgb))
-                    )
-
-    def test_yiq_values(self):
-        values = [
-            # rgb, yiq
-            ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0)), # black
-            ((0.0, 0.0, 1.0), (0.11, -0.3217, 0.3121)), # blue
-            ((0.0, 1.0, 0.0), (0.59, -0.2773, -0.5251)), # green
-            ((0.0, 1.0, 1.0), (0.7, -0.599, -0.213)), # cyan
-            ((1.0, 0.0, 0.0), (0.3, 0.599, 0.213)), # red
-            ((1.0, 0.0, 1.0), (0.41, 0.2773, 0.5251)), # purple
-            ((1.0, 1.0, 0.0), (0.89, 0.3217, -0.3121)), # yellow
-            ((1.0, 1.0, 1.0), (1.0, 0.0, 0.0)), # white
-            ((0.5, 0.5, 0.5), (0.5, 0.0, 0.0)), # grey
-        ]
-        for (rgb, yiq) in values:
-            self.assertTripleEqual(yiq, colorsys.rgb_to_yiq(*rgb))
-            self.assertTripleEqual(rgb, colorsys.yiq_to_rgb(*yiq))
+def test_main():
+    test.support.run_unittest(ColorsysTest)
 
 if __name__ == "__main__":
-    unittest.main()
+    test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_deque.py
--- a/Lib/test/test_deque.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_deque.py	Mon Aug 12 02:18:40 2013 +0200
@@ -536,7 +536,7 @@
 
     @support.cpython_only
     def test_sizeof(self):
-        BLOCKLEN = 62
+        BLOCKLEN = 64
         basesize = support.calcobjsize('2P4nlP')
         blocksize = struct.calcsize('2P%dP' % BLOCKLEN)
         self.assertEqual(object.__sizeof__(deque()), basesize)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_descr.py
--- a/Lib/test/test_descr.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_descr.py	Mon Aug 12 02:18:40 2013 +0200
@@ -3736,8 +3736,18 @@
         # bug).
         del c
 
+        # If that didn't blow up, it's also interesting to see whether clearing
+        # the last container slot works: that will attempt to delete c again,
+        # which will cause c to get appended back to the container again
+        # "during" the del.  (On non-CPython implementations, however, __del__
+        # is typically not called again.)
         support.gc_collect()
         self.assertEqual(len(C.container), 1)
+        del C.container[-1]
+        if support.check_impl_detail():
+            support.gc_collect()
+            self.assertEqual(len(C.container), 1)
+            self.assertEqual(C.container[-1].attr, 42)
 
         # Make c mortal again, so that the test framework with -l doesn't report
         # it as a leak.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_dictviews.py
--- a/Lib/test/test_dictviews.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_dictviews.py	Mon Aug 12 02:18:40 2013 +0200
@@ -112,13 +112,6 @@
         self.assertEqual(d1.keys() ^ set(d3.keys()),
                          {'a', 'b', 'd', 'e'})
 
-        self.assertEqual(d1.keys() - d1.keys(), set())
-        self.assertEqual(d1.keys() - d2.keys(), {'a'})
-        self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'})
-        self.assertEqual(d1.keys() - set(d1.keys()), set())
-        self.assertEqual(d1.keys() - set(d2.keys()), {'a'})
-        self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'})
-
         self.assertFalse(d1.keys().isdisjoint(d1.keys()))
         self.assertFalse(d1.keys().isdisjoint(d2.keys()))
         self.assertFalse(d1.keys().isdisjoint(list(d2.keys())))
@@ -169,13 +162,6 @@
         self.assertEqual(d1.items() ^ d3.items(),
                          {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
 
-        self.assertEqual(d1.items() - d1.items(), set())
-        self.assertEqual(d1.items() - d2.items(), {('a', 1)})
-        self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)})
-        self.assertEqual(d1.items() - set(d1.items()), set())
-        self.assertEqual(d1.items() - set(d2.items()), {('a', 1)})
-        self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)})
-
         self.assertFalse(d1.items().isdisjoint(d1.items()))
         self.assertFalse(d1.items().isdisjoint(d2.items()))
         self.assertFalse(d1.items().isdisjoint(list(d2.items())))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_docxmlrpc.py
--- a/Lib/test/test_docxmlrpc.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_docxmlrpc.py	Mon Aug 12 02:18:40 2013 +0200
@@ -54,18 +54,8 @@
             """
             return x + y
 
-        def annotation(x: int):
-            """ Use function annotations. """
-            return x
-
-        class ClassWithAnnotation:
-            def method_annotation(self, x: bytes):
-                return x.decode()
-
         serv.register_function(add)
         serv.register_function(lambda x, y: x-y)
-        serv.register_function(annotation)
-        serv.register_instance(ClassWithAnnotation())
 
         while numrequests > 0:
             serv.handle_request()
@@ -187,7 +177,10 @@
              b'method&nbsp;takes&nbsp;two&nbsp;integers&nbsp;as&nbsp;arguments'
              b'<br>\nand&nbsp;returns&nbsp;a&nbsp;double&nbsp;result.<br>\n&nbsp;'
              b'<br>\nThis&nbsp;server&nbsp;does&nbsp;NOT&nbsp;support&nbsp;system'
-             b'.methodSignature.</tt></dd></dl>'), response)
+             b'.methodSignature.</tt></dd></dl>\n<dl><dt><a name="-test_method">'
+             b'<strong>test_method</strong></a>(arg)</dt><dd><tt>Test&nbsp;'
+             b'method\'s&nbsp;docs.&nbsp;This&nbsp;method&nbsp;truly&nbsp;does'
+             b'&nbsp;very&nbsp;little.</tt></dd></dl>'), response)
 
     def test_autolink_dotted_methods(self):
         """Test that selfdot values are made strong automatically in the
@@ -198,18 +191,6 @@
         self.assertIn(b"""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""",
                       response.read())
 
-    def test_annotations(self):
-        """ Test that annotations works as expected """
-        self.client.request("GET", "/")
-        response = self.client.getresponse()
-        self.assertIn(
-            (b'<dl><dt><a name="-annotation"><strong>annotation</strong></a>'
-             b'(x: int)</dt><dd><tt>Use&nbsp;function&nbsp;annotations.</tt>'
-             b'</dd></dl>\n<dl><dt><a name="-method_annotation"><strong>'
-             b'method_annotation</strong></a>(x: bytes)</dt></dl>'),
-            response.read())
-
-
 def test_main():
     support.run_unittest(DocXMLRPCHTTPGETServer)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_email/test_email.py
--- a/Lib/test/test_email/test_email.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_email/test_email.py	Mon Aug 12 02:18:40 2013 +0200
@@ -249,42 +249,15 @@
         self.assertTrue('TO' in msg)
 
     def test_as_string(self):
+        eq = self.ndiffAssertEqual
         msg = self._msgobj('msg_01.txt')
         with openfile('msg_01.txt') as fp:
             text = fp.read()
-        self.assertEqual(text, str(msg))
+        eq(text, str(msg))
         fullrepr = msg.as_string(unixfrom=True)
         lines = fullrepr.split('\n')
         self.assertTrue(lines[0].startswith('From '))
-        self.assertEqual(text, NL.join(lines[1:]))
-
-    def test_as_string_policy(self):
-        msg = self._msgobj('msg_01.txt')
-        newpolicy = msg.policy.clone(linesep='\r\n')
-        fullrepr = msg.as_string(policy=newpolicy)
-        s = StringIO()
-        g = Generator(s, policy=newpolicy)
-        g.flatten(msg)
-        self.assertEqual(fullrepr, s.getvalue())
-
-    def test_as_bytes(self):
-        msg = self._msgobj('msg_01.txt')
-        with openfile('msg_01.txt', 'rb') as fp:
-            data = fp.read()
-        self.assertEqual(data, bytes(msg))
-        fullrepr = msg.as_bytes(unixfrom=True)
-        lines = fullrepr.split(b'\n')
-        self.assertTrue(lines[0].startswith(b'From '))
-        self.assertEqual(data, b'\n'.join(lines[1:]))
-
-    def test_as_bytes_policy(self):
-        msg = self._msgobj('msg_01.txt')
-        newpolicy = msg.policy.clone(linesep='\r\n')
-        fullrepr = msg.as_bytes(policy=newpolicy)
-        s = BytesIO()
-        g = BytesGenerator(s,policy=newpolicy)
-        g.flatten(msg)
-        self.assertEqual(fullrepr, s.getvalue())
+        eq(text, NL.join(lines[1:]))
 
     # test_headerregistry.TestContentTypeHeader.bad_params
     def test_bad_param(self):
@@ -953,7 +926,7 @@
 This is a long line that has two whitespaces  in a row.  This used to cause
  truncation of the header when folded""")
 
-    def test_splitter_split_on_punctuation_only_if_fws_with_header(self):
+    def test_splitter_split_on_punctuation_only_if_fws(self):
         eq = self.ndiffAssertEqual
         h = Header('thisverylongheaderhas;semicolons;and,commas,but'
             'they;arenotlegal;fold,points')
@@ -4241,6 +4214,9 @@
         self._test_encode('x' * 200 + '\n',
                 2 * ('x' * 75 + '=\n') + 'x' * 50 + '\n')
 
+    def test_encode_one_long_line(self):
+        self._test_encode('x' * 100 + '\n', 'x' * 75 + '=\n' + 'x' * 25 + '\n')
+
     def test_encode_shortest_maxlinelen(self):
         self._test_encode('=' * 5, '=3D=\n' * 4 + '=3D', maxlinelen=4)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_enum.py
--- a/Lib/test/test_enum.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_enum.py	Mon Aug 12 02:18:40 2013 +0200
@@ -78,6 +78,21 @@
     def test_intenum_value(self):
         self.assertEqual(IntStooges.CURLY.value, 2)
 
+    def test_dir_on_class(self):
+        Season = self.Season
+        self.assertEqual(
+            set(dir(Season)),
+            set(['__class__', '__doc__', '__members__',
+                'SPRING', 'SUMMER', 'AUTUMN', 'WINTER']),
+            )
+
+    def test_dir_on_item(self):
+        Season = self.Season
+        self.assertEqual(
+            set(dir(Season.WINTER)),
+            set(['__class__', '__doc__', 'name', 'value']),
+            )
+
     def test_enum(self):
         Season = self.Season
         lst = list(Season)
@@ -568,24 +583,6 @@
             option3 = 3
         self.assertEqual(int(MailManOptions.option1), 1)
 
-    def test_introspection(self):
-        class Number(IntEnum):
-            one = 100
-            two = 200
-        self.assertIs(Number.one._member_type_, int)
-        self.assertIs(Number._member_type_, int)
-        class String(str, Enum):
-            yarn = 'soft'
-            rope = 'rough'
-            wire = 'hard'
-        self.assertIs(String.yarn._member_type_, str)
-        self.assertIs(String._member_type_, str)
-        class Plain(Enum):
-            vanilla = 'white'
-            one = 1
-        self.assertIs(Plain.vanilla._member_type_, object)
-        self.assertIs(Plain._member_type_, object)
-
     def test_no_such_enum_member(self):
         class Color(Enum):
             red = 1
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_fcntl.py
--- a/Lib/test/test_fcntl.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_fcntl.py	Mon Aug 12 02:18:40 2013 +0200
@@ -32,8 +32,6 @@
             pid_t = 'l'
         lockdata = struct.pack(off_t + off_t + pid_t + 'hh', 0, 0, 0,
                                fcntl.F_WRLCK, 0)
-    elif sys.platform.startswith('gnukfreebsd'):
-        lockdata = struct.pack('qqihhi', 0, 0, 0, fcntl.F_WRLCK, 0, 0)
     elif sys.platform in ['aix3', 'aix4', 'hp-uxB', 'unixware7']:
         lockdata = struct.pack('hhlllii', fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
     else:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_finalization.py
--- a/Lib/test/test_finalization.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,513 +0,0 @@
-"""
-Tests for object finalization semantics, as outlined in PEP 442.
-"""
-
-import contextlib
-import gc
-import unittest
-import weakref
-
-import _testcapi
-from test import support
-
-
-class NonGCSimpleBase:
-    """
-    The base class for all the objects under test, equipped with various
-    testing features.
-    """
-
-    survivors = []
-    del_calls = []
-    tp_del_calls = []
-    errors = []
-
-    _cleaning = False
-
-    __slots__ = ()
-
-    @classmethod
-    def _cleanup(cls):
-        cls.survivors.clear()
-        cls.errors.clear()
-        gc.garbage.clear()
-        gc.collect()
-        cls.del_calls.clear()
-        cls.tp_del_calls.clear()
-
-    @classmethod
-    @contextlib.contextmanager
-    def test(cls):
-        """
-        A context manager to use around all finalization tests.
-        """
-        with support.disable_gc():
-            cls.del_calls.clear()
-            cls.tp_del_calls.clear()
-            NonGCSimpleBase._cleaning = False
-            try:
-                yield
-                if cls.errors:
-                    raise cls.errors[0]
-            finally:
-                NonGCSimpleBase._cleaning = True
-                cls._cleanup()
-
-    def check_sanity(self):
-        """
-        Check the object is sane (non-broken).
-        """
-
-    def __del__(self):
-        """
-        PEP 442 finalizer.  Record that this was called, check the
-        object is in a sane state, and invoke a side effect.
-        """
-        try:
-            if not self._cleaning:
-                self.del_calls.append(id(self))
-                self.check_sanity()
-                self.side_effect()
-        except Exception as e:
-            self.errors.append(e)
-
-    def side_effect(self):
-        """
-        A side effect called on destruction.
-        """
-
-
-class SimpleBase(NonGCSimpleBase):
-
-    def __init__(self):
-        self.id_ = id(self)
-
-    def check_sanity(self):
-        assert self.id_ == id(self)
-
-
-class NonGC(NonGCSimpleBase):
-    __slots__ = ()
-
-class NonGCResurrector(NonGCSimpleBase):
-    __slots__ = ()
-
-    def side_effect(self):
-        """
-        Resurrect self by storing self in a class-wide list.
-        """
-        self.survivors.append(self)
-
-class Simple(SimpleBase):
-    pass
-
-class SimpleResurrector(NonGCResurrector, SimpleBase):
-    pass
-
-
-class TestBase:
-
-    def setUp(self):
-        self.old_garbage = gc.garbage[:]
-        gc.garbage[:] = []
-
-    def tearDown(self):
-        # None of the tests here should put anything in gc.garbage
-        try:
-            self.assertEqual(gc.garbage, [])
-        finally:
-            del self.old_garbage
-            gc.collect()
-
-    def assert_del_calls(self, ids):
-        self.assertEqual(sorted(SimpleBase.del_calls), sorted(ids))
-
-    def assert_tp_del_calls(self, ids):
-        self.assertEqual(sorted(SimpleBase.tp_del_calls), sorted(ids))
-
-    def assert_survivors(self, ids):
-        self.assertEqual(sorted(id(x) for x in SimpleBase.survivors), sorted(ids))
-
-    def assert_garbage(self, ids):
-        self.assertEqual(sorted(id(x) for x in gc.garbage), sorted(ids))
-
-    def clear_survivors(self):
-        SimpleBase.survivors.clear()
-
-
-class SimpleFinalizationTest(TestBase, unittest.TestCase):
-    """
-    Test finalization without refcycles.
-    """
-
-    def test_simple(self):
-        with SimpleBase.test():
-            s = Simple()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-
-    def test_simple_resurrect(self):
-        with SimpleBase.test():
-            s = SimpleResurrector()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors(ids)
-            self.assertIsNot(wr(), None)
-            self.clear_survivors()
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-        self.assertIs(wr(), None)
-
-    def test_non_gc(self):
-        with SimpleBase.test():
-            s = NonGC()
-            self.assertFalse(gc.is_tracked(s))
-            ids = [id(s)]
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-
-    def test_non_gc_resurrect(self):
-        with SimpleBase.test():
-            s = NonGCResurrector()
-            self.assertFalse(gc.is_tracked(s))
-            ids = [id(s)]
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors(ids)
-            self.clear_survivors()
-            gc.collect()
-            self.assert_del_calls(ids * 2)
-            self.assert_survivors(ids)
-
-
-class SelfCycleBase:
-
-    def __init__(self):
-        super().__init__()
-        self.ref = self
-
-    def check_sanity(self):
-        super().check_sanity()
-        assert self.ref is self
-
-class SimpleSelfCycle(SelfCycleBase, Simple):
-    pass
-
-class SelfCycleResurrector(SelfCycleBase, SimpleResurrector):
-    pass
-
-class SuicidalSelfCycle(SelfCycleBase, Simple):
-
-    def side_effect(self):
-        """
-        Explicitly break the reference cycle.
-        """
-        self.ref = None
-
-
-class SelfCycleFinalizationTest(TestBase, unittest.TestCase):
-    """
-    Test finalization of an object having a single cyclic reference to
-    itself.
-    """
-
-    def test_simple(self):
-        with SimpleBase.test():
-            s = SimpleSelfCycle()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-
-    def test_simple_resurrect(self):
-        # Test that __del__ can resurrect the object being finalized.
-        with SimpleBase.test():
-            s = SelfCycleResurrector()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors(ids)
-            # XXX is this desirable?
-            self.assertIs(wr(), None)
-            # When trying to destroy the object a second time, __del__
-            # isn't called anymore (and the object isn't resurrected).
-            self.clear_survivors()
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-
-    def test_simple_suicide(self):
-        # Test the GC is able to deal with an object that kills its last
-        # reference during __del__.
-        with SimpleBase.test():
-            s = SuicidalSelfCycle()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-
-
-class ChainedBase:
-
-    def chain(self, left):
-        self.suicided = False
-        self.left = left
-        left.right = self
-
-    def check_sanity(self):
-        super().check_sanity()
-        if self.suicided:
-            assert self.left is None
-            assert self.right is None
-        else:
-            left = self.left
-            if left.suicided:
-                assert left.right is None
-            else:
-                assert left.right is self
-            right = self.right
-            if right.suicided:
-                assert right.left is None
-            else:
-                assert right.left is self
-
-class SimpleChained(ChainedBase, Simple):
-    pass
-
-class ChainedResurrector(ChainedBase, SimpleResurrector):
-    pass
-
-class SuicidalChained(ChainedBase, Simple):
-
-    def side_effect(self):
-        """
-        Explicitly break the reference cycle.
-        """
-        self.suicided = True
-        self.left = None
-        self.right = None
-
-
-class CycleChainFinalizationTest(TestBase, unittest.TestCase):
-    """
-    Test finalization of a cyclic chain.  These tests are similar in
-    spirit to the self-cycle tests above, but the collectable object
-    graph isn't trivial anymore.
-    """
-
-    def build_chain(self, classes):
-        nodes = [cls() for cls in classes]
-        for i in range(len(nodes)):
-            nodes[i].chain(nodes[i-1])
-        return nodes
-
-    def check_non_resurrecting_chain(self, classes):
-        N = len(classes)
-        with SimpleBase.test():
-            nodes = self.build_chain(classes)
-            ids = [id(s) for s in nodes]
-            wrs = [weakref.ref(s) for s in nodes]
-            del nodes
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-            self.assertEqual([wr() for wr in wrs], [None] * N)
-            gc.collect()
-            self.assert_del_calls(ids)
-
-    def check_resurrecting_chain(self, classes):
-        N = len(classes)
-        with SimpleBase.test():
-            nodes = self.build_chain(classes)
-            N = len(nodes)
-            ids = [id(s) for s in nodes]
-            survivor_ids = [id(s) for s in nodes if isinstance(s, SimpleResurrector)]
-            wrs = [weakref.ref(s) for s in nodes]
-            del nodes
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors(survivor_ids)
-            # XXX desirable?
-            self.assertEqual([wr() for wr in wrs], [None] * N)
-            self.clear_survivors()
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_survivors([])
-
-    def test_homogenous(self):
-        self.check_non_resurrecting_chain([SimpleChained] * 3)
-
-    def test_homogenous_resurrect(self):
-        self.check_resurrecting_chain([ChainedResurrector] * 3)
-
-    def test_homogenous_suicidal(self):
-        self.check_non_resurrecting_chain([SuicidalChained] * 3)
-
-    def test_heterogenous_suicidal_one(self):
-        self.check_non_resurrecting_chain([SuicidalChained, SimpleChained] * 2)
-
-    def test_heterogenous_suicidal_two(self):
-        self.check_non_resurrecting_chain(
-            [SuicidalChained] * 2 + [SimpleChained] * 2)
-
-    def test_heterogenous_resurrect_one(self):
-        self.check_resurrecting_chain([ChainedResurrector, SimpleChained] * 2)
-
-    def test_heterogenous_resurrect_two(self):
-        self.check_resurrecting_chain(
-            [ChainedResurrector, SimpleChained, SuicidalChained] * 2)
-
-    def test_heterogenous_resurrect_three(self):
-        self.check_resurrecting_chain(
-            [ChainedResurrector] * 2 + [SimpleChained] * 2 + [SuicidalChained] * 2)
-
-
-# NOTE: the tp_del slot isn't automatically inherited, so we have to call
-# with_tp_del() for each instantiated class.
-
-class LegacyBase(SimpleBase):
-
-    def __del__(self):
-        try:
-            # Do not invoke side_effect here, since we are now exercising
-            # the tp_del slot.
-            if not self._cleaning:
-                self.del_calls.append(id(self))
-                self.check_sanity()
-        except Exception as e:
-            self.errors.append(e)
-
-    def __tp_del__(self):
-        """
-        Legacy (pre-PEP 442) finalizer, mapped to a tp_del slot.
-        """
-        try:
-            if not self._cleaning:
-                self.tp_del_calls.append(id(self))
-                self.check_sanity()
-                self.side_effect()
-        except Exception as e:
-            self.errors.append(e)
-
-@_testcapi.with_tp_del
-class Legacy(LegacyBase):
-    pass
-
-@_testcapi.with_tp_del
-class LegacyResurrector(LegacyBase):
-
-    def side_effect(self):
-        """
-        Resurrect self by storing self in a class-wide list.
-        """
-        self.survivors.append(self)
-
-@_testcapi.with_tp_del
-class LegacySelfCycle(SelfCycleBase, LegacyBase):
-    pass
-
-
-class LegacyFinalizationTest(TestBase, unittest.TestCase):
-    """
-    Test finalization of objects with a tp_del.
-    """
-
-    def tearDown(self):
-        # These tests need to clean up a bit more, since they create
-        # uncollectable objects.
-        gc.garbage.clear()
-        gc.collect()
-        super().tearDown()
-
-    def test_legacy(self):
-        with SimpleBase.test():
-            s = Legacy()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_tp_del_calls(ids)
-            self.assert_survivors([])
-            self.assertIs(wr(), None)
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_tp_del_calls(ids)
-
-    def test_legacy_resurrect(self):
-        with SimpleBase.test():
-            s = LegacyResurrector()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_tp_del_calls(ids)
-            self.assert_survivors(ids)
-            # weakrefs are cleared before tp_del is called.
-            self.assertIs(wr(), None)
-            self.clear_survivors()
-            gc.collect()
-            self.assert_del_calls(ids)
-            self.assert_tp_del_calls(ids * 2)
-            self.assert_survivors(ids)
-        self.assertIs(wr(), None)
-
-    def test_legacy_self_cycle(self):
-        # Self-cycles with legacy finalizers end up in gc.garbage.
-        with SimpleBase.test():
-            s = LegacySelfCycle()
-            ids = [id(s)]
-            wr = weakref.ref(s)
-            del s
-            gc.collect()
-            self.assert_del_calls([])
-            self.assert_tp_del_calls([])
-            self.assert_survivors([])
-            self.assert_garbage(ids)
-            self.assertIsNot(wr(), None)
-            # Break the cycle to allow collection
-            gc.garbage[0].ref = None
-        self.assert_garbage([])
-        self.assertIs(wr(), None)
-
-
-def test_main():
-    support.run_unittest(__name__)
-
-if __name__ == "__main__":
-    test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_frame.py
--- a/Lib/test/test_frame.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-import gc
-import sys
-import unittest
-import weakref
-
-from test import support
-
-
-class ClearTest(unittest.TestCase):
-    """
-    Tests for frame.clear().
-    """
-
-    def inner(self, x=5, **kwargs):
-        1/0
-
-    def outer(self, **kwargs):
-        try:
-            self.inner(**kwargs)
-        except ZeroDivisionError as e:
-            exc = e
-        return exc
-
-    def clear_traceback_frames(self, tb):
-        """
-        Clear all frames in a traceback.
-        """
-        while tb is not None:
-            tb.tb_frame.clear()
-            tb = tb.tb_next
-
-    def test_clear_locals(self):
-        class C:
-            pass
-        c = C()
-        wr = weakref.ref(c)
-        exc = self.outer(c=c)
-        del c
-        support.gc_collect()
-        # A reference to c is held through the frames
-        self.assertIsNot(None, wr())
-        self.clear_traceback_frames(exc.__traceback__)
-        support.gc_collect()
-        # The reference was released by .clear()
-        self.assertIs(None, wr())
-
-    def test_clear_generator(self):
-        endly = False
-        def g():
-            nonlocal endly
-            try:
-                yield
-                inner()
-            finally:
-                endly = True
-        gen = g()
-        next(gen)
-        self.assertFalse(endly)
-        # Clearing the frame closes the generator
-        gen.gi_frame.clear()
-        self.assertTrue(endly)
-
-    def test_clear_executing(self):
-        # Attempting to clear an executing frame is forbidden.
-        try:
-            1/0
-        except ZeroDivisionError as e:
-            f = e.__traceback__.tb_frame
-        with self.assertRaises(RuntimeError):
-            f.clear()
-        with self.assertRaises(RuntimeError):
-            f.f_back.clear()
-
-    def test_clear_executing_generator(self):
-        # Attempting to clear an executing generator frame is forbidden.
-        endly = False
-        def g():
-            nonlocal endly
-            try:
-                1/0
-            except ZeroDivisionError as e:
-                f = e.__traceback__.tb_frame
-                with self.assertRaises(RuntimeError):
-                    f.clear()
-                with self.assertRaises(RuntimeError):
-                    f.f_back.clear()
-                yield f
-            finally:
-                endly = True
-        gen = g()
-        f = next(gen)
-        self.assertFalse(endly)
-        # Clearing the frame closes the generator
-        f.clear()
-        self.assertTrue(endly)
-
-    @support.cpython_only
-    def test_clear_refcycles(self):
-        # .clear() doesn't leave any refcycle behind
-        with support.disable_gc():
-            class C:
-                pass
-            c = C()
-            wr = weakref.ref(c)
-            exc = self.outer(c=c)
-            del c
-            self.assertIsNot(None, wr())
-            self.clear_traceback_frames(exc.__traceback__)
-            self.assertIs(None, wr())
-
-
-def test_main():
-    support.run_unittest(__name__)
-
-if __name__ == "__main__":
-    test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_gc.py
--- a/Lib/test/test_gc.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_gc.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,4 +1,3 @@
-import _testcapi
 import unittest
 from test.support import (verbose, refcount_test, run_unittest,
                             strip_python_stderr)
@@ -41,7 +40,6 @@
         # gc collects it.
         self.wr = weakref.ref(C1055820(666), it_happened)
 
-@_testcapi.with_tp_del
 class Uncollectable(object):
     """Create a reference cycle with multiple __del__ methods.
 
@@ -54,7 +52,7 @@
             self.partner = Uncollectable(partner=self)
         else:
             self.partner = partner
-    def __tp_del__(self):
+    def __del__(self):
         pass
 
 ### Tests
@@ -143,12 +141,11 @@
         del a
         self.assertNotEqual(gc.collect(), 0)
 
-    def test_legacy_finalizer(self):
+    def test_finalizer(self):
         # A() is uncollectable if it is part of a cycle, make sure it shows up
         # in gc.garbage.
-        @_testcapi.with_tp_del
         class A:
-            def __tp_del__(self): pass
+            def __del__(self): pass
         class B:
             pass
         a = A()
@@ -168,12 +165,11 @@
             self.fail("didn't find obj in garbage (finalizer)")
         gc.garbage.remove(obj)
 
-    def test_legacy_finalizer_newclass(self):
+    def test_finalizer_newclass(self):
         # A() is uncollectable if it is part of a cycle, make sure it shows up
         # in gc.garbage.
-        @_testcapi.with_tp_del
         class A(object):
-            def __tp_del__(self): pass
+            def __del__(self): pass
         class B(object):
             pass
         a = A()
@@ -574,14 +570,12 @@
         import subprocess
         code = """if 1:
             import gc
-            import _testcapi
-            @_testcapi.with_tp_del
             class X:
                 def __init__(self, name):
                     self.name = name
                 def __repr__(self):
                     return "<X %%r>" %% self.name
-                def __tp_del__(self):
+                def __del__(self):
                     pass
 
             x = X('first')
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_generators.py
--- a/Lib/test/test_generators.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_generators.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,55 +1,3 @@
-import gc
-import sys
-import unittest
-import weakref
-
-from test import support
-
-
-class FinalizationTest(unittest.TestCase):
-
-    def test_frame_resurrect(self):
-        # A generator frame can be resurrected by a generator's finalization.
-        def gen():
-            nonlocal frame
-            try:
-                yield
-            finally:
-                frame = sys._getframe()
-
-        g = gen()
-        wr = weakref.ref(g)
-        next(g)
-        del g
-        support.gc_collect()
-        self.assertIs(wr(), None)
-        self.assertTrue(frame)
-        del frame
-        support.gc_collect()
-
-    def test_refcycle(self):
-        # A generator caught in a refcycle gets finalized anyway.
-        old_garbage = gc.garbage[:]
-        finalized = False
-        def gen():
-            nonlocal finalized
-            try:
-                g = yield
-                yield 1
-            finally:
-                finalized = True
-
-        g = gen()
-        next(g)
-        g.send(g)
-        self.assertGreater(sys.getrefcount(g), 2)
-        self.assertFalse(finalized)
-        del g
-        support.gc_collect()
-        self.assertTrue(finalized)
-        self.assertEqual(gc.garbage, old_garbage)
-
-
 tutorial_tests = """
 Let's try a simple generator:
 
@@ -1932,7 +1880,6 @@
 # so this works as expected in both ways of running regrtest.
 def test_main(verbose=None):
     from test import support, test_generators
-    support.run_unittest(__name__)
     support.run_doctest(test_generators, verbose)
 
 # This part isn't needed for regrtest, but for running the test directly.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_hashlib.py
--- a/Lib/test/test_hashlib.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_hashlib.py	Mon Aug 12 02:18:40 2013 +0200
@@ -75,8 +75,8 @@
         if _hashlib:
             # These two algorithms should always be present when this module
             # is compiled.  If not, something was compiled wrong.
-            self.assertTrue(hasattr(_hashlib, 'openssl_md5'))
-            self.assertTrue(hasattr(_hashlib, 'openssl_sha1'))
+            assert hasattr(_hashlib, 'openssl_md5')
+            assert hasattr(_hashlib, 'openssl_sha1')
             for algorithm, constructors in self.constructors_to_test.items():
                 constructor = getattr(_hashlib, 'openssl_'+algorithm, None)
                 if constructor:
@@ -105,14 +105,10 @@
 
         super(HashLibTestCase, self).__init__(*args, **kwargs)
 
-    @property
-    def hash_constructors(self):
-        constructors = self.constructors_to_test.values()
-        return itertools.chain.from_iterable(constructors)
-
     def test_hash_array(self):
         a = array.array("b", range(10))
-        for cons in self.hash_constructors:
+        constructors = self.constructors_to_test.values()
+        for cons in itertools.chain.from_iterable(constructors):
             c = cons(a)
             c.hexdigest()
 
@@ -149,64 +145,40 @@
         self.assertRaises(TypeError, get_builtin_constructor, 3)
 
     def test_hexdigest(self):
-        for cons in self.hash_constructors:
-            h = cons()
-            self.assertIsInstance(h.digest(), bytes)
+        for name in self.supported_hash_names:
+            h = hashlib.new(name)
+            assert isinstance(h.digest(), bytes), name
             self.assertEqual(hexstr(h.digest()), h.hexdigest())
 
-    def test_name_attribute(self):
-        for cons in self.hash_constructors:
-            h = cons()
-            self.assertIsInstance(h.name, str)
-            self.assertIn(h.name, self.supported_hash_names)
-            self.assertEqual(h.name, hashlib.new(h.name).name)
 
     def test_large_update(self):
         aas = b'a' * 128
         bees = b'b' * 127
         cees = b'c' * 126
-        dees = b'd' * 2048 #  HASHLIB_GIL_MINSIZE
 
-        for cons in self.hash_constructors:
-            m1 = cons()
+        for name in self.supported_hash_names:
+            m1 = hashlib.new(name)
             m1.update(aas)
             m1.update(bees)
             m1.update(cees)
-            m1.update(dees)
 
-            m2 = cons()
-            m2.update(aas + bees + cees + dees)
+            m2 = hashlib.new(name)
+            m2.update(aas + bees + cees)
             self.assertEqual(m1.digest(), m2.digest())
 
-            m3 = cons(aas + bees + cees + dees)
-            self.assertEqual(m1.digest(), m3.digest())
-
-            # verify copy() doesn't touch original
-            m4 = cons(aas + bees + cees)
-            m4_digest = m4.digest()
-            m4_copy = m4.copy()
-            m4_copy.update(dees)
-            self.assertEqual(m1.digest(), m4_copy.digest())
-            self.assertEqual(m4.digest(), m4_digest)
-
-    def check(self, name, data, hexdigest):
-        hexdigest = hexdigest.lower()
+    def check(self, name, data, digest):
+        digest = digest.lower()
         constructors = self.constructors_to_test[name]
         # 2 is for hashlib.name(...) and hashlib.new(name, ...)
         self.assertGreaterEqual(len(constructors), 2)
         for hash_object_constructor in constructors:
-            m = hash_object_constructor(data)
-            computed = m.hexdigest()
+            computed = hash_object_constructor(data).hexdigest()
             self.assertEqual(
-                    computed, hexdigest,
+                    computed, digest,
                     "Hash algorithm %s constructed using %s returned hexdigest"
                     " %r for %d byte input data that should have hashed to %r."
                     % (name, hash_object_constructor,
-                       computed, len(data), hexdigest))
-            computed = m.digest()
-            digest = bytes.fromhex(hexdigest)
-            self.assertEqual(computed, digest)
-            self.assertEqual(len(digest), m.digest_size)
+                       computed, len(data), digest))
 
     def check_no_unicode(self, algorithm_name):
         # Unicode objects are not allowed as input.
@@ -226,29 +198,6 @@
         self.check_no_unicode('sha3_384')
         self.check_no_unicode('sha3_512')
 
-    def check_blocksize_name(self, name, block_size=0, digest_size=0):
-        constructors = self.constructors_to_test[name]
-        for hash_object_constructor in constructors:
-            m = hash_object_constructor()
-            self.assertEqual(m.block_size, block_size)
-            self.assertEqual(m.digest_size, digest_size)
-            self.assertEqual(len(m.digest()), digest_size)
-            self.assertEqual(m.name.lower(), name.lower())
-            # split for sha3_512 / _sha3.sha3 object
-            self.assertIn(name.split("_")[0], repr(m).lower())
-
-    def test_blocksize_name(self):
-        self.check_blocksize_name('md5', 64, 16)
-        self.check_blocksize_name('sha1', 64, 20)
-        self.check_blocksize_name('sha224', 64, 28)
-        self.check_blocksize_name('sha256', 64, 32)
-        self.check_blocksize_name('sha384', 128, 48)
-        self.check_blocksize_name('sha512', 128, 64)
-        self.check_blocksize_name('sha3_224', NotImplemented, 28)
-        self.check_blocksize_name('sha3_256', NotImplemented, 32)
-        self.check_blocksize_name('sha3_384', NotImplemented, 48)
-        self.check_blocksize_name('sha3_512', NotImplemented, 64)
-
     def test_case_md5_0(self):
         self.check('md5', b'', 'd41d8cd98f00b204e9800998ecf8427e')
 
@@ -490,13 +439,13 @@
         # for multithreaded operation (which is hardwired to 2048).
         gil_minsize = 2048
 
-        for cons in self.hash_constructors:
-            m = cons()
+        for name in self.supported_hash_names:
+            m = hashlib.new(name)
             m.update(b'1')
             m.update(b'#' * gil_minsize)
             m.update(b'1')
 
-            m = cons(b'x' * gil_minsize)
+            m = hashlib.new(name, b'x' * gil_minsize)
             m.update(b'1')
 
         m = hashlib.md5()
@@ -533,8 +482,8 @@
         events = []
         for threadnum in range(num_threads):
             chunk_size = len(data) // (10**threadnum)
-            self.assertGreater(chunk_size, 0)
-            self.assertEqual(chunk_size % len(smallest_data), 0)
+            assert chunk_size > 0
+            assert chunk_size % len(smallest_data) == 0
             event = threading.Event()
             events.append(event)
             threading.Thread(target=hash_in_chunks,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_http_cookiejar.py
--- a/Lib/test/test_http_cookiejar.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_http_cookiejar.py	Mon Aug 12 02:18:40 2013 +0200
@@ -7,7 +7,7 @@
 import unittest
 import urllib.request
 
-from http.cookiejar import (time2isoz, http2time, iso2time, time2netscape,
+from http.cookiejar import (time2isoz, http2time, time2netscape,
      parse_ns_headers, join_header_words, split_header_words, Cookie,
      CookieJar, DefaultCookiePolicy, LWPCookieJar, MozillaCookieJar,
      LoadError, lwp_cookie_str, DEFAULT_HTTP_PORT, escape_path,
@@ -56,8 +56,6 @@
          '03-Feb-1994 00:00:00 GMT',  # broken rfc850 (no weekday)
          '03-Feb-1994 00:00 GMT',  # broken rfc850 (no weekday, no seconds)
          '03-Feb-1994 00:00',  # broken rfc850 (no weekday, no seconds, no tz)
-         '02-Feb-1994 24:00',  # broken rfc850 (no weekday, no seconds,
-                               # no tz) using hour 24 with yesterday date
 
          '03-Feb-94',  # old rfc850 HTTP format (no weekday, no time)
          '03-Feb-1994',  # broken rfc850 HTTP format (no weekday, no time)
@@ -80,7 +78,7 @@
             t3 = http2time(s.upper())
 
             self.assertTrue(t == t2 == t3 == test_t,
-                            "'%s'  =>  %s, %s, %s (%s)" % (s, t, t2, t3, test_t))
+                         "'%s'  =>  %s, %s, %s (%s)" % (s, t, t2, t3, test_t))
 
     def test_http2time_garbage(self):
         for test in [
@@ -95,71 +93,10 @@
             '01-01-1980 00:61:00',
             '01-01-1980 00:00:62',
             ]:
-            self.assertIsNone(http2time(test),
-                              "http2time(%s) is not None\n"
-                              "http2time(test) %s" % (test, http2time(test)))
-
-    def test_iso2time(self):
-        def parse_date(text):
-            return time.gmtime(iso2time(text))[:6]
-
-        # ISO 8601 compact format
-        self.assertEqual(parse_date("19940203T141529Z"),
-                         (1994, 2, 3, 14, 15, 29))
-
-        # ISO 8601 with time behind UTC
-        self.assertEqual(parse_date("1994-02-03 07:15:29 -0700"),
-                         (1994, 2, 3, 14, 15, 29))
-
-        # ISO 8601 with time ahead of UTC
-        self.assertEqual(parse_date("1994-02-03 19:45:29 +0530"),
-                         (1994, 2, 3, 14, 15, 29))
-
-    def test_iso2time_formats(self):
-        # test iso2time for supported dates.
-        tests = [
-            '1994-02-03 00:00:00 -0000', # ISO 8601 format
-            '1994-02-03 00:00:00 +0000', # ISO 8601 format
-            '1994-02-03 00:00:00',       # zone is optional
-            '1994-02-03',                # only date
-            '1994-02-03T00:00:00',       # Use T as separator
-            '19940203',                  # only date
-            '1994-02-02 24:00:00',       # using hour-24 yesterday date
-            '19940203T000000Z',          # ISO 8601 compact format
-
-            # A few tests with extra space at various places
-            '  1994-02-03 ',
-            '  1994-02-03T00:00:00  ',
-        ]
-
-        test_t = 760233600  # assume broken POSIX counting of seconds
-        for s in tests:
-            t = iso2time(s)
-            t2 = iso2time(s.lower())
-            t3 = iso2time(s.upper())
-
-            self.assertTrue(t == t2 == t3 == test_t,
-                            "'%s'  =>  %s, %s, %s (%s)" % (s, t, t2, t3, test_t))
-
-    def test_iso2time_garbage(self):
-        for test in [
-            '',
-            'Garbage',
-            'Thursday, 03-Feb-94 00:00:00 GMT',
-            '1980-00-01',
-            '1980-13-01',
-            '1980-01-00',
-            '1980-01-32',
-            '1980-01-01 25:00:00',
-            '1980-01-01 00:61:00',
-            '01-01-1980 00:00:62',
-            '01-01-1980T00:00:62',
-            '19800101T250000Z'
-            '1980-01-01 00:00:00 -2500',
-            ]:
-            self.assertIsNone(iso2time(test),
-                              "iso2time(%s) is not None\n"
-                              "iso2time(test) %s" % (test, iso2time(test)))
+            self.assertTrue(http2time(test) is None,
+                         "http2time(%s) is not None\n"
+                         "http2time(test) %s" % (test, http2time(test))
+                         )
 
 
 class HeaderTests(unittest.TestCase):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_idle.py
--- a/Lib/test/test_idle.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_idle.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,23 +1,9 @@
-import unittest
-from test import support
-from test.support import import_module, use_resources
-
-# Skip test if _thread or _tkinter wasn't built or idlelib was deleted.
+# Skip test if _tkinter or _thread wasn't built or idlelib was deleted.
+from test.support import import_module
+import_module('tkinter')
 import_module('threading')  # imported by PyShell, imports _thread
-tk = import_module('tkinter')  # imports _tkinter
 idletest = import_module('idlelib.idle_test')
 
-# If buildbot improperly sets gui resource (#18365, #18441), remove it
-# so requires('gui') tests are skipped while non-gui tests still run.
-# If there is a problem with Macs, see #18441, msg 193805
-if use_resources and 'gui' in use_resources:
-    try:
-        root = tk.Tk()
-        root.destroy()
-    except tk.TclError:
-        while 'gui' in use_resources:
-            use_resources.remove('gui')
-
 # Without test_main present, regrtest.runtest_inner (line1219) calls
 # unittest.TestLoader().loadTestsFromModule(this_module) which calls
 # load_tests() if it finds it. (Unittest.main does the same.)
@@ -27,5 +13,7 @@
     # Until unittest supports resources, we emulate regrtest's -ugui
     # so loaded tests run the same as if textually present here.
     # If any Idle test ever needs another resource, add it to the list.
+    from test import support
     support.use_resources = ['gui']  # use_resources is initially None
+    import unittest
     unittest.main(verbosity=2, exit=False)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_imp.py
--- a/Lib/test/test_imp.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_imp.py	Mon Aug 12 02:18:40 2013 +0200
@@ -314,16 +314,6 @@
             import marshal
             imp.reload(marshal)
 
-    def test_with_deleted_parent(self):
-        # see #18681
-        from html import parser
-        html = sys.modules.pop('html')
-        def cleanup():
-            sys.modules['html'] = html
-        self.addCleanup(cleanup)
-        with self.assertRaisesRegex(ImportError, 'html'):
-            imp.reload(parser)
-
 
 class PEP3147Tests(unittest.TestCase):
     """Tests of PEP 3147."""
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_inspect.py
--- a/Lib/test/test_inspect.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_inspect.py	Mon Aug 12 02:18:40 2013 +0200
@@ -8,7 +8,6 @@
 import collections
 import os
 import shutil
-import functools
 from os.path import normcase
 
 from test.support import run_unittest, TESTFN, DirsOnSysPath
@@ -1720,17 +1719,6 @@
                          ((('b', ..., ..., "positional_or_keyword"),),
                           ...))
 
-        # Test we handle __signature__ partway down the wrapper stack
-        def wrapped_foo_call():
-            pass
-        wrapped_foo_call.__wrapped__ = Foo.__call__
-
-        self.assertEqual(self.signature(wrapped_foo_call),
-                         ((('a', ..., ..., "positional_or_keyword"),
-                           ('b', ..., ..., "positional_or_keyword")),
-                          ...))
-
-
     def test_signature_on_class(self):
         class C:
             def __init__(self, a):
@@ -1845,10 +1833,6 @@
         self.assertEqual(self.signature(Wrapped),
                          ((('a', ..., ..., "positional_or_keyword"),),
                           ...))
-        # wrapper loop:
-        Wrapped.__wrapped__ = Wrapped
-        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
-            self.signature(Wrapped)
 
     def test_signature_on_lambdas(self):
         self.assertEqual(self.signature((lambda a=10: a)),
@@ -2300,62 +2284,6 @@
         self.assertNotEqual(ba, ba4)
 
 
-class TestUnwrap(unittest.TestCase):
-
-    def test_unwrap_one(self):
-        def func(a, b):
-            return a + b
-        wrapper = functools.lru_cache(maxsize=20)(func)
-        self.assertIs(inspect.unwrap(wrapper), func)
-
-    def test_unwrap_several(self):
-        def func(a, b):
-            return a + b
-        wrapper = func
-        for __ in range(10):
-            @functools.wraps(wrapper)
-            def wrapper():
-                pass
-        self.assertIsNot(wrapper.__wrapped__, func)
-        self.assertIs(inspect.unwrap(wrapper), func)
-
-    def test_stop(self):
-        def func1(a, b):
-            return a + b
-        @functools.wraps(func1)
-        def func2():
-            pass
-        @functools.wraps(func2)
-        def wrapper():
-            pass
-        func2.stop_here = 1
-        unwrapped = inspect.unwrap(wrapper,
-                                   stop=(lambda f: hasattr(f, "stop_here")))
-        self.assertIs(unwrapped, func2)
-
-    def test_cycle(self):
-        def func1(): pass
-        func1.__wrapped__ = func1
-        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
-            inspect.unwrap(func1)
-
-        def func2(): pass
-        func2.__wrapped__ = func1
-        func1.__wrapped__ = func2
-        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
-            inspect.unwrap(func1)
-        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
-            inspect.unwrap(func2)
-
-    def test_unhashable(self):
-        def func(): pass
-        func.__wrapped__ = None
-        class C:
-            __hash__ = None
-            __wrapped__ = func
-        self.assertIsNone(inspect.unwrap(C()))
-
-
 def test_main():
     run_unittest(
         TestDecorators, TestRetrievingSourceCode, TestOneliners, TestBuggyCases,
@@ -2363,7 +2291,7 @@
         TestGetcallargsFunctions, TestGetcallargsMethods,
         TestGetcallargsUnboundMethods, TestGetattrStatic, TestGetGeneratorState,
         TestNoEOL, TestSignatureObject, TestSignatureBind, TestParameterObject,
-        TestBoundArguments, TestGetClosureVars, TestUnwrap
+        TestBoundArguments, TestGetClosureVars
     )
 
 if __name__ == "__main__":
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_int.py
--- a/Lib/test/test_int.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_int.py	Mon Aug 12 02:18:40 2013 +0200
@@ -73,6 +73,14 @@
         x = -1-sys.maxsize
         self.assertEqual(x >> 1, x//2)
 
+        self.assertRaises(ValueError, int, '123\0')
+        self.assertRaises(ValueError, int, '53', 40)
+
+        # SF bug 1545497: embedded NULs were not detected with
+        # explicit base
+        self.assertRaises(ValueError, int, '123\0', 10)
+        self.assertRaises(ValueError, int, '123\x00 245', 20)
+
         x = int('1' * 600)
         self.assertIsInstance(x, int)
 
@@ -393,37 +401,14 @@
                     int(TruncReturnsBadInt())
 
     def test_error_message(self):
-        def check(s, base=None):
-            with self.assertRaises(ValueError,
-                                   msg="int(%r, %r)" % (s, base)) as cm:
-                if base is None:
-                    int(s)
-                else:
-                    int(s, base)
-            self.assertEqual(cm.exception.args[0],
-                "invalid literal for int() with base %d: %r" %
-                (10 if base is None else base, s))
-
-        check('\xbd')
-        check('123\xbd')
-        check('  123 456  ')
-
-        check('123\x00')
-        # SF bug 1545497: embedded NULs were not detected with explicit base
-        check('123\x00', 10)
-        check('123\x00 245', 20)
-        check('123\x00 245', 16)
-        check('123\x00245', 20)
-        check('123\x00245', 16)
-        # byte string with embedded NUL
-        check(b'123\x00')
-        check(b'123\x00', 10)
-        # non-UTF-8 byte string
-        check(b'123\xbd')
-        check(b'123\xbd', 10)
-        # lone surrogate in Unicode string
-        check('123\ud800')
-        check('123\ud800', 10)
+        testlist = ('\xbd', '123\xbd', '  123 456  ')
+        for s in testlist:
+            try:
+                int(s)
+            except ValueError as e:
+                self.assertIn(s.strip(), e.args[0])
+            else:
+                self.fail("Expected int(%r) to raise a ValueError", s)
 
 def test_main():
     support.run_unittest(IntTestCases)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_io.py
--- a/Lib/test/test_io.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_io.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1072,13 +1072,12 @@
     def test_garbage_collection(self):
         # C BufferedReader objects are collected.
         # The Python version has __del__, so it ends into gc.garbage instead
-        with support.check_warnings(('', ResourceWarning)):
-            rawio = self.FileIO(support.TESTFN, "w+b")
-            f = self.tp(rawio)
-            f.f = f
-            wr = weakref.ref(f)
-            del f
-            support.gc_collect()
+        rawio = self.FileIO(support.TESTFN, "w+b")
+        f = self.tp(rawio)
+        f.f = f
+        wr = weakref.ref(f)
+        del f
+        support.gc_collect()
         self.assertTrue(wr() is None, wr)
 
     def test_args_error(self):
@@ -1367,14 +1366,13 @@
         # C BufferedWriter objects are collected, and collecting them flushes
         # all data to disk.
         # The Python version has __del__, so it ends into gc.garbage instead
-        with support.check_warnings(('', ResourceWarning)):
-            rawio = self.FileIO(support.TESTFN, "w+b")
-            f = self.tp(rawio)
-            f.write(b"123xxx")
-            f.x = f
-            wr = weakref.ref(f)
-            del f
-            support.gc_collect()
+        rawio = self.FileIO(support.TESTFN, "w+b")
+        f = self.tp(rawio)
+        f.write(b"123xxx")
+        f.x = f
+        wr = weakref.ref(f)
+        del f
+        support.gc_collect()
         self.assertTrue(wr() is None, wr)
         with self.open(support.TESTFN, "rb") as f:
             self.assertEqual(f.read(), b"123xxx")
@@ -2609,15 +2607,14 @@
         # C TextIOWrapper objects are collected, and collecting them flushes
         # all data to disk.
         # The Python version has __del__, so it ends in gc.garbage instead.
-        with support.check_warnings(('', ResourceWarning)):
-            rawio = io.FileIO(support.TESTFN, "wb")
-            b = self.BufferedWriter(rawio)
-            t = self.TextIOWrapper(b, encoding="ascii")
-            t.write("456def")
-            t.x = t
-            wr = weakref.ref(t)
-            del t
-            support.gc_collect()
+        rawio = io.FileIO(support.TESTFN, "wb")
+        b = self.BufferedWriter(rawio)
+        t = self.TextIOWrapper(b, encoding="ascii")
+        t.write("456def")
+        t.x = t
+        wr = weakref.ref(t)
+        del t
+        support.gc_collect()
         self.assertTrue(wr() is None, wr)
         with self.open(support.TESTFN, "rb") as f:
             self.assertEqual(f.read(), b"456def")
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/test_json.py	Mon Aug 12 02:18:40 2013 +0200
@@ -0,0 +1,17 @@
+"""Tests for json.
+
+The tests for json are defined in the json.tests package;
+the test_suite() function there returns a test suite that's ready to
+be run.
+"""
+
+from test import json_tests
+import test.support
+
+
+def test_main():
+    test.support.run_unittest(json_tests.test_suite())
+
+
+if __name__ == "__main__":
+    test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/__init__.py
--- a/Lib/test/test_json/__init__.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-import os
-import sys
-import json
-import doctest
-import unittest
-
-from test import support
-
-# import json with and without accelerations
-cjson = support.import_fresh_module('json', fresh=['_json'])
-pyjson = support.import_fresh_module('json', blocked=['_json'])
-
-# create two base classes that will be used by the other tests
-class PyTest(unittest.TestCase):
-    json = pyjson
-    loads = staticmethod(pyjson.loads)
-    dumps = staticmethod(pyjson.dumps)
-
-@unittest.skipUnless(cjson, 'requires _json')
-class CTest(unittest.TestCase):
-    if cjson is not None:
-        json = cjson
-        loads = staticmethod(cjson.loads)
-        dumps = staticmethod(cjson.dumps)
-
-# test PyTest and CTest checking if the functions come from the right module
-class TestPyTest(PyTest):
-    def test_pyjson(self):
-        self.assertEqual(self.json.scanner.make_scanner.__module__,
-                         'json.scanner')
-        self.assertEqual(self.json.decoder.scanstring.__module__,
-                         'json.decoder')
-        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
-                         'json.encoder')
-
-class TestCTest(CTest):
-    def test_cjson(self):
-        self.assertEqual(self.json.scanner.make_scanner.__module__, '_json')
-        self.assertEqual(self.json.decoder.scanstring.__module__, '_json')
-        self.assertEqual(self.json.encoder.c_make_encoder.__module__, '_json')
-        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
-                         '_json')
-
-
-here = os.path.dirname(__file__)
-
-def load_tests(*args):
-    suite = additional_tests()
-    loader = unittest.TestLoader()
-    for fn in os.listdir(here):
-        if fn.startswith("test") and fn.endswith(".py"):
-            modname = "test.test_json." + fn[:-3]
-            __import__(modname)
-            module = sys.modules[modname]
-            suite.addTests(loader.loadTestsFromModule(module))
-    return suite
-
-def additional_tests():
-    suite = unittest.TestSuite()
-    for mod in (json, json.encoder, json.decoder):
-        suite.addTest(doctest.DocTestSuite(mod))
-    suite.addTest(TestPyTest('test_pyjson'))
-    suite.addTest(TestCTest('test_cjson'))
-    return suite
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/__main__.py
--- a/Lib/test/test_json/__main__.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-import unittest
-from test.test_json import load_tests
-
-unittest.main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_decode.py
--- a/Lib/test/test_json/test_decode.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,74 +0,0 @@
-import decimal
-from io import StringIO
-from collections import OrderedDict
-from test.test_json import PyTest, CTest
-
-
-class TestDecode:
-    def test_decimal(self):
-        rval = self.loads('1.1', parse_float=decimal.Decimal)
-        self.assertTrue(isinstance(rval, decimal.Decimal))
-        self.assertEqual(rval, decimal.Decimal('1.1'))
-
-    def test_float(self):
-        rval = self.loads('1', parse_int=float)
-        self.assertTrue(isinstance(rval, float))
-        self.assertEqual(rval, 1.0)
-
-    def test_empty_objects(self):
-        self.assertEqual(self.loads('{}'), {})
-        self.assertEqual(self.loads('[]'), [])
-        self.assertEqual(self.loads('""'), "")
-
-    def test_object_pairs_hook(self):
-        s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
-        p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4),
-             ("qrt", 5), ("pad", 6), ("hoy", 7)]
-        self.assertEqual(self.loads(s), eval(s))
-        self.assertEqual(self.loads(s, object_pairs_hook=lambda x: x), p)
-        self.assertEqual(self.json.load(StringIO(s),
-                                        object_pairs_hook=lambda x: x), p)
-        od = self.loads(s, object_pairs_hook=OrderedDict)
-        self.assertEqual(od, OrderedDict(p))
-        self.assertEqual(type(od), OrderedDict)
-        # the object_pairs_hook takes priority over the object_hook
-        self.assertEqual(self.loads(s, object_pairs_hook=OrderedDict,
-                                    object_hook=lambda x: None),
-                         OrderedDict(p))
-        # check that empty objects literals work (see #17368)
-        self.assertEqual(self.loads('{}', object_pairs_hook=OrderedDict),
-                         OrderedDict())
-        self.assertEqual(self.loads('{"empty": {}}',
-                                    object_pairs_hook=OrderedDict),
-                         OrderedDict([('empty', OrderedDict())]))
-
-    def test_decoder_optimizations(self):
-        # Several optimizations were made that skip over calls to
-        # the whitespace regex, so this test is designed to try and
-        # exercise the uncommon cases. The array cases are already covered.
-        rval = self.loads('{   "key"    :    "value"    ,  "k":"v"    }')
-        self.assertEqual(rval, {"key":"value", "k":"v"})
-
-    def check_keys_reuse(self, source, loads):
-        rval = loads(source)
-        (a, b), (c, d) = sorted(rval[0]), sorted(rval[1])
-        self.assertIs(a, c)
-        self.assertIs(b, d)
-
-    def test_keys_reuse(self):
-        s = '[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]'
-        self.check_keys_reuse(s, self.loads)
-        self.check_keys_reuse(s, self.json.decoder.JSONDecoder().decode)
-
-    def test_extra_data(self):
-        s = '[1, 2, 3]5'
-        msg = 'Extra data'
-        self.assertRaisesRegex(ValueError, msg, self.loads, s)
-
-    def test_invalid_escape(self):
-        s = '["abc\\y"]'
-        msg = 'escape'
-        self.assertRaisesRegex(ValueError, msg, self.loads, s)
-
-class TestPyDecode(TestDecode, PyTest): pass
-class TestCDecode(TestDecode, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_default.py
--- a/Lib/test/test_json/test_default.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-class TestDefault:
-    def test_default(self):
-        self.assertEqual(
-            self.dumps(type, default=repr),
-            self.dumps(repr(type)))
-
-
-class TestPyDefault(TestDefault, PyTest): pass
-class TestCDefault(TestDefault, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_dump.py
--- a/Lib/test/test_json/test_dump.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-from io import StringIO
-from test.test_json import PyTest, CTest
-
-from test.support import bigmemtest, _1G
-
-class TestDump:
-    def test_dump(self):
-        sio = StringIO()
-        self.json.dump({}, sio)
-        self.assertEqual(sio.getvalue(), '{}')
-
-    def test_dumps(self):
-        self.assertEqual(self.dumps({}), '{}')
-
-    def test_encode_truefalse(self):
-        self.assertEqual(self.dumps(
-                 {True: False, False: True}, sort_keys=True),
-                 '{"false": true, "true": false}')
-        self.assertEqual(self.dumps(
-                {2: 3.0, 4.0: 5, False: 1, 6: True}, sort_keys=True),
-                '{"false": 1, "2": 3.0, "4.0": 5, "6": true}')
-
-    # Issue 16228: Crash on encoding resized list
-    def test_encode_mutated(self):
-        a = [object()] * 10
-        def crasher(obj):
-            del a[-1]
-        self.assertEqual(self.dumps(a, default=crasher),
-                 '[null, null, null, null, null]')
-
-
-class TestPyDump(TestDump, PyTest): pass
-
-class TestCDump(TestDump, CTest):
-
-    # The size requirement here is hopefully over-estimated (actual
-    # memory consumption depending on implementation details, and also
-    # system memory management, since this may allocate a lot of
-    # small objects).
-
-    @bigmemtest(size=_1G, memuse=1)
-    def test_large_list(self, size):
-        N = int(30 * 1024 * 1024 * (size / _1G))
-        l = [1] * N
-        encoded = self.dumps(l)
-        self.assertEqual(len(encoded), N * 3)
-        self.assertEqual(encoded[:1], "[")
-        self.assertEqual(encoded[-2:], "1]")
-        self.assertEqual(encoded[1:-2], "1, " * (N - 1))
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_encode_basestring_ascii.py
--- a/Lib/test/test_json/test_encode_basestring_ascii.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-from collections import OrderedDict
-from test.test_json import PyTest, CTest
-
-
-CASES = [
-    ('/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?', '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
-    ('controls', '"controls"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
-    (' s p a c e d ', '" s p a c e d "'),
-    ('\U0001d120', '"\\ud834\\udd20"'),
-    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
-    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
-    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
-    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
-    ("`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
-]
-
-class TestEncodeBasestringAscii:
-    def test_encode_basestring_ascii(self):
-        fname = self.json.encoder.encode_basestring_ascii.__name__
-        for input_string, expect in CASES:
-            result = self.json.encoder.encode_basestring_ascii(input_string)
-            self.assertEqual(result, expect,
-                '{0!r} != {1!r} for {2}({3!r})'.format(
-                    result, expect, fname, input_string))
-
-    def test_ordered_dict(self):
-        # See issue 6105
-        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
-        s = self.dumps(OrderedDict(items))
-        self.assertEqual(s, '{"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}')
-
-    def test_sorted_dict(self):
-        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
-        s = self.dumps(dict(items), sort_keys=True)
-        self.assertEqual(s, '{"five": 5, "four": 4, "one": 1, "three": 3, "two": 2}')
-
-
-class TestPyEncodeBasestringAscii(TestEncodeBasestringAscii, PyTest): pass
-class TestCEncodeBasestringAscii(TestEncodeBasestringAscii, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_enum.py
--- a/Lib/test/test_json/test_enum.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,81 +0,0 @@
-from enum import Enum, IntEnum
-from test.test_json import PyTest, CTest
-
-SMALL = 1
-BIG = 1<<32
-HUGE = 1<<64
-REALLY_HUGE = 1<<96
-
-class BigNum(IntEnum):
-    small = SMALL
-    big = BIG
-    huge = HUGE
-    really_huge = REALLY_HUGE
-
-E = 2.718281
-PI = 3.141593
-TAU = 2 * PI
-
-class FloatNum(float, Enum):
-    e = E
-    pi = PI
-    tau = TAU
-
-class TestEnum:
-
-    def test_floats(self):
-        for enum in FloatNum:
-            self.assertEqual(self.dumps(enum), repr(enum.value))
-            self.assertEqual(float(self.dumps(enum)), enum)
-            self.assertEqual(self.loads(self.dumps(enum)), enum)
-
-    def test_ints(self):
-        for enum in BigNum:
-            self.assertEqual(self.dumps(enum), str(enum.value))
-            self.assertEqual(int(self.dumps(enum)), enum)
-            self.assertEqual(self.loads(self.dumps(enum)), enum)
-
-    def test_list(self):
-        self.assertEqual(
-                self.dumps(list(BigNum)),
-                str([SMALL, BIG, HUGE, REALLY_HUGE]),
-                )
-        self.assertEqual(self.dumps(list(FloatNum)), str([E, PI, TAU]))
-
-    def test_dict_keys(self):
-        s, b, h, r = BigNum
-        e, p, t = FloatNum
-        d = {
-            s:'tiny', b:'large', h:'larger', r:'largest',
-            e:"Euler's number", p:'pi', t:'tau',
-            }
-        nd = self.loads(self.dumps(d))
-        self.assertEqual(nd[str(SMALL)], 'tiny')
-        self.assertEqual(nd[str(BIG)], 'large')
-        self.assertEqual(nd[str(HUGE)], 'larger')
-        self.assertEqual(nd[str(REALLY_HUGE)], 'largest')
-        self.assertEqual(nd[repr(E)], "Euler's number")
-        self.assertEqual(nd[repr(PI)], 'pi')
-        self.assertEqual(nd[repr(TAU)], 'tau')
-
-    def test_dict_values(self):
-        d = dict(
-                tiny=BigNum.small,
-                large=BigNum.big,
-                larger=BigNum.huge,
-                largest=BigNum.really_huge,
-                e=FloatNum.e,
-                pi=FloatNum.pi,
-                tau=FloatNum.tau,
-                )
-        nd = self.loads(self.dumps(d))
-        self.assertEqual(nd['tiny'], SMALL)
-        self.assertEqual(nd['large'], BIG)
-        self.assertEqual(nd['larger'], HUGE)
-        self.assertEqual(nd['largest'], REALLY_HUGE)
-        self.assertEqual(nd['e'], E)
-        self.assertEqual(nd['pi'], PI)
-        self.assertEqual(nd['tau'], TAU)
-
-class TestPyEnum(TestEnum, PyTest): pass
-class TestCEnum(TestEnum, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_fail.py
--- a/Lib/test/test_json/test_fail.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,194 +0,0 @@
-from test.test_json import PyTest, CTest
-import re
-
-# 2007-10-05
-JSONDOCS = [
-    # http://json.org/JSON_checker/test/fail1.json
-    '"A JSON payload should be an object or array, not a string."',
-    # http://json.org/JSON_checker/test/fail2.json
-    '["Unclosed array"',
-    # http://json.org/JSON_checker/test/fail3.json
-    '{unquoted_key: "keys must be quoted"}',
-    # http://json.org/JSON_checker/test/fail4.json
-    '["extra comma",]',
-    # http://json.org/JSON_checker/test/fail5.json
-    '["double extra comma",,]',
-    # http://json.org/JSON_checker/test/fail6.json
-    '[   , "<-- missing value"]',
-    # http://json.org/JSON_checker/test/fail7.json
-    '["Comma after the close"],',
-    # http://json.org/JSON_checker/test/fail8.json
-    '["Extra close"]]',
-    # http://json.org/JSON_checker/test/fail9.json
-    '{"Extra comma": true,}',
-    # http://json.org/JSON_checker/test/fail10.json
-    '{"Extra value after close": true} "misplaced quoted value"',
-    # http://json.org/JSON_checker/test/fail11.json
-    '{"Illegal expression": 1 + 2}',
-    # http://json.org/JSON_checker/test/fail12.json
-    '{"Illegal invocation": alert()}',
-    # http://json.org/JSON_checker/test/fail13.json
-    '{"Numbers cannot have leading zeroes": 013}',
-    # http://json.org/JSON_checker/test/fail14.json
-    '{"Numbers cannot be hex": 0x14}',
-    # http://json.org/JSON_checker/test/fail15.json
-    '["Illegal backslash escape: \\x15"]',
-    # http://json.org/JSON_checker/test/fail16.json
-    '[\\naked]',
-    # http://json.org/JSON_checker/test/fail17.json
-    '["Illegal backslash escape: \\017"]',
-    # http://json.org/JSON_checker/test/fail18.json
-    '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
-    # http://json.org/JSON_checker/test/fail19.json
-    '{"Missing colon" null}',
-    # http://json.org/JSON_checker/test/fail20.json
-    '{"Double colon":: null}',
-    # http://json.org/JSON_checker/test/fail21.json
-    '{"Comma instead of colon", null}',
-    # http://json.org/JSON_checker/test/fail22.json
-    '["Colon instead of comma": false]',
-    # http://json.org/JSON_checker/test/fail23.json
-    '["Bad value", truth]',
-    # http://json.org/JSON_checker/test/fail24.json
-    "['single quote']",
-    # http://json.org/JSON_checker/test/fail25.json
-    '["\ttab\tcharacter\tin\tstring\t"]',
-    # http://json.org/JSON_checker/test/fail26.json
-    '["tab\\   character\\   in\\  string\\  "]',
-    # http://json.org/JSON_checker/test/fail27.json
-    '["line\nbreak"]',
-    # http://json.org/JSON_checker/test/fail28.json
-    '["line\\\nbreak"]',
-    # http://json.org/JSON_checker/test/fail29.json
-    '[0e]',
-    # http://json.org/JSON_checker/test/fail30.json
-    '[0e+]',
-    # http://json.org/JSON_checker/test/fail31.json
-    '[0e+-1]',
-    # http://json.org/JSON_checker/test/fail32.json
-    '{"Comma instead if closing brace": true,',
-    # http://json.org/JSON_checker/test/fail33.json
-    '["mismatch"}',
-    # http://code.google.com/p/simplejson/issues/detail?id=3
-    '["A\u001FZ control characters in string"]',
-]
-
-SKIPS = {
-    1: "why not have a string payload?",
-    18: "spec doesn't specify any nesting limitations",
-}
-
-class TestFail:
-    def test_failures(self):
-        for idx, doc in enumerate(JSONDOCS):
-            idx = idx + 1
-            if idx in SKIPS:
-                self.loads(doc)
-                continue
-            try:
-                self.loads(doc)
-            except ValueError:
-                pass
-            else:
-                self.fail("Expected failure for fail{0}.json: {1!r}".format(idx, doc))
-
-    def test_non_string_keys_dict(self):
-        data = {'a' : 1, (1, 2) : 2}
-
-        #This is for c encoder
-        self.assertRaises(TypeError, self.dumps, data)
-
-        #This is for python encoder
-        self.assertRaises(TypeError, self.dumps, data, indent=True)
-
-    def test_truncated_input(self):
-        test_cases = [
-            ('', 'Expecting value', 0),
-            ('[', 'Expecting value', 1),
-            ('[42', "Expecting ',' delimiter", 3),
-            ('[42,', 'Expecting value', 4),
-            ('["', 'Unterminated string starting at', 1),
-            ('["spam', 'Unterminated string starting at', 1),
-            ('["spam"', "Expecting ',' delimiter", 7),
-            ('["spam",', 'Expecting value', 8),
-            ('{', 'Expecting property name enclosed in double quotes', 1),
-            ('{"', 'Unterminated string starting at', 1),
-            ('{"spam', 'Unterminated string starting at', 1),
-            ('{"spam"', "Expecting ':' delimiter", 7),
-            ('{"spam":', 'Expecting value', 8),
-            ('{"spam":42', "Expecting ',' delimiter", 10),
-            ('{"spam":42,', 'Expecting property name enclosed in double quotes', 11),
-        ]
-        test_cases += [
-            ('"', 'Unterminated string starting at', 0),
-            ('"spam', 'Unterminated string starting at', 0),
-        ]
-        for data, msg, idx in test_cases:
-            self.assertRaisesRegex(ValueError,
-                r'^{0}: line 1 column {1} \(char {2}\)'.format(
-                    re.escape(msg), idx + 1, idx),
-                self.loads, data)
-
-    def test_unexpected_data(self):
-        test_cases = [
-            ('[,', 'Expecting value', 1),
-            ('{"spam":[}', 'Expecting value', 9),
-            ('[42:', "Expecting ',' delimiter", 3),
-            ('[42 "spam"', "Expecting ',' delimiter", 4),
-            ('[42,]', 'Expecting value', 4),
-            ('{"spam":[42}', "Expecting ',' delimiter", 11),
-            ('["]', 'Unterminated string starting at', 1),
-            ('["spam":', "Expecting ',' delimiter", 7),
-            ('["spam",]', 'Expecting value', 8),
-            ('{:', 'Expecting property name enclosed in double quotes', 1),
-            ('{,', 'Expecting property name enclosed in double quotes', 1),
-            ('{42', 'Expecting property name enclosed in double quotes', 1),
-            ('[{]', 'Expecting property name enclosed in double quotes', 2),
-            ('{"spam",', "Expecting ':' delimiter", 7),
-            ('{"spam"}', "Expecting ':' delimiter", 7),
-            ('[{"spam"]', "Expecting ':' delimiter", 8),
-            ('{"spam":}', 'Expecting value', 8),
-            ('[{"spam":]', 'Expecting value', 9),
-            ('{"spam":42 "ham"', "Expecting ',' delimiter", 11),
-            ('[{"spam":42]', "Expecting ',' delimiter", 11),
-            ('{"spam":42,}', 'Expecting property name enclosed in double quotes', 11),
-        ]
-        for data, msg, idx in test_cases:
-            self.assertRaisesRegex(ValueError,
-                r'^{0}: line 1 column {1} \(char {2}\)'.format(
-                    re.escape(msg), idx + 1, idx),
-                self.loads, data)
-
-    def test_extra_data(self):
-        test_cases = [
-            ('[]]', 'Extra data', 2),
-            ('{}}', 'Extra data', 2),
-            ('[],[]', 'Extra data', 2),
-            ('{},{}', 'Extra data', 2),
-        ]
-        test_cases += [
-            ('42,"spam"', 'Extra data', 2),
-            ('"spam",42', 'Extra data', 6),
-        ]
-        for data, msg, idx in test_cases:
-            self.assertRaisesRegex(ValueError,
-                r'^{0}: line 1 column {1} - line 1 column {2}'
-                r' \(char {3} - {4}\)'.format(
-                    re.escape(msg), idx + 1, len(data) + 1, idx, len(data)),
-                self.loads, data)
-
-    def test_linecol(self):
-        test_cases = [
-            ('!', 1, 1, 0),
-            (' !', 1, 2, 1),
-            ('\n!', 2, 1, 1),
-            ('\n  \n\n     !', 4, 6, 10),
-        ]
-        for data, line, col, idx in test_cases:
-            self.assertRaisesRegex(ValueError,
-                r'^Expecting value: line {0} column {1}'
-                r' \(char {2}\)$'.format(line, col, idx),
-                self.loads, data)
-
-class TestPyFail(TestFail, PyTest): pass
-class TestCFail(TestFail, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_float.py
--- a/Lib/test/test_json/test_float.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-import math
-from test.test_json import PyTest, CTest
-
-
-class TestFloat:
-    def test_floats(self):
-        for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]:
-            self.assertEqual(float(self.dumps(num)), num)
-            self.assertEqual(self.loads(self.dumps(num)), num)
-
-    def test_ints(self):
-        for num in [1, 1<<32, 1<<64]:
-            self.assertEqual(self.dumps(num), str(num))
-            self.assertEqual(int(self.dumps(num)), num)
-
-    def test_out_of_range(self):
-        self.assertEqual(self.loads('[23456789012E666]'), [float('inf')])
-        self.assertEqual(self.loads('[-23456789012E666]'), [float('-inf')])
-
-    def test_allow_nan(self):
-        for val in (float('inf'), float('-inf'), float('nan')):
-            out = self.dumps([val])
-            if val == val:  # inf
-                self.assertEqual(self.loads(out), [val])
-            else:  # nan
-                res = self.loads(out)
-                self.assertEqual(len(res), 1)
-                self.assertNotEqual(res[0], res[0])
-            self.assertRaises(ValueError, self.dumps, [val], allow_nan=False)
-
-
-class TestPyFloat(TestFloat, PyTest): pass
-class TestCFloat(TestFloat, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_indent.py
--- a/Lib/test/test_json/test_indent.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-import textwrap
-from io import StringIO
-from test.test_json import PyTest, CTest
-
-
-class TestIndent:
-    def test_indent(self):
-        h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth',
-             {'nifty': 87}, {'field': 'yes', 'morefield': False} ]
-
-        expect = textwrap.dedent("""\
-        [
-        \t[
-        \t\t"blorpie"
-        \t],
-        \t[
-        \t\t"whoops"
-        \t],
-        \t[],
-        \t"d-shtaeou",
-        \t"d-nthiouh",
-        \t"i-vhbjkhnth",
-        \t{
-        \t\t"nifty": 87
-        \t},
-        \t{
-        \t\t"field": "yes",
-        \t\t"morefield": false
-        \t}
-        ]""")
-
-        d1 = self.dumps(h)
-        d2 = self.dumps(h, indent=2, sort_keys=True, separators=(',', ': '))
-        d3 = self.dumps(h, indent='\t', sort_keys=True, separators=(',', ': '))
-        d4 = self.dumps(h, indent=2, sort_keys=True)
-        d5 = self.dumps(h, indent='\t', sort_keys=True)
-
-        h1 = self.loads(d1)
-        h2 = self.loads(d2)
-        h3 = self.loads(d3)
-
-        self.assertEqual(h1, h)
-        self.assertEqual(h2, h)
-        self.assertEqual(h3, h)
-        self.assertEqual(d2, expect.expandtabs(2))
-        self.assertEqual(d3, expect)
-        self.assertEqual(d4, d2)
-        self.assertEqual(d5, d3)
-
-    def test_indent0(self):
-        h = {3: 1}
-        def check(indent, expected):
-            d1 = self.dumps(h, indent=indent)
-            self.assertEqual(d1, expected)
-
-            sio = StringIO()
-            self.json.dump(h, sio, indent=indent)
-            self.assertEqual(sio.getvalue(), expected)
-
-        # indent=0 should emit newlines
-        check(0, '{\n"3": 1\n}')
-        # indent=None is more compact
-        check(None, '{"3": 1}')
-
-
-class TestPyIndent(TestIndent, PyTest): pass
-class TestCIndent(TestIndent, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_pass1.py
--- a/Lib/test/test_json/test_pass1.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-# from http://json.org/JSON_checker/test/pass1.json
-JSON = r'''
-[
-    "JSON Test Pattern pass1",
-    {"object with 1 member":["array with 1 element"]},
-    {},
-    [],
-    -42,
-    true,
-    false,
-    null,
-    {
-        "integer": 1234567890,
-        "real": -9876.543210,
-        "e": 0.123456789e-12,
-        "E": 1.234567890E+34,
-        "":  23456789012E66,
-        "zero": 0,
-        "one": 1,
-        "space": " ",
-        "quote": "\"",
-        "backslash": "\\",
-        "controls": "\b\f\n\r\t",
-        "slash": "/ & \/",
-        "alpha": "abcdefghijklmnopqrstuvwyz",
-        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
-        "digit": "0123456789",
-        "0123456789": "digit",
-        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
-        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
-        "true": true,
-        "false": false,
-        "null": null,
-        "array":[  ],
-        "object":{  },
-        "address": "50 St. James Street",
-        "url": "http://www.JSON.org/",
-        "comment": "// /* <!-- --",
-        "# -- --> */": " ",
-        " s p a c e d " :[1,2 , 3
-
-,
-
-4 , 5        ,          6           ,7        ],"compact":[1,2,3,4,5,6,7],
-        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
-        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
-        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
-: "A key can be any string"
-    },
-    0.5 ,98.6
-,
-99.44
-,
-
-1066,
-1e1,
-0.1e1,
-1e-1,
-1e00,2e+00,2e-00
-,"rosebud"]
-'''
-
-class TestPass1:
-    def test_parse(self):
-        # test in/out equivalence and parsing
-        res = self.loads(JSON)
-        out = self.dumps(res)
-        self.assertEqual(res, self.loads(out))
-
-
-class TestPyPass1(TestPass1, PyTest): pass
-class TestCPass1(TestPass1, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_pass2.py
--- a/Lib/test/test_json/test_pass2.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-# from http://json.org/JSON_checker/test/pass2.json
-JSON = r'''
-[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
-'''
-
-class TestPass2:
-    def test_parse(self):
-        # test in/out equivalence and parsing
-        res = self.loads(JSON)
-        out = self.dumps(res)
-        self.assertEqual(res, self.loads(out))
-
-
-class TestPyPass2(TestPass2, PyTest): pass
-class TestCPass2(TestPass2, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_pass3.py
--- a/Lib/test/test_json/test_pass3.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,24 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-# from http://json.org/JSON_checker/test/pass3.json
-JSON = r'''
-{
-    "JSON Test Pattern pass3": {
-        "The outermost value": "must be an object or array.",
-        "In this test": "It is an object."
-    }
-}
-'''
-
-
-class TestPass3:
-    def test_parse(self):
-        # test in/out equivalence and parsing
-        res = self.loads(JSON)
-        out = self.dumps(res)
-        self.assertEqual(res, self.loads(out))
-
-
-class TestPyPass3(TestPass3, PyTest): pass
-class TestCPass3(TestPass3, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_recursion.py
--- a/Lib/test/test_json/test_recursion.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,100 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-class JSONTestObject:
-    pass
-
-
-class TestRecursion:
-    def test_listrecursion(self):
-        x = []
-        x.append(x)
-        try:
-            self.dumps(x)
-        except ValueError:
-            pass
-        else:
-            self.fail("didn't raise ValueError on list recursion")
-        x = []
-        y = [x]
-        x.append(y)
-        try:
-            self.dumps(x)
-        except ValueError:
-            pass
-        else:
-            self.fail("didn't raise ValueError on alternating list recursion")
-        y = []
-        x = [y, y]
-        # ensure that the marker is cleared
-        self.dumps(x)
-
-    def test_dictrecursion(self):
-        x = {}
-        x["test"] = x
-        try:
-            self.dumps(x)
-        except ValueError:
-            pass
-        else:
-            self.fail("didn't raise ValueError on dict recursion")
-        x = {}
-        y = {"a": x, "b": x}
-        # ensure that the marker is cleared
-        self.dumps(x)
-
-    def test_defaultrecursion(self):
-        class RecursiveJSONEncoder(self.json.JSONEncoder):
-            recurse = False
-            def default(self, o):
-                if o is JSONTestObject:
-                    if self.recurse:
-                        return [JSONTestObject]
-                    else:
-                        return 'JSONTestObject'
-                return pyjson.JSONEncoder.default(o)
-
-        enc = RecursiveJSONEncoder()
-        self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"')
-        enc.recurse = True
-        try:
-            enc.encode(JSONTestObject)
-        except ValueError:
-            pass
-        else:
-            self.fail("didn't raise ValueError on default recursion")
-
-
-    def test_highly_nested_objects_decoding(self):
-        # test that loading highly-nested objects doesn't segfault when C
-        # accelerations are used. See #12017
-        with self.assertRaises(RuntimeError):
-            self.loads('{"a":' * 100000 + '1' + '}' * 100000)
-        with self.assertRaises(RuntimeError):
-            self.loads('{"a":' * 100000 + '[1]' + '}' * 100000)
-        with self.assertRaises(RuntimeError):
-            self.loads('[' * 100000 + '1' + ']' * 100000)
-
-    def test_highly_nested_objects_encoding(self):
-        # See #12051
-        l, d = [], {}
-        for x in range(100000):
-            l, d = [l], {'k':d}
-        with self.assertRaises(RuntimeError):
-            self.dumps(l)
-        with self.assertRaises(RuntimeError):
-            self.dumps(d)
-
-    def test_endless_recursion(self):
-        # See #12051
-        class EndlessJSONEncoder(self.json.JSONEncoder):
-            def default(self, o):
-                """If check_circular is False, this will keep adding another list."""
-                return [o]
-
-        with self.assertRaises(RuntimeError):
-            EndlessJSONEncoder(check_circular=False).encode(5j)
-
-
-class TestPyRecursion(TestRecursion, PyTest): pass
-class TestCRecursion(TestRecursion, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_scanstring.py
--- a/Lib/test/test_json/test_scanstring.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,98 +0,0 @@
-import sys
-from test.test_json import PyTest, CTest
-
-
-class TestScanstring:
-    def test_scanstring(self):
-        scanstring = self.json.decoder.scanstring
-        self.assertEqual(
-            scanstring('"z\\ud834\\udd20x"', 1, True),
-            ('z\U0001d120x', 16))
-
-        self.assertEqual(
-            scanstring('"z\U0001d120x"', 1, True),
-            ('z\U0001d120x', 5))
-
-        self.assertEqual(
-            scanstring('"\\u007b"', 1, True),
-            ('{', 8))
-
-        self.assertEqual(
-            scanstring('"A JSON payload should be an object or array, not a string."', 1, True),
-            ('A JSON payload should be an object or array, not a string.', 60))
-
-        self.assertEqual(
-            scanstring('["Unclosed array"', 2, True),
-            ('Unclosed array', 17))
-
-        self.assertEqual(
-            scanstring('["extra comma",]', 2, True),
-            ('extra comma', 14))
-
-        self.assertEqual(
-            scanstring('["double extra comma",,]', 2, True),
-            ('double extra comma', 21))
-
-        self.assertEqual(
-            scanstring('["Comma after the close"],', 2, True),
-            ('Comma after the close', 24))
-
-        self.assertEqual(
-            scanstring('["Extra close"]]', 2, True),
-            ('Extra close', 14))
-
-        self.assertEqual(
-            scanstring('{"Extra comma": true,}', 2, True),
-            ('Extra comma', 14))
-
-        self.assertEqual(
-            scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, True),
-            ('Extra value after close', 26))
-
-        self.assertEqual(
-            scanstring('{"Illegal expression": 1 + 2}', 2, True),
-            ('Illegal expression', 21))
-
-        self.assertEqual(
-            scanstring('{"Illegal invocation": alert()}', 2, True),
-            ('Illegal invocation', 21))
-
-        self.assertEqual(
-            scanstring('{"Numbers cannot have leading zeroes": 013}', 2, True),
-            ('Numbers cannot have leading zeroes', 37))
-
-        self.assertEqual(
-            scanstring('{"Numbers cannot be hex": 0x14}', 2, True),
-            ('Numbers cannot be hex', 24))
-
-        self.assertEqual(
-            scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, True),
-            ('Too deep', 30))
-
-        self.assertEqual(
-            scanstring('{"Missing colon" null}', 2, True),
-            ('Missing colon', 16))
-
-        self.assertEqual(
-            scanstring('{"Double colon":: null}', 2, True),
-            ('Double colon', 15))
-
-        self.assertEqual(
-            scanstring('{"Comma instead of colon", null}', 2, True),
-            ('Comma instead of colon', 25))
-
-        self.assertEqual(
-            scanstring('["Colon instead of comma": false]', 2, True),
-            ('Colon instead of comma', 25))
-
-        self.assertEqual(
-            scanstring('["Bad value", truth]', 2, True),
-            ('Bad value', 12))
-
-    def test_overflow(self):
-        with self.assertRaises(OverflowError):
-            self.json.decoder.scanstring(b"xxx", sys.maxsize+1)
-
-
-class TestPyScanstring(TestScanstring, PyTest): pass
-class TestCScanstring(TestScanstring, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_separators.py
--- a/Lib/test/test_json/test_separators.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-import textwrap
-from test.test_json import PyTest, CTest
-
-
-class TestSeparators:
-    def test_separators(self):
-        h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth',
-             {'nifty': 87}, {'field': 'yes', 'morefield': False} ]
-
-        expect = textwrap.dedent("""\
-        [
-          [
-            "blorpie"
-          ] ,
-          [
-            "whoops"
-          ] ,
-          [] ,
-          "d-shtaeou" ,
-          "d-nthiouh" ,
-          "i-vhbjkhnth" ,
-          {
-            "nifty" : 87
-          } ,
-          {
-            "field" : "yes" ,
-            "morefield" : false
-          }
-        ]""")
-
-
-        d1 = self.dumps(h)
-        d2 = self.dumps(h, indent=2, sort_keys=True, separators=(' ,', ' : '))
-
-        h1 = self.loads(d1)
-        h2 = self.loads(d2)
-
-        self.assertEqual(h1, h)
-        self.assertEqual(h2, h)
-        self.assertEqual(d2, expect)
-
-
-class TestPySeparators(TestSeparators, PyTest): pass
-class TestCSeparators(TestSeparators, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_speedups.py
--- a/Lib/test/test_json/test_speedups.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,24 +0,0 @@
-from test.test_json import CTest
-
-
-class TestSpeedups(CTest):
-    def test_scanstring(self):
-        self.assertEqual(self.json.decoder.scanstring.__module__, "_json")
-        self.assertIs(self.json.decoder.scanstring, self.json.decoder.c_scanstring)
-
-    def test_encode_basestring_ascii(self):
-        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
-                         "_json")
-        self.assertIs(self.json.encoder.encode_basestring_ascii,
-                      self.json.encoder.c_encode_basestring_ascii)
-
-
-class TestDecode(CTest):
-    def test_make_scanner(self):
-        self.assertRaises(AttributeError, self.json.scanner.c_make_scanner, 1)
-
-    def test_make_encoder(self):
-        self.assertRaises(TypeError, self.json.encoder.c_make_encoder,
-            (True, False),
-            b"\xCD\x7D\x3D\x4E\x12\x4C\xF9\x79\xD7\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75",
-            None)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_tool.py
--- a/Lib/test/test_json/test_tool.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,69 +0,0 @@
-import os
-import sys
-import textwrap
-import unittest
-import subprocess
-from test import support
-from test.script_helper import assert_python_ok
-
-class TestTool(unittest.TestCase):
-    data = """
-
-        [["blorpie"],[ "whoops" ] , [
-                                 ],\t"d-shtaeou",\r"d-nthiouh",
-        "i-vhbjkhnth", {"nifty":87}, {"morefield" :\tfalse,"field"
-            :"yes"}  ]
-           """
-
-    expect = textwrap.dedent("""\
-    [
-        [
-            "blorpie"
-        ],
-        [
-            "whoops"
-        ],
-        [],
-        "d-shtaeou",
-        "d-nthiouh",
-        "i-vhbjkhnth",
-        {
-            "nifty": 87
-        },
-        {
-            "field": "yes",
-            "morefield": false
-        }
-    ]
-    """)
-
-    def test_stdin_stdout(self):
-        with subprocess.Popen(
-                (sys.executable, '-m', 'json.tool'),
-                stdin=subprocess.PIPE, stdout=subprocess.PIPE) as proc:
-            out, err = proc.communicate(self.data.encode())
-        self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
-        self.assertEqual(err, None)
-
-    def _create_infile(self):
-        infile = support.TESTFN
-        with open(infile, "w") as fp:
-            self.addCleanup(os.remove, infile)
-            fp.write(self.data)
-        return infile
-
-    def test_infile_stdout(self):
-        infile = self._create_infile()
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile)
-        self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
-        self.assertEqual(err, b'')
-
-    def test_infile_outfile(self):
-        infile = self._create_infile()
-        outfile = support.TESTFN + '.out'
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile, outfile)
-        self.addCleanup(os.remove, outfile)
-        with open(outfile, "r") as fp:
-            self.assertEqual(fp.read(), self.expect)
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_json/test_unicode.py
--- a/Lib/test/test_json/test_unicode.py	Sun Aug 11 16:48:44 2013 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-from collections import OrderedDict
-from test.test_json import PyTest, CTest
-
-
-class TestUnicode:
-    # test_encoding1 and test_encoding2 from 2.x are irrelevant (only str
-    # is supported as input, not bytes).
-
-    def test_encoding3(self):
-        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
-        j = self.dumps(u)
-        self.assertEqual(j, '"\\u03b1\\u03a9"')
-
-    def test_encoding4(self):
-        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
-        j = self.dumps([u])
-        self.assertEqual(j, '["\\u03b1\\u03a9"]')
-
-    def test_encoding5(self):
-        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
-        j = self.dumps(u, ensure_ascii=False)
-        self.assertEqual(j, '"{0}"'.format(u))
-
-    def test_encoding6(self):
-        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
-        j = self.dumps([u], ensure_ascii=False)
-        self.assertEqual(j, '["{0}"]'.format(u))
-
-    def test_big_unicode_encode(self):
-        u = '\U0001d120'
-        self.assertEqual(self.dumps(u), '"\\ud834\\udd20"')
-        self.assertEqual(self.dumps(u, ensure_ascii=False), '"\U0001d120"')
-
-    def test_big_unicode_decode(self):
-        u = 'z\U0001d120x'
-        self.assertEqual(self.loads('"' + u + '"'), u)
-        self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u)
-
-    def test_unicode_decode(self):
-        for i in range(0, 0xd7ff):
-            u = chr(i)
-            s = '"\\u{0:04x}"'.format(i)
-            self.assertEqual(self.loads(s), u)
-
-    def test_unicode_preservation(self):
-        self.assertEqual(type(self.loads('""')), str)
-        self.assertEqual(type(self.loads('"a"')), str)
-        self.assertEqual(type(self.loads('["a"]')[0]), str)
-
-    def test_bytes_encode(self):
-        self.assertRaises(TypeError, self.dumps, b"hi")
-        self.assertRaises(TypeError, self.dumps, [b"hi"])
-
-    def test_bytes_decode(self):
-        self.assertRaises(TypeError, self.loads, b'"hi"')
-        self.assertRaises(TypeError, self.loads, b'["hi"]')
-
-
-    def test_object_pairs_hook_with_unicode(self):
-        s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
-        p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4),
-             ("qrt", 5), ("pad", 6), ("hoy", 7)]
-        self.assertEqual(self.loads(s), eval(s))
-        self.assertEqual(self.loads(s, object_pairs_hook = lambda x: x), p)
-        od = self.loads(s, object_pairs_hook = OrderedDict)
-        self.assertEqual(od, OrderedDict(p))
-        self.assertEqual(type(od), OrderedDict)
-        # the object_pairs_hook takes priority over the object_hook
-        self.assertEqual(self.loads(s, object_pairs_hook = OrderedDict,
-                                    object_hook = lambda x: None),
-                         OrderedDict(p))
-
-
-class TestPyUnicode(TestUnicode, PyTest): pass
-class TestCUnicode(TestUnicode, CTest): pass
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_kqueue.py
--- a/Lib/test/test_kqueue.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_kqueue.py	Mon Aug 12 02:18:40 2013 +0200
@@ -75,13 +75,13 @@
         self.assertEqual(ev, ev)
         self.assertNotEqual(ev, other)
 
-        bignum = 0x7fff
-        ev = select.kevent(bignum, 1, 2, 3, bignum - 1, bignum)
+        bignum = sys.maxsize * 2 + 1
+        ev = select.kevent(bignum, 1, 2, 3, sys.maxsize, bignum)
         self.assertEqual(ev.ident, bignum)
         self.assertEqual(ev.filter, 1)
         self.assertEqual(ev.flags, 2)
         self.assertEqual(ev.fflags, 3)
-        self.assertEqual(ev.data, bignum - 1)
+        self.assertEqual(ev.data, sys.maxsize)
         self.assertEqual(ev.udata, bignum)
         self.assertEqual(ev, ev)
         self.assertNotEqual(ev, other)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_linecache.py
--- a/Lib/test/test_linecache.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_linecache.py	Mon Aug 12 02:18:40 2013 +0200
@@ -11,7 +11,7 @@
 EMPTY = ''
 TESTS = 'inspect_fodder inspect_fodder2 mapping_tests'
 TESTS = TESTS.split()
-TEST_PATH = os.path.dirname(__file__)
+TEST_PATH = os.path.dirname(support.__file__)
 MODULES = "linecache abc".split()
 MODULE_PATH = os.path.dirname(FILENAME)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_minidom.py
--- a/Lib/test/test_minidom.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_minidom.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,7 +1,7 @@
 # test for xml.dom.minidom
 
 import pickle
-from test.support import run_unittest, findfile
+from test.support import verbose, run_unittest, findfile
 import unittest
 
 import xml.dom.minidom
@@ -310,10 +310,9 @@
         self.confirm(len(child.attributes) == 0
                 and child.getAttributeNode("spam") is None)
         dom2 = Document()
-        child2 = dom2.appendChild(dom2.createElement("foo"))
-        node2 = child2.getAttributeNode("spam")
-        self.assertRaises(xml.dom.NotFoundErr, child2.removeAttributeNode,
-            node2)
+        child2 = dom2.appendChild(dom.createElement("foo"))
+        self.assertRaises(xml.dom.NotFoundErr, child.removeAttributeNode,
+            node)
         dom.unlink()
 
     def testHasAttribute(self):
@@ -608,7 +607,7 @@
     def testHasChildNodes(self):
         dom = parseString("<doc><foo/></doc>")
         doc = dom.documentElement
-        self.assertTrue(doc.hasChildNodes())
+        self.assertTrue(dom.hasChildNodes())
         dom2 = parseString("<doc/>")
         doc2 = dom2.documentElement
         self.assertFalse(doc2.hasChildNodes())
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_mmap.py
--- a/Lib/test/test_mmap.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_mmap.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,12 +1,11 @@
 from test.support import (TESTFN, run_unittest, import_module, unlink,
-                          requires, _2G, _4G, gc_collect)
+                          requires, _2G, _4G)
 import unittest
 import os
 import re
 import itertools
 import socket
 import sys
-import weakref
 
 # Skip test if we can't import mmap.
 mmap = import_module('mmap')
@@ -693,15 +692,6 @@
                               "wrong exception raised in context manager")
         self.assertTrue(m.closed, "context manager failed")
 
-    def test_weakref(self):
-        # Check mmap objects are weakrefable
-        mm = mmap.mmap(-1, 16)
-        wr = weakref.ref(mm)
-        self.assertIs(wr(), mm)
-        del mm
-        gc_collect()
-        self.assertIs(wr(), None)
-
 class LargeMmapTests(unittest.TestCase):
 
     def setUp(self):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_module.py
--- a/Lib/test/test_module.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_module.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,8 +1,6 @@
 # Test the module type
 import unittest
-import weakref
 from test.support import run_unittest, gc_collect
-from test.script_helper import assert_python_ok
 
 import sys
 ModuleType = type(sys)
@@ -72,6 +70,7 @@
                "__loader__": None, "__package__": None})
         self.assertTrue(foo.__dict__ is d)
 
+    @unittest.expectedFailure
     def test_dont_clear_dict(self):
         # See issue 7140.
         def f():
@@ -96,14 +95,6 @@
         gc_collect()
         self.assertEqual(destroyed, [1])
 
-    def test_weakref(self):
-        m = ModuleType("foo")
-        wr = weakref.ref(m)
-        self.assertIs(wr(), m)
-        del m
-        gc_collect()
-        self.assertIs(wr(), None)
-
     def test_module_repr_minimal(self):
         # reprs when modules have no __file__, __name__, or __loader__
         m = ModuleType('foo')
@@ -190,19 +181,6 @@
         self.assertEqual(r[:25], "<module 'unittest' from '")
         self.assertEqual(r[-13:], "__init__.py'>")
 
-    def test_module_finalization_at_shutdown(self):
-        # Module globals and builtins should still be available during shutdown
-        rc, out, err = assert_python_ok("-c", "from test import final_a")
-        self.assertFalse(err)
-        lines = out.splitlines()
-        self.assertEqual(set(lines), {
-            b"x = a",
-            b"x = b",
-            b"final_a.x = a",
-            b"final_b.x = b",
-            b"len = len",
-            b"shutil.rmtree = rmtree"})
-
     # frozen and namespace module reprs are tested in importlib.
 
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_ntpath.py
--- a/Lib/test/test_ntpath.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_ntpath.py	Mon Aug 12 02:18:40 2013 +0200
@@ -256,40 +256,6 @@
                     # dialogs (#4804)
                     ntpath.sameopenfile(-1, -1)
 
-    def test_ismount(self):
-        self.assertTrue(ntpath.ismount("c:\\"))
-        self.assertTrue(ntpath.ismount("C:\\"))
-        self.assertTrue(ntpath.ismount("c:/"))
-        self.assertTrue(ntpath.ismount("C:/"))
-        self.assertTrue(ntpath.ismount("\\\\.\\c:\\"))
-        self.assertTrue(ntpath.ismount("\\\\.\\C:\\"))
-
-        self.assertTrue(ntpath.ismount(b"c:\\"))
-        self.assertTrue(ntpath.ismount(b"C:\\"))
-        self.assertTrue(ntpath.ismount(b"c:/"))
-        self.assertTrue(ntpath.ismount(b"C:/"))
-        self.assertTrue(ntpath.ismount(b"\\\\.\\c:\\"))
-        self.assertTrue(ntpath.ismount(b"\\\\.\\C:\\"))
-
-        with support.temp_dir() as d:
-            self.assertFalse(ntpath.ismount(d))
-
-        if sys.platform == "win32":
-            #
-            # Make sure the current folder isn't the root folder
-            # (or any other volume root). The drive-relative
-            # locations below cannot then refer to mount points
-            #
-            drive, path = ntpath.splitdrive(sys.executable)
-            with support.change_cwd(os.path.dirname(sys.executable)):
-                self.assertFalse(ntpath.ismount(drive.lower()))
-                self.assertFalse(ntpath.ismount(drive.upper()))
-
-            self.assertTrue(ntpath.ismount("\\\\localhost\\c$"))
-            self.assertTrue(ntpath.ismount("\\\\localhost\\c$\\"))
-
-            self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$"))
-            self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$\\"))
 
 class NtCommonTest(test_genericpath.CommonTest, unittest.TestCase):
     pathmodule = ntpath
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_os.py
--- a/Lib/test/test_os.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_os.py	Mon Aug 12 02:18:40 2013 +0200
@@ -24,8 +24,6 @@
 import stat
 import locale
 import codecs
-import decimal
-import fractions
 try:
     import threading
 except ImportError:
@@ -867,17 +865,6 @@
         os.makedirs(path, mode=mode, exist_ok=True)
         os.umask(old_mask)
 
-    @unittest.skipUnless(hasattr(os, 'chown'), 'test needs os.chown')
-    def test_chown_uid_gid_arguments_must_be_index(self):
-        stat = os.stat(support.TESTFN)
-        uid = stat.st_uid
-        gid = stat.st_gid
-        for value in (-1.0, -1j, decimal.Decimal(-1), fractions.Fraction(-2, 2)):
-            self.assertRaises(TypeError, os.chown, support.TESTFN, value, gid)
-            self.assertRaises(TypeError, os.chown, support.TESTFN, uid, value)
-        self.assertIsNone(os.chown(support.TESTFN, uid, gid))
-        self.assertIsNone(os.chown(support.TESTFN, -1, -1))
-
     def test_exist_ok_s_isgid_directory(self):
         path = os.path.join(support.TESTFN, 'dir1')
         S_ISGID = stat.S_ISGID
@@ -2265,6 +2252,136 @@
         else:
             self.skipTest("Could not determine the number of CPUs")
 
+
+@unittest.skipUnless(hasattr(os, 'get_inheritable'), "need os.get_inheritable()")
+class FDInheritanceTests(unittest.TestCase):
+    def create_testfile(self):
+        fileobj = open(support.TESTFN, 'xb')
+        self.addCleanup(support.unlink, support.TESTFN)
+        fileobj.close()
+
+    def test_get_inheritable(self):
+        self.create_testfile()
+
+        fd = os.open(support.TESTFN, os.O_RDONLY)
+        self.addCleanup(os.close, fd)
+        for inheritable in (False, True):
+            os.set_inheritable(fd, inheritable)
+            self.assertEqual(os.get_inheritable(fd), inheritable)
+
+    def test_set_inheritable(self):
+        self.create_testfile()
+
+        fd = os.open(support.TESTFN, os.O_RDONLY)
+        self.addCleanup(os.close, fd)
+        os.set_inheritable(fd, True)
+        self.assertEqual(os.get_inheritable(fd), True)
+
+    def test_open(self):
+        self.create_testfile()
+
+        fd = os.open(support.TESTFN, os.O_RDONLY)
+        self.addCleanup(os.close, fd)
+        self.assertEqual(os.get_inheritable(fd), False)
+
+    @unittest.skipUnless(hasattr(os, 'pipe'), "need os.pipe()")
+    def test_pipe_inheritable(self):
+        rfd, wfd = os.pipe()
+        self.addCleanup(os.close, rfd)
+        self.addCleanup(os.close, wfd)
+        self.assertEqual(os.get_inheritable(rfd), False)
+        self.assertEqual(os.get_inheritable(wfd), False)
+
+    @unittest.skipUnless(hasattr(os, 'dup'), "need os.dup()")
+    def test_dup_inheritable(self):
+        self.create_testfile()
+
+        for inheritable in (False, True):
+            fd1 = os.open(support.TESTFN, os.O_RDONLY)
+            try:
+                os.set_inheritable(fd1, not inheritable)
+                fd2 = os.dup(fd1)
+                try:
+                    self.assertEqual(os.get_inheritable(fd2), False)
+                finally:
+                    os.close(fd2)
+            finally:
+                os.close(fd1)
+
+    @unittest.skipUnless(hasattr(os, 'dup2'), "need os.dup2()")
+    def test_dup2_inheritable(self):
+        self.create_testfile()
+
+        for inheritable in (False, True):
+            fd1 = os.open(support.TESTFN, os.O_RDONLY)
+            try:
+                os.set_inheritable(fd1, not inheritable)
+                fd2 = os.open(support.TESTFN, os.O_RDONLY)
+                try:
+                    os.set_inheritable(fd2, not inheritable)
+                    os.dup2(fd1, fd2)
+                    self.assertEqual(os.get_inheritable(fd2), False)
+                finally:
+                    os.close(fd2)
+            finally:
+                os.close(fd1)
+
+    @unittest.skipUnless(hasattr(os, 'dup2'), "need os.dup2()")
+    def test_dup2_std_inheritable(self):
+        new_fd = os.open(__file__, os.O_RDONLY)
+        self.addCleanup(os.close, new_fd)
+        self.assertGreater(new_fd, 2)
+
+        for fd in (0, 1, 2):
+            with self.subTest("fd %s" % fd):
+                saved = os.dup(fd)
+                # On Windows, os.set_inheritable() fails with OSError(87,
+                # "invalid argument") on Windows console handles
+                if os.name != 'nt':
+                    was_inheritable = os.get_inheritable(fd)
+                try:
+                    os.dup2(new_fd, fd)
+                    self.assertEqual(os.get_inheritable(fd), fd < 3)
+                finally:
+                    os.dup2(saved, fd)
+                    if os.name != 'nt':
+                        os.set_inheritable(fd, was_inheritable)
+                    os.close(saved)
+
+    @unittest.skipUnless(hasattr(os, 'dup2'), "need os.dup2()")
+    def test_dup2_non_inheritable(self):
+        old_fd = os.open(__file__, os.O_RDONLY)
+        self.addCleanup(os.close, old_fd)
+        self.assertGreater(old_fd, 2)
+
+        new_fd = os.open(__file__, os.O_RDONLY)
+        self.addCleanup(os.close, new_fd)
+        self.assertGreater(new_fd, 2)
+        self.assertNotEqual(old_fd, new_fd)
+
+        for old_inheritable in (False, True):
+            # os.dup2(fd, fd) must make fd non-inheritable
+            os.set_inheritable(old_fd, old_inheritable)
+            os.dup2(old_fd, old_fd)
+            self.assertEqual(os.get_inheritable(old_fd), False)
+
+            for new_inheritable in (False, True):
+                os.set_inheritable(old_fd, old_inheritable)
+                os.set_inheritable(new_fd, new_inheritable)
+
+                # os.dup2(fd, fd2) must make fd2 non-inheritable
+                os.dup2(old_fd, new_fd)
+                self.assertEqual(os.get_inheritable(new_fd), False)
+
+    @unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+    def test_openpty_inheritable(self):
+        master_fd, slave_fd = os.openpty()
+        self.addCleanup(os.close, master_fd)
+        self.addCleanup(os.close, slave_fd)
+        self.assertEqual(os.get_inheritable(master_fd), False)
+        self.assertEqual(os.get_inheritable(slave_fd), False)
+
+
 @support.reap_threads
 def test_main():
     support.run_unittest(
@@ -2297,6 +2414,7 @@
         OSErrorTests,
         RemoveDirsTests,
         CPUCountTests,
+        FDInheritanceTests,
     )
 
 if __name__ == "__main__":
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_pep380.py
--- a/Lib/test/test_pep380.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_pep380.py	Mon Aug 12 02:18:40 2013 +0200
@@ -13,7 +13,7 @@
 import inspect
 import parser
 
-from test.support import captured_stderr, disable_gc, gc_collect
+from test.support import captured_stderr
 
 class TestPEP380Operation(unittest.TestCase):
     """
@@ -954,45 +954,6 @@
         list(gen())
         self.assertEqual(ret, 42)
 
-    def test_close_with_cleared_frame(self):
-        # See issue #17669.
-        #
-        # Create a stack of generators: outer() delegating to inner()
-        # delegating to innermost(). The key point is that the instance of
-        # inner is created first: this ensures that its frame appears before
-        # the instance of outer in the GC linked list.
-        #
-        # At the gc.collect call:
-        #   - frame_clear is called on the inner_gen frame.
-        #   - gen_dealloc is called on the outer_gen generator (the only
-        #     reference is in the frame's locals).
-        #   - gen_close is called on the outer_gen generator.
-        #   - gen_close_iter is called to close the inner_gen generator, which
-        #     in turn calls gen_close, and gen_yf.
-        #
-        # Previously, gen_yf would crash since inner_gen's frame had been
-        # cleared (and in particular f_stacktop was NULL).
-
-        def innermost():
-            yield
-        def inner():
-            outer_gen = yield
-            yield from innermost()
-        def outer():
-            inner_gen = yield
-            yield from inner_gen
-
-        with disable_gc():
-            inner_gen = inner()
-            outer_gen = outer()
-            outer_gen.send(None)
-            outer_gen.send(inner_gen)
-            outer_gen.send(outer_gen)
-
-            del outer_gen
-            del inner_gen
-            gc_collect()
-
 
 def test_main():
     from test import support
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_re.py
--- a/Lib/test/test_re.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_re.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1040,16 +1040,6 @@
         with self.assertRaisesRegex(sre_constants.error, '\?foo'):
             re.compile('(?P<?foo>)')
 
-    def test_issue17998(self):
-        for reps in '*', '+', '?', '{1}':
-            for mod in '', '?':
-                pattern = '.' + reps + mod + 'yz'
-                self.assertEqual(re.compile(pattern, re.S).findall('xyz'),
-                                 ['xyz'], msg=pattern)
-                pattern = pattern.encode()
-                self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
-                                 [b'xyz'], msg=pattern)
-
 
 def run_re_tests():
     from test.re_tests import tests, SUCCEED, FAIL, SYNTAX_ERROR
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_resource.py
--- a/Lib/test/test_resource.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_resource.py	Mon Aug 12 02:18:40 2013 +0200
@@ -124,11 +124,6 @@
 
             resource.setrlimit(resource.RLIMIT_CPU, BadSequence())
 
-    def test_pagesize(self):
-        pagesize = resource.getpagesize()
-        self.assertIsInstance(pagesize, int)
-        self.assertGreaterEqual(pagesize, 0)
-
 def test_main(verbose=None):
     support.run_unittest(ResourceTest)
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_select.py
--- a/Lib/test/test_select.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_select.py	Mon Aug 12 02:18:40 2013 +0200
@@ -75,8 +75,30 @@
         a[:] = [F()] * 10
         self.assertEqual(select.select([], a, []), ([], a[:5], []))
 
+
+@unittest.skipUnless(hasattr(os, 'get_inheritable'),
+                     "need os.get_inheritable()")
+class FDInheritanceTests(unittest.TestCase):
+    @unittest.skipUnless(hasattr(select, 'devpoll'), "need select.devpoll()")
+    def test_devpoll_inheritance(self):
+        devpoll = select.devpoll()
+        self.assertEqual(os.get_inheritable(devpoll.fileno()), False)
+        devpoll = None
+
+    @unittest.skipUnless(hasattr(select, 'epoll'), "need select.epoll()")
+    def test_epoll_inheritance(self):
+        epoll = select.epoll()
+        with epoll:
+            self.assertEqual(os.get_inheritable(epoll.fileno()), False)
+
+    @unittest.skipUnless(hasattr(select, 'kqueue'), "need select.kqueue()")
+    def test_kqueue_inheritance(self):
+        kqueue = select.kqueue()
+        self.assertEqual(os.get_inheritable(kqueue.fileno()), False)
+
+
 def test_main():
-    support.run_unittest(SelectTestCase)
+    support.run_unittest(SelectTestCase, FDInheritanceTests)
     support.reap_children()
 
 if __name__ == "__main__":
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_shutil.py
--- a/Lib/test/test_shutil.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_shutil.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1318,18 +1318,18 @@
         # that exists, it should be returned.
         base_dir, tail_dir = os.path.split(self.dir)
         relpath = os.path.join(tail_dir, self.file)
-        with support.change_cwd(path=base_dir):
+        with support.temp_cwd(path=base_dir):
             rv = shutil.which(relpath, path=self.temp_dir)
             self.assertEqual(rv, relpath)
         # But it shouldn't be searched in PATH directories (issue #16957).
-        with support.change_cwd(path=self.dir):
+        with support.temp_cwd(path=self.dir):
             rv = shutil.which(relpath, path=base_dir)
             self.assertIsNone(rv)
 
     def test_cwd(self):
         # Issue #16957
         base_dir = os.path.dirname(self.dir)
-        with support.change_cwd(path=self.dir):
+        with support.temp_cwd(path=self.dir):
             rv = shutil.which(self.file, path=base_dir)
             if sys.platform == "win32":
                 # Windows: current directory implicitly on PATH
@@ -1350,7 +1350,7 @@
 
     def test_relative_path(self):
         base_dir, tail_dir = os.path.split(self.dir)
-        with support.change_cwd(path=base_dir):
+        with support.temp_cwd(path=base_dir):
             rv = shutil.which(self.file, path=tail_dir)
             self.assertEqual(rv, os.path.join(tail_dir, self.file))
 
@@ -1375,7 +1375,7 @@
 
     def test_empty_path(self):
         base_dir = os.path.dirname(self.dir)
-        with support.change_cwd(path=self.dir), \
+        with support.temp_cwd(path=self.dir), \
              support.EnvironmentVarGuard() as env:
             env['PATH'] = self.dir
             rv = shutil.which(self.file, path='')
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_signal.py
--- a/Lib/test/test_signal.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_signal.py	Mon Aug 12 02:18:40 2013 +0200
@@ -206,17 +206,11 @@
     def test_issue9324(self):
         # Updated for issue #10003, adding SIGBREAK
         handler = lambda x, y: None
-        checked = set()
         for sig in (signal.SIGABRT, signal.SIGBREAK, signal.SIGFPE,
                     signal.SIGILL, signal.SIGINT, signal.SIGSEGV,
                     signal.SIGTERM):
-            # Set and then reset a handler for signals that work on windows.
-            # Issue #18396, only for signals without a C-level handler.
-            if signal.getsignal(sig) is not None:
-                signal.signal(sig, signal.signal(sig, handler))
-                checked.add(sig)
-        # Issue #18396: Ensure the above loop at least tested *something*
-        self.assertTrue(checked)
+            # Set and then reset a handler for signals that work on windows
+            signal.signal(sig, signal.signal(sig, handler))
 
         with self.assertRaises(ValueError):
             signal.signal(-1, handler)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_socket.py
--- a/Lib/test/test_socket.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_socket.py	Mon Aug 12 02:18:40 2013 +0200
@@ -23,10 +23,6 @@
 import pickle
 import struct
 try:
-    import fcntl
-except ImportError:
-    fcntl = False
-try:
     import multiprocessing
 except ImportError:
     multiprocessing = False
@@ -1108,9 +1104,15 @@
 
     def testNewAttributes(self):
         # testing .family, .type and .protocol
+
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.assertEqual(sock.family, socket.AF_INET)
-        self.assertEqual(sock.type, socket.SOCK_STREAM)
+        if hasattr(socket, 'SOCK_CLOEXEC'):
+            self.assertIn(sock.type,
+                          (socket.SOCK_STREAM | socket.SOCK_CLOEXEC,
+                           socket.SOCK_STREAM))
+        else:
+            self.assertEqual(sock.type, socket.SOCK_STREAM)
         self.assertEqual(sock.proto, 0)
         sock.close()
 
@@ -4748,16 +4750,52 @@
         self.assertRaises(OSError, sock.sendall, b'foo')
 
 
-@unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
-                     "SOCK_CLOEXEC not defined")
-@unittest.skipUnless(fcntl, "module fcntl not available")
-class CloexecConstantTest(unittest.TestCase):
+@unittest.skipUnless(hasattr(os, 'get_inheritable'),
+                     "need os.get_inheritable()")
+class InheritanceTest(unittest.TestCase):
+    @unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
+                         "SOCK_CLOEXEC not defined")
     @support.requires_linux_version(2, 6, 28)
     def test_SOCK_CLOEXEC(self):
         with socket.socket(socket.AF_INET,
                            socket.SOCK_STREAM | socket.SOCK_CLOEXEC) as s:
             self.assertTrue(s.type & socket.SOCK_CLOEXEC)
-            self.assertTrue(fcntl.fcntl(s, fcntl.F_GETFD) & fcntl.FD_CLOEXEC)
+            self.assertTrue(os.get_inheritable(sock.fileno()))
+
+    def test_socket_inheritance(self):
+        sock = socket.socket()
+        with sock:
+            self.assertEqual(os.get_inheritable(sock.fileno()), False)
+
+    def test_dup_inheritance(self):
+        for inheritable in (False, True):
+            sock = socket.socket()
+            with sock:
+                os.set_inheritable(sock.fileno(), inheritable)
+                newsock = sock.dup()
+                sock.close()
+            self.assertEqual(os.get_inheritable(newsock.fileno()), False)
+            newsock.close()
+
+    def test_socket_set_inheritable(self):
+        sock = socket.socket()
+        with sock:
+            # On Windows, fileno() returns an handle, not a file descriptor.
+            # Check if it is accepted.
+            os.set_inheritable(sock.fileno(), False)
+            self.assertEqual(os.get_inheritable(sock.fileno()), False)
+
+            os.set_inheritable(sock.fileno(), True)
+            self.assertEqual(os.get_inheritable(sock.fileno()), True)
+
+    @unittest.skipUnless(hasattr(socket, "socketpair"),
+                         "need socket.socketpair()")
+    def test_socketpair_inheritance(self):
+        s1, s2 = socket.socketpair()
+        self.assertEqual(os.get_inheritable(s1.fileno()), False)
+        self.assertEqual(os.get_inheritable(s2.fileno()), False)
+        s1.close()
+        s2.close()
 
 
 @unittest.skipUnless(hasattr(socket, "SOCK_NONBLOCK"),
@@ -4926,7 +4964,7 @@
         NetworkConnectionAttributesTest,
         NetworkConnectionBehaviourTest,
         ContextManagersTest,
-        CloexecConstantTest,
+        InheritanceTest,
         NonblockConstantTest
     ])
     if hasattr(socket, "socketpair"):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_startfile.py
--- a/Lib/test/test_startfile.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_startfile.py	Mon Aug 12 02:18:40 2013 +0200
@@ -21,11 +21,9 @@
         self.assertRaises(OSError, startfile, "nonexisting.vbs")
 
     def test_empty(self):
-        # We need to make sure the child process starts in a directory
-        # we're not about to delete. If we're running under -j, that
-        # means the test harness provided directory isn't a safe option.
-        # See http://bugs.python.org/issue15526 for more details
-        with support.change_cwd(path.dirname(sys.executable)):
+        # Switch to an existing, but safe, working directory to let the
+        # cleanup code do its thing without permission errors.
+        with support.temp_cwd(path=path.dirname(sys.executable)):
             empty = path.join(path.dirname(__file__), "empty.vbs")
             startfile(empty)
             startfile(empty, "open")
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_subprocess.py
--- a/Lib/test/test_subprocess.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_subprocess.py	Mon Aug 12 02:18:40 2013 +0200
@@ -416,8 +416,7 @@
     def test_executable_without_cwd(self):
         # For a normal installation, it should work without 'cwd'
         # argument.  For test runs in the build directory, see #7774.
-        self._assert_cwd(os.getcwd(), "somethingyoudonthave",
-                         executable=sys.executable)
+        self._assert_cwd('', "somethingyoudonthave", executable=sys.executable)
 
     def test_stdin_pipe(self):
         # stdin redirection
@@ -1124,7 +1123,7 @@
         if resource is not None:
             try:
                 self.old_limit = resource.getrlimit(resource.RLIMIT_CORE)
-                resource.setrlimit(resource.RLIMIT_CORE, (0, self.old_limit[1]))
+                resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
             except (ValueError, resource.error):
                 pass
 
@@ -1501,16 +1500,29 @@
         # Terminating a dead process
         self._kill_dead_process('terminate')
 
+    def _save_fds(self, save_fds):
+        fds = []
+        for fd in save_fds:
+            inheritable = os.get_inheritable(fd)
+            saved = os.dup(fd)
+            fds.append((fd, saved, inheritable))
+        return fds
+
+    def _restore_fds(self, fds):
+        for fd, saved, inheritable in fds:
+            os.dup2(saved, fd)
+            os.set_inheritable(fd, inheritable)
+            os.close(saved)
+
     def check_close_std_fds(self, fds):
         # Issue #9905: test that subprocess pipes still work properly with
         # some standard fds closed
         stdin = 0
-        newfds = []
-        for a in fds:
-            b = os.dup(a)
-            newfds.append(b)
-            if a == 0:
-                stdin = b
+        saved_fds = self._save_fds(fds)
+        for fd, saved, inheritable in saved_fds:
+            if fd == 0:
+                stdin = saved
+                break
         try:
             for fd in fds:
                 os.close(fd)
@@ -1525,10 +1537,7 @@
             err = support.strip_python_stderr(err)
             self.assertEqual((out, err), (b'apple', b'orange'))
         finally:
-            for b, a in zip(newfds, fds):
-                os.dup2(b, a)
-            for b in newfds:
-                os.close(b)
+            self._restore_fds(saved_fds)
 
     def test_close_fd_0(self):
         self.check_close_std_fds([0])
@@ -1568,7 +1577,7 @@
             os.lseek(temp_fds[1], 0, 0)
 
             # move the standard file descriptors out of the way
-            saved_fds = [os.dup(fd) for fd in range(3)]
+            saved_fds = self._save_fds(range(3))
             try:
                 # duplicate the file objects over the standard fd's
                 for fd, temp_fd in enumerate(temp_fds):
@@ -1584,10 +1593,7 @@
                     stderr=temp_fds[0])
                 p.wait()
             finally:
-                # restore the original fd's underneath sys.stdin, etc.
-                for std, saved in enumerate(saved_fds):
-                    os.dup2(saved, std)
-                    os.close(saved)
+                self._restore_fds(saved_fds)
 
             for fd in temp_fds:
                 os.lseek(fd, 0, 0)
@@ -1611,7 +1617,7 @@
                 os.unlink(fname)
 
             # save a copy of the standard file descriptors
-            saved_fds = [os.dup(fd) for fd in range(3)]
+            saved_fds = self._save_fds(range(3))
             try:
                 # duplicate the temp files over the standard fd's 0, 1, 2
                 for fd, temp_fd in enumerate(temp_fds):
@@ -1637,9 +1643,7 @@
                 out = os.read(stdout_no, 1024)
                 err = support.strip_python_stderr(os.read(stderr_no, 1024))
             finally:
-                for std, saved in enumerate(saved_fds):
-                    os.dup2(saved, std)
-                    os.close(saved)
+                self._restore_fds(saved_fds)
 
             self.assertEqual(out, b"got STDIN")
             self.assertEqual(err, b"err")
@@ -1810,6 +1814,9 @@
             self.addCleanup(os.close, fd)
             open_fds.add(fd)
 
+        for fd in open_fds:
+            os.set_inheritable(fd, True)
+
         p = subprocess.Popen([sys.executable, fd_status],
                              stdout=subprocess.PIPE, close_fds=False)
         output, ignored = p.communicate()
@@ -1854,6 +1861,8 @@
             fds = os.pipe()
             self.addCleanup(os.close, fds[0])
             self.addCleanup(os.close, fds[1])
+            os.set_inheritable(fds[0], True)
+            os.set_inheritable(fds[1], True)
             open_fds.update(fds)
 
         for fd in open_fds:
@@ -1876,6 +1885,32 @@
                         close_fds=False, pass_fds=(fd, )))
             self.assertIn('overriding close_fds', str(context.warning))
 
+    def test_pass_fds_inheritable(self):
+        script = support.findfile("inherited.py", subdir="subprocessdata")
+
+        inheritable, non_inheritable = os.pipe()
+        self.addCleanup(os.close, inheritable)
+        self.addCleanup(os.close, non_inheritable)
+        os.set_inheritable(inheritable, True)
+        os.set_inheritable(non_inheritable, False)
+        pass_fds = (inheritable, non_inheritable)
+        args = [sys.executable, script]
+        args += list(map(str, pass_fds))
+
+        p = subprocess.Popen(args,
+                             stdout=subprocess.PIPE, close_fds=True,
+                             pass_fds=pass_fds)
+        output, ignored = p.communicate()
+        fds = set(map(int, output.split(b',')))
+
+        # the inheritable file descriptor must be inherited, so its inheritable
+        # flag must be set in the child process after fork() and before exec()
+        self.assertEqual(fds, set(pass_fds))
+
+        # inheritable flag must not be changed in the parent process
+        self.assertEqual(os.get_inheritable(inheritable), True)
+        self.assertEqual(os.get_inheritable(non_inheritable), False)
+
     def test_stdout_stdin_are_single_inout_fd(self):
         with io.open(os.devnull, "r+") as inout:
             p = subprocess.Popen([sys.executable, "-c", "import sys; sys.exit(0)"],
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_support.py
--- a/Lib/test/test_support.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_support.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
 import importlib
-import shutil
 import sys
 import os
 import unittest
@@ -89,118 +88,6 @@
         s.listen(1)
         s.close()
 
-    # Tests for temp_dir()
-
-    def test_temp_dir(self):
-        """Test that temp_dir() creates and destroys its directory."""
-        parent_dir = tempfile.mkdtemp()
-        parent_dir = os.path.realpath(parent_dir)
-
-        try:
-            path = os.path.join(parent_dir, 'temp')
-            self.assertFalse(os.path.isdir(path))
-            with support.temp_dir(path) as temp_path:
-                self.assertEqual(temp_path, path)
-                self.assertTrue(os.path.isdir(path))
-            self.assertFalse(os.path.isdir(path))
-        finally:
-            shutil.rmtree(parent_dir)
-
-    def test_temp_dir__path_none(self):
-        """Test passing no path."""
-        with support.temp_dir() as temp_path:
-            self.assertTrue(os.path.isdir(temp_path))
-        self.assertFalse(os.path.isdir(temp_path))
-
-    def test_temp_dir__existing_dir__quiet_default(self):
-        """Test passing a directory that already exists."""
-        def call_temp_dir(path):
-            with support.temp_dir(path) as temp_path:
-                raise Exception("should not get here")
-
-        path = tempfile.mkdtemp()
-        path = os.path.realpath(path)
-        try:
-            self.assertTrue(os.path.isdir(path))
-            self.assertRaises(FileExistsError, call_temp_dir, path)
-            # Make sure temp_dir did not delete the original directory.
-            self.assertTrue(os.path.isdir(path))
-        finally:
-            shutil.rmtree(path)
-
-    def test_temp_dir__existing_dir__quiet_true(self):
-        """Test passing a directory that already exists with quiet=True."""
-        path = tempfile.mkdtemp()
-        path = os.path.realpath(path)
-
-        try:
-            with support.check_warnings() as recorder:
-                with support.temp_dir(path, quiet=True) as temp_path:
-                    self.assertEqual(path, temp_path)
-                warnings = [str(w.message) for w in recorder.warnings]
-            # Make sure temp_dir did not delete the original directory.
-            self.assertTrue(os.path.isdir(path))
-        finally:
-            shutil.rmtree(path)
-
-        expected = ['tests may fail, unable to create temp dir: ' + path]
-        self.assertEqual(warnings, expected)
-
-    # Tests for change_cwd()
-
-    def test_change_cwd(self):
-        original_cwd = os.getcwd()
-
-        with support.temp_dir() as temp_path:
-            with support.change_cwd(temp_path) as new_cwd:
-                self.assertEqual(new_cwd, temp_path)
-                self.assertEqual(os.getcwd(), new_cwd)
-
-        self.assertEqual(os.getcwd(), original_cwd)
-
-    def test_change_cwd__non_existent_dir(self):
-        """Test passing a non-existent directory."""
-        original_cwd = os.getcwd()
-
-        def call_change_cwd(path):
-            with support.change_cwd(path) as new_cwd:
-                raise Exception("should not get here")
-
-        with support.temp_dir() as parent_dir:
-            non_existent_dir = os.path.join(parent_dir, 'does_not_exist')
-            self.assertRaises(FileNotFoundError, call_change_cwd,
-                              non_existent_dir)
-
-        self.assertEqual(os.getcwd(), original_cwd)
-
-    def test_change_cwd__non_existent_dir__quiet_true(self):
-        """Test passing a non-existent directory with quiet=True."""
-        original_cwd = os.getcwd()
-
-        with support.temp_dir() as parent_dir:
-            bad_dir = os.path.join(parent_dir, 'does_not_exist')
-            with support.check_warnings() as recorder:
-                with support.change_cwd(bad_dir, quiet=True) as new_cwd:
-                    self.assertEqual(new_cwd, original_cwd)
-                    self.assertEqual(os.getcwd(), new_cwd)
-                warnings = [str(w.message) for w in recorder.warnings]
-
-        expected = ['tests may fail, unable to change CWD to: ' + bad_dir]
-        self.assertEqual(warnings, expected)
-
-    # Tests for change_cwd()
-
-    def test_change_cwd__chdir_warning(self):
-        """Check the warning message when os.chdir() fails."""
-        path = TESTFN + '_does_not_exist'
-        with support.check_warnings() as recorder:
-            with support.change_cwd(path=path, quiet=True):
-                pass
-            messages = [str(w.message) for w in recorder.warnings]
-        self.assertEqual(messages, ['tests may fail, unable to change CWD to: ' + path])
-
-    # Tests for temp_cwd()
-
     def test_temp_cwd(self):
         here = os.getcwd()
         with support.temp_cwd(name=TESTFN):
@@ -208,15 +95,14 @@
         self.assertFalse(os.path.exists(TESTFN))
         self.assertTrue(os.path.basename(os.getcwd()), here)
 
-
-    def test_temp_cwd__name_none(self):
-        """Test passing None to temp_cwd()."""
-        original_cwd = os.getcwd()
-        with support.temp_cwd(name=None) as new_cwd:
-            self.assertNotEqual(new_cwd, original_cwd)
-            self.assertTrue(os.path.isdir(new_cwd))
-            self.assertEqual(os.getcwd(), new_cwd)
-        self.assertEqual(os.getcwd(), original_cwd)
+    def test_temp_cwd__chdir_warning(self):
+        """Check the warning message when os.chdir() fails."""
+        path = TESTFN + '_does_not_exist'
+        with support.check_warnings() as recorder:
+            with support.temp_cwd(path=path, quiet=True):
+                pass
+            messages = [str(w.message) for w in recorder.warnings]
+        self.assertEqual(messages, ['tests may fail, unable to change the CWD to ' + path])
 
     def test_sortdict(self):
         self.assertEqual(support.sortdict({3:3, 2:2, 1:1}), "{1: 1, 2: 2, 3: 3}")
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_sys.py
--- a/Lib/test/test_sys.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_sys.py	Mon Aug 12 02:18:40 2013 +0200
@@ -515,7 +515,7 @@
         attrs = ("debug",
                  "inspect", "interactive", "optimize", "dont_write_bytecode",
                  "no_user_site", "no_site", "ignore_environment", "verbose",
-                 "bytes_warning", "quiet", "hash_randomization", "isolated")
+                 "bytes_warning", "quiet", "hash_randomization")
         for attr in attrs:
             self.assertTrue(hasattr(sys.flags, attr), attr)
             self.assertEqual(type(getattr(sys.flags, attr)), int, attr)
@@ -764,7 +764,7 @@
         nfrees = len(x.f_code.co_freevars)
         extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
                   ncells + nfrees - 1
-        check(x, vsize('13P3ic' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
+        check(x, vsize('12P3i' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
         # function
         def func(): pass
         check(func, size('12P'))
@@ -810,7 +810,7 @@
         # memoryview
         check(memoryview(b''), size('Pnin 2P2n2i5P 3cPn'))
         # module
-        check(unittest, size('PnPPP'))
+        check(unittest, size('PnP'))
         # None
         check(None, size(''))
         # NotImplementedType
@@ -864,11 +864,11 @@
         check((1,2,3), vsize('') + 3*self.P)
         # type
         # static type: PyTypeObject
-        s = vsize('P2n15Pl4Pn9Pn11PIP')
+        s = vsize('P2n15Pl4Pn9Pn11PI')
         check(int, s)
         # (PyTypeObject + PyNumberMethods + PyMappingMethods +
         #  PySequenceMethods + PyBufferProcs + 4P)
-        s = vsize('P2n15Pl4Pn9Pn11PIP') + struct.calcsize('34P 3P 10P 2P 4P')
+        s = vsize('P2n15Pl4Pn9Pn11PI') + struct.calcsize('34P 3P 10P 2P 4P')
         # Separate block for PyDictKeysObject with 4 entries
         s += struct.calcsize("2nPn") + 4*struct.calcsize("n2P")
         # class
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_tempfile.py
--- a/Lib/test/test_tempfile.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_tempfile.py	Mon Aug 12 02:18:40 2013 +0200
@@ -333,6 +333,8 @@
             v="q"
 
         file = self.do_create()
+        if hasattr(os, 'get_inheritable'):
+            self.assertEqual(os.get_inheritable(file.fd), False)
         fd = "%d" % file.fd
 
         try:
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_traceback.py
--- a/Lib/test/test_traceback.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_traceback.py	Mon Aug 12 02:18:40 2013 +0200
@@ -150,17 +150,11 @@
 
 class TracebackFormatTests(unittest.TestCase):
 
-    def some_exception(self):
-        raise KeyError('blah')
-
-    def check_traceback_format(self, cleanup_func=None):
+    def test_traceback_format(self):
         try:
-            self.some_exception()
+            raise KeyError('blah')
         except KeyError:
             type_, value, tb = sys.exc_info()
-            if cleanup_func is not None:
-                # Clear the inner frames, not this one
-                cleanup_func(tb.tb_next)
             traceback_fmt = 'Traceback (most recent call last):\n' + \
                             ''.join(traceback.format_tb(tb))
             file_ = StringIO()
@@ -189,22 +183,12 @@
 
         # Make sure that the traceback is properly indented.
         tb_lines = python_fmt.splitlines()
-        self.assertEqual(len(tb_lines), 5)
-        banner = tb_lines[0]
-        location, source_line = tb_lines[-2:]
+        self.assertEqual(len(tb_lines), 3)
+        banner, location, source_line = tb_lines
         self.assertTrue(banner.startswith('Traceback'))
         self.assertTrue(location.startswith('  File'))
         self.assertTrue(source_line.startswith('    raise'))
 
-    def test_traceback_format(self):
-        self.check_traceback_format()
-
-    def test_traceback_format_with_cleared_frames(self):
-        # Check that traceback formatting also works with a clear()ed frame
-        def cleanup_tb(tb):
-            tb.tb_frame.clear()
-        self.check_traceback_format(cleanup_tb)
-
     def test_stack_format(self):
         # Verify _stack functions. Note we have to use _getframe(1) to
         # compare them without this frame appearing in the output
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_unicode.py
--- a/Lib/test/test_unicode.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_unicode.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1735,6 +1735,8 @@
         self.assertRaises(TypeError, "hello".encode, 42, 42, 42)
 
         # Error handling (lone surrogate in PyUnicode_TransformDecimalToASCII())
+        self.assertRaises(UnicodeError, int, "\ud800")
+        self.assertRaises(UnicodeError, int, "\udf00")
         self.assertRaises(UnicodeError, float, "\ud800")
         self.assertRaises(UnicodeError, float, "\udf00")
         self.assertRaises(UnicodeError, complex, "\ud800")
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_wave.py
--- a/Lib/test/test_wave.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_wave.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1,5 +1,7 @@
-from test.support import TESTFN, unlink
+from test.support import TESTFN, run_unittest
+import os
 import wave
+import struct
 import unittest
 
 nchannels = 2
@@ -15,7 +17,10 @@
     def tearDown(self):
         if self.f is not None:
             self.f.close()
-        unlink(TESTFN)
+        try:
+            os.remove(TESTFN)
+        except OSError:
+            pass
 
     def test_it(self, test_rounding=False):
         self.f = wave.open(TESTFN, 'wb')
@@ -69,49 +74,9 @@
         self.assertEqual(params.comptype, self.f.getcomptype())
         self.assertEqual(params.compname, self.f.getcompname())
 
-    def test_wave_write_context_manager_calls_close(self):
-        # Close checks for a minimum header and will raise an error
-        # if it is not set, so this proves that close is called.
-        with self.assertRaises(wave.Error):
-            with wave.open(TESTFN, 'wb') as f:
-                pass
-        with self.assertRaises(wave.Error):
-            with open(TESTFN, 'wb') as testfile:
-                with wave.open(testfile):
-                    pass
 
-    def test_context_manager_with_open_file(self):
-        with open(TESTFN, 'wb') as testfile:
-            with wave.open(testfile) as f:
-                f.setnchannels(nchannels)
-                f.setsampwidth(sampwidth)
-                f.setframerate(framerate)
-            self.assertFalse(testfile.closed)
-        with open(TESTFN, 'rb') as testfile:
-            with wave.open(testfile) as f:
-                self.assertFalse(f.getfp().closed)
-                params = f.getparams()
-                self.assertEqual(params.nchannels, nchannels)
-                self.assertEqual(params.sampwidth, sampwidth)
-                self.assertEqual(params.framerate, framerate)
-            self.assertIsNone(f.getfp())
-            self.assertFalse(testfile.closed)
-
-    def test_context_manager_with_filename(self):
-        # If the file doesn't get closed, this test won't fail, but it will
-        # produce a resource leak warning.
-        with wave.open(TESTFN, 'wb') as f:
-            f.setnchannels(nchannels)
-            f.setsampwidth(sampwidth)
-            f.setframerate(framerate)
-        with wave.open(TESTFN) as f:
-            self.assertFalse(f.getfp().closed)
-            params = f.getparams()
-            self.assertEqual(params.nchannels, nchannels)
-            self.assertEqual(params.sampwidth, sampwidth)
-            self.assertEqual(params.framerate, framerate)
-        self.assertIsNone(f.getfp())
-
+def test_main():
+    run_unittest(TestWave)
 
 if __name__ == '__main__':
-    unittest.main()
+    test_main()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_xml_etree.py
--- a/Lib/test/test_xml_etree.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_xml_etree.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1839,20 +1839,6 @@
             summarize_list(e.findall(".//{http://effbot.org/ns}tag")),
             ['{http://effbot.org/ns}tag'] * 3)
 
-    def test_findall_different_nsmaps(self):
-        root = ET.XML('''
-            <a xmlns:x="X" xmlns:y="Y">
-                <x:b><c/></x:b>
-                <b/>
-                <c><x:b/><b/></c><y:b/>
-            </a>''')
-        nsmap = {'xx': 'X'}
-        self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2)
-        self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2)
-        nsmap = {'xx': 'Y'}
-        self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1)
-        self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2)
-
     def test_bad_find(self):
         e = ET.XML(SAMPLE_XML)
         with self.assertRaisesRegex(SyntaxError, 'cannot use absolute path'):
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/test/test_xmlrpc.py
--- a/Lib/test/test_xmlrpc.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/test/test_xmlrpc.py	Mon Aug 12 02:18:40 2013 +0200
@@ -3,7 +3,6 @@
 import sys
 import time
 import unittest
-from unittest import mock
 import xmlrpc.client as xmlrpclib
 import xmlrpc.server
 import http.client
@@ -254,14 +253,7 @@
 
 class DateTimeTestCase(unittest.TestCase):
     def test_default(self):
-        with mock.patch('time.localtime') as localtime_mock:
-            time_struct = time.struct_time(
-                [2013, 7, 15, 0, 24, 49, 0, 196, 0])
-            localtime_mock.return_value = time_struct
-            localtime = time.localtime()
-            t = xmlrpclib.DateTime()
-            self.assertEqual(str(t),
-                             time.strftime("%Y%m%dT%H:%M:%S", localtime))
+        t = xmlrpclib.DateTime()
 
     def test_time(self):
         d = 1181399930.036952
@@ -298,7 +290,7 @@
         self.assertEqual(t1, tref)
 
         t2 = xmlrpclib._datetime(d)
-        self.assertEqual(t2, tref)
+        self.assertEqual(t1, tref)
 
     def test_comparison(self):
         now = datetime.datetime.now()
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/unittest/test/test_assertions.py
--- a/Lib/unittest/test/test_assertions.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/unittest/test/test_assertions.py	Mon Aug 12 02:18:40 2013 +0200
@@ -34,10 +34,6 @@
         self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
         self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)
 
-        self.assertAlmostEqual(1.0, 1.0, delta=0.5)
-        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
-                          1.0, 1.0, delta=0.5)
-
         self.assertRaises(self.failureException, self.assertAlmostEqual,
                           1.1, 1.0, delta=0.05)
         self.assertRaises(self.failureException, self.assertNotAlmostEqual,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/wave.py
--- a/Lib/wave.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/wave.py	Mon Aug 12 02:18:40 2013 +0200
@@ -167,13 +167,6 @@
 
     def __del__(self):
         self.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
     #
     # User visible methods.
     #
@@ -330,12 +323,6 @@
     def __del__(self):
         self.close()
 
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
     #
     # User visible methods.
     #
@@ -448,13 +435,11 @@
 
     def close(self):
         if self._file:
-            try:
-                self._ensure_header_written(0)
-                if self._datalength != self._datawritten:
-                    self._patchheader()
-                self._file.flush()
-            finally:
-                self._file = None
+            self._ensure_header_written(0)
+            if self._datalength != self._datawritten:
+                self._patchheader()
+            self._file.flush()
+            self._file = None
         if self._i_opened_the_file:
             self._i_opened_the_file.close()
             self._i_opened_the_file = None
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/xml/etree/ElementPath.py
--- a/Lib/xml/etree/ElementPath.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/xml/etree/ElementPath.py	Mon Aug 12 02:18:40 2013 +0200
@@ -249,12 +249,10 @@
 
 def iterfind(elem, path, namespaces=None):
     # compile selector pattern
-    cache_key = (path, None if namespaces is None
-                            else tuple(sorted(namespaces.items())))
     if path[-1:] == "/":
         path = path + "*" # implicit all (FIXME: keep this?)
     try:
-        selector = _cache[cache_key]
+        selector = _cache[path]
     except KeyError:
         if len(_cache) > 100:
             _cache.clear()
@@ -274,7 +272,7 @@
                     token = next()
             except StopIteration:
                 break
-        _cache[cache_key] = selector
+        _cache[path] = selector
     # execute selector pattern
     result = [elem]
     context = _SelectorContext(elem)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Lib/xmlrpc/server.py
--- a/Lib/xmlrpc/server.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Lib/xmlrpc/server.py	Mon Aug 12 02:18:40 2013 +0200
@@ -584,13 +584,6 @@
         SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding, use_builtin_types)
         socketserver.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
 
-        # [Bug #1222790] If possible, set close-on-exec flag; if a
-        # method spawns a subprocess, the subprocess shouldn't have
-        # the listening socket open.
-        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
-            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
-            flags |= fcntl.FD_CLOEXEC
-            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
 
 class MultiPathXMLRPCServer(SimpleXMLRPCServer):
     """Multipath XML-RPC Server
@@ -756,23 +749,20 @@
             self.escape(anchor), self.escape(name))
 
         if inspect.ismethod(object):
-            args = inspect.getfullargspec(object)
+            args, varargs, varkw, defaults = inspect.getargspec(object)
             # exclude the argument bound to the instance, it will be
             # confusing to the non-Python user
             argspec = inspect.formatargspec (
-                    args.args[1:],
-                    args.varargs,
-                    args.varkw,
-                    args.defaults,
-                    annotations=args.annotations,
+                    args[1:],
+                    varargs,
+                    varkw,
+                    defaults,
                     formatvalue=self.formatvalue
                 )
         elif inspect.isfunction(object):
-            args = inspect.getfullargspec(object)
+            args, varargs, varkw, defaults = inspect.getargspec(object)
             argspec = inspect.formatargspec(
-                args.args, args.varargs, args.varkw, args.defaults,
-                annotations=args.annotations,
-                formatvalue=self.formatvalue)
+                args, varargs, varkw, defaults, formatvalue=self.formatvalue)
         else:
             argspec = '(...)'
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Mac/BuildScript/build-installer.py
--- a/Mac/BuildScript/build-installer.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Mac/BuildScript/build-installer.py	Mon Aug 12 02:18:40 2013 +0200
@@ -982,62 +982,22 @@
     # the end-users system. Also remove the directories from _sysconfigdata.py
     # (added in 3.3) if it exists.
 
-    include_path = '-I%s/libraries/usr/local/include' % (WORKDIR,)
-    lib_path = '-L%s/libraries/usr/local/lib' % (WORKDIR,)
-
     path_to_lib = os.path.join(rootDir, 'Library', 'Frameworks',
                                 'Python.framework', 'Versions',
                                 version, 'lib', 'python%s'%(version,))
-
-    # fix Makefile
-    path = os.path.join(path_to_lib, 'config' + config_suffix, 'Makefile')
-    fp = open(path, 'r')
-    data = fp.read()
-    fp.close()
-
-    for p in (include_path, lib_path):
-        data = data.replace(" " + p, '')
-        data = data.replace(p + " ", '')
-
-    fp = open(path, 'w')
-    fp.write(data)
-    fp.close()
-
-    # fix _sysconfigdata if it exists
-    #
-    # TODO: make this more robust!  test_sysconfig_module of
-    # distutils.tests.test_sysconfig.SysconfigTestCase tests that
-    # the output from get_config_var in both sysconfig and
-    # distutils.sysconfig is exactly the same for both CFLAGS and
-    # LDFLAGS.  The fixing up is now complicated by the pretty
-    # printing in _sysconfigdata.py.  Also, we are using the
-    # pprint from the Python running the installer build which
-    # may not cosmetically format the same as the pprint in the Python
-    # being built (and which is used to originally generate
-    # _sysconfigdata.py).
-
-    import pprint
-    path = os.path.join(path_to_lib, '_sysconfigdata.py')
-    if os.path.exists(path):
+    paths = [os.path.join(path_to_lib, 'config' + config_suffix, 'Makefile'),
+             os.path.join(path_to_lib, '_sysconfigdata.py')]
+    for path in paths:
+        if not os.path.exists(path):
+            continue
         fp = open(path, 'r')
         data = fp.read()
         fp.close()
-        # create build_time_vars dict
-        exec(data)
-        vars = {}
-        for k, v in build_time_vars.items():
-            if type(v) == type(''):
-                for p in (include_path, lib_path):
-                    v = v.replace(' ' + p, '')
-                    v = v.replace(p + ' ', '')
-            vars[k] = v
 
+        data = data.replace(' -L%s/libraries/usr/local/lib'%(WORKDIR,), '')
+        data = data.replace(' -I%s/libraries/usr/local/include'%(WORKDIR,), '')
         fp = open(path, 'w')
-        # duplicated from sysconfig._generate_posix_vars()
-        fp.write('# system configuration generated and used by'
-                    ' the sysconfig module\n')
-        fp.write('build_time_vars = ')
-        pprint.pprint(vars, stream=fp)
+        fp.write(data)
         fp.close()
 
     # Add symlinks in /usr/local/bin, using relative links
diff -r 9e61563edb67 -r 1f8979a8c2c5 Makefile.pre.in
--- a/Makefile.pre.in	Sun Aug 11 16:48:44 2013 -0700
+++ b/Makefile.pre.in	Mon Aug 12 02:18:40 2013 +0200
@@ -211,12 +211,6 @@
 PROFILE_TASK=	$(srcdir)/Tools/pybench/pybench.py -n 2 --with-gc --with-syscheck
 #PROFILE_TASK=	$(srcdir)/Lib/test/regrtest.py
 
-# report files for gcov / lcov coverage report
-COVERAGE_INFO=	$(abs_builddir)/coverage.info
-COVERAGE_REPORT=$(abs_builddir)/lcov-report
-COVERAGE_REPORT_OPTIONS=--no-branch-coverage --title "CPython lcov report"
-
-
 # === Definitions added by makesetup ===
 
 
@@ -469,48 +463,11 @@
 build_all_use_profile:
 	$(MAKE) all CFLAGS="$(CFLAGS) -fprofile-use -fprofile-correction"
 
-# Compile and run with gcov
-.PHONY=coverage coverage-lcov coverage-report
 coverage:
 	@echo "Building with support for coverage checking:"
-	$(MAKE) clean profile-removal
+	$(MAKE) clean
 	$(MAKE) all CFLAGS="$(CFLAGS) -O0 -pg -fprofile-arcs -ftest-coverage" LIBS="$(LIBS) -lgcov"
 
-coverage-lcov:
-	@echo "Creating Coverage HTML report with LCOV:"
-	@rm -f $(COVERAGE_INFO)
-	@rm -rf $(COVERAGE_REPORT)
-	@lcov --capture --directory $(abs_builddir) \
-	    --base-directory $(realpath $(abs_builddir)) \
-	    --path $(realpath $(abs_srcdir)) \
-	    --output-file $(COVERAGE_INFO)
-	: # remove 3rd party modules and system headers
-	@lcov --remove $(COVERAGE_INFO) \
-	    '*/Modules/_ctypes/libffi*/*' \
-	    '*/Modules/_sha3/keccak/*' \
-	    '*/Modules/_decimal/libmpdec/*' \
-	    '*/Modules/expat/*' \
-	    '*/Modules/zlib/*' \
-	    '*/Include/*' \
-	    '/usr/include/*' \
-	    '/usr/local/include/*' \
-	    --output-file $(COVERAGE_INFO)
-	@genhtml $(COVERAGE_INFO) --output-directory $(COVERAGE_REPORT) \
-	    $(COVERAGE_REPORT_OPTIONS)
-	@echo
-	@echo "lcov report at $(COVERAGE_REPORT)/index.html"
-	@echo
-
-coverage-report:
-	: # force rebuilding of parser and importlib
-	@touch $(GRAMMAR_INPUT)
-	@touch $(srcdir)/Lib/importlib/_bootstrap.py
-	: # build with coverage info
-	$(MAKE) coverage
-	: # run tests, ignore failures
-	$(TESTRUNNER) $(TESTOPTS) || true
-	: # build lcov report
-	$(MAKE) coverage-lcov
 
 # Build the interpreter
 $(BUILDPYTHON):	Modules/python.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY)
@@ -1055,7 +1012,7 @@
 		tkinter/test/test_ttk site-packages test \
 		test/capath test/data \
 		test/cjkencodings test/decimaltestdata test/xmltestdata \
-		test/subprocessdata test/sndhdrdata test/support \
+		test/subprocessdata test/sndhdrdata \
 		test/tracedmodules test/encoded_modules \
 		test/namespace_pkgs \
 		test/namespace_pkgs/both_portions \
@@ -1079,7 +1036,7 @@
                 test/namespace_pkgs/module_and_namespace_package/a_test \
 		collections concurrent concurrent/futures encodings \
 		email email/mime test/test_email test/test_email/data \
-		html json test/test_json http dbm xmlrpc \
+		html json test/json_tests http dbm xmlrpc \
 		sqlite3 sqlite3/test \
 		logging csv wsgiref urllib \
 		lib2to3 lib2to3/fixes lib2to3/pgen2 lib2to3/tests \
@@ -1201,13 +1158,6 @@
 	sed -e "s,@EXENAME@,$(BINDIR)/python$(LDVERSION)$(EXE)," < $(srcdir)/Misc/python-config.in >python-config.py
 	# Replace makefile compat. variable references with shell script compat. ones; $(VAR) -> ${VAR}
 	sed -e 's,\$$(\([A-Za-z0-9_]*\)),\$$\{\1\},g' < Misc/python-config.sh >python-config
-	# On Darwin, always use the python version of the script, the shell
-	# version doesn't use the compiler customizations that are provided
-	# in python (_osx_support.py).
-	if test `uname -s` = Darwin; then \
-		cp python-config.py python-config; \
-	fi
-
 
 # Install the include files
 INCLDIRSTOMAKE=$(INCLUDEDIR) $(CONFINCLUDEDIR) $(INCLUDEPY) $(CONFINCLUDEPY)
@@ -1446,8 +1396,6 @@
 
 profile-removal:
 	find . -name '*.gc??' -exec rm -f {} ';'
-	rm -f $(COVERAGE_INFO)
-	rm -rf $(COVERAGE_REPORT)
 
 clobber: clean profile-removal
 	-rm -f $(BUILDPYTHON) $(PGEN) $(LIBRARY) $(LDLIBRARY) $(DLLLIBRARY) \
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/ACKS
--- a/Misc/ACKS	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/ACKS	Mon Aug 12 02:18:40 2013 +0200
@@ -288,6 +288,7 @@
 Kushal Das
 Jonathan Dasteel
 Pierre-Yves David
+Xavier de Gaye
 John DeGood
 Ned Deily
 Vincent Delft
@@ -350,6 +351,7 @@
 Phil Elson
 David Ely
 Jeff Epler
+Jeff McNeil
 Tom Epperly
 Gökcen Eraslan
 Stoffel Erasmus
@@ -630,6 +632,7 @@
 Peter van Kampen
 Rafe Kaplan
 Jacob Kaplan-Moss
+Jan Kaliszewski
 Janne Karila
 Per Øyvind Karlsen
 Anton Kasyanov
@@ -701,7 +704,6 @@
 Cameron Laird
 David Lam
 Thomas Lamb
-Valerie Lambert
 Jean-Baptiste "Jiba" Lamy
 Ronan Lamy
 Torsten Landschoff
@@ -735,7 +737,6 @@
 Luke Kenneth Casson Leighton
 Tshepang Lekhonkhobe
 Marc-André Lemburg
-Mateusz Lenik
 John Lenton
 Kostyantyn Leschenko
 Benno Leslie
@@ -773,7 +774,6 @@
 Lukas Lueg
 Loren Luke
 Fredrik Lundh
-Zhongyue Luo
 Mark Lutz
 Taras Lyapun
 Jim Lynch
@@ -1237,7 +1237,6 @@
 Amir Szekely
 Arfrever Frehtes Taifersar Arahesis
 Hideaki Takahashi
-Indra Talip
 Neil Tallim
 Geoff Talvola
 Musashi Tamura
@@ -1291,7 +1290,6 @@
 Stephen Turner
 Theodore Turocy
 Bill Tutt
-Fraser Tweedale
 Doobee R. Tzeck
 Eren Türkay
 Lionel Ulmer
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/NEWS
--- a/Misc/NEWS	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/NEWS	Mon Aug 12 02:18:40 2013 +0200
@@ -2,72 +2,14 @@
 Python News
 +++++++++++
 
-What's New in Python 3.4.0 Alpha 2?
+What's New in Python 3.4.0 Alpha 1?
 ===================================
 
-Projected Release date: 2013-09-08
+*Relase date: 2014-XX-XX*
 
 Core and Builtins
 -----------------
 
-- Issue #16499: Add command line option for isolated mode.
-
-- Issue #15301: Parsing fd, uid, and gid parameters for builtins
-  in Modules/posixmodule.c is now far more robust.
-
-- Issue #18368: PyOS_StdioReadline() no longer leaks memory when realloc()
-  fail.
-
-- Issue #17934: Add a clear() method to frame objects, to help clean up
-  expensive details (local variables) and break reference cycles.
-
-Library
--------
-
-- Issue #18676: Change 'positive' to 'non-negative' in queue.py put and get
-  docstrings and ValueError messages. Patch by Zhongyue Luo
-
-- Fix refcounting issue with extension types in tkinter.
-
-- Issue #8112: xlmrpc.server's DocXMLRPCServer server no longer raises an error
-  if methods have annotations; it now correctly displays the annotations.
-
-- Issue #18600: Added policy argument to email.message.Message.as_string,
-  and as_bytes and __bytes__ methods to Message.
-
-- Issue #18671: Output more information when logging exceptions occur.
-
-- Issue #18621: Prevent the site module's patched builtins from keeping
-  too many references alive for too long.
-
-- Issue #4885: Add weakref support to mmap objects.  Patch by Valerie Lambert.
-
-- Issue #8860: Fixed rounding in timedelta constructor.
-
-
-What's New in Python 3.4.0 Alpha 1?
-===================================
-
-Release date: 2013-08-03
-
-Core and Builtins
------------------
-
-- Issue #16741: Fix an error reporting in int().
-
-- Issue #17899: Fix rare file descriptor leak in os.listdir().
-
-- Issue #10241: Clear extension module dict copies at interpreter shutdown.
-  Patch by Neil Schemenauer, minimally modified.
-
-- Issue #9035: ismount now recognises volumes mounted below a drive root
-  on Windows. Original patch by Atsuo Ishimoto.
-
-- Issue #18214: Improve finalization of Python modules to avoid setting
-  their globals to None, in most cases.
-
-- Issue #18112: PEP 442 implementation (safe object finalization).
-
 - Issue #18552: Check return value of PyArena_AddPyObject() in
   obj2ast_object().
 
@@ -229,34 +171,6 @@
 Library
 -------
 
-- Issue #18681: Fix a NameError in importlib.reload() (noticed by Weizhao Li).
-
-- Issue #14323: Expanded the number of digits in the coefficients for the
-  RGB -- YIQ conversions so that they match the FCC NTSC versions.
-
-- Issue #17998: Fix an internal error in regular expression engine.
-
-- Issue #17557: Fix os.getgroups() to work with the modified behavior of
-  getgroups(2) on OS X 10.8.  Original patch by Mateusz Lenik.
-
-- Issue #18608: Avoid keeping a strong reference to the locale module
-  inside the _io module.
-
-- Issue #18619: Fix atexit leaking callbacks registered from sub-interpreters,
-  and make it GC-aware.
-
-- Issue #15699: The readline module now uses PEP 3121-style module
-  initialization, so as to reclaim allocated resources (Python callbacks)
-  at shutdown.  Original patch by Robin Schreiber.
-
-- Issue #17616: wave.open now supports the context manager protocol.
-
-- Issue #18599: Fix name attribute of _sha1.sha1() object. It now returns
-  'SHA1' instead of 'SHA'.
-
-- Issue #13266: Added inspect.unwrap to easily unravel __wrapped__ chains
-  (initial patch by Daniel Urban and Aaron Iles)
-
 - Issue #18561: Skip name in ctypes' _build_callargs() if name is NULL.
 
 - Issue #18559: Fix NULL pointer dereference error in _pickle module
@@ -370,9 +284,6 @@
   when \r\n appears at end of 65535 bytes without other newlines.
 
 - Issue #18076: Introduce importlib.util.decode_source().
-- Issue #18357: add tests for dictview set difference.
-  Patch by Fraser Tweedale.
-
 
 - importlib.abc.SourceLoader.get_source() no longer changes SyntaxError or
   UnicodeDecodeError into ImportError.
@@ -657,22 +568,6 @@
 Tests
 -----
 
-- Issue #18273: move the tests in Lib/test/json_tests to Lib/test/test_json
-  and make them discoverable by unittest.  Patch by Zachary Ware.
-
-- Fix a fcntl test case on KFreeBSD, Debian #708653 (Petr Salinger).
-
-- Issue #18396: Fix spurious test failure in test_signal on Windows when
-  faulthandler is enabled (Patch by Jeremy Kloth)
-
-- Issue #17046: Fix broken test_executable_without_cwd in test_subprocess.
-
-- Issue #15415: Add new temp_dir() and change_cwd() context managers to
-  test.support, and refactor temp_cwd() to use them.  Patch by Chris Jerdonek.
-
-- Issue #15494: test.support is now a package rather than a module (Initial
-  patch by Indra Talip)
-
 - Issue #17944: test_zipfile now discoverable and uses subclassing to
   generate tests for different compression types.  Fixed a bug with skipping
   some tests due to use of exhausted iterators.
@@ -778,13 +673,6 @@
 IDLE
 ----
 
-- Issue #18429: Format / Format Paragraph, now works when comment blocks
-  are selected. As with text blocks, this works best when the selection
-  only includes complete lines.
-
-- Issue #18226: Add docstrings and unittests for FormatParagraph.py.
-  Original patches by Todd Rovito and Phil Webster.
-
 - Issue #18279: Format - Strip trailing whitespace no longer marks a file as
   changed when it has not been changed. This fix followed the addition of a
   test file originally written by Phil Webster (the issue's main goal).
@@ -820,25 +708,9 @@
 - Issue #17532: Always include Options menu for IDLE on OS X.
   Patch by Guilherme Simões.
 
-Windows
--------
-
-- Issue #18569: The installer now adds .py to the PATHEXT variable when extensions
-  are registered. Patch by Paul Moore.
-
 Build
 -----
 
-- Issue #16067: Add description into MSI file to replace installer's
-  temporary name.
-
-- Issue #18257: Fix readlink usage in python-config.  Install the python
-  version again on Darwin.
-
-- Issue #18481: Add C coverage reporting with gcov and lcov. A new make target
-  "coverage-report" creates an instrumented Python build, runs unit tests
-  and creates a HTML. The report can be updated with "make coverage-lcov".
-
 - Issue #17845: Clarified the message printed when some module are not built.
 
 - Issue #18256: Compilation fix for recent AIX releases.  Patch by
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/README
--- a/Misc/README	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/README	Mon Aug 12 02:18:40 2013 +0200
@@ -22,7 +22,8 @@
 README.coverity         Information about running Coverity's Prevent on Python
 README.valgrind         Information for Valgrind users, see valgrind-python.supp
 RPM                     (Old) tools to build RPMs
+svnmap.txt              Map of old SVN revs and branches to hg changeset ids
 SpecialBuilds.txt       Describes extra symbols you can set for debug builds
-svnmap.txt              Map of old SVN revs and branches to hg changeset ids
+TextMate                A TextMate bundle for Python development
 valgrind-python.supp    Valgrind suppression file, see README.valgrind
 vgrindefs               Python configuration for vgrind (a generic pretty printer)
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/RPM/python-3.4.spec
--- a/Misc/RPM/python-3.4.spec	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/RPM/python-3.4.spec	Mon Aug 12 02:18:40 2013 +0200
@@ -39,7 +39,7 @@
 
 %define name python
 #--start constants--
-%define version 3.4.0a1
+%define version 3.4.0a0
 %define libvers 3.4
 #--end constants--
 %define release 1pydotorg
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/python-config.in
--- a/Misc/python-config.in	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/python-config.in	Mon Aug 12 02:18:40 2013 +0200
@@ -1,8 +1,6 @@
 #!@EXENAME@
 # -*- python -*-
 
-# Keep this script in sync with python-config.sh.in
-
 import getopt
 import os
 import sys
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/python-config.sh.in
--- a/Misc/python-config.sh.in	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/python-config.sh.in	Mon Aug 12 02:18:40 2013 +0200
@@ -1,7 +1,5 @@
 #!/bin/sh
 
-# Keep this script in sync with python-config.in
-
 exit_with_usage ()
 {
     echo "Usage: $0 --prefix|--exec-prefix|--includes|--libs|--cflags|--ldflags|--extension-suffix|--help|--abiflags|--configdir"
@@ -17,9 +15,7 @@
 {
     RESULT=$(dirname $(cd $(dirname "$1") && pwd -P))
     if which readlink >/dev/null 2>&1 ; then
-        if readlink -f "$RESULT" >/dev/null 2>&1; then
-          RESULT=$(readlink -f "$RESULT")
-        fi
+        RESULT=$(readlink -f "$RESULT")
     fi
     echo $RESULT
 }
@@ -27,8 +23,7 @@
 prefix_build="@prefix@"
 prefix_real=$(installed_prefix "$0")
 
-# Use sed to fix paths from their built-to locations to their installed-to
-# locations.
+# Use sed to fix paths from their built to locations to their installed to locations.
 prefix=$(echo "$prefix_build" | sed "s#$prefix_build#$prefix_real#")
 exec_prefix_build="@exec_prefix@"
 exec_prefix=$(echo "$exec_prefix_build" | sed "s#$exec_prefix_build#$prefix_real#")
diff -r 9e61563edb67 -r 1f8979a8c2c5 Misc/python.man
--- a/Misc/python.man	Sun Aug 11 16:48:44 2013 -0700
+++ b/Misc/python.man	Mon Aug 12 02:18:40 2013 +0200
@@ -26,14 +26,11 @@
 .B \-i
 ]
 [
-.B \-I
+.B \-m
+.I module-name
 ]
 .br
        [
-.B \-m
-.I module-name
-]
-[
 .B \-q
 ]
 [
@@ -142,13 +139,6 @@
 useful to inspect global variables or a stack trace when a script
 raises an exception.
 .TP
-.B \-I
-Run Python in isolated mode. This also implies \fB\-E\fP and \fB\-S\fP. In
-isolated mode sys.path contains neither the script’s directory nor the user’s
-site-packages directory. All PYTHON* environment variables are ignored, too.
-Further restrictions may be imposed to prevent the user from injecting
-malicious code.
-.TP
 .BI "\-m " module-name
 Searches 
 .I sys.path 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_collectionsmodule.c
--- a/Modules/_collectionsmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_collectionsmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -10,14 +10,11 @@
 /* The block length may be set to any number over 1.  Larger numbers
  * reduce the number of calls to the memory allocator, give faster
  * indexing and rotation, and reduce the link::data overhead ratio.
- *
- * Ideally, the block length will be set to two less than some
- * multiple of the cache-line length (so that the full block
- * including the leftlink and rightlink will fit neatly into
- * cache lines).
+ * If the block length is a power-of-two, we also get faster
+ * division/modulo computations during indexing.
  */
 
-#define BLOCKLEN 62
+#define BLOCKLEN 64
 #define CENTER ((BLOCKLEN - 1) / 2)
 
 /* A `dequeobject` is composed of a doubly-linked list of `block` nodes.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_ctypes/callbacks.c
--- a/Modules/_ctypes/callbacks.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_ctypes/callbacks.c	Mon Aug 12 02:18:40 2013 +0200
@@ -98,37 +98,20 @@
     PyObject *py_globals = 0;
     PyCodeObject *py_code = 0;
     PyFrameObject *py_frame = 0;
-    PyObject *exception, *value, *tb;
-
-    /* (Save and) Clear the current exception. Python functions must not be
-       called with an exception set. Calling Python functions happens when
-       the codec of the filesystem encoding is implemented in pure Python. */
-    PyErr_Fetch(&exception, &value, &tb);
 
     py_globals = PyDict_New();
-    if (!py_globals)
-        goto bad;
+    if (!py_globals) goto bad;
     py_code = PyCode_NewEmpty(filename, funcname, lineno);
-    if (!py_code)
-        goto bad;
+    if (!py_code) goto bad;
     py_frame = PyFrame_New(
         PyThreadState_Get(), /*PyThreadState *tstate,*/
         py_code,             /*PyCodeObject *code,*/
         py_globals,          /*PyObject *globals,*/
         0                    /*PyObject *locals*/
         );
-    if (!py_frame)
-        goto bad;
+    if (!py_frame) goto bad;
     py_frame->f_lineno = lineno;
-
-    PyErr_Restore(exception, value, tb);
     PyTraceBack_Here(py_frame);
-
-    Py_DECREF(py_globals);
-    Py_DECREF(py_code);
-    Py_DECREF(py_frame);
-    return;
-
   bad:
     Py_XDECREF(py_globals);
     Py_XDECREF(py_code);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_ctypes/libffi_osx/x86/x86-ffi64.c
--- a/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c	Mon Aug 12 02:18:40 2013 +0200
@@ -46,7 +46,7 @@
 	unsigned long	bytes,
 	unsigned		flags,
 	void*			raddr,
-	void			(*fnaddr)(void),
+	void			(*fnaddr)(),
 	unsigned		ssecount);
 
 /*	All reference to register classes here is identical to the code in
@@ -431,7 +431,7 @@
 void
 ffi_call(
 	ffi_cif*	cif,
-	void		(*fn)(void),
+	void		(*fn)(),
 	void*		rvalue,
 	void**		avalue)
 {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_cursesmodule.c
--- a/Modules/_cursesmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_cursesmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -1702,6 +1702,7 @@
     fd = mkstemp(fn);
     if (fd < 0)
         return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+    _Py_try_set_inheritable(fd, 0);
     fp = fdopen(fd, "wb+");
     if (fp == NULL) {
         close(fd);
@@ -2265,6 +2266,7 @@
     fd = mkstemp(fn);
     if (fd < 0)
         return PyErr_SetFromErrnoWithFilename(PyExc_IOError, fn);
+    _Py_try_set_inheritable(fd, 0);
     fp = fdopen(fd, "wb+");
     if (fp == NULL) {
         close(fd);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_datetimemodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -140,6 +140,19 @@
     return quo;
 }
 
+/* Round a double to the nearest long.  |x| must be small enough to fit
+ * in a C long; this is not checked.
+ */
+static long
+round_to_long(double x)
+{
+    if (x >= 0.0)
+        x = floor(x + 0.5);
+    else
+        x = ceil(x - 0.5);
+    return (long)x;
+}
+
 /* Nearest integer to m / n for integers m and n. Half-integer results
  * are rounded to even.
  */
@@ -1384,7 +1397,7 @@
  */
 
 /* Conversion factors. */
-static PyObject *one = NULL;      /* 1 */
+static PyObject *us_per_us = NULL;      /* 1 */
 static PyObject *us_per_ms = NULL;      /* 1000 */
 static PyObject *us_per_second = NULL;  /* 1000000 */
 static PyObject *us_per_minute = NULL;  /* 1e6 * 60 as Python int */
@@ -2106,7 +2119,7 @@
         goto Done
 
     if (us) {
-        y = accum("microseconds", x, us, one, &leftover_us);
+        y = accum("microseconds", x, us, us_per_us, &leftover_us);
         CLEANUP;
     }
     if (ms) {
@@ -2135,33 +2148,7 @@
     }
     if (leftover_us) {
         /* Round to nearest whole # of us, and add into x. */
-        double whole_us = round(leftover_us);
-        int x_is_odd;
-        PyObject *temp;
-
-        whole_us = round(leftover_us);
-        if (fabs(whole_us - leftover_us) == 0.5) {
-            /* We're exactly halfway between two integers.  In order
-             * to do round-half-to-even, we must determine whether x
-             * is odd. Note that x is odd when it's last bit is 1. The
-             * code below uses bitwise and operation to check the last
-             * bit. */
-	    temp = PyNumber_And(x, one);  /* temp <- x & 1 */
-            if (temp == NULL) {
-                Py_DECREF(x);
-                goto Done;
-            }
-            x_is_odd = PyObject_IsTrue(temp);
-            Py_DECREF(temp);
-            if (x_is_odd == -1) {
-                Py_DECREF(x);
-                goto Done;
-            }
-            whole_us = 2.0 * round((leftover_us + x_is_odd) * 0.5) - x_is_odd;
-        }
-
-        temp = PyLong_FromLong(whole_us);
-
+        PyObject *temp = PyLong_FromLong(round_to_long(leftover_us));
         if (temp == NULL) {
             Py_DECREF(x);
             goto Done;
@@ -2252,14 +2239,22 @@
 {
     PyObject *total_seconds;
     PyObject *total_microseconds;
+    PyObject *one_million;
 
     total_microseconds = delta_to_microseconds((PyDateTime_Delta *)self);
     if (total_microseconds == NULL)
         return NULL;
 
-    total_seconds = PyNumber_TrueDivide(total_microseconds, us_per_second);
+    one_million = PyLong_FromLong(1000000L);
+    if (one_million == NULL) {
+        Py_DECREF(total_microseconds);
+        return NULL;
+    }
+
+    total_seconds = PyNumber_TrueDivide(total_microseconds, one_million);
 
     Py_DECREF(total_microseconds);
+    Py_DECREF(one_million);
     return total_seconds;
 }
 
@@ -5356,12 +5351,12 @@
     assert(DI100Y == 25 * DI4Y - 1);
     assert(DI100Y == days_before_year(100+1));
 
-    one = PyLong_FromLong(1);
+    us_per_us = PyLong_FromLong(1);
     us_per_ms = PyLong_FromLong(1000);
     us_per_second = PyLong_FromLong(1000000);
     us_per_minute = PyLong_FromLong(60000000);
     seconds_per_day = PyLong_FromLong(24 * 3600);
-    if (one == NULL || us_per_ms == NULL || us_per_second == NULL ||
+    if (us_per_us == NULL || us_per_ms == NULL || us_per_second == NULL ||
         us_per_minute == NULL || seconds_per_day == NULL)
         return NULL;
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_elementtree.c
--- a/Modules/_elementtree.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_elementtree.c	Mon Aug 12 02:18:40 2013 +0200
@@ -66,51 +66,10 @@
 static PyTypeObject XMLParser_Type;
 
 
-/* Per-module state; PEP 3121 */
-typedef struct {
-    PyObject *parseerror_obj;
-    PyObject *deepcopy_obj;
-    PyObject *elementpath_obj;
-} elementtreestate;
-
-static struct PyModuleDef elementtreemodule;
-
-/* Given a module object (assumed to be _elementtree), get its per-module
- * state.
- */
-#define ET_STATE(mod) ((elementtreestate *) PyModule_GetState(mod))
-
-/* Find the module instance imported in the currently running sub-interpreter
- * and get its state.
- */
-#define ET_STATE_GLOBAL \
-    ((elementtreestate *) PyModule_GetState(PyState_FindModule(&elementtreemodule)))
-
-static int
-elementtree_clear(PyObject *m)
-{
-    elementtreestate *st = ET_STATE(m);
-    Py_CLEAR(st->parseerror_obj);
-    Py_CLEAR(st->deepcopy_obj);
-    Py_CLEAR(st->elementpath_obj);
-    return 0;
-}
-
-static int
-elementtree_traverse(PyObject *m, visitproc visit, void *arg)
-{
-    elementtreestate *st = ET_STATE(m);
-    Py_VISIT(st->parseerror_obj);
-    Py_VISIT(st->deepcopy_obj);
-    Py_VISIT(st->elementpath_obj);
-    return 0;
-}
-
-static void
-elementtree_free(void *m)
-{
-    elementtree_clear((PyObject *)m);
-}
+/* glue functions (see the init function for details) */
+static PyObject* elementtree_parseerror_obj;
+static PyObject* elementtree_deepcopy_obj;
+static PyObject* elementpath_obj;
 
 /* helpers */
 
@@ -118,11 +77,11 @@
 deepcopy(PyObject* object, PyObject* memo)
 {
     /* do a deep copy of the given object */
+
     PyObject* args;
     PyObject* result;
-    elementtreestate *st = ET_STATE_GLOBAL;
-
-    if (!st->deepcopy_obj) {
+
+    if (!elementtree_deepcopy_obj) {
         PyErr_SetString(
             PyExc_RuntimeError,
             "deepcopy helper not found"
@@ -133,7 +92,7 @@
     args = PyTuple_Pack(2, object, memo);
     if (!args)
         return NULL;
-    result = PyObject_CallObject(st->deepcopy_obj, args);
+    result = PyObject_CallObject(elementtree_deepcopy_obj, args);
     Py_DECREF(args);
     return result;
 }
@@ -1088,7 +1047,6 @@
     PyObject* tag;
     PyObject* namespaces = Py_None;
     static char *kwlist[] = {"path", "namespaces", 0};
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find", kwlist,
                                      &tag, &namespaces))
@@ -1097,7 +1055,7 @@
     if (checkpath(tag) || namespaces != Py_None) {
         _Py_IDENTIFIER(find);
         return _PyObject_CallMethodId(
-            st->elementpath_obj, &PyId_find, "OOO", self, tag, namespaces
+            elementpath_obj, &PyId_find, "OOO", self, tag, namespaces
             );
     }
 
@@ -1125,7 +1083,6 @@
     PyObject* namespaces = Py_None;
     _Py_IDENTIFIER(findtext);
     static char *kwlist[] = {"path", "default", "namespaces", 0};
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:findtext", kwlist,
                                      &tag, &default_value, &namespaces))
@@ -1133,7 +1090,7 @@
 
     if (checkpath(tag) || namespaces != Py_None)
         return _PyObject_CallMethodId(
-            st->elementpath_obj, &PyId_findtext, "OOOO", self, tag, default_value, namespaces
+            elementpath_obj, &PyId_findtext, "OOOO", self, tag, default_value, namespaces
             );
 
     if (!self->extra) {
@@ -1165,7 +1122,6 @@
     PyObject* tag;
     PyObject* namespaces = Py_None;
     static char *kwlist[] = {"path", "namespaces", 0};
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:findall", kwlist,
                                      &tag, &namespaces))
@@ -1174,7 +1130,7 @@
     if (checkpath(tag) || namespaces != Py_None) {
         _Py_IDENTIFIER(findall);
         return _PyObject_CallMethodId(
-            st->elementpath_obj, &PyId_findall, "OOO", self, tag, namespaces
+            elementpath_obj, &PyId_findall, "OOO", self, tag, namespaces
             );
     }
 
@@ -1206,14 +1162,13 @@
     PyObject* namespaces = Py_None;
     _Py_IDENTIFIER(iterfind);
     static char *kwlist[] = {"path", "namespaces", 0};
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:iterfind", kwlist,
                                      &tag, &namespaces))
         return NULL;
 
     return _PyObject_CallMethodId(
-        st->elementpath_obj, &PyId_iterfind, "OOO", self, tag, namespaces
+        elementpath_obj, &PyId_iterfind, "OOO", self, tag, namespaces
         );
 }
 
@@ -2396,7 +2351,6 @@
 {
     PyObject* node;
     PyObject* this;
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     if (self->data) {
         if (self->this == self->last) {
@@ -2427,7 +2381,7 @@
     } else {
         if (self->root) {
             PyErr_SetString(
-                st->parseerror_obj,
+                elementtree_parseerror_obj,
                 "multiple elements on top level"
                 );
             goto error;
@@ -2716,10 +2670,6 @@
 
 #include "expat.h"
 #include "pyexpat.h"
-
-/* The PyExpat_CAPI structure is an immutable dispatch table, so it can be
- * cached globally without being in per-module state.
- */
 static struct PyExpat_CAPI *expat_capi;
 #define EXPAT(func) (expat_capi->func)
 
@@ -2829,7 +2779,6 @@
 expat_set_error(enum XML_Error error_code, int line, int column, char *message)
 {
     PyObject *errmsg, *error, *position, *code;
-    elementtreestate *st = ET_STATE_GLOBAL;
 
     errmsg = PyUnicode_FromFormat("%s: line %d, column %d",
                 message ? message : EXPAT(ErrorString)(error_code),
@@ -2837,7 +2786,7 @@
     if (errmsg == NULL)
         return;
 
-    error = PyObject_CallFunction(st->parseerror_obj, "O", errmsg);
+    error = PyObject_CallFunction(elementtree_parseerror_obj, "O", errmsg);
     Py_DECREF(errmsg);
     if (!error)
         return;
@@ -2867,7 +2816,7 @@
     }
     Py_DECREF(position);
 
-    PyErr_SetObject(st->parseerror_obj, error);
+    PyErr_SetObject(elementtree_parseerror_obj, error);
     Py_DECREF(error);
 }
 
@@ -3690,29 +3639,22 @@
 };
 
 
-static struct PyModuleDef elementtreemodule = {
-    PyModuleDef_HEAD_INIT,
-    "_elementtree",
-    NULL,
-    sizeof(elementtreestate),
-    _functions,
-    NULL,
-    elementtree_traverse,
-    elementtree_clear,
-    elementtree_free
+static struct PyModuleDef _elementtreemodule = {
+        PyModuleDef_HEAD_INIT,
+        "_elementtree",
+        NULL,
+        -1,
+        _functions,
+        NULL,
+        NULL,
+        NULL,
+        NULL
 };
 
 PyMODINIT_FUNC
 PyInit__elementtree(void)
 {
     PyObject *m, *temp;
-    elementtreestate *st;
-
-    m = PyState_FindModule(&elementtreemodule);
-    if (m) {
-        Py_INCREF(m);
-        return m;
-    }
 
     /* Initialize object types */
     if (PyType_Ready(&ElementIter_Type) < 0)
@@ -3724,17 +3666,16 @@
     if (PyType_Ready(&XMLParser_Type) < 0)
         return NULL;
 
-    m = PyModule_Create(&elementtreemodule);
+    m = PyModule_Create(&_elementtreemodule);
     if (!m)
         return NULL;
-    st = ET_STATE(m);
 
     if (!(temp = PyImport_ImportModule("copy")))
         return NULL;
-    st->deepcopy_obj = PyObject_GetAttrString(temp, "deepcopy");
+    elementtree_deepcopy_obj = PyObject_GetAttrString(temp, "deepcopy");
     Py_XDECREF(temp);
 
-    if (!(st->elementpath_obj = PyImport_ImportModule("xml.etree.ElementPath")))
+    if (!(elementpath_obj = PyImport_ImportModule("xml.etree.ElementPath")))
         return NULL;
 
     /* link against pyexpat */
@@ -3754,11 +3695,11 @@
         return NULL;
     }
 
-    st->parseerror_obj = PyErr_NewException(
+    elementtree_parseerror_obj = PyErr_NewException(
         "xml.etree.ElementTree.ParseError", PyExc_SyntaxError, NULL
         );
-    Py_INCREF(st->parseerror_obj);
-    PyModule_AddObject(m, "ParseError", st->parseerror_obj);
+    Py_INCREF(elementtree_parseerror_obj);
+    PyModule_AddObject(m, "ParseError", elementtree_parseerror_obj);
 
     Py_INCREF((PyObject *)&Element_Type);
     PyModule_AddObject(m, "Element", (PyObject *)&Element_Type);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/_iomodule.c
--- a/Modules/_io/_iomodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/_iomodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -533,31 +533,6 @@
 }
 
 
-PyObject *
-_PyIO_get_locale_module(_PyIO_State *state)
-{
-    PyObject *mod;
-    if (state->locale_module != NULL) {
-        assert(PyWeakref_CheckRef(state->locale_module));
-        mod = PyWeakref_GET_OBJECT(state->locale_module);
-        if (mod != Py_None) {
-            Py_INCREF(mod);
-            return mod;
-        }
-        Py_CLEAR(state->locale_module);
-    }
-    mod = PyImport_ImportModule("locale");
-    if (mod == NULL)
-        return NULL;
-    state->locale_module = PyWeakref_NewRef(mod, NULL);
-    if (state->locale_module == NULL) {
-        Py_DECREF(mod);
-        return NULL;
-    }
-    return mod;
-}
-
-
 static int
 iomodule_traverse(PyObject *mod, visitproc visit, void *arg) {
     _PyIO_State *state = IO_MOD_STATE(mod);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/_iomodule.h
--- a/Modules/_io/_iomodule.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/_iomodule.h	Mon Aug 12 02:18:40 2013 +0200
@@ -137,8 +137,6 @@
 #define IO_MOD_STATE(mod) ((_PyIO_State *)PyModule_GetState(mod))
 #define IO_STATE IO_MOD_STATE(PyState_FindModule(&_PyIO_Module))
 
-extern PyObject *_PyIO_get_locale_module(_PyIO_State *);
-
 extern PyObject *_PyIO_str_close;
 extern PyObject *_PyIO_str_closed;
 extern PyObject *_PyIO_str_decode;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/bufferedio.c
--- a/Modules/_io/bufferedio.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/bufferedio.c	Mon Aug 12 02:18:40 2013 +0200
@@ -190,8 +190,7 @@
     0,                          /*tp_getattro*/
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_FINALIZE,  /*tp_flags*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
     bufferediobase_doc,         /* tp_doc */
     0,                          /* tp_traverse */
     0,                          /* tp_clear */
@@ -210,16 +209,6 @@
     0,                          /* tp_init */
     0,                          /* tp_alloc */
     0,                          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
 
 
@@ -231,7 +220,7 @@
     int detached;
     int readable;
     int writable;
-    char finalizing;
+    int deallocating;
 
     /* True if this is a vanilla Buffered object (rather than a user derived
        class) *and* the raw stream is a vanilla FileIO object. */
@@ -395,8 +384,8 @@
 static void
 buffered_dealloc(buffered *self)
 {
-    self->finalizing = 1;
-    if (_PyIOBase_finalize((PyObject *) self) < 0)
+    self->deallocating = 1;
+    if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
         return;
     _PyObject_GC_UNTRACK(self);
     self->ok = 0;
@@ -439,6 +428,8 @@
 static int
 buffered_clear(buffered *self)
 {
+    if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
+        return -1;
     self->ok = 0;
     Py_CLEAR(self->raw);
     Py_CLEAR(self->dict);
@@ -517,7 +508,7 @@
         goto end;
     }
 
-    if (self->finalizing) {
+    if (self->deallocating) {
         PyObject *r = buffered_dealloc_warn(self, (PyObject *) self);
         if (r)
             Py_DECREF(r);
@@ -1758,7 +1749,6 @@
 
 static PyMemberDef bufferedreader_members[] = {
     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
-    {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
     {NULL}
 };
 
@@ -1791,7 +1781,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+            | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     bufferedreader_doc,         /* tp_doc */
     (traverseproc)buffered_traverse, /* tp_traverse */
     (inquiry)buffered_clear,    /* tp_clear */
@@ -1810,16 +1800,6 @@
     (initproc)bufferedreader_init, /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
 
 
@@ -2150,7 +2130,6 @@
 
 static PyMemberDef bufferedwriter_members[] = {
     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
-    {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
     {NULL}
 };
 
@@ -2183,7 +2162,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,   /*tp_flags*/
+        | Py_TPFLAGS_HAVE_GC,   /*tp_flags*/
     bufferedwriter_doc,         /* tp_doc */
     (traverseproc)buffered_traverse, /* tp_traverse */
     (inquiry)buffered_clear,    /* tp_clear */
@@ -2202,16 +2181,6 @@
     (initproc)bufferedwriter_init, /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
 
 
@@ -2447,7 +2416,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,   /* tp_flags */
+        | Py_TPFLAGS_HAVE_GC,   /* tp_flags */
     bufferedrwpair_doc,         /* tp_doc */
     (traverseproc)bufferedrwpair_traverse, /* tp_traverse */
     (inquiry)bufferedrwpair_clear, /* tp_clear */
@@ -2466,16 +2435,6 @@
     (initproc)bufferedrwpair_init, /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
 
 
@@ -2563,7 +2522,6 @@
 
 static PyMemberDef bufferedrandom_members[] = {
     {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
-    {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0},
     {NULL}
 };
 
@@ -2596,7 +2554,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,   /*tp_flags*/
+        | Py_TPFLAGS_HAVE_GC,   /*tp_flags*/
     bufferedrandom_doc,         /* tp_doc */
     (traverseproc)buffered_traverse, /* tp_traverse */
     (inquiry)buffered_clear,    /* tp_clear */
@@ -2615,14 +2573,4 @@
     (initproc)bufferedrandom_init, /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/fileio.c
--- a/Modules/_io/fileio.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/fileio.c	Mon Aug 12 02:18:40 2013 +0200
@@ -51,7 +51,7 @@
     unsigned int writable : 1;
     signed int seekable : 2; /* -1 means unknown */
     unsigned int closefd : 1;
-    char finalizing;
+    unsigned int deallocating: 1;
     PyObject *weakreflist;
     PyObject *dict;
 } fileio;
@@ -128,7 +128,7 @@
         self->fd = -1;
         Py_RETURN_NONE;
     }
-    if (self->finalizing) {
+    if (self->deallocating) {
         PyObject *r = fileio_dealloc_warn(self, (PyObject *) self);
         if (r)
             Py_DECREF(r);
@@ -202,6 +202,9 @@
     return 0;
 }
 
+#ifdef O_CLOEXEC
+extern int _Py_open_cloexec_works;
+#endif
 
 static int
 fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)
@@ -221,6 +224,11 @@
     int fd = -1;
     int closefd = 1;
     int fd_is_own = 0;
+#ifdef O_CLOEXEC
+    int *atomic_flag_works = &_Py_open_cloexec_works;
+#else
+    int *atomic_flag_works = NULL;
+#endif
 
     assert(PyFileIO_Check(oself));
     if (self->fd >= 0) {
@@ -345,6 +353,11 @@
     if (append)
         flags |= O_APPEND;
 #endif
+#ifdef MS_WINDOWS
+    flags |= O_NOINHERIT;
+#elif defined(O_CLOEXEC)
+    flags |= O_CLOEXEC;
+#endif
 
     if (fd >= 0) {
         if (check_fd(fd))
@@ -369,10 +382,16 @@
             else
 #endif
                 self->fd = open(name, flags, 0666);
+
             Py_END_ALLOW_THREADS
-        } else {
-            PyObject *fdobj = PyObject_CallFunction(
-                                  opener, "Oi", nameobj, flags);
+        }
+        else {
+            PyObject *fdobj;
+
+            /* the opener may clear the atomic flag */
+            atomic_flag_works = NULL;
+
+            fdobj = PyObject_CallFunction(opener, "Oi", nameobj, flags);
             if (fdobj == NULL)
                 goto error;
             if (!PyLong_Check(fdobj)) {
@@ -394,6 +413,11 @@
             PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, nameobj);
             goto error;
         }
+
+#ifndef MS_WINDOWS
+        if (_Py_set_inheritable(self->fd, 0, atomic_flag_works) < 0)
+            goto error;
+#endif
     }
     if (dircheck(self, nameobj) < 0)
         goto error;
@@ -447,7 +471,7 @@
 static void
 fileio_dealloc(fileio *self)
 {
-    self->finalizing = 1;
+    self->deallocating = 1;
     if (_PyIOBase_finalize((PyObject *) self) < 0)
         return;
     _PyObject_GC_UNTRACK(self);
@@ -1182,11 +1206,6 @@
     {NULL},
 };
 
-static PyMemberDef fileio_members[] = {
-    {"_finalizing", T_BOOL, offsetof(fileio, finalizing), 0},
-    {NULL}
-};
-
 PyTypeObject PyFileIO_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "_io.FileIO",
@@ -1208,7 +1227,7 @@
     0,                                          /* tp_setattro */
     0,                                          /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,       /* tp_flags */
+                    | Py_TPFLAGS_HAVE_GC,       /* tp_flags */
     fileio_doc,                                 /* tp_doc */
     (traverseproc)fileio_traverse,              /* tp_traverse */
     (inquiry)fileio_clear,                      /* tp_clear */
@@ -1217,7 +1236,7 @@
     0,                                          /* tp_iter */
     0,                                          /* tp_iternext */
     fileio_methods,                             /* tp_methods */
-    fileio_members,                             /* tp_members */
+    0,                                          /* tp_members */
     fileio_getsetlist,                          /* tp_getset */
     0,                                          /* tp_base */
     0,                                          /* tp_dict */
@@ -1228,13 +1247,4 @@
     PyType_GenericAlloc,                        /* tp_alloc */
     fileio_new,                                 /* tp_new */
     PyObject_GC_Del,                            /* tp_free */
-    0,                                          /* tp_is_gc */
-    0,                                          /* tp_bases */
-    0,                                          /* tp_mro */
-    0,                                          /* tp_cache */
-    0,                                          /* tp_subclasses */
-    0,                                          /* tp_weaklist */
-    0,                                          /* tp_del */
-    0,                                          /* tp_version_tag */
-    0,                                          /* tp_finalize */
 };
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/iobase.c
--- a/Modules/_io/iobase.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/iobase.c	Mon Aug 12 02:18:40 2013 +0200
@@ -196,24 +196,26 @@
 
 /* Finalization and garbage collection support */
 
-static void
-iobase_finalize(PyObject *self)
+int
+_PyIOBase_finalize(PyObject *self)
 {
     PyObject *res;
-    PyObject *error_type, *error_value, *error_traceback;
-    int closed;
-    _Py_IDENTIFIER(_finalizing);
+    PyObject *tp, *v, *tb;
+    int closed = 1;
+    int is_zombie;
 
-    /* Save the current exception, if any. */
-    PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
+    /* If _PyIOBase_finalize() is called from a destructor, we need to
+       resurrect the object as calling close() can invoke arbitrary code. */
+    is_zombie = (Py_REFCNT(self) == 0);
+    if (is_zombie) {
+        ++Py_REFCNT(self);
+    }
+    PyErr_Fetch(&tp, &v, &tb);
     /* If `closed` doesn't exist or can't be evaluated as bool, then the
        object is probably in an unusable state, so ignore. */
     res = PyObject_GetAttr(self, _PyIO_str_closed);
-    if (res == NULL) {
+    if (res == NULL)
         PyErr_Clear();
-        closed = -1;
-    }
     else {
         closed = PyObject_IsTrue(res);
         Py_DECREF(res);
@@ -221,10 +223,6 @@
             PyErr_Clear();
     }
     if (closed == 0) {
-        /* Signal close() that it was called as part of the object
-           finalization process. */
-        if (_PyObject_SetAttrId(self, &PyId__finalizing, Py_True))
-            PyErr_Clear();
         res = PyObject_CallMethodObjArgs((PyObject *) self, _PyIO_str_close,
                                           NULL);
         /* Silencing I/O errors is bad, but printing spurious tracebacks is
@@ -235,25 +233,31 @@
         else
             Py_DECREF(res);
     }
-
-    /* Restore the saved exception. */
-    PyErr_Restore(error_type, error_value, error_traceback);
-}
-
-int
-_PyIOBase_finalize(PyObject *self)
-{
-    int is_zombie;
-
-    /* If _PyIOBase_finalize() is called from a destructor, we need to
-       resurrect the object as calling close() can invoke arbitrary code. */
-    is_zombie = (Py_REFCNT(self) == 0);
-    if (is_zombie)
-        return PyObject_CallFinalizerFromDealloc(self);
-    else {
-        PyObject_CallFinalizer(self);
-        return 0;
+    PyErr_Restore(tp, v, tb);
+    if (is_zombie) {
+        if (--Py_REFCNT(self) != 0) {
+            /* The object lives again. The following code is taken from
+               slot_tp_del in typeobject.c. */
+            Py_ssize_t refcnt = Py_REFCNT(self);
+            _Py_NewReference(self);
+            Py_REFCNT(self) = refcnt;
+            /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
+             * we need to undo that. */
+            _Py_DEC_REFTOTAL;
+            /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
+             * chain, so no more to do there.
+             * If COUNT_ALLOCS, the original decref bumped tp_frees, and
+             * _Py_NewReference bumped tp_allocs:  both of those need to be
+             * undone.
+             */
+#ifdef COUNT_ALLOCS
+            --Py_TYPE(self)->tp_frees;
+            --Py_TYPE(self)->tp_allocs;
+#endif
+            return -1;
+        }
     }
+    return 0;
 }
 
 static int
@@ -266,6 +270,8 @@
 static int
 iobase_clear(iobase *self)
 {
+    if (_PyIOBase_finalize((PyObject *) self) < 0)
+        return -1;
     Py_CLEAR(self->dict);
     return 0;
 }
@@ -735,7 +741,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,   /*tp_flags*/
+        | Py_TPFLAGS_HAVE_GC,   /*tp_flags*/
     iobase_doc,                 /* tp_doc */
     (traverseproc)iobase_traverse, /* tp_traverse */
     (inquiry)iobase_clear,      /* tp_clear */
@@ -754,16 +760,6 @@
     0,                          /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    (destructor)iobase_finalize, /* tp_finalize */
 };
 
 
@@ -909,7 +905,7 @@
     0,                          /*tp_getattro*/
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_FINALIZE,  /*tp_flags*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
     rawiobase_doc,              /* tp_doc */
     0,                          /* tp_traverse */
     0,                          /* tp_clear */
@@ -928,14 +924,4 @@
     0,                          /* tp_init */
     0,                          /* tp_alloc */
     0,                          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_io/textio.c
--- a/Modules/_io/textio.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_io/textio.c	Mon Aug 12 02:18:40 2013 +0200
@@ -173,8 +173,7 @@
     0,                          /*tp_getattro*/
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_FINALIZE,  /*tp_flags*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
     textiobase_doc,             /* tp_doc */
     0,                          /* tp_traverse */
     0,                          /* tp_clear */
@@ -193,16 +192,6 @@
     0,                          /* tp_init */
     0,                          /* tp_alloc */
     0,                          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
 
 
@@ -702,7 +691,7 @@
     char seekable;
     char has_read1;
     char telling;
-    char finalizing;
+    char deallocating;
     /* Specialized encoding func (see below) */
     encodefunc_t encodefunc;
     /* Whether or not it's the start of the stream */
@@ -917,29 +906,35 @@
         }
     }
     if (encoding == NULL && self->encoding == NULL) {
-        PyObject *locale_module = _PyIO_get_locale_module(state);
-        if (locale_module == NULL)
-            goto catch_ImportError;
-        self->encoding = _PyObject_CallMethodId(
-            locale_module, &PyId_getpreferredencoding, "O", Py_False);
-        Py_DECREF(locale_module);
-        if (self->encoding == NULL) {
-          catch_ImportError:
-            /*
-             Importing locale can raise a ImportError because of
-             _functools, and locale.getpreferredencoding can raise a
-             ImportError if _locale is not available.  These will happen
-             during module building.
-            */
-            if (PyErr_ExceptionMatches(PyExc_ImportError)) {
-                PyErr_Clear();
-                self->encoding = PyUnicode_FromString("ascii");
+        if (state->locale_module == NULL) {
+            state->locale_module = PyImport_ImportModule("locale");
+            if (state->locale_module == NULL)
+                goto catch_ImportError;
+            else
+                goto use_locale;
+        }
+        else {
+          use_locale:
+            self->encoding = _PyObject_CallMethodId(
+                state->locale_module, &PyId_getpreferredencoding, "O", Py_False);
+            if (self->encoding == NULL) {
+              catch_ImportError:
+                /*
+                 Importing locale can raise a ImportError because of
+                 _functools, and locale.getpreferredencoding can raise a
+                 ImportError if _locale is not available.  These will happen
+                 during module building.
+                */
+                if (PyErr_ExceptionMatches(PyExc_ImportError)) {
+                    PyErr_Clear();
+                    self->encoding = PyUnicode_FromString("ascii");
+                }
+                else
+                    goto error;
             }
-            else
-                goto error;
+            else if (!PyUnicode_Check(self->encoding))
+                Py_CLEAR(self->encoding);
         }
-        else if (!PyUnicode_Check(self->encoding))
-            Py_CLEAR(self->encoding);
     }
     if (self->encoding != NULL) {
         encoding = _PyUnicode_AsString(self->encoding);
@@ -1117,6 +1112,8 @@
 static int
 _textiowrapper_clear(textio *self)
 {
+    if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
+        return -1;
     self->ok = 0;
     Py_CLEAR(self->buffer);
     Py_CLEAR(self->encoding);
@@ -1134,10 +1131,9 @@
 static void
 textiowrapper_dealloc(textio *self)
 {
-    self->finalizing = 1;
-    if (_PyIOBase_finalize((PyObject *) self) < 0)
+    self->deallocating = 1;
+    if (_textiowrapper_clear(self) < 0)
         return;
-    _textiowrapper_clear(self);
     _PyObject_GC_UNTRACK(self);
     if (self->weakreflist != NULL)
         PyObject_ClearWeakRefs((PyObject *)self);
@@ -2577,7 +2573,7 @@
     }
     else {
         PyObject *exc = NULL, *val, *tb;
-        if (self->finalizing) {
+        if (self->deallocating) {
             res = _PyObject_CallMethodId(self->buffer, &PyId__dealloc_warn, "O", self);
             if (res)
                 Py_DECREF(res);
@@ -2738,7 +2734,6 @@
     {"encoding", T_OBJECT, offsetof(textio, encoding), READONLY},
     {"buffer", T_OBJECT, offsetof(textio, buffer), READONLY},
     {"line_buffering", T_BOOL, offsetof(textio, line_buffering), READONLY},
-    {"_finalizing", T_BOOL, offsetof(textio, finalizing), 0},
     {NULL}
 };
 
@@ -2775,7 +2770,7 @@
     0,                          /*tp_setattro*/
     0,                          /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
-        | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+            | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
     textiowrapper_doc,          /* tp_doc */
     (traverseproc)textiowrapper_traverse, /* tp_traverse */
     (inquiry)textiowrapper_clear, /* tp_clear */
@@ -2794,14 +2789,4 @@
     (initproc)textiowrapper_init, /* tp_init */
     0,                          /* tp_alloc */
     PyType_GenericNew,          /* tp_new */
-    0,                          /* tp_free */
-    0,                          /* tp_is_gc */
-    0,                          /* tp_bases */
-    0,                          /* tp_mro */
-    0,                          /* tp_cache */
-    0,                          /* tp_subclasses */
-    0,                          /* tp_weaklist */
-    0,                          /* tp_del */
-    0,                          /* tp_version_tag */
-    0,                          /* tp_finalize */
 };
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_json.c
--- a/Modules/_json.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_json.c	Mon Aug 12 02:18:40 2013 +0200
@@ -116,8 +116,6 @@
 static PyObject *
 encoder_encode_string(PyEncoderObject *s, PyObject *obj);
 static PyObject *
-encoder_encode_long(PyEncoderObject* s UNUSED, PyObject *obj);
-static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj);
 
 #define S_CHAR(c) (c >= ' ' && c <= '~' && c != '\\' && c != '"')
@@ -1304,45 +1302,13 @@
 }
 
 static PyObject *
-encoder_encode_long(PyEncoderObject* s UNUSED, PyObject *obj)
-{
-    /* Return the JSON representation of a PyLong and PyLong subclasses.
-       Calls int() on PyLong subclasses in case the str() was changed.
-       Added specifically to deal with IntEnum.  See Issue18264. */
-    PyObject *encoded, *longobj;
-    if (PyLong_CheckExact(obj)) {
-        encoded = PyObject_Str(obj);
-    }
-    else {
-        longobj = PyNumber_Long(obj);
-        if (longobj == NULL) {
-            PyErr_SetString(
-                    PyExc_ValueError,
-                    "Unable to coerce int subclass to int"
-                    );
-            return NULL;
-        }
-        encoded = PyObject_Str(longobj);
-        Py_DECREF(longobj);
-    }
-    return encoded;
-}
-
-
-static PyObject *
 encoder_encode_float(PyEncoderObject *s, PyObject *obj)
 {
-    /* Return the JSON representation of a PyFloat.
-       Modified to call float() on float subclasses in case the subclass
-       changes the repr.  See Issue18264.  */
-    PyObject *encoded, *floatobj;
+    /* Return the JSON representation of a PyFloat */
     double i = PyFloat_AS_DOUBLE(obj);
     if (!Py_IS_FINITE(i)) {
         if (!s->allow_nan) {
-            PyErr_SetString(
-                    PyExc_ValueError,
-                    "Out of range float values are not JSON compliant"
-                    );
+            PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant");
             return NULL;
         }
         if (i > 0) {
@@ -1355,24 +1321,8 @@
             return PyUnicode_FromString("NaN");
         }
     }
-    /* coerce float subclasses to float (primarily for Enum) */
-    if (PyFloat_CheckExact(obj)) {
-        /* Use a better float format here? */
-        encoded = PyObject_Repr(obj);
-    }
-    else {
-        floatobj = PyNumber_Float(obj);
-        if (floatobj == NULL) {
-            PyErr_SetString(
-                    PyExc_ValueError,
-                    "Unable to coerce float subclass to float"
-                    );
-            return NULL;
-        }
-        encoded = PyObject_Repr(floatobj);
-        Py_DECREF(floatobj);
-    }
-    return encoded;
+    /* Use a better float format here? */
+    return PyObject_Repr(obj);
 }
 
 static PyObject *
@@ -1416,7 +1366,7 @@
         return _steal_accumulate(acc, encoded);
     }
     else if (PyLong_Check(obj)) {
-        PyObject *encoded = encoder_encode_long(s, obj);
+        PyObject *encoded = PyObject_Str(obj);
         if (encoded == NULL)
             return -1;
         return _steal_accumulate(acc, encoded);
@@ -1601,10 +1551,9 @@
                 goto bail;
         }
         else if (PyLong_Check(key)) {
-            kstr = encoder_encode_long(s, key);
-            if (kstr == NULL) {
+            kstr = PyObject_Str(key);
+            if (kstr == NULL)
                 goto bail;
-            }
         }
         else if (skipkeys) {
             Py_DECREF(item);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_posixsubprocess.c
--- a/Modules/_posixsubprocess.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_posixsubprocess.c	Mon Aug 12 02:18:40 2013 +0200
@@ -35,7 +35,7 @@
 # define FD_DIR "/proc/self/fd"
 #endif
 
-#define POSIX_CALL(call)   if ((call) == -1) goto error
+#define POSIX_CALL(call)   do { if ((call) == -1) goto error; } while (0)
 
 
 /* Maximum file descriptor, initialized on module load. */
@@ -87,7 +87,7 @@
     if (stat("/dev", &dev_stat) != 0)
         return 0;
     if (stat(FD_DIR, &dev_fd_stat) != 0)
-        return 0; 
+        return 0;
     if (dev_stat.st_dev == dev_fd_stat.st_dev)
         return 0;  /* / == /dev == /dev/fd means it is static. #fail */
     return 1;
@@ -136,6 +136,23 @@
     return 0;
 }
 
+static int
+make_inheritable(PyObject *py_fds_to_keep)
+{
+    Py_ssize_t i, len;
+
+    len = PySequence_Length(py_fds_to_keep);
+    for (i = 0; i < len; ++i) {
+        PyObject* fdobj = PySequence_Fast_GET_ITEM(py_fds_to_keep, i);
+        long fd = PyLong_AsLong(fdobj);
+        assert(!PyErr_Occurred());
+        assert(0 <= fd && fd <= INT_MAX);
+        if (_Py_set_inheritable((int)fd, 1, NULL) < 0)
+            return -1;
+    }
+    return 0;
+}
+
 
 /* Close all file descriptors in the range start_fd inclusive to
  * end_fd exclusive except for those in py_fds_to_keep.  If the
@@ -205,18 +222,8 @@
     int fd_dir_fd;
     if (start_fd >= end_fd)
         return;
-#ifdef O_CLOEXEC
-    fd_dir_fd = open(FD_DIR, O_RDONLY | O_CLOEXEC, 0);
-#else
-    fd_dir_fd = open(FD_DIR, O_RDONLY, 0);
-#ifdef FD_CLOEXEC
-    {
-        int old = fcntl(fd_dir_fd, F_GETFD);
-        if (old != -1)
-            fcntl(fd_dir_fd, F_SETFD, old | FD_CLOEXEC);
-    }
-#endif
-#endif
+
+    fd_dir_fd = _Py_open(FD_DIR, O_RDONLY);
     if (fd_dir_fd == -1) {
         /* No way to get a list of open fds. */
         _close_fds_by_brute_force(start_fd, end_fd, py_fds_to_keep);
@@ -356,16 +363,20 @@
     /* Buffer large enough to hold a hex integer.  We can't malloc. */
     char hex_errno[sizeof(saved_errno)*2+1];
 
+    if (make_inheritable(py_fds_to_keep) < 0)
+        goto error;
+    /* errpipe_write is part of py_fds_to_keep. It must be closed at
+       exec(), but kept open in the child process until exec() is called. */
+    if (_Py_set_inheritable((int)errpipe_write, 0, NULL) < 0)
+        goto error;
+
     /* Close parent's pipe ends. */
-    if (p2cwrite != -1) {
+    if (p2cwrite != -1)
         POSIX_CALL(close(p2cwrite));
-    }
-    if (c2pread != -1) {
+    if (c2pread != -1)
         POSIX_CALL(close(c2pread));
-    }
-    if (errread != -1) {
+    if (errread != -1)
         POSIX_CALL(close(errread));
-    }
     POSIX_CALL(close(errpipe_read));
 
     /* When duping fds, if there arises a situation where one of the fds is
@@ -378,39 +389,27 @@
     /* Dup fds for child.
        dup2() removes the CLOEXEC flag but we must do it ourselves if dup2()
        would be a no-op (issue #10806). */
-    if (p2cread == 0) {
-        int old = fcntl(p2cread, F_GETFD);
-        if (old != -1)
-            fcntl(p2cread, F_SETFD, old & ~FD_CLOEXEC);
-    } else if (p2cread != -1) {
+    if (p2cread == 0)
+        _Py_try_set_inheritable(p2cread, 1);
+    else if (p2cread != -1)
         POSIX_CALL(dup2(p2cread, 0));  /* stdin */
-    }
-    if (c2pwrite == 1) {
-        int old = fcntl(c2pwrite, F_GETFD);
-        if (old != -1)
-            fcntl(c2pwrite, F_SETFD, old & ~FD_CLOEXEC);
-    } else if (c2pwrite != -1) {
+    if (c2pwrite == 1)
+        _Py_try_set_inheritable(c2pwrite, 1);
+    else if (c2pwrite != -1)
         POSIX_CALL(dup2(c2pwrite, 1));  /* stdout */
-    }
-    if (errwrite == 2) {
-        int old = fcntl(errwrite, F_GETFD);
-        if (old != -1)
-            fcntl(errwrite, F_SETFD, old & ~FD_CLOEXEC);
-    } else if (errwrite != -1) {
+    if (errwrite == 2)
+        _Py_try_set_inheritable(errwrite, 1);
+    else if (errwrite != -1)
         POSIX_CALL(dup2(errwrite, 2));  /* stderr */
-    }
 
     /* Close pipe fds.  Make sure we don't close the same fd more than */
     /* once, or standard fds. */
-    if (p2cread > 2) {
+    if (p2cread > 2)
         POSIX_CALL(close(p2cread));
-    }
-    if (c2pwrite > 2 && c2pwrite != p2cread) {
+    if (c2pwrite > 2 && c2pwrite != p2cread)
         POSIX_CALL(close(c2pwrite));
-    }
-    if (errwrite != c2pwrite && errwrite != p2cread && errwrite > 2) {
+    if (errwrite != c2pwrite && errwrite != p2cread && errwrite > 2)
         POSIX_CALL(close(errwrite));
-    }
 
     if (close_fds) {
         int local_max_fd = max_fd;
@@ -543,7 +542,7 @@
         PyObject *result;
         _Py_IDENTIFIER(isenabled);
         _Py_IDENTIFIER(disable);
-        
+
         gc_module = PyImport_ImportModule("gc");
         if (gc_module == NULL)
             return NULL;
@@ -720,52 +719,6 @@
 Raises: Only on an error in the parent process.\n\
 ");
 
-PyDoc_STRVAR(subprocess_cloexec_pipe_doc,
-"cloexec_pipe() -> (read_end, write_end)\n\n\
-Create a pipe whose ends have the cloexec flag set.");
-
-static PyObject *
-subprocess_cloexec_pipe(PyObject *self, PyObject *noargs)
-{
-    int fds[2];
-    int res;
-#ifdef HAVE_PIPE2
-    Py_BEGIN_ALLOW_THREADS
-    res = pipe2(fds, O_CLOEXEC);
-    Py_END_ALLOW_THREADS
-    if (res != 0 && errno == ENOSYS)
-    {
-        {
-#endif
-        /* We hold the GIL which offers some protection from other code calling
-         * fork() before the CLOEXEC flags have been set but we can't guarantee
-         * anything without pipe2(). */
-        long oldflags;
-
-        res = pipe(fds);
-
-        if (res == 0) {
-            oldflags = fcntl(fds[0], F_GETFD, 0);
-            if (oldflags < 0) res = oldflags;
-        }
-        if (res == 0)
-            res = fcntl(fds[0], F_SETFD, oldflags | FD_CLOEXEC);
-
-        if (res == 0) {
-            oldflags = fcntl(fds[1], F_GETFD, 0);
-            if (oldflags < 0) res = oldflags;
-        }
-        if (res == 0)
-            res = fcntl(fds[1], F_SETFD, oldflags | FD_CLOEXEC);
-#ifdef HAVE_PIPE2
-        }
-    }
-#endif
-    if (res != 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    return Py_BuildValue("(ii)", fds[0], fds[1]);
-}
-
 /* module level code ********************************************************/
 
 PyDoc_STRVAR(module_doc,
@@ -774,7 +727,6 @@
 
 static PyMethodDef module_methods[] = {
     {"fork_exec", subprocess_fork_exec, METH_VARARGS, subprocess_fork_exec_doc},
-    {"cloexec_pipe", subprocess_cloexec_pipe, METH_NOARGS, subprocess_cloexec_pipe_doc},
     {NULL, NULL}  /* sentinel */
 };
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_sha3/sha3module.c
--- a/Modules/_sha3/sha3module.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_sha3/sha3module.c	Mon Aug 12 02:18:40 2013 +0200
@@ -322,7 +322,7 @@
     GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
 
     /* add new data, the function takes the length in bits not bytes */
-#ifdef WITH_THREAD
+#ifdef WITH_THREADS
     if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE) {
         self->lock = PyThread_allocate_lock();
     }
@@ -464,7 +464,7 @@
     }
 
     if (data_obj) {
-#ifdef WITH_THREAD
+#ifdef WITH_THREADS
         if (buf.len >= HASHLIB_GIL_MINSIZE) {
             /* invariant: New objects can't be accessed by other code yet,
              * thus it's safe to release the GIL without locking the object.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_sqlite/connection.c
--- a/Modules/_sqlite/connection.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_sqlite/connection.c	Mon Aug 12 02:18:40 2013 +0200
@@ -698,7 +698,6 @@
     _Py_IDENTIFIER(finalize);
     int ok;
     PyObject *exception, *value, *tb;
-    int restore;
 
 #ifdef WITH_THREAD
     PyGILState_STATE threadstate;
@@ -716,7 +715,6 @@
 
     /* Keep the exception (if any) of the last call to step() */
     PyErr_Fetch(&exception, &value, &tb);
-    restore = 1;
 
     function_result = _PyObject_CallMethodId(*aggregate_instance, &PyId_finalize, "");
 
@@ -734,18 +732,11 @@
             PyErr_Clear();
         }
         _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
-#if SQLITE_VERSION_NUMBER < 3003003
-        /* with old SQLite versions, _sqlite3_result_error() sets a new Python
-           exception, so don't restore the previous exception */
-        restore = 0;
-#endif
     }
 
-    if (restore) {
-        /* Restore the exception (if any) of the last call to step(),
-           but clear also the current exception if finalize() failed */
-        PyErr_Restore(exception, value, tb);
-    }
+    /* Restore the exception (if any) of the last call to step(),
+       but clear also the current exception if finalize() failed */
+    PyErr_Restore(exception, value, tb);
 
 error:
 #ifdef WITH_THREAD
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_sre.c
--- a/Modules/_sre.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_sre.c	Mon Aug 12 02:18:40 2013 +0200
@@ -997,7 +997,7 @@
             TRACE(("|%p|%p|REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,
                    ctx->pattern[1], ctx->pattern[2]));
 
-            if ((Py_ssize_t) ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
+            if (ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
                 RETURN_FAILURE; /* cannot match */
 
             state->ptr = ctx->ptr;
@@ -1081,7 +1081,7 @@
             TRACE(("|%p|%p|MIN_REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,
                    ctx->pattern[1], ctx->pattern[2]));
 
-            if ((Py_ssize_t) ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
+            if (ctx->pattern[1] > (end - ctx->ptr) / state->charsize)
                 RETURN_FAILURE; /* cannot match */
 
             state->ptr = ctx->ptr;
@@ -1180,7 +1180,7 @@
             TRACE(("|%p|%p|MAX_UNTIL %d\n", ctx->pattern,
                    ctx->ptr, ctx->count));
 
-            if (ctx->count < (Py_ssize_t) ctx->u.rep->pattern[1]) {
+            if (ctx->count < ctx->u.rep->pattern[1]) {
                 /* not enough matches */
                 ctx->u.rep->count = ctx->count;
                 DO_JUMP(JUMP_MAX_UNTIL_1, jump_max_until_1,
@@ -1194,7 +1194,7 @@
                 RETURN_FAILURE;
             }
 
-            if ((ctx->count < (Py_ssize_t) ctx->u.rep->pattern[2] ||
+            if ((ctx->count < ctx->u.rep->pattern[2] ||
                 ctx->u.rep->pattern[2] == SRE_MAXREPEAT) &&
                 state->ptr != ctx->u.rep->last_ptr) {
                 /* we may have enough matches, but if we can
@@ -1243,7 +1243,7 @@
             TRACE(("|%p|%p|MIN_UNTIL %d %p\n", ctx->pattern,
                    ctx->ptr, ctx->count, ctx->u.rep->pattern));
 
-            if (ctx->count < (Py_ssize_t) ctx->u.rep->pattern[1]) {
+            if (ctx->count < ctx->u.rep->pattern[1]) {
                 /* not enough matches */
                 ctx->u.rep->count = ctx->count;
                 DO_JUMP(JUMP_MIN_UNTIL_1, jump_min_until_1,
@@ -1272,7 +1272,7 @@
 
             LASTMARK_RESTORE();
 
-            if ((ctx->count >= (Py_ssize_t) ctx->u.rep->pattern[2]
+            if ((ctx->count >= ctx->u.rep->pattern[2]
                 && ctx->u.rep->pattern[2] != SRE_MAXREPEAT) ||
                 state->ptr == ctx->u.rep->last_ptr)
                 RETURN_FAILURE;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_ssl.c
--- a/Modules/_ssl.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_ssl.c	Mon Aug 12 02:18:40 2013 +0200
@@ -2291,7 +2291,7 @@
     FILE *f;
     DH *dh;
 
-    f = _Py_fopen(filepath, "rb");
+    f = _Py_fopen_obj(filepath, "rb");
     if (f == NULL) {
         if (!PyErr_Occurred())
             PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, filepath);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_testcapimodule.c
--- a/Modules/_testcapimodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_testcapimodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -2491,85 +2491,6 @@
     return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), nsec);
 }
 
-static void
-slot_tp_del(PyObject *self)
-{
-    _Py_IDENTIFIER(__tp_del__);
-    PyObject *del, *res;
-    PyObject *error_type, *error_value, *error_traceback;
-
-    /* Temporarily resurrect the object. */
-    assert(self->ob_refcnt == 0);
-    self->ob_refcnt = 1;
-
-    /* Save the current exception, if any. */
-    PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
-    /* Execute __del__ method, if any. */
-    del = _PyObject_LookupSpecial(self, &PyId___tp_del__);
-    if (del != NULL) {
-        res = PyEval_CallObject(del, NULL);
-        if (res == NULL)
-            PyErr_WriteUnraisable(del);
-        else
-            Py_DECREF(res);
-        Py_DECREF(del);
-    }
-
-    /* Restore the saved exception. */
-    PyErr_Restore(error_type, error_value, error_traceback);
-
-    /* Undo the temporary resurrection; can't use DECREF here, it would
-     * cause a recursive call.
-     */
-    assert(self->ob_refcnt > 0);
-    if (--self->ob_refcnt == 0)
-        return;         /* this is the normal path out */
-
-    /* __del__ resurrected it!  Make it look like the original Py_DECREF
-     * never happened.
-     */
-    {
-        Py_ssize_t refcnt = self->ob_refcnt;
-        _Py_NewReference(self);
-        self->ob_refcnt = refcnt;
-    }
-    assert(!PyType_IS_GC(Py_TYPE(self)) ||
-           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
-    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
-     * we need to undo that. */
-    _Py_DEC_REFTOTAL;
-    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
-     * chain, so no more to do there.
-     * If COUNT_ALLOCS, the original decref bumped tp_frees, and
-     * _Py_NewReference bumped tp_allocs:  both of those need to be
-     * undone.
-     */
-#ifdef COUNT_ALLOCS
-    --Py_TYPE(self)->tp_frees;
-    --Py_TYPE(self)->tp_allocs;
-#endif
-}
-
-static PyObject *
-with_tp_del(PyObject *self, PyObject *args)
-{
-    PyObject *obj;
-    PyTypeObject *tp;
-
-    if (!PyArg_ParseTuple(args, "O:with_tp_del", &obj))
-        return NULL;
-    tp = (PyTypeObject *) obj;
-    if (!PyType_Check(obj) || !PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
-        PyErr_Format(PyExc_TypeError,
-                     "heap type expected, got %R", obj);
-        return NULL;
-    }
-    tp->tp_del = slot_tp_del;
-    Py_INCREF(obj);
-    return obj;
-}
-
 static PyObject *
 _test_incref(PyObject *ob)
 {
@@ -2614,16 +2535,6 @@
 }
 
 static PyObject *
-test_incref_decref_API(PyObject *ob)
-{
-    PyObject *obj = PyLong_FromLong(0);
-    Py_IncRef(ob);
-    Py_DecRef(obj);
-    Py_DecRef(obj);
-    Py_RETURN_NONE;
-}
-
-static PyObject *
 test_pymem_alloc0(PyObject *self)
 {
     void *ptr;
@@ -2723,7 +2634,6 @@
     case PYMEM_DOMAIN_RAW: ptr2 = PyMem_RawRealloc(ptr, size2); break;
     case PYMEM_DOMAIN_MEM: ptr2 = PyMem_Realloc(ptr, size2); break;
     case PYMEM_DOMAIN_OBJ: ptr2 = PyObject_Realloc(ptr, size2); break;
-    default: ptr2 = NULL; break;
     }
 
     if (ptr2 == NULL) {
@@ -2792,7 +2702,6 @@
     {"test_incref_doesnt_leak", (PyCFunction)test_incref_doesnt_leak,      METH_NOARGS},
     {"test_xdecref_doesnt_leak",(PyCFunction)test_xdecref_doesnt_leak,      METH_NOARGS},
     {"test_decref_doesnt_leak", (PyCFunction)test_decref_doesnt_leak,      METH_NOARGS},
-    {"test_incref_decref_API",  (PyCFunction)test_incref_decref_API,       METH_NOARGS},
     {"test_long_and_overflow", (PyCFunction)test_long_and_overflow,
      METH_NOARGS},
     {"test_long_as_double",     (PyCFunction)test_long_as_double,METH_NOARGS},
@@ -2880,7 +2789,6 @@
     {"pytime_object_to_time_t", test_pytime_object_to_time_t,  METH_VARARGS},
     {"pytime_object_to_timeval", test_pytime_object_to_timeval,  METH_VARARGS},
     {"pytime_object_to_timespec", test_pytime_object_to_timespec,  METH_VARARGS},
-    {"with_tp_del",             with_tp_del,                     METH_VARARGS},
     {"test_pymem",
      (PyCFunction)test_pymem_alloc0, METH_NOARGS},
     {"test_pymem_alloc0",
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/_tkinter.c
--- a/Modules/_tkinter.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/_tkinter.c	Mon Aug 12 02:18:40 2013 +0200
@@ -516,7 +516,6 @@
     v = PyObject_New(TkappObject, (PyTypeObject *) Tkapp_Type);
     if (v == NULL)
         return NULL;
-    Py_INCREF(Tkapp_Type);
 
     v->interp = Tcl_CreateInterp();
     v->wantobjects = wantobjects;
@@ -675,7 +674,6 @@
     self = PyObject_New(PyTclObject, (PyTypeObject *) PyTclObject_Type);
     if (self == NULL)
         return NULL;
-    Py_INCREF(PyTclObject_Type);
     Tcl_IncrRefCount(arg);
     self->value = arg;
     self->string = NULL;
@@ -685,11 +683,9 @@
 static void
 PyTclObject_dealloc(PyTclObject *self)
 {
-    PyObject *tp = (PyObject *) Py_TYPE(self);
     Tcl_DecrRefCount(self->value);
     Py_XDECREF(self->string);
     PyObject_Del(self);
-    Py_DECREF(tp);
 }
 
 static char*
@@ -2200,7 +2196,6 @@
     v = PyObject_New(TkttObject, (PyTypeObject *) Tktt_Type);
     if (v == NULL)
         return NULL;
-    Py_INCREF(Tktt_Type);
 
     Py_INCREF(func);
     v->token = NULL;
@@ -2216,12 +2211,10 @@
 {
     TkttObject *v = (TkttObject *)self;
     PyObject *func = v->func;
-    PyObject *tp = (PyObject *) Py_TYPE(self);
 
     Py_XDECREF(func);
 
     PyObject_Del(self);
-    Py_DECREF(tp);
 }
 
 static PyObject *
@@ -2527,13 +2520,11 @@
 static void
 Tkapp_Dealloc(PyObject *self)
 {
-    PyObject *tp = (PyObject *) Py_TYPE(self);
     /*CHECK_TCL_APPARTMENT;*/
     ENTER_TCL
     Tcl_DeleteInterp(Tkapp_Interp(self));
     LEAVE_TCL
     PyObject_Del(self);
-    Py_DECREF(tp);
     DisableEventHook();
 }
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/atexitmodule.c
--- a/Modules/atexitmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/atexitmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -10,6 +10,8 @@
 
 /* Forward declaration (for atexit_cleanup) */
 static PyObject *atexit_clear(PyObject*, PyObject*);
+/* Forward declaration (for atexit_callfuncs) */
+static void atexit_cleanup(PyObject*);
 /* Forward declaration of module object */
 static struct PyModuleDef atexitmodule;
 
@@ -31,35 +33,6 @@
 #define GET_ATEXIT_STATE(mod) ((atexitmodule_state*)PyModule_GetState(mod))
 
 
-static void
-atexit_delete_cb(atexitmodule_state *modstate, int i)
-{
-    atexit_callback *cb;
-
-    cb = modstate->atexit_callbacks[i];
-    modstate->atexit_callbacks[i] = NULL;
-    Py_DECREF(cb->func);
-    Py_DECREF(cb->args);
-    Py_XDECREF(cb->kwargs);
-    PyMem_Free(cb);
-}
-
-/* Clear all callbacks without calling them */
-static void
-atexit_cleanup(atexitmodule_state *modstate)
-{
-    atexit_callback *cb;
-    int i;
-    for (i = 0; i < modstate->ncallbacks; i++) {
-        cb = modstate->atexit_callbacks[i];
-        if (cb == NULL)
-            continue;
-
-        atexit_delete_cb(modstate, i);
-    }
-    modstate->ncallbacks = 0;
-}
-
 /* Installed into pythonrun.c's atexit mechanism */
 
 static void
@@ -105,12 +78,34 @@
         }
     }
 
-    atexit_cleanup(modstate);
+    atexit_cleanup(module);
 
     if (exc_type)
         PyErr_Restore(exc_type, exc_value, exc_tb);
 }
 
+static void
+atexit_delete_cb(PyObject *self, int i)
+{
+    atexitmodule_state *modstate;
+    atexit_callback *cb;
+
+    modstate = GET_ATEXIT_STATE(self);
+    cb = modstate->atexit_callbacks[i];
+    modstate->atexit_callbacks[i] = NULL;
+    Py_DECREF(cb->func);
+    Py_DECREF(cb->args);
+    Py_XDECREF(cb->kwargs);
+    PyMem_Free(cb);
+}
+
+static void
+atexit_cleanup(PyObject *self)
+{
+    PyObject *r = atexit_clear(self, NULL);
+    Py_DECREF(r);
+}
+
 /* ===================================================================== */
 /* Module methods. */
 
@@ -199,50 +194,21 @@
 static PyObject *
 atexit_clear(PyObject *self, PyObject *unused)
 {
-    atexit_cleanup(GET_ATEXIT_STATE(self));
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(atexit_ncallbacks__doc__,
-"_ncallbacks() -> int\n\
-\n\
-Return the number of registered exit functions.");
-
-static PyObject *
-atexit_ncallbacks(PyObject *self, PyObject *unused)
-{
     atexitmodule_state *modstate;
+    atexit_callback *cb;
+    int i;
 
     modstate = GET_ATEXIT_STATE(self);
 
-    return PyLong_FromSsize_t(modstate->ncallbacks);
-}
-
-static int
-atexit_m_traverse(PyObject *self, visitproc visit, void *arg)
-{
-    int i;
-    atexitmodule_state *modstate;
-
-    modstate = GET_ATEXIT_STATE(self);
     for (i = 0; i < modstate->ncallbacks; i++) {
-        atexit_callback *cb = modstate->atexit_callbacks[i];
+        cb = modstate->atexit_callbacks[i];
         if (cb == NULL)
             continue;
-        Py_VISIT(cb->func);
-        Py_VISIT(cb->args);
-        Py_VISIT(cb->kwargs);
+
+        atexit_delete_cb(self, i);
     }
-    return 0;
-}
-
-static int
-atexit_m_clear(PyObject *self)
-{
-    atexitmodule_state *modstate;
-    modstate = GET_ATEXIT_STATE(self);
-    atexit_cleanup(modstate);
-    return 0;
+    modstate->ncallbacks = 0;
+    Py_RETURN_NONE;
 }
 
 static void
@@ -250,7 +216,6 @@
 {
     atexitmodule_state *modstate;
     modstate = GET_ATEXIT_STATE(m);
-    atexit_cleanup(modstate);
     PyMem_Free(modstate->atexit_callbacks);
 }
 
@@ -281,7 +246,7 @@
         if (eq < 0)
             return NULL;
         if (eq)
-            atexit_delete_cb(modstate, i);
+            atexit_delete_cb(self, i);
     }
     Py_RETURN_NONE;
 }
@@ -295,8 +260,6 @@
         atexit_unregister__doc__},
     {"_run_exitfuncs", (PyCFunction) atexit_run_exitfuncs, METH_NOARGS,
         atexit_run_exitfuncs__doc__},
-    {"_ncallbacks", (PyCFunction) atexit_ncallbacks, METH_NOARGS,
-        atexit_ncallbacks__doc__},
     {NULL, NULL}        /* sentinel */
 };
 
@@ -312,15 +275,15 @@
 
 
 static struct PyModuleDef atexitmodule = {
-    PyModuleDef_HEAD_INIT,
-    "atexit",
-    atexit__doc__,
-    sizeof(atexitmodule_state),
-    atexit_methods,
-    NULL,
-    atexit_m_traverse,
-    atexit_m_clear,
-    (freefunc)atexit_free
+	PyModuleDef_HEAD_INIT,
+	"atexit",
+	atexit__doc__,
+	sizeof(atexitmodule_state),
+	atexit_methods,
+	NULL,
+	NULL,
+	NULL,
+	(freefunc)atexit_free
 };
 
 PyMODINIT_FUNC
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/gcmodule.c
--- a/Modules/gcmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/gcmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -223,10 +223,10 @@
 #define GC_REACHABLE                    _PyGC_REFS_REACHABLE
 #define GC_TENTATIVELY_UNREACHABLE      _PyGC_REFS_TENTATIVELY_UNREACHABLE
 
-#define IS_TRACKED(o) (_PyGC_REFS(o) != GC_UNTRACKED)
-#define IS_REACHABLE(o) (_PyGC_REFS(o) == GC_REACHABLE)
+#define IS_TRACKED(o) ((AS_GC(o))->gc.gc_refs != GC_UNTRACKED)
+#define IS_REACHABLE(o) ((AS_GC(o))->gc.gc_refs == GC_REACHABLE)
 #define IS_TENTATIVELY_UNREACHABLE(o) ( \
-    _PyGC_REFS(o) == GC_TENTATIVELY_UNREACHABLE)
+    (AS_GC(o))->gc.gc_refs == GC_TENTATIVELY_UNREACHABLE)
 
 /*** list functions ***/
 
@@ -341,8 +341,8 @@
 {
     PyGC_Head *gc = containers->gc.gc_next;
     for (; gc != containers; gc = gc->gc.gc_next) {
-        assert(_PyGCHead_REFS(gc) == GC_REACHABLE);
-        _PyGCHead_SET_REFS(gc, Py_REFCNT(FROM_GC(gc)));
+        assert(gc->gc.gc_refs == GC_REACHABLE);
+        gc->gc.gc_refs = Py_REFCNT(FROM_GC(gc));
         /* Python's cyclic gc should never see an incoming refcount
          * of 0:  if something decref'ed to 0, it should have been
          * deallocated immediately at that time.
@@ -361,7 +361,7 @@
          * so serious that maybe this should be a release-build
          * check instead of an assert?
          */
-        assert(_PyGCHead_REFS(gc) != 0);
+        assert(gc->gc.gc_refs != 0);
     }
 }
 
@@ -376,9 +376,9 @@
          * generation being collected, which can be recognized
          * because only they have positive gc_refs.
          */
-        assert(_PyGCHead_REFS(gc) != 0); /* else refcount was too small */
-        if (_PyGCHead_REFS(gc) > 0)
-            _PyGCHead_DECREF(gc);
+        assert(gc->gc.gc_refs != 0); /* else refcount was too small */
+        if (gc->gc.gc_refs > 0)
+            gc->gc.gc_refs--;
     }
     return 0;
 }
@@ -407,7 +407,7 @@
 {
     if (PyObject_IS_GC(op)) {
         PyGC_Head *gc = AS_GC(op);
-        const Py_ssize_t gc_refs = _PyGCHead_REFS(gc);
+        const Py_ssize_t gc_refs = gc->gc.gc_refs;
 
         if (gc_refs == 0) {
             /* This is in move_unreachable's 'young' list, but
@@ -415,7 +415,7 @@
              * we need to do is tell move_unreachable that it's
              * reachable.
              */
-            _PyGCHead_SET_REFS(gc, 1);
+            gc->gc.gc_refs = 1;
         }
         else if (gc_refs == GC_TENTATIVELY_UNREACHABLE) {
             /* This had gc_refs = 0 when move_unreachable got
@@ -425,7 +425,7 @@
              * again.
              */
             gc_list_move(gc, reachable);
-            _PyGCHead_SET_REFS(gc, 1);
+            gc->gc.gc_refs = 1;
         }
         /* Else there's nothing to do.
          * If gc_refs > 0, it must be in move_unreachable's 'young'
@@ -469,7 +469,7 @@
     while (gc != young) {
         PyGC_Head *next;
 
-        if (_PyGCHead_REFS(gc)) {
+        if (gc->gc.gc_refs) {
             /* gc is definitely reachable from outside the
              * original 'young'.  Mark it as such, and traverse
              * its pointers to find any other objects that may
@@ -480,8 +480,8 @@
              */
             PyObject *op = FROM_GC(gc);
             traverseproc traverse = Py_TYPE(op)->tp_traverse;
-            assert(_PyGCHead_REFS(gc) > 0);
-            _PyGCHead_SET_REFS(gc, GC_REACHABLE);
+            assert(gc->gc.gc_refs > 0);
+            gc->gc.gc_refs = GC_REACHABLE;
             (void) traverse(op,
                             (visitproc)visit_reachable,
                             (void *)young);
@@ -500,7 +500,7 @@
              */
             next = gc->gc.gc_next;
             gc_list_move(gc, unreachable);
-            _PyGCHead_SET_REFS(gc, GC_TENTATIVELY_UNREACHABLE);
+            gc->gc.gc_refs = GC_TENTATIVELY_UNREACHABLE;
         }
         gc = next;
     }
@@ -520,19 +520,22 @@
     }
 }
 
-/* Return true if object has a pre-PEP 442 finalization method. */
+/* Return true if object has a finalization method. */
 static int
-has_legacy_finalizer(PyObject *op)
+has_finalizer(PyObject *op)
 {
-    return op->ob_type->tp_del != NULL;
+    if (PyGen_CheckExact(op))
+        return PyGen_NeedsFinalizing((PyGenObject *)op);
+    else
+        return op->ob_type->tp_del != NULL;
 }
 
-/* Move the objects in unreachable with tp_del slots into `finalizers`.
+/* Move the objects in unreachable with __del__ methods into `finalizers`.
  * Objects moved into `finalizers` have gc_refs set to GC_REACHABLE; the
  * objects remaining in unreachable are left at GC_TENTATIVELY_UNREACHABLE.
  */
 static void
-move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
+move_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
 {
     PyGC_Head *gc;
     PyGC_Head *next;
@@ -546,14 +549,14 @@
         assert(IS_TENTATIVELY_UNREACHABLE(op));
         next = gc->gc.gc_next;
 
-        if (has_legacy_finalizer(op)) {
+        if (has_finalizer(op)) {
             gc_list_move(gc, finalizers);
-            _PyGCHead_SET_REFS(gc, GC_REACHABLE);
+            gc->gc.gc_refs = GC_REACHABLE;
         }
     }
 }
 
-/* A traversal callback for move_legacy_finalizer_reachable. */
+/* A traversal callback for move_finalizer_reachable. */
 static int
 visit_move(PyObject *op, PyGC_Head *tolist)
 {
@@ -561,7 +564,7 @@
         if (IS_TENTATIVELY_UNREACHABLE(op)) {
             PyGC_Head *gc = AS_GC(op);
             gc_list_move(gc, tolist);
-            _PyGCHead_SET_REFS(gc, GC_REACHABLE);
+            gc->gc.gc_refs = GC_REACHABLE;
         }
     }
     return 0;
@@ -571,7 +574,7 @@
  * into finalizers set.
  */
 static void
-move_legacy_finalizer_reachable(PyGC_Head *finalizers)
+move_finalizer_reachable(PyGC_Head *finalizers)
 {
     traverseproc traverse;
     PyGC_Head *gc = finalizers->gc.gc_next;
@@ -744,7 +747,7 @@
                        msg, Py_TYPE(op)->tp_name, op);
 }
 
-/* Handle uncollectable garbage (cycles with tp_del slots, and stuff reachable
+/* Handle uncollectable garbage (cycles with finalizers, and stuff reachable
  * only from such cycles).
  * If DEBUG_SAVEALL, all objects in finalizers are appended to the module
  * garbage list (a Python list), else only the objects in finalizers with
@@ -754,7 +757,7 @@
  * The finalizers list is made empty on a successful return.
  */
 static int
-handle_legacy_finalizers(PyGC_Head *finalizers, PyGC_Head *old)
+handle_finalizers(PyGC_Head *finalizers, PyGC_Head *old)
 {
     PyGC_Head *gc = finalizers->gc.gc_next;
 
@@ -766,7 +769,7 @@
     for (; gc != finalizers; gc = gc->gc.gc_next) {
         PyObject *op = FROM_GC(gc);
 
-        if ((debug & DEBUG_SAVEALL) || has_legacy_finalizer(op)) {
+        if ((debug & DEBUG_SAVEALL) || has_finalizer(op)) {
             if (PyList_Append(garbage, op) < 0)
                 return -1;
         }
@@ -776,62 +779,6 @@
     return 0;
 }
 
-static void
-finalize_garbage(PyGC_Head *collectable, PyGC_Head *old)
-{
-    destructor finalize;
-    PyGC_Head *gc = collectable->gc.gc_next;
-
-    for (; gc != collectable; gc = gc->gc.gc_next) {
-        PyObject *op = FROM_GC(gc);
-
-        if (!_PyGCHead_FINALIZED(gc) &&
-            PyType_HasFeature(Py_TYPE(op), Py_TPFLAGS_HAVE_FINALIZE) &&
-            (finalize = Py_TYPE(op)->tp_finalize) != NULL) {
-            _PyGCHead_SET_FINALIZED(gc, 1);
-            Py_INCREF(op);
-            finalize(op);
-            if (Py_REFCNT(op) == 1) {
-                /* op will be destroyed */
-                gc = gc->gc.gc_prev;
-            }
-            Py_DECREF(op);
-        }
-    }
-}
-
-/* Walk the collectable list and check that they are really unreachable
-   from the outside (some objects could have been resurrected by a
-   finalizer). */
-static int
-check_garbage(PyGC_Head *collectable)
-{
-    PyGC_Head *gc;
-    for (gc = collectable->gc.gc_next; gc != collectable;
-         gc = gc->gc.gc_next) {
-        _PyGCHead_SET_REFS(gc, Py_REFCNT(FROM_GC(gc)));
-        assert(_PyGCHead_REFS(gc) != 0);
-    }
-    subtract_refs(collectable);
-    for (gc = collectable->gc.gc_next; gc != collectable;
-         gc = gc->gc.gc_next) {
-        assert(_PyGCHead_REFS(gc) >= 0);
-        if (_PyGCHead_REFS(gc) != 0)
-            return -1;
-    }
-    return 0;
-}
-
-static void
-revive_garbage(PyGC_Head *collectable)
-{
-    PyGC_Head *gc;
-    for (gc = collectable->gc.gc_next; gc != collectable;
-         gc = gc->gc.gc_next) {
-        _PyGCHead_SET_REFS(gc, GC_REACHABLE);
-    }
-}
-
 /* Break reference cycles by clearing the containers involved.  This is
  * tricky business as the lists can be changing and we don't know which
  * objects may be freed.  It is possible I screwed something up here.
@@ -845,6 +792,7 @@
         PyGC_Head *gc = collectable->gc.gc_next;
         PyObject *op = FROM_GC(gc);
 
+        assert(IS_TENTATIVELY_UNREACHABLE(op));
         if (debug & DEBUG_SAVEALL) {
             PyList_Append(garbage, op);
         }
@@ -858,7 +806,7 @@
         if (collectable->gc.gc_next == gc) {
             /* object is still alive, move it, it may die later */
             gc_list_move(gc, old);
-            _PyGCHead_SET_REFS(gc, GC_REACHABLE);
+            gc->gc.gc_refs = GC_REACHABLE;
         }
     }
 }
@@ -981,15 +929,19 @@
     }
 
     /* All objects in unreachable are trash, but objects reachable from
-     * legacy finalizers (e.g. tp_del) can't safely be deleted.
+     * finalizers can't safely be deleted.  Python programmers should take
+     * care not to create such things.  For Python, finalizers means
+     * instance objects with __del__ methods.  Weakrefs with callbacks
+     * can also call arbitrary Python code but they will be dealt with by
+     * handle_weakrefs().
      */
     gc_list_init(&finalizers);
-    move_legacy_finalizers(&unreachable, &finalizers);
-    /* finalizers contains the unreachable objects with a legacy finalizer;
+    move_finalizers(&unreachable, &finalizers);
+    /* finalizers contains the unreachable objects with a finalizer;
      * unreachable objects reachable *from* those are also uncollectable,
      * and we move those into the finalizers list too.
      */
-    move_legacy_finalizer_reachable(&finalizers);
+    move_finalizer_reachable(&finalizers);
 
     /* Collect statistics on collectable objects found and print
      * debugging information.
@@ -1005,20 +957,11 @@
     /* Clear weakrefs and invoke callbacks as necessary. */
     m += handle_weakrefs(&unreachable, old);
 
-    /* Call tp_finalize on objects which have one. */
-    finalize_garbage(&unreachable, old);
-
-    if (check_garbage(&unreachable)) {
-        revive_garbage(&unreachable);
-        gc_list_merge(&unreachable, old);
-    }
-    else {
-        /* Call tp_clear on objects in the unreachable set.  This will cause
-         * the reference cycles to be broken.  It may also cause some objects
-         * in finalizers to be freed.
-         */
-        delete_garbage(&unreachable, old);
-    }
+    /* Call tp_clear on objects in the unreachable set.  This will cause
+     * the reference cycles to be broken.  It may also cause some objects
+     * in finalizers to be freed.
+     */
+    delete_garbage(&unreachable, old);
 
     /* Collect statistics on uncollectable objects found and print
      * debugging information. */
@@ -1049,7 +992,7 @@
      * reachable list of garbage.  The programmer has to deal with
      * this if they insist on creating this type of structure.
      */
-    (void)handle_legacy_finalizers(&finalizers, old);
+    (void)handle_finalizers(&finalizers, old);
 
     /* Clear free list only during the collection of the highest
      * generation */
@@ -1661,7 +1604,6 @@
 _PyGC_Fini(void)
 {
     Py_CLEAR(callbacks);
-    Py_CLEAR(tmod);
 }
 
 /* for debugging */
@@ -1720,8 +1662,7 @@
         sizeof(PyGC_Head) + basicsize);
     if (g == NULL)
         return PyErr_NoMemory();
-    g->gc.gc_refs = 0;
-    _PyGCHead_SET_REFS(g, GC_UNTRACKED);
+    g->gc.gc_refs = GC_UNTRACKED;
     generations[0].count++; /* number of allocated GC objects */
     if (generations[0].count > generations[0].threshold &&
         enabled &&
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/grpmodule.c
--- a/Modules/grpmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/grpmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -10,7 +10,7 @@
    {"gr_name", "group name"},
    {"gr_passwd", "password"},
    {"gr_gid", "group id"},
-   {"gr_mem", "group members"},
+   {"gr_mem", "group memebers"},
    {0}
 };
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/hashlib.h
--- a/Modules/hashlib.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/hashlib.h	Mon Aug 12 02:18:40 2013 +0200
@@ -2,7 +2,7 @@
 
 /*
  * Given a PyObject* obj, fill in the Py_buffer* viewp with the result
- * of PyObject_GetBuffer.  Sets an exception and issues a return NULL
+ * of PyObject_GetBuffer.  Sets and exception and issues a return NULL
  * on any errors.
  */
 #define GET_BUFFER_VIEW_OR_ERROUT(obj, viewp) do { \
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/main.c
--- a/Modules/main.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/main.c	Mon Aug 12 02:18:40 2013 +0200
@@ -22,6 +22,10 @@
 #include <crtdbg.h>
 #endif
 
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif /* HAVE_FCNTL_H */
+
 #if defined(MS_WINDOWS)
 #define PYTHONHOMEHELP "<prefix>\\lib"
 #else
@@ -43,7 +47,7 @@
 static int  orig_argc;
 
 /* command line options */
-#define BASE_OPTS L"bBc:dEhiIJm:OqRsStuvVW:xX:?"
+#define BASE_OPTS L"bBc:dEhiJm:OqRsStuvVW:xX:?"
 
 #define PROGRAM_OPTS BASE_OPTS
 
@@ -65,7 +69,6 @@
 static char *usage_2 = "\
 -i     : inspect interactively after running script; forces a prompt even\n\
          if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
--I     : isolate Python from the user's environment (implies -E and -s)\n\
 -m mod : run library module as a script (terminates option list)\n\
 -O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
 -OO    : remove doc-strings in addition to the -O optimizations\n\
@@ -143,7 +146,7 @@
 {
     char *startup = Py_GETENV("PYTHONSTARTUP");
     if (startup != NULL && startup[0] != '\0') {
-        FILE *fp = fopen(startup, "r");
+        FILE *fp = _Py_fopen(startup, "r");
         if (fp != NULL) {
             (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
             PyErr_Clear();
@@ -427,12 +430,6 @@
             Py_InteractiveFlag++;
             break;
 
-        case 'I':
-            Py_IsolatedFlag++;
-            Py_NoUserSiteDirectory++;
-            Py_IgnoreEnvironmentFlag++;
-            break;
-
         /* case 'J': reserved for Jython */
 
         case 'O':
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/mmapmodule.c
--- a/Modules/mmapmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/mmapmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -20,7 +20,6 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
-#include "structmember.h"
 
 #ifndef MS_WINDOWS
 #define UNIX
@@ -109,7 +108,6 @@
     int fd;
 #endif
 
-    PyObject *weakreflist;
     access_mode access;
 } mmap_object;
 
@@ -136,8 +134,6 @@
     }
 #endif /* UNIX */
 
-    if (m_obj->weakreflist != NULL)
-        PyObject_ClearWeakRefs((PyObject *) m_obj);
     Py_TYPE(m_obj)->tp_free((PyObject*)m_obj);
 }
 
@@ -1036,7 +1032,7 @@
     0,                                          /* tp_traverse */
     0,                                          /* tp_clear */
     0,                                          /* tp_richcompare */
-    offsetof(mmap_object, weakreflist),         /* tp_weaklistoffset */
+    0,                                          /* tp_weaklistoffset */
     0,                                          /* tp_iter */
     0,                                          /* tp_iternext */
     mmap_object_methods,                        /* tp_methods */
@@ -1194,7 +1190,6 @@
     m_obj->data = NULL;
     m_obj->size = (size_t) map_size;
     m_obj->pos = (size_t) 0;
-    m_obj->weakreflist = NULL;
     m_obj->exports = 0;
     m_obj->offset = offset;
     if (fd == -1) {
@@ -1208,7 +1203,7 @@
         flags |= MAP_ANONYMOUS;
 #else
         /* SVR4 method to map anonymous memory is to open /dev/zero */
-        fd = devzero = open("/dev/zero", O_RDWR);
+        fd = devzero = _Py_open("/dev/zero", O_RDWR);
         if (devzero == -1) {
             Py_DECREF(m_obj);
             PyErr_SetFromErrno(PyExc_OSError);
@@ -1222,6 +1217,7 @@
             PyErr_SetFromErrno(PyExc_OSError);
             return NULL;
         }
+        _Py_try_set_inheritable(m_obj->fd, 0);
     }
 
     m_obj->data = mmap(NULL, map_size,
@@ -1399,7 +1395,6 @@
     /* set the initial position */
     m_obj->pos = (size_t) 0;
 
-    m_obj->weakreflist = NULL;
     m_obj->exports = 0;
     /* set the tag name */
     if (tagname != NULL && *tagname != '\0') {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/ossaudiodev.c
--- a/Modules/ossaudiodev.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/ossaudiodev.c	Mon Aug 12 02:18:40 2013 +0200
@@ -115,7 +115,9 @@
        one open at a time.  This does *not* affect later I/O; OSS
        provides a special ioctl() for non-blocking read/write, which is
        exposed via oss_nonblock() below. */
-    if ((fd = open(devicename, imode|O_NONBLOCK)) == -1) {
+    fd = _Py_open(devicename, imode|O_NONBLOCK);
+
+    if (fd == -1) {
         PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);
         return NULL;
     }
@@ -177,7 +179,8 @@
             devicename = "/dev/mixer";
     }
 
-    if ((fd = open(devicename, O_RDWR)) == -1) {
+    fd = _Py_open(devicename, O_RDWR);
+    if (fd == -1) {
         PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);
         return NULL;
     }
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/posixmodule.c
--- a/Modules/posixmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/posixmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -417,213 +417,108 @@
 int
 _Py_Uid_Converter(PyObject *obj, void *p)
 {
-    uid_t uid;
-    PyObject *index;
     int overflow;
     long result;
-    unsigned long uresult;
-
-    index = PyNumber_Index(obj);
-    if (index == NULL) {
-        PyErr_Format(PyExc_TypeError,
-                     "uid should be integer, not %.200s",
-                     Py_TYPE(obj)->tp_name);
+    if (PyFloat_Check(obj)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float");
         return 0;
     }
-
-    /*
-     * Handling uid_t is complicated for two reasons:
-     *  * Although uid_t is (always?) unsigned, it still
-     *    accepts -1.
-     *  * We don't know its size in advance--it may be
-     *    bigger than an int, or it may be smaller than
-     *    a long.
-     *
-     * So a bit of defensive programming is in order.
-     * Start with interpreting the value passed
-     * in as a signed long and see if it works.
-     */
-
-    result = PyLong_AsLongAndOverflow(index, &overflow);
-
-    if (!overflow) {
-        uid = (uid_t)result;
-
-        if (result == -1) {
-            if (PyErr_Occurred())
-                goto fail;
-            /* It's a legitimate -1, we're done. */
-            goto success;
-        }
-
-        /* Any other negative number is disallowed. */
-        if (result < 0)
-            goto underflow;
-
-        /* Ensure the value wasn't truncated. */
+    result = PyLong_AsLongAndOverflow(obj, &overflow);
+    if (overflow < 0)
+        goto OverflowDown;
+    if (!overflow && result == -1) {
+        /* error or -1 */
+        if (PyErr_Occurred())
+            return 0;
+        *(uid_t *)p = (uid_t)-1;
+    }
+    else {
+        /* unsigned uid_t */
+        unsigned long uresult;
+        if (overflow > 0) {
+            uresult = PyLong_AsUnsignedLong(obj);
+            if (PyErr_Occurred()) {
+                if (PyErr_ExceptionMatches(PyExc_OverflowError))
+                    goto OverflowUp;
+                return 0;
+            }
+            if ((uid_t)uresult == (uid_t)-1)
+                goto OverflowUp;
+        } else {
+            if (result < 0)
+                goto OverflowDown;
+            uresult = result;
+        }
         if (sizeof(uid_t) < sizeof(long) &&
-            (long)uid != result)
-            goto underflow;
-        goto success;
-    }
-
-    if (overflow < 0)
-        goto underflow;
-
-    /*
-     * Okay, the value overflowed a signed long.  If it
-     * fits in an *unsigned* long, it may still be okay,
-     * as uid_t may be unsigned long on this platform.
-     */
-    uresult = PyLong_AsUnsignedLong(index);
-    if (PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
-            goto overflow;
-        goto fail;
-    }
-
-    uid = (uid_t)uresult;
-
-    /*
-     * If uid == (uid_t)-1, the user actually passed in ULONG_MAX,
-     * but this value would get interpreted as (uid_t)-1  by chown
-     * and its siblings.   That's not what the user meant!  So we
-     * throw an overflow exception instead.   (We already
-     * handled a real -1 with PyLong_AsLongAndOverflow() above.) 
-     */
-    if (uid == (uid_t)-1)
-        goto overflow;
-
-    /* Ensure the value wasn't truncated. */
-    if (sizeof(uid_t) < sizeof(long) &&
-        (unsigned long)uid != uresult)
-        goto overflow;
-    /* fallthrough */
-
-success:
-    Py_DECREF(index);
-    *(uid_t *)p = uid;
+            (unsigned long)(uid_t)uresult != uresult)
+            goto OverflowUp;
+        *(uid_t *)p = (uid_t)uresult;
+    }
     return 1;
 
-underflow:
+OverflowDown:
     PyErr_SetString(PyExc_OverflowError,
-                    "uid is less than minimum");
-    goto fail;
-
-overflow:
+                    "user id is less than minimum");
+    return 0;
+
+OverflowUp:
     PyErr_SetString(PyExc_OverflowError,
-                    "uid is greater than maximum");
-    /* fallthrough */
-
-fail:
-    Py_DECREF(index);
+                    "user id is greater than maximum");
     return 0;
 }
 
 int
 _Py_Gid_Converter(PyObject *obj, void *p)
 {
-    gid_t gid;
-    PyObject *index;
     int overflow;
     long result;
-    unsigned long uresult;
-
-    index = PyNumber_Index(obj);
-    if (index == NULL) {
-        PyErr_Format(PyExc_TypeError,
-                     "gid should be integer, not %.200s",
-                     Py_TYPE(obj)->tp_name);
+    if (PyFloat_Check(obj)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float");
         return 0;
     }
-
-    /*
-     * Handling gid_t is complicated for two reasons:
-     *  * Although gid_t is (always?) unsigned, it still
-     *    accepts -1.
-     *  * We don't know its size in advance--it may be
-     *    bigger than an int, or it may be smaller than
-     *    a long.
-     *
-     * So a bit of defensive programming is in order.
-     * Start with interpreting the value passed
-     * in as a signed long and see if it works.
-     */
-
-    result = PyLong_AsLongAndOverflow(index, &overflow);
-
-    if (!overflow) {
-        gid = (gid_t)result;
-
-        if (result == -1) {
-            if (PyErr_Occurred())
-                goto fail;
-            /* It's a legitimate -1, we're done. */
-            goto success;
-        }
-
-        /* Any other negative number is disallowed. */
-        if (result < 0) {
-            goto underflow;
-        }
-
-        /* Ensure the value wasn't truncated. */
+    result = PyLong_AsLongAndOverflow(obj, &overflow);
+    if (overflow < 0)
+        goto OverflowDown;
+    if (!overflow && result == -1) {
+        /* error or -1 */
+        if (PyErr_Occurred())
+            return 0;
+        *(gid_t *)p = (gid_t)-1;
+    }
+    else {
+        /* unsigned gid_t */
+        unsigned long uresult;
+        if (overflow > 0) {
+            uresult = PyLong_AsUnsignedLong(obj);
+            if (PyErr_Occurred()) {
+                if (PyErr_ExceptionMatches(PyExc_OverflowError))
+                    goto OverflowUp;
+                return 0;
+            }
+            if ((gid_t)uresult == (gid_t)-1)
+                goto OverflowUp;
+        } else {
+            if (result < 0)
+                goto OverflowDown;
+            uresult = result;
+        }
         if (sizeof(gid_t) < sizeof(long) &&
-            (long)gid != result)
-            goto underflow;
-        goto success;
-    }
-
-    if (overflow < 0)
-        goto underflow;
-
-    /*
-     * Okay, the value overflowed a signed long.  If it
-     * fits in an *unsigned* long, it may still be okay,
-     * as gid_t may be unsigned long on this platform.
-     */
-    uresult = PyLong_AsUnsignedLong(index);
-    if (PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
-            goto overflow;
-        goto fail;
-    }
-
-    gid = (gid_t)uresult;
-
-    /*
-     * If gid == (gid_t)-1, the user actually passed in ULONG_MAX,
-     * but this value would get interpreted as (gid_t)-1  by chown
-     * and its siblings.   That's not what the user meant!  So we
-     * throw an overflow exception instead.   (We already
-     * handled a real -1 with PyLong_AsLongAndOverflow() above.) 
-     */
-    if (gid == (gid_t)-1)
-        goto overflow;
-
-    /* Ensure the value wasn't truncated. */
-    if (sizeof(gid_t) < sizeof(long) &&
-        (unsigned long)gid != uresult)
-        goto overflow;
-    /* fallthrough */
-
-success:
-    Py_DECREF(index);
-    *(gid_t *)p = gid;
+            (unsigned long)(gid_t)uresult != uresult)
+            goto OverflowUp;
+        *(gid_t *)p = (gid_t)uresult;
+    }
     return 1;
 
-underflow:
+OverflowDown:
     PyErr_SetString(PyExc_OverflowError,
-                    "gid is less than minimum");
-    goto fail;
-
-overflow:
+                    "group id is less than minimum");
+    return 0;
+
+OverflowUp:
     PyErr_SetString(PyExc_OverflowError,
-                    "gid is greater than maximum");
-    /* fallthrough */
-
-fail:
-    Py_DECREF(index);
+                    "group id is greater than maximum");
     return 0;
 }
 #endif /* MS_WINDOWS */
@@ -646,29 +541,25 @@
 _fd_converter(PyObject *o, int *p, const char *allowed)
 {
     int overflow;
-    long long_value;
-
-    PyObject *index = PyNumber_Index(o);
-    if (index == NULL) {
+    long long_value = PyLong_AsLongAndOverflow(o, &overflow);
+    if (PyFloat_Check(o) ||
+        (long_value == -1 && !overflow && PyErr_Occurred())) {
+        PyErr_Clear();
         PyErr_Format(PyExc_TypeError,
-                     "argument should be %s, not %.200s",
-                     allowed, Py_TYPE(o)->tp_name);
+                        "argument should be %s, not %.200s",
+                        allowed, Py_TYPE(o)->tp_name);
         return 0;
     }
-
-    long_value = PyLong_AsLongAndOverflow(index, &overflow);
-    Py_DECREF(index);
     if (overflow > 0 || long_value > INT_MAX) {
         PyErr_SetString(PyExc_OverflowError,
-                        "fd is greater than maximum");
+                        "signed integer is greater than maximum");
         return 0;
     }
     if (overflow < 0 || long_value < INT_MIN) {
         PyErr_SetString(PyExc_OverflowError,
-                        "fd is less than minimum");
+                        "signed integer is less than minimum");
         return 0;
     }
-
     *p = (int)long_value;
     return 1;
 }
@@ -3529,13 +3420,12 @@
 static PyObject *
 _posix_listdir(path_t *path, PyObject *list)
 {
+    int fd = -1;
+
     PyObject *v;
     DIR *dirp = NULL;
     struct dirent *ep;
     int return_str; /* if false, return bytes */
-#ifdef HAVE_FDOPENDIR
-    int fd = -1;
-#endif
 
     errno = 0;
 #ifdef HAVE_FDOPENDIR
@@ -3543,6 +3433,8 @@
         /* closedir() closes the FD, so we duplicate it */
         Py_BEGIN_ALLOW_THREADS
         fd = dup(path->fd);
+        if (fd != -1)
+            _Py_try_set_inheritable(fd, 0);
         Py_END_ALLOW_THREADS
 
         if (fd == -1) {
@@ -3577,13 +3469,6 @@
 
     if (dirp == NULL) {
         list = path_error(path);
-#ifdef HAVE_FDOPENDIR
-        if (fd != -1) {
-            Py_BEGIN_ALLOW_THREADS
-            close(fd);
-            Py_END_ALLOW_THREADS
-        }
-#endif
         goto exit;
     }
     if ((list = PyList_New(0)) == NULL) {
@@ -3626,10 +3511,8 @@
 exit:
     if (dirp != NULL) {
         Py_BEGIN_ALLOW_THREADS
-#ifdef HAVE_FDOPENDIR
         if (fd > -1)
             rewinddir(dirp);
-#endif
         closedir(dirp);
         Py_END_ALLOW_THREADS
     }
@@ -3830,47 +3713,6 @@
     else
         Py_RETURN_FALSE;
 }
-
-PyDoc_STRVAR(posix__getvolumepathname__doc__,
-"Return volume mount point of the specified path.");
-
-/* A helper function for ismount on windows */
-static PyObject *
-posix__getvolumepathname(PyObject *self, PyObject *args)
-{
-    PyObject *po, *result;
-    wchar_t *path, *mountpath=NULL;
-    size_t bufsize;
-    BOOL ret;
-
-    if (!PyArg_ParseTuple(args, "U|:_getvolumepathname", &po))
-        return NULL;
-    path = PyUnicode_AsUnicode(po);
-    if (path == NULL)
-        return NULL;
-
-    /* Volume path should be shorter than entire path */
-    bufsize = max(MAX_PATH, wcslen(path) * 2 * sizeof(wchar_t)+1);
-    mountpath = (wchar_t *)PyMem_Malloc(bufsize);
-    if (mountpath == NULL)
-        return PyErr_NoMemory();
-
-    Py_BEGIN_ALLOW_THREADS
-    ret = GetVolumePathNameW(path, mountpath, bufsize);
-    Py_END_ALLOW_THREADS
-
-    if (!ret) {
-        result = win32_error_object("_getvolumepathname", po);
-        goto exit;
-    }
-    result = PyUnicode_FromWideChar(mountpath, wcslen(mountpath));
-
-exit:
-    PyMem_Free(mountpath);
-    return result;
-}
-/* end of posix__getvolumepathname */
-
 #endif /* MS_WINDOWS */
 
 PyDoc_STRVAR(posix_mkdir__doc__,
@@ -4654,7 +4496,6 @@
 
     memset(&path, 0, sizeof(path));
     path.function_name = "utime";
-    memset(&utime, 0, sizeof(utime_t));
 #if UTIME_HAVE_FD
     path.allow_fd = 1;
 #endif
@@ -5774,8 +5615,9 @@
 static PyObject *
 posix_openpty(PyObject *self, PyObject *noargs)
 {
-    int master_fd, slave_fd;
+    int master_fd = -1, slave_fd = -1;
 #ifndef HAVE_OPENPTY
+    int flags;
     char * slave_name;
 #endif
 #if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
@@ -5788,18 +5630,40 @@
 #ifdef HAVE_OPENPTY
     if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) != 0)
         return posix_error();
+
+    if (_Py_set_inheritable(master_fd, 0, NULL) < 0)
+        goto error;
+    if (_Py_set_inheritable(slave_fd, 0, NULL) < 0)
+        goto error;
+
 #elif defined(HAVE__GETPTY)
     slave_name = _getpty(&master_fd, O_RDWR, 0666, 0);
     if (slave_name == NULL)
         return posix_error();
-
-    slave_fd = open(slave_name, O_RDWR);
+    if (_Py_set_inheritable(master_fd, 0, NULL) < 0)
+        goto error;
+
+    flags = O_RDWR;
+#ifdef O_CLOEXEC
+    flags |= O_CLOEXEC;
+#endif
+    slave_fd = open(slave_name, flags);
     if (slave_fd < 0)
         return posix_error();
-#else
-    master_fd = open(DEV_PTY_FILE, O_RDWR | O_NOCTTY); /* open master */
+    if (_Py_set_inheritable(slave_fd, 0, NULL) < 0)
+        goto error;
+
+#else
+    flags = O_RDWR | O_NOCTTY;
+#ifdef O_CLOEXEC
+    flags |= O_CLOEXEC;
+#endif
+    master_fd = open(DEV_PTY_FILE, flags); /* open master */
     if (master_fd < 0)
         return posix_error();
+    if (_Py_set_inheritable(master_fd, 0, NULL) < 0)
+        goto error;
+
     sig_saved = PyOS_setsig(SIGCHLD, SIG_DFL);
     /* change permission of slave */
     if (grantpt(master_fd) < 0) {
@@ -5815,9 +5679,15 @@
     slave_name = ptsname(master_fd); /* get name of slave */
     if (slave_name == NULL)
         return posix_error();
-    slave_fd = open(slave_name, O_RDWR | O_NOCTTY); /* open slave */
+    flags = O_RDWR | O_NOCTTY;
+#ifdef O_CLOEXEC
+    flags |= O_CLOEXEC;
+#endif
+    slave_fd = open(slave_name, flags); /* open slave */
     if (slave_fd < 0)
         return posix_error();
+    if (_Py_set_inheritable(slave_fd, 0, NULL) < 0)
+        goto error;
 #if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
     ioctl(slave_fd, I_PUSH, "ptem"); /* push ptem */
     ioctl(slave_fd, I_PUSH, "ldterm"); /* push ldterm */
@@ -5829,6 +5699,12 @@
 
     return Py_BuildValue("(ii)", master_fd, slave_fd);
 
+error:
+    if (master_fd != -1)
+        close(master_fd);
+    if (slave_fd != -1)
+        close(slave_fd);
+    return NULL;
 }
 #endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
 
@@ -6020,34 +5896,6 @@
     gid_t* alt_grouplist = grouplist;
     int n;
 
-#ifdef __APPLE__
-    /* Issue #17557: As of OS X 10.8, getgroups(2) no longer raises EINVAL if
-     * there are more groups than can fit in grouplist.  Therefore, on OS X
-     * always first call getgroups with length 0 to get the actual number
-     * of groups.
-     */
-    n = getgroups(0, NULL);
-    if (n < 0) {
-        return posix_error();
-    } else if (n <= MAX_GROUPS) {
-        /* groups will fit in existing array */
-        alt_grouplist = grouplist;
-    } else {
-        alt_grouplist = PyMem_Malloc(n * sizeof(gid_t));
-        if (alt_grouplist == NULL) {
-            errno = EINVAL;
-            return posix_error();
-        }
-    }
-
-    n = getgroups(n, alt_grouplist);
-    if (n == -1) {
-        if (alt_grouplist != grouplist) {
-            PyMem_Free(alt_grouplist);
-        }
-        return posix_error();
-    }
-#else
     n = getgroups(MAX_GROUPS, grouplist);
     if (n < 0) {
         if (errno == EINVAL) {
@@ -6074,8 +5922,6 @@
             return posix_error();
         }
     }
-#endif
-
     result = PyList_New(n);
     if (result != NULL) {
         int i;
@@ -7438,6 +7284,10 @@
 
 /* Functions acting on file descriptors */
 
+#ifdef O_CLOEXEC
+extern int _Py_open_cloexec_works;
+#endif
+
 PyDoc_STRVAR(posix_open__doc__,
 "open(path, flags, mode=0o777, *, dir_fd=None)\n\n\
 Open a file for low level IO.  Returns a file handle (integer).\n\
@@ -7457,6 +7307,13 @@
     int fd;
     PyObject *return_value = NULL;
     static char *keywords[] = {"path", "flags", "mode", "dir_fd", NULL};
+#ifndef MS_WINDOWS
+#ifdef O_CLOEXEC
+    int *atomic_flag_works = &_Py_open_cloexec_works;
+#else
+    int *atomic_flag_works = NULL;
+#endif
+#endif
 
     memset(&path, 0, sizeof(path));
     path.function_name = "open";
@@ -7471,6 +7328,12 @@
         ))
         return NULL;
 
+#ifdef MS_WINDOWS
+    flags |= O_NOINHERIT;
+#elif defined(O_CLOEXEC)
+    flags |= O_CLOEXEC;
+#endif
+
     Py_BEGIN_ALLOW_THREADS
 #ifdef MS_WINDOWS
     if (path.wide)
@@ -7490,6 +7353,13 @@
         goto exit;
     }
 
+#ifndef MS_WINDOWS
+    if (_Py_set_inheritable(fd, 0, atomic_flag_works) < 0) {
+        close(fd);
+        goto exit;
+    }
+#endif
+
     return_value = PyLong_FromLong((long)fd);
 
 exit:
@@ -7546,13 +7416,41 @@
 posix_dup(PyObject *self, PyObject *args)
 {
     int fd;
+    int inheritable;
+
     if (!PyArg_ParseTuple(args, "i:dup", &fd))
         return NULL;
+
     if (!_PyVerify_fd(fd))
         return posix_error();
-    fd = dup(fd);
-    if (fd < 0)
-        return posix_error();
+
+#ifdef MS_WINDOWS
+    inheritable = (fd < 3);
+#else
+    inheritable = 0;
+#endif
+
+#if defined(HAVE_FCNTL_H) && defined(F_DUPFD_CLOEXEC)
+    if (!inheritable) {
+        Py_BEGIN_ALLOW_THREADS
+            fd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
+        Py_END_ALLOW_THREADS
+            if (fd < 0)
+                return posix_error();
+    }
+    else
+#endif
+    {
+        Py_BEGIN_ALLOW_THREADS
+        fd = dup(fd);
+        Py_END_ALLOW_THREADS
+        if (fd < 0)
+            return posix_error();
+        if (!inheritable && _Py_set_inheritable(fd, 0, NULL) < 0) {
+            close(fd);
+            return NULL;
+        }
+    }
     return PyLong_FromLong((long)fd);
 }
 
@@ -7565,13 +7463,47 @@
 posix_dup2(PyObject *self, PyObject *args)
 {
     int fd, fd2, res;
+    int inheritable;
+#ifdef HAVE_DUP3
+    /* dup3() is available on Linux 2.6.27+ and glibc 2.9 */
+    int dup3_works = -1;
+#endif
+
     if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2))
         return NULL;
     if (!_PyVerify_fd_dup2(fd, fd2))
         return posix_error();
-    res = dup2(fd, fd2);
-    if (res < 0)
-        return posix_error();
+    inheritable = (fd2 < 3);
+
+#ifdef HAVE_DUP3
+    if (!inheritable && dup3_works != 0) {
+        Py_BEGIN_ALLOW_THREADS
+        res = dup3(fd, fd2, O_CLOEXEC);
+        Py_END_ALLOW_THREADS
+        if (res < 0) {
+            if (dup3_works == -1)
+                dup3_works = (errno != ENOSYS);
+            if (dup3_works)
+                return posix_error();
+        }
+    }
+
+    if (inheritable || dup3_works == 0)
+    {
+#endif
+        Py_BEGIN_ALLOW_THREADS
+        res = dup2(fd, fd2);
+        Py_END_ALLOW_THREADS
+        if (res < 0)
+            return posix_error();
+        if (!inheritable && _Py_set_inheritable(fd2, 0, NULL) < 0) {
+            close(fd2);
+            return NULL;
+        }
+#ifdef HAVE_DUP3
+    }
+#endif
+
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -8052,30 +7984,75 @@
 
 #ifdef HAVE_PIPE
 PyDoc_STRVAR(posix_pipe__doc__,
-"pipe() -> (read_end, write_end)\n\n\
-Create a pipe.");
+"pipe() -> (read_end, write_end)\n\n"
+"Create a pipe. If cloexec is True, set the close-on-exec flag.");
 
 static PyObject *
 posix_pipe(PyObject *self, PyObject *noargs)
 {
-#if !defined(MS_WINDOWS)
     int fds[2];
+#ifdef MS_WINDOWS
+    HANDLE read, write;
+    SECURITY_ATTRIBUTES attr;
+    BOOL ok;
+#else
     int res;
-    res = pipe(fds);
-    if (res != 0)
-        return posix_error();
-    return Py_BuildValue("(ii)", fds[0], fds[1]);
-#else /* MS_WINDOWS */
-    HANDLE read, write;
-    int read_fd, write_fd;
-    BOOL ok;
-    ok = CreatePipe(&read, &write, NULL, 0);
+#endif
+
+#ifdef MS_WINDOWS
+    attr.nLength = sizeof(attr);
+    attr.lpSecurityDescriptor = NULL;
+    attr.bInheritHandle = FALSE;
+
+    Py_BEGIN_ALLOW_THREADS
+    ok = CreatePipe(&read, &write, &attr, 0);
+    if (ok) {
+        fds[0] = _open_osfhandle((Py_intptr_t)read, _O_RDONLY);
+        fds[1] = _open_osfhandle((Py_intptr_t)write, _O_WRONLY);
+        if (fds[0] == -1 || fds[1] == -1) {
+            CloseHandle(read);
+            CloseHandle(write);
+            ok = 0;
+        }
+    }
+    Py_END_ALLOW_THREADS
+
     if (!ok)
         return PyErr_SetFromWindowsErr(0);
-    read_fd = _open_osfhandle((Py_intptr_t)read, 0);
-    write_fd = _open_osfhandle((Py_intptr_t)write, 1);
-    return Py_BuildValue("(ii)", read_fd, write_fd);
-#endif /* MS_WINDOWS */
+#else
+
+#ifdef HAVE_PIPE2
+    Py_BEGIN_ALLOW_THREADS
+    res = pipe2(fds, O_CLOEXEC);
+    Py_END_ALLOW_THREADS
+
+    if (res != 0 && errno == ENOSYS)
+    {
+#endif
+        Py_BEGIN_ALLOW_THREADS
+        res = pipe(fds);
+        Py_END_ALLOW_THREADS
+
+        if (res == 0) {
+            if (_Py_set_inheritable(fds[0], 0, NULL) < 0) {
+                close(fds[0]);
+                close(fds[1]);
+                return NULL;
+            }
+            if (_Py_set_inheritable(fds[1], 0, NULL) < 0) {
+                close(fds[0]);
+                close(fds[1]);
+                return NULL;
+            }
+        }
+#ifdef HAVE_PIPE2
+    }
+#endif
+
+    if (res != 0)
+        return PyErr_SetFromErrno(PyExc_OSError);
+#endif /* !MS_WINDOWS */
+    return Py_BuildValue("(ii)", fds[0], fds[1]);
 }
 #endif  /* HAVE_PIPE */
 
@@ -10665,6 +10642,76 @@
         Py_RETURN_NONE;
 }
 
+#if defined(MS_WINDOWS) \
+    || (defined(HAVE_SYS_IOCTL_H) && defined(FIOCLEX) && defined(FIONCLEX)) \
+    || defined(HAVE_FCNTL_H)
+#define POSIX_SET_CLOEXEC
+#endif
+
+#ifdef POSIX_SET_CLOEXEC
+PyDoc_STRVAR(get_inheritable__doc__,
+    "get_inheritable(fd) -> bool\n" \
+    "\n" \
+    "Get the close-on-exe flag of the specified file descriptor.");
+
+static PyObject*
+posix_get_inheritable(PyObject *self, PyObject *args)
+{
+    int fd;
+    int inheritable;
+
+    if (!PyArg_ParseTuple(args, "i:get_inheritable", &fd))
+        return NULL;
+
+#ifdef MS_WINDOWS
+    if (!_PyVerify_fd(fd)) {
+        /* fd may be an handle, ex: a Windows socket */
+        fd = _open_osfhandle((Py_intptr_t)fd, _O_RDONLY);
+        if (fd == -1) {
+            PyErr_SetFromWindowsErr(0);
+            return NULL;
+        }
+    }
+#endif
+
+    inheritable = _Py_get_inheritable(fd);
+    if (inheritable < 0)
+        return NULL;
+    return PyBool_FromLong(inheritable);
+}
+
+PyDoc_STRVAR(set_inheritable__doc__,
+    "set_inheritable(fd, inheritable)\n" \
+    "\n" \
+    "Set or clear inheritable flag on the specified file descriptor.");
+
+static PyObject*
+posix_set_inheritable(PyObject *self, PyObject *args)
+{
+    int fd;
+    int inheritable = 1;
+
+    if (!PyArg_ParseTuple(args, "ii:set_inheritable", &fd, &inheritable))
+        return NULL;
+
+#ifdef MS_WINDOWS
+    if (!_PyVerify_fd(fd)) {
+        /* fd may be an handle, ex: a Windows socket */
+        fd = _open_osfhandle((Py_intptr_t)fd, _O_RDONLY);
+        if (fd == -1) {
+            PyErr_SetFromWindowsErr(0);
+            return NULL;
+        }
+    }
+#endif
+
+    if (_Py_set_inheritable(fd, inheritable, NULL) < 0)
+        return NULL;
+    Py_RETURN_NONE;
+}
+#endif   /* POSIX_SET_CLOEXEC */
+
+
 
 static PyMethodDef posix_methods[] = {
     {"access",          (PyCFunction)posix_access,
@@ -11075,7 +11122,6 @@
     {"_getfinalpathname",       posix__getfinalpathname, METH_VARARGS, NULL},
     {"_isdir",                  posix__isdir, METH_VARARGS, posix__isdir__doc__},
     {"_getdiskusage",           win32__getdiskusage, METH_VARARGS, win32__getdiskusage__doc__},
-    {"_getvolumepathname",      posix__getvolumepathname, METH_VARARGS, posix__getvolumepathname__doc__},
 #endif
 #ifdef HAVE_GETLOADAVG
     {"getloadavg",      posix_getloadavg, METH_NOARGS, posix_getloadavg__doc__},
@@ -11113,6 +11159,10 @@
 #endif
     {"cpu_count", (PyCFunction)posix_cpu_count,
                   METH_NOARGS, posix_cpu_count__doc__},
+#ifdef POSIX_SET_CLOEXEC
+    {"get_inheritable", posix_get_inheritable, METH_VARARGS, get_inheritable__doc__},
+    {"set_inheritable", posix_set_inheritable, METH_VARARGS, set_inheritable__doc__},
+#endif
     {NULL,              NULL}            /* Sentinel */
 };
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/readline.c
--- a/Modules/readline.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/readline.c	Mon Aug 12 02:18:40 2013 +0200
@@ -6,7 +6,6 @@
 
 /* Standard definitions */
 #include "Python.h"
-#include <stddef.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <errno.h>
@@ -75,55 +74,6 @@
    (see issue #17289 for the motivation). */
 static char *completer_word_break_characters;
 
-typedef struct {
-  PyObject *completion_display_matches_hook;
-  PyObject *startup_hook;
-  PyObject *pre_input_hook;
-  PyObject *completer;
-  PyObject *begidx;
-  PyObject *endidx;
-} readlinestate;
-
-
-#define readline_state(o) ((readlinestate *)PyModule_GetState(o))
-
-static int
-readline_clear(PyObject *m)
-{
-   readlinestate *state = readline_state(m);
-   Py_CLEAR(state->completion_display_matches_hook);
-   Py_CLEAR(state->startup_hook);
-   Py_CLEAR(state->pre_input_hook);
-   Py_CLEAR(state->completer);
-   Py_CLEAR(state->begidx);
-   Py_CLEAR(state->endidx);
-   return 0;
-}
-
-static int
-readline_traverse(PyObject *m, visitproc visit, void *arg)
-{
-    readlinestate *state = readline_state(m);
-    Py_VISIT(state->completion_display_matches_hook);
-    Py_VISIT(state->startup_hook);
-    Py_VISIT(state->pre_input_hook);
-    Py_VISIT(state->completer);
-    Py_VISIT(state->begidx);
-    Py_VISIT(state->endidx);
-    return 0;
-}
-
-static void
-readline_free(void *m)
-{
-    readline_clear((PyObject *)m);
-}
-
-static PyModuleDef readlinemodule;
-
-#define readlinestate_global ((readlinestate *)PyModule_GetState(PyState_FindModule(&readlinemodule)))
-
-
 /* Exported function to send one line to readline's init file parser */
 
 static PyObject *
@@ -300,21 +250,23 @@
 
 /* Exported functions to specify hook functions in Python */
 
+static PyObject *completion_display_matches_hook = NULL;
+static PyObject *startup_hook = NULL;
 
 #ifdef HAVE_RL_PRE_INPUT_HOOK
-
+static PyObject *pre_input_hook = NULL;
 #endif
 
 static PyObject *
 set_completion_display_matches_hook(PyObject *self, PyObject *args)
 {
     PyObject *result = set_hook("completion_display_matches_hook",
-                    &readlinestate_global->completion_display_matches_hook, args);
+                    &completion_display_matches_hook, args);
 #ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK
     /* We cannot set this hook globally, since it replaces the
        default completion display. */
     rl_completion_display_matches_hook =
-        readlinestate_global->completion_display_matches_hook ?
+        completion_display_matches_hook ?
 #if defined(_RL_FUNCTION_TYPEDEF)
         (rl_compdisp_func_t *)on_completion_display_matches_hook : 0;
 #else
@@ -335,7 +287,7 @@
 static PyObject *
 set_startup_hook(PyObject *self, PyObject *args)
 {
-    return set_hook("startup_hook", &readlinestate_global->startup_hook, args);
+    return set_hook("startup_hook", &startup_hook, args);
 }
 
 PyDoc_STRVAR(doc_set_startup_hook,
@@ -352,7 +304,7 @@
 static PyObject *
 set_pre_input_hook(PyObject *self, PyObject *args)
 {
-    return set_hook("pre_input_hook", &readlinestate_global->pre_input_hook, args);
+    return set_hook("pre_input_hook", &pre_input_hook, args);
 }
 
 PyDoc_STRVAR(doc_set_pre_input_hook,
@@ -367,10 +319,10 @@
 
 /* Exported function to specify a word completer in Python */
 
+static PyObject *completer = NULL;
 
-
-
-
+static PyObject *begidx = NULL;
+static PyObject *endidx = NULL;
 
 
 /* Get the completion type for the scope of the tab-completion */
@@ -390,8 +342,8 @@
 static PyObject *
 get_begidx(PyObject *self, PyObject *noarg)
 {
-    Py_INCREF(readlinestate_global->begidx);
-    return readlinestate_global->begidx;
+    Py_INCREF(begidx);
+    return begidx;
 }
 
 PyDoc_STRVAR(doc_get_begidx,
@@ -404,8 +356,8 @@
 static PyObject *
 get_endidx(PyObject *self, PyObject *noarg)
 {
-    Py_INCREF(readlinestate_global->endidx);
-    return readlinestate_global->endidx;
+    Py_INCREF(endidx);
+    return endidx;
 }
 
 PyDoc_STRVAR(doc_get_endidx,
@@ -570,7 +522,7 @@
 static PyObject *
 set_completer(PyObject *self, PyObject *args)
 {
-    return set_hook("completer", &readlinestate_global->completer, args);
+    return set_hook("completer", &completer, args);
 }
 
 PyDoc_STRVAR(doc_set_completer,
@@ -584,11 +536,11 @@
 static PyObject *
 get_completer(PyObject *self, PyObject *noargs)
 {
-    if (readlinestate_global->completer == NULL) {
+    if (completer == NULL) {
         Py_RETURN_NONE;
     }
-    Py_INCREF(readlinestate_global->completer);
-    return readlinestate_global->completer;
+    Py_INCREF(completer);
+    return completer;
 }
 
 PyDoc_STRVAR(doc_get_completer,
@@ -792,6 +744,9 @@
     int result = 0;
     if (func != NULL) {
         PyObject *r;
+#ifdef WITH_THREAD
+        PyGILState_STATE gilstate = PyGILState_Ensure();
+#endif
         r = PyObject_CallFunction(func, NULL);
         if (r == NULL)
             goto error;
@@ -808,6 +763,9 @@
         PyErr_Clear();
         Py_XDECREF(r);
       done:
+#ifdef WITH_THREAD
+        PyGILState_Release(gilstate);
+#endif
         return result;
     }
     return result;
@@ -816,30 +774,14 @@
 static int
 on_startup_hook(void)
 {
-    int r;
-#ifdef WITH_THREAD
-    PyGILState_STATE gilstate = PyGILState_Ensure();
-#endif
-    r = on_hook(readlinestate_global->startup_hook);
-#ifdef WITH_THREAD
-    PyGILState_Release(gilstate);
-#endif
-    return r;
+    return on_hook(startup_hook);
 }
 
 #ifdef HAVE_RL_PRE_INPUT_HOOK
 static int
 on_pre_input_hook(void)
 {
-    int r;
-#ifdef WITH_THREAD
-    PyGILState_STATE gilstate = PyGILState_Ensure();
-#endif
-    r = on_hook(readlinestate_global->pre_input_hook);
-#ifdef WITH_THREAD
-    PyGILState_Release(gilstate);
-#endif
-    return r;
+    return on_hook(pre_input_hook);
 }
 #endif
 
@@ -866,7 +808,7 @@
         if (PyList_SetItem(m, i, s) == -1)
             goto error;
     }
-    r = PyObject_CallFunction(readlinestate_global->completion_display_matches_hook,
+    r = PyObject_CallFunction(completion_display_matches_hook,
                               "sOi", matches[0], m, max_length);
 
     Py_DECREF(m); m=NULL;
@@ -896,13 +838,13 @@
 on_completion(const char *text, int state)
 {
     char *result = NULL;
-    if (readlinestate_global->completer != NULL) {
+    if (completer != NULL) {
         PyObject *r;
 #ifdef WITH_THREAD
         PyGILState_STATE gilstate = PyGILState_Ensure();
 #endif
         rl_attempted_completion_over = 1;
-        r = PyObject_CallFunction(readlinestate_global->completer, "si", text, state);
+        r = PyObject_CallFunction(completer, "si", text, state);
         if (r == NULL)
             goto error;
         if (r == Py_None) {
@@ -935,32 +877,24 @@
 static char **
 flex_complete(char *text, int start, int end)
 {
-    char **result;
-#ifdef WITH_THREAD
-    PyGILState_STATE gilstate = PyGILState_Ensure();
-#endif
 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
     rl_completion_append_character ='\0';
 #endif
 #ifdef HAVE_RL_COMPLETION_SUPPRESS_APPEND
     rl_completion_suppress_append = 0;
 #endif
-    Py_XDECREF(readlinestate_global->begidx);
-    Py_XDECREF(readlinestate_global->endidx);
-    readlinestate_global->begidx = PyLong_FromLong((long) start);
-    readlinestate_global->endidx = PyLong_FromLong((long) end);
-    result = completion_matches(text, *on_completion);
-#ifdef WITH_THREAD
-    PyGILState_Release(gilstate);
-#endif
-    return result;
+    Py_XDECREF(begidx);
+    Py_XDECREF(endidx);
+    begidx = PyLong_FromLong((long) start);
+    endidx = PyLong_FromLong((long) end);
+    return completion_matches(text, *on_completion);
 }
 
 
 /* Helper to initialize GNU readline properly. */
 
 static void
-setup_readline(readlinestate *mod_state)
+setup_readline(void)
 {
 #ifdef SAVE_LOCALE
     char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
@@ -997,8 +931,8 @@
         strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");
         /* All nonalphanums except '.' */
 
-    mod_state->begidx = PyLong_FromLong(0L);
-    mod_state->endidx = PyLong_FromLong(0L);
+    begidx = PyLong_FromLong(0L);
+    endidx = PyLong_FromLong(0L);
     /* Initialize (allows .inputrc to override)
      *
      * XXX: A bug in the readline-2.2 library causes a memory leak
@@ -1220,12 +1154,12 @@
     PyModuleDef_HEAD_INIT,
     "readline",
     doc_module,
-    sizeof(readlinestate),
+    -1,
     readline_methods,
     NULL,
-    readline_traverse,
-    readline_clear,
-    readline_free
+    NULL,
+    NULL,
+    NULL
 };
 
 
@@ -1233,7 +1167,6 @@
 PyInit_readline(void)
 {
     PyObject *m;
-    readlinestate *mod_state;
 
 #ifdef __APPLE__
     if (strncmp(rl_library_version, libedit_version_tag, strlen(libedit_version_tag)) == 0) {
@@ -1250,8 +1183,7 @@
     if (m == NULL)
         return NULL;
 
-    mod_state = (readlinestate *) PyModule_GetState(m);
     PyOS_ReadlineFunctionPointer = call_readline;
-    setup_readline(mod_state);
+    setup_readline();
     return m;
 }
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/selectmodule.c
--- a/Modules/selectmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/selectmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -882,6 +882,17 @@
     return NULL;
 }
 
+static PyObject*
+devpoll_fileno(devpollObject *self)
+{
+    return PyLong_FromLong(self->fd_devpoll);
+}
+
+PyDoc_STRVAR(devpoll_fileno_doc,
+"fileno() -> int\n\
+\n\
+Return the file descriptor.");
+
 static PyMethodDef devpoll_methods[] = {
     {"register",        (PyCFunction)devpoll_register,
      METH_VARARGS,  devpoll_register_doc},
@@ -891,11 +902,13 @@
      METH_O,        devpoll_unregister_doc},
     {"poll",            (PyCFunction)devpoll_poll,
      METH_VARARGS,  devpoll_poll_doc},
+    {"fileno",          (PyCFunction)devpoll_fileno,    METH_NOARGS,
+     devpoll_fileno_doc},
     {NULL,              NULL}           /* sentinel */
 };
 
 static devpollObject *
-newDevPollObject(void)
+newDevPollObject()
 {
     devpollObject *self;
     int fd_devpoll, limit_result;
@@ -923,6 +936,11 @@
         return NULL;
     }
 
+    if (_Py_set_inheritable(fd_devpoll, 0, NULL) < 0) {
+        close(fd_devpoll);
+        return NULL;
+    }
+
     fds = PyMem_NEW(struct pollfd, limit.rlim_cur);
     if (fds == NULL) {
         close(fd_devpoll);
@@ -1103,6 +1121,7 @@
     if (fd == -1) {
         Py_BEGIN_ALLOW_THREADS
 #ifdef HAVE_EPOLL_CREATE1
+        flags |= EPOLL_CLOEXEC;
         if (flags)
             self->epfd = epoll_create1(flags);
         else
@@ -1118,6 +1137,14 @@
         PyErr_SetFromErrno(PyExc_OSError);
         return NULL;
     }
+
+#ifndef HAVE_EPOLL_CREATE1
+    if (_Py_set_inheritable(self->epfd, 0, NULL) < 0) {
+        Py_DECREF(self);
+        return NULL;
+    }
+#endif
+
     return (PyObject *)self;
 }
 
@@ -1805,13 +1832,19 @@
         PyErr_SetFromErrno(PyExc_OSError);
         return NULL;
     }
+
+    if (fd == -1) {
+        if (_Py_set_inheritable(self->kqfd, 0, NULL) < 0) {
+            Py_DECREF(self);
+            return NULL;
+        }
+    }
     return (PyObject *)self;
 }
 
 static PyObject *
 kqueue_queue_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-
     if ((args != NULL && PyObject_Size(args)) ||
                     (kwds != NULL && PyObject_Size(kwds))) {
         PyErr_SetString(PyExc_ValueError,
@@ -1822,6 +1855,7 @@
     return newKqueue_Object(type, -1);
 }
 
+
 static void
 kqueue_queue_dealloc(kqueue_queue_Object *self)
 {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/sha1module.c
--- a/Modules/sha1module.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/sha1module.c	Mon Aug 12 02:18:40 2013 +0200
@@ -411,7 +411,7 @@
 static PyObject *
 SHA1_get_name(PyObject *self, void *closure)
 {
-    return PyUnicode_FromStringAndSize("SHA1", 4);
+    return PyUnicode_FromStringAndSize("SHA1", 3);
 }
 
 static PyObject *
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/socketmodule.c
--- a/Modules/socketmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/socketmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -97,13 +97,14 @@
 
 /* Socket object documentation */
 PyDoc_STRVAR(sock_doc,
-"socket([family[, type[, proto]]]) -> socket object\n\
+"socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None, cloexec=None) -> socket object\n\
 \n\
 Open a socket of the given type.  The family argument specifies the\n\
 address family; it defaults to AF_INET.  The type argument specifies\n\
 whether this is a stream (SOCK_STREAM, this is the default)\n\
 or datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\n\
 specifying the default protocol.  Keyword arguments are accepted.\n\
+If cloexec is True, set close-on-exec flag.\n\
 \n\
 A socket object represents one endpoint of a network connection.\n\
 \n\
@@ -114,7 +115,7 @@
 close() -- close the socket\n\
 connect(addr) -- connect the socket to a remote address\n\
 connect_ex(addr) -- connect, return an error code instead of an exception\n\
-_dup() -- return a new socket fd duplicated from fileno()\n\
+dup(cloexec=None) -- return a new socket fd duplicated from fileno()\n\
 fileno() -- return underlying file descriptor\n\
 getpeername() -- return remote address [*]\n\
 getsockname() -- return local address\n\
@@ -1955,6 +1956,11 @@
     PyObject *addr = NULL;
     PyObject *res = NULL;
     int timeout;
+#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
+    /* accept4() is available on Linux 2.6.28+ and glibc 2.10 */
+    static int accept4_works = -1;
+#endif
+
     if (!getsockaddrlen(s, &addrlen))
         return NULL;
     memset(&addrbuf, 0, addrlen);
@@ -1963,10 +1969,22 @@
         return select_error();
 
     BEGIN_SELECT_LOOP(s)
+
     Py_BEGIN_ALLOW_THREADS
     timeout = internal_select_ex(s, 0, interval);
     if (!timeout) {
+#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
+        if (accept4_works != 0) {
+            newfd = accept4(s->sock_fd, SAS2SA(&addrbuf), &addrlen,
+                            SOCK_CLOEXEC);
+            if (newfd == INVALID_SOCKET && accept4_works == -1)
+                accept4_works = (errno != ENOSYS);
+        }
+        if (accept4_works == 0)
+            newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+#else
         newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+#endif
     }
     Py_END_ALLOW_THREADS
 
@@ -1979,6 +1997,27 @@
     if (newfd == INVALID_SOCKET)
         return s->errorhandler();
 
+#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
+    if (!accept4_works)
+#endif
+    {
+        int os_fd;
+#ifdef MS_WINDOWS
+        os_fd = _open_osfhandle((Py_intptr_t)newfd, O_RDWR);
+        if (os_fd == -1) {
+            PyErr_SetFromWindowsErr(0);
+            SOCKETCLOSE(newfd);
+            goto finally;
+        }
+#else
+        os_fd = newfd;
+#endif
+        if (_Py_set_inheritable(os_fd, 0, NULL) < 0) {
+            SOCKETCLOSE(newfd);
+            goto finally;
+        }
+    }
+
     sock = PyLong_FromSocket_t(newfd);
     if (sock == NULL) {
         SOCKETCLOSE(newfd);
@@ -3909,6 +3948,12 @@
 
 /* Initialize a new socket object. */
 
+#ifdef SOCK_CLOEXEC
+/* socket() and socketpair() fail with EINVAL on Linux kernel older
+ * than 2.6.27 if SOCK_CLOEXEC flag is set in the socket type. */
+static int sock_cloexec_works = -1;
+#endif
+
 /*ARGSUSED*/
 static int
 sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
@@ -3918,6 +3963,11 @@
     SOCKET_T fd = INVALID_SOCKET;
     int family = AF_INET, type = SOCK_STREAM, proto = 0;
     static char *keywords[] = {"family", "type", "proto", "fileno", 0};
+#ifdef SOCK_CLOEXEC
+    int *atomic_flag_works = &sock_cloexec_works;
+#else
+    int *atomic_flag_works = NULL;
+#endif
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds,
                                      "|iiiO:socket", keywords,
@@ -3962,15 +4012,48 @@
         }
     }
     else {
+        int os_fd;
+
         Py_BEGIN_ALLOW_THREADS
-        fd = socket(family, type, proto);
+#ifdef SOCK_CLOEXEC
+        if (sock_cloexec_works != 0) {
+            fd = socket(family, type | SOCK_CLOEXEC, proto);
+            if (sock_cloexec_works == -1) {
+                if (fd >= 0) {
+                    sock_cloexec_works = 1;
+                }
+                else if (errno == EINVAL) {
+                    /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
+                    sock_cloexec_works = 0;
+                    fd = socket(family, type, proto);
+                }
+            }
+        }
+        else
+#endif
+        {
+            fd = socket(family, type, proto);
+        }
         Py_END_ALLOW_THREADS
 
         if (fd == INVALID_SOCKET) {
             set_error();
             return -1;
         }
-    }
+
+#ifdef MS_WINDOWS
+        os_fd = _open_osfhandle((Py_intptr_t)fd, O_RDWR);
+        if (os_fd == -1) {
+            PyErr_SetFromWindowsErr(0);
+            return -1;
+        }
+#else
+        os_fd = fd;
+#endif
+        if (_Py_set_inheritable(os_fd, 0, atomic_flag_works) < 0)
+            return -1;
+    }
+
     init_sockobject(s, fd, family, type, proto);
 
     return 0;
@@ -4535,7 +4618,7 @@
 {
     SOCKET_T fd, newfd;
     PyObject *newfdobj;
-
+    int os_fd;
 
     fd = PyLong_AsSocket_t(fdobj);
     if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
@@ -4545,6 +4628,21 @@
     if (newfd == INVALID_SOCKET)
         return set_error();
 
+#ifdef MS_WINDOWS
+    os_fd = _open_osfhandle((Py_intptr_t)newfd, O_RDWR);
+    if (os_fd == -1) {
+        PyErr_SetFromWindowsErr(0);
+        SOCKETCLOSE(newfd);
+        return NULL;
+    }
+#else
+    os_fd = newfd;
+#endif
+    if (_Py_set_inheritable(os_fd, 0, NULL) < 0) {
+        SOCKETCLOSE(newfd);
+        return NULL;
+    }
+
     newfdobj = PyLong_FromSocket_t(newfd);
     if (newfdobj == NULL)
         SOCKETCLOSE(newfd);
@@ -4570,8 +4668,14 @@
 {
     PySocketSockObject *s0 = NULL, *s1 = NULL;
     SOCKET_T sv[2];
-    int family, type = SOCK_STREAM, proto = 0;
+    int family = AF_INET, type = SOCK_STREAM, proto = 0;
     PyObject *res = NULL;
+#ifdef SOCK_CLOEXEC
+    int *atomic_flag_works = &sock_cloexec_works;
+#else
+    int *atomic_flag_works = NULL;
+#endif
+    int ret;
 
 #if defined(AF_UNIX)
     family = AF_UNIX;
@@ -4581,9 +4685,38 @@
     if (!PyArg_ParseTuple(args, "|iii:socketpair",
                           &family, &type, &proto))
         return NULL;
+
     /* Create a pair of socket fds */
-    if (socketpair(family, type, proto, sv) < 0)
+    Py_BEGIN_ALLOW_THREADS
+#ifdef SOCK_CLOEXEC
+    if (sock_cloexec_works != 0) {
+        ret = socketpair(family, type | SOCK_CLOEXEC, proto, sv);
+        if (sock_cloexec_works == -1) {
+            if (ret >= 0) {
+                sock_cloexec_works = 1;
+            }
+            else if (errno == EINVAL) {
+                /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
+                sock_cloexec_works = 0;
+                ret = socketpair(family, type, proto, sv);
+            }
+        }
+    }
+    else
+#endif
+    {
+        ret = socketpair(family, type, proto, sv);
+    }
+    Py_END_ALLOW_THREADS
+
+    if (ret < 0)
         return set_error();
+
+    if (_Py_set_inheritable(sv[0], 0, atomic_flag_works) < 0)
+        goto finally;
+    if (_Py_set_inheritable(sv[1], 0, atomic_flag_works) < 0)
+        goto finally;
+
     s0 = new_sockobject(sv[0], family, type, proto);
     if (s0 == NULL)
         goto finally;
@@ -4605,7 +4738,7 @@
 }
 
 PyDoc_STRVAR(socketpair_doc,
-"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
+"socketpair(family=AF_INET, type=SOCK_STREAM, proto=0) -> (socket object, socket object)\n\
 \n\
 Create a pair of socket objects from the sockets returned by the platform\n\
 socketpair() function.\n\
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/sre.h
--- a/Modules/sre.h	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/sre.h	Mon Aug 12 02:18:40 2013 +0200
@@ -19,7 +19,7 @@
 #if SIZEOF_SIZE_T > 4
 # define SRE_MAXREPEAT (~(SRE_CODE)0)
 #else
-# define SRE_MAXREPEAT ((SRE_CODE)PY_SSIZE_T_MAX)
+# define SRE_MAXREPEAT ((SRE_CODE)PY_SSIZE_T_MAX + 1u)
 #endif
 
 typedef struct {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Modules/zipimport.c
--- a/Modules/zipimport.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Modules/zipimport.c	Mon Aug 12 02:18:40 2013 +0200
@@ -870,7 +870,7 @@
     const char *charset;
     int bootstrap;
 
-    fp = _Py_fopen(archive, "rb");
+    fp = _Py_fopen_obj(archive, "rb");
     if (fp == NULL) {
         if (!PyErr_Occurred())
             PyErr_Format(ZipImportError, "can't open Zip file: %R", archive);
@@ -1064,7 +1064,7 @@
         return NULL;
     }
 
-    fp = _Py_fopen(archive, "rb");
+    fp = _Py_fopen_obj(archive, "rb");
     if (!fp) {
         if (!PyErr_Occurred())
             PyErr_Format(PyExc_IOError,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/abstract.c
--- a/Objects/abstract.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/abstract.c	Mon Aug 12 02:18:40 2013 +0200
@@ -1261,6 +1261,25 @@
 }
 
 
+/* Add a check for embedded NULL-bytes in the argument. */
+static PyObject *
+long_from_string(const char *s, Py_ssize_t len)
+{
+    char *end;
+    PyObject *x;
+
+    x = PyLong_FromString((char*)s, &end, 10);
+    if (x == NULL)
+        return NULL;
+    if (end != s + len) {
+        PyErr_SetString(PyExc_ValueError,
+                        "null byte in argument for int()");
+        Py_DECREF(x);
+        return NULL;
+    }
+    return x;
+}
+
 PyObject *
 PyNumber_Long(PyObject *o)
 {
@@ -1308,16 +1327,16 @@
 
     if (PyBytes_Check(o))
         /* need to do extra error checking that PyLong_FromString()
-         * doesn't do.  In particular int('9\x005') must raise an
-         * exception, not truncate at the null.
+         * doesn't do.  In particular int('9.5') must raise an
+         * exception, not truncate the float.
          */
-        return _PyLong_FromBytes(PyBytes_AS_STRING(o),
-                                 PyBytes_GET_SIZE(o), 10);
+        return long_from_string(PyBytes_AS_STRING(o),
+                                PyBytes_GET_SIZE(o));
     if (PyUnicode_Check(o))
         /* The above check is done in PyLong_FromUnicode(). */
         return PyLong_FromUnicodeObject(o, 10);
     if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
-        return _PyLong_FromBytes(buffer, buffer_len, 10);
+        return long_from_string(buffer, buffer_len);
 
     return type_error("int() argument must be a string or a "
                       "number, not '%.200s'", o);
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/frameobject.c
--- a/Objects/frameobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/frameobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -488,7 +488,7 @@
 }
 
 static void
-frame_tp_clear(PyFrameObject *f)
+frame_clear(PyFrameObject *f)
 {
     PyObject **fastlocals, **p, **oldtop;
     Py_ssize_t i, slots;
@@ -500,7 +500,6 @@
      */
     oldtop = f->f_stacktop;
     f->f_stacktop = NULL;
-    f->f_executing = 0;
 
     Py_CLEAR(f->f_exc_type);
     Py_CLEAR(f->f_exc_value);
@@ -521,25 +520,6 @@
 }
 
 static PyObject *
-frame_clear(PyFrameObject *f)
-{
-    if (f->f_executing) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "cannot clear an executing frame");
-        return NULL;
-    }
-    if (f->f_gen) {
-        _PyGen_Finalize(f->f_gen);
-        assert(f->f_gen == NULL);
-    }
-    frame_tp_clear(f);
-    Py_RETURN_NONE;
-}
-
-PyDoc_STRVAR(clear__doc__,
-"F.clear(): clear most references held by the frame");
-
-static PyObject *
 frame_sizeof(PyFrameObject *f)
 {
     Py_ssize_t res, extras, ncells, nfrees;
@@ -558,8 +538,6 @@
 "F.__sizeof__() -> size of F in memory, in bytes");
 
 static PyMethodDef frame_methods[] = {
-    {"clear",           (PyCFunction)frame_clear,       METH_NOARGS,
-     clear__doc__},
     {"__sizeof__",      (PyCFunction)frame_sizeof,      METH_NOARGS,
      sizeof__doc__},
     {NULL,              NULL}   /* sentinel */
@@ -588,7 +566,7 @@
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     0,                                          /* tp_doc */
     (traverseproc)frame_traverse,               /* tp_traverse */
-    (inquiry)frame_tp_clear,                    /* tp_clear */
+    (inquiry)frame_clear,                       /* tp_clear */
     0,                                          /* tp_richcompare */
     0,                                          /* tp_weaklistoffset */
     0,                                          /* tp_iter */
@@ -730,8 +708,6 @@
     f->f_lasti = -1;
     f->f_lineno = code->co_firstlineno;
     f->f_iblock = 0;
-    f->f_executing = 0;
-    f->f_gen = NULL;
 
     _PyObject_GC_TRACK(f);
     return f;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/genobject.c
--- a/Objects/genobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/genobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -15,31 +15,6 @@
     return 0;
 }
 
-void
-_PyGen_Finalize(PyObject *self)
-{
-    PyGenObject *gen = (PyGenObject *)self;
-    PyObject *res;
-    PyObject *error_type, *error_value, *error_traceback;
-
-    if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)
-        /* Generator isn't paused, so no need to close */
-        return;
-
-    /* Save the current exception, if any. */
-    PyErr_Fetch(&error_type, &error_value, &error_traceback);
-
-    res = gen_close(gen, NULL);
-
-    if (res == NULL)
-        PyErr_WriteUnraisable(self);
-    else
-        Py_DECREF(res);
-
-    /* Restore the saved exception. */
-    PyErr_Restore(error_type, error_value, error_traceback);
-}
-
 static void
 gen_dealloc(PyGenObject *gen)
 {
@@ -52,8 +27,12 @@
 
     _PyObject_GC_TRACK(self);
 
-    if (PyObject_CallFinalizerFromDealloc(self))
-        return;                     /* resurrected.  :( */
+    if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {
+        /* Generator is paused, so we need to close */
+        Py_TYPE(gen)->tp_del(self);
+        if (self->ob_refcnt > 0)
+            return;                     /* resurrected.  :( */
+    }
 
     _PyObject_GC_UNTRACK(self);
     Py_CLEAR(gen->gi_frame);
@@ -61,6 +40,7 @@
     PyObject_GC_Del(gen);
 }
 
+
 static PyObject *
 gen_send_ex(PyGenObject *gen, PyObject *arg, int exc)
 {
@@ -140,7 +120,6 @@
         Py_XDECREF(t);
         Py_XDECREF(v);
         Py_XDECREF(tb);
-        gen->gi_frame->f_gen = NULL;
         gen->gi_frame = NULL;
         Py_DECREF(f);
     }
@@ -243,6 +222,68 @@
     return NULL;
 }
 
+static void
+gen_del(PyObject *self)
+{
+    PyObject *res;
+    PyObject *error_type, *error_value, *error_traceback;
+    PyGenObject *gen = (PyGenObject *)self;
+
+    if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)
+        /* Generator isn't paused, so no need to close */
+        return;
+
+    /* Temporarily resurrect the object. */
+    assert(self->ob_refcnt == 0);
+    self->ob_refcnt = 1;
+
+    /* Save the current exception, if any. */
+    PyErr_Fetch(&error_type, &error_value, &error_traceback);
+
+    res = gen_close(gen, NULL);
+
+    if (res == NULL)
+        PyErr_WriteUnraisable(self);
+    else
+        Py_DECREF(res);
+
+    /* Restore the saved exception. */
+    PyErr_Restore(error_type, error_value, error_traceback);
+
+    /* Undo the temporary resurrection; can't use DECREF here, it would
+     * cause a recursive call.
+     */
+    assert(self->ob_refcnt > 0);
+    if (--self->ob_refcnt == 0)
+        return; /* this is the normal path out */
+
+    /* close() resurrected it!  Make it look like the original Py_DECREF
+     * never happened.
+     */
+    {
+        Py_ssize_t refcnt = self->ob_refcnt;
+        _Py_NewReference(self);
+        self->ob_refcnt = refcnt;
+    }
+    assert(PyType_IS_GC(Py_TYPE(self)) &&
+           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
+
+    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
+     * we need to undo that. */
+    _Py_DEC_REFTOTAL;
+    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
+     * chain, so no more to do there.
+     * If COUNT_ALLOCS, the original decref bumped tp_frees, and
+     * _Py_NewReference bumped tp_allocs:  both of those need to be
+     * undone.
+     */
+#ifdef COUNT_ALLOCS
+    --(Py_TYPE(self)->tp_frees);
+    --(Py_TYPE(self)->tp_allocs);
+#endif
+}
+
+
 
 PyDoc_STRVAR(throw_doc,
 "throw(typ[,val[,tb]]) -> raise exception in generator,\n\
@@ -476,8 +517,7 @@
     PyObject_GenericGetAttr,                    /* tp_getattro */
     0,                                          /* tp_setattro */
     0,                                          /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-        Py_TPFLAGS_HAVE_FINALIZE,               /* tp_flags */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     0,                                          /* tp_doc */
     (traverseproc)gen_traverse,                 /* tp_traverse */
     0,                                          /* tp_clear */
@@ -504,9 +544,7 @@
     0,                                          /* tp_cache */
     0,                                          /* tp_subclasses */
     0,                                          /* tp_weaklist */
-    0,                                          /* tp_del */
-    0,                                          /* tp_version_tag */
-    _PyGen_Finalize,                            /* tp_finalize */
+    gen_del,                                    /* tp_del */
 };
 
 PyObject *
@@ -518,7 +556,6 @@
         return NULL;
     }
     gen->gi_frame = f;
-    f->f_gen = (PyObject *) gen;
     Py_INCREF(f->f_code);
     gen->gi_code = (PyObject *)(f->f_code);
     gen->gi_running = 0;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/longobject.c
--- a/Objects/longobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/longobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -549,7 +549,7 @@
         x = (x << PyLong_SHIFT) | v->ob_digit[i];
         if ((x >> PyLong_SHIFT) != prev) {
             PyErr_SetString(PyExc_OverflowError,
-                            "Python int too large to convert "
+                            "python int too large to convert "
                             "to C unsigned long");
             return (unsigned long) -1;
         }
@@ -1602,7 +1602,7 @@
     */
     if (size_a > PY_SSIZE_T_MAX / PyLong_SHIFT) {
         PyErr_SetString(PyExc_OverflowError,
-                        "int too large to format");
+                        "long is too large to format");
         return -1;
     }
     /* the expression size_a * PyLong_SHIFT is now safe from overflow */
@@ -1785,7 +1785,7 @@
         /* Ensure overflow doesn't occur during computation of sz. */
         if (size_a > (PY_SSIZE_T_MAX - 3) / PyLong_SHIFT) {
             PyErr_SetString(PyExc_OverflowError,
-                            "int too large to format");
+                            "int is too large to format");
             return -1;
         }
         size_a_in_bits = (size_a - 1) * PyLong_SHIFT +
@@ -2000,14 +2000,6 @@
     return long_normalize(z);
 }
 
-/* Parses a long from a bytestring. Leading and trailing whitespace will be
- * ignored.
- *
- * If successful, a PyLong object will be returned and 'pend' will be pointing
- * to the first unused byte unless it's NULL.
- *
- * If unsuccessful, NULL will be returned.
- */
 PyObject *
 PyLong_FromString(char *str, char **pend, int base)
 {
@@ -2270,54 +2262,24 @@
         str++;
     if (*str != '\0')
         goto onError;
+    if (pend)
+        *pend = str;
     long_normalize(z);
-    z = maybe_small_long(z);
-    if (z == NULL)
-        return NULL;
-    if (pend != NULL)
-        *pend = str;
-    return (PyObject *) z;
+    return (PyObject *) maybe_small_long(z);
 
   onError:
-    if (pend != NULL)
-        *pend = str;
     Py_XDECREF(z);
     slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
     strobj = PyUnicode_FromStringAndSize(orig_str, slen);
     if (strobj == NULL)
         return NULL;
     PyErr_Format(PyExc_ValueError,
-                 "invalid literal for int() with base %d: %.200R",
+                 "invalid literal for int() with base %d: %R",
                  base, strobj);
     Py_DECREF(strobj);
     return NULL;
 }
 
-/* Since PyLong_FromString doesn't have a length parameter,
- * check here for possible NULs in the string.
- *
- * Reports an invalid literal as a bytes object.
- */
-PyObject *
-_PyLong_FromBytes(const char *s, Py_ssize_t len, int base)
-{
-    PyObject *result, *strobj;
-    char *end = NULL;
-
-    result = PyLong_FromString((char*)s, &end, base);
-    if (end == NULL || (result != NULL && end == s + len))
-        return result;
-    Py_XDECREF(result);
-    strobj = PyBytes_FromStringAndSize(s, Py_MIN(len, 200));
-    if (strobj != NULL) {
-        PyErr_Format(PyExc_ValueError,
-                     "invalid literal for int() with base %d: %.200R",
-                     base, strobj);
-        Py_DECREF(strobj);
-    }
-    return NULL;
-}
-
 PyObject *
 PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
 {
@@ -2332,8 +2294,9 @@
 PyObject *
 PyLong_FromUnicodeObject(PyObject *u, int base)
 {
-    PyObject *result, *asciidig;
-    char *buffer, *end = NULL;
+    PyObject *result;
+    PyObject *asciidig;
+    char *buffer, *end;
     Py_ssize_t buflen;
 
     asciidig = _PyUnicode_TransformDecimalAndSpaceToASCII(u);
@@ -2342,22 +2305,17 @@
     buffer = PyUnicode_AsUTF8AndSize(asciidig, &buflen);
     if (buffer == NULL) {
         Py_DECREF(asciidig);
-        if (!PyErr_ExceptionMatches(PyExc_UnicodeEncodeError))
-            return NULL;
-    }
-    else {
-        result = PyLong_FromString(buffer, &end, base);
-        if (end == NULL || (result != NULL && end == buffer + buflen)) {
-            Py_DECREF(asciidig);
-            return result;
-        }
-        Py_DECREF(asciidig);
-        Py_XDECREF(result);
-    }
-    PyErr_Format(PyExc_ValueError,
-                 "invalid literal for int() with base %d: %.200R",
-                 base, u);
-    return NULL;
+        return NULL;
+    }
+    result = PyLong_FromString(buffer, &end, base);
+    if (result != NULL && end != buffer + buflen) {
+        PyErr_SetString(PyExc_ValueError,
+                        "null byte in argument for int()");
+        Py_DECREF(result);
+        result = NULL;
+    }
+    Py_DECREF(asciidig);
+    return result;
 }
 
 /* forward */
@@ -2700,7 +2658,7 @@
     x = _PyLong_Frexp((PyLongObject *)v, &exponent);
     if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) {
         PyErr_SetString(PyExc_OverflowError,
-                        "int too large to convert to float");
+                        "long int too large to convert to float");
         return -1.0;
     }
     return ldexp(x, (int)exponent);
@@ -4361,12 +4319,23 @@
     if (PyUnicode_Check(x))
         return PyLong_FromUnicodeObject(x, (int)base);
     else if (PyByteArray_Check(x) || PyBytes_Check(x)) {
+        /* Since PyLong_FromString doesn't have a length parameter,
+         * check here for possible NULs in the string. */
         char *string;
+        Py_ssize_t size = Py_SIZE(x);
         if (PyByteArray_Check(x))
             string = PyByteArray_AS_STRING(x);
         else
             string = PyBytes_AS_STRING(x);
-        return _PyLong_FromBytes(string, Py_SIZE(x), (int)base);
+        if (strlen(string) != (size_t)size || !size) {
+            /* We only see this if there's a null byte in x or x is empty,
+               x is a bytes or buffer, *and* a base is given. */
+            PyErr_Format(PyExc_ValueError,
+                         "invalid literal for int() with base %d: %R",
+                         (int)base, x);
+            return NULL;
+        }
+        return PyLong_FromString(string, NULL, (int)base);
     }
     else {
         PyErr_SetString(PyExc_TypeError,
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/moduleobject.c
--- a/Objects/moduleobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/moduleobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -11,8 +11,6 @@
     PyObject *md_dict;
     struct PyModuleDef *md_def;
     void *md_state;
-    PyObject *md_weaklist;
-    PyObject *md_name;  /* for logging purposes after md_dict is cleared */
 } PyModuleObject;
 
 static PyMemberDef module_members[] = {
@@ -29,8 +27,7 @@
 
 
 static int
-module_init_dict(PyModuleObject *mod, PyObject *md_dict,
-                 PyObject *name, PyObject *doc)
+module_init_dict(PyObject *md_dict, PyObject *name, PyObject *doc)
 {
     if (md_dict == NULL)
         return -1;
@@ -45,11 +42,6 @@
         return -1;
     if (PyDict_SetItemString(md_dict, "__loader__", Py_None) != 0)
         return -1;
-    if (PyUnicode_CheckExact(name)) {
-        Py_INCREF(name);
-        Py_XDECREF(mod->md_name);
-        mod->md_name = name;
-    }
 
     return 0;
 }
@@ -64,10 +56,8 @@
         return NULL;
     m->md_def = NULL;
     m->md_state = NULL;
-    m->md_weaklist = NULL;
-    m->md_name = NULL;
     m->md_dict = PyDict_New();
-    if (module_init_dict(m, m->md_dict, name, NULL) != 0)
+    if (module_init_dict(m->md_dict, name, NULL) != 0)
         goto fail;
     PyObject_GC_Track(m);
     return (PyObject *)m;
@@ -372,7 +362,7 @@
             return -1;
         m->md_dict = dict;
     }
-    if (module_init_dict(m, dict, name, doc) < 0)
+    if (module_init_dict(dict, name, doc) < 0)
         return -1;
     return 0;
 }
@@ -381,15 +371,12 @@
 module_dealloc(PyModuleObject *m)
 {
     PyObject_GC_UnTrack(m);
-    if (Py_VerboseFlag && m->md_name) {
-        PySys_FormatStderr("# destroy %S\n", m->md_name);
-    }
-    if (m->md_weaklist != NULL)
-        PyObject_ClearWeakRefs((PyObject *) m);
     if (m->md_def && m->md_def->m_free)
         m->md_def->m_free(m);
-    Py_XDECREF(m->md_dict);
-    Py_XDECREF(m->md_name);
+    if (m->md_dict != NULL) {
+        _PyModule_Clear((PyObject *)m);
+        Py_DECREF(m->md_dict);
+    }
     if (m->md_state != NULL)
         PyMem_FREE(m->md_state);
     Py_TYPE(m)->tp_free((PyObject *)m);
@@ -535,7 +522,7 @@
     (traverseproc)module_traverse,              /* tp_traverse */
     (inquiry)module_clear,                      /* tp_clear */
     0,                                          /* tp_richcompare */
-    offsetof(PyModuleObject, md_weaklist),      /* tp_weaklistoffset */
+    0,                                          /* tp_weaklistoffset */
     0,                                          /* tp_iter */
     0,                                          /* tp_iternext */
     module_methods,                             /* tp_methods */
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/object.c
--- a/Objects/object.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/object.c	Mon Aug 12 02:18:40 2013 +0200
@@ -255,72 +255,6 @@
     return PyObject_INIT_VAR(op, tp, nitems);
 }
 
-void
-PyObject_CallFinalizer(PyObject *self)
-{
-    PyTypeObject *tp = Py_TYPE(self);
-
-    /* The former could happen on heaptypes created from the C API, e.g.
-       PyType_FromSpec(). */
-    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_FINALIZE) ||
-        tp->tp_finalize == NULL)
-        return;
-    /* tp_finalize should only be called once. */
-    if (PyType_IS_GC(tp) && _PyGC_FINALIZED(self))
-        return;
-
-    tp->tp_finalize(self);
-    if (PyType_IS_GC(tp))
-        _PyGC_SET_FINALIZED(self, 1);
-}
-
-int
-PyObject_CallFinalizerFromDealloc(PyObject *self)
-{
-    Py_ssize_t refcnt;
-
-    /* Temporarily resurrect the object. */
-    if (self->ob_refcnt != 0) {
-        Py_FatalError("PyObject_CallFinalizerFromDealloc called on "
-                      "object with a non-zero refcount");
-    }
-    self->ob_refcnt = 1;
-
-    PyObject_CallFinalizer(self);
-
-    /* Undo the temporary resurrection; can't use DECREF here, it would
-     * cause a recursive call.
-     */
-    assert(self->ob_refcnt > 0);
-    if (--self->ob_refcnt == 0)
-        return 0;         /* this is the normal path out */
-
-    /* tp_finalize resurrected it!  Make it look like the original Py_DECREF
-     * never happened.
-     */
-    refcnt = self->ob_refcnt;
-    _Py_NewReference(self);
-    self->ob_refcnt = refcnt;
-
-    if (PyType_IS_GC(Py_TYPE(self))) {
-        assert(_PyGC_REFS(self) != _PyGC_REFS_UNTRACKED);
-    }
-    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
-     * we need to undo that. */
-    _Py_DEC_REFTOTAL;
-    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
-     * chain, so no more to do there.
-     * If COUNT_ALLOCS, the original decref bumped tp_frees, and
-     * _Py_NewReference bumped tp_allocs:  both of those need to be
-     * undone.
-     */
-#ifdef COUNT_ALLOCS
-    --Py_TYPE(self)->tp_frees;
-    --Py_TYPE(self)->tp_allocs;
-#endif
-    return -1;
-}
-
 int
 PyObject_Print(PyObject *op, FILE *fp, int flags)
 {
@@ -2047,7 +1981,7 @@
 _PyTrash_deposit_object(PyObject *op)
 {
     assert(PyObject_IS_GC(op));
-    assert(_PyGC_REFS(op) == _PyGC_REFS_UNTRACKED);
+    assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED);
     assert(op->ob_refcnt == 0);
     _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later;
     _PyTrash_delete_later = op;
@@ -2059,7 +1993,7 @@
 {
     PyThreadState *tstate = PyThreadState_GET();
     assert(PyObject_IS_GC(op));
-    assert(_PyGC_REFS(op) == _PyGC_REFS_UNTRACKED);
+    assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED);
     assert(op->ob_refcnt == 0);
     _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *) tstate->trash_delete_later;
     tstate->trash_delete_later = op;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/setobject.c
--- a/Objects/setobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/setobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -118,7 +118,7 @@
     /* In the loop, key == dummy is by far (factor of 100s) the
        least likely outcome, so test for that last. */
     for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
-        i = i * 5 + perturb + 1;
+        i = (i << 2) + i + perturb + 1;
         entry = &table[i & mask];
         if (entry->key == NULL) {
             if (freeslot != NULL)
@@ -189,7 +189,7 @@
     /* In the loop, key == dummy is by far (factor of 100s) the
        least likely outcome, so test for that last. */
     for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
-        i = i * 5 + perturb + 1;
+        i = (i << 2) + i + perturb + 1;
         entry = &table[i & mask];
         if (entry->key == NULL)
             return freeslot == NULL ? entry : freeslot;
@@ -258,7 +258,7 @@
     i = (size_t)hash & mask;
     entry = &table[i];
     for (perturb = hash; entry->key != NULL; perturb >>= PERTURB_SHIFT) {
-        i = i * 5 + perturb + 1;
+        i = (i << 2) + i + perturb + 1;
         entry = &table[i & mask];
     }
     so->fill++;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/typeobject.c
--- a/Objects/typeobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/typeobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -921,7 +921,6 @@
     PyTypeObject *type, *base;
     destructor basedealloc;
     PyThreadState *tstate = PyThreadState_GET();
-    int has_finalizer;
 
     /* Extract the type; we expect it to be a heap type */
     type = Py_TYPE(self);
@@ -937,10 +936,6 @@
            clear_slots(), or DECREF the dict, or clear weakrefs. */
 
         /* Maybe call finalizer; exit early if resurrected */
-        if (type->tp_finalize) {
-            if (PyObject_CallFinalizerFromDealloc(self) < 0)
-                return;
-        }
         if (type->tp_del) {
             type->tp_del(self);
             if (self->ob_refcnt > 0)
@@ -992,36 +987,25 @@
         assert(base);
     }
 
-    has_finalizer = type->tp_finalize || type->tp_del;
-
-    /* Maybe call finalizer; exit early if resurrected */
-    if (has_finalizer)
-        _PyObject_GC_TRACK(self);
-
-    if (type->tp_finalize) {
-        if (PyObject_CallFinalizerFromDealloc(self) < 0) {
-            /* Resurrected */
-            goto endlabel;
-        }
-    }
     /* If we added a weaklist, we clear it.      Do this *before* calling
-       tp_del, clearing slots, or clearing the instance dict. */
+       the finalizer (__del__), clearing slots, or clearing the instance
+       dict. */
+
     if (type->tp_weaklistoffset && !base->tp_weaklistoffset)
         PyObject_ClearWeakRefs(self);
 
+    /* Maybe call finalizer; exit early if resurrected */
     if (type->tp_del) {
+        _PyObject_GC_TRACK(self);
         type->tp_del(self);
-        if (self->ob_refcnt > 0) {
-            /* Resurrected */
-            goto endlabel;
-        }
-    }
-    if (has_finalizer) {
-        _PyObject_GC_UNTRACK(self);
+        if (self->ob_refcnt > 0)
+            goto endlabel;              /* resurrected */
+        else
+            _PyObject_GC_UNTRACK(self);
         /* New weakrefs could be created during the finalizer call.
-           If this occurs, clear them out without calling their
-           finalizers since they might rely on part of the object
-           being finalized that has already been destroyed. */
+            If this occurs, clear them out without calling their
+            finalizers since they might rely on part of the object
+            being finalized that has already been destroyed. */
         if (type->tp_weaklistoffset && !base->tp_weaklistoffset) {
             /* Modeled after GET_WEAKREFS_LISTPTR() */
             PyWeakReference **list = (PyWeakReference **) \
@@ -2247,7 +2231,7 @@
 
     /* Initialize tp_flags */
     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE |
-        Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_FINALIZE;
+        Py_TPFLAGS_BASETYPE;
     if (base->tp_flags & Py_TPFLAGS_HAVE_GC)
         type->tp_flags |= Py_TPFLAGS_HAVE_GC;
 
@@ -4127,10 +4111,6 @@
         COPYSLOT(tp_init);
         COPYSLOT(tp_alloc);
         COPYSLOT(tp_is_gc);
-        if ((type->tp_flags & Py_TPFLAGS_HAVE_FINALIZE) &&
-            (base->tp_flags & Py_TPFLAGS_HAVE_FINALIZE)) {
-            COPYSLOT(tp_finalize);
-        }
         if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) ==
             (base->tp_flags & Py_TPFLAGS_HAVE_GC)) {
             /* They agree about gc. */
@@ -4757,18 +4737,6 @@
 }
 
 static PyObject *
-wrap_del(PyObject *self, PyObject *args, void *wrapped)
-{
-    destructor func = (destructor)wrapped;
-
-    if (!check_num_args(args, 0))
-        return NULL;
-
-    (*func)(self);
-    Py_RETURN_NONE;
-}
-
-static PyObject *
 wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op)
 {
     richcmpfunc func = (richcmpfunc)wrapped;
@@ -5649,12 +5617,16 @@
 }
 
 static void
-slot_tp_finalize(PyObject *self)
+slot_tp_del(PyObject *self)
 {
     _Py_IDENTIFIER(__del__);
     PyObject *del, *res;
     PyObject *error_type, *error_value, *error_traceback;
 
+    /* Temporarily resurrect the object. */
+    assert(self->ob_refcnt == 0);
+    self->ob_refcnt = 1;
+
     /* Save the current exception, if any. */
     PyErr_Fetch(&error_type, &error_value, &error_traceback);
 
@@ -5671,6 +5643,37 @@
 
     /* Restore the saved exception. */
     PyErr_Restore(error_type, error_value, error_traceback);
+
+    /* Undo the temporary resurrection; can't use DECREF here, it would
+     * cause a recursive call.
+     */
+    assert(self->ob_refcnt > 0);
+    if (--self->ob_refcnt == 0)
+        return;         /* this is the normal path out */
+
+    /* __del__ resurrected it!  Make it look like the original Py_DECREF
+     * never happened.
+     */
+    {
+        Py_ssize_t refcnt = self->ob_refcnt;
+        _Py_NewReference(self);
+        self->ob_refcnt = refcnt;
+    }
+    assert(!PyType_IS_GC(Py_TYPE(self)) ||
+           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
+    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
+     * we need to undo that. */
+    _Py_DEC_REFTOTAL;
+    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
+     * chain, so no more to do there.
+     * If COUNT_ALLOCS, the original decref bumped tp_frees, and
+     * _Py_NewReference bumped tp_allocs:  both of those need to be
+     * undone.
+     */
+#ifdef COUNT_ALLOCS
+    --Py_TYPE(self)->tp_frees;
+    --Py_TYPE(self)->tp_allocs;
+#endif
 }
 
 
@@ -5779,7 +5782,7 @@
            "see help(type(x)) for signature",
            PyWrapperFlag_KEYWORDS),
     TPSLOT("__new__", tp_new, slot_tp_new, NULL, ""),
-    TPSLOT("__del__", tp_finalize, slot_tp_finalize, (wrapperfunc)wrap_del, ""),
+    TPSLOT("__del__", tp_del, slot_tp_del, NULL, ""),
 
     BINSLOT("__add__", nb_add, slot_nb_add,
         "+"),
diff -r 9e61563edb67 -r 1f8979a8c2c5 Objects/unicodeobject.c
--- a/Objects/unicodeobject.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Objects/unicodeobject.c	Mon Aug 12 02:18:40 2013 +0200
@@ -3235,7 +3235,7 @@
     wchar_t *wstr;
     PyObject *bytes = NULL;
     char *errmsg;
-    PyObject *reason = NULL;
+    PyObject *reason;
     PyObject *exc;
     size_t error_pos;
     int surrogateescape;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Parser/myreadline.c
--- a/Parser/myreadline.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Parser/myreadline.c	Mon Aug 12 02:18:40 2013 +0200
@@ -112,7 +112,7 @@
 PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 {
     size_t n;
-    char *p, *pr;
+    char *p;
     n = 100;
     if ((p = (char *)PyMem_MALLOC(n)) == NULL)
         return NULL;
@@ -135,29 +135,17 @@
     n = strlen(p);
     while (n > 0 && p[n-1] != '\n') {
         size_t incr = n+2;
+        p = (char *)PyMem_REALLOC(p, n + incr);
+        if (p == NULL)
+            return NULL;
         if (incr > INT_MAX) {
-            PyMem_FREE(p);
             PyErr_SetString(PyExc_OverflowError, "input line too long");
-            return NULL;
         }
-        pr = (char *)PyMem_REALLOC(p, n + incr);
-        if (pr == NULL) {
-            PyMem_FREE(p);
-            PyErr_NoMemory();
-            return NULL;
-        }
-        p = pr;
         if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
             break;
         n += strlen(p+n);
     }
-    pr = (char *)PyMem_REALLOC(p, n+1);
-    if (pr == NULL) {
-        PyMem_FREE(p);
-        PyErr_NoMemory();
-        return NULL;
-    }
-    return pr;
+    return (char *)PyMem_REALLOC(p, n+1);
 }
 
 
diff -r 9e61563edb67 -r 1f8979a8c2c5 Parser/pgen.c
--- a/Parser/pgen.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Parser/pgen.c	Mon Aug 12 02:18:40 2013 +0200
@@ -283,7 +283,6 @@
 
     REQ(n, ATOM);
     i = n->n_nchildren;
-    (void)i; /* Don't warn about set but unused */
     REQN(i, 1);
     n = n->n_child;
     if (n->n_type == LPAR) {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Parser/tokenizer.c
--- a/Parser/tokenizer.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Parser/tokenizer.c	Mon Aug 12 02:18:40 2013 +0200
@@ -1734,6 +1734,10 @@
     if (fd < 0) {
         return NULL;
     }
+#ifndef PGEN
+    _Py_try_set_inheritable(fd, 0);
+#endif
+
     fp = fdopen(fd, "r");
     if (fp == NULL) {
         return NULL;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/ceval.c
--- a/Python/ceval.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/ceval.c	Mon Aug 12 02:18:40 2013 +0200
@@ -1182,7 +1182,6 @@
     stack_pointer = f->f_stacktop;
     assert(stack_pointer != NULL);
     f->f_stacktop = NULL;       /* remains NULL unless yield suspends frame */
-    f->f_executing = 1;
 
     if (co->co_flags & CO_GENERATOR && !throwflag) {
         if (f->f_exc_type != NULL && f->f_exc_type != Py_None) {
@@ -3207,7 +3206,6 @@
     /* pop frame */
 exit_eval_frame:
     Py_LeaveRecursiveCall();
-    f->f_executing = 0;
     tstate->frame = f->f_back;
 
     return retval;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/errors.c
--- a/Python/errors.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/errors.c	Mon Aug 12 02:18:40 2013 +0200
@@ -2,6 +2,7 @@
 /* Error handling */
 
 #include "Python.h"
+#include <fcntl.h>
 
 #ifndef __STDC__
 #ifndef MS_WINDOWS
@@ -977,7 +978,7 @@
 
     if (filename == NULL || *filename == '\0' || lineno <= 0)
         return NULL;
-    fp = fopen(filename, "r" PY_STDIOTEXTMODE);
+    fp = _Py_fopen(filename, "r" PY_STDIOTEXTMODE);
     if (fp == NULL)
         return NULL;
     for (i = 0; i < lineno; i++) {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/fileutils.c
--- a/Python/fileutils.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/fileutils.c	Mon Aug 12 02:18:40 2013 +0200
@@ -9,10 +9,29 @@
 #include <langinfo.h>
 #endif
 
+#if defined(HAVE_SYS_IOCTL_H)
+#  include <sys/ioctl.h>
+#endif
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif /* HAVE_FCNTL_H */
+
 #ifdef __APPLE__
 extern wchar_t* _Py_DecodeUTF8_surrogateescape(const char *s, Py_ssize_t size);
 #endif
 
+#ifdef O_CLOEXEC
+/* Does open() supports the O_CLOEXEC flag? Possible values:
+
+   -1: unknown
+    0: open() ignores O_CLOEXEC flag, ex: Linux kernel older than 2.6.23
+    1: open() supports O_CLOEXEC flag, close-on-exec is set
+
+   The flag is used by open_cloexec(), io.FileIO and os.open() */
+int _Py_open_cloexec_works = -1;
+#endif
+
 PyObject *
 _Py_device_encoding(int fd)
 {
@@ -547,14 +566,211 @@
 
 #endif
 
+/* Get the inheritable flag of the specified file descriptor.
+   Return 1 if it the file descriptor is inheritable, 0 if it is not,
+   raise an exception and return -1 on error. */
+int
+_Py_get_inheritable(int fd)
+{
+#ifdef MS_WINDOWS
+    HANDLE handle;
+    BOOL success;
+    DWORD flags;
+
+    if (!_PyVerify_fd(fd)) {
+        PyErr_SetFromWindowsErr(ERROR_INVALID_HANDLE);
+        return -1;
+    }
+
+    handle = (HANDLE)_get_osfhandle(fd);
+    if (handle == INVALID_HANDLE_VALUE) {
+        PyErr_SetFromWindowsErr(0);
+        return -1;
+    }
+
+    success = GetHandleInformation(handle, &flags);
+    if (!success) {
+        PyErr_SetFromWindowsErr(0);
+        return -1;
+    }
+
+    return (flags & HANDLE_FLAG_INHERIT);
+#else
+    int flags;
+
+    flags = fcntl(fd, F_GETFD, 0);
+    if (flags == -1) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    return !(flags & FD_CLOEXEC);
+#endif
+}
+
+static int
+set_inheritable(int fd, int inheritable, int raise)
+{
+#ifdef MS_WINDOWS
+    HANDLE handle;
+    DWORD flags;
+    BOOL success;
+#elif defined(HAVE_SYS_IOCTL_H) && defined(FIOCLEX) && defined(FIONCLEX)
+    int request;
+    int err;
+#elif defined(HAVE_FCNTL_H)
+    int flags;
+    int res;
+#endif
+
+#ifdef MS_WINDOWS
+    if (!_PyVerify_fd(fd)) {
+        if (raise)
+            PyErr_SetFromWindowsErr(ERROR_INVALID_HANDLE);
+        return -1;
+    }
+
+    handle = (HANDLE)_get_osfhandle(fd);
+    if (handle == INVALID_HANDLE_VALUE) {
+        if (raise)
+            PyErr_SetFromWindowsErr(0);
+        return -1;
+    }
+
+    if (inheritable)
+        flags = HANDLE_FLAG_INHERIT;
+    else
+        flags = 0;
+    success = SetHandleInformation(handle, HANDLE_FLAG_INHERIT, flags);
+    if (!success) {
+        if (raise)
+            PyErr_SetFromWindowsErr(0);
+        return -1;
+    }
+    return 0;
+#elif defined(HAVE_SYS_IOCTL_H) && defined(FIOCLEX) && defined(FIONCLEX)
+    if (inheritable)
+        request = FIONCLEX;
+    else
+        request = FIOCLEX;
+    err = ioctl(fd, request);
+    if (err) {
+        if (raise)
+            PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    return 0;
+#elif defined(HAVE_FCNTL_H)
+    flags = fcntl(fd, F_GETFD);
+    if (flags < 0) {
+        if (raise)
+            PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+
+    if (inheritable)
+        flags &= ~FD_CLOEXEC;
+    else
+        flags |= FD_CLOEXEC;
+    res = fcntl(fd, F_SETFD, flags);
+    if (res < 0) {
+        if (raise)
+            PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    return 0;
+#else
+    if (raise)
+        PyErr_SetString(PyExc_NotImplementedError,
+            "close-on-exec flag is not supported on your platform");
+    return -1;
+#endif
+}
+
+/* Set or clear inheritable flag of the specified file descriptor.
+   On success: return 0, on error: raise an exception if raise is nonzero
+   and return -1. */
+int
+_Py_set_inheritable(int fd, int inheritable, int *atomic_flag_works)
+{
+    if (atomic_flag_works != NULL) {
+        if (*atomic_flag_works == -1) {
+            int inheritable = _Py_get_inheritable(fd);
+            if (inheritable == -1)
+                return -1;
+            *atomic_flag_works = !inheritable;
+        }
+
+        if (*atomic_flag_works)
+            return 0;
+    }
+
+    return set_inheritable(fd, inheritable, 1);
+}
+
+/* Try to set or clear the inheritable flag of the specified file descriptor.
+   If setting the close-on-exec flag failed, ignore the error. */
+void
+_Py_try_set_inheritable(int fd, int inheritable)
+{
+    (void)set_inheritable(fd, inheritable, 0);
+}
+
+static int
+open_cloexec(const char *pathname, int flags, int cloexec)
+{
+    int fd;
+
+    if (!cloexec)
+        return open(pathname, flags);
+
+#ifdef MS_WINDOWS
+    flags |= O_NOINHERIT;
+#elif defined(O_CLOEXEC)
+    flags |= O_CLOEXEC;
+#endif
+    fd = open(pathname, flags);
+    if (fd < 0)
+        return fd;
+
+#if defined(O_CLOEXEC) && !defined(MS_WINDOWS)
+    if (_Py_open_cloexec_works == -1) {
+        int flags = fcntl(fd, F_GETFD, 0);
+        if (flags != -1)
+            _Py_open_cloexec_works = (flags & FD_CLOEXEC);
+        else
+            _Py_open_cloexec_works = 0;
+    }
+
+    if (!_Py_open_cloexec_works) {
+        /* Linux kernel older than 2.6.23 ignores O_CLOEXEC flag */
+        (void)set_inheritable(fd, 0, 0);
+    }
+#elif !defined(MS_WINDOWS)
+    (void)set_inheritable(fd, 0, 0);
+#endif
+    return fd;
+}
+
+/* Open a file with the specified flags (wrapper to open() function).
+
+   Try to set the file descriptor non-inheritable. If clearing the inheritable
+   flag failed, ignore the error. */
+int
+_Py_open(const char *pathname, int flags)
+{
+    return open_cloexec(pathname, flags, 1);
+}
+
 /* Open a file. Use _wfopen() on Windows, encode the path to the locale
-   encoding and use fopen() otherwise. */
+   encoding and use fopen() otherwise.
 
+   Try to clear the inheritable flag on the newly created file descriptor.  If
+   clearing the inheritable flag failed, ignore the error. */
 FILE *
 _Py_wfopen(const wchar_t *path, const wchar_t *mode)
 {
+    FILE *f;
 #ifndef MS_WINDOWS
-    FILE *f;
     char *cpath;
     char cmode[10];
     size_t r;
@@ -570,19 +786,38 @@
     PyMem_Free(cpath);
     return f;
 #else
-    return _wfopen(path, mode);
+    f = _wfopen(path, mode);
 #endif
+    if (f == NULL)
+        return NULL;
+    (void)set_inheritable(fileno(f), 0, 0);
+    return f;
 }
 
-/* Call _wfopen() on Windows, or encode the path to the filesystem encoding and
-   call fopen() otherwise.
+/* Wrapper to fopen().
+   Try to make the file non-inheritable, ignore the error if it failed. */
+FILE*
+_Py_fopen(const char *pathname, const char *mode)
+{
+    FILE *f = fopen(pathname, mode);
+    if (f == NULL)
+        return NULL;
+    (void)set_inheritable(fileno(f), 0, 0);
+    return f;
+}
+
+/* Open a file. Call _wfopen() on Windows, or encode the path to the filesystem
+   encoding and call fopen() otherwise.
+
+   Try to clear the inheritable flag on the newly created file descriptor.  If
+   clearing the inheritable flag failed, ignore the error.
 
    Return the new file object on success, or NULL if the file cannot be open or
-   (if PyErr_Occurred()) on unicode error */
-
+   (if PyErr_Occurred()) on unicode error.  */
 FILE*
-_Py_fopen(PyObject *path, const char *mode)
+_Py_fopen_obj(PyObject *path, const char *mode)
 {
+    FILE *f;
 #ifdef MS_WINDOWS
     wchar_t *wpath;
     wchar_t wmode[10];
@@ -602,16 +837,18 @@
     if (usize == 0)
         return NULL;
 
-    return _wfopen(wpath, wmode);
+    f = _wfopen(wpath, wmode);
 #else
-    FILE *f;
     PyObject *bytes;
     if (!PyUnicode_FSConverter(path, &bytes))
         return NULL;
     f = fopen(PyBytes_AS_STRING(bytes), mode);
     Py_DECREF(bytes);
+#endif
+    if (f == NULL)
+        return NULL;
+    (void)set_inheritable(fileno(f), 0, 0);
     return f;
-#endif
 }
 
 #ifdef HAVE_READLINK
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/import.c
--- a/Python/import.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/import.c	Mon Aug 12 02:18:40 2013 +0200
@@ -277,7 +277,6 @@
     "path", "argv", "ps1", "ps2",
     "last_type", "last_value", "last_traceback",
     "path_hooks", "path_importer_cache", "meta_path",
-    "__interactivehook__",
     /* misc stuff */
     "flags", "float_info",
     NULL
@@ -290,17 +289,40 @@
     NULL
 };
 
+static int
+is_essential_module(PyObject *name)
+{
+    Py_ssize_t name_len;
+    char *name_str = PyUnicode_AsUTF8AndSize(name, &name_len);
+
+    if (name_str == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+    if (strcmp(name_str, "builtins") == 0)
+        return 1;
+    if (strcmp(name_str, "sys") == 0)
+        return 1;
+    /* These are all needed for stderr to still function */
+    if (strcmp(name_str, "codecs") == 0)
+        return 1;
+    if (strcmp(name_str, "_codecs") == 0)
+        return 1;
+    if (strncmp(name_str, "encodings.", 10) == 0)
+        return 1;
+    return 0;
+}
+
+
 /* Un-initialize things, as good as we can */
 
 void
 PyImport_Cleanup(void)
 {
-    Py_ssize_t pos;
+    Py_ssize_t pos, ndone;
     PyObject *key, *value, *dict;
     PyInterpreterState *interp = PyThreadState_GET()->interp;
     PyObject *modules = interp->modules;
-    PyObject *builtins = interp->builtins;
-    PyObject *weaklist = NULL;
 
     if (modules == NULL)
         return; /* Already done */
@@ -311,8 +333,6 @@
        deleted *last* of all, they would come too late in the normal
        destruction order.  Sigh. */
 
-    /* XXX Perhaps these precautions are obsolete. Who knows? */
-
     value = PyDict_GetItemString(modules, "builtins");
     if (value != NULL && PyModule_Check(value)) {
         dict = PyModule_GetDict(value);
@@ -340,87 +360,87 @@
         }
     }
 
-    /* We prepare a list which will receive (name, weakref) tuples of
-       modules when they are removed from sys.modules.  The name is used
-       for diagnosis messages (in verbose mode), while the weakref helps
-       detect those modules which have been held alive. */
-    weaklist = PyList_New(0);
-    if (weaklist == NULL)
-        PyErr_Clear();
-
-#define STORE_MODULE_WEAKREF(name, mod) \
-    if (weaklist != NULL) { \
-        PyObject *wr = PyWeakref_NewRef(mod, NULL); \
-        if (name && wr) { \
-            PyObject *tup = PyTuple_Pack(2, name, wr); \
-            PyList_Append(weaklist, tup); \
-            Py_XDECREF(tup); \
-        } \
-        Py_XDECREF(wr); \
-        if (PyErr_Occurred()) \
-            PyErr_Clear(); \
+    /* First, delete __main__ */
+    value = PyDict_GetItemString(modules, "__main__");
+    if (value != NULL && PyModule_Check(value)) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# cleanup __main__\n");
+        _PyModule_Clear(value);
+        PyDict_SetItemString(modules, "__main__", Py_None);
     }
 
-    /* Remove all modules from sys.modules, hoping that garbage collection
-       can reclaim most of them. */
+    /* The special treatment of "builtins" here is because even
+       when it's not referenced as a module, its dictionary is
+       referenced by almost every module's __builtins__.  Since
+       deleting a module clears its dictionary (even if there are
+       references left to it), we need to delete the "builtins"
+       module last.  Likewise, we don't delete sys until the very
+       end because it is implicitly referenced (e.g. by print).
+
+       Also note that we 'delete' modules by replacing their entry
+       in the modules dict with None, rather than really deleting
+       them; this avoids a rehash of the modules dictionary and
+       also marks them as "non existent" so they won't be
+       re-imported. */
+
+    /* Next, repeatedly delete modules with a reference count of
+       one (skipping builtins and sys) and delete them */
+    do {
+        ndone = 0;
+        pos = 0;
+        while (PyDict_Next(modules, &pos, &key, &value)) {
+            if (value->ob_refcnt != 1)
+                continue;
+            if (PyUnicode_Check(key) && PyModule_Check(value)) {
+                if (is_essential_module(key))
+                    continue;
+                if (Py_VerboseFlag)
+                    PySys_FormatStderr(
+                        "# cleanup[1] %U\n", key);
+                _PyModule_Clear(value);
+                PyDict_SetItem(modules, key, Py_None);
+                ndone++;
+            }
+        }
+    } while (ndone > 0);
+
+    /* Next, delete all modules (still skipping builtins and sys) */
     pos = 0;
     while (PyDict_Next(modules, &pos, &key, &value)) {
-        if (PyModule_Check(value)) {
-            if (Py_VerboseFlag && PyUnicode_Check(key))
-                PySys_FormatStderr("# cleanup[2] removing %U\n", key, value);
-            STORE_MODULE_WEAKREF(key, value);
+        if (PyUnicode_Check(key) && PyModule_Check(value)) {
+            if (is_essential_module(key))
+                continue;
+            if (Py_VerboseFlag)
+                PySys_FormatStderr("# cleanup[2] %U\n", key);
+            _PyModule_Clear(value);
             PyDict_SetItem(modules, key, Py_None);
         }
     }
 
-    /* Clear the modules dict. */
-    PyDict_Clear(modules);
-    /* Replace the interpreter's reference to builtins with an empty dict
-       (module globals still have a reference to the original builtins). */
-    builtins = interp->builtins;
-    interp->builtins = PyDict_New();
-    Py_DECREF(builtins);
-    /* Clear module dict copies stored in the interpreter state */
-    _PyState_ClearModules();
-    /* Collect references */
-    _PyGC_CollectNoFail();
+    /* Collect garbage remaining after deleting the modules. Mostly
+       reference cycles created by classes. */
+    PyGC_Collect();
+
     /* Dump GC stats before it's too late, since it uses the warnings
        machinery. */
     _PyGC_DumpShutdownStats();
 
-    /* Now, if there are any modules left alive, clear their globals to
-       minimize potential leaks.  All C extension modules actually end
-       up here, since they are kept alive in the interpreter state. */
-    if (weaklist != NULL) {
-        Py_ssize_t i, n;
-        n = PyList_GET_SIZE(weaklist);
-        for (i = 0; i < n; i++) {
-            PyObject *tup = PyList_GET_ITEM(weaklist, i);
-            PyObject *name = PyTuple_GET_ITEM(tup, 0);
-            PyObject *mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1));
-            if (mod == Py_None)
-                continue;
-            Py_INCREF(mod);
-            assert(PyModule_Check(mod));
-            if (Py_VerboseFlag && PyUnicode_Check(name))
-                PySys_FormatStderr("# cleanup[3] wiping %U\n",
-                                   name, mod);
-            _PyModule_Clear(mod);
-            Py_DECREF(mod);
+    /* Next, delete all remaining modules */
+    pos = 0;
+    while (PyDict_Next(modules, &pos, &key, &value)) {
+        if (PyUnicode_Check(key) && PyModule_Check(value)) {
+            if (Py_VerboseFlag)
+                PySys_FormatStderr("# cleanup[3] %U\n", key);
+            _PyModule_Clear(value);
+            PyDict_SetItem(modules, key, Py_None);
         }
-        Py_DECREF(weaklist);
     }
 
-    /* Clear and delete the modules directory.  Actual modules will
-       still be there only if imported during the execution of some
-       destructor. */
+    /* Finally, clear and delete the modules directory */
+    PyDict_Clear(modules);
+    _PyGC_CollectNoFail();
     interp->modules = NULL;
     Py_DECREF(modules);
-
-    /* Once more */
-    _PyGC_CollectNoFail();
-
-#undef STORE_MODULE_WEAKREF
 }
 
 
@@ -1800,7 +1820,7 @@
                           &name, PyUnicode_FSDecoder, &pathname, &fob))
         return NULL;
     if (fob != NULL) {
-        fp = _Py_fopen(pathname, "r");
+        fp = _Py_fopen_obj(pathname, "r");
         if (fp == NULL) {
             Py_DECREF(pathname);
             if (!PyErr_Occurred())
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/pystate.c
--- a/Python/pystate.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/pystate.c	Mon Aug 12 02:18:40 2013 +0200
@@ -320,31 +320,6 @@
     return PyList_SetItem(state->modules_by_index, index, Py_None);
 }
 
-/* used by import.c:PyImport_Cleanup */
-void
-_PyState_ClearModules(void)
-{
-    PyInterpreterState *state = PyThreadState_GET()->interp;
-    if (state->modules_by_index) {
-        Py_ssize_t i;
-        for (i = 0; i < PyList_GET_SIZE(state->modules_by_index); i++) {
-            PyObject *m = PyList_GET_ITEM(state->modules_by_index, i);
-            if (PyModule_Check(m)) {
-                /* cleanup the saved copy of module dicts */
-                PyModuleDef *md = PyModule_GetDef(m);
-                if (md)
-                    Py_CLEAR(md->m_base.m_copy);
-            }
-        }
-        /* Setting modules_by_index to NULL could be dangerous, so we
-           clear the list instead. */
-        if (PyList_SetSlice(state->modules_by_index,
-                            0, PyList_GET_SIZE(state->modules_by_index),
-                            NULL))
-            PyErr_WriteUnraisable(state->modules_by_index);
-    }
-}
-
 void
 PyThreadState_Clear(PyThreadState *tstate)
 {
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/pythonrun.c
--- a/Python/pythonrun.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/pythonrun.c	Mon Aug 12 02:18:40 2013 +0200
@@ -29,6 +29,10 @@
 #include <langinfo.h>
 #endif
 
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif /* HAVE_FCNTL_H */
+
 #ifdef MS_WINDOWS
 #undef BYTE
 #include "windows.h"
@@ -112,7 +116,6 @@
 int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
 int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */
 int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */
-int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */
 
 PyThreadState *_Py_Finalizing = NULL;
 
@@ -1383,8 +1386,8 @@
     return 0;
 }
 
-static int
-set_main_loader(PyObject *d, const char *filename, const char *loader_name)
+int
+static set_main_loader(PyObject *d, const char *filename, const char *loader_name)
 {
     PyInterpreterState *interp;
     PyThreadState *tstate;
@@ -1451,7 +1454,7 @@
         /* Try to run a pyc file. First, re-open in binary */
         if (closeit)
             fclose(fp);
-        if ((pyc_fp = fopen(filename, "rb")) == NULL) {
+        if ((pyc_fp = _Py_fopen(filename, "rb")) == NULL) {
             fprintf(stderr, "python: Can't reopen .pyc file\n");
             goto done;
         }
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/random.c
--- a/Python/random.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/random.c	Mon Aug 12 02:18:40 2013 +0200
@@ -101,7 +101,7 @@
 
     assert (0 < size);
 
-    fd = open("/dev/urandom", O_RDONLY);
+    fd = _Py_open("/dev/urandom", O_RDONLY);
     if (fd < 0)
         Py_FatalError("Failed to open /dev/urandom");
 
@@ -134,10 +134,9 @@
         return 0;
 
     Py_BEGIN_ALLOW_THREADS
-    fd = open("/dev/urandom", O_RDONLY);
+    fd = _Py_open("/dev/urandom", O_RDONLY);
     Py_END_ALLOW_THREADS
-    if (fd < 0)
-    {
+    if (fd < 0) {
         PyErr_SetString(PyExc_NotImplementedError,
                         "/dev/urandom (or equivalent) not found");
         return -1;
diff -r 9e61563edb67 -r 1f8979a8c2c5 Python/sysmodule.c
--- a/Python/sysmodule.c	Sun Aug 11 16:48:44 2013 -0700
+++ b/Python/sysmodule.c	Mon Aug 12 02:18:40 2013 +0200
@@ -1369,7 +1369,6 @@
     {"bytes_warning",           "-b"},
     {"quiet",                   "-q"},
     {"hash_randomization",      "-R"},
-    {"isolated",                "-I"},
     {0}
 };
 
@@ -1377,7 +1376,7 @@
     "sys.flags",        /* name */
     flags__doc__,       /* doc */
     flags_fields,       /* fields */
-    13
+    12
 };
 
 static PyObject*
@@ -1407,7 +1406,6 @@
     SetFlag(Py_BytesWarningFlag);
     SetFlag(Py_QuietFlag);
     SetFlag(Py_HashRandomizationFlag);
-    SetFlag(Py_IsolatedFlag);
 #undef SetFlag
 
     if (PyErr_Occurred()) {
@@ -1946,7 +1944,7 @@
 void
 PySys_SetArgv(int argc, wchar_t **argv)
 {
-    PySys_SetArgvEx(argc, argv, Py_IsolatedFlag == 0);
+    PySys_SetArgvEx(argc, argv, 1);
 }
 
 /* Reimplementation of PyFile_WriteString() no calling indirectly
diff -r 9e61563edb67 -r 1f8979a8c2c5 README
--- a/README	Sun Aug 11 16:48:44 2013 -0700
+++ b/README	Mon Aug 12 02:18:40 2013 +0200
@@ -1,5 +1,5 @@
-This is Python version 3.4.0 alpha 1
-====================================
+This is Python version 3.4.0 prerelease
+=======================================
 
 Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
 2012, 2013 Python Software Foundation.  All rights reserved.
diff -r 9e61563edb67 -r 1f8979a8c2c5 Tools/msi/msi.py
--- a/Tools/msi/msi.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/Tools/msi/msi.py	Mon Aug 12 02:18:40 2013 +0200
@@ -121,7 +121,6 @@
     "31":"{4afcba0b-13e4-47c3-bebe-477428b46913}",
     "32":"{3ff95315-1096-4d31-bd86-601d5438ad5e}",
     "33":"{f7581ca4-d368-4eea-8f82-d48c64c4f047}",
-    "34":"{7A0C5812-2583-40D9-BCBB-CD7485F11377}",
     } [major+minor]
 
 # Compute the name that Sphinx gives to the docfile
@@ -1270,10 +1269,6 @@
               "{60254CA5-953B-11CF-8C96-00AA00B8708C}", "REGISTRY.def"),
             ])
 
-    # PATHEXT
-    add_data(db, "Environment",
-             [("PathExtAddition", "=-*PathExt", "[~];.PY", "REGISTRY.def")])
-
     # Registry keys
     prefix = r"Software\%sPython\PythonCore\%s" % (testprefix, short_version)
     add_data(db, "Registry",
@@ -1415,10 +1410,7 @@
 # certname (from config.py) should be (a substring of)
 # the certificate subject, e.g. "Python Software Foundation"
 if certname:
-    os.system('signtool sign /n "%s" '
-      '/t http://timestamp.verisign.com/scripts/timestamp.dll '
-      '/d "Python %s" '
-      '%s' % (certname, full_current_version, msiname))
+    os.system('signtool sign /n "%s" /t http://timestamp.verisign.com/scripts/timestamp.dll %s' % (certname, msiname))
 
 if pdbzip:
     build_pdbzip()
diff -r 9e61563edb67 -r 1f8979a8c2c5 configure.ac
--- a/configure.ac	Sun Aug 11 16:48:44 2013 -0700
+++ b/configure.ac	Mon Aug 12 02:18:40 2013 +0200
@@ -2806,7 +2806,7 @@
 
 # checks for library functions
 AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \
- clock confstr ctermid execv faccessat fchmod fchmodat fchown fchownat \
+ clock confstr ctermid dup3 execv faccessat fchmod fchmodat fchown fchownat \
  fexecve fdopendir fork fpathconf fstatat ftime ftruncate futimesat \
  futimens futimes gai_strerror \
  getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
diff -r 9e61563edb67 -r 1f8979a8c2c5 setup.py
--- a/setup.py	Sun Aug 11 16:48:44 2013 -0700
+++ b/setup.py	Mon Aug 12 02:18:40 2013 +0200
@@ -1534,15 +1534,6 @@
         if '_tkinter' not in [e.name for e in self.extensions]:
             missing.append('_tkinter')
 
-##         # Uncomment these lines if you want to play with xxmodule.c
-##         ext = Extension('xx', ['xxmodule.c'])
-##         self.extensions.append(ext)
-
-        if 'd' not in sys.abiflags:
-            ext = Extension('xxlimited', ['xxlimited.c'],
-                            define_macros=[('Py_LIMITED_API', 1)])
-            self.extensions.append(ext)
-
         return missing
 
     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
@@ -1740,6 +1731,14 @@
                         )
         self.extensions.append(ext)
 
+##         # Uncomment these lines if you want to play with xxmodule.c
+##         ext = Extension('xx', ['xxmodule.c'])
+##         self.extensions.append(ext)
+        if 'd' not in sys.abiflags:
+            ext = Extension('xxlimited', ['xxlimited.c'],
+                            define_macros=[('Py_LIMITED_API', 1)])
+            self.extensions.append(ext)
+
         # XXX handle these, but how to detect?
         # *** Uncomment and edit for PIL (TkImaging) extension only:
         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \