path: root/Doc/whatsnew/2.6.rst

****************************
  What's New in Python 2.6  
****************************

.. % XXX mention switch to reST for documentation
.. % XXX mention switch to Roundup for bug tracking

:Author: A.M. Kuchling
:Release: |release|
:Date: |today|

.. % $Id: whatsnew26.tex 55963 2007-06-13 18:07:49Z guido.van.rossum $
.. % Rules for maintenance:
.. % 
.. % * Anyone can add text to this document.  Do not spend very much time
.. % on the wording of your changes, because your text will probably
.. % get rewritten to some degree.
.. % 
.. % * The maintainer will go through Misc/NEWS periodically and add
.. % changes; it's therefore more important to add your changes to
.. % Misc/NEWS than to this file.
.. % 
.. % * This is not a complete list of every single change; completeness
.. % is the purpose of Misc/NEWS.  Some changes I consider too small
.. % or esoteric to include.  If such a change is added to the text,
.. % I'll just remove it.  (This is another reason you shouldn't spend
.. % too much time on writing your addition.)
.. % 
.. % * If you want to draw your new text to the attention of the
.. % maintainer, add 'XXX' to the beginning of the paragraph or
.. % section.
.. % 
.. % * It's OK to just add a fragmentary note about a change.  For
.. % example: "XXX Describe the transmogrify() function added to the
.. % socket module."  The maintainer will research the change and
.. % write the necessary text.
.. % 
.. % * You can comment out your additions if you like, but it's not
.. % necessary (especially when a final release is some months away).
.. % 
.. % * Credit the author of a patch or bugfix.   Just the name is
.. % sufficient; the e-mail address isn't necessary.
.. % 
.. % * It's helpful to add the bug/patch number as a comment:
.. % 
.. % % Patch 12345
.. % XXX Describe the transmogrify() function added to the socket
.. % module.
.. % (Contributed by P.Y. Developer.)
.. % 
.. % This saves the maintainer the effort of going through the SVN log
.. % when researching a change.

This article explains the new features in Python 2.6.  No release date for
Python 2.6 has been set; it will probably be released in mid 2008.

This article doesn't attempt to provide a complete specification of the new
features, but instead provides a convenient overview.  For full details, you
should refer to the documentation for Python 2.6. If you want to understand the
complete implementation and design rationale, refer to the PEP for a particular
new feature.

.. % Compare with previous release in 2 - 3 sentences here.
.. % add hyperlink when the documentation becomes available online.

.. % ======================================================================
.. % Large, PEP-level features and changes should be described here.
.. % Should there be a new section here for 3k migration?
.. % Or perhaps a more general section describing module changes/deprecation?
.. % ======================================================================

Python 3.0
================

.. % XXX add general comment about Python 3.0 features in 2.6

The development cycle for Python 2.6 also saw the release of the first
alphas of Python 3.0, and the development of 3.0 has influenced 
a number of features in 2.6.

Python 3.0 is a far-ranging redesign of Python that breaks
compatibility with the 2.x series.  This means that existing Python
code will need a certain amount of conversion in order to run on
Python 3.0.  However, not all the changes in 3.0 necessarily break
compatibility.  In cases where new features won't cause existing code
to break, they've been backported to 2.6 and are described in this
document in the appropriate place.  Some of the 3.0-derived features 
are:

* A :meth:`__complex__` method for converting objects to a complex number.
* Alternate syntax for catching exceptions: ``except TypeError as exc``.
* The addition of :func:`functools.reduce` as a synonym for the built-in
  :func:`reduce` function.

A new command-line switch, :option:`-3`, enables warnings
about features that will be removed in Python 3.0.  You can run code
with this switch to see how much work will be necessary to port
code to 3.0.

.. seealso::

   The 3xxx series of PEPs, which describes the development process for
   Python 3.0 and various features that have been accepted, rejected,
   or are still under consideration.

PEP 343: The 'with' statement
=============================

The previous version, Python 2.5, added the ':keyword:`with`'
statement an optional feature, to be enabled by a ``from __future__
import with_statement`` directive.  In 2.6 the statement no longer needs to
be specially enabled; this means that :keyword:`with` is now always a
keyword.  The rest of this section is a copy of the corresponding 
section from "What's New in Python 2.5" document; if you read
it back when Python 2.5 came out, you can skip the rest of this
section.

The ':keyword:`with`' statement clarifies code that previously would use
``try...finally`` blocks to ensure that clean-up code is executed.  In this
section, I'll discuss the statement as it will commonly be used.  In the next
section, I'll examine the implementation details and show how to write objects
for use with this statement.

The ':keyword:`with`' statement is a new control-flow structure whose basic
structure is::

   with expression [as variable]:
       with-block

The expression is evaluated, and it should result in an object that supports the
context management protocol (that is, has :meth:`__enter__` and :meth:`__exit__`
methods.

The object's :meth:`__enter__` is called before *with-block* is executed and
therefore can run set-up code. It also may return a value that is bound to the
name *variable*, if given.  (Note carefully that *variable* is *not* assigned
the result of *expression*.)

After execution of the *with-block* is finished, the object's :meth:`__exit__`
method is called, even if the block raised an exception, and can therefore run
clean-up code.

Some standard Python objects now support the context management protocol and can
be used with the ':keyword:`with`' statement. File objects are one example::

   with open('/etc/passwd', 'r') as f:
       for line in f:
           print line
           ... more processing code ...

After this statement has executed, the file object in *f* will have been
automatically closed, even if the :keyword:`for` loop raised an exception part-
way through the block.

.. note::

   In this case, *f* is the same object created by :func:`open`, because
   :meth:`file.__enter__` returns *self*.

The :mod:`threading` module's locks and condition variables  also support the
':keyword:`with`' statement::

   lock = threading.Lock()
   with lock:
       # Critical section of code
       ...

The lock is acquired before the block is executed and always released once  the
block is complete.

The new :func:`localcontext` function in the :mod:`decimal` module makes it easy
to save and restore the current decimal context, which encapsulates the desired
precision and rounding characteristics for computations::

   from decimal import Decimal, Context, localcontext

   # Displays with default precision of 28 digits
   v = Decimal('578')
   print v.sqrt()

   with localcontext(Context(prec=16)):
       # All code in this block uses a precision of 16 digits.
       # The original context is restored on exiting the block.
       print v.sqrt()


.. _new-26-context-managers:

Writing Context Managers
------------------------

Under the hood, the ':keyword:`with`' statement is fairly complicated. Most
people will only use ':keyword:`with`' in company with existing objects and
don't need to know these details, so you can skip the rest of this section if
you like.  Authors of new objects will need to understand the details of the
underlying implementation and should keep reading.

A high-level explanation of the context management protocol is:

* The expression is evaluated and should result in an object called a "context
  manager".  The context manager must have :meth:`__enter__` and :meth:`__exit__`
  methods.

* The context manager's :meth:`__enter__` method is called.  The value returned
  is assigned to *VAR*.  If no ``as VAR`` clause is present, the value is simply
  discarded.

* The code in *BLOCK* is executed.

* If *BLOCK* raises an exception, the :meth:`__exit__(type, value, traceback)`
  is called with the exception details, the same values returned by
  :func:`sys.exc_info`.  The method's return value controls whether the exception
  is re-raised: any false value re-raises the exception, and ``True`` will result
  in suppressing it.  You'll only rarely want to suppress the exception, because
  if you do the author of the code containing the ':keyword:`with`' statement will
  never realize anything went wrong.

* If *BLOCK* didn't raise an exception,  the :meth:`__exit__` method is still
  called, but *type*, *value*, and *traceback* are all ``None``.

Let's think through an example.  I won't present detailed code but will only
sketch the methods necessary for a database that supports transactions.

(For people unfamiliar with database terminology: a set of changes to the
database are grouped into a transaction.  Transactions can be either committed,
meaning that all the changes are written into the database, or rolled back,
meaning that the changes are all discarded and the database is unchanged.  See
any database textbook for more information.)

Let's assume there's an object representing a database connection. Our goal will
be to let the user write code like this::

   db_connection = DatabaseConnection()
   with db_connection as cursor:
       cursor.execute('insert into ...')
       cursor.execute('delete from ...')
       # ... more operations ...

The transaction should be committed if the code in the block runs flawlessly or
rolled back if there's an exception. Here's the basic interface for
:class:`DatabaseConnection` that I'll assume::

   class DatabaseConnection:
       # Database interface
       def cursor(self):
           "Returns a cursor object and starts a new transaction"
       def commit(self):
           "Commits current transaction"
       def rollback(self):
           "Rolls back current transaction"

The :meth:`__enter__` method is pretty easy, having only to start a new
transaction.  For this application the resulting cursor object would be a useful
result, so the method will return it.  The user can then add ``as cursor`` to
their ':keyword:`with`' statement to bind the cursor to a variable name. ::

   class DatabaseConnection:
       ...
       def __enter__(self):
           # Code to start a new transaction
           cursor = self.cursor()
           return cursor

The :meth:`__exit__` method is the most complicated because it's where most of
the work has to be done.  The method has to check if an exception occurred.  If
there was no exception, the transaction is committed.  The transaction is rolled
back if there was an exception.

In the code below, execution will just fall off the end of the function,
returning the default value of ``None``.  ``None`` is false, so the exception
will be re-raised automatically.  If you wished, you could be more explicit and
add a :keyword:`return` statement at the marked location. ::

   class DatabaseConnection:
       ...
       def __exit__(self, type, value, tb):
           if tb is None:
               # No exception, so commit
               self.commit()
           else:
               # Exception occurred, so rollback.
               self.rollback()
               # return False


.. _module-contextlib:

The contextlib module
---------------------

The new :mod:`contextlib` module provides some functions and a decorator that
are useful for writing objects for use with the ':keyword:`with`' statement.

The decorator is called :func:`contextmanager`, and lets you write a single
generator function instead of defining a new class.  The generator should yield
exactly one value.  The code up to the :keyword:`yield` will be executed as the
:meth:`__enter__` method, and the value yielded will be the method's return
value that will get bound to the variable in the ':keyword:`with`' statement's
:keyword:`as` clause, if any.  The code after the :keyword:`yield` will be
executed in the :meth:`__exit__` method.  Any exception raised in the block will
be raised by the :keyword:`yield` statement.

Our database example from the previous section could be written  using this
decorator as::

   from contextlib import contextmanager

   @contextmanager
   def db_transaction(connection):
       cursor = connection.cursor()
       try:
           yield cursor
       except:
           connection.rollback()
           raise
       else:
           connection.commit()

   db = DatabaseConnection()
   with db_transaction(db) as cursor:
       ...

The :mod:`contextlib` module also has a :func:`nested(mgr1, mgr2, ...)` function
that combines a number of context managers so you don't need to write nested
':keyword:`with`' statements.  In this example, the single ':keyword:`with`'
statement both starts a database transaction and acquires a thread lock::

   lock = threading.Lock()
   with nested (db_transaction(db), lock) as (cursor, locked):
       ...

Finally, the :func:`closing(object)` function returns *object* so that it can be
bound to a variable, and calls ``object.close`` at the end of the block. ::

   import urllib, sys
   from contextlib import closing

   with closing(urllib.urlopen('http://www.yahoo.com')) as f:
       for line in f:
           sys.stdout.write(line)


.. seealso::

   :pep:`343` - The "with" statement
      PEP written by Guido van Rossum and Nick Coghlan; implemented by Mike Bland,
      Guido van Rossum, and Neal Norwitz.  The PEP shows the code generated for a
      ':keyword:`with`' statement, which can be helpful in learning how the statement
      works.

   The documentation  for the :mod:`contextlib` module.

.. % ======================================================================

.. _pep-3110:

PEP 3110: Exception-Handling Changes
=====================================================

One error that Python programmers occasionally make 
is the following::

    try:
        ...
    except TypeError, ValueError:
        ...

The author is probably trying to catch both 
:exc:`TypeError` and :exc:`ValueError` exceptions, but this code
actually does something different: it will catch 
:exc:`TypeError` and bind the resulting exception object
to the local name ``"ValueError"``.  The correct code 
would have specified a tuple::

    try:
        ...
    except (TypeError, ValueError):
        ...

This error is possible because the use of the comma here is ambiguous:
does it indicate two different nodes in the parse tree, or a single
node that's a tuple.

Python 3.0 changes the syntax to make this unambiguous by replacing
the comma with the word "as".  To catch an exception and store the 
exception object in the variable ``exc``, you must write::

    try:
        ...
    except TypeError as exc:
        ...

Python 3.0 will only support the use of "as", and therefore interprets
the first example as catching two different exceptions.  Python 2.6
supports both the comma and "as", so existing code will continue to
work.

.. seealso::

   :pep:`3110` - Catching Exceptions in Python 3000
      PEP written and implemented by Collin Winter.

.. % ======================================================================

.. _pep-3119:

PEP 3119: Abstract Base Classes
=====================================================

XXX

.. seealso::

   :pep:`3119` - Introducing Abstract Base Classes
      PEP written by Guido van Rossum and Talin.
      Implemented by XXX.
      Backported to 2.6 by Benjamin Aranguren (with Alex Martelli).

Other Language Changes
======================

Here are all of the changes that Python 2.6 makes to the core Python language.

* When calling a function using the ``**`` syntax to provide keyword
  arguments, you are no longer required to use a Python dictionary;
  any mapping will now work::

    >>> def f(**kw):
    ...    print sorted(kw)
    ... 
    >>> ud=UserDict.UserDict()
    >>> ud['a'] = 1
    >>> ud['b'] = 'string'
    >>> f(**ud)
    ['a', 'b']

  .. % Patch 1686487

* The built-in types now have improved support for extended slicing syntax,
  where various combinations of ``(start, stop, step)`` are supplied.
  Previously, the support was partial and certain corner cases wouldn't work.
  (Implemented by Thomas Wouters.)

  .. % Revision 57619

* C functions and methods that use 
  :cfunc:`PyComplex_AsCComplex` will now accept arguments that 
  have a :meth:`__complex__` method.  In particular, the functions in the 
  :mod:`cmath` module will now accept objects with this method.
  This is a backport of a Python 3.0 change.
  (Contributed by Mark Dickinson.)

  .. % Patch #1675423

* Changes to the :class:`Exception` interface
  as dictated by :pep:`352` continue to be made.  For 2.6, 
  the :attr:`message` attribute is being deprecated in favor of the
  :attr:`args` attribute.

* The :func:`compile` built-in function now accepts keyword arguments
  as well as positional parameters.  (Contributed by Thomas Wouters.)

  .. % Patch 1444529

* The :func:`complex` constructor now accepts strings containing 
  parenthesized complex numbers, letting ``complex(repr(cmplx))``
  will now round-trip values.  For example, ``complex('(3+4j)')``
  now returns the value (3+4j).

  .. % Patch 1491866

* The string :meth:`translate` method now accepts ``None`` as the 
  translation table parameter, which is treated as the identity 
  transformation.   This makes it easier to carry out operations
  that only delete characters.  (Contributed by Bengt Richter.)

  .. % Patch 1193128

* The built-in :func:`dir` function now checks for a :meth:`__dir__`
  method on the objects it receives.  This method must return a list
  of strings containing the names of valid attributes for the object,
  and lets the object control the value that :func:`dir` produces.
  Objects that have :meth:`__getattr__` or :meth:`__getattribute__` 
  methods can use this to advertise pseudo-attributes they will honor.

  .. % Patch 1591665

* An obscure change: when you use the the :func:`locals` function inside a
  :keyword:`class` statement, the resulting dictionary no longer returns free
  variables.  (Free variables, in this case, are variables referred to in the
  :keyword:`class` statement  that aren't attributes of the class.)

.. % ======================================================================


Optimizations
-------------

* Internally, a bit is now set in type objects to indicate some of the standard
  built-in types.  This speeds up checking if an object is a subclass of one of
  these types.  (Contributed by Neal Norwitz.)

The net result of the 2.6 optimizations is that Python 2.6 runs the pystone
benchmark around XX% faster than Python 2.5.

.. % ======================================================================


New, Improved, and Deprecated Modules
=====================================

As usual, Python's standard library received a number of enhancements and bug
fixes.  Here's a partial list of the most notable changes, sorted alphabetically
by module name. Consult the :file:`Misc/NEWS` file in the source tree for a more
complete list of changes, or look through the CVS logs for all the details.

* The :mod:`bsddb.dbshelve` module now uses the highest pickling protocol
  available, instead of restricting itself to protocol 1.
  (Contributed by W. Barnes.)

  .. % Patch 1551443

* A new data type in the :mod:`collections` module: :class:`namedtuple(typename,
  fieldnames)` is a factory function that creates subclasses of the standard tuple
  whose fields are accessible by name as well as index.  For example::

     >>> var_type = collections.namedtuple('variable', 
     ...             'id name type size')
     # Names are separated by spaces or commas.
     # 'id, name, type, size' would also work.
     >>> var_type._fields
     ('id', 'name', 'type', 'size')

     >>> var = var_type(1, 'frequency', 'int', 4)
     >>> print var[0], var.id		# Equivalent
     1 1
     >>> print var[2], var.type          # Equivalent
     int int
     >>> var._asdict()
     {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
     >>> v2 = var._replace('name', 'amplitude')
     >>> v2
     variable(id=1, name='amplitude', type='int', size=4)

  (Contributed by Raymond Hettinger.)

* Another change to the :mod:`collections` module is that the 
  :class:`deque` type now supports an optional *maxlen* parameter;
  if supplied, the deque's size will be restricted to no more 
  than *maxlen* items.  Adding more items to a full deque causes
  old items to be discarded.

  ::

    >>> from collections import deque
    >>> dq=deque(maxlen=3)
    >>> dq
    deque([], maxlen=3)
    >>> dq.append(1) ; dq.append(2) ; dq.append(3)
    >>> dq
    deque([1, 2, 3], maxlen=3)
    >>> dq.append(4)
    >>> dq
    deque([2, 3, 4], maxlen=3)

  (Contributed by Raymond Hettinger.)

* The :mod:`ctypes` module now supports a :class:`c_bool` datatype 
  that represents the C99 ``bool`` type.  (Contributed by David Remahl.)

  .. % Patch 1649190

  The :mod:`ctypes` string, buffer and array types also have improved
  support for extended slicing syntax,
  where various combinations of ``(start, stop, step)`` are supplied.
  (Implemented by Thomas Wouters.)

  .. % Revision 57769


* A new method in the :mod:`curses` module: for a window, :meth:`chgat` changes
  the display characters for a  certain number of characters on a single line.
  ::

     # Boldface text starting at y=0,x=21 
     # and affecting the rest of the line.
     stdscr.chgat(0,21, curses.A_BOLD)  

  (Contributed by Fabian Kreutz.)

* The :mod:`decimal` module was updated to version 1.66 of 
  `the General Decimal Specification <http://www2.hursley.ibm.com/decimal/decarith.html>`__.  New features
  include some methods for some basic mathematical functions such as
  :meth:`exp` and :meth:`log10`::

    >>> Decimal(1).exp()
    Decimal("2.718281828459045235360287471")
    >>> Decimal("2.7182818").ln()
    Decimal("0.9999999895305022877376682436")
    >>> Decimal(1000).log10()
    Decimal("3")

  (Implemented by Facundo Batista and Mark Dickinson.)

* An optional ``timeout`` parameter was added to the
  :class:`ftplib.FTP` class constructor as well as the :meth:`connect`
  method, specifying a timeout measured in seconds.  (Added by Facundo
  Batista.)

* The :func:`reduce` built-in function is also available in the 
  :mod:`functools` module.  In Python 3.0, the built-in is dropped and it's
  only available from :mod:`functools`; currently there are no plans
  to drop the built-in in the 2.x series.  (Patched by 
  Christian Heimes.)

  .. % Patch 1739906

* The :func:`glob.glob` function can now return Unicode filenames if 
  a Unicode path was used and Unicode filenames are matched within the directory.

  .. % Patch #1001604

* The :mod:`gopherlib` module has been removed.

* A new function in the :mod:`heapq` module: ``merge(iter1, iter2, ...)``
  takes any number of iterables that return data  *in sorted order*,  and  returns
  a new iterator that returns the contents of all the iterators, also in sorted
  order.  For example::

     heapq.merge([1, 3, 5, 9], [2, 8, 16]) ->
       [1, 2, 3, 5, 8, 9, 16]

  (Contributed by Raymond Hettinger.)

* An optional ``timeout`` parameter was added to the
  :class:`httplib.HTTPConnection` and :class:`HTTPSConnection` 
  class constructors, specifying a timeout measured in seconds.
  (Added by Facundo Batista.)

* A new function in the :mod:`itertools` module: ``izip_longest(iter1, iter2,
  ...[, fillvalue])`` makes tuples from each of the elements; if some of the
  iterables are shorter than others, the missing values  are set to *fillvalue*.
  For example::

     itertools.izip_longest([1,2,3], [1,2,3,4,5]) ->
       [(1, 1), (2, 2), (3, 3), (None, 4), (None, 5)]

  (Contributed by Raymond Hettinger.)

* The :mod:`macfs` module has been removed.  This in turn required the
  :func:`macostools.touched` function to be removed because it depended on the
  :mod:`macfs` module.

  .. % Patch #1490190

* The :func:`os.walk` function now has a ``followlinks`` parameter. If
  set to True, it will follow symlinks pointing to directories and
  visit the directory's contents.  For backward compatibility, the
  parameter's default value is false.  Note that the function can fall
  into an infinite recursion if there's a symlink that points to a
  parent directory.
       
  .. % Patch 1273829

* The ``os.environ`` object's :meth:`clear` method will now unset the 
  environment variables using :func:`os.unsetenv` in addition to clearing
  the object's keys.  (Contributed by Martin Horcicka.)

  .. % Patch #1181 

* In the :mod:`os.path` module, the :func:`splitext` function
  has been changed to not split on leading period characters.
  This produces better results when operating on Unix's dot-files.
  For example, ``os.path.splitext('.ipython')``
  now returns ``('.ipython', '')`` instead of ``('', '.ipython')``.

  .. % Bug #115886

  A new function, :func:`relpath(path, start)` returns a relative path
  from the ``start`` path, if it's supplied, or from the current
  working directory to the destination ``path``.  (Contributed by
  Richard Barran.)

  .. % Patch 1339796

  On Windows, :func:`os.path.expandvars` will now expand environment variables 
  in the form "%var%", and "~user" will be expanded into the 
  user's home directory path.  (Contributed by Josiah Carlson.)

  .. % Patch 957650

* The Python debugger provided by the :mod:`pdb` module 
  gained a new command: "run" restarts the Python program being debugged,
  and can optionally take new command-line arguments for the program.
  (Contributed by Rocky Bernstein.)

  .. % Patch #1393667

* New functions in the :mod:`posix` module: :func:`chflags` and :func:`lchflags`
  are wrappers for the corresponding system calls (where they're available).
  Constants for the flag values are defined in the :mod:`stat` module; some
  possible values include :const:`UF_IMMUTABLE` to signal the file may not be
  changed and :const:`UF_APPEND` to indicate that data can only be appended to the
  file.  (Contributed by M. Levinson.)

* The :mod:`rgbimg` module has been removed.

* The :mod:`sets` module has been deprecated; it's better to 
  use the built-in :class:`set` and :class:`frozenset` types.

* The :mod:`smtplib` module now supports SMTP over SSL thanks to the
  addition of the :class:`SMTP_SSL` class. This class supports an
  interface identical to the existing :class:`SMTP` class.   Both 
  class constructors also have an optional ``timeout`` parameter
  that specifies a timeout for the initial connection attempt, measured in
  seconds.

  An implementation of the LMTP protocol (:rfc:`2033`) was also added to
  the module.  LMTP is used in place of SMTP when transferring e-mail
  between agents that don't manage a mail queue.

  (SMTP over SSL contributed by Monty Taylor; timeout parameter
  added by Facundo Batista; LMTP implemented by Leif
  Hedstrom.)

  .. % Patch #957003

* The :mod:`tarfile` module now supports POSIX.1-2001 (pax) and
  POSIX.1-1988 (ustar) format tarfiles, in addition to the GNU tar
  format that was already supported.  The default format 
  is GNU tar; specify the ``format`` parameter to open a file
  using a different format::

    tar = tarfile.open("output.tar", "w", format=tarfile.PAX_FORMAT)

  The new ``errors`` parameter lets you specify an error handling
  scheme for character conversions: the three standard ways Python can
  handle errors ``'strict'``, ``'ignore'``, ``'replace'`` , or the
  special value ``'utf-8'``, which replaces bad characters with their
  UTF-8 representation.  Character conversions occur because the PAX
  format supports Unicode filenames, defaulting to UTF-8 encoding.

  The :meth:`TarFile.add` method now accepts a ``exclude`` argument that's
  a function that can be used to exclude certain filenames from
  an archive. 
  The function must take a filename and return true if the file 
  should be excluded or false if it should be archived.
  The function is applied to both the name initially passed to :meth:`add`
  and to the names of files in recursively-added directories.
  
  (All changes contributed by Lars Gustäbel).

* An optional ``timeout`` parameter was added to the
  :class:`telnetlib.Telnet` class constructor, specifying a timeout
  measured in seconds.  (Added by Facundo Batista.)

* The :class:`tempfile.NamedTemporaryFile` class usually deletes 
  the temporary file it created when the file is closed.  This 
  behaviour can now be changed by passing ``delete=False`` to the 
  constructor.  (Contributed by Damien Miller.)

  .. % Patch #1537850

* The :mod:`test.test_support` module now contains a
  :func:`EnvironmentVarGuard`
  context manager that  supports temporarily changing environment variables and
  automatically restores them to their old values. 

  Another context manager, :class:`TransientResource`, can surround calls
  to resources that may or may not be available; it will catch and
  ignore a specified list of exceptions.  For example,
  a network test may ignore certain failures when connecting to an
  external web site::

      with test_support.TransientResource(IOError, errno=errno.ETIMEDOUT):
          f = urllib.urlopen('https://sf.net')                         
          ...

  (Contributed by Brett Cannon.)

* The :mod:`textwrap` module can now preserve existing whitespace 
  at the beginnings and ends of the newly-created lines
  by specifying ``drop_whitespace=False``
  as an argument::

    >>> S = """This  sentence  has a bunch   of    extra   whitespace."""
    >>> print textwrap.fill(S, width=15)
    This  sentence
    has a bunch
    of    extra
    whitespace.
    >>> print textwrap.fill(S, drop_whitespace=False, width=15)
    This  sentence
      has a bunch
       of    extra
       whitespace.
    >>> 

  .. % Patch #1581073

* The :mod:`timeit` module now accepts callables as well as strings 
  for the statement being timed and for the setup code.
  Two convenience functions were added for creating 
  :class:`Timer` instances: 
  ``repeat(stmt, setup, time, repeat, number)`` and 
  ``timeit(stmt, setup, time, number)`` create an instance and call
  the corresponding method. (Contributed by Erik Demaine.)

  .. % Patch #1533909

* An optional ``timeout`` parameter was added to the
  :func:`urllib.urlopen` function and the
  :class:`urllib.ftpwrapper` class constructor, as well as the 
  :func:`urllib2.urlopen` function.  The parameter specifies a timeout
  measured in seconds.   For example::

     >>> u = urllib2.urlopen("http://slow.example.com", timeout=3)
     Traceback (most recent call last):
       ...
     urllib2.URLError: <urlopen error timed out>
     >>>   

  (Added by Facundo Batista.) 

* The XML-RPC classes :class:`SimpleXMLRPCServer` and :class:`DocXMLRPCServer`
  classes can now be prevented from immediately opening and binding to
  their socket by passing True as the ``bind_and_activate``
  constructor parameter.  This can be used to modify the instance's
  :attr:`allow_reuse_address` attribute before calling the 
  :meth:`server_bind` and :meth:`server_activate` methods to 
  open the socket and begin listening for connections.
  (Contributed by Peter Parente.)

  .. % Patch 1599845

  :class:`SimpleXMLRPCServer` also has a :attr:`_send_traceback_header`
  attribute; if true, the exception and formatted traceback are returned 
  as HTTP headers "X-Exception" and "X-Traceback".  This feature is 
  for debugging purposes only and should not be used on production servers
  because the tracebacks could possibly reveal passwords or other sensitive
  information.  (Contributed by Alan McIntyre as part of his 
  project for Google's Summer of Code 2007.)

.. % ======================================================================
.. % whole new modules get described in subsections here

Improved SSL Support
--------------------------------------------------

Bill Janssen made extensive improvements to Python 2.6's support for
SSL.

XXX use ssl.sslsocket - subclass of socket.socket.

XXX Can specify if certificate is required, and obtain certificate info
by calling getpeercert method.

XXX sslwrap() behaves like socket.ssl

XXX Certain features require the OpenSSL package to be installed, notably
  the 'openssl' binary.

.. seealso::

   SSL module documentation.

.. % ======================================================================


Build and C API Changes
=======================

Changes to Python's build process and to the C API include:

* Python 2.6 can be built with Microsoft Visual Studio 2008.
  See the :file:`PCbuild9` directory for the build files.
  (Implemented by Christian Heimes.)

* The BerkeleyDB module now has a C API object, available as 
  ``bsddb.db.api``.   This object can be used by other C extensions
  that wish to use the :mod:`bsddb` module for their own purposes.
  (Contributed by Duncan Grisby.)

  .. % Patch 1551895


.. % ======================================================================


Port-Specific Changes
---------------------

Platform-specific changes go here.

.. % ======================================================================


.. _section-other:

Other Changes and Fixes
=======================

As usual, there were a bunch of other improvements and bugfixes scattered
throughout the source tree.  A search through the change logs finds there were
XXX patches applied and YYY bugs fixed between Python 2.5 and 2.6.  Both figures
are likely to be underestimates.

Some of the more notable changes are:

* Details will go here.

.. % ======================================================================


Porting to Python 2.6
=====================

This section lists previously described changes that may require changes to your
code:

* The :mod:`socket` module exception :exc:`socket.error` now inherits
  from :exc:`IOError`.  Previously it wasn't a subclass of
  :exc:`StandardError` but now it is, through :exc:`IOError`.
  (Implemented by Gregory P. Smith.)

  .. % http://bugs.python.org/issue1706815

.. % ======================================================================


.. _acks:

Acknowledgements
================

The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: .