raisefunction 1.0.3__tar.gz → 1.0.5__tar.gz

{raisefunction-1.0.3/src/raisefunction.egg-info → raisefunction-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raisefunction
-Version: 1.0.3
+Version: 1.0.5
 Summary: This project provides a function that raises errors passed to it.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -40,7 +40,6 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: overloadable<2,>=1.0.14
 Dynamic: license-file
 
 =============

{raisefunction-1.0.3 → raisefunction-1.0.5}/pyproject.toml

@@ -1,7 +1,7 @@
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [
-    "setuptools>=61.0",
+    "setuptools>=64.0",
 ]
 
 [project]
@@ -19,15 +19,13 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "Typing :: Typed",
 ]
-dependencies = [
-    "overloadable>=1.0.14,<2",
-]
+dependencies = []
 description = "This project provides a function that raises errors passed to it."
 keywords = []
 name = "raisefunction"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.0.3"
+version = "1.0.5"
 
 [project.license]
 file = "LICENSE.txt"

raisefunction-1.0.5/src/raisefunction/__init__.py

@@ -0,0 +1,2 @@
+from raisefunction.core import raisefunction
+from raisefunction.tests import test

raisefunction-1.0.5/src/raisefunction/core/__init__.py

@@ -0,0 +1,27 @@
+from typing import *
+
+__all__ = ["raisefunction"]
+
+DEFAULT = object()
+
+
+@overload
+def raisefunction(
+    exc: BaseException | type[BaseException],
+) -> Never: ...
+@overload
+def raisefunction(
+    exc: BaseException | type[BaseException],
+    cause: Optional[BaseException],
+) -> Never: ...
+
+
+def raisefunction(
+    exc: BaseException | type[BaseException],
+    cause: Optional[BaseException] | object = DEFAULT,
+) -> Never:
+    "This function raises the given exception."
+    if cause is DEFAULT:
+        raise exc
+    else:
+        raise exc from cause

{raisefunction-1.0.3 → raisefunction-1.0.5}/src/raisefunction/tests/__init__.py

@@ -5,6 +5,10 @@ __all__ = ["test"]
 
 def test() -> unittest.TextTestRunner:
     "This function runs all the tests."
+    loader: unittest.TestLoader
+    tests: unittest.TestSuite
+    runner: unittest.TextTestRunner
+    result: unittest.TextTestResult
     loader = unittest.TestLoader()
     tests = loader.discover(start_dir="raisefunction.tests")
     runner = unittest.TextTestRunner()

raisefunction-1.0.5/src/raisefunction/tests/test_0.py

@@ -0,0 +1,51 @@
+import unittest
+from typing import *
+
+from raisefunction.core import raisefunction
+
+__all__ = ["Test0"]
+
+
+class Test0(unittest.TestCase):
+    def test_dispatcher_no_arguments(self: Self) -> None:
+        "Test the dispatcher raises a TypeError with no arguments."
+        with self.assertRaises(TypeError):
+            raisefunction()
+        # self.assertIn("requires at least 1 positional argument", str(context.exception))
+
+    def test_dispatcher_too_many_arguments(self: Self) -> None:
+        "Test the dispatcher raises a TypeError with more than 2 arguments."
+        with self.assertRaises(TypeError):
+            raisefunction(1, 2, 3)
+        # self.assertIn("takes at most 2 positional arguments", str(context.exception))
+
+    def test_raise_single_exception(self: Self) -> None:
+        "Test the single exception raising overload."
+        with self.assertRaises(ValueError):
+            raisefunction(ValueError("Test single exception"))
+
+    def test_raise_exception_with_cause(self: Self) -> None:
+        "Test the exception raising overload with a cause."
+        with self.assertRaises(ValueError) as context:
+            raisefunction(ValueError("Test exception"), TypeError("Cause exception"))
+        self.assertEqual(str(context.exception), "Test exception")
+        self.assertIsInstance(context.exception.__cause__, TypeError)
+        self.assertEqual(str(context.exception.__cause__), "Cause exception")
+
+    def test_invalid_arguments_in_overloads(self: Self) -> None:
+        "Test invalid argument types raise appropriate errors."
+        with self.assertRaises(TypeError):
+            raisefunction("not an exception")
+        with self.assertRaises(TypeError):
+            raisefunction("not an exception", "not a cause")
+
+    def test_raise_exception_with_cause(self: Self) -> None:
+        "Test the exception raising overload with a cause."
+        with self.assertRaises(ValueError) as context:
+            raisefunction(ValueError("Test exception"), KeyError("Cause exception"))
+        self.assertEqual(str(context.exception), "Test exception")
+        self.assertIsInstance(context.exception.__cause__, KeyError)
+
+
+if __name__ == "__main__":
+    unittest.main()

raisefunction-1.0.5/src/raisefunction/tests/test_1.py

@@ -0,0 +1,62 @@
+import unittest
+from typing import *
+
+from raisefunction import core
+
+__all__ = ["Test1"]
+
+
+class Test1(unittest.TestCase):
+    def test_raises_given_exception_instance_without_cause(self: Self) -> None:
+        exc: ValueError
+        exc = ValueError("boom")
+
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(exc)
+
+        self.assertIs(cm.exception, exc)
+        # When no explicit cause is given, __cause__ is normally None
+        # and __context__ may or may not be set depending on context.
+        self.assertIsNone(cm.exception.__cause__)
+
+    def test_raises_given_exception_class_without_cause(self: Self) -> None:
+        # Using a class mirrors: raise ValueError
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(ValueError)
+        self.assertIsInstance(cm.exception, ValueError)
+        self.assertIsNone(cm.exception.__cause__)
+
+    def test_raises_with_explicit_cause(self: Self) -> None:
+        cause: RuntimeError
+        exc: ValueError
+        cause = RuntimeError("original")
+        exc = ValueError("wrapped")
+
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(exc, cause)
+
+        self.assertIs(cm.exception.__cause__, cause)
+
+    def test_raises_with_suppressed_context_when_cause_is_none(self: Self) -> None:
+        exc: ValueError
+        exc = ValueError("no context")
+
+        # Explicit `from None` should result in __cause__ being None,
+        # and suppress linking to any active exception.
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(exc, None)
+
+        self.assertIsNone(cm.exception.__cause__)
+
+    def test_raising_class_that_requires_args_produces_type_error(self: Self) -> None:
+        class NeedsArg(Exception):
+            def __init__(self: Self, msg: str) -> None:
+                super().__init__(msg)
+
+        # This mirrors normal `raise NeedsArg` behaviour
+        with self.assertRaises(TypeError):
+            core.raisefunction(NeedsArg)
+
+
+if __name__ == "__main__":
+    unittest.main()

raisefunction-1.0.5/src/raisefunction/tests/test_2.py

@@ -0,0 +1,76 @@
+import unittest
+from typing import *
+
+from raisefunction import core
+
+__all__ = ["Test2"]
+
+
+class Test2(unittest.TestCase):
+    def test_raises_given_exception_instance_without_cause(self: Self) -> None:
+        cm: unittest._AssertRaisesContext[ValueError]
+        exc: ValueError
+        exc = ValueError("boom")
+
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(exc)
+
+        self.assertIs(cm.exception, exc)
+        # When no explicit cause is given, __cause__ is normally None.
+        # __context__ may or may not be set depending on context.
+        self.assertIsNone(cm.exception.__cause__)
+
+    def test_raises_given_exception_class_without_cause(self: Self) -> None:
+        cm: unittest._AssertRaisesContext[ValueError]
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(ValueError)
+
+        self.assertIsInstance(cm.exception, ValueError)
+        self.assertIsNone(cm.exception.__cause__)
+
+    def test_raises_with_explicit_cause(self: Self) -> None:
+        cause: RuntimeError
+        cm: unittest._AssertRaisesContext[ValueError]
+        exc: ValueError
+        cause = RuntimeError("original")
+        exc = ValueError("wrapped")
+
+        with self.assertRaises(ValueError) as cm:
+            core.raisefunction(exc, cause)
+
+        self.assertIs(cm.exception.__cause__, cause)
+
+    def test_raise_from_None(self: Self) -> None:
+        cm: unittest._AssertRaisesContext[ValueError]
+        exc: ValueError
+        one: int
+        zero: int
+
+        exc = ValueError("no context")
+        with self.assertRaises(ValueError) as cm:
+            try:
+                # Create a real context exception
+                one = 1
+                zero = 0
+                one / zero
+            except ZeroDivisionError:
+                raise exc from None
+        self.assertIsNone(cm.exception.__cause__)
+        self.assertIsInstance(cm.exception.__context__, ZeroDivisionError)
+        self.assertTrue(cm.exception.__suppress_context__)
+
+    def test_raising_class_that_requires_args_produces_type_error(self: Self) -> None:
+        class NeedsArg(Exception):
+            def __init__(self: Self, msg: str) -> None:
+                super().__init__(msg)
+
+        cm: unittest._AssertRaisesContext[BaseException]
+        with self.assertRaises(TypeError) as cm:
+            core.raisefunction(NeedsArg)
+
+        # Optional: sanity check on the error type/message
+        self.assertIsInstance(cm.exception, TypeError)
+
+
+if __name__ == "__main__":
+    unittest.main()

raisefunction-1.0.5/src/raisefunction/tests/test_3.py

@@ -0,0 +1,42 @@
+import unittest
+from typing import *
+
+from raisefunction import core
+
+__all__ = ["Test3"]
+
+
+class Test3(unittest.TestCase):
+
+    def go(self: Self, *, use_func: bool) -> None:
+        cm: unittest._AssertRaisesContext[ValueError]
+        exc: ValueError
+        exc = ValueError("no context")
+        with self.assertRaises(ValueError) as cm:
+            self.go_with(use_func=use_func, exc=exc)
+        self.assertIsNone(cm.exception.__cause__)
+        self.assertIsInstance(cm.exception.__context__, ZeroDivisionError)
+        self.assertTrue(cm.exception.__suppress_context__)
+
+    def go_with(self: Self, *, use_func: bool, exc: Exception) -> None:
+        one: int
+        zero: int
+        try:
+            # Create a real context exception
+            one = 1
+            zero = 0
+            one / zero
+        except ZeroDivisionError:
+            # This should behave like: raise exc from None
+            if use_func:
+                core.raisefunction(exc, None)
+            else:
+                raise exc from None
+
+    def test_raise_from_None(self: Self) -> None:
+        self.go(use_func=False)
+        self.go(use_func=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

{raisefunction-1.0.3 → raisefunction-1.0.5/src/raisefunction.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raisefunction
-Version: 1.0.3
+Version: 1.0.5
 Summary: This project provides a function that raises errors passed to it.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -40,7 +40,6 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: overloadable<2,>=1.0.14
 Dynamic: license-file
 
 =============

{raisefunction-1.0.3 → raisefunction-1.0.5}/src/raisefunction.egg-info/SOURCES.txt

@@ -7,9 +7,10 @@ src/raisefunction/__init__.py
 src/raisefunction.egg-info/PKG-INFO
 src/raisefunction.egg-info/SOURCES.txt
 src/raisefunction.egg-info/dependency_links.txt
-src/raisefunction.egg-info/requires.txt
 src/raisefunction.egg-info/top_level.txt
 src/raisefunction/core/__init__.py
 src/raisefunction/tests/__init__.py
 src/raisefunction/tests/test_0.py
-src/raisefunction/tests/test_1.py
+src/raisefunction/tests/test_1.py
+src/raisefunction/tests/test_2.py
+src/raisefunction/tests/test_3.py

raisefunction-1.0.3/src/raisefunction/__init__.py

@@ -1,5 +0,0 @@
-from raisefunction.core import *
-from raisefunction.tests import *
-
-if __name__ == "__main__":
-    main()

raisefunction-1.0.3/src/raisefunction/core/__init__.py

@@ -1,29 +0,0 @@
-from typing import *
-
-from overloadable import overloadable
-
-__all__ = ["raisefunction"]
-
-
-@overloadable
-def raisefunction(*args: Any, **kwargs: Any) -> int:
-    "This function works as dispatcher."
-    argc: int = len(args)
-    keys: set = set(kwargs.keys())
-    if argc <= 1 and keys == set():
-        return 1
-    if argc == 0 and keys == {"exc"}:
-        return 1
-    return 2
-
-
-@raisefunction.overload(1)
-def raisefunction(exc: BaseException) -> None:
-    "This function raises the given exception."
-    raise exc
-
-
-@raisefunction.overload(2)
-def raisefunction(exc: BaseException, cause: Optional[BaseException]) -> None:
-    "This function raises the given exception with the given cause."
-    raise exc from cause

raisefunction-1.0.3/src/raisefunction/tests/test_0.py

@@ -1,41 +0,0 @@
-import unittest
-
-from raisefunction.core import raisefunction
-
-
-class TestRaiseFunction(unittest.TestCase):
-    def test_dispatcher_no_arguments(self):
-        """Test the dispatcher raises a TypeError with no arguments."""
-        with self.assertRaises(TypeError) as context:
-            raisefunction()
-        # self.assertIn("requires at least 1 positional argument", str(context.exception))
-
-    def test_dispatcher_too_many_arguments(self):
-        """Test the dispatcher raises a TypeError with more than 2 arguments."""
-        with self.assertRaises(TypeError) as context:
-            raisefunction(1, 2, 3)
-        # self.assertIn("takes at most 2 positional arguments", str(context.exception))
-
-    def test_raise_single_exception(self):
-        """Test the single exception raising overload."""
-        with self.assertRaises(ValueError):
-            raisefunction(ValueError("Test single exception"))
-
-    def test_raise_exception_with_cause(self):
-        """Test the exception raising overload with a cause."""
-        with self.assertRaises(ValueError) as context:
-            raisefunction(ValueError("Test exception"), TypeError("Cause exception"))
-        self.assertEqual(str(context.exception), "Test exception")
-        self.assertIsInstance(context.exception.__cause__, TypeError)
-        self.assertEqual(str(context.exception.__cause__), "Cause exception")
-
-    def test_invalid_arguments_in_overloads(self):
-        """Test invalid argument types raise appropriate errors."""
-        with self.assertRaises(TypeError):
-            raisefunction("not an exception")
-        with self.assertRaises(TypeError):
-            raisefunction("not an exception", "not a cause")
-
-
-if __name__ == "__main__":
-    unittest.main()

raisefunction-1.0.3/src/raisefunction/tests/test_1.py

@@ -1,17 +0,0 @@
-import unittest
-
-from raisefunction.core import raisefunction
-
-
-class TestRaiseFunction(unittest.TestCase):
-
-    def test_raise_exception_with_cause(self):
-        """Test the exception raising overload with a cause."""
-        with self.assertRaises(ValueError) as context:
-            raisefunction(ValueError("Test exception"), KeyError("Cause exception"))
-        self.assertEqual(str(context.exception), "Test exception")
-        self.assertIsInstance(context.exception.__cause__, KeyError)
-
-
-if __name__ == "__main__":
-    unittest.main()

raisefunction-1.0.3/src/raisefunction.egg-info/requires.txt

@@ -1 +0,0 @@
-overloadable<2,>=1.0.14