[Python-checkins] cpython (merge 3.4 -> default): Issue #22609: Constructors and update methods of mapping classes in the

Thu Nov 27 15:54:55 CET 2014

https://hg.python.org/cpython/rev/88ab046fdd8a
changeset: 93620:88ab046fdd8a
parent: 93617:1c97f373fe49
parent: 93619:816c15fe5812
user: Serhiy Storchaka <storchaka at gmail.com>
date: Thu Nov 27 16:35:26 2014 +0200
summary:
 Issue #22609: Constructors and update methods of mapping classes in the
collections module now accept the self keyword argument.
files:
 Lib/_collections_abc.py | 35 ++++++------
 Lib/collections/__init__.py | 47 ++++++++++++++---
 Lib/test/test_collections.py | 64 ++++++++++++++++++++++-
 Misc/NEWS | 3 +
 4 files changed, 121 insertions(+), 28 deletions(-)

diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
--- a/Lib/_collections_abc.py
+++ b/Lib/_collections_abc.py
@@ -592,23 +592,24 @@
 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
 In either case, this is followed by: for k, v in F.items(): D[k] = v
 '''
- if len(args) > 2:
- raise TypeError("update() takes at most 2 positional "
- "arguments ({} given)".format(len(args)))
- elif not args:
- raise TypeError("update() takes at least 1 argument (0 given)")
- self = args[0]
- other = args[1] if len(args) >= 2 else ()
-
- if isinstance(other, Mapping):
- for key in other:
- self[key] = other[key]
- elif hasattr(other, "keys"):
- for key in other.keys():
- self[key] = other[key]
- else:
- for key, value in other:
- self[key] = value
+ if not args:
+ raise TypeError("descriptor 'update' of 'MutableMapping' object "
+ "needs an argument")
+ self, *args = args
+ if len(args) > 1:
+ raise TypeError('update expected at most 1 arguments, got %d' %
+ len(args))
+ if args:
+ other = args[0]
+ if isinstance(other, Mapping):
+ for key in other:
+ self[key] = other[key]
+ elif hasattr(other, "keys"):
+ for key in other.keys():
+ self[key] = other[key]
+ else:
+ for key, value in other:
+ self[key] = value
 for key, value in kwds.items():
 self[key] = value
 
diff --git a/Lib/collections/__init__.py b/Lib/collections/__init__.py
--- a/Lib/collections/__init__.py
+++ b/Lib/collections/__init__.py
@@ -55,12 +55,16 @@
 # Individual links are kept alive by the hard reference in self.__map.
 # Those hard references disappear when a key is deleted from an OrderedDict.
 
- def __init__(self, *args, **kwds):
+ def __init__(*args, **kwds):
 '''Initialize an ordered dictionary. The signature is the same as
 regular dictionaries, but keyword arguments are not recommended because
 their insertion order is arbitrary.
 
 '''
+ if not args:
+ raise TypeError("descriptor '__init__' of 'OrderedDict' object "
+ "needs an argument")
+ self, *args = args
 if len(args) > 1:
 raise TypeError('expected at most 1 arguments, got %d' % len(args))
 try:
@@ -479,7 +483,7 @@
 # http://code.activestate.com/recipes/259174/
 # Knuth, TAOCP Vol. II section 4.6.3
 
- def __init__(self, iterable=None, **kwds):
+ def __init__(*args, **kwds):
 '''Create a new, empty Counter object. And if given, count elements
 from an input iterable. Or, initialize the count from another mapping
 of elements to their counts.
@@ -490,8 +494,14 @@
 >>> c = Counter(a=4, b=2) # a new counter from keyword args
 
 '''
- super().__init__()
- self.update(iterable, **kwds)
+ if not args:
+ raise TypeError("descriptor '__init__' of 'Counter' object "
+ "needs an argument")
+ self, *args = args
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ super(Counter, self).__init__()
+ self.update(*args, **kwds)
 
 def __missing__(self, key):
 'The count of elements not in the Counter is zero.'
@@ -542,7 +552,7 @@
 raise NotImplementedError(
 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
 
- def update(self, iterable=None, **kwds):
+ def update(*args, **kwds):
 '''Like dict.update() but add counts instead of replacing them.
 
 Source can be an iterable, a dictionary, or another Counter instance.
@@ -562,6 +572,13 @@
 # contexts. Instead, we implement straight-addition. Both the inputs
 # and outputs are allowed to contain zero and negative counts.
 
+ if not args:
+ raise TypeError("descriptor 'update' of 'Counter' object "
+ "needs an argument")
+ self, *args = args
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ iterable = args[0] if args else None
 if iterable is not None:
 if isinstance(iterable, Mapping):
 if self:
@@ -569,13 +586,13 @@
 for elem, count in iterable.items():
 self[elem] = count + self_get(elem, 0)
 else:
- super().update(iterable) # fast path when counter is empty
+ super(Counter, self).update(iterable) # fast path when counter is empty
 else:
 _count_elements(self, iterable)
 if kwds:
 self.update(kwds)
 
- def subtract(self, iterable=None, **kwds):
+ def subtract(*args, **kwds):
 '''Like dict.update() but subtracts counts instead of replacing them.
 Counts can be reduced below zero. Both the inputs and outputs are
 allowed to contain zero and negative counts.
@@ -591,6 +608,13 @@
 -1
 
 '''
+ if not args:
+ raise TypeError("descriptor 'subtract' of 'Counter' object "
+ "needs an argument")
+ self, *args = args
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ iterable = args[0] if args else None
 if iterable is not None:
 self_get = self.get
 if isinstance(iterable, Mapping):
@@ -898,7 +922,14 @@
 class UserDict(MutableMapping):
 
 # Start by filling-out the abstract methods
- def __init__(self, dict=None, **kwargs):
+ def __init__(*args, **kwargs):
+ if not args:
+ raise TypeError("descriptor '__init__' of 'UserDict' object "
+ "needs an argument")
+ self, *args = args
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ dict = args[0] if args else None
 self.data = {}
 if dict is not None:
 self.update(dict)
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -1137,6 +1137,28 @@
 self.assertEqual(c.setdefault('e', 5), 5)
 self.assertEqual(c['e'], 5)
 
+ def test_init(self):
+ self.assertEqual(list(Counter(self=42).items()), [('self', 42)])
+ self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])
+ self.assertEqual(list(Counter(iterable=None).items()), [('iterable', None)])
+ self.assertRaises(TypeError, Counter, 42)
+ self.assertRaises(TypeError, Counter, (), ())
+ self.assertRaises(TypeError, Counter.__init__)
+
+ def test_update(self):
+ c = Counter()
+ c.update(self=42)
+ self.assertEqual(list(c.items()), [('self', 42)])
+ c = Counter()
+ c.update(iterable=42)
+ self.assertEqual(list(c.items()), [('iterable', 42)])
+ c = Counter()
+ c.update(iterable=None)
+ self.assertEqual(list(c.items()), [('iterable', None)])
+ self.assertRaises(TypeError, Counter().update, 42)
+ self.assertRaises(TypeError, Counter().update, {}, {})
+ self.assertRaises(TypeError, Counter.update)
+
 def test_copying(self):
 # Check that counters are copyable, deepcopyable, picklable, and
 #have a repr/eval round-trip
@@ -1258,6 +1280,16 @@
 c.subtract('aaaabbcce')
 self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))
 
+ c = Counter()
+ c.subtract(self=42)
+ self.assertEqual(list(c.items()), [('self', -42)])
+ c = Counter()
+ c.subtract(iterable=42)
+ self.assertEqual(list(c.items()), [('iterable', -42)])
+ self.assertRaises(TypeError, Counter().subtract, 42)
+ self.assertRaises(TypeError, Counter().subtract, {}, {})
+ self.assertRaises(TypeError, Counter.subtract)
+
 def test_unary(self):
 c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
 self.assertEqual(dict(+c), dict(c=5, d=10, e=15, g=40))
@@ -1308,8 +1340,11 @@
 c=3, e=5).items()), pairs) # mixed input
 
 # make sure no positional args conflict with possible kwdargs
- self.assertEqual(inspect.getargspec(OrderedDict.__dict__['__init__']).args,
- ['self'])
+ self.assertEqual(list(OrderedDict(self=42).items()), [('self', 42)])
+ self.assertEqual(list(OrderedDict(other=42).items()), [('other', 42)])
+ self.assertRaises(TypeError, OrderedDict, 42)
+ self.assertRaises(TypeError, OrderedDict, (), ())
+ self.assertRaises(TypeError, OrderedDict.__init__)
 
 # Make sure that direct calls to __init__ do not clear previous contents
 d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
@@ -1354,6 +1389,10 @@
 self.assertEqual(list(d.items()),
 [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
 
+ self.assertRaises(TypeError, OrderedDict().update, 42)
+ self.assertRaises(TypeError, OrderedDict().update, (), ())
+ self.assertRaises(TypeError, OrderedDict.update)
+
 def test_abc(self):
 self.assertIsInstance(OrderedDict(), MutableMapping)
 self.assertTrue(issubclass(OrderedDict, MutableMapping))
@@ -1600,6 +1639,24 @@
 d = self._empty_mapping()
 self.assertRaises(KeyError, d.popitem)
 
+class TestUserDict(unittest.TestCase):
+
+ def test_init(self):
+ self.assertEqual(list(UserDict(self=42).items()), [('self', 42)])
+ self.assertEqual(list(UserDict(dict=42).items()), [('dict', 42)])
+ self.assertEqual(list(UserDict(dict=None).items()), [('dict', None)])
+ self.assertRaises(TypeError, UserDict, 42)
+ self.assertRaises(TypeError, UserDict, (), ())
+ self.assertRaises(TypeError, UserDict.__init__)
+
+ def test_update(self):
+ d = UserDict()
+ d.update(self=42)
+ self.assertEqual(list(d.items()), [('self', 42)])
+ self.assertRaises(TypeError, UserDict().update, 42)
+ self.assertRaises(TypeError, UserDict().update, {}, {})
+ self.assertRaises(TypeError, UserDict.update)
+
 
 ################################################################################
 ### Run tests
@@ -1611,7 +1668,8 @@
 NamedTupleDocs = doctest.DocTestSuite(module=collections)
 test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
 TestCollectionABCs, TestCounter, TestChainMap,
- TestOrderedDict, GeneralMappingTests, SubclassMappingTests]
+ TestOrderedDict, GeneralMappingTests, SubclassMappingTests,
+ TestUserDict,]
 support.run_unittest(*test_classes)
 support.run_doctest(collections, verbose)
 
diff --git a/Misc/NEWS b/Misc/NEWS
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -191,6 +191,9 @@
 Library
 -------
 
+- Issue #22609: Constructors and update methods of mapping classes in the
+ collections module now accept the self keyword argument.
+
 - Issue #22940: Add readline.append_history_file.
 
 - Issue #19676: Added the "namereplace" error handler.
-- 
Repository URL: https://hg.python.org/cpython
