StructResult 0.8.0__tar.gz → 0.8.2__tar.gz

{structresult-0.8.0 → structresult-0.8.2}/PKG-INFO

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

{structresult-0.8.0 → structresult-0.8.2}/pyproject.toml

@@ -9,7 +9,7 @@ where = ["src"]
 
 [project]
 name = "StructResult"
-version = "0.8.0"
+version = "0.8.2"
 requires-python = ">= 3.12"
 authors = [
     {name="Serj Kotilevski", email="youserj@outlook.com"}

{structresult-0.8.0 → structresult-0.8.2}/src/StructResult/result.py

@@ -1,9 +1,10 @@
 from dataclasses import dataclass, field
 from typing import Optional, Self, Protocol, Iterator, Any
+
 """
 Functional error handling system with:
 - Result composition
-- Error accumulation 
+- Error accumulation
 - Type-safe operations
 
 Core concepts:
@@ -19,6 +20,18 @@ class Result(Protocol):
         """Returns True if successful (no errors)"""
 
 
+class Ok(Result):
+    """Singleton success marker without value"""
+    def is_ok(self) -> bool:
+        return True
+
+    def __str__(self) -> str:
+        return "OK"
+
+
+OK = Ok()
+
+
 class ErrorPropagator(Result, Protocol):
     """Protocol for error-accumulating types"""
     err: Optional[ExceptionGroup]
@@ -53,7 +66,7 @@ class ErrorPropagator(Result, Protocol):
                 self.err = ExceptionGroup(self.msg, (e, self.err))
         return self
 
-    def propagate_err[T](self, res: "Collector[T]") -> Optional[T]:
+    def propagate_err[T](self, res: "Collector[T] | ErrorAccumulator") -> Optional[T]:
         """Merges errors from another result and returns its value:
         1. If res has errors - merges them into current
         2. Returns res's value (if exists)
@@ -63,6 +76,30 @@ class ErrorPropagator(Result, Protocol):
         return res.value if hasattr(res, "value") else None
 
 
+@dataclass(slots=True)
+class Error(ErrorPropagator):
+    """Error-only result container"""
+    err: ExceptionGroup
+    msg: str = ""
+
+    @classmethod
+    def from_e(cls, e: Exception, msg: str = "") -> Self:
+        return cls(ExceptionGroup(msg, (e,)), msg)
+
+
+@dataclass(slots=True)
+class ErrorAccumulator(ErrorPropagator):
+    """Base container for error propagation with status conversion"""
+    err: Optional[ExceptionGroup] = field(init=False, default=None)
+    msg: str = ""
+
+    @property
+    def result(self) -> Ok | Error:
+        if self.err is None:
+            return OK
+        return Error(self.err)
+
+
 class Collector[T](ErrorPropagator, Protocol):
     """Protocol for value containers with error handling"""
     value: T
@@ -78,64 +115,41 @@ class Collector[T](ErrorPropagator, Protocol):
 
 
 @dataclass(slots=True)
-class Simple[T](Collector[Optional[T]], Result):
-    """Basic collector for optional values"""
+class Simple[T](Collector[T], Result):
+    """Basic collector for values"""
+    value: T
     msg: str = ""
-    value: Optional[T] = field(default=None)
     err: Optional[ExceptionGroup] = field(init=False, default=None)
 
-    def set(self, res: "Simple[T]") -> Optional[T]:
+    def set(self, res: "Simple[T]") -> T:
         """set value and append errors"""
         self.value = res.value
-        return self.propagate_err(res)
+        if res.err is not None:
+            self.append_err(res.err)
+        return res.value
 
 
 @dataclass(slots=True)
-class Bool(Collector[bool], Result):
+class Bool(Simple[bool], Result):
     """Specialized collector for boolean results"""
-    msg: str = ""
     value: bool = field(default=False)
     err: Optional[ExceptionGroup] = field(init=False, default=None)
 
-    def set(self, res: "Bool") -> bool:
-        """set value and append errors"""
-        self.value = res.value
-        self.propagate_err(res)
-        return res.value
-
-
-class Ok(Result):
-    """Singleton success marker without value"""
-    __slots__ = ()
-
-    def is_ok(self) -> bool:
-        return True
-
-    def __str__(self) -> str:
-        return "OK"
-
-
-OK = Ok()
-
 
-class Error(ErrorPropagator):
-    """Error-only result container"""
-    __slots__ = ("msg", "err")
-    err: ExceptionGroup
-
-    def __init__(self, e: Exception, msg: str = "") -> None:
-        self.msg = msg
-        self.err = ExceptionGroup(self.msg, (e,))
+@dataclass(slots=True)
+class Option[T](Simple[Optional[T]], Result):
+    """Basic collector for optional values"""
+    value: Optional[T] = field(default=None)
 
 
 @dataclass(slots=True)
 class List[T](Collector[list[Optional[T | Ok]]], Result):
     """List collector with error accumulation"""
-    msg: str = ""
     value: list[Optional[T] | Ok] = field(init=False, default_factory=list)
+    msg: str = ""
     err: Optional[ExceptionGroup] = field(init=False, default=None)
 
-    def append(self, res: Collector[Optional[T]] | Error | Ok) -> None:
+    def append(self, res:  Option[T] | Simple[T] | Error | Ok) -> None:
         """Appends result with rules:
         - For OK: adds OK marker
         - For Error: adds None and merges errors
@@ -151,6 +165,6 @@ class List[T](Collector[list[Optional[T | Ok]]], Result):
         else:
             self.value.append(res.value)
 
-    def __add__(self, other: Collector[Optional[T]] | Error | Ok) -> Self:
+    def __add__(self, other: Option[T] | Simple[T] | Error | Ok) -> Self:
         self.append(other)
         return self

{structresult-0.8.0 → structresult-0.8.2}/src/StructResult.egg-info/PKG-INFO

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

{structresult-0.8.0 → structresult-0.8.2}/test/benchmark.py

@@ -1,19 +1,27 @@
 import timeit
-from src.StructResult.result import OK, Error, Simple
+from typing import Any, TypeGuard
+from src.StructResult import result
+from src.StructResult.result import Ok, Error, Simple, Result, Collector
 
 # test data
 ok_result = Simple(value=1)
-error_result = Error(ValueError("fail"))
+error_result = Error.from_e(ValueError("fail"))
 
 
 # var 1: if not result.is_ok()
-def check_is_ok(result):
-    return not result.is_ok()
+def check_is_ok[T](res: Collector[T] | Error | Ok) -> TypeGuard[Collector[T] | Ok]:
+    return not res.is_ok()
 
 
 # var 2: if not isinstance(result, Error)
-def check_isinstance(result):
-    return not isinstance(result, Error)
+def check_isinstance(res: Result) -> bool:
+    return not isinstance(res, Error)
+
+
+def foo(res: Simple[Any] | Error) -> None:
+    if not check_is_ok(res):
+        raise ValueError()
+    print(res.value)
 
 
 # OK_result speed

{structresult-0.8.0 → structresult-0.8.2}/test/test_formatter.py

@@ -1,11 +1,11 @@
 import unittest
-from src.StructResult.result import Simple, Error, List
+from src.StructResult.result import Option, Error, List
 from src.StructResult.formatter import format_eg
 
 
 class TestFormatEG(unittest.TestCase):
     def setUp(self) -> None:
-        self.simple_error = ValueError("Simple error")
+        self.simple_error = ValueError("Option error")
         self.nested_group = ExceptionGroup("Nested", [TypeError("Type error")])
 
         # Create a complex group with at least one exception in each subgroup
@@ -16,16 +16,16 @@ class TestFormatEG(unittest.TestCase):
         ])
 
         # Create test Result objects
-        self.simple_result = Simple[str](value="test")
-        self.error_result = Error(self.simple_error, msg="error occurred")
+        self.simple_result = Option[str](value="test")
+        self.error_result = Error.from_e(self.simple_error, msg="error occurred")
         self.list_result = List[int]()
-        self.list_result.append(Simple[int](value=42))
-        self.list_result.append(Simple[int](value=None))
+        self.list_result.append(Option[int](value=42))
+        self.list_result.append(Option[int](value=None))
 
     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')"
+        expected = "Test (1 sub-exception):\n  - ValueError('Option error')"
         self.assertEqual(result, expected)
 
     def test_nested_exception_group(self) -> None:
@@ -37,7 +37,7 @@ class TestFormatEG(unittest.TestCase):
         result = format_eg(self.complex_group)
         expected = (
             "Complex (3 sub-exceptions):\n"
-            "  - ValueError('Simple error')\n"
+            "  - ValueError('Option error')\n"
             "  Nested (1 sub-exception):\n"
             "    - TypeError('Type error')\n"
             "  With content (1 sub-exception):\n"
@@ -46,13 +46,13 @@ class TestFormatEG(unittest.TestCase):
         self.assertEqual(result, expected)
 
     def test_with_result_protocol(self) -> None:
-        error_result = Simple[str]()
+        error_result = Option[str]()
         error_result.append_err(self.complex_group)
         if error_result.err is not None:
             result = format_eg(error_result.err)
             expected = (
                 "Complex (3 sub-exceptions):\n"
-                "  - ValueError('Simple error')\n"
+                "  - ValueError('Option error')\n"
                 "  Nested (1 sub-exception):\n"
                 "    - TypeError('Type error')\n"
                 "  With content (1 sub-exception):\n"
@@ -69,19 +69,19 @@ class TestFormatEG(unittest.TestCase):
             show_count=False,
             repr_fn=lambda e: f"{type(e).__name__}: {str(e)}"
         )
-        expected = "Custom:\n    * ValueError: Simple error"
+        expected = "Custom:\n    * ValueError: Option error"
         self.assertEqual(result, expected)
 
     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)
+        list_result.append(Option[int](value=1))
+        error_result = Option[int](value=2)
         error_result.append_err(self.simple_error)
         list_result.append(error_result)
 
         if list_result.err:
             result = format_eg(list_result.err)
-            expected = " (1 sub-exception):\n  - ValueError('Simple error')"
+            expected = " (1 sub-exception):\n  - ValueError('Option error')"
             self.assertTrue(result.endswith(expected))
 
     def test_protocol_compatibility(self) -> None:

{structresult-0.8.0 → structresult-0.8.2}/test/test_result.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import patch
-from typing import Optional, Any
-from src.StructResult.result import Simple, Bool, Ok, OK, Error, List
+from typing import Any
+from src.StructResult.result import Option, Bool, Ok, OK, Error, List
 
 
 class TestResultSystem(unittest.TestCase):
@@ -11,7 +11,7 @@ class TestResultSystem(unittest.TestCase):
 
     def test_error_creation(self) -> None:
         exc = ValueError("test error")
-        err = Error(exc, "context")
+        err = Error.from_e(exc, "context")
         self.assertFalse(err.is_ok())
         self.assertIsNotNone(err.err)
         self.assertEqual(err.msg, "context")
@@ -19,30 +19,30 @@ class TestResultSystem(unittest.TestCase):
         self.assertIsInstance(err.err.exceptions[0], ValueError)
 
     def test_simple_success(self) -> None:
-        res = Simple[str]("test", value="success")
+        res = Option[str]("success", "test")
         self.assertTrue(res.is_ok())
         self.assertEqual(res.unwrap(), "success")
         self.assertIsNone(res.err)
 
     def test_simple_failure(self) -> None:
         exc = TypeError("type error")
-        res = Simple[str]("test").append_err(exc)
+        res = Option[str]("test").append_err(exc)
         self.assertFalse(res.is_ok())
         self.assertIsNotNone(res.err)
         with self.assertRaises(ExceptionGroup):
             res.unwrap()
 
     def test_bool_type(self) -> None:
-        true_res = Bool("test", value=True)
-        false_res = Bool("test", value=False)
+        true_res = Bool(value=True, msg="test")
+        false_res = Bool(value=False, msg="test")
         self.assertTrue(true_res.unwrap())
         self.assertFalse(false_res.unwrap())
 
     def test_error_propagation(self) -> None:
         exc1 = RuntimeError("error 1")
         exc2 = KeyError("error 2")
-        res1 = Simple[int]("op1").append_err(exc1)
-        res2 = Simple[int]("op2").append_err(exc2)
+        res1 = Option[int](msg="op1").append_err(exc1)
+        res2 = Option[int](msg="op2").append_err(exc2)
         res1.propagate_err(res2)
         self.assertFalse(res1.is_ok())
         if res1.err is not None:
@@ -52,10 +52,10 @@ class TestResultSystem(unittest.TestCase):
 
     def test_list_collector(self) -> None:
         lst = List[int]("collection")
-        lst.append(Simple[int]("item1", value=42))
-        lst.append(Error(ValueError("bad value"), "item2"))
+        lst.append(Option[int](42, "item1"))
+        lst.append(Error.from_e(ValueError("bad value"), "item2"))
         lst.append(OK)
-        lst.append(Simple[int]("item3", value=100))
+        lst.append(Option[int](100, "item3"))
         self.assertEqual(len(lst.value), 4)
         self.assertEqual(lst.value[0], 42)
         self.assertIsInstance(lst.value[2], Ok)
@@ -65,8 +65,8 @@ class TestResultSystem(unittest.TestCase):
         self.assertIsInstance(lst.err.exceptions[0].exceptions[0], ValueError)
 
     def test_list_operator_overload(self) -> None:
-        lst = List[str]("test") + Simple[str]("first", value="hello")
-        lst += Error(TypeError("type error"), "second")
+        lst = List[str]("test") + Option[str]("hello", "first")
+        lst += Error.from_e(TypeError("type error"), "second")
         self.assertEqual(len(lst.value), 2)
         self.assertEqual(lst.value[0], "hello")
         self.assertFalse(lst.is_ok())
@@ -75,8 +75,8 @@ class TestResultSystem(unittest.TestCase):
         exc1 = ValueError("val1")
         exc2 = TypeError("type1")
         exc3 = KeyError("key1")
-        res1 = Simple[None]("group1").append_err(exc1).append_err(exc2)
-        res2 = Simple[None]("group1").append_err(exc3)
+        res1: Option[object] = Option(msg="group1").append_err(exc1).append_err(exc2)
+        res2: Option[object] = Option(msg="group1").append_err(exc3)
         res1.propagate_err(res2)
         self.assertEqual(len(res1.err.exceptions), 3)
         self.assertEqual(res1.err.message, "group1")
@@ -84,34 +84,34 @@ class TestResultSystem(unittest.TestCase):
     def test_different_error_groups(self) -> None:
         exc1 = ValueError("val1")
         exc2 = TypeError("type1")
-        res1 = Simple[None]("group1").append_err(exc1)
-        res2 = Simple[None]("group2").append_err(exc2)
+        res1: Option[object] = Option(msg="group1").append_err(exc1)
+        res2: Option[object] = Option(msg="group2").append_err(exc2)
         res1.propagate_err(res2)
         self.assertEqual(len(res1.err.exceptions), 2)
         self.assertIsInstance(res1.err.exceptions[1], ExceptionGroup)
 
     def test_set_operation(self) -> None:
-        main = Simple[str]("main")
-        other = Simple[str]("other", value="data")
+        main: Option[str] = Option(msg="main")
+        other: Option[str] = Option("data", "other")
         result = main.set(other)
         self.assertEqual(main.value, "data")
         self.assertEqual(result, "data")
         self.assertTrue(main.is_ok())
 
     def test_bool_set_operation(self) -> None:
-        main = Bool("main")
-        other = Bool("other", value=True)
+        main = Bool(msg="main")
+        other = Bool(value=True, msg="other")
         result = main.set(other)
         self.assertTrue(main.value)
         self.assertTrue(result)
 
     def test_simple_none_value(self) -> None:
-        res = Simple[Optional[int]]("test", value=None)
+        res: Option[int] = Option(msg="test")
         self.assertTrue(res.is_ok())
         self.assertIsNone(res.unwrap())
 
     def test_bool_false_with_error(self) -> None:
-        res = Bool("test", value=False)
+        res = Bool(value=False, msg="test")
         res.append_err(ValueError("bool error"))
         self.assertFalse(res.value)
         self.assertFalse(res.is_ok())
@@ -121,7 +121,7 @@ class TestResultSystem(unittest.TestCase):
     def test_nested_exception_groups(self) -> None:
         inner_group = ExceptionGroup("inner", [ValueError("v1"), TypeError("t1")])
         outer_group = ExceptionGroup("outer", [inner_group, KeyError("k1")])
-        res = Simple[int]("test").append_err(outer_group)
+        res = Option[int](msg="test").append_err(outer_group)
         if res.err is not None:
             self.assertEqual(len(res.err.exceptions), 1)
             self.assertIsInstance(res.err.exceptions[0], ExceptionGroup)
@@ -135,35 +135,35 @@ class TestResultSystem(unittest.TestCase):
         self.assertIsNone(lst.err)
 
     def test_list_mixed_types(self) -> None:
-        lst = List[object]("mixed")
-        lst.append(Simple[int]("int", value=42))
-        lst.append(Simple[str]("str", value="hello"))
-        lst.append(Error(ValueError("error"), "error"))
+        lst: List[str | int] = List("mixed")
+        lst.append(Option(42, "int"))
+        lst.append(Option("hello", "str"))
+        lst.append(Error.from_e(ValueError("error"), "error"))
         self.assertEqual(len(lst.value), 3)
         self.assertEqual(lst.value[0], 42)
         self.assertEqual(lst.value[1], "hello")
         self.assertIsInstance(lst.value[2], type(None))
 
     def test_propagate_none(self) -> None:
-        res = Simple[int]("main", value=42)
-        res.propagate_err(Simple[int]("other"))
+        res = Option[int](42, "main")
+        res.propagate_err(Option[int](msg="other"))
         self.assertTrue(res.is_ok())
         self.assertEqual(res.unwrap(), 42)
 
     def test_type_hints(self) -> None:
-        def processor() -> Simple[str]:
-            return Simple[str]("processor", value="result")
+        def processor() -> Option[str]:
+            return Option[str]("result", "processor")
 
         result = processor()
-        value: str = result.unwrap()
+        value: str | None = result.unwrap()
         self.assertEqual(value, "result")
 
     def test_combined_workflow(self) -> None:
         main = List[int]("combined workflow")
-        main += Simple[int]("op1", value=10)
-        main += Simple[int]("op2", value=20)
-        main += Error(ValueError("invalid value"), "op3")
-        main += Simple[int]("op4", value=30)
+        main += Option[int](10, "op1")
+        main += Option[int](20, "op2")
+        main += Error.from_e(ValueError("invalid value"), "op3")
+        main += Option[int](30, "op4")
         self.assertEqual(len(main.value), 4)
         self.assertEqual(main.value[0], 10)
         self.assertEqual(main.value[1], 20)
@@ -174,42 +174,40 @@ class TestResultSystem(unittest.TestCase):
             main.unwrap()
 
     def test_multiple_propagations(self) -> None:
-        res1 = Simple[int]("first").append_err(ValueError("v1"))
-        res2 = Simple[int]("second").append_err(TypeError("t1"))
-        res3 = Simple[int]("third").append_err(KeyError("k1"))
-
-        main = Simple[int]("main")
+        res1: Option[int] = Option(msg="first").append_err(ValueError("v1"))
+        res2: Option[int] = Option(msg="second").append_err(TypeError("t1"))
+        res3: Option[int] = Option(msg="third").append_err(KeyError("k1"))
+        main: Option[int] = Option(msg="main")
         main.propagate_err(res1)
         main.propagate_err(res2)
         main.propagate_err(res3)
-
         self.assertEqual(len(main.err.exceptions), 3)
 
-    @patch.object(Simple, "append_err")
+    @patch.object(Option, "append_err")
     def test_propagate_err_calls(self, mock_append: Any) -> None:
-        err_res = Simple[int]("error")
+        err_res = Option[int](msg="error")
         err_res.err = ExceptionGroup("error", [ValueError("test")])
-        main = Simple[int]("main")
+        main = Option[int](msg="main")
         main.propagate_err(err_res)
         mock_append.assert_called_once_with(err_res.err)
 
     def test_iterator_protocol(self) -> None:
-        res = Simple[str]("iter", value="test")
+        res = Option[str]("test", "iter")
         values = list(res)
         self.assertEqual(len(values), 2)
         self.assertEqual(values[0], "test")
         self.assertIsNone(values[1])
 
     def test_bool_truthiness(self) -> None:
-        true_res = Bool("true", value=True)
-        false_res = Bool("false", value=False)
+        true_res = Bool(value=True, msg="true")
+        false_res = Bool(value=False, msg="false")
         self.assertTrue(true_res.value)
         self.assertFalse(false_res.value)
         self.assertTrue(bool(true_res.unwrap()))
         self.assertFalse(bool(false_res.unwrap()))
 
-    def test_equal(self):
-        res = Simple("1")
+    def test_equal(self) -> None:
+        res: Option[str] = Option(msg="1")
         group = ExceptionGroup("1", (ValueError("1"),))
         res.append_err(group)
         self.assertEqual(res.err, group)