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

mm_std/data_result.py

@@ -10,41 +10,33 @@ 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 auxiliary `data` field regardless of success or failure.
+    Optionally carries `data` field regardless of success or failure.
     """
 
-    def __init__(
-        self,
-        ok: T | None = None,
-        err: str | None = None,
-        data: object = None,
-        ok_is_none: bool = False,  # Allow None as a valid success value
-    ) -> None:
-        # Sanity check: at least one of ok or err must be provided, unless explicitly allowed via `ok_is_none`
-        if ok is None and err is None and not ok_is_none:
-            raise ValueError("Either ok or err must be set")
-        # You can't set both ok and err unless ok_is_none is True (used to explicitly accept None as success)
-        if (ok_is_none or ok is not None) and err is not None:
-            raise ValueError("Cannot set both ok and err")
-
-        self.ok = ok
-        self.err = err
-        self.data = data
+    _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
+        return self._err is None
 
     def is_err(self) -> bool:
         """
         Returns True if the result represents an error.
         """
-        return self.err is not None
+        return self._err is not None
 
     def unwrap(self) -> T:
         """
@@ -52,7 +44,7 @@ class DataResult(Generic[T]):
         """
         if self.is_err():
             raise RuntimeError(f"Called `unwrap()` on an `Err` value: {self.err!r}")
-        return cast(T, self.ok)
+        return cast(T, self._ok)
 
     def unwrap_ok_or(self, default: T) -> T:
         """
@@ -66,7 +58,7 @@ class DataResult(Generic[T]):
             The success value or the default value.
         """
         if self.is_ok():
-            return cast(T, self.ok)
+            return cast(T, self._ok)
         return default
 
     def unwrap_err(self) -> str:
@@ -75,13 +67,13 @@ class DataResult(Generic[T]):
         """
         if self.is_ok():
             raise RuntimeError(f"Called `unwrap_err()` on an `Ok` value: {self.ok!r}")
-        return cast(str, self.err)
+        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}
+        return {"ok": self._ok, "err": self._err, "data": self.data}
 
     def map(self, fn: Callable[[T], U]) -> DataResult[U]:
         """
@@ -96,13 +88,13 @@ class DataResult(Generic[T]):
             A new DataResult with the transformed success value or an error.
         """
         if self.is_err():
-            return DataResult[U](err=self.err, data=self.data)
+            return DataResult[U].err(self.unwrap_err(), self.data)
 
         try:
             mapped_ok = fn(self.unwrap())
-            return DataResult[U](ok=mapped_ok, data=self.data)
+            return DataResult[U].ok(mapped_ok, self.data)
         except Exception as e:
-            return DataResult[U](err=f"Error in map: {e!s}", data={"original_data": self.data, "original_ok": self.ok})
+            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]:
         """
@@ -117,13 +109,13 @@ class DataResult(Generic[T]):
             A new DataResult with the transformed success value or an error.
         """
         if self.is_err():
-            return DataResult[U](err=self.err, data=self.data)
+            return DataResult[U].err(self.unwrap_err(), self.data)
 
         try:
             mapped_ok = await fn(self.unwrap())
-            return DataResult[U](ok=mapped_ok, data=self.data)
+            return DataResult[U].ok(mapped_ok, self.data)
         except Exception as e:
-            return DataResult[U](err=f"Error in map_async: {e!s}", data={"original_data": self.data, "original_ok": self.ok})
+            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]:
         """
@@ -139,12 +131,12 @@ class DataResult(Generic[T]):
             The result of the function application or the original error.
         """
         if self.is_err():
-            return DataResult[U](err=self.err, data=self.data)
+            return DataResult[U].err(self.unwrap_err(), self.data)
 
         try:
             return fn(self.unwrap())
         except Exception as e:
-            return DataResult[U](err=f"Error in and_then: {e!s}", data={"original_data": self.data, "original_ok": self.ok})
+            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]:
         """
@@ -160,18 +152,18 @@ class DataResult(Generic[T]):
             The result of the function application or the original error.
         """
         if self.is_err():
-            return DataResult[U](err=self.err, data=self.data)
+            return DataResult[U].err(self.unwrap_err(), self.data)
 
         try:
             return await fn(self.unwrap())
         except Exception as e:
-            return DataResult[U](err=f"Error in and_then_async: {e!s}", data={"original_data": self.data, "original_ok": self.ok})
+            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}"
+        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 + ")"
@@ -188,7 +180,7 @@ class DataResult(Generic[T]):
         """
         if not isinstance(other, DataResult):
             return NotImplemented
-        return self.ok == other.ok and self.err == other.err and self.data == other.data
+        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:
@@ -210,9 +202,48 @@ class DataResult(Generic[T]):
         if isinstance(v, cls):
             return v
         if isinstance(v, dict):
-            return cls(
+            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/http_request.py

@@ -74,7 +74,7 @@ async def _request_with_http_or_none_proxy(
         method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, proxy=proxy, timeout=timeout
     ) as res:
         return HttpResponse(
-            status=res.status,
+            status_code=res.status,
             error=None,
             error_message=None,
             body=(await res.read()).decode(),
@@ -102,7 +102,7 @@ async def _request_with_socks_proxy(
         ) as res,
     ):
         return HttpResponse(
-            status=res.status,
+            status_code=res.status,
             error=None,
             error_message=None,
             body=(await res.read()).decode(),

mm_std/http/response.py

@@ -3,8 +3,9 @@ import json
 from typing import Any
 
 import pydash
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
+from pydantic import BaseModel
+
+from mm_std.data_result import DataResult
 
 
 @enum.unique
@@ -15,79 +16,32 @@ class HttpError(str, enum.Enum):
     ERROR = "error"
 
 
-class HttpResponse:
-    def __init__(
-        self,
-        status: 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 = status
-        self.error = error
-        self.error_message = error_message
-        self.body = body
-        self.headers = headers
-
-        self._json_data: Any = None
-        self._json_parsed = False
-        self._json_parsed_error = False
+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
 
-    def _parse_json(self) -> None:
+    def parse_json_body(self, path: str | None = None, none_on_error: bool = False) -> Any:  # noqa: ANN401
         if self.body is None:
-            self._json_parsed_error = True
-            return
+            if none_on_error:
+                return None
+            raise ValueError("Body is None")
+
         try:
-            self._json_data = None
-            self._json_data = json.loads(self.body)
-            self._json_parsed_error = False
+            res = json.loads(self.body)
+            return pydash.get(res, path, None) if path else res
         except json.JSONDecodeError:
-            self._json_parsed_error = True
-        self._json_parsed = True
-
-    def json(self, path: str | None = None) -> Any:  # noqa: ANN401
-        if not self._json_parsed:
-            self._parse_json()
-        if path:
-            return pydash.get(self._json_data, path, None)
-        return self._json_data
-
-    def dict(self) -> dict[str, object]:
-        return {
-            "status": self.status,
-            "error": self.error,
-            "error_message": self.error_message,
-            "body": self.body,
-            "headers": self.headers,
-        }
-
-    def is_json_parse_error(self) -> bool:
-        if not self._json_parsed:
-            self._parse_json()
-        return self._json_parsed_error
+            if none_on_error:
+                return None
+            raise
 
-    def __repr__(self) -> str:
-        return f"HttpResponse(status={self.status}, error={self.error}, error_message={self.error_message}, body={self.body}, headers={self.headers})"  # noqa: E501
+    def is_error(self) -> bool:
+        return self.error is not None or (self.status_code is not None and self.status_code >= 400)
 
-    @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.dict()),
-        )
+    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())
 
-    @classmethod
-    def _validate(cls, v: object) -> "HttpResponse":
-        if isinstance(v, cls):
-            return v
-        if isinstance(v, dict):
-            return cls(
-                status=v.get("status"),
-                error=HttpError(v["error"]) if v.get("error") else None,
-                error_message=v.get("error_message"),
-                body=v.get("body"),
-                headers=v.get("headers"),
-            )
-        raise TypeError(f"Cannot parse value as {cls.__name__}: {v}")
+    def to_data_result_ok[T](self, result: T) -> DataResult[T]:
+        return DataResult.ok(result, self.model_dump())

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.28
+Version: 0.3.30
 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~=2.11.3
 Requires-Dist: pydash~=8.0.5

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

@@ -2,7 +2,7 @@ mm_std/__init__.py,sha256=ePkjykjImp2Wu10lFzK3Fl1HpGqqXFb_HZK_BSiU3MM,3316
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
-mm_std/data_result.py,sha256=AMG6ttFTa9wxOS2U3kgPI2Z1shntdhF-7KxvfYYILoo,8104
+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
@@ -27,8 +27,8 @@ mm_std/concurrency/sync_decorators.py,sha256=syCQBOmN7qPO55yzgJB2rbkh10CVww376hm
 mm_std/concurrency/sync_scheduler.py,sha256=j4tBL_cBI1spr0cZplTA7N2CoYsznuORMeRN8rpR6gY,2407
 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=mJak332gv9NvY0JLO3hNrBxroQGS1HlNBzd1yq4Dy24,3694
-mm_std/http/response.py,sha256=vvv5COTjJula9t33mFyrruhrFC4dr_Uy0jDKj6t1JxM,2923
-mm_std-0.3.28.dist-info/METADATA,sha256=NbbHHlhKM4WMRWCSpEvDdQhfDiH9L6-TUQQBP6Px4Co,415
-mm_std-0.3.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.28.dist-info/RECORD,,
+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,,