memwal 0.1.11.dev9__tar.gz → 0.1.11.dev11__tar.gz

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/CHANGELOG.md

@@ -2,8 +2,13 @@
 
 ## Unreleased
 
+### Added
+
+- `get_remember_status(job_id)` on `MemWal` and `MemWalSync` returns `RememberJobStatus` from `GET /api/remember/{job_id}`, accepting 200 and 404 like the TypeScript SDK. (WALM-832, #1096)
+
 ### Fixed
 
+- `get_remember_status` and `wait_for_remember_job` reject a job id outside `[A-Za-z0-9_-]+` before the request. `.`, `..`, a backslash, and encoded dot-dot used to pass a denylist and be rewritten after signing. An empty id used to call `GET /api/remember/` and raise `json.JSONDecodeError`. An unparseable 404 is `not_found` / `MemWalRememberJobNotFound`, not a JSON error. `uuid.UUID` is coerced with `str()`. Valid UUID job ids are unchanged. (WALM-833, #1100, #1216)
 - `remember`, `remember_bulk`, `analyze`, and `embed` reject whitespace-only text before the request. A blank body used to be accepted and then sit until the caller timed out. (#1129)
 - A 401 `AUTH_REJECTED` now says a wallet address is not a MemWal account ID. (#1132)
 - `wait_for_remember_jobs` / `remember_bulk_and_wait` no longer return a batch they could not read as if it were still uploading. When every status poll is rate-limited, the wait makes one confirming read and raises `MemWalRateLimited` (`status` 429, `job_ids`, `retry_after`) if that is refused too. An item still unsettled at the deadline names its last known status, or says no read got through. (WALM-671, #967)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev9
+Version: 0.1.11.dev11
 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
@@ -240,6 +240,7 @@ Create a new async client.
 | Method | Description |
 |--------|-------------|
 | `await remember(text, namespace?)` | Accept a background remember job and return `job_id` |
+| `await get_remember_status(job_id)` | Read one remember job without waiting |
 | `await wait_for_remember_job(job_id, ...)` | Poll one remember job until it is searchable |
 | `await remember_and_wait(text, namespace?, ...)` | Store a memory and wait until it is searchable |
 | `await remember_bulk(items)` | Accept several background remember jobs |

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/README.md

@@ -201,6 +201,7 @@ Create a new async client.
 | Method | Description |
 |--------|-------------|
 | `await remember(text, namespace?)` | Accept a background remember job and return `job_id` |
+| `await get_remember_status(job_id)` | Read one remember job without waiting |
 | `await wait_for_remember_job(job_id, ...)` | Poll one remember job until it is searchable |
 | `await remember_and_wait(text, namespace?, ...)` | Store a memory and wait until it is searchable |
 | `await remember_bulk(items)` | Accept several background remember jobs |

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/memwal/__init__.py

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

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

@@ -69,6 +69,7 @@ from .types import (
     RememberBulkResult,
     RememberBulkStatusItem,
     RememberBulkStatusResult,
+    RememberJobStatus,
     RememberManualOptions,
     RememberManualResult,
     RememberResult,
@@ -156,6 +157,36 @@ def _derived_idempotency_key(request_identity: str) -> str:
     return f"r1-{hashlib.sha256(payload).hexdigest()}"
 
 
+def _require_remember_job_id(job_id: object) -> str:
+    """String form of a remember job id.
+
+    ``uuid.UUID`` used to interpolate into the path and still does. Any other
+    non-string is a type mistake: ``not_found`` would hide a job that exists.
+    """
+
+    if isinstance(job_id, uuid.UUID):
+        return str(job_id)
+    if not isinstance(job_id, str):
+        raise TypeError(
+            f"remember job id must be a string, got {type(job_id).__name__}"
+        )
+    return job_id
+
+
+def _remember_status_path(job_id: str) -> Optional[str]:
+    """``/api/remember/{job_id}`` when the id is one safe segment, else None.
+
+    httpx rewrites the path after it is signed. ``.`` requests
+    ``/api/remember``, ``..`` requests ``/api``, and a NUL raises
+    ``InvalidURL``. An allowlist keeps those from leaving the client. A
+    normal UUID is unchanged. (#1100, #1216)
+    """
+
+    if re.fullmatch(r"[A-Za-z0-9_-]+", job_id) is None:
+        return None
+    return f"/api/remember/{job_id}"
+
+
 def normalize_server_url(url: str) -> str:
     """Strip a trailing slash and warn on plaintext HTTP to a remote host.
 
@@ -524,6 +555,55 @@ class MemWal:
         remaining_s = (deadline_ms - _now_ms()) / 1000.0
         return max(0.001, min(60.0, remaining_s))
 
+    async def get_remember_status(self, job_id: str) -> RememberJobStatus:
+        """One-shot lookup of a remember job. Mirrors TS ``getRememberStatus``.
+
+        ``GET /api/remember/{job_id}``, accepting 200 and 404. A 404, or a
+        body with no ``status``, is ``not_found`` — not an exception. A job
+        id outside ``[A-Za-z0-9_-]+`` is ``not_found`` without a request.
+        """
+
+        job_id = _require_remember_job_id(job_id)
+        path = _remember_status_path(job_id)
+        if path is None:
+            return RememberJobStatus(
+                job_id=job_id,
+                status="not_found",
+                error=f"Job {job_id} not found",
+            )
+        try:
+            data = await self._signed_request(
+                "GET",
+                path,
+                {},
+                accepted_statuses=(200, 404),
+                # Status is metadata. No SEAL decrypt, so no session. Matches TS.
+                include_seal_session=False,
+            )
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            data = None
+        if not isinstance(data, dict):
+            return RememberJobStatus(
+                job_id=job_id,
+                status="not_found",
+                error=f"remember job not found: {job_id}",
+            )
+        status = data.get("status")
+        if not status:
+            return RememberJobStatus(
+                job_id=data.get("job_id") or job_id,
+                status="not_found",
+                error=data.get("error") or f"remember job not found: {job_id}",
+            )
+        return RememberJobStatus(
+            job_id=data.get("job_id", job_id),
+            status=status,
+            owner=data.get("owner"),
+            namespace=data.get("namespace"),
+            blob_id=data.get("blob_id"),
+            error=data.get("error"),
+        )
+
     async def wait_for_remember_job(
         self,
         job_id: str,
@@ -542,6 +622,11 @@ class MemWal:
         - First poll is immediate; later polls grow 1.5x toward 5s.
         """
 
+        job_id = _require_remember_job_id(job_id)
+        path = _remember_status_path(job_id)
+        if path is None:
+            raise MemWalRememberJobNotFound(job_id)
+
         deadline_ms = _now_ms() + timeout_ms
         attempt = 0
         saw_rate_limit = False
@@ -563,7 +648,7 @@ class MemWal:
                 try:
                     data = await self._signed_request(
                         "GET",
-                        f"/api/remember/{job_id}",
+                        path,
                         {},
                         accepted_statuses=(200, 404),
                         timeout=poll_timeout,
@@ -572,12 +657,14 @@ class MemWal:
                     if "unexpected keyword argument" in str(err) and "timeout" in str(err):
                         data = await self._signed_request(
                             "GET",
-                            f"/api/remember/{job_id}",
+                            path,
                             {},
                             accepted_statuses=(200, 404),
                         )
                     else:
                         raise
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                raise MemWalRememberJobNotFound(job_id) from None
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
                     last_refusal = err.status
@@ -592,6 +679,8 @@ class MemWal:
                 last_refusal = 0
                 continue
 
+            if not isinstance(data, dict):
+                raise MemWalRememberJobNotFound(job_id)
             status_str = data.get("status")
             if status_str is None or status_str == "not_found":
                 raise MemWalRememberJobNotFound(job_id)
@@ -1964,6 +2053,10 @@ class MemWalSync:
     ) -> RememberAcceptedResult:
         return self._run(self._inner.remember_async(text, namespace, idempotency_key))
 
+    def get_remember_status(self, job_id: str) -> RememberJobStatus:
+        """Synchronous version of :meth:`MemWal.get_remember_status`."""
+        return self._run(self._inner.get_remember_status(job_id))
+
     def wait_for_remember_job(
         self,
         job_id: str,

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/memwal/middleware.py

@@ -140,10 +140,67 @@ class _PendingSaves:
     run — this keeps a strong reference until each one is done.
     """
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        on_save_error: Optional[Callable[[BaseException], None]] = None,
+    ) -> None:
         self._tasks: "set[asyncio.Task[Any]]" = set()
         self._threads: List[threading.Thread] = []
+        self._failures: List[tuple[str, str]] = []
+        self._dropped = 0
+        self._on_save_error = on_save_error
         self._lock = threading.Lock()
+        self._callback_threads: set[int] = set()
+
+    def note_error(self, err: BaseException) -> None:
+        """Remember a background analyze failure so flush does not report success.
+
+        The ledger is updated before the callback. A flush from that callback
+        returns without draining or clearing the failure. A flush from any
+        other thread still waits and raises. The ledger keeps only a type and
+        a one-line message, so a client that never flushes does not pin the
+        request traceback.
+        """
+        type_name = type(err).__name__
+        message = str(err).splitlines()[0][:200] if str(err) else ""
+        with self._lock:
+            if len(self._failures) < 8:
+                self._failures.append((type_name, message))
+            else:
+                self._dropped += 1
+        if self._on_save_error is None:
+            return
+        ident = threading.get_ident()
+        with self._lock:
+            self._callback_threads.add(ident)
+        try:
+            self._on_save_error(err)
+        except Exception:
+            logger.warning("Walrus Memory on_save_error raised", exc_info=True)
+        finally:
+            with self._lock:
+                self._callback_threads.discard(ident)
+
+    def _flush_called_from_callback(self) -> bool:
+        with self._lock:
+            return threading.get_ident() in self._callback_threads
+
+    def _note_result(self, result: Any) -> None:
+        if isinstance(result, BaseException):
+            self.note_error(result)
+
+    def _raise_if_failed(self) -> None:
+        with self._lock:
+            failures, self._failures = self._failures, []
+            dropped, self._dropped = self._dropped, 0
+        total = len(failures) + dropped
+        if total == 0:
+            return
+        type_name, message = failures[0] if failures else ("Error", "")
+        detail = f"{type_name}: {message}" if message else type_name
+        raise RuntimeError(
+            f"Walrus Memory auto-save failed ({total} call(s)): {detail}"
+        )
 
     def track_task(self, task: "asyncio.Task[Any]") -> None:
         self._tasks.add(task)
@@ -169,25 +226,44 @@ class _PendingSaves:
         thread.start()
 
     async def flush(self) -> None:
-        """Await every pending task, then join every pending thread."""
+        """Await every pending task, then join every pending thread.
+
+        Raises when any background auto-save failed. The chat call itself
+        still returned; this is the signal for a caller that waited. A call
+        made from ``on_save_error`` returns before draining, joining, or
+        clearing the failure being recorded.
+        """
+        if self._flush_called_from_callback():
+            return
         if self._tasks:
-            await asyncio.gather(*list(self._tasks), return_exceptions=True)
+            tasks = list(self._tasks)
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            for result in results:
+                self._note_result(result)
         self._join_threads()
+        self._raise_if_failed()
 
     def flush_sync(self) -> None:
-        """Join every pending thread. A pending Task belongs to the loop
-        that created it (e.g. an earlier `await llm.ainvoke(...)` call) and
-        cannot be awaited from a different one -- if any are still pending
-        here, the caller mixed sync and async entry points on the same
-        wrapped client, and this cleanup path can't safely drain them. Log
-        and continue draining threads rather than raise out of what's
-        usually shutdown code."""
+        """Join every pending thread and raise when a background auto-save failed.
+
+        A pending Task belongs to the loop that created it. When this thread
+        has no running loop, those tasks are awaited here. When it does, they
+        are logged and left for :meth:`flush`. A call made from
+        ``on_save_error`` returns before draining, joining, or clearing the
+        failure being recorded.
+        """
+        if self._flush_called_from_callback():
+            return
         if self._tasks:
-            async def _drain(tasks: "list[asyncio.Task[Any]]") -> None:
-                await asyncio.gather(*tasks, return_exceptions=True)
+            tasks = list(self._tasks)
+
+            async def _drain(pending_tasks: "list[asyncio.Task[Any]]") -> None:
+                results = await asyncio.gather(*pending_tasks, return_exceptions=True)
+                for result in results:
+                    self._note_result(result)
 
             try:
-                asyncio.run(_drain(list(self._tasks)))
+                asyncio.run(_drain(tasks))
             except (RuntimeError, ValueError):
                 logger.warning(
                     "Walrus Memory flush_sync() could not await %d pending "
@@ -197,10 +273,14 @@ class _PendingSaves:
                     len(self._tasks),
                 )
         self._join_threads()
+        self._raise_if_failed()
 
     def _join_threads(self) -> None:
+        current = threading.current_thread()
         with self._lock:
             threads, self._threads = self._threads, []
+            self._threads.extend(thread for thread in threads if thread is current)
+            threads = [thread for thread in threads if thread is not current]
         for thread in threads:
             thread.join()
 
@@ -291,6 +371,7 @@ def with_memwal_langchain(
     min_relevance: float = 0.3,
     debug: bool = False,
     env: Optional[str] = None,
+    on_save_error: Optional[Callable[[BaseException], None]] = None,
 ) -> "BaseChatModel":
     """Wrap a LangChain ``BaseChatModel`` with Walrus Memory management.
 
@@ -313,6 +394,9 @@ def with_memwal_langchain(
         debug: Enable debug logging.
         env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
             ``"local"``). Same precedence as :meth:`MemWal.create`.
+        on_save_error: Called with the original exception when a background
+            auto-save fails. ``flush`` / ``flush_sync`` from this callback does
+            not clear that failure.
 
     Returns:
         A wrapped ``BaseChatModel`` that automatically uses Walrus Memory.
@@ -335,7 +419,7 @@ def with_memwal_langchain(
     )
 
     log = logger.debug if not debug else logger.warning
-    pending = _PendingSaves()
+    pending = _PendingSaves(on_save_error)
 
     original_agenerate = llm._agenerate
     original_generate = llm._generate
@@ -408,6 +492,7 @@ def with_memwal_langchain(
                 await memwal.analyze(user_text, namespace)
             except Exception as e:
                 log(f"[Walrus Memory] Auto-save failed: {e}")
+                pending.note_error(e)
 
     async def patched_agenerate(
         messages: List[List[BaseMessage]], *args: Any, **kwargs: Any
@@ -470,6 +555,7 @@ def with_memwal_openai(
     min_relevance: float = 0.3,
     debug: bool = False,
     env: Optional[str] = None,
+    on_save_error: Optional[Callable[[BaseException], None]] = None,
 ) -> Any:
     """Wrap an OpenAI client with Walrus Memory management.
 
@@ -494,6 +580,9 @@ def with_memwal_openai(
         debug: Enable debug logging.
         env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
             ``"local"``). Same precedence as :meth:`MemWal.create`.
+        on_save_error: Called with the original exception when a background
+            auto-save fails. ``flush`` / ``flush_sync`` from this callback does
+            not clear that failure.
 
     Returns:
         The same client, with ``chat.completions.create`` wrapped to use Walrus Memory.
@@ -507,7 +596,7 @@ def with_memwal_openai(
     )
 
     log = logger.debug if not debug else logger.warning
-    pending = _PendingSaves()
+    pending = _PendingSaves(on_save_error)
 
     is_async = hasattr(client, "_async_client") or type(client).__name__ == "AsyncOpenAI"
 
@@ -572,6 +661,7 @@ def _wrap_async_openai(
                     await memwal.analyze(user_text, namespace)
                 except Exception as e:
                     log(f"[Walrus Memory] Auto-save failed: {e}")
+                    pending.note_error(e)
 
             _fire_and_forget(_analyze(), pending)
 
@@ -633,6 +723,7 @@ def _wrap_sync_openai(
                     _run_memwal(lambda: memwal.analyze(user_text, namespace))
                 except Exception as e:
                     log(f"[Walrus Memory] Auto-save failed: {e}")
+                    pending.note_error(e)
 
             pending.spawn_thread(_analyze)
 

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

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

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/tests/test_client.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import base64
 import json
 import time
+import uuid
 from datetime import datetime, timedelta, timezone
 from typing import Any, Sequence
 
@@ -24,6 +25,7 @@ from memwal.client import (
     MemWalCompatibilityError,
     MemWalError,
     MemWalRateLimited,
+    MemWalRememberJobNotFound,
     MemWalRememberJobTimeout,
     MemWalSync,
     _HttpStatusError,
@@ -36,6 +38,7 @@ from memwal.types import (
     RememberBulkOptions,
     RememberBulkStatusItem,
     RememberBulkStatusResult,
+    RememberJobStatus,
     RememberManualOptions,
     ScoringWeights,
 )
@@ -642,6 +645,151 @@ class TestRememberJobTimeoutDetail:
         )
 
 
+# ============================================================
+# one-job remember status
+# ============================================================
+
+
+_NORMAL_JOB_ID = "550e8400-e29b-41d4-a716-446655440000"
+
+
+class TestRememberJobStatus:
+    @respx.mock
+    async def test_unsafe_job_id_is_not_requested(self, memwal_client: MemWal) -> None:
+        route = respx.route().mock(return_value=httpx.Response(500, text="nope"))
+        for job_id in ("", "abc/def?x=1", "job 1", "a\tb", "?", "/", ".", "..", "%2e%2e", "a\\b"):
+            status = await memwal_client.get_remember_status(job_id)
+            assert status == RememberJobStatus(
+                job_id=job_id,
+                status="not_found",
+                error=f"Job {job_id} not found",
+            )
+            with pytest.raises(MemWalRememberJobNotFound) as exc:
+                await memwal_client.wait_for_remember_job(
+                    job_id, poll_interval_ms=0, timeout_ms=5_000
+                )
+            assert exc.value.status == 404
+            assert exc.value.job_id == job_id
+            assert not isinstance(exc.value, json.JSONDecodeError)
+        assert route.call_count == 0
+
+    async def test_non_string_job_id_is_a_type_error(self, memwal_client: MemWal) -> None:
+        with pytest.raises(TypeError):
+            await memwal_client.get_remember_status(1)  # type: ignore[arg-type]
+        with pytest.raises(TypeError):
+            await memwal_client.wait_for_remember_job(1, poll_interval_ms=0, timeout_ms=5_000)  # type: ignore[arg-type]
+
+    @respx.mock
+    async def test_uuid_object_reads_the_string_path(self, memwal_client: MemWal) -> None:
+        _mock_version()
+        job = uuid.UUID(_NORMAL_JOB_ID)
+        route = respx.get(f"{_TEST_SERVER}/api/remember/{job}").mock(
+            return_value=httpx.Response(200, json={"job_id": str(job), "status": "running"})
+        )
+        status = await memwal_client.get_remember_status(job)  # type: ignore[arg-type]
+        assert status.status == "running"
+        assert status.job_id == str(job)
+        assert route.call_count == 1
+
+    @respx.mock
+    async def test_non_object_404_body_is_not_found(self, memwal_client: MemWal) -> None:
+        mock_seal_session_prereqs()
+        route = respx.get(f"{_TEST_SERVER}/api/remember/job-1")
+        for body in (b"null", b"[]", b'"Not Found"', b"<html>nope</html>"):
+            route.mock(return_value=httpx.Response(404, content=body))
+            status = await memwal_client.get_remember_status("job-1")
+            assert status.status == "not_found"
+            assert status.job_id == "job-1"
+            with pytest.raises(MemWalRememberJobNotFound) as exc:
+                await memwal_client.wait_for_remember_job(
+                    "job-1", poll_interval_ms=0, timeout_ms=5_000
+                )
+            assert exc.value.status == 404
+
+    @respx.mock
+    async def test_empty_404_body_is_not_found(self, memwal_client: MemWal) -> None:
+        mock_seal_session_prereqs()
+        respx.get(f"{_TEST_SERVER}/api/remember/job-1").mock(
+            return_value=httpx.Response(404, content=b"")
+        )
+        status = await memwal_client.get_remember_status("job-1")
+        assert status.status == "not_found"
+        assert status.job_id == "job-1"
+        with pytest.raises(MemWalRememberJobNotFound) as exc:
+            await memwal_client.wait_for_remember_job(
+                "job-1", poll_interval_ms=0, timeout_ms=5_000
+            )
+        assert exc.value.status == 404
+
+    @respx.mock
+    async def test_reads_a_normal_job_id(self, memwal_client: MemWal) -> None:
+        mock_seal_session_prereqs()
+        route = respx.get(f"{_TEST_SERVER}/api/remember/{_NORMAL_JOB_ID}").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "job_id": _NORMAL_JOB_ID,
+                    "status": "done",
+                    "blob_id": "blob-1",
+                    "owner": "0xowner",
+                    "namespace": "profile",
+                },
+            )
+        )
+
+        status = await memwal_client.get_remember_status(_NORMAL_JOB_ID)
+        assert status == RememberJobStatus(
+            job_id=_NORMAL_JOB_ID,
+            status="done",
+            owner="0xowner",
+            namespace="profile",
+            blob_id="blob-1",
+        )
+        assert "x-seal-session" not in route.calls[0].request.headers
+
+        result = await memwal_client.wait_for_remember_job(
+            _NORMAL_JOB_ID, poll_interval_ms=0, timeout_ms=5_000
+        )
+        assert result.blob_id == "blob-1"
+        assert result.namespace == "profile"
+        assert [str(call.request.url) for call in route.calls] == [
+            f"{_TEST_SERVER}/api/remember/{_NORMAL_JOB_ID}",
+            f"{_TEST_SERVER}/api/remember/{_NORMAL_JOB_ID}",
+        ]
+
+    @respx.mock
+    def test_sync_reads_a_normal_job_id(self) -> None:
+        _mock_version()
+        route = respx.get(f"{_TEST_SERVER}/api/remember/{_NORMAL_JOB_ID}").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "job_id": _NORMAL_JOB_ID,
+                    "status": "running",
+                    "namespace": "profile",
+                },
+            )
+        )
+        client = MemWalSync.create(
+            key=_TEST_KEY_HEX,
+            account_id=_TEST_ACCOUNT_ID,
+            server_url=_TEST_SERVER,
+        )
+        try:
+            missing = client.get_remember_status("")
+            assert missing.status == "not_found"
+            with pytest.raises(MemWalRememberJobNotFound):
+                client.wait_for_remember_job("abc/def?x=1", poll_interval_ms=0, timeout_ms=5_000)
+            status = client.get_remember_status(_NORMAL_JOB_ID)
+            assert status.status == "running"
+            assert status.namespace == "profile"
+            assert str(route.calls[0].request.url) == (
+                f"{_TEST_SERVER}/api/remember/{_NORMAL_JOB_ID}"
+            )
+        finally:
+            client.close()
+
+
 # ============================================================
 # recall() tests
 # ============================================================

{memwal-0.1.11.dev9 → memwal-0.1.11.dev11}/tests/test_middleware.py

@@ -1000,3 +1000,157 @@ class TestPendingSaves:
 
         time.sleep(0.05)
         assert len(pending._threads) == 0
+
+    def test_flush_raises_when_a_background_save_failed(self) -> None:
+        seen: list[BaseException] = []
+        pending = _PendingSaves(seen.append)
+        pending.note_error(RuntimeError("analyze down"))
+
+        async def go() -> None:
+            await pending.flush()
+
+        try:
+            asyncio.run(go())
+        except RuntimeError as err:
+            assert "auto-save failed" in str(err)
+        else:
+            raise AssertionError("flush did not raise")
+        assert len(seen) == 1
+
+    def test_flush_sync_raises_when_a_background_save_failed(self) -> None:
+        pending = _PendingSaves()
+        pending.note_error(RuntimeError("analyze down"))
+        try:
+            pending.flush_sync()
+        except RuntimeError as err:
+            assert "auto-save failed" in str(err)
+        else:
+            raise AssertionError("flush_sync did not raise")
+
+    def test_flush_sees_a_failing_task_without_note_error(self) -> None:
+        pending = _PendingSaves()
+
+        async def fail() -> None:
+            raise RuntimeError("analyze down")
+
+        async def go() -> None:
+            task = asyncio.create_task(fail())
+            pending.track_task(task)
+            await pending.flush()
+
+        try:
+            asyncio.run(go())
+        except RuntimeError as err:
+            assert "analyze down" in str(err)
+        else:
+            raise AssertionError("flush did not raise")
+
+    def test_callback_flush_does_not_swallow_the_failure(self) -> None:
+        pending = _PendingSaves()
+
+        def on_error(_err: BaseException) -> None:
+            pending.flush_sync()
+
+        pending._on_save_error = on_error
+        pending.note_error(RuntimeError("analyze down"))
+
+        async def go() -> None:
+            await pending.flush()
+
+        try:
+            asyncio.run(go())
+        except RuntimeError as err:
+            assert "analyze down" in str(err)
+        else:
+            raise AssertionError("flush did not raise")
+
+    def test_worker_callback_flush_sync_keeps_the_failure(self) -> None:
+        pending = _PendingSaves()
+        callback_error: list[str] = []
+        saw_self = []
+
+        def on_error(_err: BaseException) -> None:
+            try:
+                pending.flush_sync()
+            except Exception as err:
+                callback_error.append(repr(err))
+            with pending._lock:
+                saw_self.append(threading.current_thread() in pending._threads)
+
+        pending._on_save_error = on_error
+        done = threading.Event()
+
+        def fail() -> None:
+            pending.note_error(RuntimeError("analyze down"))
+            done.set()
+
+        pending.spawn_thread(fail)
+        assert done.wait(2)
+        assert callback_error == []
+        assert saw_self == [True]
+        try:
+            pending.flush_sync()
+        except RuntimeError as err:
+            assert "analyze down" in str(err)
+        else:
+            raise AssertionError("flush_sync did not raise")
+
+    def test_two_worker_callbacks_do_not_join_each_other(self) -> None:
+        """Overlapping on_save_error flushes must not join the other worker.
+
+        Each callback returns before drain, join, and raise. The later caller
+        flush still reports both failures.
+        """
+        pending = _PendingSaves()
+        entered = threading.Barrier(2)
+        callback_error: list[str] = []
+        done = threading.Barrier(3)
+
+        def on_error(_err: BaseException) -> None:
+            entered.wait(2)
+            try:
+                pending.flush_sync()
+            except Exception as err:
+                callback_error.append(repr(err))
+
+        pending._on_save_error = on_error
+
+        def fail(message: str):
+            def run() -> None:
+                pending.note_error(RuntimeError(message))
+                done.wait(2)
+            return run
+
+        pending.spawn_thread(fail("analyze down"))
+        pending.spawn_thread(fail("analyze also down"))
+        done.wait(2)
+        assert callback_error == []
+        try:
+            pending.flush_sync()
+        except RuntimeError as err:
+            assert "2 call" in str(err)
+            assert "analyze down" in str(err)
+        else:
+            raise AssertionError("flush_sync did not raise")
+
+    def test_flush_from_another_thread_still_raises_during_callback(self) -> None:
+        """The callback thread bails out. Any other flush still reports the failure."""
+        import time
+
+        pending = _PendingSaves()
+        started = threading.Event()
+
+        def on_error(_err: BaseException) -> None:
+            started.set()
+            time.sleep(0.2)
+
+        pending._on_save_error = on_error
+        pending.spawn_thread(lambda: pending.note_error(RuntimeError("analyze down")))
+        assert started.wait(2)
+        try:
+            pending.flush_sync()
+        except RuntimeError as err:
+            assert "analyze down" in str(err)
+        else:
+            raise AssertionError("flush_sync did not raise")
+