mm-http 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

mm_http/__init__.py

@@ -1,5 +1,7 @@
-from .request import http_request
-from .request_sync import http_request_sync
-from .response import HttpResponse, TransportError, TransportErrorDetail
+"""HTTP client library with sync and async support."""
 
-__all__ = ["HttpResponse", "TransportError", "TransportErrorDetail", "http_request", "http_request_sync"]
+from .request import http_request as http_request
+from .request_sync import http_request_sync as http_request_sync
+from .response import HttpResponse as HttpResponse
+from .response import TransportError as TransportError
+from .response import TransportErrorType as TransportErrorType

mm_http/request.py

@@ -1,3 +1,5 @@
+"""Async HTTP request implementation using aiohttp."""
+
 from typing import Any
 
 import aiohttp
@@ -10,11 +12,10 @@ from aiohttp import (
     ServerConnectionError,
     ServerDisconnectedError,
 )
-from aiohttp.typedefs import LooseCookies
 from aiohttp_socks import ProxyConnectionError, ProxyConnector
 from multidict import CIMultiDictProxy
 
-from .response import HttpResponse, TransportError, TransportErrorDetail
+from .response import HttpResponse, TransportErrorType
 
 
 async def http_request(
@@ -25,14 +26,14 @@ async def http_request(
     data: dict[str, Any] | None = None,
     json: dict[str, Any] | None = None,
     headers: dict[str, Any] | None = None,
-    cookies: LooseCookies | None = None,
+    cookies: dict[str, str] | None = None,
     user_agent: str | None = None,
     proxy: str | None = None,
     timeout: float | None = 10.0,
+    verify_ssl: bool = True,
+    follow_redirects: bool = True,
 ) -> HttpResponse:
-    """
-    Send an HTTP request and return the response.
-    """
+    """Send an HTTP request and return the response."""
     timeout_ = aiohttp.ClientTimeout(total=timeout) if timeout else None
     if user_agent:
         if not headers:
@@ -51,6 +52,8 @@ async def http_request(
                 cookies=cookies,
                 proxy=proxy,
                 timeout=timeout_,
+                verify_ssl=verify_ssl,
+                follow_redirects=follow_redirects,
             )
         return await _request_with_http_or_none_proxy(
             url,
@@ -62,13 +65,15 @@ async def http_request(
             cookies=cookies,
             proxy=proxy,
             timeout=timeout_,
+            verify_ssl=verify_ssl,
+            follow_redirects=follow_redirects,
         )
     except TimeoutError as err:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.TIMEOUT, message=str(err)))
+        return HttpResponse.from_transport_error(TransportErrorType.TIMEOUT, str(err))
     except (aiohttp.ClientProxyConnectionError, ProxyConnectionError, ClientHttpProxyError) as err:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.PROXY, message=str(err)))
-    except InvalidUrlClientError as e:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.INVALID_URL, message=str(e)))
+        return HttpResponse.from_transport_error(TransportErrorType.PROXY, str(err))
+    except InvalidUrlClientError as err:
+        return HttpResponse.from_transport_error(TransportErrorType.INVALID_URL, str(err))
     except (
         ClientConnectorError,
         ServerConnectionError,
@@ -76,9 +81,9 @@ async def http_request(
         ClientSSLError,
         ClientConnectionError,
     ) as err:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.CONNECTION, message=str(err)))
+        return HttpResponse.from_transport_error(TransportErrorType.CONNECTION, str(err))
     except Exception as err:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.ERROR, message=str(err)))
+        return HttpResponse.from_transport_error(TransportErrorType.ERROR, str(err))
 
 
 async def _request_with_http_or_none_proxy(
@@ -89,12 +94,25 @@ async def _request_with_http_or_none_proxy(
     data: dict[str, Any] | None = None,
     json: dict[str, Any] | None = None,
     headers: dict[str, Any] | None = None,
-    cookies: LooseCookies | None = None,
+    cookies: dict[str, str] | None = None,
     proxy: str | None = None,
     timeout: aiohttp.ClientTimeout | None,
+    verify_ssl: bool,
+    follow_redirects: bool,
 ) -> HttpResponse:
+    """Execute request with HTTP proxy or no proxy."""
     async with aiohttp.request(
-        method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, proxy=proxy, timeout=timeout
+        method,
+        url,
+        params=params,
+        data=data,
+        json=json,
+        headers=headers,
+        cookies=cookies,
+        proxy=proxy,
+        timeout=timeout,
+        ssl=verify_ssl,
+        allow_redirects=follow_redirects,
     ) as res:
         return HttpResponse(
             status_code=res.status,
@@ -112,14 +130,25 @@ async def _request_with_socks_proxy(
     data: dict[str, Any] | None = None,
     json: dict[str, Any] | None = None,
     headers: dict[str, Any] | None = None,
-    cookies: LooseCookies | None = None,
+    cookies: dict[str, str] | None = None,
     timeout: aiohttp.ClientTimeout | None,
+    verify_ssl: bool,
+    follow_redirects: bool,
 ) -> HttpResponse:
-    connector = ProxyConnector.from_url(proxy)
+    """Execute request through SOCKS proxy."""
+    connector = ProxyConnector.from_url(proxy, ssl=verify_ssl)
     async with (
         aiohttp.ClientSession(connector=connector) as session,
         session.request(
-            method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, timeout=timeout
+            method,
+            url,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            allow_redirects=follow_redirects,
         ) as res,
     ):
         return HttpResponse(
@@ -130,6 +159,7 @@ async def _request_with_socks_proxy(
 
 
 def headers_dict(headers: CIMultiDictProxy[str]) -> dict[str, str]:
+    """Convert multidict headers to dict, joining duplicate keys with comma."""
     result: dict[str, str] = {}
     for key in headers:
         values = headers.getall(key)

mm_http/request_sync.py

@@ -1,17 +1,12 @@
+"""Sync HTTP request implementation using requests library."""
+
 from typing import Any
 
 import requests
-from requests.exceptions import (
-    ConnectionError as RequestsConnectionError,
-)
-from requests.exceptions import (
-    InvalidSchema,
-    MissingSchema,
-    ProxyError,
-    SSLError,
-)
+from requests.exceptions import ConnectionError as RequestsConnectionError
+from requests.exceptions import InvalidSchema, MissingSchema, ProxyError, SSLError
 
-from .response import HttpResponse, TransportError, TransportErrorDetail
+from .response import HttpResponse, TransportErrorType
 
 
 def http_request_sync(
@@ -22,14 +17,14 @@ def http_request_sync(
     data: dict[str, Any] | None = None,
     json: dict[str, Any] | None = None,
     headers: dict[str, Any] | None = None,
-    cookies: dict[str, Any] | None = None,
+    cookies: dict[str, str] | None = None,
     user_agent: str | None = None,
     proxy: str | None = None,
     timeout: float | None = 10.0,
+    verify_ssl: bool = True,
+    follow_redirects: bool = True,
 ) -> HttpResponse:
-    """
-    Send a synchronous HTTP request and return the response.
-    """
+    """Send a synchronous HTTP request and return the response."""
     if user_agent:
         if headers is None:
             headers = {}
@@ -53,19 +48,21 @@ def http_request_sync(
             cookies=cookies,
             timeout=timeout,
             proxies=proxies,
+            verify=verify_ssl,
+            allow_redirects=follow_redirects,
         )
         return HttpResponse(
             status_code=res.status_code,
             body=res.text,
             headers=dict(res.headers),
         )
-    except requests.Timeout as e:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.TIMEOUT, message=str(e)))
-    except ProxyError as e:
-        return HttpResponse(transport_error=TransportErrorDetail(type=TransportError.PROXY, message=str(e)))
-    except (InvalidSchema, MissingSchema) as 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(transport_error=TransportErrorDetail(type=TransportError.ERROR, message=str(e)))
+    except requests.Timeout as err:
+        return HttpResponse.from_transport_error(TransportErrorType.TIMEOUT, str(err))
+    except ProxyError as err:
+        return HttpResponse.from_transport_error(TransportErrorType.PROXY, str(err))
+    except (InvalidSchema, MissingSchema) as err:
+        return HttpResponse.from_transport_error(TransportErrorType.INVALID_URL, str(err))
+    except (RequestsConnectionError, SSLError) as err:
+        return HttpResponse.from_transport_error(TransportErrorType.CONNECTION, str(err))
+    except Exception as err:
+        return HttpResponse.from_transport_error(TransportErrorType.ERROR, str(err))

mm_http/response.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+"""HTTP response models and error types."""
 
 import enum
 import json
@@ -10,7 +10,9 @@ from pydantic import BaseModel, model_validator
 
 
 @enum.unique
-class TransportError(str, enum.Enum):
+class TransportErrorType(str, enum.Enum):
+    """Transport-level error types."""
+
     TIMEOUT = "timeout"
     PROXY = "proxy"
     INVALID_URL = "invalid_url"
@@ -18,10 +20,10 @@ class TransportError(str, enum.Enum):
     ERROR = "error"
 
 
-class TransportErrorDetail(BaseModel):
+class TransportError(BaseModel):
     """Transport error with type and message."""
 
-    type: TransportError
+    type: TransportErrorType
     message: str
 
 
@@ -31,7 +33,7 @@ class HttpResponse(BaseModel):
     status_code: int | None = None
     body: str | None = None
     headers: dict[str, str] | None = None
-    transport_error: TransportErrorDetail | None = None
+    transport_error: TransportError | None = None
 
     @model_validator(mode="after")
     def validate_mutually_exclusive_states(self) -> HttpResponse:
@@ -49,20 +51,38 @@ class HttpResponse(BaseModel):
 
         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."""
+    @classmethod
+    def from_transport_error(cls, error_type: TransportErrorType, message: str) -> HttpResponse:
+        """Create HttpResponse from transport error."""
+        return cls(transport_error=TransportError(type=error_type, message=message))
+
+    def json_body(self, path: str | None = None) -> Result[Any]:
+        """Parse body as JSON with explicit error handling."""
         if self.body is None:
-            if none_on_error:
-                return None
-            raise ValueError("Body is None")
+            return Result.err("body is None")
+        try:
+            data = json.loads(self.body)
+        except json.JSONDecodeError as e:
+            return Result.err(("JSON decode error", e))
+
+        if path:
+            if not pydash.has(data, path):
+                return Result.err(f"path not found: {path}")
+            return Result.ok(pydash.get(data, path))
+        return Result.ok(data)
 
+    def json_body_or_none(self, path: str | None = None) -> Any:  # noqa: ANN401 - JSON returns dynamic types
+        """Parse body as JSON. Returns None if body is None, JSON invalid, or path not found.
+
+        Warning: Do not use if None is a valid expected value — use json_body() instead.
+        """
+        if self.body is None:
+            return None
         try:
             res = json.loads(self.body)
             return pydash.get(res, path, None) if path else res
         except json.JSONDecodeError:
-            if none_on_error:
-                return None
-            raise
+            return None
 
     def get_header(self, name: str) -> str | None:
         """Get header value (case-insensitive)."""
@@ -101,11 +121,11 @@ class HttpResponse(BaseModel):
             result_error = f"HTTP {self.status_code}"
         else:
             result_error = "error"
-        return Result.err(result_error, extra=self.model_dump(mode="json"))
+        return Result.err(result_error, context=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.model_dump(mode="json"))
+        return Result.ok(value, context=self.model_dump(mode="json"))
 
     @property
     def content_type(self) -> str | None:

{mm_http-0.2.4.dist-info → mm_http-0.3.0.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-http
-Version: 0.2.4
-Requires-Python: >=3.13
+Version: 0.3.0
+Requires-Python: >=3.14
 Requires-Dist: aiohttp-socks~=0.11.0
 Requires-Dist: aiohttp~=3.13.3
-Requires-Dist: mm-result~=0.1.2
+Requires-Dist: mm-result~=0.2.0
 Requires-Dist: pydantic~=2.12.5
-Requires-Dist: pydash~=8.0.5
+Requires-Dist: pydash~=8.0.6
 Requires-Dist: requests[socks]~=2.32.5
-Requires-Dist: urllib3~=2.6.3

mm_http-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mm_http/__init__.py,sha256=UlnNFVFqi3qI07MbL7Cm3k3qaEmdUwv-H--6XvfLAEU,340
+mm_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_http/request.py,sha256=RjJ6QWwyQpIZ6jDhDufQ_R8AvDNvmbKb2VATUAYmVYA,5231
+mm_http/request_sync.py,sha256=xQ0vgYJf4eSackna03GmV4h0iZvNPzWb535ts_oterE,2253
+mm_http/response.py,sha256=dxGY6Tg669qhIJRM1bGawiJwOLmAPgD01tXgMKrYl24,4913
+mm_http-0.3.0.dist-info/METADATA,sha256=OD3RTIe5K43mlKdiJDG8ta1zdLzhB4d8uDzUtr2XIE4,275
+mm_http-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mm_http-0.3.0.dist-info/RECORD,,

mm_http-0.2.4.dist-info/RECORD

@@ -1,8 +0,0 @@
-mm_http/__init__.py,sha256=KQ5BhEyTpNXdV-gRYV8keh6_caee8jo8xuj292VWGTU,258
-mm_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_http/request.py,sha256=3uVkKiB89jL5o64SY-hyQV4iBlwLL8Pt4UekwU2zYVI,4569
-mm_http/request_sync.py,sha256=2YjWAvWiut2HPcLMuwpCVMwpR99bmTQA3jYEutISKJE,2216
-mm_http/response.py,sha256=WDRXNASFreDUGiUQk4QIelVP7qCPLWmNXsTd9uln-v8,4040
-mm_http-0.2.4.dist-info/METADATA,sha256=GcZeadaz6uYk8CM-MjuTGDDBbqbBtRIKptMkRoa1qT0,305
-mm_http-0.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mm_http-0.2.4.dist-info/RECORD,,