memwal 0.1.11.dev8__tar.gz → 0.1.11.dev9__tar.gz

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

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

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

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

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import hashlib
 import json
 import logging
 import math
@@ -136,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.
 
@@ -466,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
 
@@ -615,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
 
@@ -1610,7 +1635,6 @@ class MemWal:
             - ``x-account-id``: Walrus Memory account object ID
             - ``Content-Type``: application/json
         """
-        import uuid
 
         await self._ensure_compatible_relayer()
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.11.dev8"
+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-")