mm-std 0.3.27__py3-none-any.whl → 0.3.29__py3-none-any.whl

mm_std/data_result.py

@@ -87,35 +87,85 @@ class DataResult(Generic[T]):
         """
         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 the original error.
+            A new DataResult with the transformed success value or an error.
         """
         if self.is_err():
             return DataResult[U](err=self.err, data=self.data)
 
-        mapped_ok = fn(self.unwrap())
-        return DataResult[U](ok=mapped_ok, data=self.data)
+        try:
+            mapped_ok = fn(self.unwrap())
+            return DataResult[U](ok=mapped_ok, data=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})
 
     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 the original error.
+            A new DataResult with the transformed success value or an error.
         """
         if self.is_err():
             return DataResult[U](err=self.err, data=self.data)
 
-        mapped_ok = await fn(self.unwrap())
-        return DataResult[U](ok=mapped_ok, data=self.data)
+        try:
+            mapped_ok = await fn(self.unwrap())
+            return DataResult[U](ok=mapped_ok, data=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})
+
+    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.err, data=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})
+
+    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.err, data=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})
 
     def __repr__(self) -> str:
         """

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", data=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, data=self.model_dump())

{mm_std-0.3.27.dist-info → mm_std-0.3.29.dist-info}/METADATA

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

{mm_std-0.3.27.dist-info → mm_std-0.3.29.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=--rg0YPaJkszCmbt9TO-BthdGdYrCRARA8iII9LVocE,5871
+mm_std/data_result.py,sha256=AMG6ttFTa9wxOS2U3kgPI2Z1shntdhF-7KxvfYYILoo,8104
 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.27.dist-info/METADATA,sha256=H30ViZKdZolKRVDR9PxBk7OoQZWofyy-EqjrUpT2NkQ,415
-mm_std-0.3.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.27.dist-info/RECORD,,
+mm_std/http/http_request.py,sha256=h74_ZjACwdbeINjzhuEwNUpvnaHZvyGl7TExjlBwMGg,3704
+mm_std/http/response.py,sha256=qEQYV_TkwttS9fVuQwNmyB9QtrwUsuLAcC7juVbyCAg,1387
+mm_std-0.3.29.dist-info/METADATA,sha256=ZZrqphz0r5EALNmkV3ysuqLCt8h5X_MxD3MSVSkLzLM,415
+mm_std-0.3.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.29.dist-info/RECORD,,