memwal 0.1.11.dev7__tar.gz → 0.1.11.dev9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev7
+Version: 0.1.11.dev9
 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.dev9}/memwal/__init__.py

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

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

@@ -27,13 +27,16 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import hashlib
 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
 
@@ -134,6 +137,25 @@ def _reject_blank_text(text: object, message: str = "Text cannot be empty") -> N
         raise ValueError(message)
 
 
+IDEMPOTENCY_BUCKET_MS = 30 * 60 * 1000
+
+
+def _derived_idempotency_key(request_identity: str) -> str:
+    """Window over which the same (namespace, text) resolves to one key.
+
+    `_pending_remember_keys` only dedupes retries that reuse one client instance,
+    and callers such as sidecars or serverless functions build a fresh client
+    per session — so a random key lets a replay mint a second paid blob. The
+    bucket bounds the collapse: `remember_jobs` rows are never pruned, so an
+    unbucketed key would dedupe against a job from any point in history.
+
+    Matches TypeScript SDK derivedIdempotencyKey contract.
+    """
+    bucket = int(time.time() * 1000) // IDEMPOTENCY_BUCKET_MS
+    payload = f"{bucket}\0{request_identity}".encode("utf-8")
+    return f"r1-{hashlib.sha256(payload).hexdigest()}"
+
+
 def normalize_server_url(url: str) -> str:
     """Strip a trailing slash and warn on plaintext HTTP to a remote host.
 
@@ -199,18 +221,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:
@@ -431,9 +486,11 @@ class MemWal:
         resolved_namespace = namespace or self._namespace
         request_identity = f"{resolved_namespace}\0{text}"
         generated_key = idempotency_key is None
-        resolved_key = idempotency_key or self._pending_remember_keys.get(request_identity)
-        if resolved_key is None:
-            resolved_key = str(uuid.uuid4())
+        resolved_key = (
+            idempotency_key
+            or self._pending_remember_keys.get(request_identity)
+            or _derived_idempotency_key(request_identity)
+        )
         if generated_key:
             self._pending_remember_keys[request_identity] = resolved_key
 
@@ -463,6 +520,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 +559,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 +586,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":
@@ -558,12 +637,15 @@ class MemWal:
         ``failed``). Mirrors TS ``rememberAndWait``.
         """
 
+        _reject_blank_text(text)
         resolved_namespace = namespace or self._namespace
         request_identity = f"{resolved_namespace}\0{text}"
         generated_key = idempotency_key is None
-        resolved_key = idempotency_key or self._pending_remember_keys.get(request_identity)
-        if resolved_key is None:
-            resolved_key = str(uuid.uuid4())
+        resolved_key = (
+            idempotency_key
+            or self._pending_remember_keys.get(request_identity)
+            or _derived_idempotency_key(request_identity)
+        )
         if generated_key:
             self._pending_remember_keys[request_identity] = resolved_key
 
@@ -632,7 +714,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 +728,7 @@ class MemWal:
             "POST",
             "/api/remember/bulk/status",
             {"job_ids": list(job_ids)},
+            timeout=timeout,
         )
         return RememberBulkStatusResult(
             results=[
@@ -726,7 +811,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 +827,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 +854,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 +1614,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.
 
@@ -1535,7 +1635,6 @@ class MemWal:
             - ``x-account-id``: Walrus Memory account object ID
             - ``Content-Type``: application/json
         """
-        import uuid
 
         await self._ensure_compatible_relayer()
 
@@ -1575,6 +1674,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.dev9}/pyproject.toml

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

memwal-0.1.11.dev9/tests/test_remember_derived_key.py

@@ -0,0 +1,250 @@
+"""
+Tests for derived idempotency keys in Python SDK (GH #1094, WALM-800).
+
+Validates parity with TypeScript SDK specification:
+- An omitted idempotency_key is derived from bucket + namespace + text:
+  r1-{sha256(bucket \0 namespace \0 text)}
+- Repeated identical writes reuse the same idempotency key across client instances
+- Different texts or namespaces produce distinct keys
+- Explicit idempotency keys are respected
+- MemWalSync synchronous wrapper inherits the same behavior
+"""
+
+import hashlib
+import json
+import time
+from unittest.mock import patch
+
+import httpx
+import pytest
+import respx
+
+from memwal.client import (
+    IDEMPOTENCY_BUCKET_MS,
+    MemWal,
+    MemWalRememberJobTimeout,
+    MemWalSync,
+    _derived_idempotency_key,
+)
+from memwal.utils import bytes_to_hex
+
+_TEST_KEY_HEX = bytes_to_hex(b"\x01" * 32)
+_TEST_ACCOUNT_ID = "0xabc123"
+_TEST_SERVER = "http://localhost:8000"
+
+
+def _make_client(namespace: str = "default") -> MemWal:
+    client = MemWal.create(
+        key=_TEST_KEY_HEX,
+        account_id=_TEST_ACCOUNT_ID,
+        server_url=_TEST_SERVER,
+        namespace=namespace,
+    )
+    # Cache a valid seal session (expiry in milliseconds) to avoid needing live Sui RPC
+    client._session_cache = ("fake-seal-session", int(time.time() * 1000) + 3_600_000)
+    return client
+
+
+def _mock_version_and_config():
+    respx.get(f"{_TEST_SERVER}/version").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "apiVersion": "1.0.0",
+                "relayerVersion": "1.0.0",
+                "minSupportedSdk": {"python": "0.1.0"},
+            },
+        )
+    )
+    respx.get(f"{_TEST_SERVER}/config").mock(
+        return_value=httpx.Response(
+            200,
+            json={"packageId": "0x1", "network": "testnet"},
+        )
+    )
+
+
+def test_derived_idempotency_key_format_and_cross_language_parity():
+    """Verify byte-for-byte SHA256 digest parity with TypeScript SDK."""
+    bucket = 123456
+    request_identity = "default\0I am allergic to peanuts"
+
+    # Pre-calculated reference matching TypeScript:
+    # r1-${sha256("123456\0default\0I am allergic to peanuts")}
+    expected_digest = hashlib.sha256(f"{bucket}\0{request_identity}".encode("utf-8")).hexdigest()
+    expected_key = f"r1-{expected_digest}"
+    assert expected_key == "r1-8690455a552eca1cc0d77d60b2a7c2a05a2dd836874f5106b1c9967dc5adc083"
+
+    with patch("time.time", return_value=(bucket * IDEMPOTENCY_BUCKET_MS) / 1000.0):
+        actual_key = _derived_idempotency_key(request_identity)
+        assert actual_key == expected_key
+        assert actual_key.startswith("r1-")
+        assert len(actual_key) == 3 + 64
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_same_fact_reuses_one_idempotency_key_across_client_instances():
+    """Two instances build what sidecars or serverless functions run on reconnect.
+
+    A per-instance random uuid4 made the replay look like a new write, so the
+    relayer minted a second paid Walrus blob. The content-based derived key
+    ensures both send the identical key.
+    """
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        return httpx.Response(202, json={"job_id": "job-1", "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+    respx.get(f"{_TEST_SERVER}/api/remember/job-1").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "job_id": "job-1",
+                "status": "done",
+                "blob_id": "blob-1",
+                "owner": _TEST_ACCOUNT_ID,
+                "namespace": "default",
+            },
+        )
+    )
+
+    client1 = _make_client()
+    await client1.remember_and_wait("a durable fact")
+
+    client2 = _make_client()
+    await client2.remember_and_wait("a durable fact")
+
+    assert len(posted_bodies) == 2
+    assert posted_bodies[0]["idempotency_key"] == posted_bodies[1]["idempotency_key"]
+    assert posted_bodies[0]["idempotency_key"].startswith("r1-")
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_remember_async_reuses_derived_key():
+    """remember() (async accept) also derives the content key."""
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        job_id = f"job-{len(posted_bodies)}"
+        return httpx.Response(202, json={"job_id": job_id, "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+
+    client = _make_client()
+    await client.remember("user likes pizza")
+    await client.remember("user likes pizza")
+
+    assert len(posted_bodies) == 2
+    assert posted_bodies[0]["idempotency_key"] == posted_bodies[1]["idempotency_key"]
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_different_text_and_namespaces_get_different_keys():
+    """Distinct writes must not collapse onto one job."""
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        job_id = f"job-{len(posted_bodies)}"
+        return httpx.Response(202, json={"job_id": job_id, "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+
+    client = _make_client()
+    await client.remember("fact one")
+    await client.remember("fact two")
+    await client.remember("fact one", namespace="other-namespace")
+
+    keys = [b["idempotency_key"] for b in posted_bodies]
+    assert len(set(keys)) == 3, "distinct writes must produce distinct keys"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_explicit_idempotency_key_still_wins():
+    """When the caller passes an explicit key, that key is sent directly."""
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        return httpx.Response(202, json={"job_id": "job-explicit", "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+
+    client = _make_client()
+    await client.remember("a fact", idempotency_key="caller-owned-key")
+
+    assert len(posted_bodies) == 1
+    assert posted_bodies[0]["idempotency_key"] == "caller-owned-key"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_remember_and_wait_preserves_key_on_polling_timeout():
+    """If polling times out, the pending key stays in the map for immediate retry."""
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        return httpx.Response(202, json={"job_id": "slow-job", "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+    respx.get(f"{_TEST_SERVER}/api/remember/slow-job").mock(
+        return_value=httpx.Response(200, json={"job_id": "slow-job", "status": "running"})
+    )
+
+    client = _make_client()
+    with pytest.raises(MemWalRememberJobTimeout):
+        await client.remember_and_wait("timeout fact", poll_interval_ms=10, timeout_ms=50)
+
+    # Key must still be in pending map
+    request_identity = "default\0timeout fact"
+    assert request_identity in client._pending_remember_keys
+    pending_key = client._pending_remember_keys[request_identity]
+
+    # Retry uses the exact same pending key
+    with pytest.raises(MemWalRememberJobTimeout):
+        await client.remember_and_wait("timeout fact", poll_interval_ms=10, timeout_ms=50)
+
+    assert len(posted_bodies) == 2
+    assert posted_bodies[0]["idempotency_key"] == pending_key
+    assert posted_bodies[1]["idempotency_key"] == pending_key
+
+
+@respx.mock
+def test_sync_client_uses_derived_key():
+    """MemWalSync synchronous client derives and reuses content keys."""
+    _mock_version_and_config()
+    posted_bodies = []
+
+    def handle_remember(request: httpx.Request) -> httpx.Response:
+        posted_bodies.append(json.loads(request.content))
+        return httpx.Response(202, json={"job_id": "job-sync", "status": "pending"})
+
+    respx.post(f"{_TEST_SERVER}/api/remember").mock(side_effect=handle_remember)
+
+    sync_client = MemWalSync.create(
+        key=_TEST_KEY_HEX,
+        account_id=_TEST_ACCOUNT_ID,
+        server_url=_TEST_SERVER,
+        namespace="default",
+    )
+    sync_client._inner._session_cache = ("fake-seal-session", int(time.time() * 1000) + 3_600_000)
+
+    sync_client.remember("sync fact")
+    sync_client.remember("sync fact")
+
+    assert len(posted_bodies) == 2
+    assert posted_bodies[0]["idempotency_key"] == posted_bodies[1]["idempotency_key"]
+    assert posted_bodies[0]["idempotency_key"].startswith("r1-")

memwal-0.1.11.dev9/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.dev9/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 "")