mm-http 0.2.5__tar.gz → 0.3.1__tar.gz

mm_http-0.3.1/CLAUDE.md

@@ -0,0 +1,24 @@
+# AI Agent Start Guide
+
+## Critical: Language
+RESPOND IN ENGLISH. Always. No exceptions.
+User's language does NOT determine your response language.
+Only switch if user EXPLICITLY requests it (e.g., "respond in {language}").
+Language switching applies ONLY to chat. All code, comments, commit messages, and files must ALWAYS be in English — no exceptions.
+
+## Mandatory Rules (external)
+These files are REQUIRED. Read them fully and follow all rules.
+- `~/.claude/shared-rules/general.md`
+- `~/.claude/shared-rules/python.md`
+
+## Project Reading (context)
+These files are REQUIRED for project understanding.
+- `README.md`
+
+## Preflight (mandatory)
+Before your first response:
+1. Read all files listed above.
+2. Do not answer until all are read.
+3. In your first reply, list every file you have read from this document.
+
+Failure to follow this protocol is considered an error.

{mm_http-0.2.5 → mm_http-0.3.1}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-http
-Version: 0.2.5
-Requires-Python: >=3.13
+Version: 0.3.1
+Requires-Python: >=3.14
 Requires-Dist: aiohttp-socks~=0.11.0
 Requires-Dist: aiohttp~=3.13.3
-Requires-Dist: mm-result~=0.1.3
+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.2.5 → mm_http-0.3.1}/README.md

@@ -6,7 +6,7 @@ A simple and convenient HTTP client library for Python with both synchronous and
 
 - **Simple API** for one-off HTTP requests
 - **Sync and Async** support with identical interfaces
-- **JSON path navigation** with dot notation (`response.parse_json_body("user.profile.name")`)
+- **JSON path navigation** with dot notation (`response.json_body("user.profile.name")`)
 - **Proxy support** (HTTP and SOCKS5)
 - **Unified error handling**
 - **Type-safe** with full type annotations
@@ -21,7 +21,8 @@ from mm_http import http_request
 
 # Simple GET request
 response = await http_request("https://api.github.com/users/octocat")
-user_name = response.parse_json("name")  # Navigate JSON with dot notation
+result = response.json_body("name")  # Navigate JSON with dot notation
+user_name = result.value if result.is_ok() else None
 
 # POST with JSON data
 response = await http_request(
@@ -45,7 +46,8 @@ from mm_http import http_request_sync
 
 # Same API, but synchronous
 response = http_request_sync("https://api.github.com/users/octocat")
-user_name = response.parse_json("name")
+result = response.json_body("name")
+user_name = result.value if result.is_ok() else None
 ```
 
 ## API Reference
@@ -63,10 +65,12 @@ user_name = response.parse_json("name")
 - `data: dict[str, Any] | None = None` - Form data
 - `json: dict[str, Any] | None = None` - JSON data
 - `headers: dict[str, Any] | None = None` - HTTP headers
-- `cookies: LooseCookies | None = None` - Cookies
+- `cookies: dict[str, str] | None = None` - Cookies
 - `user_agent: str | None = None` - User-Agent header
 - `proxy: str | None = None` - Proxy URL (supports http://, https://, socks4://, socks5://)
 - `timeout: float | None = 10.0` - Request timeout in seconds
+- `verify_ssl: bool = True` - Enable/disable SSL certificate verification
+- `follow_redirects: bool = True` - Enable/disable following redirects
 
 ### HttpResponse
 
@@ -75,10 +79,10 @@ class HttpResponse(BaseModel):
     status_code: int | None
     body: str | None
     headers: dict[str, str] | None
-    transport_error: TransportErrorDetail | None
+    transport_error: TransportError | None
 
     # JSON parsing
-    def parse_json(self, path: str | None = None, none_on_error: bool = False) -> Any
+    def json_body(self, path: str | None = None) -> Result[Any]
 
     # Header access
     def get_header(self, name: str) -> str | None
@@ -95,15 +99,15 @@ class HttpResponse(BaseModel):
     # Pydantic methods
     def model_dump(self, mode: str = "python") -> dict[str, Any]
 
-class TransportErrorDetail(BaseModel):
-    type: TransportError
+class TransportError(BaseModel):
+    type: TransportErrorType
     message: str
 ```
 
 ### Error Types
 
 ```python
-class TransportError(str, Enum):
+class TransportErrorType(str, Enum):
     TIMEOUT = "timeout"
     PROXY = "proxy"
     INVALID_URL = "invalid_url"
@@ -119,14 +123,20 @@ class TransportError(str, Enum):
 response = await http_request("https://api.github.com/users/octocat")
 
 # Instead of: json.loads(response.body)["plan"]["name"]
-plan_name = response.parse_json("plan.name")
+result = response.json_body("plan.name")
+if result.is_ok():
+    plan_name = result.value
 
-# Safe navigation - returns None if path doesn't exist
-followers = response.parse_json("followers_count")
-nonexistent = response.parse_json("does.not.exist")  # Returns None
+# Navigate with dot notation
+followers = response.json_body("followers_count")
+nonexistent = response.json_body("does.not.exist")  # Result with error
 
-# Or get full JSON
-data = response.parse_json()
+# Get full JSON
+result = response.json_body()
+if result.is_ok():
+    data = result.value
+else:
+    print(f"Error: {result.error}")  # "body is None", "JSON decode error", or "path not found: ..."
 ```
 
 ### Error Handling
@@ -136,7 +146,7 @@ response = await http_request("https://example.com", timeout=5.0)
 
 # Simple check
 if response.is_success():
-    data = response.parse_json()
+    result = response.json_body()
 
 # Detailed error handling
 if response.is_err():
@@ -188,17 +198,19 @@ async def get_user_id() -> Result[int]:
     response = await http_request("https://api.example.com/user")
 
     if response.is_err():
-        return response.to_result_err()  # Returns "HTTP 404" or TransportError.TIMEOUT
+        return response.to_result_err()  # Returns "HTTP 404" or TransportErrorType.TIMEOUT
 
-    user_id = response.parse_json("id")
-    return response.to_result_ok(user_id)
+    result = response.json_body("id")
+    if result.is_err():
+        return response.to_result_err("invalid_json")
+    return response.to_result_ok(result.value)
 
 # Usage
 result = await get_user_id()
 if result.is_ok():
     print(f"User ID: {result.value}")
 else:
-    print(f"Error: {result.error}")  # "HTTP 404" or TransportError.TIMEOUT
+    print(f"Error: {result.error}")  # "HTTP 404" or TransportErrorType.TIMEOUT
     print(f"HTTP details: {result.extra}")  # Contains full HTTP response data
 ```
 

{mm_http-0.2.5 → mm_http-0.3.1}/pyproject.toml

@@ -1,16 +1,15 @@
 [project]
 name = "mm-http"
-version = "0.2.5"
+version = "0.3.1"
 description = ""
-requires-python = ">=3.13"
+requires-python = ">=3.14"
 dependencies = [
-    "mm-result~=0.1.3",
+    "mm-result~=0.2.0",
     "requests[socks]~=2.32.5",
     "aiohttp~=3.13.3",
     "aiohttp-socks~=0.11.0",
-    "pydash~=8.0.5",
+    "pydash~=8.0.6",
     "pydantic~=2.12.5",
-    "urllib3~=2.6.3",          # CVE-2026-21441
 ]
 
 [build-system]
@@ -23,25 +22,25 @@ dev = [
     "pytest-asyncio~=1.3.0",
     "pytest-xdist~=3.8.0",
     "pytest-httpserver~=1.1.3",
-    "ruff~=0.14.13",
+    "ruff~=0.15.0",
     "mypy~=1.19.1",
     "pip-audit~=2.10.0",
-    "bandit~=1.9.2",
+    "bandit~=1.9.3",
     "pre-commit~=4.5.1",
     "types-requests~=2.32.4.20260107",
     "python-dotenv~=1.2.1",
-    "ty~=0.0.12",
+    "ty~=0.0.14",
 ]
 
 [tool.mypy]
-python_version = "3.13"
+python_version = "3.14"
 warn_no_return = false
 strict = true
 exclude = ["^tests/", "^tmp/"]
 
 [tool.ruff]
 line-length = 130
-target-version = "py313"
+target-version = "py314"
 [tool.ruff.lint]
 select = ["ALL"]
 ignore = [
@@ -49,7 +48,6 @@ ignore = [
     "A005",     # flake8-builtins: stdlib-module-shadowing
     "ERA001",   # eradicate: commented-out-code
     "PT",       # flake8-pytest-style
-    "D",        # pydocstyle
     "FIX",      # flake8-fixme
     "PLR0911",  # pylint: too-many-return-statements
     "PLR0912",  # pylint: too-many-branches
@@ -68,17 +66,19 @@ ignore = [
     "COM812",   # it's used in ruff formatter
     "ASYNC109",
     "G004",
+    "D203",     # pydocstyle: one-blank-line-before-class (conflicts with D211)
+    "D213",     # pydocstyle: multi-line-summary-second-line (conflicts with D212)
 ]
 [tool.ruff.lint.pep8-naming]
 classmethod-decorators = ["field_validator"]
 [tool.ruff.lint.per-file-ignores]
-"tests/*.py" = ["ANN", "S"]
+"tests/*.py" = ["ANN", "S", "D"]
 [tool.ruff.format]
 quote-style = "double"
 indent-style = "space"
 
 [tool.ty.environment]
-python-version = "3.13"
+python-version = "3.14"
 [[tool.ty.overrides]]
 include = ["tests/**"]
 [tool.ty.overrides.rules]

mm_http-0.3.1/src/mm_http/__init__.py

@@ -0,0 +1,7 @@
+"""HTTP client library with sync and async support."""
+
+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-0.2.5 → mm_http-0.3.1}/src/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-0.3.1/src/mm_http/request_sync.py

@@ -0,0 +1,68 @@
+"""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 .response import HttpResponse, TransportErrorType
+
+
+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, 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."""
+    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,
+            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 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-0.2.5 → mm_http-0.3.1}/src/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(enum.StrEnum):
+    """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,25 @@ 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."""
-        if self.body is None:
-            if none_on_error:
-                return None
-            raise ValueError("Body is None")
+    @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:
+            return Result.err("body is 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
+            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 get_header(self, name: str) -> str | None:
         """Get header value (case-insensitive)."""
@@ -101,11 +108,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.3.1/tests/conftest.py

@@ -0,0 +1,97 @@
+import json
+import os
+import time
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+from dotenv import load_dotenv
+from pytest_httpserver import HTTPServer
+from werkzeug import Request, Response
+
+load_dotenv()
+
+
+@pytest.fixture
+def proxy_http() -> str:
+    proxy = os.getenv("PROXY_HTTP")
+    if not proxy:
+        raise ValueError("PROXY_HTTP environment variable must be set")
+    return proxy
+
+
+@pytest.fixture
+def proxy_socks5() -> str:
+    proxy = os.getenv("PROXY_SOCKS5")
+    if not proxy:
+        raise ValueError("PROXY_SOCKS5 environment variable must be set")
+    return proxy
+
+
+@pytest.fixture
+def json_response_data() -> dict[str, Any]:
+    """Sample nested JSON for testing."""
+    return {
+        "user": {"id": 123, "profile": {"name": "John Doe", "email": "john@example.com"}},
+        "items": [{"id": 1, "value": "a"}, {"id": 2, "value": "b"}],
+        "nullable_field": None,
+        "count": 42,
+    }
+
+
+@pytest.fixture
+def setup_json_endpoint(httpserver: HTTPServer, json_response_data: dict[str, Any]) -> Callable[[], str]:
+    """Configure JSON endpoint that returns sample data."""
+
+    def setup() -> str:
+        httpserver.expect_request("/json").respond_with_json(json_response_data)
+        return httpserver.url_for("/json")
+
+    return setup
+
+
+@pytest.fixture
+def setup_text_endpoint(httpserver: HTTPServer) -> Callable[[str, int], str]:
+    """Configure text endpoint with custom content and status."""
+
+    def setup(content: str = "Hello, World!", status: int = 200) -> str:
+        httpserver.expect_request("/text").respond_with_data(content, status=status, content_type="text/plain")
+        return httpserver.url_for("/text")
+
+    return setup
+
+
+@pytest.fixture
+def setup_echo_endpoint(httpserver: HTTPServer) -> Callable[[], str]:
+    """Configure echo endpoint that returns request details."""
+
+    def handler(request: Request) -> Response:
+        echo_data = {
+            "method": request.method,
+            "path": request.path,
+            "query_string": request.query_string.decode("utf-8"),
+            "headers": dict(request.headers),
+            "body": request.get_data(as_text=True),
+        }
+        return Response(json.dumps(echo_data), content_type="application/json")
+
+    def setup() -> str:
+        httpserver.expect_request("/echo").respond_with_handler(handler)
+        return httpserver.url_for("/echo")
+
+    return setup
+
+
+@pytest.fixture
+def setup_timeout_endpoint(httpserver: HTTPServer) -> Callable[[float], str]:
+    """Configure delayed response endpoint for timeout tests."""
+
+    def setup(delay: float = 2.0) -> str:
+        def handler(_request: Request) -> Response:
+            time.sleep(delay)
+            return Response("OK", content_type="text/plain")
+
+        httpserver.expect_request("/timeout").respond_with_handler(handler)
+        return httpserver.url_for("/timeout")
+
+    return setup

mm_http-0.3.1/tests/helpers/__init__.py

@@ -0,0 +1 @@
+"""Test helpers package."""