mm-http 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

mm_http/__init__.py

@@ -1,5 +1,5 @@
 from .http_request import http_request
 from .http_request_sync import http_request_sync
-from .response import HttpError, HttpResponse
+from .response import HttpResponse, TransportError, TransportErrorDetail
 
-__all__ = ["HttpError", "HttpResponse", "http_request", "http_request_sync"]
+__all__ = ["HttpResponse", "TransportError", "TransportErrorDetail", "http_request", "http_request_sync"]

mm_http/http_request.py

@@ -1,12 +1,20 @@
 from typing import Any
 
 import aiohttp
-from aiohttp import ClientHttpProxyError, InvalidUrlClientError
+from aiohttp import (
+    ClientConnectionError,
+    ClientConnectorError,
+    ClientHttpProxyError,
+    ClientSSLError,
+    InvalidUrlClientError,
+    ServerConnectionError,
+    ServerDisconnectedError,
+)
 from aiohttp.typedefs import LooseCookies
 from aiohttp_socks import ProxyConnectionError, ProxyConnector
 from multidict import CIMultiDictProxy
 
-from .response import HttpError, HttpResponse
+from .response import HttpResponse, TransportError, TransportErrorDetail
 
 
 async def http_request(
@@ -14,9 +22,9 @@ async def http_request(
     *,
     method: str = "GET",
     params: dict[str, Any] | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
+    data: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
     cookies: LooseCookies | None = None,
     user_agent: str | None = None,
     proxy: str | None = None,
@@ -56,13 +64,21 @@ async def http_request(
             timeout=timeout_,
         )
     except TimeoutError as err:
-        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(err))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.TIMEOUT, message=str(err)))
     except (aiohttp.ClientProxyConnectionError, ProxyConnectionError, ClientHttpProxyError) as err:
-        return HttpResponse(error=HttpError.PROXY, error_message=str(err))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.PROXY, message=str(err)))
     except InvalidUrlClientError as e:
-        return HttpResponse(error=HttpError.INVALID_URL, error_message=str(e))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.INVALID_URL, message=str(e)))
+    except (
+        ClientConnectorError,
+        ServerConnectionError,
+        ServerDisconnectedError,
+        ClientSSLError,
+        ClientConnectionError,
+    ) as err:
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.CONNECTION, message=str(err)))
     except Exception as err:
-        return HttpResponse(error=HttpError.ERROR, error_message=str(err))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.ERROR, message=str(err)))
 
 
 async def _request_with_http_or_none_proxy(
@@ -70,9 +86,9 @@ async def _request_with_http_or_none_proxy(
     *,
     method: str = "GET",
     params: dict[str, Any] | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
+    data: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
     cookies: LooseCookies | None = None,
     proxy: str | None = None,
     timeout: aiohttp.ClientTimeout | None,
@@ -82,9 +98,7 @@ async def _request_with_http_or_none_proxy(
     ) as res:
         return HttpResponse(
             status_code=res.status,
-            error=None,
-            error_message=None,
-            body=(await res.read()).decode(),
+            body=await res.text(),
             headers=headers_dict(res.headers),
         )
 
@@ -95,9 +109,9 @@ async def _request_with_socks_proxy(
     method: str = "GET",
     proxy: str,
     params: dict[str, Any] | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
+    data: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
     cookies: LooseCookies | None = None,
     timeout: aiohttp.ClientTimeout | None,
 ) -> HttpResponse:
@@ -110,9 +124,7 @@ async def _request_with_socks_proxy(
     ):
         return HttpResponse(
             status_code=res.status,
-            error=None,
-            error_message=None,
-            body=(await res.read()).decode(),
+            body=await res.text(),
             headers=headers_dict(res.headers),
         )
 

mm_http/http_request_sync.py

@@ -1,9 +1,17 @@
 from typing import Any
 
 import requests
-from requests.exceptions import InvalidSchema, MissingSchema, ProxyError
+from requests.exceptions import (
+    ConnectionError as RequestsConnectionError,
+)
+from requests.exceptions import (
+    InvalidSchema,
+    MissingSchema,
+    ProxyError,
+    SSLError,
+)
 
-from .response import HttpError, HttpResponse
+from .response import HttpResponse, TransportError, TransportErrorDetail
 
 
 def http_request_sync(
@@ -48,16 +56,16 @@ def http_request_sync(
         )
         return HttpResponse(
             status_code=res.status_code,
-            error=None,
-            error_message=None,
             body=res.text,
             headers=dict(res.headers),
         )
     except requests.Timeout as e:
-        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(e))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.TIMEOUT, message=str(e)))
     except ProxyError as e:
-        return HttpResponse(error=HttpError.PROXY, error_message=str(e))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.PROXY, message=str(e)))
     except (InvalidSchema, MissingSchema) as e:
-        return HttpResponse(error=HttpError.INVALID_URL, error_message=str(e))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.INVALID_URL, message=str(e)))
+    except (RequestsConnectionError, SSLError) as e:
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.CONNECTION, message=str(e)))
     except Exception as e:
-        return HttpResponse(error=HttpError.ERROR, error_message=str(e))
+        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.ERROR, message=str(e)))

mm_http/response.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 import enum
 import json
-from dataclasses import dataclass
 from typing import Any
 
 import pydash
 from mm_result import Result
+from pydantic import BaseModel, model_validator
 
 
 @enum.unique
-class HttpError(str, enum.Enum):
+class TransportError(str, enum.Enum):
     TIMEOUT = "timeout"
     PROXY = "proxy"
     INVALID_URL = "invalid_url"
@@ -18,17 +18,38 @@ class HttpError(str, enum.Enum):
     ERROR = "error"
 
 
-@dataclass
-class HttpResponse:
-    """HTTP response with status, error, body, and headers."""
+class TransportErrorDetail(BaseModel):
+    """Transport error with type and message."""
+
+    type: TransportError
+    message: str
+
+
+class HttpResponse(BaseModel):
+    """HTTP response with status, body, headers, and optional transport error."""
 
     status_code: int | None = None
-    error: HttpError | None = None
-    error_message: str | None = None
     body: str | None = None
     headers: dict[str, str] | None = None
+    transport_error: TransportErrorDetail | None = None
+
+    @model_validator(mode="after")
+    def validate_mutually_exclusive_states(self) -> HttpResponse:
+        """Validate that response has either HTTP data or transport error, but not both."""
+        has_http_response = self.status_code is not None
+        has_transport_error = self.transport_error is not None
 
-    def parse_json_body(self, path: str | None = None, none_on_error: bool = False) -> Any:  # noqa: ANN401
+        if has_http_response and has_transport_error:
+            msg = "Cannot have both HTTP response and transport error"
+            raise ValueError(msg)
+
+        if not has_http_response and not has_transport_error:
+            msg = "Must have either HTTP response or transport error"
+            raise ValueError(msg)
+
+        return self
+
+    def parse_json(self, path: str | None = None, none_on_error: bool = False) -> Any:  # noqa: ANN401
         """Parse JSON body and optionally extract value by path."""
         if self.body is None:
             if none_on_error:
@@ -43,48 +64,41 @@ class HttpResponse:
                 return None
             raise
 
+    def get_header(self, name: str) -> str | None:
+        """Get header value (case-insensitive)."""
+        if self.headers is None:
+            return None
+        name_lower = name.lower()
+        for key, value in self.headers.items():
+            if key.lower() == name_lower:
+                return value
+        return None
+
+    def is_success(self) -> bool:
+        """Check if response has 2xx status."""
+        return self.status_code is not None and 200 <= self.status_code < 300
+
     def is_err(self) -> bool:
-        """Check if response represents an error (has error or status >= 400)."""
-        return self.error is not None or (self.status_code is not None and self.status_code >= 400)
+        """Check if response represents an error (has transport error or status >= 400)."""
+        return self.transport_error is not None or (self.status_code is not None and self.status_code >= 400)
 
     def to_result_err[T](self, error: str | Exception | tuple[str, Exception] | None = None) -> Result[T]:
-        """Create error Result[T] from HttpResponse."""
-        return Result.err(error or self.error or "error", extra=self.to_dict())
+        """Create error Result[T] from HttpResponse with meaningful error message."""
+        if error is not None:
+            result_error = error
+        elif self.transport_error is not None:
+            result_error = self.transport_error.type
+        elif self.status_code is not None:
+            result_error = f"HTTP {self.status_code}"
+        else:
+            result_error = "error"
+        return Result.err(result_error, extra=self.model_dump(mode="json"))
 
     def to_result_ok[T](self, value: T) -> Result[T]:
         """Create success Result[T] from HttpResponse with given value."""
-        return Result.ok(value, extra=self.to_dict())
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert HttpResponse to dictionary."""
-        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,
-        }
+        return Result.ok(value, extra=self.model_dump(mode="json"))
 
     @property
     def content_type(self) -> str | None:
         """Get Content-Type header value (case-insensitive)."""
-        if self.headers is None:
-            return None
-        for key in self.headers:
-            if key.lower() == "content-type":
-                return self.headers[key]
-        return None
-
-    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)})"
+        return self.get_header("content-type")

{mm_http-0.1.3.dist-info → mm_http-0.2.0.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-http
-Version: 0.1.3
+Version: 0.2.0
 Requires-Python: >=3.13
 Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: aiohttp~=3.12.15
-Requires-Dist: mm-result~=0.1.1
+Requires-Dist: aiohttp~=3.13.0
+Requires-Dist: mm-result~=0.1.2
+Requires-Dist: pydantic~=2.12.0
 Requires-Dist: pydash~=8.0.5
 Requires-Dist: requests[socks]~=2.32.5

mm_http-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mm_http/__init__.py,sha256=-a5cUQa-Gr6xKErvlyJNApIb1itlL48xfi_pg-GMM7Y,268
+mm_http/http_request.py,sha256=3uVkKiB89jL5o64SY-hyQV4iBlwLL8Pt4UekwU2zYVI,4569
+mm_http/http_request_sync.py,sha256=2YjWAvWiut2HPcLMuwpCVMwpR99bmTQA3jYEutISKJE,2216
+mm_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_http/response.py,sha256=hoqVqLT4yzWxHYtkEGg0eTmAV530gvaB20WERQgpZpg,3634
+mm_http-0.2.0.dist-info/METADATA,sha256=ddTBM6-fSpviUfM7Xta54yb4xVdPmOJjaBZctfaeh7U,275
+mm_http-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_http-0.2.0.dist-info/RECORD,,

mm_http-0.1.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-mm_http/__init__.py,sha256=vW7ASPktUjm6S2Q7_biiA4F_PzG7gPF8gK3E7bBO4yQ,212
-mm_http/http_request.py,sha256=3yapH-ADtSGqV7pMQj1cGWrGywDmRnTIE53AzM6ECtg,4116
-mm_http/http_request_sync.py,sha256=lajd4Xt_wHKuRYyPtybO5CHHvquLzGPZEMHzKjN1wlM,1819
-mm_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_http/response.py,sha256=CCnL9COZvzP0kyAy6sASRbo1VtmnGsSiTd0kgvrt-MI,3036
-mm_http-0.1.3.dist-info/METADATA,sha256=01CkW2dV0gfZp_8Kl-IsJYc_2SwASD0wwDPIY9hSHc4,244
-mm_http-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_http-0.1.3.dist-info/RECORD,,