[Python-3000-checkins] r53335 - in python/branches/p3yk: Doc/Makefile.deps Doc/lib/lib.tex Doc/lib/libsets.tex Doc/lib/libstdtypes.tex Lib/msilib/__init__.py Lib/sets.py Lib/test/test_cookielib.py Lib/test/test_set.py Lib/test/test_sets.py
guido.van.rossum
python-3000-checkins at python.org
Wed Jan 10 02:28:35 CET 2007
Author: guido.van.rossum
Date: Wed Jan 10 02:28:32 2007
New Revision: 53335
Removed:
python/branches/p3yk/Lib/sets.py
python/branches/p3yk/Lib/test/test_sets.py
Modified:
python/branches/p3yk/Doc/Makefile.deps
python/branches/p3yk/Doc/lib/lib.tex
python/branches/p3yk/Doc/lib/libsets.tex
python/branches/p3yk/Doc/lib/libstdtypes.tex
python/branches/p3yk/Lib/msilib/__init__.py
python/branches/p3yk/Lib/test/test_cookielib.py
python/branches/p3yk/Lib/test/test_set.py
Log:
Excise the sets module. SF #1500611 by Collin Winter.
Modified: python/branches/p3yk/Doc/Makefile.deps
==============================================================================
--- python/branches/p3yk/Doc/Makefile.deps (original)
+++ python/branches/p3yk/Doc/Makefile.deps Wed Jan 10 02:28:32 2007
@@ -109,7 +109,6 @@
lib/libplatform.tex \
lib/libfpectl.tex \
lib/libgc.tex \
- lib/libsets.tex \
lib/libweakref.tex \
lib/libinspect.tex \
lib/libpydoc.tex \
Modified: python/branches/p3yk/Doc/lib/lib.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/lib.tex (original)
+++ python/branches/p3yk/Doc/lib/lib.tex Wed Jan 10 02:28:32 2007
@@ -104,7 +104,6 @@
\input{libheapq}
\input{libbisect}
\input{libarray}
-\input{libsets}
\input{libsched}
\input{libmutex}
\input{libqueue}
Modified: python/branches/p3yk/Doc/lib/libsets.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libsets.tex (original)
+++ python/branches/p3yk/Doc/lib/libsets.tex Wed Jan 10 02:28:32 2007
@@ -1,264 +0,0 @@
-\section{\module{sets} ---
- Unordered collections of unique elements}
-
-\declaremodule{standard}{sets}
-\modulesynopsis{Implementation of sets of unique elements.}
-\moduleauthor{Greg V. Wilson}{gvwilson at nevex.com}
-\moduleauthor{Alex Martelli}{aleax at aleax.it}
-\moduleauthor{Guido van Rossum}{guido at python.org}
-\sectionauthor{Raymond D. Hettinger}{python at rcn.com}
-
-\versionadded{2.3}
-
-The \module{sets} module provides classes for constructing and manipulating
-unordered collections of unique elements. Common uses include membership
-testing, removing duplicates from a sequence, and computing standard math
-operations on sets such as intersection, union, difference, and symmetric
-difference.
-
-Like other collections, sets support \code{\var{x} in \var{set}},
-\code{len(\var{set})}, and \code{for \var{x} in \var{set}}. Being an
-unordered collection, sets do not record element position or order of
-insertion. Accordingly, sets do not support indexing, slicing, or
-other sequence-like behavior.
-
-Most set applications use the \class{Set} class which provides every set
-method except for \method{__hash__()}. For advanced applications requiring
-a hash method, the \class{ImmutableSet} class adds a \method{__hash__()}
-method but omits methods which alter the contents of the set. Both
-\class{Set} and \class{ImmutableSet} derive from \class{BaseSet}, an
-abstract class useful for determining whether something is a set:
-\code{isinstance(\var{obj}, BaseSet)}.
-
-The set classes are implemented using dictionaries. Accordingly, the
-requirements for set elements are the same as those for dictionary keys;
-namely, that the element defines both \method{__eq__} and \method{__hash__}.
-As a result, sets
-cannot contain mutable elements such as lists or dictionaries.
-However, they can contain immutable collections such as tuples or
-instances of \class{ImmutableSet}. For convenience in implementing
-sets of sets, inner sets are automatically converted to immutable
-form, for example, \code{Set([Set(['dog'])])} is transformed to
-\code{Set([ImmutableSet(['dog'])])}.
-
-\begin{classdesc}{Set}{\optional{iterable}}
-Constructs a new empty \class{Set} object. If the optional \var{iterable}
-parameter is supplied, updates the set with elements obtained from iteration.
-All of the elements in \var{iterable} should be immutable or be transformable
-to an immutable using the protocol described in
-section~\ref{immutable-transforms}.
-\end{classdesc}
-
-\begin{classdesc}{ImmutableSet}{\optional{iterable}}
-Constructs a new empty \class{ImmutableSet} object. If the optional
-\var{iterable} parameter is supplied, updates the set with elements obtained
-from iteration. All of the elements in \var{iterable} should be immutable or
-be transformable to an immutable using the protocol described in
-section~\ref{immutable-transforms}.
-
-Because \class{ImmutableSet} objects provide a \method{__hash__()} method,
-they can be used as set elements or as dictionary keys. \class{ImmutableSet}
-objects do not have methods for adding or removing elements, so all of the
-elements must be known when the constructor is called.
-\end{classdesc}
-
-
-\subsection{Set Objects \label{set-objects}}
-
-Instances of \class{Set} and \class{ImmutableSet} both provide
-the following operations:
-
-\begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result}
- \lineiii{len(\var{s})}{}{cardinality of set \var{s}}
-
- \hline
- \lineiii{\var{x} in \var{s}}{}
- {test \var{x} for membership in \var{s}}
- \lineiii{\var{x} not in \var{s}}{}
- {test \var{x} for non-membership in \var{s}}
- \lineiii{\var{s}.issubset(\var{t})}{\code{\var{s} <= \var{t}}}
- {test whether every element in \var{s} is in \var{t}}
- \lineiii{\var{s}.issuperset(\var{t})}{\code{\var{s} >= \var{t}}}
- {test whether every element in \var{t} is in \var{s}}
-
- \hline
- \lineiii{\var{s}.union(\var{t})}{\var{s} \textbar{} \var{t}}
- {new set with elements from both \var{s} and \var{t}}
- \lineiii{\var{s}.intersection(\var{t})}{\var{s} \&\ \var{t}}
- {new set with elements common to \var{s} and \var{t}}
- \lineiii{\var{s}.difference(\var{t})}{\var{s} - \var{t}}
- {new set with elements in \var{s} but not in \var{t}}
- \lineiii{\var{s}.symmetric_difference(\var{t})}{\var{s} \^\ \var{t}}
- {new set with elements in either \var{s} or \var{t} but not both}
- \lineiii{\var{s}.copy()}{}
- {new set with a shallow copy of \var{s}}
-\end{tableiii}
-
-Note, the non-operator versions of \method{union()},
-\method{intersection()}, \method{difference()}, and
-\method{symmetric_difference()} will accept any iterable as an argument.
-In contrast, their operator based counterparts require their arguments to
-be sets. This precludes error-prone constructions like
-\code{Set('abc') \&\ 'cbs'} in favor of the more readable
-\code{Set('abc').intersection('cbs')}.
-\versionchanged[Formerly all arguments were required to be sets]{2.3.1}
-
-In addition, both \class{Set} and \class{ImmutableSet}
-support set to set comparisons. Two sets are equal if and only if
-every element of each set is contained in the other (each is a subset
-of the other).
-A set is less than another set if and only if the first set is a proper
-subset of the second set (is a subset, but is not equal).
-A set is greater than another set if and only if the first set is a proper
-superset of the second set (is a superset, but is not equal).
-
-The subset and equality comparisons do not generalize to a complete
-ordering function. For example, any two disjoint sets are not equal and
-are not subsets of each other, so \emph{all} of the following return
-\code{False}: \code{\var{a}<\var{b}}, \code{\var{a}==\var{b}}, or
-\code{\var{a}>\var{b}}.
-Accordingly, sets do not implement the \method{__cmp__} method.
-
-Since sets only define partial ordering (subset relationships), the output
-of the \method{list.sort()} method is undefined for lists of sets.
-
-The following table lists operations available in \class{ImmutableSet}
-but not found in \class{Set}:
-
-\begin{tableii}{c|l}{code}{Operation}{Result}
- \lineii{hash(\var{s})}{returns a hash value for \var{s}}
-\end{tableii}
-
-The following table lists operations available in \class{Set}
-but not found in \class{ImmutableSet}:
-
-\begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result}
- \lineiii{\var{s}.update(\var{t})}
- {\var{s} \textbar= \var{t}}
- {return set \var{s} with elements added from \var{t}}
- \lineiii{\var{s}.intersection_update(\var{t})}
- {\var{s} \&= \var{t}}
- {return set \var{s} keeping only elements also found in \var{t}}
- \lineiii{\var{s}.difference_update(\var{t})}
- {\var{s} -= \var{t}}
- {return set \var{s} after removing elements found in \var{t}}
- \lineiii{\var{s}.symmetric_difference_update(\var{t})}
- {\var{s} \textasciicircum= \var{t}}
- {return set \var{s} with elements from \var{s} or \var{t}
- but not both}
-
- \hline
- \lineiii{\var{s}.add(\var{x})}{}
- {add element \var{x} to set \var{s}}
- \lineiii{\var{s}.remove(\var{x})}{}
- {remove \var{x} from set \var{s}; raises \exception{KeyError}
- if not present}
- \lineiii{\var{s}.discard(\var{x})}{}
- {removes \var{x} from set \var{s} if present}
- \lineiii{\var{s}.pop()}{}
- {remove and return an arbitrary element from \var{s}; raises
- \exception{KeyError} if empty}
- \lineiii{\var{s}.clear()}{}
- {remove all elements from set \var{s}}
-\end{tableiii}
-
-Note, the non-operator versions of \method{update()},
-\method{intersection_update()}, \method{difference_update()}, and
-\method{symmetric_difference_update()} will accept any iterable as
-an argument.
-\versionchanged[Formerly all arguments were required to be sets]{2.3.1}
-
-Also note, the module also includes a \method{union_update()} method
-which is an alias for \method{update()}. The method is included for
-backwards compatibility. Programmers should prefer the
-\method{update()} method because it is supported by the builtin
-\class{set()} and \class{frozenset()} types.
-
-\subsection{Example \label{set-example}}
-
-\begin{verbatim}
->>> from sets import Set
->>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])
->>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])
->>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack'])
->>> employees = engineers | programmers | managers # union
->>> engineering_management = engineers & managers # intersection
->>> fulltime_management = managers - engineers - programmers # difference
->>> engineers.add('Marvin') # add element
->>> print engineers
-Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack'])
->>> employees.issuperset(engineers) # superset test
-False
->>> employees.union_update(engineers) # update from another set
->>> employees.issuperset(engineers)
-True
->>> for group in [engineers, programmers, managers, employees]:
-... group.discard('Susan') # unconditionally remove element
-... print group
-...
-Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack'])
-Set(['Janice', 'Jack', 'Sam'])
-Set(['Jane', 'Zack', 'Jack'])
-Set(['Jack', 'Sam', 'Jane', 'Marvin', 'Janice', 'John', 'Zack'])
-\end{verbatim}
-
-
-\subsection{Protocol for automatic conversion to immutable
- \label{immutable-transforms}}
-
-Sets can only contain immutable elements. For convenience, mutable
-\class{Set} objects are automatically copied to an \class{ImmutableSet}
-before being added as a set element.
-
-The mechanism is to always add a hashable element, or if it is not
-hashable, the element is checked to see if it has an
-\method{__as_immutable__()} method which returns an immutable equivalent.
-
-Since \class{Set} objects have a \method{__as_immutable__()} method
-returning an instance of \class{ImmutableSet}, it is possible to
-construct sets of sets.
-
-A similar mechanism is needed by the \method{__contains__()} and
-\method{remove()} methods which need to hash an element to check
-for membership in a set. Those methods check an element for hashability
-and, if not, check for a \method{__as_temporarily_immutable__()} method
-which returns the element wrapped by a class that provides temporary
-methods for \method{__hash__()}, \method{__eq__()}, and \method{__ne__()}.
-
-The alternate mechanism spares the need to build a separate copy of
-the original mutable object.
-
-\class{Set} objects implement the \method{__as_temporarily_immutable__()}
-method which returns the \class{Set} object wrapped by a new class
-\class{_TemporarilyImmutableSet}.
-
-The two mechanisms for adding hashability are normally invisible to the
-user; however, a conflict can arise in a multi-threaded environment
-where one thread is updating a set while another has temporarily wrapped it
-in \class{_TemporarilyImmutableSet}. In other words, sets of mutable sets
-are not thread-safe.
-
-
-\subsection{Comparison to the built-in \class{set} types
- \label{comparison-to-builtin-set}}
-
-The built-in \class{set} and \class{frozenset} types were designed based
-on lessons learned from the \module{sets} module. The key differences are:
-
-\begin{itemize}
-\item \class{Set} and \class{ImmutableSet} were renamed to \class{set} and
- \class{frozenset}.
-\item There is no equivalent to \class{BaseSet}. Instead, use
- \code{isinstance(x, (set, frozenset))}.
-\item The hash algorithm for the built-ins performs significantly better
- (fewer collisions) for most datasets.
-\item The built-in versions have more space efficient pickles.
-\item The built-in versions do not have a \method{union_update()} method.
- Instead, use the \method{update()} method which is equivalent.
-\item The built-in versions do not have a \method{_repr(sorted=True)} method.
- Instead, use the built-in \function{repr()} and \function{sorted()}
- functions: \code{repr(sorted(s))}.
-\item The built-in version does not have a protocol for automatic conversion
- to immutable. Many found this feature to be confusing and no one
- in the community reported having found real uses for it.
-\end{itemize}
Modified: python/branches/p3yk/Doc/lib/libstdtypes.tex
==============================================================================
--- python/branches/p3yk/Doc/lib/libstdtypes.tex (original)
+++ python/branches/p3yk/Doc/lib/libstdtypes.tex Wed Jan 10 02:28:32 2007
@@ -1334,16 +1334,6 @@
\method{intersection_update()}, \method{difference_update()}, and
\method{symmetric_difference_update()} methods will accept any iterable
as an argument.
-
-The design of the set types was based on lessons learned from the
-\module{sets} module.
-
-\begin{seealso}
- \seelink{comparison-to-builtin-set.html}
- {Comparison to the built-in set types}
- {Differences between the \module{sets} module and the
- built-in set types.}
-\end{seealso}
\section{Mapping Types --- \class{dict} \label{typesmapping}}
Modified: python/branches/p3yk/Lib/msilib/__init__.py
==============================================================================
--- python/branches/p3yk/Lib/msilib/__init__.py (original)
+++ python/branches/p3yk/Lib/msilib/__init__.py Wed Jan 10 02:28:32 2007
@@ -2,7 +2,7 @@
# Copyright (C) 2005 Martin v. Löwis
# Licensed to PSF under a Contributor Agreement.
from _msi import *
-import sets, os, string, re
+import os, string, re
Win64=0
@@ -184,7 +184,7 @@
def __init__(self, name):
self.name = name
self.files = []
- self.filenames = sets.Set()
+ self.filenames = set()
self.index = 0
def gen_id(self, file):
@@ -215,7 +215,7 @@
os.unlink(filename)
db.Commit()
-_directories = sets.Set()
+_directories = set()
class Directory:
def __init__(self, db, cab, basedir, physical, _logical, default, componentflags=None):
"""Create a new directory in the Directory table. There is a current component
@@ -239,8 +239,8 @@
self.physical = physical
self.logical = logical
self.component = None
- self.short_names = sets.Set()
- self.ids = sets.Set()
+ self.short_names = set()
+ self.ids = set()
self.keyfiles = {}
self.componentflags = componentflags
if basedir:
Deleted: /python/branches/p3yk/Lib/sets.py
==============================================================================
--- /python/branches/p3yk/Lib/sets.py Wed Jan 10 02:28:32 2007
+++ (empty file)
@@ -1,577 +0,0 @@
-"""Classes to represent arbitrary sets (including sets of sets).
-
-This module implements sets using dictionaries whose values are
-ignored. The usual operations (union, intersection, deletion, etc.)
-are provided as both methods and operators.
-
-Important: sets are not sequences! While they support 'x in s',
-'len(s)', and 'for x in s', none of those operations are unique for
-sequences; for example, mappings support all three as well. The
-characteristic operation for sequences is subscripting with small
-integers: s[i], for i in range(len(s)). Sets don't support
-subscripting at all. Also, sequences allow multiple occurrences and
-their elements have a definite order; sets on the other hand don't
-record multiple occurrences and don't remember the order of element
-insertion (which is why they don't support s[i]).
-
-The following classes are provided:
-
-BaseSet -- All the operations common to both mutable and immutable
- sets. This is an abstract class, not meant to be directly
- instantiated.
-
-Set -- Mutable sets, subclass of BaseSet; not hashable.
-
-ImmutableSet -- Immutable sets, subclass of BaseSet; hashable.
- An iterable argument is mandatory to create an ImmutableSet.
-
-_TemporarilyImmutableSet -- A wrapper around a Set, hashable,
- giving the same hash value as the immutable set equivalent
- would have. Do not use this class directly.
-
-Only hashable objects can be added to a Set. In particular, you cannot
-really add a Set as an element to another Set; if you try, what is
-actually added is an ImmutableSet built from it (it compares equal to
-the one you tried adding).
-
-When you ask if `x in y' where x is a Set and y is a Set or
-ImmutableSet, x is wrapped into a _TemporarilyImmutableSet z, and
-what's tested is actually `z in y'.
-
-"""
-
-# Code history:
-#
-# - Greg V. Wilson wrote the first version, using a different approach
-# to the mutable/immutable problem, and inheriting from dict.
-#
-# - Alex Martelli modified Greg's version to implement the current
-# Set/ImmutableSet approach, and make the data an attribute.
-#
-# - Guido van Rossum rewrote much of the code, made some API changes,
-# and cleaned up the docstrings.
-#
-# - Raymond Hettinger added a number of speedups and other
-# improvements.
-
-from __future__ import generators
-try:
- from itertools import ifilter, ifilterfalse
-except ImportError:
- # Code to make the module run under Py2.2
- def ifilter(predicate, iterable):
- if predicate is None:
- def predicate(x):
- return x
- for x in iterable:
- if predicate(x):
- yield x
- def ifilterfalse(predicate, iterable):
- if predicate is None:
- def predicate(x):
- return x
- for x in iterable:
- if not predicate(x):
- yield x
- try:
- True, False
- except NameError:
- True, False = (0==0, 0!=0)
-
-__all__ = ['BaseSet', 'Set', 'ImmutableSet']
-
-class BaseSet(object):
- """Common base class for mutable and immutable sets."""
-
- __slots__ = ['_data']
-
- # Constructor
-
- def __init__(self):
- """This is an abstract class."""
- # Don't call this from a concrete subclass!
- if self.__class__ is BaseSet:
- raise TypeError, ("BaseSet is an abstract class. "
- "Use Set or ImmutableSet.")
-
- # Standard protocols: __len__, __repr__, __str__, __iter__
-
- def __len__(self):
- """Return the number of elements of a set."""
- return len(self._data)
-
- def __repr__(self):
- """Return string representation of a set.
-
- This looks like 'Set([<list of elements>])'.
- """
- return self._repr()
-
- # __str__ is the same as __repr__
- __str__ = __repr__
-
- def _repr(self, sorted=False):
- elements = self._data.keys()
- if sorted:
- elements.sort()
- return '%s(%r)' % (self.__class__.__name__, elements)
-
- def __iter__(self):
- """Return an iterator over the elements or a set.
-
- This is the keys iterator for the underlying dict.
- """
- return self._data.iterkeys()
-
- # Three-way comparison is not supported. However, because __eq__ is
- # tried before __cmp__, if Set x == Set y, x.__eq__(y) returns True and
- # then cmp(x, y) returns 0 (Python doesn't actually call __cmp__ in this
- # case).
-
- def __cmp__(self, other):
- raise TypeError, "can't compare sets using cmp()"
-
- # Equality comparisons using the underlying dicts. Mixed-type comparisons
- # are allowed here, where Set == z for non-Set z always returns False,
- # and Set != z always True. This allows expressions like "x in y" to
- # give the expected result when y is a sequence of mixed types, not
- # raising a pointless TypeError just because y contains a Set, or x is
- # a Set and y contain's a non-set ("in" invokes only __eq__).
- # Subtle: it would be nicer if __eq__ and __ne__ could return
- # NotImplemented instead of True or False. Then the other comparand
- # would get a chance to determine the result, and if the other comparand
- # also returned NotImplemented then it would fall back to object address
- # comparison (which would always return False for __eq__ and always
- # True for __ne__). However, that doesn't work, because this type
- # *also* implements __cmp__: if, e.g., __eq__ returns NotImplemented,
- # Python tries __cmp__ next, and the __cmp__ here then raises TypeError.
-
- def __eq__(self, other):
- if isinstance(other, BaseSet):
- return self._data == other._data
- else:
- return False
-
- def __ne__(self, other):
- if isinstance(other, BaseSet):
- return self._data != other._data
- else:
- return True
-
- # Copying operations
-
- def copy(self):
- """Return a shallow copy of a set."""
- result = self.__class__()
- result._data.update(self._data)
- return result
-
- __copy__ = copy # For the copy module
-
- def __deepcopy__(self, memo):
- """Return a deep copy of a set; used by copy module."""
- # This pre-creates the result and inserts it in the memo
- # early, in case the deep copy recurses into another reference
- # to this same set. A set can't be an element of itself, but
- # it can certainly contain an object that has a reference to
- # itself.
- from copy import deepcopy
- result = self.__class__()
- memo[id(self)] = result
- data = result._data
- value = True
- for elt in self:
- data[deepcopy(elt, memo)] = value
- return result
-
- # Standard set operations: union, intersection, both differences.
- # Each has an operator version (e.g. __or__, invoked with |) and a
- # method version (e.g. union).
- # Subtle: Each pair requires distinct code so that the outcome is
- # correct when the type of other isn't suitable. For example, if
- # we did "union = __or__" instead, then Set().union(3) would return
- # NotImplemented instead of raising TypeError (albeit that *why* it
- # raises TypeError as-is is also a bit subtle).
-
- def __or__(self, other):
- """Return the union of two sets as a new set.
-
- (I.e. all elements that are in either set.)
- """
- if not isinstance(other, BaseSet):
- return NotImplemented
- return self.union(other)
-
- def union(self, other):
- """Return the union of two sets as a new set.
-
- (I.e. all elements that are in either set.)
- """
- result = self.__class__(self)
- result._update(other)
- return result
-
- def __and__(self, other):
- """Return the intersection of two sets as a new set.
-
- (I.e. all elements that are in both sets.)
- """
- if not isinstance(other, BaseSet):
- return NotImplemented
- return self.intersection(other)
-
- def intersection(self, other):
- """Return the intersection of two sets as a new set.
-
- (I.e. all elements that are in both sets.)
- """
- if not isinstance(other, BaseSet):
- other = Set(other)
- if len(self) <= len(other):
- little, big = self, other
- else:
- little, big = other, self
- common = ifilter(big._data.__contains__, little)
- return self.__class__(common)
-
- def __xor__(self, other):
- """Return the symmetric difference of two sets as a new set.
-
- (I.e. all elements that are in exactly one of the sets.)
- """
- if not isinstance(other, BaseSet):
- return NotImplemented
- return self.symmetric_difference(other)
-
- def symmetric_difference(self, other):
- """Return the symmetric difference of two sets as a new set.
-
- (I.e. all elements that are in exactly one of the sets.)
- """
- result = self.__class__()
- data = result._data
- value = True
- selfdata = self._data
- try:
- otherdata = other._data
- except AttributeError:
- otherdata = Set(other)._data
- for elt in ifilterfalse(otherdata.__contains__, selfdata):
- data[elt] = value
- for elt in ifilterfalse(selfdata.__contains__, otherdata):
- data[elt] = value
- return result
-
- def __sub__(self, other):
- """Return the difference of two sets as a new Set.
-
- (I.e. all elements that are in this set and not in the other.)
- """
- if not isinstance(other, BaseSet):
- return NotImplemented
- return self.difference(other)
-
- def difference(self, other):
- """Return the difference of two sets as a new Set.
-
- (I.e. all elements that are in this set and not in the other.)
- """
- result = self.__class__()
- data = result._data
- try:
- otherdata = other._data
- except AttributeError:
- otherdata = Set(other)._data
- value = True
- for elt in ifilterfalse(otherdata.__contains__, self):
- data[elt] = value
- return result
-
- # Membership test
-
- def __contains__(self, element):
- """Report whether an element is a member of a set.
-
- (Called in response to the expression `element in self'.)
- """
- try:
- return element in self._data
- except TypeError:
- transform = getattr(element, "__as_temporarily_immutable__", None)
- if transform is None:
- raise # re-raise the TypeError exception we caught
- return transform() in self._data
-
- # Subset and superset test
-
- def issubset(self, other):
- """Report whether another set contains this set."""
- self._binary_sanity_check(other)
- if len(self) > len(other): # Fast check for obvious cases
- return False
- for elt in ifilterfalse(other._data.__contains__, self):
- return False
- return True
-
- def issuperset(self, other):
- """Report whether this set contains another set."""
- self._binary_sanity_check(other)
- if len(self) < len(other): # Fast check for obvious cases
- return False
- for elt in ifilterfalse(self._data.__contains__, other):
- return False
- return True
-
- # Inequality comparisons using the is-subset relation.
- __le__ = issubset
- __ge__ = issuperset
-
- def __lt__(self, other):
- self._binary_sanity_check(other)
- return len(self) < len(other) and self.issubset(other)
-
- def __gt__(self, other):
- self._binary_sanity_check(other)
- return len(self) > len(other) and self.issuperset(other)
-
- # Assorted helpers
-
- def _binary_sanity_check(self, other):
- # Check that the other argument to a binary operation is also
- # a set, raising a TypeError otherwise.
- if not isinstance(other, BaseSet):
- raise TypeError, "Binary operation only permitted between sets"
-
- def _compute_hash(self):
- # Calculate hash code for a set by xor'ing the hash codes of
- # the elements. This ensures that the hash code does not depend
- # on the order in which elements are added to the set. This is
- # not called __hash__ because a BaseSet should not be hashable;
- # only an ImmutableSet is hashable.
- result = 0
- for elt in self:
- result ^= hash(elt)
- return result
-
- def _update(self, iterable):
- # The main loop for update() and the subclass __init__() methods.
- data = self._data
-
- # Use the fast update() method when a dictionary is available.
- if isinstance(iterable, BaseSet):
- data.update(iterable._data)
- return
-
- value = True
-
- if type(iterable) in (list, tuple, xrange):
- # Optimized: we know that __iter__() and next() can't
- # raise TypeError, so we can move 'try:' out of the loop.
- it = iter(iterable)
- while True:
- try:
- for element in it:
- data[element] = value
- return
- except TypeError:
- transform = getattr(element, "__as_immutable__", None)
- if transform is None:
- raise # re-raise the TypeError exception we caught
- data[transform()] = value
- else:
- # Safe: only catch TypeError where intended
- for element in iterable:
- try:
- data[element] = value
- except TypeError:
- transform = getattr(element, "__as_immutable__", None)
- if transform is None:
- raise # re-raise the TypeError exception we caught
- data[transform()] = value
-
-
-class ImmutableSet(BaseSet):
- """Immutable set class."""
-
- __slots__ = ['_hashcode']
-
- # BaseSet + hashing
-
- def __init__(self, iterable=None):
- """Construct an immutable set from an optional iterable."""
- self._hashcode = None
- self._data = {}
- if iterable is not None:
- self._update(iterable)
-
- def __hash__(self):
- if self._hashcode is None:
- self._hashcode = self._compute_hash()
- return self._hashcode
-
- def __getstate__(self):
- return self._data, self._hashcode
-
- def __setstate__(self, state):
- self._data, self._hashcode = state
-
-class Set(BaseSet):
- """ Mutable set class."""
-
- __slots__ = []
-
- # BaseSet + operations requiring mutability; no hashing
-
- def __init__(self, iterable=None):
- """Construct a set from an optional iterable."""
- self._data = {}
- if iterable is not None:
- self._update(iterable)
-
- def __getstate__(self):
- # getstate's results are ignored if it is not
- return self._data,
-
- def __setstate__(self, data):
- self._data, = data
-
- def __hash__(self):
- """A Set cannot be hashed."""
- # We inherit object.__hash__, so we must deny this explicitly
- raise TypeError, "Can't hash a Set, only an ImmutableSet."
-
- # In-place union, intersection, differences.
- # Subtle: The xyz_update() functions deliberately return None,
- # as do all mutating operations on built-in container types.
- # The __xyz__ spellings have to return self, though.
-
- def __ior__(self, other):
- """Update a set with the union of itself and another."""
- self._binary_sanity_check(other)
- self._data.update(other._data)
- return self
-
- def union_update(self, other):
- """Update a set with the union of itself and another."""
- self._update(other)
-
- def __iand__(self, other):
- """Update a set with the intersection of itself and another."""
- self._binary_sanity_check(other)
- self._data = (self & other)._data
- return self
-
- def intersection_update(self, other):
- """Update a set with the intersection of itself and another."""
- if isinstance(other, BaseSet):
- self &= other
- else:
- self._data = (self.intersection(other))._data
-
- def __ixor__(self, other):
- """Update a set with the symmetric difference of itself and another."""
- self._binary_sanity_check(other)
- self.symmetric_difference_update(other)
- return self
-
- def symmetric_difference_update(self, other):
- """Update a set with the symmetric difference of itself and another."""
- data = self._data
- value = True
- if not isinstance(other, BaseSet):
- other = Set(other)
- if self is other:
- self.clear()
- for elt in other:
- if elt in data:
- del data[elt]
- else:
- data[elt] = value
-
- def __isub__(self, other):
- """Remove all elements of another set from this set."""
- self._binary_sanity_check(other)
- self.difference_update(other)
- return self
-
- def difference_update(self, other):
- """Remove all elements of another set from this set."""
- data = self._data
- if not isinstance(other, BaseSet):
- other = Set(other)
- if self is other:
- self.clear()
- for elt in ifilter(data.__contains__, other):
- del data[elt]
-
- # Python dict-like mass mutations: update, clear
-
- def update(self, iterable):
- """Add all values from an iterable (such as a list or file)."""
- self._update(iterable)
-
- def clear(self):
- """Remove all elements from this set."""
- self._data.clear()
-
- # Single-element mutations: add, remove, discard
-
- def add(self, element):
- """Add an element to a set.
-
- This has no effect if the element is already present.
- """
- try:
- self._data[element] = True
- except TypeError:
- transform = getattr(element, "__as_immutable__", None)
- if transform is None:
- raise # re-raise the TypeError exception we caught
- self._data[transform()] = True
-
- def remove(self, element):
- """Remove an element from a set; it must be a member.
-
- If the element is not a member, raise a KeyError.
- """
- try:
- del self._data[element]
- except TypeError:
- transform = getattr(element, "__as_temporarily_immutable__", None)
- if transform is None:
- raise # re-raise the TypeError exception we caught
- del self._data[transform()]
-
- def discard(self, element):
- """Remove an element from a set if it is a member.
-
- If the element is not a member, do nothing.
- """
- try:
- self.remove(element)
- except KeyError:
- pass
-
- def pop(self):
- """Remove and return an arbitrary set element."""
- return self._data.popitem()[0]
-
- def __as_immutable__(self):
- # Return a copy of self as an immutable set
- return ImmutableSet(self)
-
- def __as_temporarily_immutable__(self):
- # Return self wrapped in a temporarily immutable set
- return _TemporarilyImmutableSet(self)
-
-
-class _TemporarilyImmutableSet(BaseSet):
- # Wrap a mutable set as if it was temporarily immutable.
- # This only supplies hashing and equality comparisons.
-
- def __init__(self, set):
- self._set = set
- self._data = set._data # Needed by ImmutableSet.__eq__()
-
- def __hash__(self):
- return self._set._compute_hash()
Modified: python/branches/p3yk/Lib/test/test_cookielib.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_cookielib.py (original)
+++ python/branches/p3yk/Lib/test/test_cookielib.py Wed Jan 10 02:28:32 2007
@@ -1723,7 +1723,6 @@
def test_main(verbose=None):
- from test import test_sets
test_support.run_unittest(
DateTimeTests,
HeaderTests,
Modified: python/branches/p3yk/Lib/test/test_set.py
==============================================================================
--- python/branches/p3yk/Lib/test/test_set.py (original)
+++ python/branches/p3yk/Lib/test/test_set.py Wed Jan 10 02:28:32 2007
@@ -1451,7 +1451,6 @@
#==============================================================================
def test_main(verbose=None):
- from test import test_sets
test_classes = (
TestSet,
TestSetSubclass,
Deleted: /python/branches/p3yk/Lib/test/test_sets.py
==============================================================================
--- /python/branches/p3yk/Lib/test/test_sets.py Wed Jan 10 02:28:32 2007
+++ (empty file)
@@ -1,853 +0,0 @@
-#!/usr/bin/env python
-
-import unittest, operator, copy, pickle, random
-from sets import Set, ImmutableSet
-from test import test_support
-
-empty_set = Set()
-
-#==============================================================================
-
-class TestBasicOps(unittest.TestCase):
-
- def test_repr(self):
- if self.repr is not None:
- self.assertEqual(repr(self.set), self.repr)
-
- def test_length(self):
- self.assertEqual(len(self.set), self.length)
-
- def test_self_equality(self):
- self.assertEqual(self.set, self.set)
-
- def test_equivalent_equality(self):
- self.assertEqual(self.set, self.dup)
-
- def test_copy(self):
- self.assertEqual(self.set.copy(), self.dup)
-
- def test_self_union(self):
- result = self.set | self.set
- self.assertEqual(result, self.dup)
-
- def test_empty_union(self):
- result = self.set | empty_set
- self.assertEqual(result, self.dup)
-
- def test_union_empty(self):
- result = empty_set | self.set
- self.assertEqual(result, self.dup)
-
- def test_self_intersection(self):
- result = self.set & self.set
- self.assertEqual(result, self.dup)
-
- def test_empty_intersection(self):
- result = self.set & empty_set
- self.assertEqual(result, empty_set)
-
- def test_intersection_empty(self):
- result = empty_set & self.set
- self.assertEqual(result, empty_set)
-
- def test_self_symmetric_difference(self):
- result = self.set ^ self.set
- self.assertEqual(result, empty_set)
-
- def checkempty_symmetric_difference(self):
- result = self.set ^ empty_set
- self.assertEqual(result, self.set)
-
- def test_self_difference(self):
- result = self.set - self.set
- self.assertEqual(result, empty_set)
-
- def test_empty_difference(self):
- result = self.set - empty_set
- self.assertEqual(result, self.dup)
-
- def test_empty_difference_rev(self):
- result = empty_set - self.set
- self.assertEqual(result, empty_set)
-
- def test_iteration(self):
- for v in self.set:
- self.assert_(v in self.values)
-
- def test_pickling(self):
- p = pickle.dumps(self.set)
- copy = pickle.loads(p)
- self.assertEqual(self.set, copy,
- "%s != %s" % (self.set, copy))
-
-#------------------------------------------------------------------------------
-
-class TestBasicOpsEmpty(TestBasicOps):
- def setUp(self):
- self.case = "empty set"
- self.values = []
- self.set = Set(self.values)
- self.dup = Set(self.values)
- self.length = 0
- self.repr = "Set([])"
-
-#------------------------------------------------------------------------------
-
-class TestBasicOpsSingleton(TestBasicOps):
- def setUp(self):
- self.case = "unit set (number)"
- self.values = [3]
- self.set = Set(self.values)
- self.dup = Set(self.values)
- self.length = 1
- self.repr = "Set([3])"
-
- def test_in(self):
- self.failUnless(3 in self.set)
-
- def test_not_in(self):
- self.failUnless(2 not in self.set)
-
-#------------------------------------------------------------------------------
-
-class TestBasicOpsTuple(TestBasicOps):
- def setUp(self):
- self.case = "unit set (tuple)"
- self.values = [(0, "zero")]
- self.set = Set(self.values)
- self.dup = Set(self.values)
- self.length = 1
- self.repr = "Set([(0, 'zero')])"
-
- def test_in(self):
- self.failUnless((0, "zero") in self.set)
-
- def test_not_in(self):
- self.failUnless(9 not in self.set)
-
-#------------------------------------------------------------------------------
-
-class TestBasicOpsTriple(TestBasicOps):
- def setUp(self):
- self.case = "triple set"
- self.values = [0, "zero", operator.add]
- self.set = Set(self.values)
- self.dup = Set(self.values)
- self.length = 3
- self.repr = None
-
-#==============================================================================
-
-def baditer():
- raise TypeError
- yield True
-
-def gooditer():
- yield True
-
-class TestExceptionPropagation(unittest.TestCase):
- """SF 628246: Set constructor should not trap iterator TypeErrors"""
-
- def test_instanceWithException(self):
- self.assertRaises(TypeError, Set, baditer())
-
- def test_instancesWithoutException(self):
- # All of these iterables should load without exception.
- Set([1,2,3])
- Set((1,2,3))
- Set({'one':1, 'two':2, 'three':3})
- Set(xrange(3))
- Set('abc')
- Set(gooditer())
-
-#==============================================================================
-
-class TestSetOfSets(unittest.TestCase):
- def test_constructor(self):
- inner = Set([1])
- outer = Set([inner])
- element = outer.pop()
- self.assertEqual(type(element), ImmutableSet)
- outer.add(inner) # Rebuild set of sets with .add method
- outer.remove(inner)
- self.assertEqual(outer, Set()) # Verify that remove worked
- outer.discard(inner) # Absence of KeyError indicates working fine
-
-#==============================================================================
-
-class TestBinaryOps(unittest.TestCase):
- def setUp(self):
- self.set = Set((2, 4, 6))
-
- def test_eq(self): # SF bug 643115
- self.assertEqual(self.set, Set({2:1,4:3,6:5}))
-
- def test_union_subset(self):
- result = self.set | Set([2])
- self.assertEqual(result, Set((2, 4, 6)))
-
- def test_union_superset(self):
- result = self.set | Set([2, 4, 6, 8])
- self.assertEqual(result, Set([2, 4, 6, 8]))
-
- def test_union_overlap(self):
- result = self.set | Set([3, 4, 5])
- self.assertEqual(result, Set([2, 3, 4, 5, 6]))
-
- def test_union_non_overlap(self):
- result = self.set | Set([8])
- self.assertEqual(result, Set([2, 4, 6, 8]))
-
- def test_intersection_subset(self):
- result = self.set & Set((2, 4))
- self.assertEqual(result, Set((2, 4)))
-
- def test_intersection_superset(self):
- result = self.set & Set([2, 4, 6, 8])
- self.assertEqual(result, Set([2, 4, 6]))
-
- def test_intersection_overlap(self):
- result = self.set & Set([3, 4, 5])
- self.assertEqual(result, Set([4]))
-
- def test_intersection_non_overlap(self):
- result = self.set & Set([8])
- self.assertEqual(result, empty_set)
-
- def test_sym_difference_subset(self):
- result = self.set ^ Set((2, 4))
- self.assertEqual(result, Set([6]))
-
- def test_sym_difference_superset(self):
- result = self.set ^ Set((2, 4, 6, 8))
- self.assertEqual(result, Set([8]))
-
- def test_sym_difference_overlap(self):
- result = self.set ^ Set((3, 4, 5))
- self.assertEqual(result, Set([2, 3, 5, 6]))
-
- def test_sym_difference_non_overlap(self):
- result = self.set ^ Set([8])
- self.assertEqual(result, Set([2, 4, 6, 8]))
-
- def test_cmp(self):
- a, b = Set('a'), Set('b')
- self.assertRaises(TypeError, cmp, a, b)
-
- # In py3k, this works!
- self.assertRaises(TypeError, cmp, a, a)
-
- self.assertRaises(TypeError, cmp, a, 12)
- self.assertRaises(TypeError, cmp, "abc", a)
-
- def test_inplace_on_self(self):
- t = self.set.copy()
- t |= t
- self.assertEqual(t, self.set)
- t &= t
- self.assertEqual(t, self.set)
- t -= t
- self.assertEqual(len(t), 0)
- t = self.set.copy()
- t ^= t
- self.assertEqual(len(t), 0)
-
-
-#==============================================================================
-
-class TestUpdateOps(unittest.TestCase):
- def setUp(self):
- self.set = Set((2, 4, 6))
-
- def test_union_subset(self):
- self.set |= Set([2])
- self.assertEqual(self.set, Set((2, 4, 6)))
-
- def test_union_superset(self):
- self.set |= Set([2, 4, 6, 8])
- self.assertEqual(self.set, Set([2, 4, 6, 8]))
-
- def test_union_overlap(self):
- self.set |= Set([3, 4, 5])
- self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))
-
- def test_union_non_overlap(self):
- self.set |= Set([8])
- self.assertEqual(self.set, Set([2, 4, 6, 8]))
-
- def test_union_method_call(self):
- self.set.union_update(Set([3, 4, 5]))
- self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))
-
- def test_intersection_subset(self):
- self.set &= Set((2, 4))
- self.assertEqual(self.set, Set((2, 4)))
-
- def test_intersection_superset(self):
- self.set &= Set([2, 4, 6, 8])
- self.assertEqual(self.set, Set([2, 4, 6]))
-
- def test_intersection_overlap(self):
- self.set &= Set([3, 4, 5])
- self.assertEqual(self.set, Set([4]))
-
- def test_intersection_non_overlap(self):
- self.set &= Set([8])
- self.assertEqual(self.set, empty_set)
-
- def test_intersection_method_call(self):
- self.set.intersection_update(Set([3, 4, 5]))
- self.assertEqual(self.set, Set([4]))
-
- def test_sym_difference_subset(self):
- self.set ^= Set((2, 4))
- self.assertEqual(self.set, Set([6]))
-
- def test_sym_difference_superset(self):
- self.set ^= Set((2, 4, 6, 8))
- self.assertEqual(self.set, Set([8]))
-
- def test_sym_difference_overlap(self):
- self.set ^= Set((3, 4, 5))
- self.assertEqual(self.set, Set([2, 3, 5, 6]))
-
- def test_sym_difference_non_overlap(self):
- self.set ^= Set([8])
- self.assertEqual(self.set, Set([2, 4, 6, 8]))
-
- def test_sym_difference_method_call(self):
- self.set.symmetric_difference_update(Set([3, 4, 5]))
- self.assertEqual(self.set, Set([2, 3, 5, 6]))
-
- def test_difference_subset(self):
- self.set -= Set((2, 4))
- self.assertEqual(self.set, Set([6]))
-
- def test_difference_superset(self):
- self.set -= Set((2, 4, 6, 8))
- self.assertEqual(self.set, Set([]))
-
- def test_difference_overlap(self):
- self.set -= Set((3, 4, 5))
- self.assertEqual(self.set, Set([2, 6]))
-
- def test_difference_non_overlap(self):
- self.set -= Set([8])
- self.assertEqual(self.set, Set([2, 4, 6]))
-
- def test_difference_method_call(self):
- self.set.difference_update(Set([3, 4, 5]))
- self.assertEqual(self.set, Set([2, 6]))
-
-#==============================================================================
-
-class TestMutate(unittest.TestCase):
- def setUp(self):
- self.values = ["a", "b", "c"]
- self.set = Set(self.values)
-
- def test_add_present(self):
- self.set.add("c")
- self.assertEqual(self.set, Set("abc"))
-
- def test_add_absent(self):
- self.set.add("d")
- self.assertEqual(self.set, Set("abcd"))
-
- def test_add_until_full(self):
- tmp = Set()
- expected_len = 0
- for v in self.values:
- tmp.add(v)
- expected_len += 1
- self.assertEqual(len(tmp), expected_len)
- self.assertEqual(tmp, self.set)
-
- def test_remove_present(self):
- self.set.remove("b")
- self.assertEqual(self.set, Set("ac"))
-
- def test_remove_absent(self):
- try:
- self.set.remove("d")
- self.fail("Removing missing element should have raised LookupError")
- except LookupError:
- pass
-
- def test_remove_until_empty(self):
- expected_len = len(self.set)
- for v in self.values:
- self.set.remove(v)
- expected_len -= 1
- self.assertEqual(len(self.set), expected_len)
-
- def test_discard_present(self):
- self.set.discard("c")
- self.assertEqual(self.set, Set("ab"))
-
- def test_discard_absent(self):
- self.set.discard("d")
- self.assertEqual(self.set, Set("abc"))
-
- def test_clear(self):
- self.set.clear()
- self.assertEqual(len(self.set), 0)
-
- def test_pop(self):
- popped = {}
- while self.set:
- popped[self.set.pop()] = None
- self.assertEqual(len(popped), len(self.values))
- for v in self.values:
- self.failUnless(v in popped)
-
- def test_update_empty_tuple(self):
- self.set.union_update(())
- self.assertEqual(self.set, Set(self.values))
-
- def test_update_unit_tuple_overlap(self):
- self.set.union_update(("a",))
- self.assertEqual(self.set, Set(self.values))
-
- def test_update_unit_tuple_non_overlap(self):
- self.set.union_update(("a", "z"))
- self.assertEqual(self.set, Set(self.values + ["z"]))
-
-#==============================================================================
-
-class TestSubsets(unittest.TestCase):
-
- case2method = {"<=": "issubset",
- ">=": "issuperset",
- }
-
- reverse = {"==": "==",
- "!=": "!=",
- "<": ">",
- ">": "<",
- "<=": ">=",
- ">=": "<=",
- }
-
- def test_issubset(self):
- x = self.left
- y = self.right
- for case in "!=", "==", "<", "<=", ">", ">=":
- expected = case in self.cases
- # Test the binary infix spelling.
- result = eval("x" + case + "y", locals())
- self.assertEqual(result, expected)
- # Test the "friendly" method-name spelling, if one exists.
- if case in TestSubsets.case2method:
- method = getattr(x, TestSubsets.case2method[case])
- result = method(y)
- self.assertEqual(result, expected)
-
- # Now do the same for the operands reversed.
- rcase = TestSubsets.reverse[case]
- result = eval("y" + rcase + "x", locals())
- self.assertEqual(result, expected)
- if rcase in TestSubsets.case2method:
- method = getattr(y, TestSubsets.case2method[rcase])
- result = method(x)
- self.assertEqual(result, expected)
-#------------------------------------------------------------------------------
-
-class TestSubsetEqualEmpty(TestSubsets):
- left = Set()
- right = Set()
- name = "both empty"
- cases = "==", "<=", ">="
-
-#------------------------------------------------------------------------------
-
-class TestSubsetEqualNonEmpty(TestSubsets):
- left = Set([1, 2])
- right = Set([1, 2])
- name = "equal pair"
- cases = "==", "<=", ">="
-
-#------------------------------------------------------------------------------
-
-class TestSubsetEmptyNonEmpty(TestSubsets):
- left = Set()
- right = Set([1, 2])
- name = "one empty, one non-empty"
- cases = "!=", "<", "<="
-
-#------------------------------------------------------------------------------
-
-class TestSubsetPartial(TestSubsets):
- left = Set([1])
- right = Set([1, 2])
- name = "one a non-empty proper subset of other"
- cases = "!=", "<", "<="
-
-#------------------------------------------------------------------------------
-
-class TestSubsetNonOverlap(TestSubsets):
- left = Set([1])
- right = Set([2])
- name = "neither empty, neither contains"
- cases = "!="
-
-#==============================================================================
-
-class TestOnlySetsInBinaryOps(unittest.TestCase):
-
- def test_eq_ne(self):
- # Unlike the others, this is testing that == and != *are* allowed.
- self.assertEqual(self.other == self.set, False)
- self.assertEqual(self.set == self.other, False)
- self.assertEqual(self.other != self.set, True)
- self.assertEqual(self.set != self.other, True)
-
- def test_ge_gt_le_lt(self):
- self.assertRaises(TypeError, lambda: self.set < self.other)
- self.assertRaises(TypeError, lambda: self.set <= self.other)
- self.assertRaises(TypeError, lambda: self.set > self.other)
- self.assertRaises(TypeError, lambda: self.set >= self.other)
-
- self.assertRaises(TypeError, lambda: self.other < self.set)
- self.assertRaises(TypeError, lambda: self.other <= self.set)
- self.assertRaises(TypeError, lambda: self.other > self.set)
- self.assertRaises(TypeError, lambda: self.other >= self.set)
-
- def test_union_update_operator(self):
- try:
- self.set |= self.other
- except TypeError:
- pass
- else:
- self.fail("expected TypeError")
-
- def test_union_update(self):
- if self.otherIsIterable:
- self.set.union_update(self.other)
- else:
- self.assertRaises(TypeError, self.set.union_update, self.other)
-
- def test_union(self):
- self.assertRaises(TypeError, lambda: self.set | self.other)
- self.assertRaises(TypeError, lambda: self.other | self.set)
- if self.otherIsIterable:
- self.set.union(self.other)
- else:
- self.assertRaises(TypeError, self.set.union, self.other)
-
- def test_intersection_update_operator(self):
- try:
- self.set &= self.other
- except TypeError:
- pass
- else:
- self.fail("expected TypeError")
-
- def test_intersection_update(self):
- if self.otherIsIterable:
- self.set.intersection_update(self.other)
- else:
- self.assertRaises(TypeError,
- self.set.intersection_update,
- self.other)
-
- def test_intersection(self):
- self.assertRaises(TypeError, lambda: self.set & self.other)
- self.assertRaises(TypeError, lambda: self.other & self.set)
- if self.otherIsIterable:
- self.set.intersection(self.other)
- else:
- self.assertRaises(TypeError, self.set.intersection, self.other)
-
- def test_sym_difference_update_operator(self):
- try:
- self.set ^= self.other
- except TypeError:
- pass
- else:
- self.fail("expected TypeError")
-
- def test_sym_difference_update(self):
- if self.otherIsIterable:
- self.set.symmetric_difference_update(self.other)
- else:
- self.assertRaises(TypeError,
- self.set.symmetric_difference_update,
- self.other)
-
- def test_sym_difference(self):
- self.assertRaises(TypeError, lambda: self.set ^ self.other)
- self.assertRaises(TypeError, lambda: self.other ^ self.set)
- if self.otherIsIterable:
- self.set.symmetric_difference(self.other)
- else:
- self.assertRaises(TypeError, self.set.symmetric_difference, self.other)
-
- def test_difference_update_operator(self):
- try:
- self.set -= self.other
- except TypeError:
- pass
- else:
- self.fail("expected TypeError")
-
- def test_difference_update(self):
- if self.otherIsIterable:
- self.set.difference_update(self.other)
- else:
- self.assertRaises(TypeError,
- self.set.difference_update,
- self.other)
-
- def test_difference(self):
- self.assertRaises(TypeError, lambda: self.set - self.other)
- self.assertRaises(TypeError, lambda: self.other - self.set)
- if self.otherIsIterable:
- self.set.difference(self.other)
- else:
- self.assertRaises(TypeError, self.set.difference, self.other)
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsNumeric(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = 19
- self.otherIsIterable = False
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsDict(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = {1:2, 3:4}
- self.otherIsIterable = True
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = operator.add
- self.otherIsIterable = False
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsTuple(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = (2, 4, 6)
- self.otherIsIterable = True
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsString(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = 'abc'
- self.otherIsIterable = True
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):
- def setUp(self):
- def gen():
- for i in xrange(0, 10, 2):
- yield i
- self.set = Set((1, 2, 3))
- self.other = gen()
- self.otherIsIterable = True
-
-#------------------------------------------------------------------------------
-
-class TestOnlySetsofSets(TestOnlySetsInBinaryOps):
- def setUp(self):
- self.set = Set((1, 2, 3))
- self.other = [Set('ab'), ImmutableSet('cd')]
- self.otherIsIterable = True
-
-#==============================================================================
-
-class TestCopying(unittest.TestCase):
-
- def test_copy(self):
- dup = self.set.copy()
- dup_list = sorted(dup, key=repr)
- set_list = sorted(self.set, key=repr)
- self.assertEqual(len(dup_list), len(set_list))
- for i in range(len(dup_list)):
- self.failUnless(dup_list[i] is set_list[i])
-
- def test_deep_copy(self):
- dup = copy.deepcopy(self.set)
- ##print type(dup), repr(dup)
- dup_list = sorted(dup, key=repr)
- set_list = sorted(self.set, key=repr)
- self.assertEqual(len(dup_list), len(set_list))
- for i in range(len(dup_list)):
- self.assertEqual(dup_list[i], set_list[i])
-
-#------------------------------------------------------------------------------
-
-class TestCopyingEmpty(TestCopying):
- def setUp(self):
- self.set = Set()
-
-#------------------------------------------------------------------------------
-
-class TestCopyingSingleton(TestCopying):
- def setUp(self):
- self.set = Set(["hello"])
-
-#------------------------------------------------------------------------------
-
-class TestCopyingTriple(TestCopying):
- def setUp(self):
- self.set = Set(["zero", 0, None])
-
-#------------------------------------------------------------------------------
-
-class TestCopyingTuple(TestCopying):
- def setUp(self):
- self.set = Set([(1, 2)])
-
-#------------------------------------------------------------------------------
-
-class TestCopyingNested(TestCopying):
- def setUp(self):
- self.set = Set([((1, 2), (3, 4))])
-
-#==============================================================================
-
-class TestIdentities(unittest.TestCase):
- def setUp(self):
- self.a = Set([random.randrange(100) for i in xrange(50)])
- self.b = Set([random.randrange(100) for i in xrange(50)])
-
- def test_binopsVsSubsets(self):
- a, b = self.a, self.b
- self.assert_(a - b <= a)
- self.assert_(b - a <= b)
- self.assert_(a & b <= a)
- self.assert_(a & b <= b)
- self.assert_(a | b >= a)
- self.assert_(a | b >= b)
- self.assert_(a ^ b <= a | b)
-
- def test_commutativity(self):
- a, b = self.a, self.b
- self.assertEqual(a&b, b&a)
- self.assertEqual(a|b, b|a)
- self.assertEqual(a^b, b^a)
- if a != b:
- self.assertNotEqual(a-b, b-a)
-
- def test_reflexsive_relations(self):
- a, zero = self.a, Set()
- self.assertEqual(a ^ a, zero)
- self.assertEqual(a - a, zero)
- self.assertEqual(a | a, a)
- self.assertEqual(a & a, a)
- self.assert_(a <= a)
- self.assert_(a >= a)
- self.assert_(a == a)
-
- def test_summations(self):
- # check that sums of parts equal the whole
- a, b = self.a, self.b
- self.assertEqual((a-b)|(a&b)|(b-a), a|b)
- self.assertEqual((a&b)|(a^b), a|b)
- self.assertEqual(a|(b-a), a|b)
- self.assertEqual((a-b)|b, a|b)
- self.assertEqual((a-b)|(a&b), a)
- self.assertEqual((b-a)|(a&b), b)
- self.assertEqual((a-b)|(b-a), a^b)
-
- def test_exclusion(self):
- # check that inverse operations do not overlap
- a, b, zero = self.a, self.b, Set()
- self.assertEqual((a-b)&b, zero)
- self.assertEqual((b-a)&a, zero)
- self.assertEqual((a&b)&(a^b), zero)
-
- def test_cardinality_relations(self):
- a, b = self.a, self.b
- self.assertEqual(len(a), len(a-b) + len(a&b))
- self.assertEqual(len(b), len(b-a) + len(a&b))
- self.assertEqual(len(a^b), len(a-b) + len(b-a))
- self.assertEqual(len(a|b), len(a-b) + len(a&b) + len(b-a))
- self.assertEqual(len(a^b) + len(a&b), len(a|b))
-
-#==============================================================================
-
-libreftest = """
-Example from the Library Reference: Doc/lib/libsets.tex
-
->>> from sets import Set as Base # override _repr to get sorted output
->>> class Set(Base):
-... def _repr(self):
-... return Base._repr(self, sorted=True)
->>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])
->>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])
->>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack'])
->>> employees = engineers | programmers | managers # union
->>> engineering_management = engineers & managers # intersection
->>> fulltime_management = managers - engineers - programmers # difference
->>> engineers.add('Marvin')
->>> print engineers
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])
->>> employees.issuperset(engineers) # superset test
-False
->>> employees.union_update(engineers) # update from another set
->>> employees.issuperset(engineers)
-True
->>> for group in [engineers, programmers, managers, employees]:
-... group.discard('Susan') # unconditionally remove element
-... print group
-...
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])
-Set(['Jack', 'Janice', 'Sam'])
-Set(['Jack', 'Jane', 'Zack'])
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin', 'Sam', 'Zack'])
-"""
-
-#==============================================================================
-
-__test__ = {'libreftest' : libreftest}
-
-def test_main(verbose=None):
- import doctest
- from test import test_sets
- test_support.run_unittest(
- TestSetOfSets,
- TestExceptionPropagation,
- TestBasicOpsEmpty,
- TestBasicOpsSingleton,
- TestBasicOpsTuple,
- TestBasicOpsTriple,
- TestBinaryOps,
- TestUpdateOps,
- TestMutate,
- TestSubsetEqualEmpty,
- TestSubsetEqualNonEmpty,
- TestSubsetEmptyNonEmpty,
- TestSubsetPartial,
- TestSubsetNonOverlap,
- TestOnlySetsNumeric,
- TestOnlySetsDict,
- TestOnlySetsOperator,
- TestOnlySetsTuple,
- TestOnlySetsString,
- TestOnlySetsGenerator,
- TestOnlySetsofSets,
- TestCopyingEmpty,
- TestCopyingSingleton,
- TestCopyingTriple,
- TestCopyingTuple,
- TestCopyingNested,
- TestIdentities,
- doctest.DocTestSuite(test_sets),
- )
-
-if __name__ == "__main__":
- test_main(verbose=True)
More information about the Python-3000-checkins
mailing list