memwal 0.2.2.dev6__py3-none-any.whl → 0.2.3.dev0__py3-none-any.whl

memwal/__init__.py

@@ -29,6 +29,7 @@ from .client import (
     MemWalError,
     MemWalJsonBodyError,
     MemWalRateLimited,
+    MemWalRecallAllDropped,
     MemWalRememberJobFailed,
     MemWalRememberJobNotFound,
     MemWalRememberJobTimeout,
@@ -87,6 +88,7 @@ __all__ = [
     "MemWalClockDriftError",
     "MemWalJsonBodyError",
     "MemWalRateLimited",
+    "MemWalRecallAllDropped",
     "MemWalRememberJobFailed",
     "MemWalRememberJobNotFound",
     "MemWalRememberJobTimeout",
@@ -132,4 +134,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.2.2.dev6"
+__version__ = "0.2.3.dev0"

memwal/client.py

@@ -453,6 +453,15 @@ def _check_limit(limit: Any) -> None:
         raise ValueError(f"limit must be a positive integer, got {limit!r}")
 
 
+def _check_on_dropped(on_dropped: Any) -> str:
+    """Validate the recall all-dropped handling policy before signing."""
+    if on_dropped not in ("throw", "ignore"):
+        raise ValueError(
+            f"on_dropped must be 'throw' or 'ignore', got {on_dropped!r}"
+        )
+    return str(on_dropped)
+
+
 def _check_vector(vector: Any) -> None:
     """Reject a vector that is not a non-empty list of finite numbers (#1218).
 
@@ -1175,6 +1184,7 @@ class MemWal:
         limit: int = 10,
         namespace: Optional[str] = None,
         max_distance: Optional[float] = None,
+        on_dropped: str = "ignore",
     ) -> RecallResult:
         """Recall memories similar to a query.
 
@@ -1200,6 +1210,11 @@ class MemWal:
             max_distance: Optional client-side relevance threshold. Memories
                 with ``distance >= max_distance`` are dropped. Ignored when
                 ``query`` is a :class:`RecallParams`.
+            on_dropped: Policy when every matched memory failed download or
+                decrypt (``"ignore"`` by default returns the degraded
+                :class:`RecallResult` with ``degraded=True`` and
+                ``dropped_count``; ``"throw"`` raises
+                :class:`MemWalRecallAllDropped`).
 
         Returns:
             :class:`RecallResult` with decrypted text results.
@@ -1214,15 +1229,18 @@ class MemWal:
             max_distance = params.max_distance
             scoring_weights = params.scoring_weights
             sort = params.sort
+            on_dropped = params.on_dropped
         else:
             query_text = query
         _reject_blank_text(query_text, "query cannot be empty")
         _check_limit(limit)
         validate_max_distance(max_distance)
+        policy = _check_on_dropped(on_dropped)
+        resolved_namespace = self._resolve_namespace(namespace)
         body = {
             "query": query_text,
             "limit": limit,
-            "namespace": self._resolve_namespace(namespace),
+            "namespace": resolved_namespace,
         }
         if scoring_weights is not None:
             body["scoring_weights"] = scoring_weights.to_wire()
@@ -1241,16 +1259,34 @@ class MemWal:
         ]
         raw_dropped = data.get("dropped_count") or 0
         try:
-            dropped = int(raw_dropped)
+            dropped = max(0, int(raw_dropped))
         except (TypeError, ValueError):
             dropped = 0
-        total_count = data.get("total", len(memories))
+        degraded = bool(data.get("degraded")) or dropped > 0
+        raw_total = data.get("total", len(memories))
+        try:
+            total_count = int(raw_total)
+        except (TypeError, ValueError):
+            total_count = len(memories)
+
+        if len(memories) == 0 and degraded:
+            effective_dropped = dropped if dropped > 0 else max(1, total_count)
+            effective_total = max(total_count, effective_dropped)
+            if policy == "throw":
+                raise MemWalRecallAllDropped(
+                    dropped_count=effective_dropped,
+                    total=effective_total,
+                    namespace=resolved_namespace,
+                )
+            dropped = effective_dropped
+
         if max_distance is not None:
             memories = [m for m in memories if m.distance < max_distance]
         return RecallResult(
             results=memories,
             total=total_count,
             dropped_count=dropped,
+            degraded=degraded,
         )
 
     async def forget(self, namespace: Optional[str] = None) -> ForgetResult:
@@ -2311,6 +2347,27 @@ class MemWalRememberJobTimeout(MemWalError):
         self.last_refusal = last_refusal
 
 
+class MemWalRecallAllDropped(MemWalError):
+    """Raised by :meth:`MemWal.recall` when ``on_dropped="throw"`` is set and
+    every matched memory failed to download or decrypt (``results == []`` and
+    ``dropped_count > 0``).
+
+    By default (``on_dropped="ignore"``), :meth:`MemWal.recall` returns the
+    degraded :class:`RecallResult` without raising.
+    """
+
+    def __init__(self, dropped_count: int, total: int, namespace: str) -> None:
+        noun = "match" if total == 1 else "matches"
+        super().__init__(
+            f'MemWal recall matched {total} {noun} in namespace "{namespace}", '
+            f"but all {dropped_count} failed to download or decrypt"
+        )
+        self.code = "RECALL_ALL_DROPPED"
+        self.dropped_count = dropped_count
+        self.total = total
+        self.namespace = namespace
+
+
 async def _discard_http_client(memwal: MemWal) -> None:
     """Close the cached httpx client, and drop it either way.
 
@@ -2502,10 +2559,19 @@ class MemWalSync:
         limit: int = 10,
         namespace: Optional[str] = None,
         max_distance: Optional[float] = None,
+        on_dropped: str = "ignore",
     ) -> RecallResult:
         """Synchronous version of :meth:`MemWal.recall` (accepts
         :class:`RecallParams` for the recommended object-style call)."""
-        return self._run(self._inner.recall(query, limit, namespace, max_distance))
+        return self._run(
+            self._inner.recall(
+                query,
+                limit,
+                namespace,
+                max_distance,
+                on_dropped=on_dropped,
+            )
+        )
 
     def forget(self, namespace: Optional[str] = None) -> ForgetResult:
         """Synchronous version of :meth:`MemWal.forget`."""

memwal/middleware.py

@@ -659,7 +659,9 @@ def with_memwal_langchain(
             return messages
 
         try:
-            recall_result = await memwal.recall(user_text, max_memories, namespace)
+            recall_result = await memwal.recall(
+                user_text, max_memories, namespace, on_dropped="throw"
+            )
             relevant = [
                 m for m in recall_result.results
                 if (1 - m.distance) >= min_relevance
@@ -837,7 +839,9 @@ def _wrap_async_openai(
             user_text = _find_last_user_message(messages)
             if user_text:
                 try:
-                    recall_result = await memwal.recall(user_text, max_memories, namespace)
+                    recall_result = await memwal.recall(
+                        user_text, max_memories, namespace, on_dropped="throw"
+                    )
                     relevant = [
                         m for m in recall_result.results
                         if (1 - m.distance) >= min_relevance
@@ -915,7 +919,9 @@ def _wrap_sync_openai(
             if user_text:
                 try:
                     recall_result = _run_memwal(
-                        lambda: memwal.recall(user_text, max_memories, namespace)
+                        lambda: memwal.recall(
+                            user_text, max_memories, namespace, on_dropped="throw"
+                        )
                     )
                     relevant = [
                         m for m in recall_result.results

memwal/mock.py

@@ -267,6 +267,7 @@ class MemWalMock:
         limit: int = 10,
         namespace: Optional[str] = None,
         max_distance: Optional[float] = None,
+        on_dropped: str = "ignore",
     ) -> RecallResult:
         """Token-overlap recall over the in-memory store.
 
@@ -281,6 +282,7 @@ class MemWalMock:
             namespace = query.namespace
             max_distance = query.max_distance
             sort = query.sort
+            on_dropped = query.on_dropped
             query_text = query.query
         else:
             sort = None
@@ -288,6 +290,10 @@ class MemWalMock:
         _validate_text(query_text, "query")
         _check_limit(limit)
         validate_max_distance(max_distance)
+        if on_dropped not in ("throw", "ignore"):
+            raise ValueError(
+                f"on_dropped must be 'throw' or 'ignore', got {on_dropped!r}"
+            )
         if sort not in (None, "relevance", "recent"):
             raise ValueError("sort must be 'relevance' or 'recent'")
         resolved_namespace = self._namespace if namespace is None else namespace
@@ -670,9 +676,16 @@ class MemWalMockSync:
         limit: int = 10,
         namespace: Optional[str] = None,
         max_distance: Optional[float] = None,
+        on_dropped: str = "ignore",
     ) -> RecallResult:
         return self._run(
-            self._inner.recall(query, limit, namespace, max_distance)
+            self._inner.recall(
+                query,
+                limit,
+                namespace,
+                max_distance,
+                on_dropped=on_dropped,
+            )
         )
 
     def analyze(

memwal/types.py

@@ -121,6 +121,7 @@ class RecallParams:
     max_distance: Optional[float] = None
     scoring_weights: Optional["ScoringWeights"] = None
     sort: Optional[str] = None
+    on_dropped: str = "ignore"
 
 
 @dataclass
@@ -132,6 +133,8 @@ class RecallResult:
     # Matches omitted because download or decrypt failed. 0 also means the
     # relayer omitted the field (older servers).
     dropped_count: int = 0
+    # True whenever one or more matched blobs were dropped (dropped_count > 0).
+    degraded: bool = False
 
 
 @dataclass

{memwal-0.2.2.dev6.dist-info → memwal-0.2.3.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.2.2.dev6
+Version: 0.2.3.dev0
 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.3.dev0.dist-info/RECORD

@@ -0,0 +1,10 @@
+memwal/__init__.py,sha256=qms4CbnYe-3LFoMW15Af_aByF0pWXs0yp0vsz2cV8Ts,3290
+memwal/client.py,sha256=R6Btr_iUaChkoTHo0zJaqQiPM-Anz__5MRBfRS_ABpQ,104586
+memwal/compatibility.py,sha256=R3Gt1gVRjYSLNa78leNrTpGMZI1UATYo7N8Ie_44CGI,3054
+memwal/middleware.py,sha256=n_kbXDO4kLqtR8ctPInAzdsorl7jTGg9rnOwhRA4aH4,38603
+memwal/mock.py,sha256=0YBmxeixQ6lTjtiYRRTev3ZEw-x5-2lyWCeI6LYK6dM,25282
+memwal/types.py,sha256=03e91D9rFKQesa7q7oYRIBZJ_Ru96yxGzhLaOkY742Q,14282
+memwal/utils.py,sha256=RYlELBpKUHN9RuvWQu0cSGMoyXpAdTWlNKawfDpDbQ0,13361
+memwal-0.2.3.dev0.dist-info/METADATA,sha256=PKU67DhcdIRBfVqGyMg149fJIfcG_cGyzeiJw2o_To8,12151
+memwal-0.2.3.dev0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+memwal-0.2.3.dev0.dist-info/RECORD,,

memwal-0.2.2.dev6.dist-info/RECORD

@@ -1,10 +0,0 @@
-memwal/__init__.py,sha256=dSoujKelLWb8QaOZtr9vDVQSpxy6OZ8vXRY4z7gK1Rc,3232
-memwal/client.py,sha256=eCp7wnvWryITN_Z3fw_NwBV1u1_mlU_mVrdBhLUoltM,102076
-memwal/compatibility.py,sha256=R3Gt1gVRjYSLNa78leNrTpGMZI1UATYo7N8Ie_44CGI,3054
-memwal/middleware.py,sha256=z2xdbvaobBg4byJXnrX7amWdVYE4jfeO4t31DoDBv_o,38413
-memwal/mock.py,sha256=oG0znsO-gekoCkQ0mNgT1kjQwP1ku8TjQEkaNkbRDlQ,24878
-memwal/types.py,sha256=jekUFnpGhVezU_VavY4DEzty6EWb0GxAwspmszk5Cdc,14144
-memwal/utils.py,sha256=RYlELBpKUHN9RuvWQu0cSGMoyXpAdTWlNKawfDpDbQ0,13361
-memwal-0.2.2.dev6.dist-info/METADATA,sha256=lqyLcVerCRkvXJXvEYG24Zh7ZiOE0ugIbV9rTXingHM,12151
-memwal-0.2.2.dev6.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-memwal-0.2.2.dev6.dist-info/RECORD,,