StructResult 0.6.2__tar.gz → 0.7.0__tar.gz

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

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

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

@@ -9,7 +9,7 @@ where = ["src"]
 
 [project]
 name = "StructResult"
-version = "0.6.2"
+version = "0.7.0"
 requires-python = ">= 3.12"
 authors = [
     {name="Serj Kotilevski", email="youserj@outlook.com"}
@@ -64,8 +64,7 @@ exclude = [
     "venv",
 ]
 include = [
-    "src/*/*.py",
-    "examples/*/*.py",
+    "src/**/*.py",
     "test/test_*.py"
 ]
 

{structresult-0.6.2 → structresult-0.7.0}/src/StructResult/result.py

@@ -1,28 +1,19 @@
 from dataclasses import dataclass, field
-from typing import Optional, Self, Any, Protocol, Iterator, Final
+from typing import Optional, Self, Protocol, Iterator, Any
 
 
-class Result[T](Protocol):
-    value: Optional[T]
-    err: Optional[ExceptionGroup]
-    msg: str = ""
+class Result(Protocol):
+    msg: str
 
-    def __iter__(self) -> Iterator[T | ExceptionGroup[Exception] | None]:
-        return iter((self.value, self.err))
+    def is_ok(self) -> bool: ...
 
-    def unwrap(self) -> Optional[T]:
-        if self.err:
-            raise self.err
-        return self.value
+
+class ErrorPropagator(Result, Protocol):
+    err: Optional[ExceptionGroup]
 
     def is_ok(self) -> bool:
         return self.err is None
 
-
-class ErrorGrouper(Protocol):
-    err: Optional[ExceptionGroup]
-    msg: str = ""
-
     def append_err(self, e: Exception | ExceptionGroup) -> Self:
         """append except"""
         if isinstance(e, ExceptionGroup):
@@ -41,61 +32,66 @@ class ErrorGrouper(Protocol):
                 self.err = ExceptionGroup(self.msg, (e, self.err))
         return self
 
-
-class ErrorPropagator(ErrorGrouper, Protocol):
-    def propagate_err[T](self, res: Result[T]) -> Optional[T]:
+    def propagate_err[T](self, res: "Collector[T]") -> Optional[T]:
         """Propagates (merges) the error from another Result into this one, returning its value"""
         if res.err is not None:
             self.append_err(res.err)
-        return res.value
+        return res.value if hasattr(res, "value") else None
 
 
-class Appender[T](ErrorPropagator, Protocol):
-    def append(self, res: Result[T]) -> Optional[T]: ...
+class Collector[T](ErrorPropagator, Protocol):
+    value: T
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter((self.value, self.err))
+
+    def unwrap(self) -> T:
+        if self.err:
+            raise self.err
+        return self.value
 
 
 @dataclass(slots=True)
-class Simple[T](Result[T], Appender[T]):
+class Simple[T](Collector[Optional[T]], Result):
+    msg: str = ""
     value: Optional[T] = field(default=None)
-    msg: str = field(default="")
     err: Optional[ExceptionGroup] = field(init=False, default=None)
 
-    def append(self, res: Result[T]) -> Optional[T]:
+    def set(self, res: "Simple[T]") -> Optional[T]:
         """set value and append errors"""
         self.value = res.value
         return self.propagate_err(res)
 
 
-@dataclass(frozen=True)
-class Null(Result[Any]):
-    value: Final[None] = None
-    err: None = None
+@dataclass(slots=True)
+class Null(Result):
+    msg: str = ""
 
+    def is_ok(self) -> bool:
+        return True
 
-NONE = Null()
-"""None result"""
 
+class Error(ErrorPropagator):
+    __slots__ = ("msg", "err")
 
-@dataclass(slots=True)
-class Error(ErrorPropagator, Result[Any]):
-    value: Final[None] = field(default=None)
-    msg: str = field(default="")
-    err: Optional[ExceptionGroup] = field(init=False, default=None)
+    def __init__(self, e: Exception, msg: str = "") -> None:
+        self.msg = msg
+        self.err = ExceptionGroup(self.msg, (e,))
 
 
 @dataclass(slots=True)
-class List[T](Appender[T], Result[list[Optional[T]]]):
-    msg: str = field(default="")
-    value: Optional[list[Optional[T]]] = field(init=False, default=None)
+class List[T](Collector[list[Optional[T]]], Result):
+    msg: str = ""
+    value: list[Optional[T]] = field(init=False, default_factory=list)
     err: Optional[ExceptionGroup] = field(init=False, default=None)
 
-    def append(self, res: Result[T]) -> Optional[T]:
+    def append(self, res: Simple[T]) -> Optional[T]:
         """append value and errors"""
         if self.value is None:
             self.value = []
         self.value.append(res.value)
         return self.propagate_err(res)
 
-    def __add__(self, other: Result[T]) -> Self:
+    def __add__(self, other: Simple[T]) -> Self:
         self.append(other)
         return self

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

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

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

@@ -17,8 +17,7 @@ class TestFormatEG(unittest.TestCase):
 
         # Create test Result objects
         self.simple_result = Simple[str](value="test")
-        self.error_result = Error(msg="error occurred")
-        self.error_result.append_err(self.simple_error)
+        self.error_result = Error(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))
@@ -86,8 +85,7 @@ class TestFormatEG(unittest.TestCase):
             self.assertTrue(result.endswith(expected))
 
     def test_protocol_compatibility(self) -> None:
-        error_result = Error(msg="test")
-        error_result.append_err(self.complex_group)
+        error_result = Error(self.complex_group, msg="test")
 
         self.assertIsInstance(error_result.err, BaseExceptionGroup)
         if error_result.err is not None:

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

@@ -1,6 +1,6 @@
 import unittest
 from typing import Any
-from src.StructResult.result import Simple, NONE, Error, List
+from src.StructResult.result import Simple, Error, List, Null
 
 
 class TestResultProtocols(unittest.TestCase):
@@ -28,20 +28,12 @@ class TestResultProtocols(unittest.TestCase):
         self.assertEqual(list(res), [42, res.err])
 
     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])
+        self.assertTrue(Null().is_ok())
 
     def test_error(self) -> None:
-        err = Error(msg="test")
-        err.append_err(self.exception1)
-        self.assertIsNone(err.value)
+        err = Error(self.exception1, msg="test")
         self.assertIsNotNone(err.err)
         self.assertFalse(err.is_ok())
-        with self.assertRaises(ExceptionGroup):
-            err.unwrap()
 
     def test_list_append(self) -> None:
         lst = List[int]()
@@ -136,12 +128,12 @@ class TestResultProtocols(unittest.TestCase):
         res_err.append_err(self.exception1)
 
         # Append OK result
-        simple.append(res_ok)
+        simple.set(res_ok)
         self.assertEqual(simple.value, 42)
         self.assertIsNone(simple.err)
 
         # Append error result
-        simple.append(res_err)
+        simple.set(res_err)
         self.assertEqual(simple.value, 0)
         self.assertIsNotNone(simple.err)