Clarify that even though some of the relevant specifications define the
order in which form variables should be encoded in a request, a CGI script
should not rely on that since a client may not conform to those specs, or
they may not be relevant to the request.
Closes SF bug #596866.

Now that __init__ transforms set elements, we know that all of the
elements are hashable, so we can use dict.update() or dict.copy()
for a C speed Set.copy().

Add regression test for proper construction of sets of sets.

Replace all cases of "while 1" with "while True".
Though slightly slower, has better clarity and teaching value.

Sped ._update() method by factoring try/except out of the inner loop.

Ouch.  The test suite *really* needs work!!!!!  There were several
superficial errors and one deep one that aren't currently caught.  I'm
headed for bed after this checkin.

- Fixed several typos introduced by Raymond Hettinger (through
  cut-n-paste from my template): it's _as_temporarily_immutable, not
  _as_temporary_immutable, and moreover when the element is added, we
  should use _as_immutable.

- Made the seq argument to ImmutableSet.__init__ optional, so we can
  write ImmutableSet() to create an immutable empty set.

- Rename the seq argument to Set and ImmutableSet to iterable.

- Add a Set.__hash__ method that raises a TypeError.  We inherit a
  default __hash__ implementation from object, and we don't want that.
  We can then catch this in update(), so that
  e.g. s.update([Set([1])]) will transform the Set([1]) to
  ImmutableSet([1]).

- Added the dance to catch TypeError and try _as_immutable in the
  constructors too (by calling _update()).  This is needed so that
  Set([Set([1])]) is correctly interpreted as
  Set([ImmutableSet([1])]).  (I was puzzled by a side effect of this
  and the inherited __hash__ when comparing two sets of sets while
  testing different powerset implementations: the Set element passed
  to a Set constructor wasn't transformed to an ImmutableSet, and then
  the dictionary didn't believe the Set found in one dict it was the
  same as ImmutableSet in the other, because the hashes were
  different.)

- Refactored Set.update() and both __init__() methods; moved the body
  of update() into BaseSet as _update(), and call this from __init__()
  and update().

- Changed the NotImplementedError in BaseSet.__init__ to TypeError,
  both for consistency with basestring() and because we have to use
  TypeError when denying Set.__hash__.  Together those provide
  sufficient evidence that an unimplemented method needs to raise
  TypeError.

Add Raymond H to the list of authors; add some XXX comments about
possible API improvements.

Fast size check for sub/super set tests

Optimize try/except ordering in sets.py.

Gains a 5:1 speed-up for membership testing by
handling the most common case first (the case
where the element is hashable).

Closes SF Patch 597444.

Minor typo

Rename popitem() to pop().  (An idea from SF patch 597444.)

Move __init__ from BaseSet into Set and ImmutableSet.  This causes a
tiny amount of code duplication, but makes it possible to give BaseSet
an __init__ that raises an exception.

Typo repair.  Please include in any backports.

Add a note reminding the reader that sets are not sequences.  I
received feedback that was based in the misunderstanding that sets
were sequences.

SF patch 595846 by Brett Cannon: Update environ for CGIHTTPServer.py

This patch causes CGIHTTPServer to update os.environ regardless of how
it tries to handle calls (fork, popen*, etc.).

Backport bugfix candidate.

long_format(), long_lshift():  Someone on c.l.py is trying to boost
SHIFT and MASK, and widen digit.  One problem is that code of the form

    digit << small_integer

implicitly assumes that the result fits in an int or unsigned int
(platform-dependent, but "int sized" in any case), since digit is
promoted "just" to int or unsigned via the usual integer promotions.
But if digit is typedef'ed as unsigned int, this loses information.
The cure for this is just to cast digit to twodigits first.

Fix some endcase bugs in unicode rfind()/rindex() and endswith().
These were reported and fixed by Inyeol Lee in SF bug 595350.  The
endswith() bug was already fixed in 2.3, but this adds some more test
cases.

Comment typo repair.

My patch #597221.  Use f_lasti more consistently.

Bump version number to 2.3

Added tests for SF patch #597593, syntactically invalid Content-Type: headers.

get_content_type(), get_content_maintype(), get_content_subtype(): RFC
2045, section 5.2 states that if the Content-Type: header is
syntactically invalid, the default type should be text/plain.
Implement minimal sanity checking of the header -- it must have
exactly one slash in it.  This closes SF patch #597593 by Skip, but in
a different way.

Note that these methods used to raise ValueError for invalid ctypes,
but now they won't.

_dispatch(): Use get_content_maintype() and get_content_subtype() to
get the MIME main and sub types, instead of getting the whole ctype
and splitting it here.   The two more specific methods now correctly
implement RFC 2045, section 5.2.

getinstclassname():  Squash new compiler wng in assert (comparison of
signed vs unsigned).

Clarify the endpos argument to the rx.match() method.
Closes SF bug #597177.

test_three_lines(): Test case reported by Andrew McNamara.  Works in
email 2.2 but fails in email 1.0.

Cover the sets module.

(There's a link to PEP218; has PEP218 been updated to match the actual
module implementation?)

Create two subsections of the "Core Language Changes" section, because
   the list is getting awfully long
Mention Karatsuba multiplication and some other items

Add versionadded for operator.pow

Extend some comments on the order of values in the returns from
dict.items/keys/values/iteritems/iterkeys/itervalues().

SF patch 576101, by Oren Tirosh: alternative implementation of
interning.  I modified Oren's patch significantly, but the basic idea
and most of the implementation is unchanged.  Interned strings created
with PyString_InternInPlace() are now mortal, and you must keep a
reference to the resulting string around; use the new function
PyString_InternImmortal() to create immortal interned strings.

Add a warning comment to the LOAD_GLOBAL inline code.

Another ugly inlining hack, expanding the two PyDict_GetItem() calls
in LOAD_GLOBAL.  Besides saving a C function call, it saves checks
whether f_globals and f_builtins are dicts, and extracting and testing
the string object's hash code is done only once.  We bail out of the
inlining if the name is not exactly a string, or when its hash is -1;
because of interning, neither should ever happen.  I believe interning
guarantees that the hash code is set, and I believe that the 'names'
tuple of a code object always contains interned strings, but I'm not
assuming that -- I'm simply testing hash != -1.

On my home machine, this makes a pystone variant with new-style
classes and slots run at the same speed as classic pystone!  (With
new-style classes but without slots, it is still a lot slower.)

Call me anal, but there was a particular phrase that was speading to
comments everywhere that bugged me: /* Foo is inlined */ instead of
/* Inline Foo */.  Somehow the "is inlined" phrase always confused me
for half a second (thinking, "No it isn't" until I added the missing
"here").  The new phrase is hopefully unambiguous.

Another modest speedup in PyObject_GenericGetAttr(): inline the call
to _PyType_Lookup().

Make PyDescr_IsData() a macro.  It's too simple to be a function.
Should save 4% on slot lookups.

Check in my ultra-shortlived patch #597220.

Move some debugging checks inside Py_DEBUG.

They were causing cache misses according to cachegrind.

Inline call to _PyObject_GetDictPtr() in PyObject_GenericGetAttr().
This causes a modest speedup.

Fix typo in __slots__ of ImmutableSet.

News about sets.  (There's no documentation; if someone wants to
convert the doc strings to LaTeX, be my guest.)

Set classes and their unit tests, from sandbox.

Simple but important optimization for descr_check(): instead of the
expensive and overly general PyObject_IsInstance(), call
PyObject_TypeCheck() which is a macro that often avoids a call, and if
it does make a call, calls the much more efficient PyType_IsSubtype().
This saved 6% on a benchmark for slot lookups.

Fix spelling errors and note the addition of operator.pow()

Merged the MacPython thanks list into the general acknowledgements.
There's really no point in a separate list of thank-you notes.

Added __pow__(a,b) to the operator module. Completes the pattern of
all operators having a counterpart in the operator module.

Closes SF bug #577513.

SF bug 595919: popenN return only text mode pipes
popen2() and popen3() created text-mode pipes even when binary mode
was asked for.  This was specific to Windows.

Add Steve Purcell for unittest.py

Refuse to run if the last bit of the destination path contains a # character.
This is a silly workaround for a rather serious bug in MacOSX: if you take
a long filename and convert it to an FSSpec the fsspec gets a magic
cooky (containing a #, indeed). If you then massage the extension of this
fsspec and convert back to a pathname you may end up referring to the
same file. This could destroy your sourcefile. The problem only occcurs
in MacPython-OS9, not MacPython-OSX (I think).

Closes bug #505562.

Modify splituser() method to allow an @ in the userinfo field.
Jeremy reported that this is not allowed by RFC 2396; however,
other tools support unescaped @'s so we should also.

Apply SF patch 596581 closing bug 581529.

OS/2 EMX behaves like Windows where file permissions are concerned

update contact info

Prep for 2.3:
 - update DLL version number
 - add files required for 2.3 (no changes to modules though)
 - restructure build of pgen.exe

NOTE:  As I don't have the VACPP compiler, these changes are untested.
Apart from slightly re-ordering some file lists, and matching file name
casing, I believe these changes are the minimum necessary to build 2.3
with VACPP.

make port notes current

Build process updates:
 - the security fixes to tempfile have lead to test_tempfile wanting
   to create 100 temporary files.  as the EMX default is only 40,
   the number of file handles has been bumped (up to 250).
 - changes to pgen have required restructuring its build support.

Get rid of _once(); inlining it takes less code. :-)

Also, don't call gettempdir() in the default expression for the 'dir'
argument to various functions; use 'dir=None' for the default and
insert 'if dir is None: dir = gettemptir()' in the bodies.  That way
the work done by gettempdir is postponed until needed.

Patch by Zack W to make test_noinherit() more robust: spawn a Python
subprocess that does the right checks.  This now works on Windows as
well.

Get this to compile again if Py_USING_UNICODE is not defined.
com_error() is static in Python/compile.c.

Drop the number of test files to 100 for all the tests

Inline fast_cfunction() in new call_function().

Also, don't handle METH_OLDARGS on the fast path.  All the interesting
builtins have been converted to use METH_NOARGS, METH_O, or
METH_VARARGS.

Result is another 1-2% speedup.  If I can cobble together 10 of these,
it might make a difference.

Remove the outdated PLAN.txt file.

Move body of CALL_FUNCTION opcode into helper function.

This makes the code much easier to ready, because it is at a sane
indentation level.  On my box this shows a 1-2% speedup, which means
nothing, except that I'm not going to worry about the performance
effects of the change.

Squash a few calls to the hideously expensive PyObject_CallObject(o,a)
-- replace then with slightly faster PyObject_Call(o,a,NULL).  (The
difference is that the latter requires a to be a tuple; the former
allows other values and wraps them in a tuple if necessary; it
involves two more levels of C function calls to accomplish all that.)

Streamline the fast track for CFunction calls a bit more: there was
nothing special done if keyword arguments were present, so test for
that earlier and fall through to the normal case if there are any.
This ought to slow down CFunction calls with keyword args, but I don't
care; it's a tiny (1%) improvement for pystone.

Regenerated with PyDoc_STR() around docstrings.

iUse PyDoc_STR() around docstrings.

A nice little speed-up for filter():

- Use PyObject_Call() instead of PyEval_CallObject(), saves several
  layers of calls and checks.

- Pre-allocate the argument tuple rather than calling Py_BuildValue()
  each time round the loop.

- For filter(None, seq), avoid an INCREF and a DECREF.

Fix SF bug 595838 -- buffer in type_new() should not be static.  Moved
to inner scope, too.

SF bug 594996:  OverflowError in random.randrange
Loosened the acceptable 'start' and 'stop' arguments so that any
Python (bounded) ints can be used.  So, e.g., randrange(-sys.maxint-1,
sys.maxint) no longer blows up.

Newly-relaxed limits on random.randrange().  Also added some info about
Karatsuba's better cache behavior with extremely large multiplicands.

Mention warnings about defining None.

Add warnings for arguments named None.  All set.  (I could add a
warning for 'global None', but that's either accompanied by an
assignment to None, which will trigger a warning, or not, in which
case it's harmless. :-)

check_events():  This was failing under -O, due to not expecting any
LINE events when not __debug__.  But we get them anyway under -O now,
so just stop special-casing non-__debug__ mode.

Add warning for None used as keyword argument name in function call.
Still to do: function definition arguments (including *None and
**None).

Add warnings for assignment or deletion of variables and attributes
named 'None'.  Still to do: function definition parameter lists, and
function call keyword arguments.

Minor cleanup of parsename() and parsestr(): the 'struct compiling *'
argument should be called 'c', like everywhere else.  Renamed a
complex variable 'c' to 'z' and moved it inside the only scope where
it's used.

base64.decodestring('') should return '' instead of raising an
exception.  The bug fix for SF #430849 wasn't quite right.  This
closes SF bug #595671.  I'll backport this to Python 2.2.

Fixed the bugs in the constant definitions, and in the code to test
them.
The FutureWarnings are still there, until a way has been found to
say "I know what I'm doing here when I say 0xff000000".

After generating the Python file with definitions try to run it, so
we catch errors during the build process in stead of later during runtime.

Try to cater for a source tree checked out with MacCVS in stead of
unix cvs. In this case the resource files are actual resource files
in stead of AppleSingle encoded files.

Illustrating by example one good reason not to trust a proof <wink>.

k_mul() comments:  In honor of Dijkstra, made the proof that "t3 fits"
rigorous instead of hoping for testing not to turn up counterexamples.
Call me heretical, but despite that I'm wholly confident in the proof,
and have done it two different ways now, I still put more faith in
testing ...

long_mul():  Simplified exit code.  In particular, k_mul() returns a
normalized result, so no point to normalizing it again.  The number
of test+branches was also excessive.

This is my patch

[ 587993 ] SET_LINENO killer

Remove SET_LINENO.  Tracing is now supported by inspecting co_lnotab.

Many sundry changes to document and adapt to this change.

Add notes about universal newlines.

Fix typo.  It's --with-universal-newlines, not
--with-universal-newline.

Slight reordering of directories searched for BerkDB libs and include files.
Push /usr/... further down the list - always check /usr/local/... before
/usr/...

Doubt this will help with http://python.org/sf/589427 or not, but these
changes were prompted by my investigation of that bug report.  I wasn't able
to reproduce that problem though

forgot the best part - the new tests...
see patch 586561

provide less mysterious error messages when seeing end-of-line in
single-quoted strings or end-of-file in triple-quoted strings.
closes patch 586561.

Add 'in' change
Revise sentence
Add two reminders

Add news about Fred's change to Py_InitModule4().

Reflow long lines.

Py_InitModule() and friends now accept NULL for the 'methods'
argument.  This makes sense now that extension types can support
__init__ directly rather than requiring function constructors.

Py_InitModule4():  Accept NULL for the 'methods' argument.  This makes
sense now that extension types can support __init__ directly rather
than requiring function constructors.

Docstring nits: The module is neither proposed nor new.

Added Hisao Suzuki.

More changes of DeprecationWarning to FutureWarning.

Explain use of currentThread() in _Condition methods.

The filterwarnings() call here should be updated to filter out
FutureWarning.

Explain a little more.

Explain a minor mystery.