raisefunction 1.0.4__tar.gz → 1.0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raisefunction
-Version: 1.0.4
+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)

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

@@ -25,7 +25,7 @@ keywords = []
 name = "raisefunction"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.0.4"
+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.4 → raisefunction-1.0.5}/src/raisefunction/core/__init__.py

@@ -6,13 +6,18 @@ DEFAULT = object()
 
 
 @overload
-def raisefunction(exc: BaseException) -> None: ...
+def raisefunction(
+    exc: BaseException | type[BaseException],
+) -> Never: ...
 @overload
-def raisefunction(exc: BaseException, cause: Optional[BaseException]) -> None: ...
+def raisefunction(
+    exc: BaseException | type[BaseException],
+    cause: Optional[BaseException],
+) -> Never: ...
 
 
 def raisefunction(
-    exc: BaseException,
+    exc: BaseException | type[BaseException],
     cause: Optional[BaseException] | object = DEFAULT,
 ) -> Never:
     "This function raises the given exception."

{raisefunction-1.0.4 → raisefunction-1.0.5}/src/raisefunction/tests/test_0.py

@@ -3,19 +3,19 @@ from typing import *
 
 from raisefunction.core import raisefunction
 
-__all__ = ["TestRaiseFunction"]
+__all__ = ["Test0"]
 
 
-class TestRaiseFunction(unittest.TestCase):
+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) as context:
+        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) as context:
+        with self.assertRaises(TypeError):
             raisefunction(1, 2, 3)
         # self.assertIn("takes at most 2 positional arguments", str(context.exception))
 

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.4 → raisefunction-1.0.5/src/raisefunction.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raisefunction
-Version: 1.0.4
+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)

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

@@ -10,4 +10,7 @@ src/raisefunction.egg-info/dependency_links.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_0.py
+src/raisefunction/tests/test_1.py
+src/raisefunction/tests/test_2.py
+src/raisefunction/tests/test_3.py

raisefunction-1.0.4/src/raisefunction/__init__.py

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