StructResult 0.4.2__tar.gz → 0.5.1__tar.gz

{structresult-0.4.2 → structresult-0.5.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: StructResult
-Version: 0.4.2
-Summary: structural result with exception
+Version: 0.5.1
+Summary: structural result with ExceptionGroup
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/Result_prj
-Keywords: result,exception
+Keywords: result,Exception,ExceptionGroup,AggregateExceptions
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{structresult-0.4.2 → structresult-0.5.1}/pyproject.toml

@@ -9,16 +9,21 @@ where = ["src"]
 
 [project]
 name = "StructResult"
-version = "0.4.2"
+version = "0.5.1"
 requires-python = ">= 3.12"
 authors = [
     {name="Serj Kotilevski", email="youserj@outlook.com"}
 ]
 dependencies = [
 ]
-description="structural result with exception"
+description="structural result with ExceptionGroup"
 readme = "README.md"
-keywords=['result', 'exception']
+keywords=[
+    'result',
+    'Exception',
+    'ExceptionGroup',
+    'AggregateExceptions'
+]
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

structresult-0.5.1/src/StructResult/result.py

@@ -0,0 +1,129 @@
+from typing import Optional, TypeVar, Generic, Self
+from abc import ABC, abstractmethod
+
+T = TypeVar("T")
+
+empty = tuple()
+
+
+class Result(Generic[T], ABC):
+    value: Optional[T]
+    err: Optional[ExceptionGroup]
+    msg: str = ""
+    __slots__ = empty
+
+    def __getitem__(self, item):
+        if item == 0:
+            return self.value
+        elif item == 1:
+            return self.err
+        else:
+            raise StopIteration
+
+    @abstractmethod
+    def append(self, res: Self) -> T:
+        """"""
+
+    def append_err(self, e: Exception | ExceptionGroup):
+        if isinstance(e, ExceptionGroup):
+            if self.err is None:
+                self.err = e
+            elif self.msg == e.message:
+                self.err = ExceptionGroup(self.msg, (*self.err.exceptions, *e.exceptions))
+            else:
+                self.err = ExceptionGroup(self.msg, (*self.err.exceptions, e))
+        else:  # for Exception
+            if self.err is None:
+                self.err = ExceptionGroup(self.msg, (e,))
+            elif self.msg == self.err.message:
+                self.err = ExceptionGroup(self.msg, (*self.err.exceptions, e))
+            else:
+                self.err = ExceptionGroup(self.msg, (e, self.err))
+
+    def unwrap(self) -> T:
+        if self.err:
+            raise self.err
+        return self.value
+
+    def is_ok(self) -> bool:
+        return self.err is None
+
+
+class Simple(Result, Generic[T]):
+    __slots__ = ("value", "err", "msg")
+
+    def __init__(self, value: Optional[T] = None, e: Exception = None, msg: str = ""):
+        self.value = value
+        if e is not None:
+            self.err = ExceptionGroup(msg, (e,))
+        else:
+            self.err = None
+        self.msg = msg
+
+    def append(self, res: Result) -> T:
+        """set value and append errors"""
+        self.value = res.value
+        if res.err is not None:
+            self.append_err(res.err)
+        return res.value
+
+
+class Null(Result):
+    """can't append value or errors"""
+    __slots__ = empty
+
+    def append(self, res: Self):
+        raise RuntimeError(F"can't append for {self.__class__.__name__}")
+
+    @property
+    def value(self):
+        return None
+
+    @property
+    def err(self):
+        return None
+
+
+NONE = Null()
+"""None result"""
+
+
+class Error(Result):
+    __slots__ = ("err", "msg")
+
+    def __init__(self, e: Exception = None, msg: str = ""):
+        if e is not None:
+            self.err = ExceptionGroup(msg, (e,))
+        else:
+            self.err = None
+        self.msg = msg
+
+    def append(self, res: Result) -> None:
+        if res.err is not None:
+            self.append_err(res.err)
+        return None
+
+    @property
+    def value(self):
+        return None
+
+
+class List(Result, Generic[T]):
+    value: list[T]
+    __slots__ = ("value", "err", "msg")
+
+    def __init__(self, msg: str = ""):
+        self.value = list()
+        self.err = None
+        self.msg = msg
+
+    def append(self, res: Result[T]) -> T:
+        """append value and errors"""
+        self.value.append(res.value)
+        if res.err is not None:
+            self.append_err(res.err)
+        return res.value[-1]
+
+    def __add__(self, other: Result[T]) -> Self:
+        self.append(other)
+        return self

{structresult-0.4.2 → structresult-0.5.1}/src/StructResult.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: StructResult
-Version: 0.4.2
-Summary: structural result with exception
+Version: 0.5.1
+Summary: structural result with ExceptionGroup
 Author-email: Serj Kotilevski <youserj@outlook.com>
 Project-URL: Source, https://github.com/youserj/Result_prj
-Keywords: result,exception
+Keywords: result,Exception,ExceptionGroup,AggregateExceptions
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

structresult-0.5.1/test/test_Result.py

@@ -0,0 +1,124 @@
+import traceback
+import unittest
+from StructResult import result
+
+
+class TestType(unittest.TestCase):
+
+    def test_init(self):
+        res = result.Simple[int](1, msg="handle")
+        res.append_err(ExceptionGroup("handle1", [ValueError(2)]))
+        res.append_err(ValueError(1))
+        self.assertEqual(res.value, 1)
+        traceback.print_exception(res.err)
+
+    def test_Optional(self):
+
+        def foo() -> result.Simple[int]:
+            return result.Simple(None)
+
+    def test_resultList(self):
+        res = result.List[int]("list")
+        res.append(result.Simple(1, ValueError(1)))
+        res.append_err(ValueError(2))
+        res.append(result.Simple(2))
+        res.append(result.Simple(None, ZeroDivisionError(3), msg="devide"))
+        res.append(result.Simple("1"))
+        res += result.Simple(3, TypeError(13), msg="type")
+        traceback.print_exception(res.err)
+
+    def test_Null(self):
+        res = result.NONE
+        self.assertRaises(RuntimeError, res.append, result.Simple(1))
+        a, b = res
+        print(a)
+
+    def test_Error(self):
+        res = result.Error()
+        res.append(result.Simple(1, ZeroDivisionError()))
+        a, b = res
+        print(a)
+
+    def test_simple_append_value(self):
+        # Test appending a successful Simple result
+        res1 = result.Simple(10)
+        res2 = result.Simple(20)
+        res1.append(res2)
+        self.assertEqual(res1.value, 20)
+        self.assertIsNone(res1.err)
+
+    def test_simple_append_error(self):
+        # Test appending an error Simple result
+        res1 = result.Simple(10)
+        res2 = result.Simple(e=ValueError("test error"), msg="test")
+        res1.append(res2)
+        self.assertEqual(res1.value, None)
+        self.assertIsNotNone(res1.err)
+        self.assertEqual(len(res1.err.exceptions), 1)
+
+    def test_simple_append_multiple_errors(self):
+        # Test error aggregation
+        res1 = result.Simple(e=TypeError("type error"), msg="test")
+        res2 = result.Simple(e=ValueError("value error"), msg="test")
+        res1.append(res2)
+        self.assertEqual(len(res1.err.exceptions), 2)
+
+    def test_simple_append_different_messages(self):
+        # Test error aggregation with different messages
+        res1 = result.Simple(e=TypeError("type error"), msg="test1")
+        res2 = result.Simple(e=ValueError("value error"), msg="test2")
+        res1.append(res2)
+        # Should nest the exception groups
+        self.assertEqual(len(res1.err.exceptions), 2)
+        self.assertIsInstance(res1.err.exceptions[1], ExceptionGroup)
+
+    def test_null_append(self):
+        # Test that Null can't be appended to
+        with self.assertRaises(RuntimeError):
+            result.NONE.append(result.Simple(10))
+
+    def test_error_append_value(self):
+        # Test that Error ignores values but collects errors
+        err1 = result.Error(e=ValueError("error1"), msg="test")
+        simple = result.Simple(10)
+        err1.append(simple)
+        self.assertIsNone(err1.value)
+
+    def test_error_append_error(self):
+        # Test error aggregation in Error class
+        err1 = result.Error(e=ValueError("error1"), msg="test")
+        err2 = result.Error(e=TypeError("error2"), msg="test")
+        err1.append(err2)
+        self.assertEqual(len(err1.err.exceptions), 2)
+
+    def test_list_append_values(self):
+        # Test value collection in List
+        lst = result.List[int]()
+        lst.append(result.Simple(1))
+        lst.append(result.Simple(2))
+        lst.append(result.Simple(3))
+        self.assertEqual(lst.value, [1, 2, 3])
+        self.assertIsNone(lst.err)
+
+    def test_list_append_mixed(self):
+        # Test mixed success and error cases
+        lst = result.List[int](msg="test")
+        lst.append(result.Simple(1))
+        lst.append(result.Simple(e=ValueError("error1")))
+        lst.append(result.Simple(2))
+        lst.append(result.Simple(e=TypeError("error2")))
+        self.assertEqual(lst.value, [1, None, 2, None])
+        self.assertEqual(len(lst.err.exceptions), 2)
+
+    def test_list_operator_overload(self):
+        # Test the __add__ operator
+        lst = result.List[int]()
+        lst += result.Simple(1)
+        lst = lst + result.Simple(2)
+        self.assertEqual(lst.value, [1, 2])
+
+    def test_type_safety(self):
+        # Test type safety (should ideally fail but currently doesn't)
+        lst = result.List[int]()
+        lst.append(result.Simple("string"))  # This should ideally raise TypeError
+        self.assertEqual(lst.value, ["string"])

structresult-0.4.2/src/StructResult/result.py

@@ -1,105 +0,0 @@
-from typing import Optional, TypeVar, Generic, Self
-from abc import ABC, abstractmethod
-
-T = TypeVar("T")
-
-empty = tuple()
-
-
-class Result(Generic[T], ABC):
-    value: Optional[T]
-    err: Optional[list[Exception]]
-    __slots__ = empty
-
-    def __getitem__(self, item):
-        if item == 0:
-            return self.value
-        elif item == 1:
-            return self.err
-        else:
-            raise StopIteration
-
-    @abstractmethod
-    def append(self, res: Self):
-        """"""
-
-    def append_err(self, e: Exception):
-        if self.err is None:
-            self.err = list()
-        self.err.append(e)
-
-    def extend_err(self, e: list[Exception]):
-        if self.err is None:
-            self.err = list()
-        self.err.extend(e)
-
-
-class Simple(Result, Generic[T]):
-    value: Optional[T]
-    err: Optional[list[Exception]]
-    __slots__ = ("value", "err")
-
-    def __init__(self, value: Optional[T] = None, err: list[Exception] = None):
-        self.value = value
-        self.err = err
-
-    def append(self, res: Result):
-        """set value and append errors"""
-        self.value = res.value
-        if res.err is not None:
-            self.extend_err(res.err)
-
-
-class Null(Result):
-    """can't append value or errors"""
-    __slots__ = empty
-
-    def append(self, res: Self):
-        raise RuntimeError(F"can't append for {self.__class__.__name__}")
-
-    @property
-    def value(self):
-        return None
-
-    @property
-    def err(self):
-        return None
-
-
-NONE = Null()
-"""None result"""
-
-
-class Error(Result):
-    err: Optional[list[Exception]]
-    __slots__ = ("err",)
-
-    def __init__(self, err: list[Exception] = None):
-        self.err = err
-
-    def append(self, res: Result):
-        if res.err is not None:
-            self.extend_err(res.err)
-
-    @property
-    def value(self):
-        return None
-
-
-class List(Result, Generic[T]):
-    value: list[T]
-    __slots__ = ("value", "err")
-
-    def __init__(self, err: list[Exception] = None):
-        self.value = list()
-        self.err = err
-
-    def append(self, res: Result[T]):
-        """append value and errors"""
-        self.value.append(res.value)
-        if res.err is not None:
-            self.extend_err(res.err)
-
-    def __add__(self, other: Result[T]) -> Self:
-        self.append(other)
-        return self

structresult-0.4.2/test/test_Result.py

@@ -1,36 +0,0 @@
-import unittest
-from StructResult import result
-
-
-class TestType(unittest.TestCase):
-
-    def test_init(self):
-        res = result.Simple[int](1)
-        self.assertEqual(res.value, 1)
-        self.assertEqual(list(res), [1, None])
-
-    def test_Optional(self):
-
-        def foo() -> result.Simple[int]:
-            return result.Simple(None)
-
-    def test_resultList(self):
-        res = result.List[int]()
-        res.append(result.Simple(1, [ValueError("1")]))
-        res.append(result.Simple(2))
-        res.append(result.Simple(None, [ZeroDivisionError()]))
-        res.append(result.Simple("1"))
-        res += result.Simple(3)
-        print(res)
-
-    def test_Null(self):
-        res = result.NONE
-        self.assertRaises(RuntimeError, res.append, result.Simple(1))
-        a, b = res
-        print(a)
-
-    def test_Error(self):
-        res = result.Error()
-        res.append(result.Simple(1, [ZeroDivisionError()]))
-        a, b = res
-        print(a)