What's New in Python 2.3 alpha 1?

XXX Release date: DD-MMM-2002 XXX

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

Type/class unification and new-style classes

Core and builtins

- Deprecated features of xrange objects have been removed as

promised. The start, stop, and step attributes and the tolist()

method no longer exist. xrange repetition and slicing have been

removed.

- New builtin function enumerate(x), from PEP 279. Example:

enumerate("abc") is an iterator returning (0,"a"), (1,"b"), (2,"c").

The argument can be an arbitrary iterable object.

- The assert statement no longer tests __debug__ at runtime. This means

that assert statements cannot be disabled by assigning a false value

to __debug__.

- A method zfill() was added to str and unicode, that fills a numeric

string to the left with zeros. For example,

"+123".zfill(6) -> "+00123".

- Complex numbers supported divmod() and the // and % operators, but

these make no sense. Since this was documented, they're being

deprecated now.

- String and unicode methods lstrip(), rstrip() and strip() now take

an optional argument that specifies the characters to strip. For

example, "Foo!!!?!?!?".rstrip("?!") -> "Foo".

- Added a new dict method pop(key). This removes and returns the

value corresponding to key. [SF patch #539949]

- Changed new-style class instantiation so that when C's __new__

method returns something that's not a C instance, its __init__ is

not called. [SF bug #537450]

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

- A new built-in type, bool, has been added, as well as built-in

names for its two values, True and False. Comparisons and sundry

other operations that return a truth value have been changed to

return a bool instead. Read PEP 285 for an explanation of why this

is backward compatible.

- 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.

- The optional object allocator has been enabled by default.

- 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.)

- PyErr_Display will provide file and line information for all exceptions

that have an attribute print_file_and_line, not just SyntaxErrors.

- The UTF-8 codec will now encode and decode Unicode surrogates

correctly and without raising exceptions for unpaired ones.

- file.xreadlines() now raises a ValueError if the file is closed:

Previously, an xreadlines object was returned which would raise

a ValueError when the xreadlines.next() method was called.

- sys.exit() inadvertently allowed more than one argument.

An exception will now be raised if more than one argument is used.

Extension modules

- The bsddb.*open functions can now take 'None' as a filename.

This will create a temporary in-memory bsddb that won't be

written to disk.

- posix.killpg and posix.mknod have been added where available.

- The locale module now exposes the C library's gettext interface.

- 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 now ships with zlib-1.1.4.

- pwd, grp, and resource return enhanced tuples now, with symbolic

field names.

- array.array is now a type object. A new format character

'u' indicates Py_UNICODE arrays. For those, .tounicode and

.fromunicode methods are available. Arrays now support __iadd__

and __imul__.

- dl now builds on every system that has dlfcn.h. Failure in case

of sizeof(int)!=sizeof(long)!=sizeof(void*) is delayed until dl.open

is called.

Library

- added degree/radian conversion functions to the math module.

- ftplib.retrlines() now tests for callback is None rather than testing

for False. Was causing an error when given a callback object which

was callable but also returned len() as zero. The change may

create new breakage if the caller relied on the undocumented behavior

and called with callback set to [] or some other False value not

identical to None.

- random.gauss() uses a piece of hidden state used by nothing else,

and the .seed() and .whseed() methods failed to reset it. In other

words, setting the seed didn't completely determine the sequence of

results produced by random.gauss(). It does now. Programs repeatedly

mixing calls to a seed method with calls to gauss() may see different

results now.

- The pickle.Pickler class grew a clear_memo() method to mimic that

provided by cPickle.Pickler.

- difflib's SequenceMatcher class now does a dynamic analysis of

which elements are so frequent as to constitute noise. For

comparing files as sequences of lines, this generally works better

than the IS_LINE_JUNK function, and function ndiff's linejunk

argument defaults to None now as a result. A happy benefit is

that SequenceMatcher may run much faster now when applied

to large files with many duplicate lines (for example, C program

text with lots of repeated "}" and "return NULL;" lines).

- New Text.dump() method in Tkinter module.

- New distutils commands for building packagers were added to

support pkgtool on Solaris and swinstall on HP-UX.

- distutils now has a new abstract binary packager base class

command/bdist_packager, which simplifies writing packagers.

This will hopefully provide the missing bits to encourage

people to submit more packagers, e.g. for Debian, FreeBSD

and other systems.

- The UTF-16, -LE and -BE now raise a NotImplementedError

for all calls to .readline(). Previously, they used to just

produce garbage or fail with an encoding error -- UTF-16 is

a 2-byte encoding and the C lib's line reading APIs don't

work well with these.

- compileall now supports quiet operation.

- The BaseHTTPServer now implements optional HTTP/1.1 persistent

connections.

- socket module: the SSL support was broken out of the main

_socket module C helper and placed into a new _ssl helper

which now gets imported by socket.py if available and working.

- encodings package: added aliases for all supported IANA character

sets

- ftplib: to safeguard the user's privacy, anonymous login will use

"anonymous@" as default password, rather than the real user and host

name.

- 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.

- gettext.translation has an optional fallback argument, and

gettext.find an optional all argument. Translations will now fallback

on a per-message basis.

- distutils bdist commands now offer a --skip-build option.

- warnings.warn now accepts a Warning instance as first argument.

- 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]

Tools/Demos

- freeze.py now produces binaries which can import shared modules,

unlike before when this failed due to missing symbol exports in

the generated binary.

Build

- XXX WITH_UNIVERSAL_NEWLINES Somebody fill this in; the PEP doesn't

say how or when to configure it, or how to turn it off.

- On Unix, a shared libpython2.3.so can be created with --enable-shared.

- All uses of the CACHE_HASH, INTERN_STRINGS, and DONT_SHARE_SHORT_STRINGS

preprocessor symbols were eliminated. The internal decisions they

controlled stopped being experimental long ago.

- The tools used to build the documentation now work under Cygwin as

well as Unix.

C API

- Added new macro PySequence_ITEM(o, i) that directly calls

sq_item without rechecking that o is a sequence and without

adjusting for negative indices.

- PyRange_New() now raises ValueError if the fourth argument is not 1.

This is part of the removal of deprecated features of the xrange

object.

- PyNumber_Coerce() and PyNumber_CoerceEx() now also invoke the type's

coercion if both arguments have the same type but this type has the

CHECKTYPES flag set. This is to better support proxies.

- The type of tp_free has been changed from "void (*)(PyObject *)" to

"void (*)(void *)".

- PyObject_Del, PyObject_GC_Del are now functions instead of macros.

- 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.

- The PyCore_* family of APIs have been removed.

- The "u#" parser marker will now pass through Unicode objects as-is

without going through the buffer API.

- The enumerators of cmp_op have been renamed to use the prefix PyCmp_.

- An old #define of ANY as void has been removed from pyport.h. This

hasn't been used since Python's pre-ANSI days, and the #define has

been marked as obsolete since then. SF bug 495548 says it created

conflicts with other packages, so keeping it around wasn't harmless.

- Because Python's magic number scheme broke on January 1st, we decided

to stop Python development. Thanks for all the fish!

- Some of us don't like fish, so we changed Python's magic number

scheme to a new one. See Python/import.c for details.

New platforms

- GNU/Hurd is now supported.

Tests

Windows

- Sometimes the uninstall executable (UNWISE.EXE) vanishes. One cause

of that has been fixed in the installer (disabled Wise's "delete in-

use files" uninstall option).

- 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.

- file.truncate([newsize]) now works on Windows for all newsize values.

It used to fail if newsize didn't fit in 32 bits, reflecting a

limitation of MS _chsize (which is no longer used).

- os.waitpid() is now implemented for Windows, and can be used to block

until a specified process exits. This is similar to, but not exactly

the same as, os.waitpid() on POSIX systems. If you're waiting for

a specific process whose pid was obtained from one of the spawn()

functions, the same Python os.waitpid() code works across platforms.

See the docs for details. The docs were changed to clarify that

spawn functions return, and waitpid requires, a process handle on

Windows (not the same thing as a Windows process id).

- New tempfile.TemporaryFile implementation for Windows: this doesn't

need a TemporaryFileWrapper wrapper anymore, and should be immune

to a nasty problem: before 2.3, if you got a temp file on Windows, it

got wrapped in an object whose close() method first closed the

underlying file, then deleted the file. This usually worked fine.

However, the spawn family of functions on Windows create (at a low C

level) the same set of open files in the spawned process Q as were

open in the spawning process P. If a temp file f was among them, then

doing f.close() in P first closed P's C-level file handle on f, but Q's

C-level file handle on f remained open, so the attempt in P to delete f

blew up with a "Permission denied" error (Windows doesn't allow

deleting open files). This was surprising, subtle, and difficult to

work around.

- The os module now exports all the symbolic constants usable with the

low-level os.open() on Windows: the new constants in 2.3 are

O_NOINHERIT, O_SHORT_LIVED, O_TEMPORARY, O_RANDOM and O_SEQUENTIAL.

The others were also available in 2.2: O_APPEND, O_BINARY, O_CREAT,

O_EXCL, O_RDONLY, O_RDWR, O_TEXT, O_TRUNC and O_WRONLY. Contrary

to Microsoft docs, O_SHORT_LIVED does not seem to imply O_TEMPORARY

(so specify both if you want both; note that neither is useful unless

specified with O_CREAT too).

Mac

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 regression 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 class 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() signatures 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

[email protected]; 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 read-only 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 subclass 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