automatically convert dict.iter*() and dict.view*() methods to...

automatically convert dict.iter*() and dict.view*() methods to .keys/values/items() in Py3 for typed dicts

CHANGES.rst

@@ -8,6 +8,10 @@ Cython Changelog
 Features added
 --------------
 
+* The Python2-only dict methods ``.iter*()`` and ``.view*()`` (requires Python 2.7)
+  are automatically mapped to the equivalent keys/values/items methods in Python 3
+  for typed dictionaries.
+
 * Unicode slicing is substantially faster.
 
 * list.append() is faster on average.

Cython/Compiler/Builtin.py

@@ -287,6 +287,18 @@ builtin_types_table = [
                                                   utility_code=UtilityCode.load("py_dict_keys", "Builtins.c")),
                                     BuiltinMethod("values", "T",   "O", "__Pyx_PyDict_Values",
                                                   utility_code=UtilityCode.load("py_dict_values", "Builtins.c")),
+                                    BuiltinMethod("iteritems",  "T",   "O", "__Pyx_PyDict_IterItems",
+                                                  utility_code=UtilityCode.load("py_dict_iteritems", "Builtins.c")),
+                                    BuiltinMethod("iterkeys",   "T",   "O", "__Pyx_PyDict_IterKeys",
+                                                  utility_code=UtilityCode.load("py_dict_iterkeys", "Builtins.c")),
+                                    BuiltinMethod("itervalues", "T",   "O", "__Pyx_PyDict_IterValues",
+                                                  utility_code=UtilityCode.load("py_dict_itervalues", "Builtins.c")),
+                                    BuiltinMethod("viewitems",  "T",   "O", "__Pyx_PyDict_ViewItems",
+                                                  utility_code=UtilityCode.load("py_dict_viewitems", "Builtins.c")),
+                                    BuiltinMethod("viewkeys",   "T",   "O", "__Pyx_PyDict_ViewKeys",
+                                                  utility_code=UtilityCode.load("py_dict_viewkeys", "Builtins.c")),
+                                    BuiltinMethod("viewvalues", "T",   "O", "__Pyx_PyDict_ViewValues",
+                                                  utility_code=UtilityCode.load("py_dict_viewvalues", "Builtins.c")),
                                     BuiltinMethod("clear",  "T",   "r", "__Pyx_PyDict_Clear",
                                                   utility_code=UtilityCode.load("py_dict_clear", "Optimize.c")),
                                     BuiltinMethod("copy",   "T",   "T", "PyDict_Copy")]),

Cython/Utility/Builtins.c

@@ -292,3 +292,71 @@ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) {
 }
 #endif
 
+//////////////////// py_dict_iterkeys.proto ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d); /*proto*/
+
+//////////////////// py_dict_iterkeys ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("keys") : PYIDENT("iterkeys"), NULL);
+}
+
+//////////////////// py_dict_itervalues.proto ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d); /*proto*/
+
+//////////////////// py_dict_itervalues ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("values") : PYIDENT("itervalues"), NULL);
+}
+
+//////////////////// py_dict_iteritems.proto ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d); /*proto*/
+
+//////////////////// py_dict_itervalues ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("items") : PYIDENT("iteritems"), NULL);
+}
+
+//////////////////// py_dict_viewkeys.proto ////////////////////
+
+#if PY_VERSION_HEX < 0x02070000
+#error This module uses dict views, which require Python 2.7 or later
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d); /*proto*/
+
+//////////////////// py_dict_viewkeys ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("keys") : PYIDENT("viewkeys"), NULL);
+}
+
+//////////////////// py_dict_viewvalues.proto ////////////////////
+
+#if PY_VERSION_HEX < 0x02070000
+#error This module uses dict views, which require Python 2.7 or later
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d); /*proto*/
+
+//////////////////// py_dict_viewvalues ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("values") : PYIDENT("viewvalues"), NULL);
+}
+
+//////////////////// py_dict_viewitems.proto ////////////////////
+
+#if PY_VERSION_HEX < 0x02070000
+#error This module uses dict views, which require Python 2.7 or later
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d); /*proto*/
+
+//////////////////// py_dict_viewitems ////////////////////
+
+static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d) {
+    return PyObject_CallMethodObjArgs(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("items") : PYIDENT("viewitems"), NULL);
+}

runtests.py

@@ -222,6 +222,7 @@ VER_DEP_MODULES = {
                                           ]),
     (2,7) : (operator.lt, lambda x: x in ['run.withstat_py', # multi context with statement
                                           'run.yield_inside_lambda',
+                                          'run.test_dictviews',
                                           ]),
     # The next line should start (3,); but this is a dictionary, so
     # we can only have one (3,) key.  Since 2.7 is supposed to be the

tests/run/test_dictviews.pyx

+import unittest
+
+class DictSetTest(unittest.TestCase):
+
+    def test_constructors_not_callable(self):
+        kt = type({}.viewkeys())
+        self.assertRaises(TypeError, kt, {})
+        self.assertRaises(TypeError, kt)
+        it = type({}.viewitems())
+        self.assertRaises(TypeError, it, {})
+        self.assertRaises(TypeError, it)
+        vt = type({}.viewvalues())
+        self.assertRaises(TypeError, vt, {})
+        self.assertRaises(TypeError, vt)
+
+    def test_dict_keys(self):
+        d = {1: 10, "a": "ABC"}
+        keys = d.viewkeys()
+        self.assertEqual(len(keys), 2)
+        self.assertEqual(set(keys), set([1, "a"]))
+        self.assertEqual(keys, set([1, "a"]))
+        self.assertNotEqual(keys, set([1, "a", "b"]))
+        self.assertNotEqual(keys, set([1, "b"]))
+        self.assertNotEqual(keys, set([1]))
+        self.assertNotEqual(keys, 42)
+        self.assertIn(1, keys)
+        self.assertIn("a", keys)
+        self.assertNotIn(10, keys)
+        self.assertNotIn("Z", keys)
+        self.assertEqual(d.viewkeys(), d.viewkeys())
+        e = {1: 11, "a": "def"}
+        self.assertEqual(d.viewkeys(), e.viewkeys())
+        del e["a"]
+        self.assertNotEqual(d.viewkeys(), e.viewkeys())
+
+    def test_dict_items(self):
+        d = {1: 10, "a": "ABC"}
+        items = d.viewitems()
+        self.assertEqual(len(items), 2)
+        self.assertEqual(set(items), set([(1, 10), ("a", "ABC")]))
+        self.assertEqual(items, set([(1, 10), ("a", "ABC")]))
+        self.assertNotEqual(items, set([(1, 10), ("a", "ABC"), "junk"]))
+        self.assertNotEqual(items, set([(1, 10), ("a", "def")]))
+        self.assertNotEqual(items, set([(1, 10)]))
+        self.assertNotEqual(items, 42)
+        self.assertIn((1, 10), items)
+        self.assertIn(("a", "ABC"), items)
+        self.assertNotIn((1, 11), items)
+        self.assertNotIn(1, items)
+        self.assertNotIn((), items)
+        self.assertNotIn((1,), items)
+        self.assertNotIn((1, 2, 3), items)
+        self.assertEqual(d.viewitems(), d.viewitems())
+        e = dict(d.copy())
+        self.assertEqual(d.viewitems(), e.viewitems())
+        e["a"] = "def"
+        self.assertNotEqual(d.viewitems(), e.viewitems())
+
+    def test_dict_mixed_keys_items(self):
+        d = {(1, 1): 11, (2, 2): 22}
+        e = {1: 1, 2: 2}
+        self.assertEqual(d.viewkeys(), e.viewitems())
+        self.assertNotEqual(d.viewitems(), e.viewkeys())
+
+    def test_dict_values(self):
+        d = {1: 10, "a": "ABC"}
+        values = d.viewvalues()
+        self.assertEqual(set(values), set([10, "ABC"]))
+        self.assertEqual(len(values), 2)
+
+    def test_dict_repr(self):
+        d = {1: 10, "a": "ABC"}
+        self.assertIsInstance(repr(d), str)
+        r = repr(d.viewitems())
+        self.assertIsInstance(r, str)
+        self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or
+                        r == "dict_items([(1, 10), ('a', 'ABC')])")
+        r = repr(d.viewkeys())
+        self.assertIsInstance(r, str)
+        self.assertTrue(r == "dict_keys(['a', 1])" or
+                        r == "dict_keys([1, 'a'])")
+        r = repr(d.viewvalues())
+        self.assertIsInstance(r, str)
+        self.assertTrue(r == "dict_values(['ABC', 10])" or
+                        r == "dict_values([10, 'ABC'])")
+
+    def test_keys_set_operations(self):
+        d1 = {'a': 1, 'b': 2}
+        d2 = {'b': 3, 'c': 2}
+        d3 = {'d': 4, 'e': 5}
+        self.assertEqual(d1.viewkeys() & d1.viewkeys(), {'a', 'b'})
+        self.assertEqual(d1.viewkeys() & d2.viewkeys(), {'b'})
+        self.assertEqual(d1.viewkeys() & d3.viewkeys(), set())
+        self.assertEqual(d1.viewkeys() & set(d1.viewkeys()), {'a', 'b'})
+        self.assertEqual(d1.viewkeys() & set(d2.viewkeys()), {'b'})
+        self.assertEqual(d1.viewkeys() & set(d3.viewkeys()), set())
+
+        self.assertEqual(d1.viewkeys() | d1.viewkeys(), {'a', 'b'})
+        self.assertEqual(d1.viewkeys() | d2.viewkeys(), {'a', 'b', 'c'})
+        self.assertEqual(d1.viewkeys() | d3.viewkeys(), {'a', 'b', 'd', 'e'})
+        self.assertEqual(d1.viewkeys() | set(d1.viewkeys()), {'a', 'b'})
+        self.assertEqual(d1.viewkeys() | set(d2.viewkeys()), {'a', 'b', 'c'})
+        self.assertEqual(d1.viewkeys() | set(d3.viewkeys()),
+                         {'a', 'b', 'd', 'e'})
+
+        self.assertEqual(d1.viewkeys() ^ d1.viewkeys(), set())
+        self.assertEqual(d1.viewkeys() ^ d2.viewkeys(), {'a', 'c'})
+        self.assertEqual(d1.viewkeys() ^ d3.viewkeys(), {'a', 'b', 'd', 'e'})
+        self.assertEqual(d1.viewkeys() ^ set(d1.viewkeys()), set())
+        self.assertEqual(d1.viewkeys() ^ set(d2.viewkeys()), {'a', 'c'})
+        self.assertEqual(d1.viewkeys() ^ set(d3.viewkeys()),
+                         {'a', 'b', 'd', 'e'})
+
+    def test_items_set_operations(self):
+        d1 = {'a': 1, 'b': 2}
+        d2 = {'a': 2, 'b': 2}
+        d3 = {'d': 4, 'e': 5}
+        self.assertEqual(
+            d1.viewitems() & d1.viewitems(), {('a', 1), ('b', 2)})
+        self.assertEqual(d1.viewitems() & d2.viewitems(), {('b', 2)})
+        self.assertEqual(d1.viewitems() & d3.viewitems(), set())
+        self.assertEqual(d1.viewitems() & set(d1.viewitems()),
+                         {('a', 1), ('b', 2)})
+        self.assertEqual(d1.viewitems() & set(d2.viewitems()), {('b', 2)})
+        self.assertEqual(d1.viewitems() & set(d3.viewitems()), set())
+
+        self.assertEqual(d1.viewitems() | d1.viewitems(),
+                         {('a', 1), ('b', 2)})
+        self.assertEqual(d1.viewitems() | d2.viewitems(),
+                         {('a', 1), ('a', 2), ('b', 2)})
+        self.assertEqual(d1.viewitems() | d3.viewitems(),
+                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
+        self.assertEqual(d1.viewitems() | set(d1.viewitems()),
+                         {('a', 1), ('b', 2)})
+        self.assertEqual(d1.viewitems() | set(d2.viewitems()),
+                         {('a', 1), ('a', 2), ('b', 2)})
+        self.assertEqual(d1.viewitems() | set(d3.viewitems()),
+                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
+
+        self.assertEqual(d1.viewitems() ^ d1.viewitems(), set())
+        self.assertEqual(d1.viewitems() ^ d2.viewitems(),
+                         {('a', 1), ('a', 2)})
+        self.assertEqual(d1.viewitems() ^ d3.viewitems(),
+                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
+
+
+
+
+def test_main():
+    try:
+        from test import test_support as support
+    except ImportError:
+        from test import support
+    support.run_unittest(DictSetTest)
+
+if __name__ == "__main__":
+    test_main()