mm-std 0.3.30__py3-none-any.whl → 0.4.0__py3-none-any.whl

mm_std/__init__.py

@@ -13,7 +13,6 @@ from .config import BaseConfig as BaseConfig
 from .crypto import fernet_decrypt as fernet_decrypt
 from .crypto import fernet_encrypt as fernet_encrypt
 from .crypto import fernet_generate_key as fernet_generate_key
-from .data_result import DataResult as DataResult
 from .date import parse_date as parse_date
 from .date import utc_delta as utc_delta
 from .date import utc_now as utc_now
@@ -21,16 +20,9 @@ from .date import utc_random as utc_random
 from .dict import replace_empty_dict_values as replace_empty_dict_values
 from .env import get_dotenv as get_dotenv
 from .http.http_request import http_request as http_request
+from .http.http_request_sync import http_request_sync as http_request_sync
 from .http.response import HttpError as HttpError
 from .http.response import HttpResponse as HttpResponse
-from .http_ import CHROME_USER_AGENT as CHROME_USER_AGENT
-from .http_ import FIREFOX_USER_AGENT as FIREFOX_USER_AGENT
-from .http_ import HResponse as HResponse
-from .http_ import add_query_params_to_url as add_query_params_to_url
-from .http_ import hr as hr
-from .http_ import hra as hra
-from .http_ import hrequest as hrequest
-from .http_ import hrequest_async as hrequest_async
 from .json_ import CustomJSONEncoder as CustomJSONEncoder
 from .json_ import json_dumps as json_dumps
 from .log import configure_logging as configure_logging
@@ -47,12 +39,7 @@ from .print_ import print_table as print_table
 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 Err as Err
-from .result import Ok as Ok
 from .result import Result as Result
-from .result import err as err
-from .result import ok as ok
-from .result import try_ok as try_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

@@ -6,7 +6,7 @@ from typing import NoReturn, Self
 from pydantic import BaseModel, ConfigDict, ValidationError
 
 from .print_ import print_json, print_plain
-from .result import Err, Ok, Result
+from .result import Result
 from .zip import read_text_from_zip_archive
 
 
@@ -19,18 +19,18 @@ class BaseConfig(BaseModel):
 
     @classmethod
     def read_toml_config_or_exit[T](cls: type[T], config_path: Path, zip_password: str = "") -> T:  # noqa: PYI019 # nosec
-        res = cls.read_toml_config(config_path, zip_password)  # type: ignore[attr-defined]
-        if isinstance(res, Ok):
-            return res.unwrap()  # type: ignore[no-any-return]
+        res: Result[T] = cls.read_toml_config(config_path, zip_password)  # type:ignore[attr-defined]
+        if res.is_ok():
+            return res.unwrap()
 
-        if res.err == "validator_error":
+        if res.error == "validator_error" and res.extra:
             print_plain("config validation errors")
-            for e in res.data["errors"]:
+            for e in res.extra["errors"]:
                 loc = e["loc"]
                 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.err}")
+            print_plain(f"can't parse config file: {res.error}")
 
         sys.exit(1)
 
@@ -43,8 +43,8 @@ class BaseConfig(BaseModel):
             else:
                 with config_path.open("rb") as f:
                     data = tomllib.load(f)
-            return Ok(cls(**data))
-        except ValidationError as err:
-            return Err("validator_error", data={"errors": err.errors()})
-        except Exception as err:
-            return Err(err)
+            return Result.success(cls(**data))
+        except ValidationError as e:
+            return Result.failure_with_exception(e, error="validator_error", extra={"errors": e.errors()})
+        except Exception as e:
+            return Result.failure_with_exception(e)

mm_std/http/http_request_sync.py

@@ -0,0 +1,58 @@
+from typing import Any
+
+import requests
+
+from mm_std.http.response import HttpError, HttpResponse
+
+
+def http_request_sync(
+    url: str,
+    *,
+    method: str = "GET",
+    params: dict[str, Any] | None = None,
+    data: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
+    cookies: dict[str, Any] | None = None,
+    user_agent: str | None = None,
+    proxy: str | None = None,
+    timeout: float | None = 10.0,
+) -> HttpResponse:
+    """
+    Send a synchronous HTTP request and return the response.
+    """
+    if user_agent:
+        if headers is None:
+            headers = {}
+        headers["User-Agent"] = user_agent
+
+    proxies: dict[str, str] | None = None
+    if proxy:
+        proxies = {
+            "http": proxy,
+            "https": proxy,
+        }
+
+    try:
+        res = requests.request(
+            method=method,
+            url=url,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            proxies=proxies,
+        )
+        return HttpResponse(
+            status_code=res.status_code,
+            error=None,
+            error_message=None,
+            body=res.text,
+            headers=dict(res.headers),
+        )
+    except requests.Timeout as err:
+        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(err))
+    except Exception as err:
+        return HttpResponse(error=HttpError.ERROR, error_message=str(err))

mm_std/http/response.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import enum
 import json
 from typing import Any
 
 import pydash
-from pydantic import BaseModel
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
 
-from mm_std.data_result import DataResult
+from mm_std.result import Result
 
 
 @enum.unique
@@ -16,12 +19,26 @@ class HttpError(str, enum.Enum):
     ERROR = "error"
 
 
-class HttpResponse(BaseModel):
-    status_code: int | None = None
-    error: HttpError | None = None
-    error_message: str | None = None
-    body: str | None = None
-    headers: dict[str, str] | None = None
+class HttpResponse:
+    status_code: int | None
+    error: HttpError | None
+    error_message: str | None
+    body: str | None
+    headers: dict[str, str] | None
+
+    def __init__(
+        self,
+        status_code: int | None = None,
+        error: HttpError | None = None,
+        error_message: str | None = None,
+        body: str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        self.status_code = status_code
+        self.error = error
+        self.error_message = error_message
+        self.body = body
+        self.headers = headers
 
     def parse_json_body(self, path: str | None = None, none_on_error: bool = False) -> Any:  # noqa: ANN401
         if self.body is None:
@@ -40,8 +57,53 @@ class HttpResponse(BaseModel):
     def is_error(self) -> bool:
         return self.error is not None or (self.status_code is not None and self.status_code >= 400)
 
-    def to_data_result_err[T](self, error: str | None = None) -> DataResult[T]:
-        return DataResult.err(error or self.error or "error", self.model_dump())
+    def to_result_err[T](self, error: str | None = None) -> Result[T]:
+        return Result.failure(error or self.error or "error", extra=self.to_dict())
+
+    def to_result_ok[T](self, result: T) -> Result[T]:
+        return Result.success(result, extra=self.to_dict())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "status_code": self.status_code,
+            "error": self.error.value if self.error else None,
+            "error_message": self.error_message,
+            "body": self.body,
+            "headers": self.headers,
+        }
+
+    def __repr__(self) -> str:
+        parts: list[str] = []
+        if self.status_code is not None:
+            parts.append(f"status_code={self.status_code!r}")
+        if self.error is not None:
+            parts.append(f"error={self.error!r}")
+        if self.error_message is not None:
+            parts.append(f"error_message={self.error_message!r}")
+        if self.body is not None:
+            parts.append(f"body={self.body!r}")
+        if self.headers is not None:
+            parts.append(f"headers={self.headers!r}")
+        return f"HttpResponse({', '.join(parts)})"
+
+    @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()),
+        )
 
-    def to_data_result_ok[T](self, result: T) -> DataResult[T]:
-        return DataResult.ok(result, self.model_dump())
+    @classmethod
+    def _validate(cls, value: object) -> HttpResponse:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, dict):
+            return cls(
+                status_code=value.get("status_code"),
+                error=HttpError(value["error"]) if value.get("error") else None,
+                error_message=value.get("error_message"),
+                body=value.get("body"),
+                headers=value.get("headers"),
+            )
+        raise TypeError(f"Invalid value for HttpResponse: {value}")

mm_std/json_.py

@@ -9,15 +9,13 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
-from mm_std.result import Err, Ok
+from mm_std.result import Result
 
 
 class CustomJSONEncoder(JSONEncoder):
     def default(self, o: object) -> object:
-        if isinstance(o, Ok):
-            return {"ok": o.ok}
-        if isinstance(o, Err):
-            return {"err": o.err}
+        if isinstance(o, Result):
+            return o.to_dict()
         if isinstance(o, Decimal):
             return str(o)
         if isinstance(o, Path):

mm_std/result.py

@@ -1,281 +1,197 @@
 from __future__ import annotations
 
-import time
-from collections.abc import Callable
-from typing import Any, ClassVar, Literal, NoReturn, TypeGuard, TypeVar, Union
+from collections.abc import Awaitable, Callable
+from typing import Any, TypeVar, cast
 
-from pydantic_core import core_schema
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
 
+T = TypeVar("T")
+U = TypeVar("U")
 
-class Ok[T]:
-    model_config: ClassVar[dict[str, object]] = {"arbitrary_types_allowed": True}
-    __match_args__ = ("ok",)
-
-    def __init__(self, ok: T, data: object = None) -> None:
-        self.ok = ok
-        self.data = data
-
-    def __repr__(self) -> str:
-        if self.data is None:
-            return f"Ok({self.ok!r})"
-        return f"Ok({self.ok!r}, data={self.data!r})"
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, Ok) and self.ok == other.ok and self.data == other.data
-
-    def __ne__(self, other: object) -> bool:
-        return not (self == other)
-
-    def __hash__(self) -> int:
-        return hash((True, self.ok, self.data))
-
-    def is_ok(self) -> Literal[True]:
-        return True
-
-    def is_err(self) -> Literal[False]:
-        return False
-
-    @property
-    def err(self) -> None:
-        return None
-
-    def expect(self, _message: str) -> T:
-        return self.ok
-
-    def expect_err(self, message: str) -> NoReturn:
-        raise UnwrapError(self, message)
-
-    def unwrap(self) -> T:
-        return self.ok
-
-    def unwrap_err(self) -> NoReturn:
-        raise UnwrapError(self, "Called `Result.unwrap_err()` on an `Ok` value")
-
-    def unwrap_or[U](self, _default: U) -> T:
-        return self.ok
+type Extra = dict[str, Any] | None
 
-    def unwrap_or_else(self, _op: object) -> T:
-        return self.ok
 
-    def unwrap_or_raise(self, _e: object) -> T:
-        return self.ok
+class Result[T]:
+    """
+    A container representing either a successful result or an error.
+    Use `Result.success()` or `Result.failure()` to create instances.
+    """
 
-    def map[U](self, op: Callable[[T], U]) -> Ok[U]:
-        return Ok(op(self.ok), data=self.data)
+    ok: 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 map_or[U](self, _default: object, op: Callable[[T], U]) -> U:
-        return op(self.ok)
+    def __init__(self) -> None:
+        raise RuntimeError("Result is not intended to be instantiated directly. Use the static methods instead.")
 
-    def map_or_else[U](self, _err_op: object, ok_op: Callable[[T], U]) -> U:
+    def is_ok(self) -> bool:
         """
-        The contained result is `Ok`, so return original value mapped to
-        a new value using the passed in `op` function.
+        Returns True if the result represents success.
         """
-        return ok_op(self.ok)
+        return self.error is None
 
-    def map_err(self, _op: object) -> Ok[T]:
+    def is_error(self) -> bool:
         """
-        The contained result is `Ok`, so return `Ok` with the original value
+        Returns True if the result represents an error.
         """
-        return self
+        return self.error is not None
 
-    def and_then[U](self, op: Callable[[T], U | Result[U]]) -> Result[U]:
+    def is_exception(self) -> bool:
         """
-        The contained result is `Ok`, so return the result of `op` with the
-        original value passed in. If return of `op` function is not Result, it will be a Ok value.
+        Returns True if an exception is attached to the result.
         """
-        try:
-            res = op(self.ok)
-            if not isinstance(res, Ok | Err):
-                res = Ok(res)
-        except Exception as e:
-            res = Err(e)
-        res.data = self.data
-        return res
-
-    def or_else(self, _op: object) -> Ok[T]:
-        return self
-
-    def ok_or_err(self) -> T | str:
-        return self.ok
+        return self.exception is not None
 
-    def ok_or_none(self) -> T | None:
-        return self.ok
-
-    @classmethod
-    def __get_pydantic_core_schema__(cls, _source_type: object, _handler: object) -> 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:
-    model_config: ClassVar[dict[str, object]] = {"arbitrary_types_allowed": True}
-    __match_args__ = ("err",)
-
-    def __init__(self, err: str | Exception, data: object = None) -> None:
-        self.err = f"exception: {err}" if isinstance(err, Exception) else err
-        self.data = data
+    def unwrap(self) -> T:
+        """
+        Returns the success value.
+        Raises RuntimeError if the result is an error.
+        """
+        if not self.is_ok():
+            raise RuntimeError(f"Called unwrap() on a failure value: {self.error}")
+        return cast(T, self.ok)
+
+    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.ok)
+
+    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_error() 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 to_dict(self) -> dict[str, object]:
+        """
+        Returns a dictionary representation of the result.
+        Note: the exception is converted to a string if present.
+        """
+        return {
+            "ok": self.ok,
+            "error": self.error,
+            "exception": str(self.exception) if self.exception else None,
+            "extra": 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)
+            except Exception as e:
+                return Result.failure_with_exception(e, error="map_exception", 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)
+            except Exception as e:
+                return Result.failure_with_exception(e, error="map_exception", 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))
+            except Exception as e:
+                return Result.failure_with_exception(e, error="and_then_exception", 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))
+            except Exception as e:
+                return Result.failure_with_exception(e, error="and_then_exception", extra=self.extra)
+        return cast(Result[U], self)
 
     def __repr__(self) -> str:
-        if self.data is None:
-            return f"Err({self.err!r})"
-        return f"Err({self.err!r}, data={self.data!r})"
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, Err) and self.err == other.err and self.data == other.data
-
-    def __ne__(self, other: object) -> bool:
-        return not (self == other)
+        parts: list[str] = []
+        if self.ok is not None:
+            parts.append(f"ok={self.ok!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((False, self.err, self.data))
-
-    def is_ok(self) -> Literal[False]:
-        return False
-
-    def is_err(self) -> Literal[True]:
-        return True
-
-    @property
-    def ok(self) -> None:
-        """
-        Return `None`.
-        """
-        return None
-
-    def expect(self, message: str) -> NoReturn:
-        """
-        Raises an `UnwrapError`.
-        """
-        exc = UnwrapError(self, f"{message}: {self.err!r}")
-        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.err
-
-    def unwrap(self) -> NoReturn:
-        """
-        Raises an `UnwrapError`.
-        """
-        exc = UnwrapError(self, f"Called `Result.unwrap()` on an `Err` value: {self.err!r}")
-        if isinstance(self.err, BaseException):
-            raise exc from self.err
-        raise exc
-
-    def unwrap_err(self) -> str:
-        """
-        Return the inner value
-        """
-        return self.err
-
-    def unwrap_or[U](self, default: U) -> U:
-        """
-        Return `default`.
-        """
-        return default
-
-    def unwrap_or_else[T](self, op: Callable[[str], T]) -> T:
-        """
-        The contained result is ``Err``, so return the result of applying
-        ``op`` to the error value.
-        """
-        return op(self.err)
-
-    def unwrap_or_raise[TBE: BaseException](self, e: type[TBE]) -> NoReturn:
-        """
-        The contained result is ``Err``, so raise the exception with the value.
-        """
-        raise e(self.err)
-
-    def map(self, _op: object) -> Err:
-        """
-        Return `Err` with the same value
-        """
-        return self
-
-    def map_or[U](self, default: U, _op: object) -> U:
-        """
-        Return the default value
-        """
-        return default
-
-    def map_or_else[U](self, err_op: Callable[[str], U], _ok_op: object) -> U:
-        """
-        Return the result of the default operation
-        """
-        return err_op(self.err)
-
-    def and_then(self, _op: object) -> Err:
-        """
-        The contained result is `Err`, so return `Err` with the original value
-        """
-        return self
+        return hash(
+            (
+                self.ok,
+                self.error,
+                self.exception,
+                frozenset(self.extra.items()) if self.extra else None,
+            )
+        )
 
-    def ok_or_err[T](self) -> T | str:
-        return self.err
+    def __eq__(self, other: object) -> bool:
+        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
+        )
 
-    def ok_or_none[T](self) -> T | None:
-        return None
+    @classmethod
+    def _create(cls, ok: T | None, error: str | None, exception: Exception | None, extra: Extra) -> Result[T]:
+        obj = object.__new__(cls)
+        obj.ok = ok
+        obj.error = error
+        obj.exception = exception
+        obj.extra = extra
+        return obj
+
+    @staticmethod
+    def success(ok: T, extra: Extra = None) -> Result[T]:
+        return Result._create(ok=ok, error=None, exception=None, extra=extra)
+
+    @staticmethod
+    def failure(error: str, extra: Extra = None) -> Result[T]:
+        return Result._create(ok=None, error=error, exception=None, extra=extra)
+
+    @staticmethod
+    def failure_with_exception(exception: Exception, *, error: str = "exception", extra: Extra = None) -> Result[T]:
+        return Result._create(ok=None, error=error, exception=exception, extra=extra)
 
     @classmethod
-    def __get_pydantic_core_schema__(cls, _source_type: object, _handler: object) -> 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()),
-                },
-            ),
+    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()),
         )
 
-
-T = TypeVar("T")
-Result = Union[Ok[T], Err]  # noqa: UP007
-
-
-class UnwrapError(Exception):
-    _result: Result[Any]
-
-    def __init__(self, result: Result[Any], message: str) -> None:
-        self._result = result
-        super().__init__(message)
-
-    @property
-    def result(self) -> Result[Any]:
-        return self._result
-
-
-def ok(result: Result[T]) -> TypeGuard[Ok[T]]:
-    """Used for type narrowing from `Result` to `Ok`."""
-    return isinstance(result, Ok)
-
-
-def err(result: Result[T]) -> TypeGuard[Err]:
-    """Used for type narrowing from `Result` to `Err`."""
-    return isinstance(result, Err)
-
-
-def try_ok[T](fn: Callable[..., Result[T]], *, args: tuple[object], attempts: int, delay: float = 0) -> Result[T]:
-    if attempts <= 0:
-        raise ValueError("attempts must be more than zero")
-    res: Result[T] = Err("not started")
-    for _ in range(attempts):
-        res = fn(*args)
-        if res.is_ok():
-            return res
-        if delay:
-            time.sleep(delay)
-    return res
+    @classmethod
+    def _validate(cls, value: object) -> Result[Any]:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, dict):
+            return cls._create(
+                ok=value.get("ok"),
+                error=value.get("error"),
+                exception=value.get("exception"),
+                extra=value.get("extra"),
+            )
+        raise TypeError(f"Invalid value for Result: {value}")

{mm_std-0.3.30.dist-info → mm_std-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.30
+Version: 0.4.0
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
 Requires-Dist: aiohttp~=3.11.16

{mm_std-0.3.30.dist-info → mm_std-0.4.0.dist-info}/RECORD

@@ -1,20 +1,18 @@
-mm_std/__init__.py,sha256=ePkjykjImp2Wu10lFzK3Fl1HpGqqXFb_HZK_BSiU3MM,3316
+mm_std/__init__.py,sha256=Kl-7TT_hd-xmwDJJ0E5AO2Qjpj5H8H7A93DgDwv_r-0,2804
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
-mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
+mm_std/config.py,sha256=VCrvTIjq21uDJngPANVClq5CO9xjmeDJCjRlZgn-fBs,1918
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
-mm_std/data_result.py,sha256=aUDhnxp5EagYFkCiOGKYReQshDrK_3zXfGYla5mJ8Yk,8739
 mm_std/date.py,sha256=976eEkSONuNqHQBgSRu8hrtH23tJqztbmHFHLdbP2TY,1879
 mm_std/dict.py,sha256=6GkhJPXD0LiJDxPcYe6jPdEDw-MN7P7mKu6U5XxwYDk,675
 mm_std/env.py,sha256=5zaR9VeIfObN-4yfgxoFeU5IM1GDeZZj9SuYf7t9sOA,125
 mm_std/fs.py,sha256=RwarNRJq3tIMG6LVX_g03hasfYpjYFh_O27oVDt5IPQ,291
-mm_std/http_.py,sha256=5_V5Hx1M07xwzf0VVqAsxSFJkvtaAhj9_sFQP_HliQw,8215
-mm_std/json_.py,sha256=Naa6mBE4D0yiQGkPNRrFvndnUH3R7ovw3FeaejWV60o,1196
+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=2cLa0Lb1W7IY1Kxn-r-9GyqDz3colabp00dcvr7AKbU,7917
+mm_std/result.py,sha256=gUmseH3fkapLIcTDkaeilPkubO5nHXWUCc5PmWh3EiY,6874
 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
@@ -28,7 +26,8 @@ mm_std/concurrency/sync_scheduler.py,sha256=j4tBL_cBI1spr0cZplTA7N2CoYsznuORMeRN
 mm_std/concurrency/sync_task_runner.py,sha256=s5JPlLYLGQGHIxy4oDS-PN7O9gcy-yPZFoNm8RQwzcw,1780
 mm_std/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_std/http/http_request.py,sha256=h74_ZjACwdbeINjzhuEwNUpvnaHZvyGl7TExjlBwMGg,3704
-mm_std/http/response.py,sha256=WNQWd1HC134WvjEOSvikHCmujbsvs2332VzUPp9DnyM,1377
-mm_std-0.3.30.dist-info/METADATA,sha256=wv2Gs6_yVnt-f58T01_Dt6-cP8btIij1MFm91G04xYM,447
-mm_std-0.3.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.30.dist-info/RECORD,,
+mm_std/http/http_request_sync.py,sha256=aawVZfopzMI0alS3lkJQmVOVxH51rmtvsOK_inUlJOs,1537
+mm_std/http/response.py,sha256=A5PXdFaP1YWygrt42WICTBLXLhShu37OkJmkfaIXtZQ,3621
+mm_std-0.4.0.dist-info/METADATA,sha256=o6yleMNzi58oJWMULKE2CmnOT3qOccxfg7Lm58uoEeY,446
+mm_std-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.4.0.dist-info/RECORD,,

mm_std/data_result.py

@@ -1,249 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from typing import Any, Generic, TypeVar, cast
-
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-
-T = TypeVar("T")
-U = TypeVar("U")
-
-
-type Data = dict[str, object] | None
-
-
-class DataResult(Generic[T]):
-    """
-    A result wrapper that encapsulates either a successful result (`ok`) or an error message (`err`).
-    Optionally carries `data` field regardless of success or failure.
-    """
-
-    _ok: T | None
-    _err: str | None
-    data: Data | None
-
-    def __init__(self) -> None:
-        raise RuntimeError("DataResult is not intended to be instantiated directly. Use the static methods instead.")
-
-    def is_ok(self) -> bool:
-        """
-        Returns True if the result represents a success.
-        """
-        return self._err is None
-
-    def is_err(self) -> bool:
-        """
-        Returns True if the result represents an error.
-        """
-        return self._err is not None
-
-    def unwrap(self) -> T:
-        """
-        Returns the successful value or raises an exception if this is an error result.
-        """
-        if self.is_err():
-            raise RuntimeError(f"Called `unwrap()` on an `Err` value: {self.err!r}")
-        return cast(T, self._ok)
-
-    def unwrap_ok_or(self, default: T) -> T:
-        """
-        Returns the contained success value if this is a success result,
-        or returns the provided default value if this is an error result.
-
-        Args:
-            default: The value to return if this is an error result.
-
-        Returns:
-            The success value or the default value.
-        """
-        if self.is_ok():
-            return cast(T, self._ok)
-        return default
-
-    def unwrap_err(self) -> str:
-        """
-        Returns the error message or raises an exception if this is a success result.
-        """
-        if self.is_ok():
-            raise RuntimeError(f"Called `unwrap_err()` on an `Ok` value: {self.ok!r}")
-        return cast(str, self._err)
-
-    def dict(self) -> dict[str, object]:
-        """
-        Returns a dictionary representation of the result.
-        """
-        return {"ok": self._ok, "err": self._err, "data": self.data}
-
-    def map(self, fn: Callable[[T], U]) -> DataResult[U]:
-        """
-        Transforms the success value using the provided function if this is a success result.
-        If this is an error result, returns a new error result with the same error message.
-        If the function raises an exception, returns a new error result with the exception message.
-
-        Args:
-            fn: A function that transforms the success value from type T to type U.
-
-        Returns:
-            A new DataResult with the transformed success value or an error.
-        """
-        if self.is_err():
-            return DataResult[U].err(self.unwrap_err(), self.data)
-
-        try:
-            mapped_ok = fn(self.unwrap())
-            return DataResult[U].ok(mapped_ok, self.data)
-        except Exception as e:
-            return DataResult[U].exception(e, data={"original_data": self.data, "original_ok": self.ok})
-
-    async def map_async(self, fn: Callable[[T], Awaitable[U]]) -> DataResult[U]:
-        """
-        Asynchronously transforms the success value using the provided async function if this is a success result.
-        If this is an error result, returns a new error result with the same error message.
-        If the function raises an exception, returns a new error result with the exception message.
-
-        Args:
-            fn: An async function that transforms the success value from type T to type U.
-
-        Returns:
-            A new DataResult with the transformed success value or an error.
-        """
-        if self.is_err():
-            return DataResult[U].err(self.unwrap_err(), self.data)
-
-        try:
-            mapped_ok = await fn(self.unwrap())
-            return DataResult[U].ok(mapped_ok, self.data)
-        except Exception as e:
-            return DataResult[U].exception(e, data={"original_data": self.data, "original_ok": self.ok})
-
-    def and_then(self, fn: Callable[[T], DataResult[U]]) -> DataResult[U]:
-        """
-        Applies the function to the success value if this is a success result.
-        If this is an error result, returns a new error result with the same error message.
-
-        Unlike map, the function must return a DataResult.
-
-        Args:
-            fn: A function that takes the success value and returns a new DataResult.
-
-        Returns:
-            The result of the function application or the original error.
-        """
-        if self.is_err():
-            return DataResult[U].err(self.unwrap_err(), self.data)
-
-        try:
-            return fn(self.unwrap())
-        except Exception as e:
-            return DataResult[U].exception(e, data={"original_data": self.data, "original_ok": self.ok})
-
-    async def and_then_async(self, fn: Callable[[T], Awaitable[DataResult[U]]]) -> DataResult[U]:
-        """
-        Asynchronously applies the function to the success value if this is a success result.
-        If this is an error result, returns a new error result with the same error message.
-
-        Unlike map_async, the function must return a DataResult.
-
-        Args:
-            fn: An async function that takes the success value and returns a new DataResult.
-
-        Returns:
-            The result of the function application or the original error.
-        """
-        if self.is_err():
-            return DataResult[U].err(self.unwrap_err(), self.data)
-
-        try:
-            return await fn(self.unwrap())
-        except Exception as e:
-            return DataResult[U].exception(e, {"original_data": self.data, "original_ok": self.ok})
-
-    def __repr__(self) -> str:
-        """
-        Returns the debug representation of the result.
-        """
-        result = f"DataResult(ok={self._ok!r}" if self.is_ok() else f"DataResult(err={self._err!r}"
-        if self.data is not None:
-            result += f", data={self.data!r}"
-        return result + ")"
-
-    def __hash__(self) -> int:
-        """
-        Enables hashing for use in sets and dict keys.
-        """
-        return hash((self.ok, self.err, self.data))
-
-    def __eq__(self, other: object) -> bool:
-        """
-        Compares two DataResult instances by value.
-        """
-        if not isinstance(other, DataResult):
-            return NotImplemented
-        return self._ok == other._ok and self._err == other._err and self.data == other.data
-
-    @classmethod
-    def __get_pydantic_core_schema__(cls, _source_type: type[Any], _handler: GetCoreSchemaHandler) -> CoreSchema:
-        """
-        Custom Pydantic v2 integration method for schema generation and validation.
-        """
-        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.dict()),
-        )
-
-    @classmethod
-    def _validate(cls, v: object) -> DataResult[T]:
-        """
-        Internal validation logic for Pydantic.
-        Accepts either an instance of DataResult or a dict-like input.
-        """
-        if isinstance(v, cls):
-            return v
-        if isinstance(v, dict):
-            return cls._create(
-                ok=v.get("ok"),
-                err=v.get("err"),
-                data=v.get("data"),
-            )
-        raise TypeError(f"Cannot parse value as {cls.__name__}: {v}")
-
-    @classmethod
-    def _create(cls, ok: T | None, err: str | None, data: Data) -> DataResult[T]:
-        """
-        Internal method to create a DataResult instance.
-        """
-        obj = object.__new__(cls)
-        obj._ok = ok  # noqa: SLF001
-        obj._err = err  # noqa: SLF001
-        obj.data = data
-        return obj
-
-    @staticmethod
-    def ok(value: T, data: Data = None) -> DataResult[T]:
-        """
-        Static method to create a successful DataResult.
-        """
-        return DataResult._create(ok=value, err=None, data=data)
-
-    @staticmethod
-    def err(error: str, data: Data = None) -> DataResult[T]:
-        """
-        Static method to create an error DataResult.
-        """
-        return DataResult._create(ok=None, err=error, data=data)
-
-    @staticmethod
-    def exception(err: Exception, data: Data = None) -> DataResult[T]:
-        """
-        Static method to create an error DataResult from an exception.
-        """
-        if data is None:
-            data = {}
-        key = "exception_message"
-        while key in data:
-            key += "_"
-        data[key] = str(err)
-
-        return DataResult._create(ok=None, err="exception", data=data)

mm_std/http_.py

@@ -1,257 +0,0 @@
-import json
-from dataclasses import asdict, dataclass, field
-from typing import Any, cast
-from urllib.parse import urlencode, urlparse
-
-import aiohttp
-import pydash
-import requests
-from aiohttp_socks import ProxyConnector
-from multidict import CIMultiDictProxy
-from requests.auth import AuthBase
-
-from mm_std.result import Err, Ok, Result
-
-FIREFOX_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:134.0) Gecko/20100101 Firefox/134.0"
-SAFARI_USER_AGENT = (
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15"
-)
-CHROME_USER_AGENT = (
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-)
-
-
-@dataclass
-class HResponse:
-    code: int = 0
-    error: str | None = None
-    body: str = ""
-    headers: dict[str, str] = field(default_factory=dict)
-
-    _json_data: Any = None
-    _json_parsed = False
-    _json_parsed_error = False
-
-    def _parse_json(self) -> None:
-        try:
-            self._json_data = None
-            self._json_data = json.loads(self.body)
-            self._json_parsed_error = False
-        except json.JSONDecodeError:
-            self._json_parsed_error = True
-        self._json_parsed = True
-
-    @property
-    def json(self) -> Any:  # noqa: ANN401
-        if not self._json_parsed:
-            self._parse_json()
-        return self._json_data
-
-    @property
-    def json_parse_error(self) -> bool:
-        if not self._json_parsed:
-            self._parse_json()
-        return self._json_parsed_error
-
-    @property
-    def content_type(self) -> str | None:
-        for key in self.headers:
-            if key.lower() == "content-type":
-                return self.headers[key]
-        return None
-
-    def to_err_result[T](self, error: str | None = None) -> Err:
-        return Err(error or self.error or "error", data=asdict(self))
-
-    def to_ok_result[T](self, result: T) -> Result[T]:
-        return Ok(result, data=asdict(self))
-
-    def is_error(self) -> bool:
-        return self.error is not None
-
-    def is_timeout_error(self) -> bool:
-        return self.error == "timeout"
-
-    def is_proxy_error(self) -> bool:
-        return self.error == "proxy"
-
-    def is_connection_error(self) -> bool:
-        return self.error is not None and self.error.startswith("connection:")
-
-    def is_dns_error(self) -> bool:
-        return self.error is not None and self.error.startswith("dns:")
-
-    def to_dict(self) -> dict[str, Any]:
-        return pydash.omit(asdict(self), "_json_data")
-
-
-def hrequest(
-    url: str,
-    *,
-    method: str = "GET",
-    proxy: str | None = None,
-    params: dict[str, Any] | None = None,
-    headers: dict[str, Any] | None = None,
-    cookies: dict[str, Any] | None = None,
-    timeout: float = 10,
-    user_agent: str | None = None,
-    json_params: bool = True,
-    auth: AuthBase | tuple[str, str] | None = None,
-    verify: bool = True,
-) -> HResponse:
-    query_params: dict[str, Any] | None = None
-    data: dict[str, Any] | None = None
-    json_: dict[str, Any] | None = None
-    method = method.upper()
-    if not headers:
-        headers = {}
-    if user_agent:
-        headers["user-agent"] = user_agent
-    if method == "GET":
-        query_params = params
-    elif json_params:
-        json_ = params
-    else:
-        data = params
-
-    proxies = None
-    if proxy:
-        proxies = {
-            "http": proxy,
-            "https": proxy,
-        }
-
-    try:
-        r = requests.request(
-            method,
-            url,
-            proxies=proxies,
-            timeout=timeout,
-            cookies=cookies,
-            auth=auth,
-            verify=verify,
-            headers=headers,
-            params=query_params,
-            json=json_,
-            data=data,
-        )
-        return HResponse(code=r.status_code, body=r.text, headers=dict(r.headers))
-    except requests.exceptions.Timeout:
-        return HResponse(error="timeout")
-    except requests.exceptions.ProxyError:
-        return HResponse(error="proxy")
-    except requests.exceptions.RequestException as err:
-        return HResponse(error=f"connection: {err}")
-    except Exception as err:
-        return HResponse(error=f"exception: {err}")
-
-
-async def hrequest_async(
-    url: str,
-    *,
-    method: str = "GET",
-    proxy: str | None = None,
-    params: dict[str, Any] | None = None,
-    headers: dict[str, Any] | None = None,
-    cookies: dict[str, Any] | None = None,
-    timeout: float = 10,
-    user_agent: str | None = None,
-    json_params: bool = True,
-    auth: tuple[str, str] | None = None,
-) -> HResponse:
-    query_params: dict[str, Any] | None = None
-    data: dict[str, Any] | None = None
-    json_: dict[str, Any] | None = None
-    method = method.upper()
-
-    if not headers:
-        headers = {}
-    if user_agent:
-        headers["user-agent"] = user_agent
-    if method == "GET":
-        query_params = params
-    elif json_params:
-        json_ = params
-    else:
-        data = params
-
-    try:
-        request_kwargs: dict[str, Any] = {"headers": headers}
-        if query_params:
-            request_kwargs["params"] = query_params
-        if json_:
-            request_kwargs["json"] = json_
-        if data:
-            request_kwargs["data"] = data
-        if cookies:
-            request_kwargs["cookies"] = cookies
-        if auth and isinstance(auth, tuple) and len(auth) == 2:
-            request_kwargs["auth"] = aiohttp.BasicAuth(auth[0], auth[1])
-
-        if proxy and proxy.startswith("socks"):
-            return await _aiohttp_socks5(url, method, proxy, request_kwargs, timeout)
-        return await _aiohttp(url, method, request_kwargs, timeout=timeout, proxy=proxy)
-
-    except TimeoutError:
-        return HResponse(error="timeout")
-    except (aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError, aiohttp.ClientConnectorError) as err:
-        if is_proxy_error(str(err), proxy):
-            return HResponse(error="proxy")
-        return HResponse(error=f"connection: {err}")
-    except aiohttp.ClientError as err:
-        return HResponse(error=f"error: {err}")
-    except Exception as err:
-        return HResponse(error=f"exception: {err}")
-
-
-def is_proxy_error(error_message: str, proxy: str | None) -> bool:
-    if not proxy:
-        return False
-    error_message = error_message.lower()
-    if "proxy" in error_message:
-        return True
-    return bool("cannot connect to" in error_message and cast(str, urlparse(proxy).hostname) in error_message)
-
-
-async def _aiohttp(
-    url: str, method: str, request_kwargs: dict[str, object], timeout: float | None = None, proxy: str | None = None
-) -> HResponse:
-    if proxy:
-        request_kwargs["proxy"] = proxy
-    client_timeout = aiohttp.ClientTimeout(total=timeout) if timeout else None
-    async with aiohttp.ClientSession(timeout=client_timeout) as session, session.request(method, url, **request_kwargs) as res:  # type: ignore[arg-type]
-        return HResponse(code=res.status, body=await res.text(), headers=headers_dict(res.headers))
-
-
-async def _aiohttp_socks5(
-    url: str, method: str, proxy: str, request_kwargs: dict[str, object], timeout: float | None = None
-) -> HResponse:
-    connector = ProxyConnector.from_url(proxy)
-    client_timeout = aiohttp.ClientTimeout(total=timeout) if timeout else None
-    async with (
-        aiohttp.ClientSession(connector=connector, timeout=client_timeout) as session,
-        session.request(method, url, **request_kwargs) as res,  # type: ignore[arg-type]
-    ):
-        return HResponse(code=res.status, body=await res.text(), headers=headers_dict(res.headers))
-
-
-def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
-    query_params = urlencode({k: v for k, v in params.items() if v is not None})
-    if query_params:
-        url += f"?{query_params}"
-    return url
-
-
-hr = hrequest
-hra = hrequest_async
-
-
-def headers_dict(headers: CIMultiDictProxy[str]) -> dict[str, str]:
-    result: dict[str, str] = {}
-    for key in headers:
-        values = headers.getall(key)
-        if len(values) == 1:
-            result[key] = values[0]
-        else:
-            result[key] = ", ".join(values)
-    return result