StructResult 0.6.0__tar.gz → 0.6.2__tar.gz

{structresult-0.6.0 → structresult-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StructResult
-Version: 0.6.0
+Version: 0.6.2
 Summary: structural result with ExceptionGroup
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/Result_prj

{structresult-0.6.0 → structresult-0.6.2}/pyproject.toml

@@ -9,7 +9,7 @@ where = ["src"]
 
 [project]
 name = "StructResult"
-version = "0.6.0"
+version = "0.6.2"
 requires-python = ">= 3.12"
 authors = [
     {name="Serj Kotilevski", email="youserj@outlook.com"}
@@ -51,6 +51,7 @@ explicit_package_bases = true
 [tool.ruff]
 src = ["src"]
 line-length = 150
+preview = true
 exclude = [
     ".git",
     ".mypy_cache",

{structresult-0.6.0 → structresult-0.6.2}/src/StructResult/formatter.py

@@ -1,11 +1,14 @@
+from typing import Callable
+
+
 def format_eg(
-        eg: BaseExceptionGroup,
+        eg: ExceptionGroup,
         indent: int = 0,
         *,
         prefix: str = "  ",
         bullet: str = "- ",
         show_count: bool = True,
-        repr_fn: callable = repr,
+        repr_fn: Callable[[BaseException], str] = repr,
 ) -> str:
     """
     Formats an ExceptionGroup into a readable tree-like string representation.
@@ -35,7 +38,7 @@ def format_eg(
             - TypeError('Bad type')
     """
     current_prefix = prefix * indent
-    count_info = f" ({len(eg.exceptions)} sub-exception{'s'[:len(eg.exceptions)!=1]})" if show_count else ""
+    count_info = f" ({len(eg.exceptions)} sub-exception{'s'[:len(eg.exceptions) != 1]})" if show_count else ""
     msg = [f"{current_prefix}{eg.message}{count_info}:"]
 
     for exc in eg.exceptions:

{structresult-0.6.0 → structresult-0.6.2}/src/StructResult.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StructResult
-Version: 0.6.0
+Version: 0.6.2
 Summary: structural result with ExceptionGroup
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/Result_prj

{structresult-0.6.0 → structresult-0.6.2}/src/StructResult.egg-info/SOURCES.txt

@@ -2,7 +2,7 @@ README.md
 pyproject.toml
 src/StructResult/__init__.py
 src/StructResult/formatter.py
-src/StructResult/py.typed.py
+src/StructResult/py.typed
 src/StructResult/result.py
 src/StructResult.egg-info/PKG-INFO
 src/StructResult.egg-info/SOURCES.txt

{structresult-0.6.0 → structresult-0.6.2}/test/test_formatter.py

@@ -4,7 +4,7 @@ from src.StructResult.formatter import format_eg
 
 
 class TestFormatEG(unittest.TestCase):
-    def setUp(self):
+    def setUp(self) -> None:
         self.simple_error = ValueError("Simple error")
         self.nested_group = ExceptionGroup("Nested", [TypeError("Type error")])
 
@@ -23,18 +23,18 @@ class TestFormatEG(unittest.TestCase):
         self.list_result.append(Simple[int](value=42))
         self.list_result.append(Simple[int](value=None))
 
-    def test_basic_exception_group(self):
+    def test_basic_exception_group(self) -> None:
         eg = ExceptionGroup("Test", [self.simple_error])
         result = format_eg(eg)
         expected = "Test (1 sub-exception):\n  - ValueError('Simple error')"
         self.assertEqual(result, expected)
 
-    def test_nested_exception_group(self):
+    def test_nested_exception_group(self) -> None:
         result = format_eg(self.nested_group)
         expected = "Nested (1 sub-exception):\n  - TypeError('Type error')"
         self.assertEqual(result, expected)
 
-    def test_complex_exception_group(self):
+    def test_complex_exception_group(self) -> None:
         result = format_eg(self.complex_group)
         expected = (
             "Complex (3 sub-exceptions):\n"
@@ -46,22 +46,22 @@ class TestFormatEG(unittest.TestCase):
         )
         self.assertEqual(result, expected)
 
-    def test_with_result_protocol(self):
+    def test_with_result_protocol(self) -> None:
         error_result = Simple[str](value=None)
         error_result.append_err(self.complex_group)
-
-        result = format_eg(error_result.err)
-        expected = (
-            "Complex (3 sub-exceptions):\n"
-            "  - ValueError('Simple error')\n"
-            "  Nested (1 sub-exception):\n"
-            "    - TypeError('Type error')\n"
-            "  With content (1 sub-exception):\n"
-            "    - ValueError('Placeholder')"
-        )
-        self.assertEqual(result, expected)
-
-    def test_custom_formatting(self):
+        if error_result.err is not None:
+            result = format_eg(error_result.err)
+            expected = (
+                "Complex (3 sub-exceptions):\n"
+                "  - ValueError('Simple error')\n"
+                "  Nested (1 sub-exception):\n"
+                "    - TypeError('Type error')\n"
+                "  With content (1 sub-exception):\n"
+                "    - ValueError('Placeholder')"
+            )
+            self.assertEqual(result, expected)
+
+    def test_custom_formatting(self) -> None:
         eg = ExceptionGroup("Custom", [self.simple_error])
         result = format_eg(
             eg,
@@ -73,7 +73,7 @@ class TestFormatEG(unittest.TestCase):
         expected = "Custom:\n    * ValueError: Simple error"
         self.assertEqual(result, expected)
 
-    def test_with_list_result_errors(self):
+    def test_with_list_result_errors(self) -> None:
         list_result = List[int]()
         list_result.append(Simple[int](value=1))
         error_result = Simple[int](value=2)
@@ -85,15 +85,16 @@ class TestFormatEG(unittest.TestCase):
             expected = " (1 sub-exception):\n  - ValueError('Simple error')"
             self.assertTrue(result.endswith(expected))
 
-    def test_protocol_compatibility(self):
+    def test_protocol_compatibility(self) -> None:
         error_result = Error(msg="test")
         error_result.append_err(self.complex_group)
 
         self.assertIsInstance(error_result.err, BaseExceptionGroup)
-        formatted = format_eg(error_result.err)
-        self.assertIn("Complex (3 sub-exceptions)", formatted)
+        if error_result.err is not None:
+            formatted = format_eg(error_result.err)
+            self.assertIn("Complex (3 sub-exceptions)", formatted)
 
-    def test_multiple_nesting_levels(self):
+    def test_multiple_nesting_levels(self) -> None:
         level3 = ExceptionGroup("Level3", [RuntimeError("Deep error")])
         level2 = ExceptionGroup("Level2", [level3])
         level1 = ExceptionGroup("Level1", [level2])

{structresult-0.6.0 → structresult-0.6.2}/test/test_result.py

@@ -4,12 +4,12 @@ from src.StructResult.result import Simple, NONE, Error, List
 
 
 class TestResultProtocols(unittest.TestCase):
-    def setUp(self):
+    def setUp(self) -> None:
         self.exception1 = ValueError("Error 1")
         self.exception2 = TypeError("Error 2")
         self.exception_group = ExceptionGroup("msg", [self.exception1, self.exception2])
 
-    def test_simple_ok(self):
+    def test_simple_ok(self) -> None:
         res = Simple[int](value=42)
         self.assertEqual(res.value, 42)
         self.assertIsNone(res.err)
@@ -17,7 +17,7 @@ class TestResultProtocols(unittest.TestCase):
         self.assertEqual(res.unwrap(), 42)
         self.assertEqual(list(res), [42, None])
 
-    def test_simple_err(self):
+    def test_simple_err(self) -> None:
         res = Simple[int](value=42)
         res.append_err(self.exception1)
         self.assertEqual(res.value, 42)
@@ -27,14 +27,14 @@ class TestResultProtocols(unittest.TestCase):
             res.unwrap()
         self.assertEqual(list(res), [42, res.err])
 
-    def test_null(self):
+    def test_null(self) -> None:
         self.assertIsNone(NONE.value)
         self.assertIsNone(NONE.err)
         self.assertTrue(NONE.is_ok())
         self.assertIsNone(NONE.unwrap())
         self.assertEqual(list(NONE), [None, None])
 
-    def test_error(self):
+    def test_error(self) -> None:
         err = Error(msg="test")
         err.append_err(self.exception1)
         self.assertIsNone(err.value)
@@ -43,7 +43,7 @@ class TestResultProtocols(unittest.TestCase):
         with self.assertRaises(ExceptionGroup):
             err.unwrap()
 
-    def test_list_append(self):
+    def test_list_append(self) -> None:
         lst = List[int]()
         lst.append(Simple[int](value=1))
         lst.append(Simple[int](value=2))
@@ -51,7 +51,7 @@ class TestResultProtocols(unittest.TestCase):
         self.assertIsNone(lst.err)
         self.assertTrue(lst.is_ok())
 
-    def test_list_append_with_errors(self):
+    def test_list_append_with_errors(self) -> None:
         lst = List[int]()
         res1 = Simple[int](value=1)
         res1.append_err(self.exception1)
@@ -63,10 +63,11 @@ class TestResultProtocols(unittest.TestCase):
 
         self.assertEqual(lst.value, [1, 2])
         self.assertIsNotNone(lst.err)
-        self.assertEqual(len(lst.err.exceptions), 2)
+        if lst.err is not None:
+            self.assertEqual(len(lst.err.exceptions), 2)
         self.assertFalse(lst.is_ok())
 
-    def test_list_add_operator(self):
+    def test_list_add_operator(self) -> None:
         lst = List[int]()
         res1 = Simple[int](value=1)
         res2 = Simple[int](value=2)
@@ -74,7 +75,7 @@ class TestResultProtocols(unittest.TestCase):
         lst += res2
         self.assertEqual(lst.value, [1, 2])
 
-    def test_propagate_err(self):
+    def test_propagate_err(self) -> None:
         target = Simple[str](msg="target")
         source_ok = Simple[str](value="ok")
         source_err = Simple[str](value="err")
@@ -89,18 +90,20 @@ class TestResultProtocols(unittest.TestCase):
         result = target.propagate_err(source_err)
         self.assertEqual(result, "err")
         self.assertIsNotNone(target.err)
-        self.assertEqual(len(target.err.exceptions), 1)
+        if target.err is not None:
+            self.assertEqual(len(target.err.exceptions), 1)
 
-    def test_error_grouping(self):
+    def test_error_grouping(self) -> None:
         grouper = Simple[Any](msg="group")
         grouper.append_err(self.exception1)
         grouper.append_err(self.exception2)
 
         self.assertIsNotNone(grouper.err)
-        self.assertEqual(len(grouper.err.exceptions), 2)
-        self.assertEqual(grouper.err.message, "group")
+        if grouper.err is not None:
+            self.assertEqual(len(grouper.err.exceptions), 2)
+            self.assertEqual(grouper.err.message, "group")
 
-    def test_exception_group_merging(self):
+    def test_exception_group_merging(self) -> None:
         grouper = Simple[Any](msg="group")
         group1 = ExceptionGroup("group", [self.exception1])
         group2 = ExceptionGroup("group", [self.exception2])
@@ -109,10 +112,11 @@ class TestResultProtocols(unittest.TestCase):
         grouper.append_err(group2)
 
         self.assertIsNotNone(grouper.err)
-        self.assertEqual(len(grouper.err.exceptions), 2)
-        self.assertEqual(grouper.err.message, "group")
+        if grouper.err is not None:
+            self.assertEqual(len(grouper.err.exceptions), 2)
+            self.assertEqual(grouper.err.message, "group")
 
-    def test_different_message_groups(self):
+    def test_different_message_groups(self) -> None:
         grouper = Simple[Any](msg="main")
         group = ExceptionGroup("other", [self.exception1])
 
@@ -120,11 +124,12 @@ class TestResultProtocols(unittest.TestCase):
 
         self.assertIsNotNone(grouper.err)
         # Should be wrapped in a new group with "main" message
-        self.assertEqual(grouper.err.message, "other")
-        self.assertEqual(len(grouper.err.exceptions), 1)
+        if grouper.err is not None:
+            self.assertEqual(grouper.err.message, "other")
+            self.assertEqual(len(grouper.err.exceptions), 1)
         self.assertIsInstance(grouper.err, ExceptionGroup)
 
-    def test_simple_append(self):
+    def test_simple_append(self) -> None:
         simple = Simple[Any]()
         res_ok = Simple[int](value=42)
         res_err = Simple[int](value=0)
@@ -140,7 +145,7 @@ class TestResultProtocols(unittest.TestCase):
         self.assertEqual(simple.value, 0)
         self.assertIsNotNone(simple.err)
 
-    def test_list_multiple_appends(self):
+    def test_list_multiple_appends(self) -> None:
         lst = List[int]()
         res1 = Simple[int](value=1)
         res2 = Simple[int](value=2)
@@ -153,4 +158,5 @@ class TestResultProtocols(unittest.TestCase):
 
         self.assertEqual(lst.value, [1, 2, 3])
         self.assertIsNotNone(lst.err)
-        self.assertEqual(len(lst.err.exceptions), 1)
+        if lst.err is not None:
+            self.assertEqual(len(lst.err.exceptions), 1)