cmp3 1.0.1__tar.gz → 1.0.2__tar.gz

{cmp3-1.0.1/src/cmp3.egg-info → cmp3-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmp3
-Version: 1.0.1
+Version: 1.0.2
 Summary: This project updates the concept of __cmp__ for python3.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)

{cmp3-1.0.1 → cmp3-1.0.2}/pyproject.toml

@@ -26,7 +26,7 @@ keywords = []
 name = "cmp3"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.0.1"
+version = "1.0.2"
 
 [project.license]
 file = "LICENSE.txt"

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3/core/__init__.py

@@ -8,16 +8,38 @@ __all__ = ["CmpABC", "cmp", "cmpDeco"]
 
 def cmp(x: Any, y: Any, /, *, mode: str = "portingguide") -> Any:
     "This function returns a value that compares to 0 as x compares to y."
-    if mode == "dunder":
+    errors: list[Exception]
+    part: str
+    if not any(map(str.isspace, mode)):
+        return cmp_mode(x, y, mode=mode)
+    errors = list()
+    for part in mode.split():
+        try:
+            return cmp_mode(x, y, mode=part)
+        except Exception as exc:
+            errors.append(exc)
+    if len(errors):
+        raise ExceptionGroup("No submode worked.", errors)
+    else:
+        raise ValueError("No submodes provided.")
+
+
+def cmp_mode(x: Any, y: Any, /, *, mode: str) -> Any:
+    "This function implements submodes."
+    if mode == "eq":
+        return 0 if x == y else float("nan")
+    if mode == "eq_strict":
+        return 0 if x == y else None
+    if mode == "le":
+        return cmp_le(x, y)
+    if mode == "magic":
         return x.__cmp__(y)
     if mode == "portingguide":
         return (x > y) - (x < y)
-    if mode == "poset":
-        return cmp_poset(x, y)
-    raise ValueError("%r is not an appropriate value for mode." % mode)
+    raise ValueError("%r is not a recognized mode." % mode)
 
 
-def cmp_poset(x: Any, y: Any, /) -> float | int:
+def cmp_le(x: Any, y: Any, /) -> float | int:
     "This function returns a value that compares to 0 as x compares to y assuming a partial order."
     if x <= y:
         if y <= x:

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3/tests/test_all_TestCmpFunction.py

@@ -21,9 +21,9 @@ class TestCmpFunction(unittest.TestCase):
 
     def test_poset_mode_uses_poset_semantics(self: Self) -> None:
         # For totally ordered ints, this should behave like normal cmp
-        self.assertEqual(cmp(1, 2, mode="poset"), -1)
-        self.assertEqual(cmp(2, 1, mode="poset"), 1)
-        self.assertEqual(cmp(5, 5, mode="poset"), 0)
+        self.assertEqual(cmp(1, 2, mode="le"), -1)
+        self.assertEqual(cmp(2, 1, mode="le"), 1)
+        self.assertEqual(cmp(5, 5, mode="le"), 0)
 
     def test_invalid_mode_raises(self: Self) -> None:
         with self.assertRaises(ValueError):

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3/tests/test_all_TestCmpPoset.py

@@ -2,16 +2,16 @@ import math
 import unittest
 from typing import *
 
-from cmp3.core import cmp_poset
+from cmp3.core import cmp
 
 __all__ = ["TestCmpPoset"]
 
 
 class TestCmpPoset(unittest.TestCase):
     def test_total_order_ints(self: Self) -> None:
-        self.assertEqual(cmp_poset(1, 2), -1)
-        self.assertEqual(cmp_poset(2, 1), 1)
-        self.assertEqual(cmp_poset(3, 3), 0)
+        self.assertEqual(cmp(1, 2, mode="le"), -1)
+        self.assertEqual(cmp(2, 1, mode="le"), 1)
+        self.assertEqual(cmp(3, 3, mode="le"), 0)
 
     def test_incomparable_returns_nan(self: Self) -> None:
         class Incomparable:
@@ -25,7 +25,7 @@ class TestCmpPoset(unittest.TestCase):
 
         x = Incomparable()
         y = Incomparable()
-        result = cmp_poset(x, y)
+        result = cmp(x, y, mode="le")
         self.assertTrue(math.isnan(result))
 
 

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3/tests/test_core_TestCmpModePoset.py

@@ -9,9 +9,9 @@ __all__ = ["TestCmpModePoset"]
 
 class TestCmpModePoset(unittest.TestCase):
     def test_cmp_uses_poset_mode(self: Self) -> None:
-        self.assertEqual(core.cmp({1}, {1, 2}, mode="poset"), -1)
-        self.assertEqual(core.cmp({1, 2}, {1}, mode="poset"), 1)
-        self.assertTrue(math.isnan(core.cmp({1}, {2}, mode="poset")))
+        self.assertEqual(core.cmp({1}, {1, 2}, mode="le"), -1)
+        self.assertEqual(core.cmp({1, 2}, {1}, mode="le"), 1)
+        self.assertTrue(math.isnan(core.cmp({1}, {2}, mode="le")))
 
 
 if __name__ == "__main__":

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3/tests/test_core_TestCmpPoset.py

@@ -2,7 +2,7 @@ import math
 import unittest
 from typing import *
 
-from cmp3 import core
+from cmp3.core import cmp
 
 __all__ = ["TestCmpPoset"]
 
@@ -10,20 +10,20 @@ __all__ = ["TestCmpPoset"]
 class TestCmpPoset(unittest.TestCase):
     def test_poset_equal(self: Self) -> None:
         # subset ordering: same set
-        self.assertEqual(core.cmp_poset({1, 2}, {1, 2}), 0)
+        self.assertEqual(cmp({1, 2}, {1, 2}, mode="le"), 0)
 
     def test_poset_less(self: Self) -> None:
         # subset ordering: strict subset
-        self.assertEqual(core.cmp_poset({1}, {1, 2}), -1)
+        self.assertEqual(cmp({1}, {1, 2}, mode="le"), -1)
 
     def test_poset_greater(self: Self) -> None:
         # subset ordering: strict superset
-        self.assertEqual(core.cmp_poset({1, 2}, {1}), 1)
+        self.assertEqual(cmp({1, 2}, {1}, mode="le"), 1)
 
     def test_poset_incomparable(self: Self) -> None:
         # incomparable in subset ordering
         res: Any
-        res = core.cmp_poset({1}, {2})
+        res = cmp({1}, {2}, mode="le")
         self.assertTrue(math.isnan(res))
 
 

cmp3-1.0.2/src/cmp3/tests/test_fix.py

@@ -0,0 +1,19 @@
+import unittest
+from typing import *
+
+from cmp3.core import cmp
+
+__all__ = ["TestFix"]
+
+
+class TestFix(unittest.TestCase):
+
+    def test_fix(self: Self) -> None:
+        with self.assertRaises(ValueError):
+            cmp(4, 2, mode="")
+        with self.assertRaises(ValueError):
+            cmp(4, 2, mode=" ")
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-1.0.2/src/cmp3/tests/test_m_TestCmpDecoAndCmpABC.py

@@ -0,0 +1,51 @@
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__all__ = ["TestCmpDecoAndCmpABC"]
+
+
+class Number(core.CmpABC):
+    def __cmp__(self: Self, other: Any) -> Any:
+        if not isinstance(other, Number):
+            return NotImplemented
+        return (self.value > other.value) - (self.value < other.value)
+
+    def __init__(self: Self, value: int) -> None:
+        self.value = value
+
+
+class TestCmpDecoAndCmpABC(unittest.TestCase):
+    def test_rich_comparisons_lt_gt(self: Self) -> None:
+        a: Number
+        b: Number
+        a = Number(1)
+        b = Number(2)
+        self.assertTrue(a < b)
+        self.assertTrue(b > a)
+
+    def test_rich_comparisons_le_ge_eq(self: Self) -> None:
+        a1: Number
+        a2: Number
+        b: Number
+        a1 = Number(5)
+        a2 = Number(5)
+        b = Number(7)
+        self.assertTrue(a1 <= a2)
+        self.assertTrue(a1 >= a2)
+        self.assertTrue(a1 == a2)
+        self.assertTrue(a1 <= b)
+        self.assertTrue(b >= a1)
+
+    def test_rich_comparisons_ne(self: Self) -> None:
+        a: Number
+        b: Number
+        a = Number(1)
+        b = Number(2)
+        self.assertTrue(a != b)
+        self.assertFalse(a != Number(1))
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-1.0.2/src/cmp3/tests/test_m_TestCmpFunctions.py

@@ -0,0 +1,100 @@
+import math
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__all__ = ["TestCmpFunctions"]
+
+
+class Number(core.CmpABC):
+    def __cmp__(self: Self, other) -> Any:
+        if not isinstance(other, Number):
+            return NotImplemented
+        return (self.value > other.value) - (self.value < other.value)
+
+    def __init__(self: Self, value: int) -> None:
+        self.value = value
+
+
+class TestCmpFunctions(unittest.TestCase):
+    def test_eq_mode_equal(self: Self) -> None:
+        self.assertEqual(core.cmp(1, 1, mode="eq"), 0)
+
+    def test_eq_mode_not_equal(self: Self) -> None:
+        result: Any
+        result = core.cmp(1, 2, mode="eq")
+        self.assertTrue(math.isnan(result))
+
+    def test_eq_strict_mode_equal(self: Self) -> None:
+        self.assertEqual(core.cmp(1, 1, mode="eq_strict"), 0)
+
+    def test_eq_strict_mode_not_equal(self: Self) -> None:
+        self.assertIsNone(core.cmp(1, 2, mode="eq_strict"))
+
+    def test_portingguide_less(self: Self) -> None:
+        self.assertEqual(core.cmp(1, 2, mode="portingguide"), -1)
+
+    def test_portingguide_equal(self: Self) -> None:
+        self.assertEqual(core.cmp(3, 3, mode="portingguide"), 0)
+
+    def test_portingguide_greater(self: Self) -> None:
+        self.assertEqual(core.cmp(5, 2, mode="portingguide"), 1)
+
+    def test_le_mode(self: Self) -> None:
+        # Using total-order ints to also test cmp_le
+        self.assertEqual(core.cmp(1, 2, mode="le"), -1)
+        self.assertEqual(core.cmp(2, 1, mode="le"), 1)
+        self.assertEqual(core.cmp(3, 3, mode="le"), 0)
+
+    def test_le_mode_nan_for_incomparable(self: Self) -> None:
+        # Simulate incomparable with a custom class
+        class P:
+            def __init__(self, v):
+                self.v = v
+
+        x: P
+        y: P
+        x = P(1)
+        y = P(2)
+        # They don't define <=, so this should raise TypeError in cmp_le
+        with self.assertRaises(TypeError):
+            core.cmp_le(x, y)
+
+    def test_magic_mode_with_cmpabc(self: Self) -> None:
+        a: Number
+        b: Number
+        a = Number(1)
+        b = Number(3)
+        self.assertEqual(core.cmp(a, b, mode="magic"), -1)
+        self.assertEqual(core.cmp(b, a, mode="magic"), 1)
+        self.assertEqual(core.cmp(a, Number(1), mode="magic"), 0)
+
+    def test_multi_mode_first_fails_second_succeeds(self: Self) -> None:
+        # "magic" will work for Number, but let's create an object without __cmp__
+        class NoCmp:
+            pass
+
+        x: NoCmp
+        y: NoCmp
+
+        x = NoCmp()
+        y = NoCmp()
+        with self.assertRaises(Exception):
+            core.cmp(x, y, mode="magic portingguide")
+
+    def test_unknown_modes_raise_exceptiongroup(self: Self) -> None:
+        exc: Any
+        with self.assertRaises(ExceptionGroup) as cm:
+            core.cmp(1, 2, mode="foo bar")
+        exc = cm.exception
+        self.assertEqual(len(exc.exceptions), 2)
+        self.assertTrue(all(isinstance(e, ValueError) for e in exc.exceptions))
+
+    def test_only_whitespace_mode_raises_valueerror(self: Self) -> None:
+        with self.assertRaises(ValueError):
+            core.cmp(1, 2, mode="   ")
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-1.0.2/src/cmp3/tests/test_redo_Point.py

@@ -0,0 +1,74 @@
+import unittest
+from typing import *
+
+from cmp3.core import CmpABC, cmp_mode
+
+__all__ = ["TestPoint"]
+
+
+class Point(CmpABC):
+    """Simple comparable type based on an integer value."""
+
+    __slots__ = ("value",)
+
+    def __init__(self: Self, value: int) -> None:
+        self.value = value
+
+    def __cmp__(self: Self, other: Any) -> int:
+        if isinstance(other, Point):
+            return (self.value > other.value) - (self.value < other.value)
+        return NotImplemented
+
+
+class TestPoint(unittest.TestCase):
+
+    def test_dunder_mode_uses___cmp__(self: Self) -> None:
+        a: Point
+        b: Point
+
+        a = Point(1)
+        b = Point(2)
+        self.assertEqual(cmp_mode(a, b, mode="magic"), -1)
+        self.assertEqual(cmp_mode(b, a, mode="magic"), 1)
+        self.assertEqual(cmp_mode(a, a, mode="magic"), 0)
+
+    def test_cmpabc_is_abstract(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            CmpABC()  # type: ignore[abstract]
+
+    def test_cmpabc_slots(self: Self) -> None:
+        self.assertEqual(CmpABC.__slots__, ())
+
+    def test_subclass_comparisons_use___cmp__(self: Self) -> None:
+        a: Point
+        b: Point
+        c: Point
+        a = Point(1)
+        b = Point(2)
+        c = Point(1)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a <= b)
+        self.assertTrue(b > a)
+        self.assertTrue(b >= a)
+        self.assertTrue(a == c)
+        self.assertTrue(a != b)
+
+        self.assertFalse(a > b)
+        self.assertFalse(a >= b)
+        self.assertFalse(b < a)
+        self.assertFalse(b <= a)
+        self.assertFalse(a != c)
+        self.assertFalse(a == b)
+
+    def test_cmpdeco_adds_comparison_methods(self: Self) -> None:
+        self.assertTrue(hasattr(Point, "__eq__"))
+        self.assertTrue(hasattr(Point, "__lt__"))
+        self.assertTrue(hasattr(Point, "__le__"))
+        self.assertTrue(hasattr(Point, "__gt__"))
+        self.assertTrue(hasattr(Point, "__ge__"))
+        self.assertTrue(hasattr(Point, "__ne__"))
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-1.0.2/src/cmp3/tests/test_redo_TestCmpFunction.py

@@ -0,0 +1,39 @@
+import unittest
+from typing import *
+
+from cmp3.core import cmp as cmp_fn
+
+__all__ = ["TestCmpFunction"]
+
+
+class TestCmpFunction(unittest.TestCase):
+    def test_default_mode_is_portingguide(self: Self) -> None:
+        self.assertEqual(cmp_fn(1, 1), 0)
+        self.assertEqual(cmp_fn(2, 1), 1)
+        self.assertEqual(cmp_fn(1, 2), -1)
+
+    def test_mode_without_whitespace_goes_directly_to_cmp_mode(self: Self) -> None:
+        # Just checks result; behavior should match portingguide
+        self.assertEqual(cmp_fn(3, 4, mode="portingguide"), -1)
+
+    def test_whitespace_modes_first_successful_used(self: Self) -> None:
+        # "portingguide" works; "equality" would give None instead
+        self.assertEqual(cmp_fn(1, 2, mode="portingguide eq_strict"), -1)
+
+    def test_whitespace_modes_falls_back_on_exception(self: Self) -> None:
+        # int has no __cmp__, so "dunder" fails, then "portingguide" works
+        self.assertEqual(cmp_fn(1, 2, mode="magic portingguide"), -1)
+
+    def test_whitespace_modes_all_fail_raise_exceptiongroup(self: Self) -> None:
+        exc: ExceptionGroup
+        # For int vs str, "dunder", "poset", and "portingguide" all raise
+        with self.assertRaises(ExceptionGroup) as cm:
+            cmp_fn(1, "a", mode="magic le portingguide")
+
+        exc = cm.exception
+        # There should be one sub-exception per submode
+        self.assertEqual(len(exc.exceptions), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-1.0.2/src/cmp3/tests/test_redo_TestIncomparable.py

@@ -0,0 +1,111 @@
+import math
+import unittest
+from typing import *
+
+from cmp3.core import CmpABC, cmp_le, cmp_mode
+
+__all__ = ["TestIncomparable"]
+
+
+class Incomparable:
+    """Type whose instances are never <= each other."""
+
+    def __le__(self: Self, other: Any) -> bool:
+        return False
+
+
+class TestIncomparable(unittest.TestCase):
+    def test_portingguide_ints(self: Self) -> None:
+        self.assertEqual(cmp_mode(1, 1, mode="portingguide"), 0)
+        self.assertEqual(cmp_mode(2, 1, mode="portingguide"), 1)
+        self.assertEqual(cmp_mode(1, 2, mode="portingguide"), -1)
+
+    def test_equality_mode(self: Self) -> None:
+        self.assertEqual(cmp_mode(10, 10, mode="eq_strict"), 0)
+        self.assertIsNone(cmp_mode(10, 11, mode="eq_strict"))
+
+    def test_poset_total_order_ints(self: Self) -> None:
+        self.assertEqual(cmp_le(1, 1), 0)
+        self.assertEqual(cmp_le(1, 2), -1)
+        self.assertEqual(cmp_le(2, 1), 1)
+
+    def test_poset_incomparable(self: Self) -> None:
+        result: object
+        x: Incomparable
+        y: Incomparable
+        x = Incomparable()
+        y = Incomparable()
+        result = cmp_le(x, y)
+        self.assertTrue(math.isnan(result))
+
+    def test_cmp_mode_invalid_raises(self: Self) -> None:
+        with self.assertRaises(ValueError):
+            cmp_mode(1, 2, mode="not-a-mode")
+
+
+class Point(CmpABC):
+    """Simple comparable type based on an integer value."""
+
+    __slots__ = ("value",)
+
+    def __init__(self: Self, value: int) -> None:
+        self.value = value
+
+    def __cmp__(self: Self, other: Any) -> int:
+        if isinstance(other, Point):
+            return (self.value > other.value) - (self.value < other.value)
+        return NotImplemented
+
+
+class TestPoint(unittest.TestCase):
+
+    def test_dunder_mode_uses___cmp__(self: Self) -> None:
+        a: Point
+        b: Point
+
+        a = Point(1)
+        b = Point(2)
+        self.assertEqual(cmp_mode(a, b, mode="magic"), -1)
+        self.assertEqual(cmp_mode(b, a, mode="magic"), 1)
+        self.assertEqual(cmp_mode(a, a, mode="magic"), 0)
+
+    def test_cmpabc_is_abstract(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            CmpABC()  # type: ignore[abstract]
+
+    def test_cmpabc_slots(self: Self) -> None:
+        self.assertEqual(CmpABC.__slots__, ())
+
+    def test_subclass_comparisons_use___cmp__(self: Self) -> None:
+        a: Point
+        b: Point
+        c: Point
+        a = Point(1)
+        b = Point(2)
+        c = Point(1)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a <= b)
+        self.assertTrue(b > a)
+        self.assertTrue(b >= a)
+        self.assertTrue(a == c)
+        self.assertTrue(a != b)
+
+        self.assertFalse(a > b)
+        self.assertFalse(a >= b)
+        self.assertFalse(b < a)
+        self.assertFalse(b <= a)
+        self.assertFalse(a != c)
+        self.assertFalse(a == b)
+
+    def test_cmpdeco_adds_comparison_methods(self: Self) -> None:
+        self.assertTrue(hasattr(Point, "__eq__"))
+        self.assertTrue(hasattr(Point, "__lt__"))
+        self.assertTrue(hasattr(Point, "__le__"))
+        self.assertTrue(hasattr(Point, "__gt__"))
+        self.assertTrue(hasattr(Point, "__ge__"))
+        self.assertTrue(hasattr(Point, "__ne__"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{cmp3-1.0.1 → cmp3-1.0.2/src/cmp3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmp3
-Version: 1.0.1
+Version: 1.0.2
 Summary: This project updates the concept of __cmp__ for python3.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)

{cmp3-1.0.1 → cmp3-1.0.2}/src/cmp3.egg-info/SOURCES.txt

@@ -18,4 +18,10 @@ src/cmp3/tests/test_core_TestCmpDecoAndCmpABC.py
 src/cmp3/tests/test_core_TestCmpDecoOnPlainClass.py
 src/cmp3/tests/test_core_TestCmpModePoset.py
 src/cmp3/tests/test_core_TestCmpPortingGuide.py
-src/cmp3/tests/test_core_TestCmpPoset.py
+src/cmp3/tests/test_core_TestCmpPoset.py
+src/cmp3/tests/test_fix.py
+src/cmp3/tests/test_m_TestCmpDecoAndCmpABC.py
+src/cmp3/tests/test_m_TestCmpFunctions.py
+src/cmp3/tests/test_redo_Point.py
+src/cmp3/tests/test_redo_TestCmpFunction.py
+src/cmp3/tests/test_redo_TestIncomparable.py