cmp3 0.6.4__tar.gz → 0.6.6__tar.gz

{cmp3-0.6.4/src/cmp3.egg-info → cmp3-0.6.6}/PKG-INFO

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

{cmp3-0.6.4 → cmp3-0.6.6}/pyproject.toml

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

{cmp3-0.6.4 → cmp3-0.6.6}/src/cmp3/core/__init__.py

@@ -8,6 +8,8 @@ __all__ = ["CmpABC", "cmp", "cmpDeco"]
 
 def cmp(x: Any, y: Any, /, *, mode: str = "portingguide") -> float | int:
     "This function returns a value that compares to 0 as x compares to y."
+    if mode == "dunder":
+        return x.__cmp__(y)
     if mode == "portingguide":
         return (x > y) - (x < y)
     if mode == "poset":
@@ -16,7 +18,7 @@ def cmp(x: Any, y: Any, /, *, mode: str = "portingguide") -> float | int:
 
 
 def cmp_poset(x: Any, y: Any, /) -> float | int:
-    "This function returns a value that compares to 0 as x compares to y under the assumption that both arguments belong to a poset."
+    "This function returns a value that compares to 0 as x compares to y assuming a partial order."
     if x <= y:
         if y <= x:
             return 0

cmp3-0.6.4/src/cmp3/tests/test_all.py → cmp3-0.6.6/src/cmp3/tests/test_all_TestCmpABCAndDeco.py

@@ -1,54 +1,9 @@
-import math
 import unittest
 from typing import *
 
-from cmp3.core import CmpABC, cmp, cmp_poset, cmpDeco
+from cmp3.core import CmpABC, cmpDeco
 
-
-class TestCmpFunction(unittest.TestCase):
-    def test_portingguide_less(self: Self) -> None:
-        self.assertEqual(cmp(1, 2), -1)
-        self.assertEqual(cmp(-5, -1), -1)
-
-    def test_portingguide_equal(self: Self) -> None:
-        self.assertEqual(cmp(3, 3), 0)
-        self.assertEqual(cmp("a", "a"), 0)
-
-    def test_portingguide_greater(self: Self) -> None:
-        self.assertEqual(cmp(2, 1), 1)
-        self.assertEqual(cmp("b", "a"), 1)
-
-    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)
-
-    def test_invalid_mode_raises(self: Self) -> None:
-        with self.assertRaises(ValueError):
-            cmp(1, 2, mode="something-else")
-
-
-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)
-
-    def test_incomparable_returns_nan(self: Self) -> None:
-        class Incomparable:
-            def __le__(self: Self, other: Any) -> bool:
-                # Always False, so no order relation is established
-                return False
-
-        result: Any
-        x: Incomparable
-        y: Incomparable
-
-        x = Incomparable()
-        y = Incomparable()
-        result = cmp_poset(x, y)
-        self.assertTrue(math.isnan(result))
+__all__ = ["TestCmpABCAndDeco"]
 
 
 # A concrete implementation of CmpABC for testing

cmp3-0.6.6/src/cmp3/tests/test_all_TestCmpFunction.py

@@ -0,0 +1,34 @@
+import unittest
+from typing import *
+
+from cmp3.core import cmp
+
+__all__ = ["TestCmpFunction"]
+
+
+class TestCmpFunction(unittest.TestCase):
+    def test_portingguide_less(self: Self) -> None:
+        self.assertEqual(cmp(1, 2), -1)
+        self.assertEqual(cmp(-5, -1), -1)
+
+    def test_portingguide_equal(self: Self) -> None:
+        self.assertEqual(cmp(3, 3), 0)
+        self.assertEqual(cmp("a", "a"), 0)
+
+    def test_portingguide_greater(self: Self) -> None:
+        self.assertEqual(cmp(2, 1), 1)
+        self.assertEqual(cmp("b", "a"), 1)
+
+    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)
+
+    def test_invalid_mode_raises(self: Self) -> None:
+        with self.assertRaises(ValueError):
+            cmp(1, 2, mode="something-else")
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_all_TestCmpPoset.py

@@ -0,0 +1,33 @@
+import math
+import unittest
+from typing import *
+
+from cmp3.core import cmp_poset
+
+__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)
+
+    def test_incomparable_returns_nan(self: Self) -> None:
+        class Incomparable:
+            def __le__(self: Self, other: Any) -> bool:
+                # Always False, so no order relation is established
+                return False
+
+        result: Any
+        x: Incomparable
+        y: Incomparable
+
+        x = Incomparable()
+        y = Incomparable()
+        result = cmp_poset(x, y)
+        self.assertTrue(math.isnan(result))
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_core_TestCmpDecoAndCmpABC.py

@@ -0,0 +1,54 @@
+import unittest
+from typing import *
+
+import setdoc
+
+from cmp3 import core
+
+__all__ = ["TestCmpDecoAndCmpABC"]
+
+
+class Number(core.CmpABC):
+    @setdoc.basic
+    def __cmp__(self: Self, other: Any) -> Any:
+        if not isinstance(other, Number):
+            return NotImplemented
+        # classic 3-way comparison
+        return (self.value > other.value) - (self.value < other.value)
+
+    @setdoc.basic
+    def __init__(self: Self, value: int) -> None:
+        self.value = value
+
+
+class TestCmpDecoAndCmpABC(unittest.TestCase):
+    def setUp(self: Self) -> None:
+        self.a = Number(1)
+        self.b = Number(2)
+        self.c = Number(1)
+
+    def test_eq_ne(self: Self) -> None:
+        self.assertTrue(self.a == self.c)
+        self.assertFalse(self.a == self.b)
+        self.assertTrue(self.a != self.b)
+        self.assertFalse(self.a != self.c)
+
+    def test_lt_le(self: Self) -> None:
+        self.assertTrue(self.a < self.b)
+        self.assertTrue(self.a <= self.b)
+        self.assertTrue(self.a <= self.c)
+        self.assertFalse(self.b < self.a)
+
+    def test_gt_ge(self: Self) -> None:
+        self.assertTrue(self.b > self.a)
+        self.assertTrue(self.b >= self.a)
+        self.assertTrue(self.b >= self.c)
+        self.assertFalse(self.a > self.b)
+
+    def test_cmpabc_is_abstract(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            core.CmpABC()  # abstract, cannot be instantiated
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_core_TestCmpDecoOnPlainClass.py

@@ -0,0 +1,35 @@
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__all__ = ["TestCmpDecoOnPlainClass"]
+
+
+class TestCmpDecoOnPlainClass(unittest.TestCase):
+    def test_decorator_on_non_abc_class(self: Self) -> None:
+        @core.cmpDeco
+        class Plain:
+            def __init__(self: Self, x: int) -> None:
+                self.x = x
+
+            def __cmp__(self: Self, other: Any) -> Any:
+                if not isinstance(other, Plain):
+                    return NotImplemented
+                return (self.x > other.x) - (self.x < other.x)
+
+        p1: Plain
+        p2: Plain
+        p3: Plain
+        p1 = Plain(1)
+        p2 = Plain(2)
+        p3 = Plain(1)
+
+        self.assertTrue(p1 < p2)
+        self.assertTrue(p2 > p1)
+        self.assertTrue(p1 == p3)
+        self.assertTrue(p1 != p2)
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_core_TestCmpModePoset.py

@@ -0,0 +1,18 @@
+import math
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__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")))
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_core_TestCmpPortingGuide.py

@@ -0,0 +1,28 @@
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__all__ = ["TestCmpPortingGuide"]
+
+
+class TestCmpPortingGuide(unittest.TestCase):
+    def test_equal(self: Self) -> None:
+        self.assertEqual(core.cmp(1, 1), 0)
+        self.assertEqual(core.cmp("a", "a"), 0)
+
+    def test_less(self: Self) -> None:
+        self.assertEqual(core.cmp(1, 2), -1)
+        self.assertEqual(core.cmp("a", "b"), -1)
+
+    def test_greater(self: Self) -> None:
+        self.assertEqual(core.cmp(2, 1), 1)
+        self.assertEqual(core.cmp("b", "a"), 1)
+
+    def test_invalid_mode_raises(self: Self) -> None:
+        with self.assertRaises(ValueError):
+            core.cmp(1, 2, mode="invalid-mode")
+
+
+if __name__ == "__main__":
+    unittest.main()

cmp3-0.6.6/src/cmp3/tests/test_core_TestCmpPoset.py

@@ -0,0 +1,31 @@
+import math
+import unittest
+from typing import *
+
+from cmp3 import core
+
+__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)
+
+    def test_poset_less(self: Self) -> None:
+        # subset ordering: strict subset
+        self.assertEqual(core.cmp_poset({1}, {1, 2}), -1)
+
+    def test_poset_greater(self: Self) -> None:
+        # subset ordering: strict superset
+        self.assertEqual(core.cmp_poset({1, 2}, {1}), 1)
+
+    def test_poset_incomparable(self: Self) -> None:
+        # incomparable in subset ordering
+        res: Any
+        res = core.cmp_poset({1}, {2})
+        self.assertTrue(math.isnan(res))
+
+
+if __name__ == "__main__":
+    unittest.main()

{cmp3-0.6.4 → cmp3-0.6.6/src/cmp3.egg-info}/PKG-INFO

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

cmp3-0.6.6/src/cmp3.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+pyproject.toml
+setup.cfg
+src/cmp3/__init__.py
+src/cmp3.egg-info/PKG-INFO
+src/cmp3.egg-info/SOURCES.txt
+src/cmp3.egg-info/dependency_links.txt
+src/cmp3.egg-info/requires.txt
+src/cmp3.egg-info/top_level.txt
+src/cmp3/core/__init__.py
+src/cmp3/tests/__init__.py
+src/cmp3/tests/test_all_TestCmpABCAndDeco.py
+src/cmp3/tests/test_all_TestCmpFunction.py
+src/cmp3/tests/test_all_TestCmpPoset.py
+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

cmp3-0.6.4/src/cmp3/tests/test_core.py

@@ -1,119 +0,0 @@
-import math
-import unittest
-from typing import *
-
-from cmp3 import core
-
-
-class TestCmpPortingGuide(unittest.TestCase):
-    def test_equal(self: Self) -> None:
-        self.assertEqual(core.cmp(1, 1), 0)
-        self.assertEqual(core.cmp("a", "a"), 0)
-
-    def test_less(self: Self) -> None:
-        self.assertEqual(core.cmp(1, 2), -1)
-        self.assertEqual(core.cmp("a", "b"), -1)
-
-    def test_greater(self: Self) -> None:
-        self.assertEqual(core.cmp(2, 1), 1)
-        self.assertEqual(core.cmp("b", "a"), 1)
-
-    def test_invalid_mode_raises(self: Self) -> None:
-        with self.assertRaises(ValueError):
-            core.cmp(1, 2, mode="invalid-mode")
-
-
-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)
-
-    def test_poset_less(self: Self) -> None:
-        # subset ordering: strict subset
-        self.assertEqual(core.cmp_poset({1}, {1, 2}), -1)
-
-    def test_poset_greater(self: Self) -> None:
-        # subset ordering: strict superset
-        self.assertEqual(core.cmp_poset({1, 2}, {1}), 1)
-
-    def test_poset_incomparable(self: Self) -> None:
-        # incomparable in subset ordering
-        res: Any
-        res = core.cmp_poset({1}, {2})
-        self.assertTrue(math.isnan(res))
-
-
-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")))
-
-
-class Number(core.CmpABC):
-    def __init__(self: Self, value: int) -> None:
-        self.value = value
-
-    def __cmp__(self: Self, other: Any) -> Any:
-        if not isinstance(other, Number):
-            return NotImplemented
-        # classic 3-way comparison
-        return (self.value > other.value) - (self.value < other.value)
-
-
-class TestCmpDecoAndCmpABC(unittest.TestCase):
-    def setUp(self: Self) -> None:
-        self.a = Number(1)
-        self.b = Number(2)
-        self.c = Number(1)
-
-    def test_eq_ne(self: Self) -> None:
-        self.assertTrue(self.a == self.c)
-        self.assertFalse(self.a == self.b)
-        self.assertTrue(self.a != self.b)
-        self.assertFalse(self.a != self.c)
-
-    def test_lt_le(self: Self) -> None:
-        self.assertTrue(self.a < self.b)
-        self.assertTrue(self.a <= self.b)
-        self.assertTrue(self.a <= self.c)
-        self.assertFalse(self.b < self.a)
-
-    def test_gt_ge(self: Self) -> None:
-        self.assertTrue(self.b > self.a)
-        self.assertTrue(self.b >= self.a)
-        self.assertTrue(self.b >= self.c)
-        self.assertFalse(self.a > self.b)
-
-    def test_cmpabc_is_abstract(self: Self) -> None:
-        with self.assertRaises(TypeError):
-            core.CmpABC()  # abstract, cannot be instantiated
-
-
-class TestCmpDecoOnPlainClass(unittest.TestCase):
-    def test_decorator_on_non_abc_class(self: Self) -> None:
-        @core.cmpDeco
-        class Plain:
-            def __init__(self: Self, x: int) -> None:
-                self.x = x
-
-            def __cmp__(self: Self, other: Any) -> Any:
-                if not isinstance(other, Plain):
-                    return NotImplemented
-                return (self.x > other.x) - (self.x < other.x)
-
-        p1: Plain
-        p2: Plain
-        p3: Plain
-        p1 = Plain(1)
-        p2 = Plain(2)
-        p3 = Plain(1)
-
-        self.assertTrue(p1 < p2)
-        self.assertTrue(p2 > p1)
-        self.assertTrue(p1 == p3)
-        self.assertTrue(p1 != p2)
-
-
-if __name__ == "__main__":
-    unittest.main()

cmp3-0.6.4/src/cmp3.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-LICENSE.txt
-MANIFEST.in
-README.rst
-pyproject.toml
-setup.cfg
-src/cmp3/__init__.py
-src/cmp3.egg-info/PKG-INFO
-src/cmp3.egg-info/SOURCES.txt
-src/cmp3.egg-info/dependency_links.txt
-src/cmp3.egg-info/requires.txt
-src/cmp3.egg-info/top_level.txt
-src/cmp3/core/__init__.py
-src/cmp3/tests/__init__.py
-src/cmp3/tests/test_all.py
-src/cmp3/tests/test_core.py