As in every release, 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
Misc/NEWS file in the source tree for a more complete list of
changes, or look through the Subversion logs for all the details.
The bdb module’s base debugging class Bdb
gained a feature for skipping modules. The constructor
now takes an iterable containing glob-style patterns such as
django.*; the debugger will not step into stack frames
from a module that matches one of these patterns.
(Contributed by Maru Newby after a suggestion by
Senthil Kumaran; bpo-5142.)
The binascii module now supports the buffer API, so it can be
used with memoryview instances and other similar buffer objects.
(Backported from 3.x by Florent Xicluna; bpo-7703.)
Updated module: the bsddb module has been updated from 4.7.2devel9
to version 4.8.4 of
the pybsddb package.
The new version features better Python 3.x compatibility, various bug fixes,
and adds several new BerkeleyDB flags and methods.
(Updated by Jesús Cea Avión; bpo-8156. The pybsddb
changelog can be read at http://hg.jcea.es/pybsddb/file/tip/ChangeLog.)
The bz2 module’s BZ2File now supports the context
management protocol, so you can write with bz2.BZ2File(...) as f:.
(Contributed by Hagen Fürstenau; bpo-3860.)
New class: the Counter class in the collections
module is useful for tallying data. Counter instances
behave mostly like dictionaries but return zero for missing keys instead of
raising a KeyError:
>>> from collections import Counter
>>> c = Counter()
>>> for letter in 'here is a sample of english text':
... c[letter] += 1
...
>>> c
Counter({' ': 6, 'e': 5, 's': 3, 'a': 2, 'i': 2, 'h': 2,
'l': 2, 't': 2, 'g': 1, 'f': 1, 'm': 1, 'o': 1, 'n': 1,
'p': 1, 'r': 1, 'x': 1})
>>> c['e']
5
>>> c['z']
0
There are three additional Counter methods.
most_common() returns the N most common
elements and their counts. elements()
returns an iterator over the contained elements, repeating each
element as many times as its count.
subtract() takes an iterable and
subtracts one for each element instead of adding; if the argument is
a dictionary or another Counter, the counts are
subtracted.
>>> c.most_common(5)
[(' ', 6), ('e', 5), ('s', 3), ('a', 2), ('i', 2)]
>>> c.elements() ->
'a', 'a', ' ', ' ', ' ', ' ', ' ', ' ',
'e', 'e', 'e', 'e', 'e', 'g', 'f', 'i', 'i',
'h', 'h', 'm', 'l', 'l', 'o', 'n', 'p', 's',
's', 's', 'r', 't', 't', 'x'
>>> c['e']
5
>>> c.subtract('very heavy on the letter e')
>>> c['e'] # Count is now lower
-1
Contributed by Raymond Hettinger; bpo-1696199.
New class: OrderedDict is described in the earlier
section PEP 372: Adding an Ordered Dictionary to collections.
New method: The deque data type now has a
count() method that returns the number of
contained elements equal to the supplied argument x, and a
reverse() method that reverses the elements
of the deque in-place. deque also exposes its maximum
length as the read-only maxlen attribute.
(Both features added by Raymond Hettinger.)
The namedtuple class now has an optional rename parameter.
If rename is true, field names that are invalid because they’ve
been repeated or aren’t legal Python identifiers will be
renamed to legal names that are derived from the field’s
position within the list of fields:
>>> from collections import namedtuple
>>> T = namedtuple('T', ['field1', '$illegal', 'for', 'field2'], rename=True)
>>> T._fields
('field1', '_1', '_2', 'field2')
(Added by Raymond Hettinger; bpo-1818.)
Finally, the Mapping abstract base class now
returns NotImplemented if a mapping is compared to
another type that isn’t a Mapping.
(Fixed by Daniel Stutzbach; bpo-8729.)
Constructors for the parsing classes in the ConfigParser module now
take an allow_no_value parameter, defaulting to false; if true,
options without values will be allowed. For example:
>>> import ConfigParser, StringIO
>>> sample_config = """
... [mysqld]
... user = mysql
... pid-file = /var/run/mysqld/mysqld.pid
... skip-bdb
... """
>>> config = ConfigParser.RawConfigParser(allow_no_value=True)
>>> config.readfp(StringIO.StringIO(sample_config))
>>> config.get('mysqld', 'user')
'mysql'
>>> print config.get('mysqld', 'skip-bdb')
None
>>> print config.get('mysqld', 'unknown')
Traceback (most recent call last):
...
NoOptionError: No option 'unknown' in section: 'mysqld'
(Contributed by Mats Kindahl; bpo-7005.)
Deprecated function: contextlib.nested(), which allows
handling more than one context manager with a single with
statement, has been deprecated, because the with statement
now supports multiple context managers.
The cookielib module now ignores cookies that have an invalid
version field, one that doesn’t contain an integer value. (Fixed by
John J. Lee; bpo-3924.)
The copy module’s deepcopy() function will now
correctly copy bound instance methods. (Implemented by
Robert Collins; bpo-1515.)
The ctypes module now always converts None to a C NULL
pointer for arguments declared as pointers. (Changed by Thomas
Heller; bpo-4606.) The underlying libffi library has been updated to version
3.0.9, containing various fixes for different platforms. (Updated
by Matthias Klose; bpo-8142.)
New method: the datetime module’s timedelta class
gained a total_seconds() method that returns the
number of seconds in the duration. (Contributed by Brian Quinlan; bpo-5788.)
New method: the Decimal class gained a
from_float() class method that performs an exact
conversion of a floating-point number to a Decimal.
This exact conversion strives for the
closest decimal approximation to the floating-point representation’s value;
the resulting decimal value will therefore still include the inaccuracy,
if any.
For example, Decimal.from_float(0.1) returns
Decimal('0.1000000000000000055511151231257827021181583404541015625').
(Implemented by Raymond Hettinger; bpo-4796.)
Comparing instances of Decimal with floating-point
numbers now produces sensible results based on the numeric values
of the operands. Previously such comparisons would fall back to
Python’s default rules for comparing objects, which produced arbitrary
results based on their type. Note that you still cannot combine
Decimal and floating-point in other operations such as addition,
since you should be explicitly choosing how to convert between float and
Decimal. (Fixed by Mark Dickinson; bpo-2531.)
The constructor for Decimal now accepts
floating-point numbers (added by Raymond Hettinger; bpo-8257)
and non-European Unicode characters such as Arabic-Indic digits
(contributed by Mark Dickinson; bpo-6595).
Most of the methods of the Context class now accept integers
as well as Decimal instances; the only exceptions are the
canonical() and is_canonical()
methods. (Patch by Juan José Conti; bpo-7633.)
When using Decimal instances with a string’s
format() method, the default alignment was previously
left-alignment. This has been changed to right-alignment, which is
more sensible for numeric types. (Changed by Mark Dickinson; bpo-6857.)
Comparisons involving a signaling NaN value (or sNAN) now signal
InvalidOperation instead of silently returning a true or
false value depending on the comparison operator. Quiet NaN values
(or NaN) are now hashable. (Fixed by Mark Dickinson;
bpo-7279.)
The difflib module now produces output that is more
compatible with modern diff/patch tools
through one small change, using a tab character instead of spaces as
a separator in the header giving the filename. (Fixed by Anatoly
Techtonik; bpo-7585.)
The Distutils sdist command now always regenerates the
MANIFEST file, since even if the MANIFEST.in or
setup.py files haven’t been modified, the user might have
created some new files that should be included.
(Fixed by Tarek Ziadé; bpo-8688.)
The doctest module’s IGNORE_EXCEPTION_DETAIL flag
will now ignore the name of the module containing the exception
being tested. (Patch by Lennart Regebro; bpo-7490.)
The email module’s Message class will
now accept a Unicode-valued payload, automatically converting the
payload to the encoding specified by output_charset.
(Added by R. David Murray; bpo-1368247.)
The Fraction class now accepts a single float or
Decimal instance, or two rational numbers, as
arguments to its constructor. (Implemented by Mark Dickinson;
rationals added in bpo-5812, and float/decimal in
bpo-8294.)
Ordering comparisons (<, <=, >, >=) between
fractions and complex numbers now raise a TypeError.
This fixes an oversight, making the Fraction
match the other numeric types.
New class: FTP_TLS in
the ftplib module provides secure FTP
connections using TLS encapsulation of authentication as well as
subsequent control and data transfers.
(Contributed by Giampaolo Rodola; bpo-2054.)
The storbinary() method for binary uploads can now restart
uploads thanks to an added rest parameter (patch by Pablo Mouzo;
bpo-6845.)
New class decorator: total_ordering() in the functools
module takes a class that defines an __eq__() method and one of
__lt__(), __le__(), __gt__(), or __ge__(),
and generates the missing comparison methods. Since the
__cmp__() method is being deprecated in Python 3.x,
this decorator makes it easier to define ordered classes.
(Added by Raymond Hettinger; bpo-5479.)
New function: cmp_to_key() will take an old-style comparison
function that expects two arguments and return a new callable that
can be used as the key parameter to functions such as
sorted(), min() and max(), etc. The primary
intended use is to help with making code compatible with Python 3.x.
(Added by Raymond Hettinger.)
New function: the gc module’s is_tracked() returns
true if a given instance is tracked by the garbage collector, false
otherwise. (Contributed by Antoine Pitrou; bpo-4688.)
The gzip module’s GzipFile now supports the context
management protocol, so you can write with gzip.GzipFile(...) as f:
(contributed by Hagen Fürstenau; bpo-3860), and it now implements
the io.BufferedIOBase ABC, so you can wrap it with
io.BufferedReader for faster processing
(contributed by Nir Aides; bpo-7471).
It’s also now possible to override the modification time
recorded in a gzipped file by providing an optional timestamp to
the constructor. (Contributed by Jacques Frechet; bpo-4272.)
Files in gzip format can be padded with trailing zero bytes; the
gzip module will now consume these trailing bytes. (Fixed by
Tadek Pietraszek and Brian Curtin; bpo-2846.)
New attribute: the hashlib module now has an algorithms
attribute containing a tuple naming the supported algorithms.
In Python 2.7, hashlib.algorithms contains
('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512').
(Contributed by Carl Chenet; bpo-7418.)
The default HTTPResponse class used by the httplib module now
supports buffering, resulting in much faster reading of HTTP responses.
(Contributed by Kristján Valur Jónsson; bpo-4879.)
The HTTPConnection and HTTPSConnection classes
now support a source_address parameter, a (host, port) 2-tuple
giving the source address that will be used for the connection.
(Contributed by Eldon Ziegler; bpo-3972.)
The ihooks module now supports relative imports. Note that
ihooks is an older module for customizing imports,
superseded by the imputil module added in Python 2.0.
(Relative import support added by Neil Schemenauer.)
The imaplib module now supports IPv6 addresses.
(Contributed by Derek Morr; bpo-1655.)
New function: the inspect module’s getcallargs()
takes a callable and its positional and keyword arguments,
and figures out which of the callable’s parameters will receive each argument,
returning a dictionary mapping argument names to their values. For example:
>>> from inspect import getcallargs
>>> def f(a, b=1, *pos, **named):
... pass
>>> getcallargs(f, 1, 2, 3)
{'a': 1, 'b': 2, 'pos': (3,), 'named': {}}
>>> getcallargs(f, a=2, x=4)
{'a': 2, 'b': 1, 'pos': (), 'named': {'x': 4}}
>>> getcallargs(f)
Traceback (most recent call last):
...
TypeError: f() takes at least 1 argument (0 given)
Contributed by George Sakkis; bpo-3135.
Updated module: The io library has been upgraded to the version shipped with
Python 3.1. For 3.1, the I/O library was entirely rewritten in C
and is 2 to 20 times faster depending on the task being performed. The
original Python version was renamed to the _pyio module.
One minor resulting change: the io.TextIOBase class now
has an errors attribute giving the error setting
used for encoding and decoding errors (one of 'strict', 'replace',
'ignore').
The io.FileIO class now raises an OSError when passed
an invalid file descriptor. (Implemented by Benjamin Peterson;
bpo-4991.) The truncate() method now preserves the
file position; previously it would change the file position to the
end of the new file. (Fixed by Pascal Chambon; bpo-6939.)
New function: itertools.compress(data, selectors) takes two
iterators. Elements of data are returned if the corresponding
value in selectors is true:
itertools.compress('ABCDEF', [1,0,1,0,1,1]) =>
A, C, E, F
New function: itertools.combinations_with_replacement(iter, r)
returns all the possible r-length combinations of elements from the
iterable iter. Unlike combinations(), individual elements
can be repeated in the generated combinations:
itertools.combinations_with_replacement('abc', 2) =>
('a', 'a'), ('a', 'b'), ('a', 'c'),
('b', 'b'), ('b', 'c'), ('c', 'c')
Note that elements are treated as unique depending on their position
in the input, not their actual values.
The itertools.count() function now has a step argument that
allows incrementing by values other than 1. count() also
now allows keyword arguments, and using non-integer values such as
floats or Decimal instances. (Implemented by Raymond
Hettinger; bpo-5032.)
itertools.combinations() and itertools.product()
previously raised ValueError for values of r larger than
the input iterable. This was deemed a specification error, so they
now return an empty iterator. (Fixed by Raymond Hettinger; bpo-4816.)
Updated module: The json module was upgraded to version 2.0.9 of the
simplejson package, which includes a C extension that makes
encoding and decoding faster.
(Contributed by Bob Ippolito; bpo-4136.)
To support the new collections.OrderedDict type, json.load()
now has an optional object_pairs_hook parameter that will be called
with any object literal that decodes to a list of pairs.
(Contributed by Raymond Hettinger; bpo-5381.)
The mailbox module’s Maildir class now records the
timestamp on the directories it reads, and only re-reads them if the
modification time has subsequently changed. This improves
performance by avoiding unneeded directory scans. (Fixed by
A.M. Kuchling and Antoine Pitrou; bpo-1607951, bpo-6896.)
New functions: the math module gained
erf() and erfc() for the error function and the complementary error function,
expm1() which computes e**x - 1 with more precision than
using exp() and subtracting 1,
gamma() for the Gamma function, and
lgamma() for the natural log of the Gamma function.
(Contributed by Mark Dickinson and nirinA raseliarison; bpo-3366.)
The multiprocessing module’s Manager* classes
can now be passed a callable that will be called whenever
a subprocess is started, along with a set of arguments that will be
passed to the callable.
(Contributed by lekma; bpo-5585.)
The Pool class, which controls a pool of worker processes,
now has an optional maxtasksperchild parameter. Worker processes
will perform the specified number of tasks and then exit, causing the
Pool to start a new worker. This is useful if tasks may leak
memory or other resources, or if some tasks will cause the worker to
become very large.
(Contributed by Charles Cazabon; bpo-6963.)
The nntplib module now supports IPv6 addresses.
(Contributed by Derek Morr; bpo-1664.)
New functions: the os module wraps the following POSIX system
calls: getresgid() and getresuid(), which return the
real, effective, and saved GIDs and UIDs;
setresgid() and setresuid(), which set
real, effective, and saved GIDs and UIDs to new values;
initgroups(), which initialize the group access list
for the current process. (GID/UID functions
contributed by Travis H.; bpo-6508. Support for initgroups added
by Jean-Paul Calderone; bpo-7333.)
The os.fork() function now re-initializes the import lock in
the child process; this fixes problems on Solaris when fork()
is called from a thread. (Fixed by Zsolt Cserna; bpo-7242.)
In the os.path module, the normpath() and
abspath() functions now preserve Unicode; if their input path
is a Unicode string, the return value is also a Unicode string.
(normpath() fixed by Matt Giuca in bpo-5827;
abspath() fixed by Ezio Melotti in bpo-3426.)
The pydoc module now has help for the various symbols that Python
uses. You can now do help('<<') or help('@'), for example.
(Contributed by David Laban; bpo-4739.)
The re module’s split(), sub(), and subn()
now accept an optional flags argument, for consistency with the
other functions in the module. (Added by Gregory P. Smith.)
New function: run_path() in the runpy module
will execute the code at a provided path argument. path can be
the path of a Python source file (example.py), a compiled
bytecode file (example.pyc), a directory
(./package/), or a zip archive (example.zip). If a
directory or zip path is provided, it will be added to the front of
sys.path and the module __main__ will be imported. It’s
expected that the directory or zip contains a __main__.py;
if it doesn’t, some other __main__.py might be imported from
a location later in sys.path. This makes more of the machinery
of runpy available to scripts that want to mimic the way
Python’s command line processes an explicit path name.
(Added by Nick Coghlan; bpo-6816.)
New function: in the shutil module, make_archive()
takes a filename, archive type (zip or tar-format), and a directory
path, and creates an archive containing the directory’s contents.
(Added by Tarek Ziadé.)
shutil’s copyfile() and copytree()
functions now raise a SpecialFileError exception when
asked to copy a named pipe. Previously the code would treat
named pipes like a regular file by opening them for reading, and
this would block indefinitely. (Fixed by Antoine Pitrou; bpo-3002.)
The signal module no longer re-installs the signal handler
unless this is truly necessary, which fixes a bug that could make it
impossible to catch the EINTR signal robustly. (Fixed by
Charles-Francois Natali; bpo-8354.)
New functions: in the site module, three new functions
return various site- and user-specific paths.
getsitepackages() returns a list containing all
global site-packages directories,
getusersitepackages() returns the path of the user’s
site-packages directory, and
getuserbase() returns the value of the USER_BASE
environment variable, giving the path to a directory that can be used
to store data.
(Contributed by Tarek Ziadé; bpo-6693.)
The site module now reports exceptions occurring
when the sitecustomize module is imported, and will no longer
catch and swallow the KeyboardInterrupt exception. (Fixed by
Victor Stinner; bpo-3137.)
The create_connection() function
gained a source_address parameter, a (host, port) 2-tuple
giving the source address that will be used for the connection.
(Contributed by Eldon Ziegler; bpo-3972.)
The recv_into() and recvfrom_into()
methods will now write into objects that support the buffer API, most usefully
the bytearray and memoryview objects. (Implemented by
Antoine Pitrou; bpo-8104.)
The SocketServer module’s TCPServer class now
supports socket timeouts and disabling the Nagle algorithm.
The disable_nagle_algorithm class attribute
defaults to False; if overridden to be true,
new request connections will have the TCP_NODELAY option set to
prevent buffering many small sends into a single TCP packet.
The timeout class attribute can hold
a timeout in seconds that will be applied to the request socket; if
no request is received within that time, handle_timeout()
will be called and handle_request() will return.
(Contributed by Kristján Valur Jónsson; bpo-6192 and bpo-6267.)
Updated module: the sqlite3 module has been updated to
version 2.6.0 of the pysqlite package. Version 2.6.0 includes a number of bugfixes, and adds
the ability to load SQLite extensions from shared libraries.
Call the enable_load_extension(True) method to enable extensions,
and then call load_extension() to load a particular shared library.
(Updated by Gerhard Häring.)
The ssl module’s SSLSocket objects now support the
buffer API, which fixed a test suite failure (fix by Antoine Pitrou;
bpo-7133) and automatically set
OpenSSL’s SSL_MODE_AUTO_RETRY, which will prevent an error
code being returned from recv() operations that trigger an SSL
renegotiation (fix by Antoine Pitrou; bpo-8222).
The ssl.wrap_socket() constructor function now takes a
ciphers argument that’s a string listing the encryption algorithms
to be allowed; the format of the string is described
in the OpenSSL documentation.
(Added by Antoine Pitrou; bpo-8322.)
Another change makes the extension load all of OpenSSL’s ciphers and
digest algorithms so that they’re all available. Some SSL
certificates couldn’t be verified, reporting an “unknown algorithm”
error. (Reported by Beda Kosata, and fixed by Antoine Pitrou;
bpo-8484.)
The version of OpenSSL being used is now available as the module
attributes ssl.OPENSSL_VERSION (a string),
ssl.OPENSSL_VERSION_INFO (a 5-tuple), and
ssl.OPENSSL_VERSION_NUMBER (an integer). (Added by Antoine
Pitrou; bpo-8321.)
The struct module will no longer silently ignore overflow
errors when a value is too large for a particular integer format
code (one of bBhHiIlLqQ); it now always raises a
struct.error exception. (Changed by Mark Dickinson;
bpo-1523.) The pack() function will also
attempt to use __index__() to convert and pack non-integers
before trying the __int__() method or reporting an error.
(Changed by Mark Dickinson; bpo-8300.)
New function: the subprocess module’s
check_output() runs a command with a specified set of arguments
and returns the command’s output as a string when the command runs without
error, or raises a CalledProcessError exception otherwise.
>>> subprocess.check_output(['df', '-h', '.'])
'Filesystem Size Used Avail Capacity Mounted on\n
/dev/disk0s2 52G 49G 3.0G 94% /\n'
>>> subprocess.check_output(['df', '-h', '/bogus'])
...
subprocess.CalledProcessError: Command '['df', '-h', '/bogus']' returned non-zero exit status 1
(Contributed by Gregory P. Smith.)
The subprocess module will now retry its internal system calls
on receiving an EINTR signal. (Reported by several people; final
patch by Gregory P. Smith in bpo-1068268.)
New function: is_declared_global() in the symtable module
returns true for variables that are explicitly declared to be global,
false for ones that are implicitly global.
(Contributed by Jeremy Hylton.)
The syslog module will now use the value of sys.argv[0] as the
identifier instead of the previous default value of 'python'.
(Changed by Sean Reifschneider; bpo-8451.)
The sys.version_info value is now a named tuple, with attributes
named major, minor, micro,
releaselevel, and serial. (Contributed by Ross
Light; bpo-4285.)
sys.getwindowsversion() also returns a named tuple,
with attributes named major, minor, build,
platform, service_pack, service_pack_major,
service_pack_minor, suite_mask, and
product_type. (Contributed by Brian Curtin; bpo-7766.)
The tarfile module’s default error handling has changed, to
no longer suppress fatal errors. The default error level was previously 0,
which meant that errors would only result in a message being written to the
debug log, but because the debug log is not activated by default,
these errors go unnoticed. The default error level is now 1,
which raises an exception if there’s an error.
(Changed by Lars Gustäbel; bpo-7357.)
tarfile now supports filtering the TarInfo
objects being added to a tar file. When you call add(),
you may supply an optional filter argument
that’s a callable. The filter callable will be passed the
TarInfo for every file being added, and can modify and return it.
If the callable returns None, the file will be excluded from the
resulting archive. This is more powerful than the existing
exclude argument, which has therefore been deprecated.
(Added by Lars Gustäbel; bpo-6856.)
The TarFile class also now supports the context management protocol.
(Added by Lars Gustäbel; bpo-7232.)
The wait() method of the threading.Event class
now returns the internal flag on exit. This means the method will usually
return true because wait() is supposed to block until the
internal flag becomes true. The return value will only be false if
a timeout was provided and the operation timed out.
(Contributed by Tim Lesher; bpo-1674032.)
The Unicode database provided by the unicodedata module is
now used internally to determine which characters are numeric,
whitespace, or represent line breaks. The database also
includes information from the Unihan.txt data file (patch
by Anders Chrigström and Amaury Forgeot d’Arc; bpo-1571184)
and has been updated to version 5.2.0 (updated by
Florent Xicluna; bpo-8024).
The urlparse module’s urlsplit() now handles
unknown URL schemes in a fashion compliant with RFC 3986: if the
URL is of the form "<something>://...", the text before the
:// is treated as the scheme, even if it’s a made-up scheme that
the module doesn’t know about. This change may break code that
worked around the old behaviour. For example, Python 2.6.4 or 2.5
will return the following:
>>> import urlparse
>>> urlparse.urlsplit('invented://host/filename?query')
('invented', '', '//host/filename?query', '', '')
Python 2.7 (and Python 2.6.5) will return:
>>> import urlparse
>>> urlparse.urlsplit('invented://host/filename?query')
('invented', 'host', '/filename?query', '', '')
(Python 2.7 actually produces slightly different output, since it
returns a named tuple instead of a standard tuple.)
The urlparse module also supports IPv6 literal addresses as defined by
RFC 2732 (contributed by Senthil Kumaran; bpo-2987).
>>> urlparse.urlparse('http://[1080::8:800:200C:417A]/foo')
ParseResult(scheme='http', netloc='[1080::8:800:200C:417A]',
path='/foo', params='', query='', fragment='')
New class: the WeakSet class in the weakref
module is a set that only holds weak references to its elements; elements
will be removed once there are no references pointing to them.
(Originally implemented in Python 3.x by Raymond Hettinger, and backported
to 2.7 by Michael Foord.)
The ElementTree library, xml.etree, no longer escapes
ampersands and angle brackets when outputting an XML processing
instruction (which looks like <?xml-stylesheet href="#style1"?>)
or comment (which looks like <!-- comment -->).
(Patch by Neil Muller; bpo-2746.)
The XML-RPC client and server, provided by the xmlrpclib and
SimpleXMLRPCServer modules, have improved performance by
supporting HTTP/1.1 keep-alive and by optionally using gzip encoding
to compress the XML being exchanged. The gzip compression is
controlled by the encode_threshold attribute of
SimpleXMLRPCRequestHandler, which contains a size in bytes;
responses larger than this will be compressed.
(Contributed by Kristján Valur Jónsson; bpo-6267.)
The zipfile module’s ZipFile now supports the context
management protocol, so you can write with zipfile.ZipFile(...) as f:.
(Contributed by Brian Curtin; bpo-5511.)
zipfile now also supports archiving empty directories and
extracts them correctly. (Fixed by Kuba Wieczorek; bpo-4710.)
Reading files out of an archive is faster, and interleaving
read() and readline() now works correctly.
(Contributed by Nir Aides; bpo-7610.)
The is_zipfile() function now
accepts a file object, in addition to the path names accepted in earlier
versions. (Contributed by Gabriel Genellina; bpo-4756.)
The writestr() method now has an optional compress_type parameter
that lets you override the default compression method specified in the
ZipFile constructor. (Contributed by Ronald Oussoren;
bpo-6003.)
Updated module: unittest
The unittest module was greatly enhanced; many
new features were added. Most of these features were implemented
by Michael Foord, unless otherwise noted. The enhanced version of
the module is downloadable separately for use with Python versions 2.4 to 2.6,
packaged as the unittest2 package, from
https://pypi.org/project/unittest2.
When used from the command line, the module can automatically discover
tests. It’s not as fancy as py.test or
nose, but provides a
simple way to run tests kept within a set of package directories. For example,
the following command will search the test/ subdirectory for
any importable test files named test*.py:
python -m unittest discover -s test
Consult the unittest module documentation for more details.
(Developed in bpo-6001.)
The main() function supports some other new options:
-b or --buffer will buffer the standard output
and standard error streams during each test. If the test passes,
any resulting output will be discarded; on failure, the buffered
output will be displayed.
-c or --catch will cause the control-C interrupt
to be handled more gracefully. Instead of interrupting the test
process immediately, the currently running test will be completed
and then the partial results up to the interruption will be reported.
If you’re impatient, a second press of control-C will cause an immediate
interruption.
This control-C handler tries to avoid causing problems when the code
being tested or the tests being run have defined a signal handler of
their own, by noticing that a signal handler was already set and
calling it. If this doesn’t work for you, there’s a
removeHandler() decorator that can be used to mark tests that
should have the control-C handling disabled.
-f or --failfast makes
test execution stop immediately when a test fails instead of
continuing to execute further tests. (Suggested by Cliff Dyer and
implemented by Michael Foord; bpo-8074.)
The progress messages now show ‘x’ for expected failures
and ‘u’ for unexpected successes when run in verbose mode.
(Contributed by Benjamin Peterson.)
Test cases can raise the SkipTest exception to skip a
test (bpo-1034053).
The error messages for assertEqual(),
assertTrue(), and assertFalse()
failures now provide more information. If you set the
longMessage attribute of your TestCase classes to
true, both the standard error message and any additional message you
provide will be printed for failures. (Added by Michael Foord; bpo-5663.)
The assertRaises() method now
returns a context handler when called without providing a callable
object to run. For example, you can write this:
with self.assertRaises(KeyError):
{}['foo']
(Implemented by Antoine Pitrou; bpo-4444.)
Module- and class-level setup and teardown fixtures are now supported.
Modules can contain setUpModule() and tearDownModule()
functions. Classes can have setUpClass() and
tearDownClass() methods that must be defined as class methods
(using @classmethod or equivalent). These functions and
methods are invoked when the test runner switches to a test case in a
different module or class.
The methods addCleanup() and
doCleanups() were added.
addCleanup() lets you add cleanup functions that
will be called unconditionally (after setUp() if
setUp() fails, otherwise after tearDown()). This allows
for much simpler resource allocation and deallocation during tests
(bpo-5679).
A number of new methods were added that provide more specialized
tests. Many of these methods were written by Google engineers
for use in their test suites; Gregory P. Smith, Michael Foord, and
GvR worked on merging them into Python’s version of unittest.
assertIsNone() and assertIsNotNone() take one
expression and verify that the result is or is not None.
assertIs() and assertIsNot()
take two values and check whether the two values evaluate to the same object or not.
(Added by Michael Foord; bpo-2578.)
assertIsInstance() and
assertNotIsInstance() check whether
the resulting object is an instance of a particular class, or of
one of a tuple of classes. (Added by Georg Brandl; bpo-7031.)
assertGreater(), assertGreaterEqual(),
assertLess(), and assertLessEqual() compare
two quantities.
assertMultiLineEqual() compares two strings, and if they’re
not equal, displays a helpful comparison that highlights the
differences in the two strings. This comparison is now used by
default when Unicode strings are compared with assertEqual().
assertRegexpMatches() and
assertNotRegexpMatches() checks whether the
first argument is a string matching or not matching the regular
expression provided as the second argument (bpo-8038).
assertRaisesRegexp() checks whether a particular exception
is raised, and then also checks that the string representation of
the exception matches the provided regular expression.
assertIn() and assertNotIn()
tests whether first is or is not in second.
assertItemsEqual() tests whether two provided sequences
contain the same elements.
assertSetEqual() compares whether two sets are equal, and
only reports the differences between the sets in case of error.
- Similarly,
assertListEqual() and assertTupleEqual()
compare the specified types and explain any differences without necessarily
printing their full values; these methods are now used by default
when comparing lists and tuples using assertEqual().
More generally, assertSequenceEqual() compares two sequences
and can optionally check whether both sequences are of a
particular type.
assertDictEqual() compares two dictionaries and reports the
differences; it’s now used by default when you compare two dictionaries
using assertEqual(). assertDictContainsSubset() checks whether
all of the key/value pairs in first are found in second.
assertAlmostEqual() and assertNotAlmostEqual() test
whether first and second are approximately equal. This method
can either round their difference to an optionally-specified number
of places (the default is 7) and compare it to zero, or require
the difference to be smaller than a supplied delta value.
loadTestsFromName() properly honors the
suiteClass attribute of
the TestLoader. (Fixed by Mark Roddy; bpo-6866.)
- A new hook lets you extend the
assertEqual() method to handle
new data types. The addTypeEqualityFunc() method takes a type
object and a function. The function will be used when both of the
objects being compared are of the specified type. This function
should compare the two objects and raise an exception if they don’t
match; it’s a good idea for the function to provide additional
information about why the two objects aren’t matching, much as the new
sequence comparison methods do.
unittest.main() now takes an optional exit argument. If
false, main() doesn’t call sys.exit(), allowing
main() to be used from the interactive interpreter.
(Contributed by J. Pablo Fernández; bpo-3379.)
TestResult has new startTestRun() and
stopTestRun() methods that are called immediately before
and after a test run. (Contributed by Robert Collins; bpo-5728.)
With all these changes, the unittest.py was becoming awkwardly
large, so the module was turned into a package and the code split into
several files (by Benjamin Peterson). This doesn’t affect how the
module is imported or used.