memwal 0.1.7.dev2__tar.gz → 0.1.7.dev4__tar.gz

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/PKG-INFO

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

@@ -122,4 +122,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.7.dev2"
+__version__ = "0.1.7.dev4"

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/memwal/client.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 import asyncio
 import base64
 import json
+import logging
 import random
 import time
 import uuid
@@ -90,6 +91,9 @@ AUTH_REJECTED_MESSAGE = (
 )
 
 
+logger = logging.getLogger("memwal")
+
+
 # ============================================================
 # Polling helpers (PR #121 parity with TS SDK)
 # ============================================================
@@ -1277,6 +1281,38 @@ class MemWalRememberJobTimeout(MemWalError):
         self.timeout_ms = timeout_ms
 
 
+async def _discard_http_client(memwal: MemWal) -> None:
+    """Close the cached httpx client, and drop it either way.
+
+    ``close()`` can fail when the client belongs to an event loop that has
+    already finished — the caller still needs ``_client`` cleared so the next
+    request builds one in a loop that is actually running.
+    """
+    try:
+        await memwal.close()
+    except Exception:
+        logger.debug("Closing the cached HTTP client failed", exc_info=True)
+    finally:
+        memwal._client = None
+
+
+async def _with_fresh_http_client(memwal: MemWal, coro: Any) -> Any:
+    """Run ``coro`` with an httpx client owned by the *current* event loop.
+
+    The sync entry points execute each coroutine in a throwaway ``asyncio.run()``
+    loop, and an ``httpx.AsyncClient`` is bound to the loop that created it, so
+    one can never be reused across calls. Both ends are closed rather than just
+    dropped (GH #606): on the way in for anything an earlier loop left behind —
+    e.g. a caller mixing ``await memwal.recall()`` with the sync wrapper — and in
+    ``finally`` for the client this call created, while its loop is still alive.
+    """
+    await _discard_http_client(memwal)
+    try:
+        return await coro
+    finally:
+        await _discard_http_client(memwal)
+
+
 class MemWalSync:
     """Synchronous wrapper around the async :class:`MemWal` client.
 
@@ -1326,11 +1362,10 @@ class MemWalSync:
         except RuntimeError:
             loop = None
 
-        # Reset the httpx client before every asyncio.run() path so it is
-        # recreated inside the loop that will use it. This matters in
-        # notebooks/Jupyter where the sync wrapper runs coroutines in worker
-        # threads with short-lived event loops.
-        self._inner._client = None
+        # The httpx client is created and closed inside the same short-lived
+        # loop that uses it. This matters in notebooks/Jupyter where the sync
+        # wrapper runs coroutines in worker threads with their own event loops.
+        wrapped = _with_fresh_http_client(self._inner, coro)
 
         if loop is not None and loop.is_running():
             # Already inside an event loop (e.g. Jupyter).
@@ -1338,9 +1373,9 @@ class MemWalSync:
             import concurrent.futures
 
             with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-                return pool.submit(asyncio.run, coro).result()
+                return pool.submit(asyncio.run, wrapped).result()
         else:
-            return asyncio.run(coro)
+            return asyncio.run(wrapped)
 
     def remember(
         self,

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/memwal/middleware.py

@@ -54,7 +54,7 @@ from typing import (
     Optional,
 )
 
-from .client import MemWal
+from .client import MemWal, _with_fresh_http_client
 from .types import RecallMemory
 
 if TYPE_CHECKING:
@@ -403,24 +403,20 @@ def with_memwal_langchain(
 
         return result
 
+    def _run_memwal(coro_factory: Callable[[], Any]) -> Any:
+        # Keep httpx clients bound to the short-lived loop that uses them.
+        return _run_blocking(lambda: _with_fresh_http_client(memwal, coro_factory()))
+
     def patched_generate(
         messages: List[List[BaseMessage]], *args: Any, **kwargs: Any
     ) -> ChatResult:
-        # For sync generate, we inject memories synchronously via asyncio.run
-        import asyncio
-
+        # Inject via _run_blocking so recall still runs when a loop is already
+        # running (notebooks, async hosts) — the same helper the sync OpenAI
+        # wrapper uses. Passing the messages through untouched there made
+        # Walrus Memory look connected while recall silently never ran.
         enriched = []
         for msg_list in messages:
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                loop = None
-
-            if loop is not None and loop.is_running():
-                # Already in async context -- cannot use asyncio.run
-                enriched.append(msg_list)
-            else:
-                enriched.append(asyncio.run(_inject_memories(msg_list)))
+            enriched.append(_run_memwal(lambda: _inject_memories(msg_list)))
 
         result = original_generate(enriched, *args, **kwargs)
 
@@ -579,8 +575,7 @@ def _wrap_sync_openai(
 
     def _run_memwal(coro_factory: Callable[[], Any]) -> Any:
         # Keep httpx clients bound to the short-lived loop that uses them.
-        memwal._client = None
-        return _run_blocking(coro_factory)
+        return _run_blocking(lambda: _with_fresh_http_client(memwal, coro_factory()))
 
     def patched_create(*args: Any, **kwargs: Any) -> Any:
         messages = kwargs.get("messages") or (args[0] if args else None)

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/pyproject.toml

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

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/tests/test_client.py

@@ -120,9 +120,26 @@ def memwal_client() -> MemWal:
 # ============================================================
 
 
+class _FakeHttpClient:
+    """Stand-in for httpx.AsyncClient, tracking whether it was closed."""
+
+    def __init__(self) -> None:
+        self.is_closed = False
+
+    async def aclose(self) -> None:
+        self.is_closed = True
+
+
 class _SyncRunInner:
+    """Minimal stand-in mirroring MemWal's httpx client lifecycle."""
+
     def __init__(self) -> None:
-        self._client = object()
+        self._client: Any = _FakeHttpClient()
+
+    async def close(self) -> None:
+        if self._client is not None and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
 
 
 class TestMemWalSyncRun:
@@ -138,6 +155,57 @@ class TestMemWalSyncRun:
         assert result == "ok"
         assert inner._client is None
 
+    async def test_closes_the_client_it_replaces(self) -> None:
+        """GH #606: _run() used to null out _client without closing it, leaking
+        the connection pool of every client an earlier event loop left behind."""
+        inner = _SyncRunInner()
+        orphan = inner._client
+        sync = MemWalSync(inner)  # type: ignore[arg-type]
+
+        async def operation() -> str:
+            return "ok"
+
+        assert not orphan.is_closed
+        assert sync._run(operation()) == "ok"
+
+        assert orphan.is_closed, "the replaced httpx client was never closed"
+        assert inner._client is None
+
+    async def test_closes_the_client_created_during_the_call(self) -> None:
+        """The per-call client is closed inside the loop that created it, so
+        repeated sync calls do not accumulate open pools."""
+        inner = _SyncRunInner()
+        await inner.close()
+        sync = MemWalSync(inner)  # type: ignore[arg-type]
+        created: list = []
+
+        async def operation() -> str:
+            # Stands in for the lazy `_http` property building a client inside
+            # whichever loop is currently running.
+            inner._client = _FakeHttpClient()
+            created.append(inner._client)
+            return "ok"
+
+        assert sync._run(operation()) == "ok"
+
+        assert len(created) == 1
+        assert created[0].is_closed, "the per-call httpx client was left open"
+        assert inner._client is None
+
+    async def test_closes_client_even_when_the_operation_raises(self) -> None:
+        inner = _SyncRunInner()
+        orphan = inner._client
+        sync = MemWalSync(inner)  # type: ignore[arg-type]
+
+        async def failing() -> str:
+            raise ValueError("boom")
+
+        with pytest.raises(ValueError, match="boom"):
+            sync._run(failing())
+
+        assert orphan.is_closed
+        assert inner._client is None
+
 
 # ============================================================
 # remember() tests

{memwal-0.1.7.dev2 → memwal-0.1.7.dev4}/tests/test_middleware.py

@@ -447,6 +447,84 @@ class TestWithMemWalLangChain:
         await smart_llm._agenerate([[SystemMessage("only system")]])
         assert not recall_route.called
 
+    def _capturing_generate(self, captured: list):
+        """Replacement for llm._generate that records the batch it received."""
+        from langchain_core.messages import AIMessage
+        from langchain_core.outputs import ChatGeneration, ChatResult
+
+        def _generate(messages_batch, *a, **kw):
+            captured.extend(messages_batch)
+            return ChatResult(
+                generations=[ChatGeneration(message=AIMessage(content="ok"))]
+            )
+
+        return _generate
+
+    @respx.mock
+    def test_sync_generate_injects_memories(self) -> None:
+        """The plain sync path (no running loop) recalls and injects."""
+        _mock_seal_session_prereqs()
+        from langchain_core.messages import HumanMessage
+
+        llm = self._make_llm()
+        captured: list = []
+        llm._generate = self._capturing_generate(captured)
+
+        recall_route = respx.post(_RECALL_URL).mock(
+            return_value=_mock_recall([
+                {"blob_id": "b1", "text": "User loves coffee", "distance": 0.05}
+            ])
+        )
+
+        smart_llm = with_memwal_langchain(
+            llm, key=_KEY_HEX, account_id=_ACCOUNT_ID, server_url=_SERVER, auto_save=False
+        )
+        smart_llm._generate([[HumanMessage("What do I drink?")]])
+
+        assert recall_route.called
+        assert any("User loves coffee" in m.content for m in captured[0])
+
+    @respx.mock
+    async def test_sync_generate_injects_memories_inside_running_loop(self) -> None:
+        """GH #607: sync _generate must still recall when a loop is already
+        running (notebooks, async hosts).
+
+        It used to append the untouched msg_list in that branch, so callers got
+        a normal LLM answer with no memory context and no warning -- Walrus
+        Memory looked connected while recall never ran.
+        """
+        _mock_seal_session_prereqs()
+        from langchain_core.messages import HumanMessage, SystemMessage
+
+        llm = self._make_llm()
+        captured: list = []
+        llm._generate = self._capturing_generate(captured)
+
+        recall_route = respx.post(_RECALL_URL).mock(
+            return_value=_mock_recall([
+                {"blob_id": "b1", "text": "User loves coffee", "distance": 0.05}
+            ])
+        )
+
+        smart_llm = with_memwal_langchain(
+            llm, key=_KEY_HEX, account_id=_ACCOUNT_ID, server_url=_SERVER, auto_save=False
+        )
+
+        # An async test body is itself a running loop -- the exact condition
+        # that used to disable injection.
+        assert asyncio.get_running_loop().is_running()
+        smart_llm._generate([[HumanMessage("What do I drink?")]])
+
+        assert recall_route.called, "recall was skipped inside a running loop"
+        assert len(captured) == 1
+        injected = captured[0]
+        assert len(injected) == 3, "guard + memory message were not injected"
+        assert any(
+            isinstance(m, HumanMessage) and "User loves coffee" in m.content
+            for m in injected
+        )
+        assert any(isinstance(m, SystemMessage) for m in injected)
+
     def test_wraps_a_real_pydantic_backed_chat_model(self) -> None:
         """with_memwal_langchain must work on a real BaseChatModel, not just
         a MagicMock. LangChain chat models are Pydantic models that reject