Simplify, and avoid PyModule_GetDict() while we're at it.

Fix an inaccuracy in the comment

Gave intersection_update a speed boost.

Gave issubet() and issuperset() major speed boosts.  That's it for now!
Someone else may want to tackle the mutating operations similarly.

Gave __sub__/difference a factor of 2-5 speed boost.

Gave __xor__/symmetric_difference a factor of 2-5 speed boost.

Sped union by a factor of 3-4.

Sped intersection by large factors (3-5x faster than before on sets of
cardinality 500; and the smaller the intersection, the bigger the speedup).

Added a clue about why xyz_update isn't the same as __xyz__.

Implemented <, <=, >, >= for sets, giving subset and proper-subset
meanings.  I did not add new, e.g., ispropersubset() methods; we're
going nuts on those, and, e.g., there was no "friendly name" for
== either.

TestSubset():  Generalized the framework to support testing upcoming
<, <=, etc methods too.

Rewrote all remaining assert stmts.

Simplified construction of the test suite.

Simplified code building sets of characters.

Ack!  Virtually every test here relied on an assert stmt.  assert stmts
should never be used in tests.  Repaired dozens, but more is needed.

Simplified the setup for is-subset testing.

Record a clue about why __or__ is not union, etc.

Replace 0 with False to match working in documentation.  SF 599681.

Correct documentation of allow_reuse_address to match the actual script.

Closes SF bug 599681.

1. Revert subprocess environment clearing, will restart subprocess
   instead.
2. Preserve the Idle client's listening socket for reuse with the
   fresh subprocess.
3. Remove some unused rpc code, comment out additional unused code.

Modified Files:
ScriptBinding.py rpc.py run.py

Improve exception handling across rpc interface
Modified Files:
  rpc.py

Removed < <= > >= from the API.  Implemented as comparisons of the
underlying dictionaries, there were no reasonable use cases (lexicographic
sorting of a list of sets is somewhat esoteric).  Frees the operators
for other uses (such as strict subset and superset comparisons).

Updated documentation and test suite accordingly.

string_contains(): speed up by avoiding function calls where
possible.  This always called PyUnicode_Check() and PyString_Check(),
at least one of which would call PyType_IsSubtype().  Also, this would
call PyString_Size() on known string objects.

Speed up the most egregious "if token in (long tuple)" cases by using
a dict instead.  (Alas, using a Set would be slower instead of
faster.)

Speedup for PyObject_IsTrue(): check for True and False first.
Because all built-in tests return bools now, this is the most common
path!

At Tim Peter's suggestion, propagated GvR's binary operator changes to
the inplace operators.  The strategy is to have the operator overloading
code do the work and then to define equivalent method calls which rely on
the operators.  The changes facilitate proper application of TypeError
and NonImplementedErrors.

Added corresponding tests to the test suite to make sure both the operator
and method call versions get exercised.

Add missing tests for difference_update().

Speedup for PyObject_RichCompareBool(): PyObject_RichCompare() almost
always returns a bool, so avoid calling PyObject_IsTrue() in that
case.

Since instances of _TemporarilyImmutableSet are always thrown away
immediately after the comparison, there in no use in caching the hashcode.
The test, 'if self._hashcode is None', never fails.  Removing the caching
saves a few lines and a little time.

Expanded tests for sets of sets.

1. Removed module self test in favor of unittests -- Timbot's suggestion.
2. Replaced calls to Set([]) with Set() -- Timbot's suggestion
3. Fixed subtle bug in sets of sets:

The following code did not work (will add to test suite):
    d = Set('d')
    s = Set([d])  # Stores inner set as an ImmutableSet
    s.remove(d)   # For comparison, wraps d in _TemporarilyImmutableSet

The comparison proceeds by computing the hash of the
_TemporarilyImmutableSet and finding it in the dictionary.
It then verifies equality by calling ImmutableSet.__eq__()
and crashes from the binary sanity check.

The problem is that the code assumed equality would be checked
with _TemporarilyImmutableSet.__eq__().

The solution is to let _TemporarilyImmutableSet derive from BaseSet
so it will pass the sanity check and then to provide it with the
._data element from the wrapped set so that ImmutableSet.__eq__()
will find ._data where it expects.

Since ._data is now provided and because BaseSet is the base class,
_TemporarilyImmutableSet no longer needs .__eq__() or .__ne__().

Note that inheriting all of BaseSet's methods is harmless because
none of those methods (except ones starting with an underscore)
can mutate the .data element.  Also _TemporarilyImmutableSet is only
used internally as is not otherwise visible.

Fix typo reported to python-docs.

pop() docstring:  this isn't a randomly-chosen element, it's merely
arbitrary.  I already changed the docs for this.

Comment repair.

Fix SF bug 599128, submitted by Inyeol Lee: .replace() would do the
wrong thing for a unicode subclass when there were zero string
replacements.  The example given in the SF bug report was only one way
to trigger this; replacing a string of length >= 2 that's not found is
another.  The code would actually write outside allocated memory if
replacement string was longer than the search string.

(I wonder how many more of these are lurking?  The unicode code base
is full of wonders.)

Bugfix candidate; this same bug is present in 2.2.1.

Code by Inyeol Lee, submitted to SF bug 595350, to implement
the string/unicode method .replace() with a zero-lengt first argument.
Inyeol contributed tests for this too.

Whitespace normalization.

Fix markup and punctuation

Got rid of the toy _Set class, in favor of sets.Set.

s/_as_Temporarily_Immutable/_as_temporarily_immutable/g, because the
latter is what the code actually does.

pop():  An arbitrary element is removed, not a random element.

Adjust the markup in a few places so this will actually format.
Remove the third column in the tables since it isn't used.

Add an entry for the sets module documentation.
Move another entry so the boilerplate doesn't get mixed up with
document-specific content.

Load docs for sets.py

RH pointed out that discard(element) doesn't do the transformation on
the element if necessary.  Fixed by calling self.remove(element).

The error messages in err_args() -- which is only called when the
required number of args is 0 or 1 -- were reversed.  Also change "1"
into "exactly one", the same words as used elsewhere for this
condition.

Added the standard MacOSX location for documentation inside a framework
to the list of places where pydoc looks for HTML documents.

Rewritten using the tokenize module, which gives us a real tokenizer
rather than a number of approximating regular expressions.
Alas, it is 3-4 times slower.  Let that be a challenge for the
tokenize module.

Don't build ConfigurePythonCarbon and ConfigurePythonClassic any longer,
classic Python is gone.

For MacPython-OS9 verbose is the default.

Interface to Apple Help Manager.

Moved CoreFoundation type support to bgen/macsupport.

Added PyDoc_STR's.

Tweak wordsep_re again: this time to recognize an em-dash with
any non-whitespace characters adjacent, not just \w.

Test an em-dash with adjacent punctuation.

Factored out BaseTestCase.check_split() method -- use it wherever
we need to test TextWrapper._split().

Test _split() method in test_unix_options().

Add test_unix_options() to WrapTestCase to test for SF bug #596434.

Fix SF bug #596434: tweak wordsep_re so "--foo-bar" now splits
into /--foo-/bar/ rather than /--/foo-/bar/.  Needed for Optik and
Docutils to handle Unix-style command-line options properly.

Standardize behavior: no docstrings in test functions.

Standardize behavior: no docstrings in test functions.  Also use
unittest.makeSuite() rather than loader.loadTestsFromTestCase().

Standardize behavior: no docstrings in test functions.  Also strip
trailing whitespace.

Document that docstrings are verboten for test functions.

Expand the example to show some actual test functions, and a setUp()
and tearDown() method.

Standardize behavior: no docstrings in test functions.  Also get rid
of dummy_test_TemporaryFile class; when NamedTemporaryFile and
TemporaryFile are the same, simply don't add a test suite for
TemporaryFile.

Standardize behavior: no docstrings in test functions; add a proper
test_main() that creates a suite and runs it.  Don't mess with sys.path!!!

Add test_em_dash() to WrapTestCase to make sure that TextWrapper handles
em-dashes -- like this -- properly.  (Also--like this.  Although this
usage may be incompatible with fixing bug #596434; we shall see.)

Standardize behavior: no docstrings in test functions.

Standardize behavior: create a single suite merging all test cases.

Standardize behavior: no docstrings in test functions; create a single
suite merging all test cases.

Made it more readable.

Fix peculiar (and ungrammatical) wording in an example program.

Simplification/cleanup in IndentTestCases.

Factor LongWordTestCase out of WrapTestCase, and rename its methods
(tests) from test_funky_punc() to test_break_long() and
test_long_words() to test_nobreak_long().

Rename base test case class to (yawn) BaseTestCase.

Ditch the whole loop-over-subcases way of working.  Add check_wrap() to
base class (WrapperTestCase) instead, and call it repeatedly in the
methods that used to have a loop-over-subcases.  Much simpler.

Rename perennial temp variable 't' to 'text'.

Simplify and reformat the use of 'subcases' lists (and following
for-loops) in test_simple(), test_wrap_short() test_hyphenated(), and
test_funky_punc().

Add comment header block.
Remove some useless comments (redundant, or info presumably available in
  PyUnit docs).

Conform to standards documented in README:
  *  lowercase test*() methods
  * define test_main() and use it instead of unittest.main()
Kill #! line.
Improve some test names and docstrings.

Test script for the textwrap module.  Kindly provided by Peter Hansen
<peter@engcorp.com> based on a test script that's been kicking around my
home directory for a couple of months now and only saw the light of day
because I included it when I sent textwrap.py to python-dev for review.

On Windows, make sure SocketType is the same as socket.  (SF bug
598097)

Change the binary operators |, &, ^, - to return NotImplemented rather
than raising TypeError when the other argument is not a BaseSet.  This
made it necessary to separate the implementation of e.g. __or__ from
the union method; the latter should not return NotImplemented but
raise TypeError.  This is accomplished by making union(self, other)
return self|other, etc.; Python's binary operator machinery will raise
TypeError.

The idea behind this change is to allow other set implementations with
an incompatible internal structure; these can provide union (etc.) with
standard sets by implementing __ror__ etc.

I wish I could do this for comparisons too, but the default comparison
implementation allows comparing anything to anything else (returning
false); we don't want that (at least the test suite makes sure
e.g. Set()==42 raises TypeError).  That's probably fine; otherwise
other set implementations would be constrained to implementing a hash
that's compatible with ours.

Give the section on PEP 263 a more meaningful title, so readers will
be able to locate this information without knowing the PEP number.

Add a note that apply() is needed since the extended call syntax is
completely equivalent.

Fix grammatically inept comment.

Added a main() function and support to run this module as a script.
Closes SF feature request #588768.

Refactor:  Remove some code that was obsoleted when this module was
           changed to use universal newlines.

           Remove all imports from the compile() function; these are
           now done at the top of the module ("Python normal form"),
           and define a helper based on the platform instead of
           testing the platform in the compile() function.

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.