helper to allow comparing dicts and None values in Python 3

Author: cmeerw

roundup/anypy/cmp_.py

@@ -0,0 +1,95 @@
+try:
+    None < 0
+    def NoneAndDictComparable(v):
+        return v
+except TypeError:
+    # comparator to allow comparisons against None and dict
+    # comparisons (these were allowed in Python 2, but aren't allowed
+    # in Python 3 any more)
+    class NoneAndDictComparable(object):
+        def __init__(self, value):
+            self.value = value
+
+        def __cmp__(self, other):
+            if not isinstance(other, self.__class__):
+                raise TypeError('not comparable')
+
+            if self.value == other.value:
+                return 0
+
+            elif self.value is None:
+                return -1
+
+            elif other.value is None:
+                return 1
+
+            elif type(self.value) == tuple and type(other.value) == tuple:
+                for lhs, rhs in zip(self.value, other.value):
+                    lhsCmp = NoneAndDictComparable(lhs)
+                    rhsCmp = NoneAndDictComparable(rhs)
+                    result = lhsCmp.__cmp__(rhsCmp)
+                    if result != 0:
+                        return result
+
+                return len(self.value) - len(other.value)
+
+            elif type(self.value) == dict and type(other.value) == dict:
+                diff = len(self.value) - len(other.value)
+                if diff == 0:
+                    lhsItems = tuple(sorted(self.value.items(),
+                                            key=NoneAndDictComparable))
+                    rhsItems = tuple(sorted(other.value.items(),
+                                            key=NoneAndDictComparable))
+                    return -1 if NoneAndDictComparable(lhsItems) < NoneAndDictComparable(rhsItems) else 1
+                else:
+                    return diff
+
+            elif self.value < other.value:
+                return -1
+
+            else:
+                return 1
+
+        def __eq__(self, other):
+            return self.__cmp__(other) == 0
+        def __ne__(self, other):
+            return self.__cmp__(other) != 0
+        def __lt__(self, other):
+            return self.__cmp__(other) < 0
+        def __le__(self, other):
+            return self.__cmp__(other) <= 0
+        def __ge__(self, other):
+            return self.__cmp__(other) >= 0
+        def __gt__(self, other):
+            return self.__cmp__(other) > 0
+
+def _test():
+    Comp = NoneAndDictComparable
+
+    assert Comp(None) < Comp(0)
+    assert Comp(None) < Comp('')
+    assert Comp(None) < Comp({})
+    assert Comp((0, None)) < Comp((0, 0))
+    assert not Comp(0) < Comp(None)
+    assert not Comp('') < Comp(None)
+    assert not Comp({}) < Comp(None)
+    assert not Comp((0, 0)) < Comp((0, None))
+
+    assert Comp((0, 0)) < Comp((0, 0, None))
+    assert Comp((0, None, None)) < Comp((0, 0, 0))
+
+    assert Comp(0) < Comp(1)
+    assert Comp(1) > Comp(0)
+    assert not Comp(1) < Comp(0)
+    assert not Comp(0) > Comp(0)
+
+    assert Comp({ 0: None }) < Comp({ 0: 0 })
+    assert Comp({ 0: 0 }) < Comp({ 0: 1 })
+
+    assert Comp({ 0: 0 }) == Comp({ 0: 0 })
+    assert Comp({ 0: 0 }) != Comp({ 0: 1 })
+    assert Comp({ 0: 0, 1: 1 }) > Comp({ 0: 1 })
+    assert Comp({ 0: 0, 1: 1 }) < Comp({ 0: 0, 2: 2 })
+
+if __name__ == '__main__':
+    _test()

roundup/hyperdb.py

@@ -30,53 +30,10 @@
 from .support import ensureParentsExist, PrioList
 from roundup.i18n import _
 from roundup.cgi.exceptions import DetectorError
+from roundup.anypy.cmp_ import NoneAndDictComparable
 
 logger = logging.getLogger('roundup.hyperdb')
 
-try:
-    None < 0
-    def _NoneComparable(v):
-        return v
-except TypeError:
-    class _NoneComparable(object):
-        def __init__(self, value):
-            self.value = value
-
-        def __cmp__(self, other):
-            if not isinstance(other, self.__class__):
-                raise TypeError('not comparable')
-
-            if self.value is None and other.value is None:
-                return 0
-            elif self.value is None:
-                return -1
-            elif other.value is None:
-                return 1
-            elif type(self.value) == type(()) and type(other.value) == type(()):
-                for lhs, rhs in zip(self.value, other.value):
-                    result = _NoneComparable(lhs).__cmp__(_NoneComparable(rhs))
-                    if result != 0:
-                        return result
-                return len(self.value) - len(other.value)
-            elif self.value < other.value:
-                return -1
-            elif self.value > other.value:
-                return 1
-            else:
-                return 0
-
-        def __eq__(self, other):
-            return self.__cmp__(other) == 0
-        def __ne__(self, other):
-            return self.__cmp__(other) != 0
-        def __lt__(self, other):
-            return self.__cmp__(other) < 0
-        def __le__(self, other):
-            return self.__cmp__(other) <= 0
-        def __ge__(self, other):
-            return self.__cmp__(other) >= 0
-        def __gt__(self, other):
-            return self.__cmp__(other) > 0
 
 #
 # Types
@@ -652,7 +609,7 @@ def _sort(self, val):
         for dir, i in reversed(list(zip(directions, dir_idx))):
             rev = dir == '-'
             sortattr = sorted (sortattr,
-                               key = lambda x: _NoneComparable(x[i:idx]),
+                               key = lambda x: NoneAndDictComparable(x[i:idx]),
                                reverse = rev)
             idx = i
         return [x[-1] for x in sortattr]

test/db_test_base.py

@@ -35,6 +35,7 @@
 from roundup.exceptions import UsageError, Reject
 
 from roundup.anypy.strings import b2s, s2b, u2s
+from roundup.anypy.cmp_ import NoneAndDictComparable
 
 from .mocknull import MockNull
 
@@ -2310,8 +2311,8 @@ def testImportExport(self):
                     j[1].second = float(int(j[1].second))
                 for j in rj:
                     j[1].second = float(int(j[1].second))
-                oj.sort(key = lambda x: x[:4])
-                rj.sort(key = lambda x: x[:4])
+                oj.sort(key = NoneAndDictComparable)
+                rj.sort(key = NoneAndDictComparable)
                 ae(oj, rj)
 
         # make sure the retired items are actually imported

test/test_misc.py

@@ -1,6 +1,7 @@
 # misc tests
 
 import unittest
+import roundup.anypy.cmp_
 from roundup.cgi.accept_language import parse
 
 class AcceptLanguageTest(unittest.TestCase):
@@ -15,3 +16,7 @@ def testParse(self):
         self.assertEqual(parse(None),[])
         self.assertEqual(parse("   "), [])
         self.assertEqual(parse("en,"), ['en'])
+
+class CmpTest(unittest.TestCase):
+    def testCmp(self):
+        roundup.anypy.cmp_._test()