What's New in Python 2.2.1 final?

Release date: XX-Apr-2002

=================================

Core and builtins

- Added new builtin function bool() and new builtin constants True and

False to ease backporting of code developed for Python 2.3. In 2.2,

bool() returns 1 or 0, True == 1, and False == 0.

- Fixed super() to work correctly with class methods. [SF bug #535444]

- Fixed two bugs reported as SF #535905: under certain conditions,

deallocating a deeply nested structure could cause a segfault in the

garbage collector, due to interaction with the "trashcan" code;

access to the current frame during destruction of a local variable

could access a pointer to freed memory.

Library

- The xml.sax.expatreader.ExpatParser class will no longer create

circular references by using itself as the locator that gets passed

to the content handler implementation. [SF bug #535474]

C API

- A type can now inherit its metatype from its base type. Previously,

when PyType_Ready() was called, if ob_type was found to be NULL, it

was always set to &PyType_Type; now it is set to base->ob_type,

where base is tp_base, defaulting to &PyObject_Type.

- PyType_Ready() accidentally did not inherit tp_is_gc; now it does.

Windows

- Fixed a bug in urllib's proxy handling in Windows. [SF bug #503031]

- The installer now installs Start menu shortcuts under (the local

equivalent of) "All Users" when doing an Admin install.

What's New in Python 2.2.1c2?

Release date: 26-Mar-2002

=============================

There were a bunch of mostly minor fixes between 2.2.1c1 and 2.2.1c2,

including:

- I remembered to run autoconf before cutting the release tarball.

Core and builtins

- The floating point behavior fix-up continued into complex_pow.

Library

- The email package bug #531966 was fixed. This caused exceptions to

occur when flattening multipart/* messages with zero or one (scalar)

attachment.

- Support for https: urls in httplib was broken (by the sendall patch

mentioned below).

- Minor bugs in the calendar module were fixed.

- A few minor bugs in pydoc were fixed (better url recognition, proper

quoting of some elements).

- Some distutils commands didn't list all their "boolean options"

which made overriding them from .cfg files not work.

What's New in Python 2.2.1c1?

Release date: 18-Mar-2002

=============================

This is primarily a bugfix release. Many bugs have been fixed since

the release of 2.2 final. Some of the more notable are listed here.

Core and builtins

- If you try to pickle an instance of a class that has __slots__ but

doesn't define or override __getstate__, a TypeError is now raised.

This is done by adding a bozo __getstate__ to the class that always

raises TypeError. (Before, this would appear to be pickled, but the

state of the slots would be lost.)

- (1).__nonzero__() would dump core.

- Tim has had another go at getting sensible behaviour with respect to

floating point underflow/overflow.

- Adding an instance of subclass of int to, say, a string, could

erroneously return "NotImplemented" instead of raising a TypeError.

- Subclassing longs could cause core dumps in certain circumstances.

- PyErr_Display will provide file and line information for all

exceptions that have an attribute print_file_and_line, not just

SyntaxErrors. This fixes the bug that no proper line number is given

for bad \x escapes.

- sys.setprofile() and sys.settrace() would dump core if called with

no arguments.

- An obscure & small memory overrun in wide unicode builds have been

fixed.

- __doc__ can now be of arbitrary type (in particular, it can be a

unicode string).

- complex objects are now immutable (as they should always have been).

Extension modules

- A security hole ("double free") was found in zlib-1.1.3, a popular

third party compression library used by some Python modules. The

hole was quickly plugged in zlib-1.1.4, and the Windows build of

Python 2.2.1 now ships with zlib-1.1.4.

- new.instancemethod no longer fails for new-style classes.

- The "pseudo-sequences" returned by os.stat(), os.fstat(),

time.localtime() can now be pickled.

- Due to a cut and paste error the object exported as

posix.statvfs_result was in fact posix.stat_result.

Library

- The copy module can be used in restricted execution mode.

- A few bugs in the email package have been fixed.

- StringIO's attitude to unicode strings has been reverted to that of

the 2.1.x branch (note cStringIO still knows nothing about unicode).

- webbrowser: tightened up the command passed to os.system() so that

arbitrary shell code can't be executed because a bogus URL was

passed in.

- Recursive structures containing new-style classes can now by

deep-copied.

- ftplib defaults to passive mode (again).

Tools

- Bugs in IDLE's autoindent when using new-style division were fixed.

What's New in Python 2.2 final?

Release date: 21-Dec-2001

===============================

Type/class unification and new-style classes

- pickle.py, cPickle: allow pickling instances of new-style classes

with a custom metaclass.

Core and builtins

- weakref proxy object: when comparing, unwrap both arguments if both

are proxies.

Extension modules

- binascii.b2a_base64(): fix a potential buffer overrun when encoding

very short strings.

- cPickle: the obscure "fast" mode was suspected of causing stack

overflows on the Mac. Hopefully fixed this by setting the recursion

limit much smaller. If the limit is too low (it only affects

performance), you can change it by defining PY_CPICKLE_FAST_LIMIT

when compiling cPickle.c (or in pyconfig.h).

Library

- dumbdbm.py: fixed a dumb old bug (the file didn't get synched at

close or delete time).

- rfc822.py: fixed a bug where the address '<>' was converted to None

instead of an empty string (also fixes the email.Utils module).

- xmlrpclib.py: version 1.0.0; uses precision for doubles.

- test suite: the pickle and cPickle tests were not executing any code

when run from the standard regresssion test.

Tools/Demos

Build

C API

New platforms

Tests

Windows

- distutils package: fixed broken Windows installers (bdist_wininst).

- tempfile.py: prevent mysterious warnings when TemporaryFileWrapper

instances are deleted at process exit time.

- socket.py: prevent mysterious warnings when socket instances are

deleted at process exit time.

- posixmodule.c: fix a Windows crash with stat() of a filename ending

in backslash.

Mac

- The Carbon toolbox modules have been upgraded to Universal Headers

3.4, and experimental CoreGraphics and CarbonEvents modules have

been added. All only for framework-enabled MacOSX.

What's New in Python 2.2c1?

Release date: 14-Dec-2001

===========================

Type/class unification and new-style classes

- Guido's tutorial introduction to the new type/class features has

been extensively updated. See

http://www.python.org/2.2/descrintro.html

That remains the primary documentation in this area.

- Fixed a leak: instance variables declared with __slots__ were never

deleted!

- The "delete attribute" method of descriptor objects is called

__delete__, not __del__. In previous releases, it was mistakenly

called __del__, which created an unfortunate overloading condition

with finalizers. (The "get attribute" and "set attribute" methods

are still called __get__ and __set__, respectively.)

- Some subtle issues with the super built-in were fixed:

(a) When super itself is subclassed, its __get__ method would still

return an instance of the base class (i.e., of super).

(b) super(C, C()).__class__ would return C rather than super. This

is confusing. To fix this, I decided to change the semantics of

super so that it only applies to code attributes, not to data

attributes. After all, overriding data attributes is not

supported anyway.

(c) The __get__ method didn't check whether the argument was an

instance of the type used in creation of the super instance.

- Previously, hash() of an instance of a subclass of a mutable type

(list or dictionary) would return some value, rather than raising

TypeError. This has been fixed. Also, directly calling

dict.__hash__ and list.__hash__ now raises the same TypeError

(previously, these were the same as object.__hash__).

- New-style objects now support deleting their __dict__. This is for

all intents and purposes equivalent to assigning a brand new empty

dictionary, but saves space if the object is not used further.

Core and builtins

- -Qnew now works as documented in PEP 238: when -Qnew is passed on

the command line, all occurrences of "/" use true division instead

of classic division. See the PEP for details. Note that "all"

means all instances in library and 3rd-party modules, as well as in

your own code. As the PEP says, -Qnew is intended for use only in

educational environments with control over the libraries in use.

Note that test_coercion.py in the standard Python test suite fails

under -Qnew; this is expected, and won't be repaired until true

division becomes the default (in the meantime, test_coercion is

testing the current rules).

- complex() now only allows the first argument to be a string

argument, and raises TypeError if either the second arg is a string

or if the second arg is specified when the first is a string.

Extension modules

- gc.get_referents was renamed to gc.get_referrers.

Library

- Functions in the os.spawn() family now release the global interpreter

lock around calling the platform spawn. They should always have done

this, but did not before 2.2c1. Multithreaded programs calling

an os.spawn function with P_WAIT will no longer block all Python threads

until the spawned program completes. It's possible that some programs

relies on blocking, although more likely by accident than by design.

- webbrowser defaults to netscape.exe on OS/2 now.

- Tix.ResizeHandle exposes detach_widget, hide, and show.

- The charset alias windows_1252 has been added.

- types.StringTypes is a tuple containing the defined string types;

usually this will be (str, unicode), but if Python was compiled

without Unicode support it will be just (str,).

- The pulldom and minidom modules were synchronized to PyXML.

Tools/Demos

- A new script called Tools/scripts/google.py was added, which fires

off a search on Google.

Build

- Note that release builds of Python should arrange to define the

preprocessor symbol NDEBUG on the command line (or equivalent).

In the 2.2 pre-release series we tried to define this by magic in

Python.h instead, but it proved to cause problems for extension

authors. The Unix, Windows and Mac builds now all define NDEBUG in

release builds via cmdline (or equivalent) instead. Ports to

other platforms should do likewise.

- It is no longer necessary to use --with-suffix when building on a

case-insensitive file system (such as Mac OS X HFS+). In the build

directory an extension is used, but not in the installed python.

C API

- New function PyDict_MergeFromSeq2() exposes the builtin dict

constructor's logic for updating a dictionary from an iterable object

producing key-value pairs.

- PyArg_ParseTupleAndKeywords() requires that the number of entries in

the keyword list equal the number of argument specifiers. This

wasn't checked correctly, and PyArg_ParseTupleAndKeywords could even

dump core in some bad cases. This has been repaired. As a result,

PyArg_ParseTupleAndKeywords may raise RuntimeError in bad cases that

previously went unchallenged.

New platforms

Tests

Windows

Mac

- In unix-Python on Mac OS X (and darwin) sys.platform is now "darwin",

without any trailing digits.

- Changed logic for finding python home in Mac OS X framework Pythons.

Now sys.executable points to the executable again, in stead of to

the shared library. The latter is used only for locating the python

home.

What's New in Python 2.2b2?

Release date: 16-Nov-2001

===========================

Type/class unification and new-style classes

- Multiple inheritance mixing new-style and classic classes in the

list of base classes is now allowed, so this works now:

class Classic: pass

class Mixed(Classic, object): pass

The MRO (method resolution order) for each base class is respected

according to its kind, but the MRO for the derived class is computed

using new-style MRO rules if any base clase is a new-style class.

This needs to be documented.

- The new builtin dictionary() constructor, and dictionary type, have

been renamed to dict. This reflects a decade of common usage.

- dict() now accepts an iterable object producing 2-sequences. For

example, dict(d.items()) == d for any dictionary d. The argument,

and the elements of the argument, can be any iterable objects.

- New-style classes can now have a __del__ method, which is called

when the instance is deleted (just like for classic classes).

- Assignment to object.__dict__ is now possible, for objects that are

instances of new-style classes that have a __dict__ (unless the base

class forbids it).

- Methods of built-in types now properly check for keyword arguments

(formerly these were silently ignored). The only built-in methods

that take keyword arguments are __call__, __init__ and __new__.

- The socket function has been converted to a type; see below.

Core and builtins

- Assignment to __debug__ raises SyntaxError at compile-time. This

was promised when 2.1c1 was released as "What's New in Python 2.1c1"

(see below) says.

- Clarified the error messages for unsupported operands to an operator

(like 1 + '').

Extension modules

- mmap has a new keyword argument, "access", allowing a uniform way for

both Windows and Unix users to create read-only, write-through and

copy-on-write memory mappings. This was previously possible only on

Unix. A new keyword argument was required to support this in a

uniform way because the mmap() signuatures had diverged across

platforms. Thanks to Jay T Miller for repairing this!

- By default, the gc.garbage list now contains only those instances in

unreachable cycles that have __del__ methods; in 2.1 it contained all

instances in unreachable cycles. "Instances" here has been generalized

to include instances of both new-style and old-style classes.

- The socket module defines a new method for socket objects,

sendall(). This is like send() but may make multiple calls to

send() until all data has been sent. Also, the socket function has

been converted to a subclassable type, like list and tuple (etc.)

before it; socket and SocketType are now the same thing.

- Various bugfixes to the curses module. There is now a test suite

for the curses module (you have to run it manually).

- binascii.b2a_base64 no longer places an arbitrary restriction of 57

bytes on its input.

Library

- tkFileDialog exposes a Directory class and askdirectory

convenience function.

- Symbolic group names in regular expressions must be unique. For

example, the regexp r'(?P<abc>)(?P<abc>)' is not allowed, because a

single name can't mean both "group 1" and "group 2" simultaneously.

Python 2.2 detects this error at regexp compilation time;

previously, the error went undetected, and results were

unpredictable. Also in sre, the pattern.split(), pattern.sub(), and

pattern.subn() methods have been rewritten in C. Also, an

experimental function/method finditer() has been added, which works

like findall() but returns an iterator.

- Tix exposes more commands through the classes DirSelectBox,

DirSelectDialog, ListNoteBook, Meter, CheckList, and the

methods tix_addbitmapdir, tix_cget, tix_configure, tix_filedialog,

tix_getbitmap, tix_getimage, tix_option_get, and tix_resetoptions.

- Traceback objects are now scanned by cyclic garbage collection, so

cycles created by casual use of sys.exc_info() no longer cause

permanent memory leaks (provided garbage collection is enabled).

- os.extsep -- a new variable needed by the RISCOS support. It is the

separator used by extensions, and is '.' on all platforms except

RISCOS, where it is '/'. There is no need to use this variable

unless you have a masochistic desire to port your code to RISCOS.

- mimetypes.py has optional support for non-standard, but commonly

found types. guess_type() and guess_extension() now accept an

optional `strict' flag, defaulting to true, which controls whether

recognize non-standard types or not. A few non-standard types we

know about have been added. Also, when run as a script, there are

new -l and -e options.

- statcache is now deprecated.

- email.Utils.formatdate() now produces the preferred RFC 2822 style

dates with numeric timezones (it used to produce obsolete dates

hard coded to "GMT" timezone). An optional `localtime' flag is

added to produce dates in the local timezone, with daylight savings

time properly taken into account.

- In pickle and cPickle, instead of masking errors in load() by

transforming them into SystemError, we let the original exception

propagate out. Also, implement support for __safe_for_unpickling__

in pickle, as it already was supported in cPickle.

Tools/Demos

Build

- The dbm module is built using libdb1 if available. The bsddb module

is built with libdb3 if available.

- Misc/Makefile.pre.in has been removed by BDFL pronouncement.

C API

- New function PySequence_Fast_GET_SIZE() returns the size of a non-

NULL result from PySequence_Fast(), more quickly than calling

PySequence_Size().

- New argument unpacking function PyArg_UnpackTuple() added.

- New functions PyObject_CallFunctionObjArgs() and

PyObject_CallMethodObjArgs() have been added to make it more

convenient and efficient to call functions and methods from C.

- PyArg_ParseTupleAndKeywords() no longer masks errors, so it's

possible that this will propagate errors it didn't before.

- New function PyObject_CheckReadBuffer(), which returns true if its

argument supports the single-segment readable buffer interface.

New platforms

- We've finally confirmed that this release builds on HP-UX 11.00,

*with* threads, and passes the test suite.

- Thanks to a series of patches from Michael Muller, Python may build

again under OS/2 Visual Age C++.

- Updated RISCOS port by Dietmar Schwertberger.

Tests

- Added a test script for the curses module. It isn't run automatically;

regrtest.py must be run with '-u curses' to enable it.

Windows

Mac

- PythonScript has been moved to unsupported and is slated to be

removed completely in the next release.

- It should now be possible to build applets that work on both OS9 and

OSX.

- The core is now linked with CoreServices not Carbon; as a side

result, default 8bit encoding on OSX is now ASCII.

- Python should now build on OSX 10.1.1

What's New in Python 2.2b1?

Release date: 19-Oct-2001

===========================

Type/class unification and new-style classes

- New-style classes are now always dynamic (except for built-in and

extension types). There is no longer a performance penalty, and I

no longer see another reason to keep this baggage around. One relic

remains: the __dict__ of a new-style class is a read-only proxy; you

must set the class's attribute to modify it. As a consequence, the

__defined__ attribute of new-style types no longer exists, for lack

of need: there is once again only one __dict__ (although in the

future a __cache__ may be resurrected with a similar function, if I

can prove that it actually speeds things up).

- C.__doc__ now works as expected for new-style classes (in 2.2a4 it

always returned None, even when there was a class docstring).

- doctest now finds and runs docstrings attached to new-style classes,

class methods, static methods, and properties.

Core and builtins

- A very subtle syntactical pitfall in list comprehensions was fixed.

For example: [a+b for a in 'abc', for b in 'def']. The comma in

this example is a mistake. Previously, this would silently let 'a'

iterate over the singleton tuple ('abc',), yielding ['abcd', 'abce',

'abcf'] rather than the intended ['ad', 'ae', 'af', 'bd', 'be',

'bf', 'cd', 'ce', 'cf']. Now, this is flagged as a syntax error.

Note that [a for a in <singleton>] is a convoluted way to say

[<singleton>] anyway, so it's not like any expressiveness is lost.

- getattr(obj, name, default) now only catches AttributeError, as

documented, rather than returning the default value for all

exceptions (which could mask bugs in a __getattr__ hook, for

example).

- Weak reference objects are now part of the core and offer a C API.

A bug which could allow a core dump when binary operations involved

proxy reference has been fixed. weakref.ReferenceError is now a

built-in exception.

- unicode(obj) now behaves more like str(obj), accepting arbitrary

objects, and calling a __unicode__ method if it exists.

unicode(obj, encoding) and unicode(obj, encoding, errors) still

require an 8-bit string or character buffer argument.

- isinstance() now allows any object as the first argument and a

class, a type or something with a __bases__ tuple attribute for the

second argument. The second argument may also be a tuple of a

class, type, or something with __bases__, in which case isinstance()

will return true if the first argument is an instance of any of the

things contained in the second argument tuple. E.g.

isinstance(x, (A, B))

returns true if x is an instance of A or B.

Extension modules

- thread.start_new_thread() now returns the thread ID (previously None).

- binascii has now two quopri support functions, a2b_qp and b2a_qp.

- readline now supports setting the startup_hook and the

pre_event_hook, and adds the add_history() function.

- os and posix supports chroot(), setgroups() and unsetenv() where

available. The stat(), fstat(), statvfs() and fstatvfs() functions

now return "pseudo-sequences" -- the various fields can now be

accessed as attributes (e.g. os.stat("/").st_mtime) but for

backwards compatibility they also behave as a fixed-length sequence.

Some platform-specific fields (e.g. st_rdev) are only accessible as

attributes.

- time: localtime(), gmtime() and strptime() now return a

pseudo-sequence similar to the os.stat() return value, with

attributes like tm_year etc.

- Decompression objects in the zlib module now accept an optional

second parameter to decompress() that specifies the maximum amount

of memory to use for the uncompressed data.

- optional SSL support in the socket module now exports OpenSSL

functions RAND_add(), RAND_egd(), and RAND_status(). These calls

are useful on platforms like Solaris where OpenSSL does not

automatically seed its PRNG. Also, the keyfile and certfile

arguments to socket.ssl() are now optional.

- posixmodule (and by extension, the os module on POSIX platforms) now

exports O_LARGEFILE, O_DIRECT, O_DIRECTORY, and O_NOFOLLOW.

Library

- doctest now excludes functions and classes not defined by the module

being tested, thanks to Tim Hochberg.

- HotShot, a new profiler implemented using a C-based callback, has

been added. This substantially reduces the overhead of profiling,

but it is still quite preliminary. Support modules and

documentation will be added in upcoming releases (before 2.2 final).

- profile now produces correct output in situations where an exception

raised in Python is cleared by C code (e.g. hasattr()). This used

to cause wrong output, including spurious claims of recursive

functions and attribution of time spent to the wrong function.

The code and documentation for the derived OldProfile and HotProfile

profiling classes was removed. The code hasn't worked for years (if

you tried to use them, they raised exceptions). OldProfile

intended to reproduce the behavior of the profiler Python used more

than 7 years ago, and isn't interesting anymore. HotProfile intended

to provide a faster profiler (but producing less information), and

that's a worthy goal we intend to meet via a different approach (but

without losing information).

- Profile.calibrate() has a new implementation that should deliver

a much better system-specific calibration constant. The constant can

now be specified in an instance constructor, or as a Profile class or

instance variable, instead of by editing profile.py's source code.

Calibration must still be done manually (see the docs for the profile

module).

Note that Profile.calibrate() must be overriden by subclasses.

Improving the accuracy required exploiting detailed knowledge of

profiler internals; the earlier method abstracted away the details

and measured a simplified model instead, but consequently computed

a constant too small by a factor of 2 on some modern machines.

- quopri's encode and decode methods take an optional header parameter,

which indicates whether output is intended for the header 'Q'

encoding.

- The SocketServer.ThreadingMixIn class now closes the request after

finish_request() returns. (Not when it errors out though.)

- The nntplib module's NNTP.body() method has grown a `file' argument

to allow saving the message body to a file.

- The email package has added a class email.Parser.HeaderParser which

only parses headers and does not recurse into the message's body.

Also, the module/class MIMEAudio has been added for representing

audio data (contributed by Anthony Baxter).

- ftplib should be able to handle files > 2GB.

- ConfigParser.getboolean() now also interprets TRUE, FALSE, YES, NO,

ON, and OFF.

- xml.dom.minidom NodeList objects now support the length attribute

and item() method as required by the DOM specifications.

Tools/Demos

- Demo/dns was removed. It no longer serves any purpose; a package

derived from it is now maintained by Anthony Baxter, see

http://PyDNS.SourceForge.net.

- The freeze tool has been made more robust, and two new options have

been added: -X and -E.

Build

- configure will use CXX in LINKCC if CXX is used to build main() and

the system requires to link a C++ main using the C++ compiler.

C API

- The documentation for the tp_compare slot is updated to require that

the return value must be -1, 0, 1; an arbitrary number <0 or >0 is

not correct. This is not yet enforced but will be enforced in

Python 2.3; even later, we may use -2 to indicate errors and +2 for

"NotImplemented". Right now, -1 should be used for an error return.

- PyLong_AsLongLong() now accepts int (as well as long) arguments.

Consequently, PyArg_ParseTuple's 'L' code also accepts int (as well

as long) arguments.

- PyThread_start_new_thread() now returns a long int giving the thread

ID, if one can be calculated; it returns -1 for error, 0 if no

thread ID is calculated (this is an incompatible change, but only

the thread module used this API). This code has only really been

tested on Linux and Windows; other platforms please beware (and

report any bugs or strange behavior).

- PyUnicode_FromEncodedObject() no longer accepts Unicode objects as

input.

New platforms

Tests

Windows

- Installer: If you install IDLE, and don't disable file-extension

registration, a new "Edit with IDLE" context (right-click) menu entry

is created for .py and .pyw files.

- The signal module now supports SIGBREAK on Windows, thanks to Steven

Scott. Note that SIGBREAK is unique to Windows. The default SIGBREAK

action remains to call Win32 ExitProcess(). This can be changed via

signal.signal(). For example:

# Make Ctrl+Break raise KeyboardInterrupt, like Python's default Ctrl+C

# (SIGINT) behavior.

import signal

signal.signal(signal.SIGBREAK,

signal.default_int_handler)

try:

while 1:

pass

except KeyboardInterrupt:

# We get here on Ctrl+C or Ctrl+Break now; if we had not changed

# SIGBREAK, only on Ctrl+C (and Ctrl+Break would terminate the

# program without the possibility for any Python-level cleanup).

print "Clean exit"

What's New in Python 2.2a4?

Release date: 28-Sep-2001

===========================

Type/class unification and new-style classes

- pydoc and inspect are now aware of new-style classes;

e.g. help(list) at the interactive prompt now shows proper

documentation for all operations on list objects.

- Applications using Jim Fulton's ExtensionClass module can now safely

be used with Python 2.2. In particular, Zope 2.4.1 now works with

Python 2.2 (as well as with Python 2.1.1). The Demo/metaclass

examples also work again. It is hoped that Gtk and Boost also work

with 2.2a4 and beyond. (If you can confirm this, please write

webmaster@python.org; if there are still problems, please open a bug

report on SourceForge.)

- property() now takes 4 keyword arguments: fget, fset, fdel and doc.

These map to readonly attributes 'fget', 'fset', 'fdel', and '__doc__'

in the constructed property object. fget, fset and fdel weren't

discoverable from Python in 2.2a3. __doc__ is new, and allows to

associate a docstring with a property.

- Comparison overloading is now more completely implemented. For

example, a str subclass instance can properly be compared to a str

instance, and it can properly overload comparison. Ditto for most

other built-in object types.

- The repr() of new-style classes has changed; instead of <type

'M.Foo'> a new-style class is now rendered as <class 'M.Foo'>,

*except* for built-in types, which are still rendered as <type

'Foo'> (to avoid upsetting existing code that might parse or

otherwise rely on repr() of certain type objects).

- The repr() of new-style objects is now always <Foo object at XXX>;

previously, it was sometimes <Foo instance at XXX>.

- For new-style classes, what was previously called __getattr__ is now

called __getattribute__. This method, if defined, is called for

*every* attribute access. A new __getattr__ hook more similar to the

one in classic classes is defined which is called only if regular

attribute access raises AttributeError; to catch *all* attribute

access, you can use __getattribute__ (for new-style classes). If

both are defined, __getattribute__ is called first, and if it raises

AttributeError, __getattr__ is called.

- The __class__ attribute of new-style objects can be assigned to.

The new class must have the same C-level object layout as the old

class.

- The builtin file type can be subclassed now. In the usual pattern,

"file" is the name of the builtin type, and file() is a new builtin

constructor, with the same signature as the builtin open() function.

file() is now the preferred way to open a file.

- Previously, __new__ would only see sequential arguments passed to

the type in a constructor call; __init__ would see both sequential

and keyword arguments. This made no sense whatsoever any more, so

now both __new__ and __init__ see all arguments.

- Previously, hash() applied to an instance of a subclass of str or

unicode always returned 0. This has been repaired.

- Previously, an operation on an instance of a subclass of an

immutable type (int, long, float, complex, tuple, str, unicode),

where the subtype didn't override the operation (and so the

operation was handled by the builtin type), could return that

instance instead a value of the base type. For example, if s was of

a str sublass type, s[:] returned s as-is. Now it returns a str

with the same value as s.

- Provisional support for pickling new-style objects has been added.

Core

- file.writelines() now accepts any iterable object producing strings.

- PyUnicode_FromEncodedObject() now works very much like

PyObject_Str(obj) in that it tries to use __str__/tp_str

on the object if the object is not a string or buffer. This

makes unicode() behave like str() when applied to non-string/buffer

objects.

- PyFile_WriteObject now passes Unicode objects to the file's write

method. As a result, all file-like objects which may be the target

of a print statement must support Unicode objects, i.e. they must

at least convert them into ASCII strings.

- Thread scheduling on Solaris should be improved; it is no longer

necessary to insert a small sleep at the start of a thread in order

to let other runnable threads be scheduled.

Library

- StringIO.StringIO instances and cStringIO.StringIO instances support

read character buffer compatible objects for their .write() methods.

These objects are converted to strings and then handled as such

by the instances.

- The "email" package has been added. This is basically a port of the

mimelib package <http://sf.net/projects/mimelib> with API changes

and some implementations updated to use iterators and generators.

- difflib.ndiff() and difflib.Differ.compare() are generators now. This

restores the ability of Tools/scripts/ndiff.py to start producing output

before the entire comparison is complete.

- StringIO.StringIO instances and cStringIO.StringIO instances support

iteration just like file objects (i.e. their .readline() method is

called for each iteration until it returns an empty string).

- The codecs module has grown four new helper APIs to access

builtin codecs: getencoder(), getdecoder(), getreader(),

getwriter().

- SimpleXMLRPCServer: a new module (based upon SimpleHTMLServer)

simplifies writing XML RPC servers.

- os.path.realpath(): a new function that returns the absolute pathname

after interpretation of symbolic links. On non-Unix systems, this

is an alias for os.path.abspath().

- operator.indexOf() (PySequence_Index() in the C API) now works with any

iterable object.

- smtplib now supports various authentication and security features of

the SMTP protocol through the new login() and starttls() methods.

- hmac: a new module implementing keyed hashing for message

authentication.

- mimetypes now recognizes more extensions and file types. At the

same time, some mappings not sanctioned by IANA were removed.

- The "compiler" package has been brought up to date to the state of

Python 2.2 bytecode generation. It has also been promoted from a

Tool to a standard library package. (Tools/compiler still exists as

a sample driver.)

Tools

Build

- Large file support (LFS) is now automatic when the platform supports

it; no more manual configuration tweaks are needed. On Linux, at

least, it's possible to have a system whose C library supports large

files but whose kernel doesn't; in this case, large file support is

still enabled but doesn't do you any good unless you upgrade your

kernel or share your Python executable with another system whose

kernel has large file support.

- The configure script now supplies plausible defaults in a

cross-compilation environment. This doesn't mean that the supplied

values are always correct, or that cross-compilation now works

flawlessly -- but it's a first step (and it shuts up most of

autoconf's warnings about AC_TRY_RUN).

- The Unix build is now a bit less chatty, courtesy of the parser

generator. The build is completely silent (except for errors) when

using "make -s", thanks to a -q option to setup.py.

C API

- The "structmember" API now supports some new flag bits to deny read

and/or write access to attributes in restricted execution mode.

New platforms

- Compaq's iPAQ handheld, running the "familiar" Linux distribution

(http://familiar.handhelds.org).

Tests

- The "classic" standard tests, which work by comparing stdout to

an expected-output file under Lib/test/output/, no longer stop at

the first mismatch. Instead the test is run to completion, and a

variant of ndiff-style comparison is used to report all differences.

This is much easier to understand than the previous style of reporting.

- The unittest-based standard tests now use regrtest's test_main()

convention, instead of running as a side-effect of merely being

imported. This allows these tests to be run in more natural and

flexible ways as unittests, outside the regrtest framework.

- regrtest.py is much better integrated with unittest and doctest now,

especially in regard to reporting errors.

Windows

- Large file support now also works for files > 4GB, on filesystems

that support it (NTFS under Windows 2000). See "What's New in

Python 2.2a3" for more detail.

What's New in Python 2.2a3?

Release Date: 07-Sep-2001

===========================

Core

- Conversion of long to float now raises OverflowError if the long is too

big to represent as a C double.

- The 3-argument builtin pow() no longer allows a third non-None argument

if either of the first two arguments is a float, or if both are of

integer types and the second argument is negative (in which latter case

the arguments are converted to float, so this is really the same

restriction).

- The builtin dir() now returns more information, and sometimes much

more, generally naming all attributes of an object, and all attributes

reachable from the object via its class, and from its class's base

classes, and so on from them too. Example: in 2.2a2, dir([]) returned

an empty list. In 2.2a3,

>>> dir([])

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',

'__eq__', '__ge__', '__getattr__', '__getitem__', '__getslice__',

'__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__le__',

'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__repr__',

'__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__',

'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove',

'reverse', 'sort']

dir(module) continues to return only the module's attributes, though.

- Overflowing operations on plain ints now return a long int rather

than raising OverflowError. This is a partial implementation of PEP

237. You can use -Wdefault::OverflowWarning to enable a warning for

this situation, and -Werror::OverflowWarning to revert to the old

OverflowError exception.

- A new command line option, -Q<arg>, is added to control run-time

warnings for the use of classic division. (See PEP 238.) Possible

values are -Qold, -Qwarn, -Qwarnall, and -Qnew. The default is

-Qold, meaning the / operator has its classic meaning and no

warnings are issued. Using -Qwarn issues a run-time warning about

all uses of classic division for int and long arguments; -Qwarnall

also warns about classic division for float and complex arguments

(for use with fixdiv.py).

[Note: the remainder of this paragraph (preserved below) became

obsolete in 2.2c1 -- -Qnew has global effect in 2.2]

<obsolete>

Using -Qnew is questionable; it turns on new division by default, but