mm-std 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

mm_std/__init__.py

@@ -40,6 +40,8 @@ from .random_ import random_choice as random_choice
 from .random_ import random_decimal as random_decimal
 from .random_ import random_str_choice as random_str_choice
 from .result import Result as Result
+from .result import is_err as is_err
+from .result import is_ok as is_ok
 from .str import number_with_separator as number_with_separator
 from .str import str_contains_any as str_contains_any
 from .str import str_ends_with_any as str_ends_with_any

mm_std/config.py

@@ -42,11 +42,11 @@ class BaseConfig(BaseModel):
             else:
                 with config_path.open("rb") as f:
                     data = tomllib.load(f)
-            return Result.success(cls(**data))
+            return Result.ok(cls(**data))
         except ValidationError as e:
-            return Result.failure(("validator_error", e), extra={"errors": e.errors()})
+            return Result.err(("validator_error", e), extra={"errors": e.errors()})
         except Exception as e:
-            return Result.failure(e)
+            return Result.err(e)
 
     @classmethod
     async def read_toml_config_async(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
@@ -58,11 +58,11 @@ class BaseConfig(BaseModel):
                 with config_path.open("rb") as f:
                     data = tomllib.load(f)
             model = await cls.model_validate(data)  # type:ignore[misc]
-            return Result.success(model)
+            return Result.ok(model)
         except ValidationError as e:
-            return Result.failure(("validator_error", e), extra={"errors": e.errors()})
+            return Result.err(("validator_error", e), extra={"errors": e.errors()})
         except Exception as e:
-            return Result.failure(e)
+            return Result.err(e)
 
     @classmethod
     def _print_error_and_exit(cls, res: Result[Any]) -> NoReturn:
@@ -73,5 +73,5 @@ class BaseConfig(BaseModel):
                 field = ".".join(str(lo) for lo in loc) if len(loc) > 0 else ""
                 print_plain(f"{field} {e['msg']}")
         else:
-            print_plain(f"can't parse config file: {res.error}")
+            print_plain(f"can't parse config file: {res.error} {res.exception}")
         sys.exit(1)

mm_std/http/http_response.py

@@ -54,14 +54,14 @@ class HttpResponse:
                 return None
             raise
 
-    def is_error(self) -> bool:
+    def is_err(self) -> bool:
         return self.error is not None or (self.status_code is not None and self.status_code >= 400)
 
-    def to_result_failure[T](self, error: str | Exception | tuple[str, Exception] | None = None) -> Result[T]:
-        return Result.failure(error or self.error or "error", extra=self.to_dict())
+    def to_err[T](self, error: str | Exception | tuple[str, Exception] | None = None) -> Result[T]:
+        return Result.err(error or self.error or "error", extra=self.to_dict())
 
-    def to_result_success[T](self, result: T) -> Result[T]:
-        return Result.success(result, extra=self.to_dict())
+    def to_ok[T](self, value: T) -> Result[T]:
+        return Result.ok(value, extra=self.to_dict())
 
     def to_dict(self) -> dict[str, Any]:
         return {

mm_std/result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from typing import Any, TypeVar, cast
+from typing import Any, Protocol, TypeGuard, TypeVar, cast
 
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import CoreSchema, core_schema
@@ -15,10 +15,10 @@ type Extra = dict[str, Any] | None
 class Result[T]:
     """
     A container representing either a successful result or an error.
-    Use `Result.success()` or `Result.failure()` to create instances.
+    Use `Result.ok()` or `Result.err()` to create instances.
     """
 
-    ok: T | None  # Success value, if any
+    value: T | None  # Success value, if any
     error: str | None  # Error message, if any
     exception: Exception | None  # Exception, if any. It's optional.
     extra: Extra  # Optional extra metadata
@@ -32,7 +32,7 @@ class Result[T]:
         """
         return self.error is None
 
-    def is_error(self) -> bool:
+    def is_err(self) -> bool:
         """
         Returns True if the result represents an error.
         """
@@ -51,7 +51,7 @@ class Result[T]:
         """
         if not self.is_ok():
             raise RuntimeError(f"Called unwrap() on a failure value: {self.error}")
-        return cast(T, self.ok)
+        return cast(T, self.value)
 
     def unwrap_or(self, default: T) -> T:
         """
@@ -59,7 +59,7 @@ class Result[T]:
         """
         if not self.is_ok():
             return default
-        return cast(T, self.ok)
+        return cast(T, self.value)
 
     def unwrap_error(self) -> str:
         """
@@ -67,7 +67,7 @@ class Result[T]:
         Raises RuntimeError if the result is a success.
         """
         if self.is_ok():
-            raise RuntimeError("Called unwrap_error() on a success value")
+            raise RuntimeError("Called unwrap_err() on a success value")
         return cast(str, self.error)
 
     def unwrap_exception(self) -> Exception:
@@ -93,50 +93,64 @@ class Result[T]:
         Note: the exception is converted to a string if present.
         """
         return {
-            "ok": self.ok,
+            "value": self.value,
             "error": self.error,
             "exception": str(self.exception) if self.exception else None,
             "extra": self.extra,
         }
 
+    def with_value(self, value: U) -> Result[U]:
+        """
+        Returns a copy of this Result with the success value replaced by `value`.
+        The `extra` metadata is preserved.
+        """
+        return Result.ok(value, self.extra)
+
+    def with_error(self, error: str | Exception | tuple[str, Exception]) -> Result[T]:
+        """
+        Returns a copy of this Result as an Err with the given `error`.
+        Preserves existing `extra` metadata.
+        """
+        return Result.err(error, self.extra)
+
     def map(self, fn: Callable[[T], U]) -> Result[U]:
         if self.is_ok():
             try:
-                new_value = fn(cast(T, self.ok))
-                return Result.success(new_value, extra=self.extra)
+                new_value = fn(cast(T, self.value))
+                return Result.ok(new_value, extra=self.extra)
             except Exception as e:
-                return Result.failure(("map_exception", e), extra=self.extra)
+                return Result.err(("map_exception", e), extra=self.extra)
         return cast(Result[U], self)
 
     async def map_async(self, fn: Callable[[T], Awaitable[U]]) -> Result[U]:
         if self.is_ok():
             try:
-                new_value = await fn(cast(T, self.ok))
-                return Result.success(new_value, extra=self.extra)
+                new_value = await fn(cast(T, self.value))
+                return Result.ok(new_value, extra=self.extra)
             except Exception as e:
-                return Result.failure(("map_exception", e), extra=self.extra)
+                return Result.err(("map_exception", e), extra=self.extra)
         return cast(Result[U], self)
 
     def and_then(self, fn: Callable[[T], Result[U]]) -> Result[U]:
         if self.is_ok():
             try:
-                return fn(cast(T, self.ok))
+                return fn(cast(T, self.value))
             except Exception as e:
-                return Result.failure(("and_then_exception", e), extra=self.extra)
+                return Result.err(("and_then_exception", e), extra=self.extra)
         return cast(Result[U], self)
 
     async def and_then_async(self, fn: Callable[[T], Awaitable[Result[U]]]) -> Result[U]:
         if self.is_ok():
             try:
-                return await fn(cast(T, self.ok))
+                return await fn(cast(T, self.value))
             except Exception as e:
-                return Result.failure(("and_then_exception", e), extra=self.extra)
+                return Result.err(("and_then_exception", e), extra=self.extra)
         return cast(Result[U], self)
 
     def __repr__(self) -> str:
         parts: list[str] = []
-        if self.ok is not None:
-            parts.append(f"ok={self.ok!r}")
+        if self.value is not None:
+            parts.append(f"value={self.value!r}")
         if self.error is not None:
             parts.append(f"error={self.error!r}")
         if self.exception is not None:
@@ -148,7 +162,7 @@ class Result[T]:
     def __hash__(self) -> int:
         return hash(
             (
-                self.ok,
+                self.value,
                 self.error,
                 self.exception,
                 frozenset(self.extra.items()) if self.extra else None,
@@ -159,34 +173,37 @@ class Result[T]:
         if not isinstance(other, Result):
             return False
         return (
-            self.ok == other.ok and self.error == other.error and self.exception == other.exception and self.extra == other.extra
+            self.value == other.value
+            and self.error == other.error
+            and self.exception == other.exception
+            and self.extra == other.extra
         )
 
     @classmethod
-    def _create(cls, ok: T | None, error: str | None, exception: Exception | None, extra: Extra) -> Result[T]:
+    def _create(cls, value: T | None, error: str | None, exception: Exception | None, extra: Extra) -> Result[T]:
         obj = object.__new__(cls)
-        obj.ok = ok
+        obj.value = value
         obj.error = error
         obj.exception = exception
         obj.extra = extra
         return obj
 
     @staticmethod
-    def success(ok: T, extra: Extra = None) -> Result[T]:
+    def ok(value: T, extra: Extra = None) -> Result[T]:
         """
         Creates a successful Result instance.
 
         Args:
-            ok: The success value to store in the Result.
+            value: The success value to store in the Result.
             extra: Optional extra metadata to associate with the Result.
 
         Returns:
             A Result instance representing success with the provided value.
         """
-        return Result._create(ok=ok, error=None, exception=None, extra=extra)
+        return Result._create(value=value, error=None, exception=None, extra=extra)
 
     @staticmethod
-    def failure(error: str | Exception | tuple[str, Exception], extra: Extra = None) -> Result[T]:
+    def err(error: str | Exception | tuple[str, Exception], extra: Extra = None) -> Result[T]:
         """
         Creates a Result instance representing a failure.
 
@@ -209,7 +226,7 @@ class Result[T]:
             error_ = error
             exception = None
 
-        return Result._create(ok=None, error=error_, exception=exception, extra=extra)
+        return Result._create(value=None, error=error_, exception=exception, extra=extra)
 
     @classmethod
     def __get_pydantic_core_schema__(cls, _source_type: type[Any], _handler: GetCoreSchemaHandler) -> CoreSchema:
@@ -225,9 +242,27 @@ class Result[T]:
             return value
         if isinstance(value, dict):
             return cls._create(
-                ok=value.get("ok"),
+                value=value.get("value"),
                 error=value.get("error"),
                 exception=value.get("exception"),
                 extra=value.get("extra"),
             )
         raise TypeError(f"Invalid value for Result: {value}")
+
+
+class OkResult(Protocol[T]):
+    value: T
+    error: None
+
+
+class ErrResult(Protocol[T]):  # type:ignore[misc]
+    value: None
+    error: str
+
+
+def is_ok(res: Result[T]) -> TypeGuard[OkResult[T]]:
+    return res.is_ok()
+
+
+def is_err(res: Result[T]) -> TypeGuard[ErrResult[T]]:
+    return res.is_err()

{mm_std-0.4.5.dist-info → mm_std-0.4.7.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.4.5
+Version: 0.4.7
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
 Requires-Dist: aiohttp~=3.11.16
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: multidict~=6.4.3
-Requires-Dist: pydantic-settings>=2.8.1
+Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pydantic~=2.11.3
 Requires-Dist: pydash~=8.0.5
 Requires-Dist: python-dotenv~=1.1.0

{mm_std-0.4.5.dist-info → mm_std-0.4.7.dist-info}/RECORD

@@ -1,6 +1,6 @@
-mm_std/__init__.py,sha256=gSMy_KY9kffPFnrDzdUti_JiQP1hB3ZtF7GxhOCc1Vc,2814
+mm_std/__init__.py,sha256=SlfY7KoSiv9YEkeBrjUksIUtLkkG17Ii-DYpC1TGphY,2886
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
-mm_std/config.py,sha256=9KfHTbv-VBbZVs8gzue4CH51ygoiEhZ9aQOmM-O-m74,3080
+mm_std/config.py,sha256=-XigcK4XLc8JHe1-9_LxufoY5aHX1l9gx-lRizWY18A,3070
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
 mm_std/date.py,sha256=976eEkSONuNqHQBgSRu8hrtH23tJqztbmHFHLdbP2TY,1879
 mm_std/dict.py,sha256=6GkhJPXD0LiJDxPcYe6jPdEDw-MN7P7mKu6U5XxwYDk,675
@@ -12,7 +12,7 @@ mm_std/net.py,sha256=qdRCBIDneip6FaPNe5mx31UtYVmzqam_AoUF7ydEyjA,590
 mm_std/print_.py,sha256=zB7sVbSSF8RffMxvnOdbKCXjCKtKzKV3R68pBri4NkQ,1638
 mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_std/random_.py,sha256=OuUX4VJeSd13NZBya4qrGpR2TfN7_87tfebOY6DBUnI,1113
-mm_std/result.py,sha256=Q4mmX2VP2TNpVFf1J_YWZY-rKwmqJwI1RlMjLsDF7hY,7896
+mm_std/result.py,sha256=ZeGL5juBLdrlYiNgI89K50W_pNn35IOVE71sdfV_1uo,8800
 mm_std/str.py,sha256=BEjJ1p5O4-uSYK0h-enasSSDdwzkBbiwdQ4_dsrlEE8,3257
 mm_std/toml.py,sha256=CNznWKR0bpOxS6e3VB5LGS-Oa9lW-wterkcPUFtPcls,610
 mm_std/types_.py,sha256=9FGd2q47a8M9QQgsWJR1Kq34jLxBAkYSoJuwih4PPqg,257
@@ -27,7 +27,7 @@ mm_std/concurrency/sync_task_runner.py,sha256=s5JPlLYLGQGHIxy4oDS-PN7O9gcy-yPZFo
 mm_std/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_std/http/http_request.py,sha256=VnjZKrfaXQfMxrHRUqQ-Sxtr5Qf9FXBiJ-mmJTCzNkY,3709
 mm_std/http/http_request_sync.py,sha256=bqCBilbe4ZJ9vkhuBQeU5UMTJh6BtvtUwjieEodu6rw,1542
-mm_std/http/http_response.py,sha256=gz4kCCL0qr7wvw4NNiK1K2hXlrY0B0Iq4fJuYSrv3bw,3920
-mm_std-0.4.5.dist-info/METADATA,sha256=vsoqJPmQ237Lvv4C057WvFRJsNkSHhmawo2Fy9VqOWI,446
-mm_std-0.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.4.5.dist-info/RECORD,,
+mm_std/http/http_response.py,sha256=vrRv7Rjr5_kTUGllfW5oJ8ZqkcfiXc9T8PlBGAr-TBM,3884
+mm_std-0.4.7.dist-info/METADATA,sha256=RM6Tu17kVqjVnLqV08LyQMWh2GuvdKV-wLsBbwon0OE,446
+mm_std-0.4.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.4.7.dist-info/RECORD,,