mm-std 0.4.17__py3-none-any.whl → 0.5.0__py3-none-any.whl

mm_std/result.py

@@ -1,315 +0,0 @@
-from __future__ import annotations
-
-import sys
-from collections.abc import Awaitable, Callable
-from typing import Any, Protocol, TypeGuard, TypeVar, cast
-
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-
-T = TypeVar("T")
-U = TypeVar("U")
-
-type Extra = dict[str, Any] | None
-
-
-class Result[T]:
-    """
-    A container representing either a successful result or an error.
-    Use `Result.ok()` or `Result.err()` to create instances.
-    """
-
-    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
-
-    def __init__(self) -> None:
-        raise RuntimeError("Result is not intended to be instantiated directly. Use the static methods instead.")
-
-    def is_ok(self) -> bool:
-        """
-        Returns True if the result represents success.
-        """
-        return self.error is None
-
-    def is_err(self) -> bool:
-        """
-        Returns True if the result represents an error.
-        """
-        return self.error is not None
-
-    def is_exception(self) -> bool:
-        """
-        Returns True if an exception is attached to the result.
-        """
-        return self.exception is not None
-
-    def unwrap(self, message_prefix: str | None = None, include_error: bool = True) -> T:
-        """
-        Returns the success value if the Result is Ok, otherwise raises a RuntimeError.
-
-        Args:
-            message_prefix: Optional custom prefix for the error message if the Result is an error.
-                            If not provided, a default message will be used.
-            include_error: If True, appends the internal error message from the Result to the final exception message.
-
-        Raises:
-            RuntimeError: If the Result is an error.
-
-        Returns:
-            The success value of type T.
-        """
-        if not self.is_ok():
-            # Use the provided message or a default fallback
-            error_message = message_prefix or "Called unwrap() on a failure value"
-            # Optionally append the error detail
-            if include_error:
-                error_message = f"{error_message}: {self.error}"
-            # Raise with the final constructed message
-            raise RuntimeError(error_message)
-        # Return the success value if present
-        return cast(T, self.value)
-
-    def unwrap_or_exit(
-        self,
-        message_prefix: str | None = None,
-        include_error: bool = True,
-        exit_code: int = 1,
-    ) -> T:
-        """
-        Returns the success value if the Result is Ok, otherwise prints an error to stderr and exits.
-
-        Args:
-            message_prefix: Optional custom prefix for the error message.
-            include_error: If True, includes the internal error message in the printed message.
-            exit_code: The exit code to use when terminating the program on error.
-
-        Returns:
-            The success value of type T.
-
-        Exits:
-            Exits the program with the specified exit code if the result is an error.
-        """
-        if self.is_ok():
-            return cast(T, self.value)
-
-        error_message = message_prefix or "Called unwrap_or_exit() on a failure value"
-        if include_error:
-            error_message = f"{error_message}: {self.error}"
-        print(error_message, file=sys.stderr)  # noqa: T201
-        sys.exit(exit_code)
-
-    def unwrap_or(self, default: T) -> T:
-        """
-        Returns the success value if available, otherwise returns the given default.
-        """
-        if not self.is_ok():
-            return default
-        return cast(T, self.value)
-
-    def unwrap_error(self) -> str:
-        """
-        Returns the error message.
-        Raises RuntimeError if the result is a success.
-        """
-        if self.is_ok():
-            raise RuntimeError("Called unwrap_err() on a success value")
-        return cast(str, self.error)
-
-    def unwrap_exception(self) -> Exception:
-        """
-        Returns the attached exception if present.
-        Raises RuntimeError if the result has no exception attached.
-        """
-        if self.exception is not None:
-            return self.exception
-        raise RuntimeError("No exception provided")
-
-    def value_or_error(self) -> T | str:
-        """
-        Returns the success value if available, otherwise returns the error message.
-        """
-        if self.is_ok():
-            return self.unwrap()
-        return self.unwrap_error()
-
-    def to_dict(self) -> dict[str, object]:
-        """
-        Returns a dictionary representation of the result.
-        Note: the exception is converted to a string if present.
-        """
-        return {
-            "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.value))
-                return Result.ok(new_value, extra=self.extra)
-            except Exception as e:
-                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.value))
-                return Result.ok(new_value, extra=self.extra)
-            except Exception as e:
-                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.value))
-            except Exception as e:
-                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.value))
-            except Exception as e:
-                return Result.err(("and_then_exception", e), extra=self.extra)
-        return cast(Result[U], self)
-
-    def __repr__(self) -> str:
-        parts: list[str] = []
-        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:
-            parts.append(f"exception={self.exception!r}")
-        if self.extra is not None:
-            parts.append(f"extra={self.extra!r}")
-        return f"Result({', '.join(parts)})"
-
-    def __hash__(self) -> int:
-        return hash(
-            (
-                self.value,
-                self.error,
-                self.exception,
-                frozenset(self.extra.items()) if self.extra else None,
-            )
-        )
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Result):
-            return False
-        return (
-            self.value == other.value
-            and self.error == other.error
-            and self.exception == other.exception
-            and self.extra == other.extra
-        )
-
-    @classmethod
-    def _create(cls, value: T | None, error: str | None, exception: Exception | None, extra: Extra) -> Result[T]:
-        obj = object.__new__(cls)
-        obj.value = value
-        obj.error = error
-        obj.exception = exception
-        obj.extra = extra
-        return obj
-
-    @staticmethod
-    def ok(value: T, extra: Extra = None) -> Result[T]:
-        """
-        Creates a successful Result instance.
-
-        Args:
-            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(value=value, error=None, exception=None, extra=extra)
-
-    @staticmethod
-    def err(error: str | Exception | tuple[str, Exception], extra: Extra = None) -> Result[T]:
-        """
-        Creates a Result instance representing a failure.
-
-        Args:
-            error: The error information, which can be:
-                - A string error message
-                - An Exception object
-                - A tuple containing (error_message, exception)
-            extra: Optional extra metadata to associate with the Result.
-
-        Returns:
-            A Result instance representing failure with the provided error information.
-        """
-        if isinstance(error, tuple):
-            error_, exception = error
-        elif isinstance(error, Exception):
-            error_ = "exception"
-            exception = error
-        else:
-            error_ = error
-            exception = None
-
-        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:
-        return core_schema.no_info_after_validator_function(
-            cls._validate,
-            core_schema.any_schema(),
-            serialization=core_schema.plain_serializer_function_ser_schema(lambda x: x.to_dict()),
-        )
-
-    @classmethod
-    def _validate(cls, value: object) -> Result[Any]:
-        if isinstance(value, cls):
-            return value
-        if isinstance(value, dict):
-            return cls._create(
-                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/str.py

@@ -1,105 +0,0 @@
-import re
-from collections.abc import Iterable
-from decimal import Decimal
-
-import pydash
-
-
-def str_to_list(
-    data: str | Iterable[object] | None,
-    lower: bool = False,
-    remove_comments: bool = False,
-    unique: bool = False,
-    split_line: bool = False,
-) -> list[str]:
-    match data:
-        case None | "" | []:
-            return []
-        case str():
-            if lower:
-                data = data.lower()
-            result = [line.strip() for line in data.split("\n") if line.strip()]
-            if remove_comments:
-                result = [line.split("#")[0].strip() for line in result]
-                result = [line for line in result if line]
-            if unique:
-                result = pydash.uniq(result)
-
-            if split_line:
-                new_result = []
-                for line in result:
-                    new_result.extend(line.split())
-                return new_result
-
-            return result
-        case Iterable():
-            return [str(x) for x in data]
-        case _:
-            raise ValueError("data has a wrong type")
-
-
-def number_with_separator(
-    value: float | str | Decimal | None,
-    prefix: str = "",
-    suffix: str = "",
-    separator: str = "_",
-    hide_zero: bool = False,
-    round_digits: int = 2,
-) -> str:
-    if value is None or value == "":
-        return ""
-    if float(value) == 0:
-        return "" if hide_zero else f"{prefix}0{suffix}"
-    if float(value) > 1000:
-        value = "".join(
-            reversed([x + (separator if i and not i % 3 else "") for i, x in enumerate(reversed(str(int(value))))]),
-        )
-    else:
-        value = round(value, round_digits)  # type:ignore[arg-type,assignment]
-
-    return f"{prefix}{value}{suffix}"
-
-
-def str_starts_with_any(value: str, prefixes: list[str]) -> bool:
-    """check if str starts with any of prefixes"""
-    return any(value.startswith(prefix) for prefix in prefixes)
-
-
-def str_ends_with_any(value: str, prefixes: list[str]) -> bool:
-    """check if str ends with any of prefixes"""
-    return any(value.endswith(prefix) for prefix in prefixes)
-
-
-def str_contains_any(value: str, substrings: list[str]) -> bool:
-    """Check if str contains any of the given substrings"""
-    return any(substring in value for substring in substrings)
-
-
-def split_on_plus_minus_tokens(value: str) -> list[str]:
-    value = "".join(value.split())
-    if not value:
-        raise ValueError("value is empty")
-    if "++" in value:
-        raise ValueError("++ in value")
-    if "--" in value:
-        raise ValueError("-- in value")
-    if value.endswith("-"):
-        raise ValueError("ends with -")
-    if value.endswith("+"):
-        raise ValueError("ends with +")
-
-    if not value.startswith("+") and not value.startswith("-"):
-        value = "+" + value
-
-    result: list[str] = []
-    rest_value = value
-    while True:
-        if not rest_value:
-            return result
-        items = re.split(r"[+\-]", rest_value)
-        if rest_value.startswith("+"):
-            result.append("+" + items[1])
-            rest_value = rest_value.removeprefix("+" + items[1])
-        elif rest_value.startswith("-"):
-            result.append("-" + items[1])
-            rest_value = rest_value.removeprefix("-" + items[1])

mm_std/toml.py

@@ -1,22 +0,0 @@
-from collections.abc import Mapping
-from decimal import Decimal
-
-import tomlkit
-from tomlkit.items import Float, Trivia
-
-
-def encode_decimal(value: object) -> Float:
-    if isinstance(value, Decimal):
-        return Float(value=float(value), trivia=Trivia(), raw=str(value))
-    raise TypeError(f"Cannot convert {type(value)} to TOML item")
-
-
-tomlkit.register_encoder(encode_decimal)
-
-
-def toml_dumps(data: Mapping[str, object], sort_keys: bool = False) -> str:
-    return tomlkit.dumps(data, sort_keys=sort_keys)
-
-
-def toml_loads(string: str | bytes) -> tomlkit.TOMLDocument:
-    return tomlkit.loads(string)

mm_std/types_.py

@@ -1,8 +0,0 @@
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-type CallableAny = Callable[..., Any]
-type Func = Callable[..., object]
-type AsyncFunc = Callable[..., Awaitable[object]]
-type Args = tuple[object, ...]
-type Kwargs = dict[str, object]

mm_std/zip.py

@@ -1,9 +0,0 @@
-from pathlib import Path
-from zipfile import ZipFile
-
-
-def read_text_from_zip_archive(zip_archive_path: Path, filename: str | None = None, password: str | None = None) -> str:
-    with ZipFile(zip_archive_path) as zipfile:
-        if filename is None:
-            filename = zipfile.filelist[0].filename
-        return zipfile.read(filename, pwd=password.encode() if password else None).decode()

mm_std-0.4.17.dist-info/METADATA

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: mm-std
-Version: 0.4.17
-Requires-Python: >=3.12
-Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: aiohttp~=3.12.2
-Requires-Dist: cryptography~=45.0.3
-Requires-Dist: pydantic-settings>=2.9.1
-Requires-Dist: pydantic~=2.11.5
-Requires-Dist: pydash~=8.0.5
-Requires-Dist: python-dotenv~=1.1.0
-Requires-Dist: requests[socks]~=2.32.3
-Requires-Dist: rich>=13.9.0
-Requires-Dist: tomlkit~=0.13.2

mm_std-0.4.17.dist-info/RECORD

@@ -1,35 +0,0 @@
-mm_std/__init__.py,sha256=OpZAZw3BG3wyDnlRR3p2BZO2cZcE-imScPCf2qRWuUk,3189
-mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
-mm_std/config.py,sha256=3-FxFCtOffY2t9vuu9adojwbzTPwdAH2P6qDaZnHLbY,3206
-mm_std/date.py,sha256=976eEkSONuNqHQBgSRu8hrtH23tJqztbmHFHLdbP2TY,1879
-mm_std/dict.py,sha256=DxFbZnl5KK4vJ4wLH_pCT0PWzfaIL3YyLNpRsVexfjw,1465
-mm_std/env.py,sha256=5zaR9VeIfObN-4yfgxoFeU5IM1GDeZZj9SuYf7t9sOA,125
-mm_std/fs.py,sha256=RwarNRJq3tIMG6LVX_g03hasfYpjYFh_O27oVDt5IPQ,291
-mm_std/json_.py,sha256=YVvROb5egcF1aQ2fXzyWG8Yw0JvYwpNBwtcBzsOADPo,1133
-mm_std/log.py,sha256=0TkTsAlUTt00gjgukvsvnZRIAGELq0MI6Lv8mKP-Wz4,2887
-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=ltq9lJ-mZYRWuwGfhVtsfb4CX9Gw-tOUKyj5cEoyHiE,10706
-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
-mm_std/zip.py,sha256=axzF1BwcIygtfNNTefZH7hXKaQqwe-ZH3ChuRWr9dnk,396
-mm_std/concurrency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/concurrency/async_decorators.py,sha256=xEpyipzp3ZhaPHtdeTE-Ikrt67SUTFKBE6LQPeoeh6Q,1735
-mm_std/concurrency/async_scheduler.py,sha256=TSu2WDJ8vfKZ4-saM3iZdcpGz8yPpSmud-7jJ4XKdJs,5579
-mm_std/concurrency/async_task_runner.py,sha256=EN7tN2enkVYVgDbhSiAr-_W4o9m9wBXCveXGT8aVXII,4994
-mm_std/concurrency/sync_decorators.py,sha256=syCQBOmN7qPO55yzgJB2rbkh10CVww376hmyvs6e5tA,1080
-mm_std/concurrency/sync_scheduler.py,sha256=j4tBL_cBI1spr0cZplTA7N2CoYsznuORMeRN8rpR6gY,2407
-mm_std/concurrency/sync_task_runner.py,sha256=s5JPlLYLGQGHIxy4oDS-PN7O9gcy-yPZFoNm8RQwzcw,1780
-mm_std/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/crypto/fernet.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
-mm_std/crypto/openssl.py,sha256=x8LTRG6-jXLucMcsWS746V7B5fGrJ1c27d08rNK5-Ng,8173
-mm_std/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/http/http_request.py,sha256=6bg3t49c3dG0jKRFxhcceeYb5yKrMoZwuyb25zBG3tY,4088
-mm_std/http/http_request_sync.py,sha256=zXLeDplYWTFIwaD1Ydyg9yTi37WcI-fReLM0mVnuvhM,1835
-mm_std/http/http_response.py,sha256=7ZllZFPKJ9s6m-18Dfhrm7hwc2XFnyX7ppt0O8gNmlE,3916
-mm_std-0.4.17.dist-info/METADATA,sha256=0rG7NElzy9ZOLdx3hnag32xev6avidgXTZe46h85waU,414
-mm_std-0.4.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.4.17.dist-info/RECORD,,