memwal 0.2.2.dev0__tar.gz → 0.2.2.dev1__tar.gz

{memwal-0.2.2.dev0 → memwal-0.2.2.dev1}/CHANGELOG.md

@@ -11,6 +11,7 @@ Unreleased.
 ### Fixed
 
 - Shield shared `_build_seal_session` and `_resolve_owner` initialization tasks with `asyncio.shield`, clear the shared task slot via a completion callback that consumes exceptions on orphaned tasks, and cancel/drain in-flight initialization tasks in `close()` so cancelling one concurrent caller does not abort sibling callers or leave unretrieved task exceptions. (#1029)
+- `health`, `ask`, `restore`, `list_namespaces`, `remember_manual`, and `recall` raise `MemWalError` naming the endpoint and field when a 2xx response omits a required field. They used to raise a bare `KeyError` that callers catching `MemWalError` never saw. (#1250, #1256)
 
 ## 0.2.1
 

{memwal-0.2.2.dev0 → memwal-0.2.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.2.2.dev0
+Version: 0.2.2.dev1
 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.2.2.dev0 → memwal-0.2.2.dev1}/memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.2.2.dev0"
+__version__ = "0.2.2.dev1"

{memwal-0.2.2.dev0 → memwal-0.2.2.dev1}/memwal/client.py

@@ -142,6 +142,24 @@ def _reject_blank_text(text: object, message: str = "Text cannot be empty") -> N
         raise ValueError(message)
 
 
+def _require(data: object, field: str, endpoint: str) -> Any:
+    """``data[field]`` from a parsed 2xx body, or a ``MemWalError`` naming both.
+
+    A bare ``KeyError`` is not a ``MemWalError``, carries only the field name,
+    and is raised far from the response that caused it (#1250). Optional
+    fields keep using ``.get()`` with a documented default.
+    """
+
+    if not isinstance(data, dict):
+        raise MemWalError(
+            f"{endpoint} response was {type(data).__name__}, expected an object "
+            f"with {field!r}"
+        )
+    if field not in data:
+        raise MemWalError(f"{endpoint} response missing {field!r}")
+    return data[field]
+
+
 IDEMPOTENCY_BUCKET_MS = 30 * 60 * 1000
 
 
@@ -1189,9 +1207,9 @@ class MemWal:
         data = await self._signed_request("POST", "/api/recall", body)
         memories = [
             RecallMemory(
-                blob_id=m["blob_id"],
-                text=m["text"],
-                distance=m["distance"],
+                blob_id=_require(m, "blob_id", "POST /api/recall"),
+                text=_require(m, "text", "POST /api/recall"),
+                distance=_require(m, "distance", "POST /api/recall"),
                 score=m.get("score"),
                 created_at=m.get("created_at"),
             )
@@ -1359,12 +1377,16 @@ class MemWal:
             "namespace": self._resolve_namespace(namespace),
         })
         memories = [
-            AskMemory(blob_id=m["blob_id"], text=m["text"], distance=m["distance"])
+            AskMemory(
+                blob_id=_require(m, "blob_id", "POST /api/ask"),
+                text=_require(m, "text", "POST /api/ask"),
+                distance=_require(m, "distance", "POST /api/ask"),
+            )
             for m in data.get("memories", [])
         ]
         return AskResult(
-            answer=data["answer"],
-            memories_used=data["memories_used"],
+            answer=_require(data, "answer", "POST /api/ask"),
+            memories_used=_require(data, "memories_used", "POST /api/ask"),
             memories=memories,
         )
 
@@ -1424,12 +1446,13 @@ class MemWal:
             "namespace": namespace,
             "limit": limit,
         })
+        endpoint = "POST /api/restore"
         return RestoreResult(
-            restored=data["restored"],
-            skipped=data["skipped"],
-            total=data["total"],
-            namespace=data["namespace"],
-            owner=data["owner"],
+            restored=_require(data, "restored", endpoint),
+            skipped=_require(data, "skipped", endpoint),
+            total=_require(data, "total", endpoint),
+            namespace=_require(data, "namespace", endpoint),
+            owner=_require(data, "owner", endpoint),
             # Relayers older than WALM-319 omit `truncated` entirely --
             # treat "not present" as "not known to be truncated" rather
             # than require every relayer version to send it.
@@ -1492,20 +1515,21 @@ class MemWal:
         # against `path_and_query`, not `path`.
         path = f"/v1/owners/{owner}/namespaces" + (f"?{query}" if query else "")
         data = await self._signed_request("GET", path, {}, include_seal_session=False)
+        endpoint = "GET /v1/owners/{owner}/namespaces"
         return NamespacesResult(
             namespaces=[
                 NamespaceSummary(
-                    id=ns["id"],
-                    name=ns["name"],
-                    memory_count=ns["memory_count"],
-                    storage_used=ns["storage_used"],
-                    updated_at=ns["updated_at"],
+                    id=_require(ns, "id", endpoint),
+                    name=_require(ns, "name", endpoint),
+                    memory_count=_require(ns, "memory_count", endpoint),
+                    storage_used=_require(ns, "storage_used", endpoint),
+                    updated_at=_require(ns, "updated_at", endpoint),
                 )
-                for ns in data["namespaces"]
+                for ns in _require(data, "namespaces", endpoint)
             ],
             next_cursor=data.get("next_cursor"),
-            has_more=data["has_more"],
-            snapshot_version=data["snapshot_version"],
+            has_more=_require(data, "has_more", endpoint),
+            snapshot_version=_require(data, "snapshot_version", endpoint),
         )
 
     async def health(self) -> HealthResult:
@@ -1523,8 +1547,8 @@ class MemWal:
             raise MemWalError(f"Health check failed: {response.status_code}")
         data = response.json()
         return HealthResult(
-            status=data["status"],
-            version=data["version"],
+            status=_require(data, "status", "GET /health"),
+            version=_require(data, "version", "GET /health"),
             relayer_version=data.get("relayerVersion"),
             api_version=data.get("apiVersion"),
             min_supported_sdk=data.get("minSupportedSdk"),
@@ -1569,11 +1593,12 @@ class MemWal:
             },
             include_seal_session=False,
         )
+        endpoint = "POST /api/remember/manual"
         return RememberManualResult(
-            id=data["id"],
-            blob_id=data["blob_id"],
-            owner=data["owner"],
-            namespace=data["namespace"],
+            id=_require(data, "id", endpoint),
+            blob_id=_require(data, "blob_id", endpoint),
+            owner=_require(data, "owner", endpoint),
+            namespace=_require(data, "namespace", endpoint),
         )
 
     async def recall_manual(self, opts: RecallManualOptions) -> RecallManualResult:

{memwal-0.2.2.dev0 → memwal-0.2.2.dev1}/pyproject.toml

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

memwal-0.2.2.dev1/tests/test_missing_response_fields.py

@@ -0,0 +1,125 @@
+"""A 2xx body missing a required field raises ``MemWalError`` (#1250).
+
+#1219 covers 2xx bodies that are not JSON. This is the valid-JSON sibling:
+six methods subscripted response fields directly, so a relayer that drifted
+or a proxy rewriting the body surfaced as a bare ``KeyError`` that callers
+catching ``MemWalError`` (the documented error type) never saw.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import httpx
+import nacl.signing
+import pytest
+import respx
+
+from memwal import MemWal, MemWalError
+from memwal.types import RememberManualOptions
+from memwal.utils import bytes_to_hex
+
+_SERVER = "https://relayer.example"
+_KEY_HEX = bytes_to_hex(bytes(nacl.signing.SigningKey(b"\x01" * 32)))
+
+
+def _client(body: Any) -> MemWal:
+    client = MemWal.create(key=_KEY_HEX, account_id="0x1", server_url=_SERVER)
+
+    async def fake_signed_request(method, path, req_body, **kwargs):  # type: ignore[no-untyped-def]
+        return body
+
+    async def fake_owner() -> str:
+        return "0xowner"
+
+    client._signed_request = fake_signed_request  # type: ignore[method-assign]
+    client._resolve_owner = fake_owner  # type: ignore[method-assign]
+    return client
+
+
+def _assert_names(exc: pytest.ExceptionInfo[MemWalError], endpoint: str, field: str) -> None:
+    assert not isinstance(exc.value, KeyError)
+    message = str(exc.value)
+    assert endpoint in message, message
+    assert field in message, message
+
+
+@respx.mock
+async def test_health_missing_status() -> None:
+    respx.get(f"{_SERVER}/health").mock(return_value=httpx.Response(200, json={}))
+    client = MemWal.create(key=_KEY_HEX, account_id="0x1", server_url=_SERVER)
+    with pytest.raises(MemWalError) as exc:
+        await client.health()
+    _assert_names(exc, "GET /health", "status")
+
+
+@respx.mock
+async def test_health_non_object_body() -> None:
+    respx.get(f"{_SERVER}/health").mock(return_value=httpx.Response(200, json=["ok"]))
+    client = MemWal.create(key=_KEY_HEX, account_id="0x1", server_url=_SERVER)
+    with pytest.raises(MemWalError) as exc:
+        await client.health()
+    _assert_names(exc, "GET /health", "status")
+
+
+async def test_ask_missing_memories_used() -> None:
+    with pytest.raises(MemWalError) as exc:
+        await _client({"answer": "hi"}).ask("q?")
+    _assert_names(exc, "POST /api/ask", "memories_used")
+
+
+async def test_ask_memory_entry_missing_text() -> None:
+    body = {"answer": "hi", "memories_used": 1, "memories": [{"blob_id": "b", "distance": 0.1}]}
+    with pytest.raises(MemWalError) as exc:
+        await _client(body).ask("q?")
+    _assert_names(exc, "POST /api/ask", "text")
+
+
+async def test_restore_missing_restored() -> None:
+    with pytest.raises(MemWalError) as exc:
+        await _client({}).restore("ns")
+    _assert_names(exc, "POST /api/restore", "restored")
+
+
+async def test_list_namespaces_missing_namespaces() -> None:
+    with pytest.raises(MemWalError) as exc:
+        await _client({}).list_namespaces()
+    _assert_names(exc, "namespaces", "namespaces")
+
+
+async def test_list_namespaces_entry_missing_name() -> None:
+    body: Dict[str, Any] = {
+        "namespaces": [{"id": "ns-1"}],
+        "has_more": False,
+        "snapshot_version": 1,
+    }
+    with pytest.raises(MemWalError) as exc:
+        await _client(body).list_namespaces()
+    _assert_names(exc, "GET /v1/owners/", "name")
+
+
+async def test_remember_manual_missing_id() -> None:
+    opts = RememberManualOptions(encrypted_data="ZGF0YQ==", vector=[0.1])
+    with pytest.raises(MemWalError) as exc:
+        await _client({}).remember_manual(opts)
+    _assert_names(exc, "POST /api/remember/manual", "id")
+
+
+async def test_recall_entry_missing_text() -> None:
+    body = {"results": [{"blob_id": "b", "distance": 0.1}], "total": 1}
+    with pytest.raises(MemWalError) as exc:
+        await _client(body).recall("coffee")
+    _assert_names(exc, "POST /api/recall", "text")
+
+
+async def test_well_formed_bodies_still_parse() -> None:
+    ask = await _client({"answer": "hi", "memories_used": 0}).ask("q?")
+    assert ask.answer == "hi" and ask.memories == []
+    recall = await _client(
+        {"results": [{"blob_id": "b", "text": "t", "distance": 0.1}], "total": 1}
+    ).recall("coffee")
+    assert recall.results[0].text == "t"
+    restore = await _client(
+        {"restored": 1, "skipped": 0, "total": 1, "namespace": "ns", "owner": "0xo"}
+    ).restore("ns")
+    assert restore.truncated is False and restore.failed == 0