memwal 0.1.11.dev11__tar.gz → 0.1.11.dev12__tar.gz

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

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

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

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

@@ -1063,14 +1063,12 @@ class MemWal:
             dropped = int(raw_dropped)
         except (TypeError, ValueError):
             dropped = 0
+        total_count = data.get("total", len(memories))
         if max_distance is not None:
             memories = [m for m in memories if m.distance < max_distance]
-            return RecallResult(
-                results=memories, total=len(memories), dropped_count=dropped
-            )
         return RecallResult(
             results=memories,
-            total=data.get("total", len(memories)),
+            total=total_count,
             dropped_count=dropped,
         )
 
@@ -1817,7 +1815,7 @@ class MemWalClockDriftError(MemWalError):
 
 def _redact_internal_urls(text: str) -> str:
     return re.sub(
-        r"https?://(?:localhost|127\.0\.0\.1)(?::\d+)?[^\s)\]>'\"]*",
+        r"https?://(?:(?:[\w-]+\.)*localhost|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[::1\]|0\.0\.0\.0)(?::\d+)?[^\s)\]>'\"]*",
         "[internal]",
         text,
         flags=re.IGNORECASE,

{memwal-0.1.11.dev11 → memwal-0.1.11.dev12}/memwal/mock.py

@@ -278,14 +278,15 @@ class MemWalMock:
             for memory in self._memories
             if memory.namespace == resolved_namespace
         ]
-        if max_distance is not None:
-            ranked = [item for item in ranked if item[1] < max_distance]
         ranked.sort(key=lambda item: (item[1], item[0].sequence))
+        page = ranked[:limit]
+        if max_distance is not None:
+            page = [item for item in page if item[1] < max_distance]
         results = [
             RecallMemory(blob_id=memory.blob_id, text=memory.text, distance=score)
-            for memory, score in ranked[:limit]
+            for memory, score in page
         ]
-        return RecallResult(results=results, total=len(results))
+        return RecallResult(results=results, total=len(ranked[:limit]))
 
     async def analyze(
         self,

{memwal-0.1.11.dev11 → memwal-0.1.11.dev12}/memwal/utils.py

@@ -299,7 +299,9 @@ def normalize_private_key(key: str) -> str:
     candidate = key.strip()
     if candidate.lower().startswith("suiprivkey1"):
         return bytes_to_hex(decode_sui_private_key(candidate))
-    return candidate[2:] if candidate.startswith("0x") else candidate
+    if candidate.startswith(("0x", "0X")):
+        return candidate[2:]
+    return candidate
 
 
 def encode_sui_private_key(seed_bytes: bytes) -> str:

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

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

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

@@ -935,9 +935,33 @@ class TestRecall:
         body = json.loads(route.calls[0].request.content)
         assert body["limit"] == 10
         assert len(result.results) == 1
-        assert result.total == 1
+        assert result.total == 2
         assert result.results[0].blob_id == "b1"
 
+    @respx.mock
+    async def test_max_distance_filters_all_preserves_total(
+        self, memwal_client: MemWal
+    ) -> None:
+        """When all matches exceed max_distance, results is empty but total
+        preserves matches (#1066)."""
+        mock_seal_session_prereqs()
+        respx.post(f"{_TEST_SERVER}/api/recall").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "results": [
+                        {"blob_id": "b1", "text": "I love coffee", "distance": 0.8},
+                        {"blob_id": "b2", "text": "I live in Tokyo", "distance": 0.9},
+                    ],
+                    "total": 2,
+                },
+            )
+        )
+
+        result = await memwal_client.recall("coffee", limit=10, max_distance=0.5)
+        assert len(result.results) == 0
+        assert result.total == 2
+
     @respx.mock
     async def test_get_signed_request_uses_empty_body_hash_and_no_wire_body(
         self, memwal_client: MemWal
@@ -1583,3 +1607,25 @@ class TestSealSession:
         assert exported["ttlMin"] == 5
         assert exported["sessionKey"].startswith("suiprivkey")
         assert exported["personalMessageSignature"]
+
+
+class TestRedactInternalUrls:
+    @pytest.mark.parametrize(
+        "raw, expected",
+        [
+            ("Error at http://localhost:8080/path", "Error at [internal]"),
+            ("Error at http://127.0.0.1:3000/api", "Error at [internal]"),
+            ("Error at http://127.0.0.2:8000/status", "Error at [internal]"),
+            ("Error at http://127.128.0.1:9000/info", "Error at [internal]"),
+            ("Error at http://[::1]:9000/seal/encrypt", "Error at [internal]"),
+            ("Error at http://0.0.0.0:8000/health", "Error at [internal]"),
+            ("Error at http://sidecar.localhost:8080/v1", "Error at [internal]"),
+            ("Error at http://sub.domain.localhost:3000/test", "Error at [internal]"),
+            ("Error at https://api.wal.app/v1/remember", "Error at https://api.wal.app/v1/remember"),
+        ],
+    )
+    def test_redact_internal_urls(self, raw: str, expected: str) -> None:
+        from memwal.client import _redact_internal_urls
+
+        assert _redact_internal_urls(raw) == expected
+

{memwal-0.1.11.dev11 → memwal-0.1.11.dev12}/tests/test_mock.py

@@ -57,6 +57,11 @@ async def test_mock_isolates_namespaces_and_honors_max_distance():
     assert [memory.text for memory in alice.results] == ["Alice likes ramen"]
     assert [memory.text for memory in bob.results] == ["Bob likes tacos"]
     assert empty.total == 0
+    dropped = await mock.recall(
+        RecallParams(query="likes", namespace="user-a", max_distance=0)
+    )
+    assert dropped.results == []
+    assert dropped.total == 1
 
 
 @pytest.mark.asyncio

{memwal-0.1.11.dev11 → memwal-0.1.11.dev12}/tests/test_signing.py

@@ -324,11 +324,20 @@ class TestPrivateKeyFormats:
         for form in (
             self._SEED_HEX,
             f"0x{self._SEED_HEX}",
+            f"0X{self._SEED_HEX}",
+            f"  0X{self._SEED_HEX}  ",
             encode_sui_private_key(seed),
             f"  {encode_sui_private_key(seed)}  ",
         ):
             assert normalize_private_key(form) == self._SEED_HEX
 
+    def test_uppercase_0x_prefix_key_produces_valid_client(self) -> None:
+        from memwal.client import MemWal
+
+        upper_0x = f"0X{self._SEED_HEX}"
+        client = MemWal.create(key=upper_0x, account_id="0xtest")
+        assert client._private_key_hex == self._SEED_HEX
+
     def test_bech32_key_produces_the_same_client_identity(self) -> None:
         from memwal.client import MemWal
         from memwal.utils import encode_sui_private_key