mm-std 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

mm_std/result.py

@@ -4,6 +4,8 @@ import time
 from collections.abc import Callable
 from typing import Any, Generic, Literal, NoReturn, TypeAlias, TypeVar
 
+from pydantic_core import core_schema
+
 T = TypeVar("T", covariant=True)  # Success type
 U = TypeVar("U")
 F = TypeVar("F")
@@ -13,24 +15,24 @@ TBE = TypeVar("TBE", bound=BaseException)
 class Ok(Generic[T]):
     __match_args__ = ("ok",)
 
-    def __init__(self, value: T, data: Any = None) -> None:
-        self._value = value
+    def __init__(self, ok: T, data: Any = None) -> None:
+        self.ok = ok
         self.data = data
 
     def __repr__(self) -> str:
         if self.data is None:
-            return f"Ok({self._value!r})"
+            return f"Ok({self.ok!r})"
         else:
-            return f"Ok({self._value!r}, data={self.data!r})"
+            return f"Ok({self.ok!r}, data={self.data!r})"
 
     def __eq__(self, other: Any) -> bool:
-        return isinstance(other, Ok) and self._value == other._value and self.data == other.data
+        return isinstance(other, Ok) and self.ok == other.ok and self.data == other.data
 
     def __ne__(self, other: Any) -> bool:
         return not (self == other)
 
     def __hash__(self) -> int:
-        return hash((True, self._value, self.data))
+        return hash((True, self.ok, self.data))
 
     def is_ok(self) -> Literal[True]:
         return True
@@ -38,47 +40,43 @@ class Ok(Generic[T]):
     def is_err(self) -> Literal[False]:
         return False
 
-    @property
-    def ok(self) -> T:
-        return self._value
-
     @property
     def err(self) -> None:
         return None
 
     def expect(self, _message: str) -> T:
-        return self._value
+        return self.ok
 
     def expect_err(self, message: str) -> NoReturn:
         raise UnwrapError(self, message)
 
     def unwrap(self) -> T:
-        return self._value
+        return self.ok
 
     def unwrap_err(self) -> NoReturn:
         raise UnwrapError(self, "Called `Result.unwrap_err()` on an `Ok` value")
 
     def unwrap_or(self, _default: U) -> T:
-        return self._value
+        return self.ok
 
     def unwrap_or_else(self, op: object) -> T:
-        return self._value
+        return self.ok
 
     def unwrap_or_raise(self, e: object) -> T:
-        return self._value
+        return self.ok
 
     def map(self, op: Callable[[T], U]) -> Ok[U]:
-        return Ok(op(self._value), data=self.data)
+        return Ok(op(self.ok), data=self.data)
 
     def map_or(self, default: object, op: Callable[[T], U]) -> U:
-        return op(self._value)
+        return op(self.ok)
 
     def map_or_else(self, err_op: object, ok_op: Callable[[T], U]) -> U:
         """
         The contained result is `Ok`, so return original value mapped to
         a new value using the passed in `op` function.
         """
-        return ok_op(self._value)
+        return ok_op(self.ok)
 
     def map_err(self, op: object) -> Ok[T]:
         """
@@ -92,7 +90,7 @@ class Ok(Generic[T]):
         original value passed in. If return of `op` function is not Result, it will be a Ok value.
         """
         try:
-            res = op(self._value)
+            res = op(self.ok)
             if not isinstance(res, Ok | Err):
                 res = Ok(res)
         except Exception as e:
@@ -104,33 +102,45 @@ class Ok(Generic[T]):
         return self
 
     def ok_or_err(self) -> T | str:
-        return self._value
+        return self.ok
 
     def ok_or_none(self) -> T | None:
-        return self._value
+        return self.ok
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        return core_schema.model_schema(
+            cls,
+            core_schema.model_fields_schema(
+                {
+                    "ok": core_schema.model_field(core_schema.any_schema()),
+                    "data": core_schema.model_field(core_schema.any_schema()),
+                }
+            ),
+        )
 
 
 class Err:
     __match_args__ = ("err",)
 
-    def __init__(self, value: str | Exception, data: Any = None) -> None:
-        self._value = f"exception: {value}" if isinstance(value, Exception) else value
+    def __init__(self, err: str | Exception, data: Any = None) -> None:
+        self.err = f"exception: {err}" if isinstance(err, Exception) else err
         self.data = data
 
     def __repr__(self) -> str:
         if self.data is None:
-            return f"Err({self._value!r})"
+            return f"Err({self.err!r})"
         else:
-            return f"Err({self._value!r}, data={self.data!r})"
+            return f"Err({self.err!r}, data={self.data!r})"
 
     def __eq__(self, other: Any) -> bool:
-        return isinstance(other, Err) and self._value == other._value and self.data == other.data
+        return isinstance(other, Err) and self.err == other.err and self.data == other.data
 
     def __ne__(self, other: Any) -> bool:
         return not (self == other)
 
     def __hash__(self) -> int:
-        return hash((False, self._value, self.data))
+        return hash((False, self.err, self.data))
 
     def is_ok(self) -> Literal[False]:
         return False
@@ -145,30 +155,23 @@ class Err:
         """
         return None
 
-    @property
-    def err(self) -> str:
-        """
-        Return the error.
-        """
-        return self._value
-
     def expect(self, message: str) -> NoReturn:
         """
         Raises an `UnwrapError`.
         """
         exc = UnwrapError(
             self,
-            f"{message}: {self._value!r}",
+            f"{message}: {self.err!r}",
         )
-        if isinstance(self._value, BaseException):
-            raise exc from self._value
+        if isinstance(self.err, BaseException):
+            raise exc from self.err
         raise exc
 
     def expect_err(self, _message: str) -> str:
         """
         Return the inner value
         """
-        return self._value
+        return self.err
 
     def unwrap(self) -> NoReturn:
         """
@@ -176,17 +179,17 @@ class Err:
         """
         exc = UnwrapError(
             self,
-            f"Called `Result.unwrap()` on an `Err` value: {self._value!r}",
+            f"Called `Result.unwrap()` on an `Err` value: {self.err!r}",
         )
-        if isinstance(self._value, BaseException):
-            raise exc from self._value
+        if isinstance(self.err, BaseException):
+            raise exc from self.err
         raise exc
 
     def unwrap_err(self) -> str:
         """
         Return the inner value
         """
-        return self._value
+        return self.err
 
     def unwrap_or(self, default: U) -> U:
         """
@@ -199,13 +202,13 @@ class Err:
         The contained result is ``Err``, so return the result of applying
         ``op`` to the error value.
         """
-        return op(self._value)
+        return op(self.err)
 
     def unwrap_or_raise(self, e: type[TBE]) -> NoReturn:
         """
         The contained result is ``Err``, so raise the exception with the value.
         """
-        raise e(self._value)
+        raise e(self.err)
 
     def map(self, op: object) -> Err:
         """
@@ -223,7 +226,7 @@ class Err:
         """
         Return the result of the default operation
         """
-        return err_op(self._value)
+        return err_op(self.err)
 
     def and_then(self, op: object) -> Err:
         """
@@ -232,11 +235,23 @@ class Err:
         return self
 
     def ok_or_err(self) -> T | str:
-        return self._value
+        return self.err
 
     def ok_or_none(self) -> T | None:
         return None
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        return core_schema.model_schema(
+            cls,
+            core_schema.model_fields_schema(
+                {
+                    "err": core_schema.model_field(core_schema.any_schema()),
+                    "data": core_schema.model_field(core_schema.any_schema()),
+                }
+            ),
+        )
+
 
 Result: TypeAlias = Ok[T] | Err
 

{mm_std-0.1.3.dist-info → mm_std-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mm-std
-Version: 0.1.3
+Version: 0.1.4
 Requires-Python: >=3.12
 Requires-Dist: cryptography~=43.0.1
 Requires-Dist: httpx[http2,socks]~=0.27.2

{mm_std-0.1.3.dist-info → mm_std-0.1.4.dist-info}/RECORD

@@ -13,11 +13,11 @@ mm_std/net.py,sha256=FIH_drMlf_ng-icI2w_mXiVyiLQUvJkskh3rQF8x8pM,4705
 mm_std/print_.py,sha256=mMixwfdrLEYW15ez7_QxXdrV-d38q9XJP8tB8F7P2pI,1553
 mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_std/random_.py,sha256=KZauQzHsJaCVIeyHrJ74hiH34hdFE7pUxuv5i0Hl28g,1175
-mm_std/result.py,sha256=EBump_FnfPk7kU7-e_Y95qrOO-myW25XGyNdjExEqrI,6989
+mm_std/result.py,sha256=mYjQdKsSEMCqRFOsq7c-ZRp2faGnO_fieTzAeUwsa20,7592
 mm_std/str.py,sha256=nG5XF5870xM2PAvU0LZrJDk-d54LYwRLGnSahIekOVw,3151
 mm_std/telegram.py,sha256=QrHPnsy0LTeqpd-g3RaHhk7gWIfHZEgnMs-S5DLW-vU,1220
 mm_std/types.py,sha256=KpFtJ-BTmDfmmFeOSlgq6cMbCfGGOQjh1oWvdcrW-kw,116
 mm_std/zip.py,sha256=2EXcae4HO5U4kObj2Lj8jl5F2OUpT-WRlJybTyFzt6I,370
-mm_std-0.1.3.dist-info/METADATA,sha256=U74FVLHkMbm1Ze5ON7k0PjiWIKsKJmxS96F_cUxeyFc,335
-mm_std-0.1.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-mm_std-0.1.3.dist-info/RECORD,,
+mm_std-0.1.4.dist-info/METADATA,sha256=Szn_7ov6SgljedK3va8zwTXjMav1i5lLHikp1n_nSHs,335
+mm_std-0.1.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mm_std-0.1.4.dist-info/RECORD,,