memwal 0.1.11.dev7__tar.gz → 0.1.11.dev8__tar.gz

{memwal-0.1.11.dev7 → memwal-0.1.11.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev7
+Version: 0.1.11.dev8
 Summary: Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memory.walrus.xyz
 Project-URL: Documentation, https://memory.walrus.xyz

{memwal-0.1.11.dev7 → memwal-0.1.11.dev8}/memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.11.dev7"
+__version__ = "0.1.11.dev8"

{memwal-0.1.11.dev7 → memwal-0.1.11.dev8}/memwal/client.py

@@ -29,11 +29,13 @@ import asyncio
 import base64
 import json
 import logging
+import math
 import random
 import re
 import time
 import uuid
 from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TypeVar, Union
 from urllib.parse import ParseResult, urlencode, urlparse
 
@@ -199,18 +201,51 @@ def _positive_retry_ms(raw: object) -> Optional[int]:
         seconds = float(raw)  # type: ignore[arg-type]
     except (TypeError, ValueError):
         return None
-    if seconds <= 0 or seconds != seconds or seconds == float("inf"):
+    if seconds <= 0 or math.isnan(seconds) or math.isinf(seconds):
+        return None
+    try:
+        ms = seconds * 1000.0
+        if math.isinf(ms) or math.isnan(ms):
+            return None
+        return int(ms)
+    except (OverflowError, ValueError):
+        return None
+
+
+def _http_date_retry_ms(raw: object) -> Optional[int]:
+    if not isinstance(raw, str):
+        return None
+    try:
+        dt = parsedate_to_datetime(raw)
+        if dt is None:
+            return None
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        target_ts = dt.timestamp()
+        # HTTP-date is absolute wall-clock time, so we deliberately compare against
+        # time.time() rather than monotonic _now_ms().
+        now_ts = time.time()
+        diff = target_ts - now_ts
+        if diff <= 0 or math.isnan(diff) or math.isinf(diff):
+            return None
+        ms = diff * 1000.0
+        if math.isinf(ms) or math.isnan(ms):
+            return None
+        return int(ms)
+    except Exception:
         return None
-    return int(seconds * 1000)
 
 
 def _retry_after_ms(err: "_HttpStatusError") -> int:
-    """Retry-After seconds, else JSON ``retry_after_seconds``, in ms."""
+    """Retry-After seconds or HTTP-date, else JSON ``retry_after_seconds``, in ms."""
 
     if err.retry_after:
         header_ms = _positive_retry_ms(err.retry_after)
         if header_ms is not None:
             return header_ms
+        date_ms = _http_date_retry_ms(err.retry_after)
+        if date_ms is not None:
+            return date_ms
     if not err.body:
         return 0
     try:
@@ -463,6 +498,10 @@ class MemWal:
     ) -> RememberAcceptedResult:
         return await self.remember(text, namespace, idempotency_key)
 
+    def _poll_deadline_s(self, deadline_ms: int) -> float:
+        remaining_s = (deadline_ms - _now_ms()) / 1000.0
+        return max(0.001, min(60.0, remaining_s))
+
     async def wait_for_remember_job(
         self,
         job_id: str,
@@ -498,12 +537,25 @@ class MemWal:
             retry_after_ms = 0
 
             try:
-                data = await self._signed_request(
-                    "GET",
-                    f"/api/remember/{job_id}",
-                    {},
-                    accepted_statuses=(200, 404),
-                )
+                poll_timeout = self._poll_deadline_s(deadline_ms)
+                try:
+                    data = await self._signed_request(
+                        "GET",
+                        f"/api/remember/{job_id}",
+                        {},
+                        accepted_statuses=(200, 404),
+                        timeout=poll_timeout,
+                    )
+                except TypeError as err:
+                    if "unexpected keyword argument" in str(err) and "timeout" in str(err):
+                        data = await self._signed_request(
+                            "GET",
+                            f"/api/remember/{job_id}",
+                            {},
+                            accepted_statuses=(200, 404),
+                        )
+                    else:
+                        raise
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
                     last_refusal = err.status
@@ -512,6 +564,11 @@ class MemWal:
                         retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
                     continue
                 raise
+            except httpx.TransportError:
+                # Network drops retry as status 0; continuing next loop iteration
+                # increments `attempt` so exponential backoff delay continues to grow.
+                last_refusal = 0
+                continue
 
             status_str = data.get("status")
             if status_str is None or status_str == "not_found":
@@ -632,7 +689,9 @@ class MemWal:
         return await self.remember_bulk_async(items)
 
     async def get_remember_bulk_status(
-        self, job_ids: Sequence[str]
+        self,
+        job_ids: Sequence[str],
+        timeout: Optional[float] = None,
     ) -> RememberBulkStatusResult:
         """Poll the bulk-status endpoint for a batch of job_ids.
 
@@ -644,6 +703,7 @@ class MemWal:
             "POST",
             "/api/remember/bulk/status",
             {"job_ids": list(job_ids)},
+            timeout=timeout,
         )
         return RememberBulkStatusResult(
             results=[
@@ -726,7 +786,14 @@ class MemWal:
             retry_after_ms = 0
 
             try:
-                batch = await self.get_remember_bulk_status(pending)
+                poll_timeout = self._poll_deadline_s(deadline_ms)
+                try:
+                    batch = await self.get_remember_bulk_status(pending, timeout=poll_timeout)
+                except TypeError as err:
+                    if "unexpected keyword argument" in str(err) and "timeout" in str(err):
+                        batch = await self.get_remember_bulk_status(pending)
+                    else:
+                        raise
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
                     last_refusal = err.status
@@ -735,6 +802,11 @@ class MemWal:
                         retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
                     continue
                 raise
+            except httpx.TransportError:
+                # Network drops retry as status 0; continuing next loop iteration
+                # increments `attempt` so exponential backoff delay continues to grow.
+                last_refusal = 0
+                continue
             answered = True
 
             terminal_ids: Set[str] = {
@@ -757,6 +829,8 @@ class MemWal:
                     retry_after = f"{wait_ms / 1000:g}" if wait_ms else None
                     raise MemWalRateLimited(job_ids, retry_after) from err
                 # Any other probe failure is not evidence about the jobs.
+            except httpx.TransportError:
+                pass
             else:
                 answered = True
                 settled = {
@@ -1515,6 +1589,7 @@ class MemWal:
         body: Dict[str, Any],
         accepted_statuses: tuple = (200,),
         include_seal_session: bool = True,
+        timeout: Optional[float] = None,
     ) -> Dict[str, Any]:
         """Make a signed request to the server.
 
@@ -1575,6 +1650,7 @@ class MemWal:
             url=url,
             headers=headers,
             content=None if method_upper == "GET" else body_str,
+            timeout=timeout,
         )
 
         if response.status_code not in accepted_statuses:

{memwal-0.1.11.dev7 → memwal-0.1.11.dev8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.11.dev7"
+version = "0.1.11.dev8"
 description = "Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing"
 readme = "README.md"
 license = "MIT"

memwal-0.1.11.dev8/tests/test_retry_after_http_date.py

@@ -0,0 +1,160 @@
+"""Tests for HTTP-date Retry-After header parsing and arithmetic overflow protection."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
+from typing import Optional
+
+import pytest
+
+from memwal.client import (
+    MemWal,
+    _clamped_retry_after_ms,
+    _HttpStatusError,
+    _positive_retry_ms,
+    _retry_after_ms,
+)
+
+
+def _err(
+    retry_after: Optional[str] = None,
+    body: Optional[str] = None,
+) -> _HttpStatusError:
+    return _HttpStatusError(429, body or "{}", retry_after=retry_after)
+
+
+def test_positive_retry_ms_delta_seconds() -> None:
+    assert _positive_retry_ms("45") == 45000
+    assert _positive_retry_ms(45) == 45000
+    assert _positive_retry_ms("0.5") == 500
+    assert _positive_retry_ms(0.25) == 250
+
+
+def test_positive_retry_ms_invalid_or_non_positive() -> None:
+    assert _positive_retry_ms(0) is None
+    assert _positive_retry_ms("0") is None
+    assert _positive_retry_ms("-5") is None
+    assert _positive_retry_ms("invalid") is None
+    assert _positive_retry_ms(None) is None
+    assert _positive_retry_ms(float("nan")) is None
+    assert _positive_retry_ms(float("inf")) is None
+
+
+def test_positive_retry_ms_overflow_protection() -> None:
+    # 1e308 is finite float, but 1e308 * 1000 overflows to infinity
+    assert _positive_retry_ms("1e308") is None
+    assert _positive_retry_ms(1e308) is None
+
+
+def test_retry_after_http_date_in_future() -> None:
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=45)
+    future_header = format_datetime(future_time, usegmt=True)
+
+    err = _err(retry_after=future_header)
+    delay = _retry_after_ms(err)
+    # Delay should be approximately 45,000 ms (allowing slight test execution variance)
+    assert 40000 <= delay <= 46000
+
+
+def test_retry_after_http_date_takes_priority_over_json() -> None:
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=60)
+    future_header = format_datetime(future_time, usegmt=True)
+    body = '{"retry_after_seconds": 10}'
+
+    err = _err(retry_after=future_header, body=body)
+    delay = _retry_after_ms(err)
+    assert 55000 <= delay <= 61000
+
+
+def test_retry_after_http_date_in_past_falls_back_to_json() -> None:
+    past_time = datetime.now(timezone.utc) - timedelta(seconds=10)
+    past_header = format_datetime(past_time, usegmt=True)
+    body = '{"retry_after_seconds": 15}'
+
+    err = _err(retry_after=past_header, body=body)
+    assert _retry_after_ms(err) == 15000
+
+
+def test_retry_after_http_date_in_past_returns_zero_when_no_json() -> None:
+    past_time = datetime.now(timezone.utc) - timedelta(seconds=10)
+    past_header = format_datetime(past_time, usegmt=True)
+
+    err = _err(retry_after=past_header)
+    assert _retry_after_ms(err) == 0
+
+
+def test_retry_after_malformed_header_falls_back_to_json() -> None:
+    err = _err(retry_after="Not A Valid Date Or Number", body='{"retry_after_seconds": 25}')
+    assert _retry_after_ms(err) == 25000
+
+
+def test_retry_after_malformed_header_without_json_returns_zero() -> None:
+    err = _err(retry_after="invalid-header")
+    assert _retry_after_ms(err) == 0
+
+
+def test_retry_after_overflowing_number_falls_back_to_json() -> None:
+    err = _err(retry_after="1e308", body='{"retry_after_seconds": 30}')
+    assert _retry_after_ms(err) == 30000
+
+
+def test_clamped_retry_after_ms_with_http_date(monkeypatch: pytest.MonkeyPatch) -> None:
+    fixed_now = 1_000_000
+    monkeypatch.setattr("memwal.client._now_ms", lambda: fixed_now)
+
+    # Future date roughly 50s ahead
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=50)
+    future_header = format_datetime(future_time, usegmt=True)
+    err = _err(retry_after=future_header)
+
+    # If remaining time is only 20s (deadline 1,020,000), clamped to 20,000
+    clamped = _clamped_retry_after_ms(err, deadline_ms=fixed_now + 20_000)
+    assert clamped == 20_000
+
+    # If remaining time is 100s, delay (~50,000 ms) is used
+    clamped_large = _clamped_retry_after_ms(err, deadline_ms=fixed_now + 100_000)
+    assert 45_000 <= clamped_large <= 51_000
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_honors_http_date_retry_after(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fixed_ts = 1700000000.0
+    monkeypatch.setattr("time.time", lambda: fixed_ts)
+    clock = {"now": int(fixed_ts * 1000)}
+    slept: list[int] = []
+
+    def fake_now_ms() -> int:
+        return clock["now"]
+
+    async def fake_sleep_ms(ms: int) -> None:
+        slept.append(ms)
+        clock["now"] += ms
+
+    monkeypatch.setattr("memwal.client._now_ms", fake_now_ms)
+    monkeypatch.setattr("memwal.client._sleep_ms", fake_sleep_ms)
+
+    client = MemWal.create(key="11" * 32, account_id="0x1", server_url="http://localhost:8000")
+    calls = {"n": 0}
+
+    # 429 Retry-After is 2 seconds into future
+    future_dt = datetime.fromtimestamp(fixed_ts, tz=timezone.utc) + timedelta(seconds=2)
+    http_date = format_datetime(future_dt, usegmt=True)
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise _HttpStatusError(429, "{}", retry_after=http_date)
+        return {"job_id": "job-1", "status": "done", "blob_id": "b-1"}
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    res = await client.wait_for_remember_job("job-1", timeout_ms=10_000)
+    assert res.blob_id == "b-1"
+    assert calls["n"] == 2
+    # First sleep is attempt 0 (0 ms), second sleep should be 2000 ms from Retry-After
+    assert len(slept) == 2
+    assert slept[0] == 0
+    assert slept[1] == 2000

memwal-0.1.11.dev8/tests/test_transport_retry.py

@@ -0,0 +1,195 @@
+"""Tests for network transport error retry and deadline bounding.
+
+Covers WALM-696 and GH #1000.
+"""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from memwal.client import (
+    MemWal,
+    MemWalRememberJobTimeout,
+    RememberBulkOptions,
+)
+
+
+def _client() -> MemWal:
+    return MemWal.create(key="11" * 32, account_id="0x1", server_url="http://localhost:8000")
+
+
+def _patch_clock(monkeypatch: pytest.MonkeyPatch) -> tuple[dict[str, int], list[int]]:
+    clock = {"now": 0}
+    slept: list[int] = []
+
+    def now_ms() -> int:
+        return clock["now"]
+
+    async def sleep_ms(ms: int) -> None:
+        slept.append(ms)
+        clock["now"] += ms
+
+    monkeypatch.setattr("memwal.client._now_ms", now_ms)
+    monkeypatch.setattr("memwal.client._sleep_ms", sleep_ms)
+    return clock, slept
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_retries_connect_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ConnectError("simulated connection drop")
+        return {
+            "job_id": "job-1",
+            "status": "done",
+            "blob_id": "blob-1",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    done = await client.wait_for_remember_job("job-1", poll_interval_ms=100, timeout_ms=5000)
+    assert done.blob_id == "blob-1"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_retries_read_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ReadTimeout("simulated socket read timeout")
+        return {
+            "job_id": "job-2",
+            "status": "done",
+            "blob_id": "blob-2",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    done = await client.wait_for_remember_job("job-2", poll_interval_ms=100, timeout_ms=5000)
+    assert done.blob_id == "blob-2"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_times_out_with_http_0_message(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock, slept = _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def failing(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        clock["now"] += 100
+        raise httpx.ConnectError("network unreachable")
+
+    monkeypatch.setattr(client, "_signed_request", failing)
+
+    with pytest.raises(MemWalRememberJobTimeout) as exc_info:
+        await client.wait_for_remember_job("job-fail", poll_interval_ms=100, timeout_ms=500)
+
+    err = exc_info.value
+    assert err.last_refusal == 0
+    assert err.status == 504
+    assert "last poll: HTTP 0" in str(err)
+    assert calls["n"] > 1
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_bounds_poll_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    clock, _ = _patch_clock(monkeypatch)
+    client = _client()
+    captured_timeouts: list[float] = []
+
+    async def capture(*_args: object, **kwargs: object) -> dict:
+        timeout = kwargs.get("timeout")
+        if timeout is not None:
+            captured_timeouts.append(timeout)
+        return {
+            "job_id": "job-bound",
+            "status": "done",
+            "blob_id": "blob-bound",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", capture)
+
+    clock["now"] = 1000
+    # timeout_ms=2000 -> deadline=3000 -> remaining=2.0s
+    await client.wait_for_remember_job("job-bound", timeout_ms=2000)
+    assert len(captured_timeouts) == 1
+    assert captured_timeouts[0] == pytest.approx(2.0, rel=1e-2)
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_jobs_bulk_retries_transport_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def bulk_status(job_ids: list[str], timeout: float | None = None):
+        from memwal.types import RememberBulkStatusItem, RememberBulkStatusResult
+
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ConnectError("simulated bulk network drop")
+        return RememberBulkStatusResult(
+            results=[
+                RememberBulkStatusItem(
+                    job_id="bulk-1",
+                    status="done",
+                    blob_id="blob-bulk-1",
+                )
+            ]
+        )
+
+    monkeypatch.setattr(client, "get_remember_bulk_status", bulk_status)
+
+    res = await client.wait_for_remember_jobs(
+        ["bulk-1"],
+        opts=RememberBulkOptions(poll_interval_ms=100, timeout_ms=5000),
+    )
+    assert len(res.results) == 1
+    assert res.results[0].status == "done"
+    assert res.results[0].blob_id == "blob-bulk-1"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_jobs_bulk_timeout_on_persistent_transport_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock, _ = _patch_clock(monkeypatch)
+    client = _client()
+
+    async def bulk_failing(job_ids: list[str], timeout: float | None = None):
+        clock["now"] += 100
+        raise httpx.ConnectError("persistent bulk network drop")
+
+    monkeypatch.setattr(client, "get_remember_bulk_status", bulk_failing)
+
+    res = await client.wait_for_remember_jobs(
+        ["bulk-dead"],
+        opts=RememberBulkOptions(poll_interval_ms=100, timeout_ms=500),
+    )
+    assert len(res.results) == 1
+    assert res.results[0].status == "timeout"
+    assert "last poll: HTTP 0" in (res.results[0].error or "")