memwal 0.2.0.dev0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.2.0.dev0"
+__version__ = "0.2.1.dev0"

memwal/client.py

@@ -98,6 +98,10 @@ PUBLIC_SUI_GRAPHQL_NETWORKS = ("mainnet", "testnet", "devnet")
 # Sui read endpoint is unresponsive.
 PACKAGE_VERSION_CHECK_TIMEOUT_S = 10.0
 SEAL_SESSION_SAFETY_MARGIN_MS = 30_000
+
+# The relayer's `MAX_BULK_ITEMS` (services/server/src/types.rs). A bulk read
+# above it is rejected with a non-transient 400, so callers must chunk.
+MAX_BULK_STATUS_IDS = 20
 AUTH_REJECTED_MESSAGE = (
     "401 from relayer: typically wrong private key, key not registered on this "
     "account, account ID mismatch (a wallet address is not a MemWal account ID), "
@@ -410,6 +414,29 @@ def _occurred_at_to_wire(
     )
 
 
+
+def _check_limit(limit: Any) -> None:
+    """Reject a limit that is not a positive integer before it is signed (#1218)."""
+    if isinstance(limit, bool) or not isinstance(limit, int) or limit <= 0:
+        raise ValueError(f"limit must be a positive integer, got {limit!r}")
+
+
+def _check_vector(vector: Any) -> None:
+    """Reject a vector that is not a non-empty list of finite numbers (#1218).
+
+    json.dumps would otherwise emit bare NaN/Infinity tokens, which are not
+    JSON, and the relayer would answer with an opaque parse error.
+    """
+    if (
+        not isinstance(vector, (list, tuple))
+        or len(vector) == 0
+        or not all(
+            isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)
+            for v in vector
+        )
+    ):
+        raise ValueError("vector must be a non-empty list of finite numbers")
+
 class MemWal:
     """Async-native Walrus Memory client.
 
@@ -907,60 +934,81 @@ class MemWal:
                 attempt += 1
             retry_after_ms = 0
 
-            try:
-                poll_timeout = self._poll_deadline_s(deadline_ms)
+            # The relayer rejects a bulk-status read of more than
+            # MAX_BULK_STATUS_IDS ids with a 400, which is NOT transient: an
+            # unchunked poll of 21+ jobs raises out of the whole wait and
+            # every retry hits the same 400. Chunk here so `memwal_wait_for_saves`
+            # and `remember_bulk_and_wait` are both fixed.
+            terminal_ids: Set[str] = set()
+            refused_ids: List[str] = []
+            for start in range(0, len(pending), MAX_BULK_STATUS_IDS):
+                chunk = pending[start : start + MAX_BULK_STATUS_IDS]
                 try:
-                    batch = await self.get_remember_bulk_status(pending, timeout=poll_timeout)
-                except TypeError as err:
-                    if "unexpected keyword argument" in str(err) and "timeout" in str(err):
-                        batch = await self.get_remember_bulk_status(pending)
-                    else:
-                        raise
-            except _HttpStatusError as err:
-                if _is_transient_polling_status(err.status):
-                    last_refusal = err.status
-                    if err.status == 429:
-                        saw_rate_limit = True
-                        retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
+                    poll_timeout = self._poll_deadline_s(deadline_ms)
+                    try:
+                        batch = await self.get_remember_bulk_status(chunk, timeout=poll_timeout)
+                    except TypeError as err:
+                        if "unexpected keyword argument" in str(err) and "timeout" in str(err):
+                            batch = await self.get_remember_bulk_status(chunk)
+                        else:
+                            raise
+                except _HttpStatusError as err:
+                    if _is_transient_polling_status(err.status):
+                        last_refusal = err.status
+                        if err.status == 429:
+                            saw_rate_limit = True
+                            retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
+                        # Refused, not answered: keep this chunk pending.
+                        refused_ids.extend(chunk)
+                        continue
+                    raise
+                except httpx.TransportError:
+                    # Network drops retry as status 0; continuing next loop iteration
+                    # increments `attempt` so exponential backoff delay continues to grow.
+                    last_refusal = 0
+                    refused_ids.extend(chunk)
                     continue
-                raise
-            except httpx.TransportError:
-                # Network drops retry as status 0; continuing next loop iteration
-                # increments `attempt` so exponential backoff delay continues to grow.
-                last_refusal = 0
-                continue
-            answered = True
+                answered = True
+                chunk_pending = set(chunk)
+                terminal_ids |= {
+                    item.job_id
+                    for item in batch.results
+                    if item.job_id in chunk_pending and settle(item)
+                }
 
-            terminal_ids: Set[str] = {
-                item.job_id
-                for item in batch.results
-                if item.job_id in pending and settle(item)
-            }
+            if not answered and refused_ids:
+                # Nothing got through this tick; back off and retry.
+                continue
             pending = [jid for jid in pending if jid not in terminal_ids]
 
         if opts.timeout_ms > 0 and len(pending) == len(job_ids) and not last_seen:
             # Nothing settled and nothing was seen: the polls may all have been
             # refused. Confirm with one direct read before reporting anything.
-            try:
-                probed = await self.get_remember_bulk_status(list(job_ids))
-            except _HttpStatusError as err:
-                if err.status == 429:
-                    # Header first, else the body's retry_after_seconds, so a
-                    # proxy that strips Retry-After does not lose the hint.
-                    wait_ms = _retry_after_ms(err)
-                    retry_after = f"{wait_ms / 1000:g}" if wait_ms else None
-                    raise MemWalRateLimited(job_ids, retry_after) from err
-                # Any other probe failure is not evidence about the jobs.
-            except httpx.TransportError:
-                pass
-            else:
+            settled: Set[str] = set()
+            all_ids = list(job_ids)
+            for start in range(0, len(all_ids), MAX_BULK_STATUS_IDS):
+                chunk = all_ids[start : start + MAX_BULK_STATUS_IDS]
+                try:
+                    probed = await self.get_remember_bulk_status(chunk)
+                except _HttpStatusError as err:
+                    if err.status == 429:
+                        # Header first, else the body's retry_after_seconds, so a
+                        # proxy that strips Retry-After does not lose the hint.
+                        wait_ms = _retry_after_ms(err)
+                        retry_after = f"{wait_ms / 1000:g}" if wait_ms else None
+                        raise MemWalRateLimited(job_ids, retry_after) from err
+                    # Any other probe failure is not evidence about the jobs.
+                    continue
+                except httpx.TransportError:
+                    continue
                 answered = True
-                settled = {
+                pending_now = set(pending)
+                settled |= {
                     item.job_id
                     for item in probed.results
-                    if item.job_id in pending and settle(item)
+                    if item.job_id in pending_now and settle(item)
                 }
-                pending = [jid for jid in pending if jid not in settled]
+            pending = [jid for jid in pending if jid not in settled]
 
         for job_id in pending:
             seen = last_seen.get(job_id)
@@ -1057,6 +1105,7 @@ class MemWal:
             sort = params.sort
         else:
             query_text = query
+        _check_limit(limit)
         body = {
             "query": query_text,
             "limit": limit,
@@ -1299,6 +1348,7 @@ class MemWal:
               downloads in parallel, then 3 SEAL decrypts in parallel, then
               embeddings. Expect seconds-per-blob on cold caches.
         """
+        _check_limit(limit)
         data = await self._signed_request("POST", "/api/restore", {
             "namespace": namespace,
             "limit": limit,
@@ -1354,6 +1404,10 @@ class MemWal:
         Returns:
             :class:`NamespacesResult`.
         """
+        # Validate before resolving the owner: on a fresh client that lookup is
+        # a signed POST /api/stats, so a bad limit must not reach it (#1218).
+        if limit is not None:
+            _check_limit(limit)
         owner = await self._resolve_owner()
 
         params: Dict[str, str] = {}
@@ -1428,6 +1482,7 @@ class MemWal:
         Returns:
             :class:`RememberManualResult` with id, blob_id, owner, namespace.
         """
+        _check_vector(opts.vector)
         data = await self._signed_request(
             "POST",
             "/api/remember/manual",
@@ -1457,6 +1512,8 @@ class MemWal:
         Returns:
             :class:`RecallManualResult` with blob_id + distance pairs.
         """
+        _check_vector(opts.vector)
+        _check_limit(opts.limit)
         body: Dict[str, Any] = {
             "vector": opts.vector,
             "limit": opts.limit,
@@ -1751,7 +1808,9 @@ class MemWal:
 
         method_upper = method.upper()
         timestamp = str(int(time.time()))
-        body_str = "" if method_upper == "GET" else json.dumps(body, separators=(",", ":"))
+        body_str = "" if method_upper == "GET" else json.dumps(
+            body, separators=(",", ":"), allow_nan=False
+        )
         body_hash = sha256_hex(body_str)
         # MED-1 / LOW-23: nonce + account_id are part of the canonical signed
         # message. Server rejects the request as "unsupported legacy SDK"

memwal/middleware.py

@@ -55,7 +55,7 @@ from typing import (
 )
 
 from .client import MemWal, _with_fresh_http_client
-from .types import RecallMemory
+from .types import RecallMemory, RememberBulkOptions, RememberBulkResult
 
 if TYPE_CHECKING:
     from langchain_core.language_models.chat_models import BaseChatModel
@@ -178,6 +178,28 @@ def _format_memories(
     ])
 
 
+SAVE_MODES = ("analyze", "remember")
+"""Valid ``save_mode`` values for the auto-save path.
+
+``"analyze"`` extracts spoken-fact-style statements via the server LLM and
+stores one memory per fact — it is lossy by design, and non-sentence content
+(code snippets, structured data) yields zero facts. ``"remember"`` stores the
+user message verbatim as a single memory, which is what callers saving code or
+other non-conversational content want.
+"""
+
+
+def _validate_save_mode(save_mode: str) -> str:
+    if save_mode not in SAVE_MODES:
+        raise ValueError(
+            f"save_mode must be one of {SAVE_MODES}, got {save_mode!r}"
+        )
+    return save_mode
+
+
+_MAX_TRACKED_JOB_IDS = 1000
+
+
 class _PendingSaves:
     """Tracks in-flight fire-and-forget auto-save work (asyncio Tasks and
     background Threads) so a caller can drain it deterministically via
@@ -197,6 +219,7 @@ class _PendingSaves:
         self._failures: List[tuple[str, str]] = []
         self._dropped = 0
         self._on_save_error = on_save_error
+        self._job_ids: List[str] = []
         self._lock = threading.Lock()
         self._callback_threads: set[int] = set()
 
@@ -250,6 +273,23 @@ class _PendingSaves:
             f"Walrus Memory auto-save failed ({total} call(s)): {detail}"
         )
 
+    def track_job_ids(self, job_ids: List[str]) -> None:
+        """Record the background remember jobs an auto-save enqueued, so a
+        caller can later confirm they finished and read their blob IDs."""
+        if not job_ids:
+            return
+        with self._lock:
+            self._job_ids.extend(job_ids)
+            if len(self._job_ids) > _MAX_TRACKED_JOB_IDS:
+                del self._job_ids[:-_MAX_TRACKED_JOB_IDS]
+
+    def drain_job_ids(self) -> List[str]:
+        """Return every job ID recorded so far and forget them, so a second
+        wait does not re-poll jobs that already settled."""
+        with self._lock:
+            job_ids, self._job_ids = self._job_ids, []
+        return job_ids
+
     def track_task(self, task: "asyncio.Task[Any]") -> None:
         self._tasks.add(task)
         task.add_done_callback(self._tasks.discard)
@@ -333,6 +373,46 @@ class _PendingSaves:
             thread.join()
 
 
+async def _run_auto_save(
+    memwal: MemWal,
+    text: str,
+    namespace: str,
+    save_mode: str,
+    pending: _PendingSaves,
+    log: Callable[..., Any],
+) -> None:
+    """Persist `text` via the configured save mode and record its job IDs.
+
+    ``analyze()`` returns cleanly with zero facts for content it cannot read
+    as spoken facts (code, structured data), so a plain call there looks
+    identical to a successful save. Log in that case and point at
+    ``save_mode="remember"`` rather than dropping the write silently.
+    """
+    try:
+        if save_mode == "remember":
+            accepted = await memwal.remember(text, namespace)
+            if accepted is not None and getattr(accepted, "job_id", None):
+                pending.track_job_ids([accepted.job_id])
+            return
+
+        result = await memwal.analyze(text, namespace)
+        if result is None:
+            return
+        job_ids = list(getattr(result, "job_ids", None) or [])
+        facts = getattr(result, "facts", None)
+        pending.track_job_ids(job_ids)
+        if not facts and not job_ids:
+            log(
+                "[Walrus Memory] Auto-save extracted 0 facts from a "
+                f"{len(text)}-character message and stored nothing. analyze() "
+                "only extracts spoken-fact-style statements — pass "
+                'save_mode="remember" to store the message verbatim instead.'
+            )
+    except Exception as e:  # noqa: BLE001 -- auto-save must never break the LLM call
+        log(f"[Walrus Memory] Auto-save failed: {e}")
+        pending.note_error(e)
+
+
 def _expose_memwal_controls(obj: Any, memwal: MemWal, pending: _PendingSaves) -> None:
     """Attach the underlying client and a way to drain pending auto-saves —
     without this, a short-lived process has no way to avoid silently
@@ -349,9 +429,48 @@ def _expose_memwal_controls(obj: Any, memwal: MemWal, pending: _PendingSaves) ->
     (obj.memwal_flush) still finds it — OpenAI clients aren't Pydantic
     models and work the same way either way.
     """
+    async def memwal_wait_for_saves(
+        opts: Optional[RememberBulkOptions] = None,
+    ) -> RememberBulkResult:
+        """Drain pending auto-saves, then poll their remember jobs to a
+        terminal state and return per-job status + blob IDs."""
+        await pending.flush()
+        job_ids = pending.drain_job_ids()
+        try:
+            return await memwal.wait_for_remember_jobs(job_ids, opts)
+        except BaseException:
+            # Cancellation and interrupts must leave unconfirmed jobs available
+            # to the next wait, while still propagating to the caller.
+            pending.track_job_ids(job_ids)
+            raise
+
+    def memwal_wait_for_saves_sync(
+        opts: Optional[RememberBulkOptions] = None,
+    ) -> RememberBulkResult:
+        """Sync counterpart of ``memwal_wait_for_saves`` for callers on the
+        blocking entry points (``OpenAI``, ``llm.invoke``)."""
+        pending.flush_sync()
+        job_ids = pending.drain_job_ids()
+        try:
+            return _run_blocking(
+                lambda: _with_fresh_http_client(
+                    memwal, memwal.wait_for_remember_jobs(job_ids, opts)
+                )
+            )
+        except BaseException:
+            # Cancellation and interrupts must leave unconfirmed jobs available
+            # to the next wait, while still propagating to the caller.
+            pending.track_job_ids(job_ids)
+            raise
+
     object.__setattr__(obj, "_memwal", memwal)
+    # Public alias: reaching wait_for_remember_jobs() and the rest of the
+    # low-level client shouldn't require touching a private attribute.
+    object.__setattr__(obj, "memwal", memwal)
     object.__setattr__(obj, "memwal_flush", pending.flush)
     object.__setattr__(obj, "memwal_flush_sync", pending.flush_sync)
+    object.__setattr__(obj, "memwal_wait_for_saves", memwal_wait_for_saves)
+    object.__setattr__(obj, "memwal_wait_for_saves_sync", memwal_wait_for_saves_sync)
 
 
 async def _warn_if_cancelled(coro: Any, label: str) -> None:
@@ -416,6 +535,7 @@ def with_memwal_langchain(
     namespace: str = "default",
     max_memories: int = 5,
     auto_save: bool = True,
+    save_mode: str = "analyze",
     min_relevance: float = 0.3,
     debug: bool = False,
     env: Optional[str] = None,
@@ -438,6 +558,11 @@ def with_memwal_langchain(
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
+        save_mode: How auto_save persists the user message. ``"analyze"``
+            (default) extracts spoken-fact-style statements and stores one
+            memory per fact — non-sentence content such as code yields zero
+            facts and stores nothing. ``"remember"`` stores the message
+            verbatim as a single memory.
         min_relevance: Minimum similarity score (0-1) to include a memory.
         debug: Enable debug logging.
         env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
@@ -458,6 +583,8 @@ def with_memwal_langchain(
             "Install with: pip install memwal[langchain]"
         ) from e
 
+    _validate_save_mode(save_mode)
+
     memwal = MemWal.create(
         key=key,
         account_id=account_id,
@@ -552,16 +679,12 @@ def with_memwal_langchain(
             return messages
 
     async def _post_analyze(messages: List[BaseMessage]) -> None:
-        """Analyze user message for new facts."""
+        """Persist the user message via the configured save mode."""
         if not auto_save or not _is_last_message_user(messages):
             return
         user_text = _find_last_user_message(messages)
         if user_text:
-            try:
-                await memwal.analyze(user_text, namespace)
-            except Exception as e:
-                log(f"[Walrus Memory] Auto-save failed: {e}")
-                pending.note_error(e)
+            await _run_auto_save(memwal, user_text, namespace, save_mode, pending, log)
 
     async def patched_agenerate(
         messages: List[BaseMessage], *args: Any, **kwargs: Any
@@ -604,6 +727,7 @@ def with_memwal_openai(
     namespace: str = "default",
     max_memories: int = 5,
     auto_save: bool = True,
+    save_mode: str = "analyze",
     min_relevance: float = 0.3,
     debug: bool = False,
     env: Optional[str] = None,
@@ -628,6 +752,11 @@ def with_memwal_openai(
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
+        save_mode: How auto_save persists the user message. ``"analyze"``
+            (default) extracts spoken-fact-style statements and stores one
+            memory per fact — non-sentence content such as code yields zero
+            facts and stores nothing. ``"remember"`` stores the message
+            verbatim as a single memory.
         min_relevance: Minimum similarity score (0-1) to include a memory.
         debug: Enable debug logging.
         env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
@@ -639,6 +768,8 @@ def with_memwal_openai(
     Returns:
         The same client, with ``chat.completions.create`` wrapped to use Walrus Memory.
     """
+    _validate_save_mode(save_mode)
+
     memwal = MemWal.create(
         key=key,
         account_id=account_id,
@@ -654,11 +785,13 @@ def with_memwal_openai(
 
     if is_async:
         _wrap_async_openai(
-            client, memwal, namespace, max_memories, auto_save, min_relevance, log, pending
+            client, memwal, namespace, max_memories, auto_save, save_mode,
+            min_relevance, log, pending,
         )
     else:
         _wrap_sync_openai(
-            client, memwal, namespace, max_memories, auto_save, min_relevance, log, pending
+            client, memwal, namespace, max_memories, auto_save, save_mode,
+            min_relevance, log, pending,
         )
 
     _expose_memwal_controls(client, memwal, pending)
@@ -672,6 +805,7 @@ def _wrap_async_openai(
     namespace: str,
     max_memories: int,
     auto_save: bool,
+    save_mode: str,
     min_relevance: float,
     log: Callable[..., Any],
     pending: _PendingSaves,
@@ -725,18 +859,14 @@ def _wrap_async_openai(
 
         result = await original_create(*args, **kwargs)
 
-        # Fire-and-forget analyze
+        # Fire-and-forget auto-save
         if auto_save and _is_last_message_user(messages):
             user_text = _find_last_user_message(messages)
             if user_text:
-                async def _analyze() -> None:
-                    try:
-                        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)
+                _fire_and_forget(
+                    _run_auto_save(memwal, user_text, namespace, save_mode, pending, log),
+                    pending,
+                )
 
         return result
 
@@ -749,6 +879,7 @@ def _wrap_sync_openai(
     namespace: str,
     max_memories: int,
     auto_save: bool,
+    save_mode: str,
     min_relevance: float,
     log: Callable[..., Any],
     pending: _PendingSaves,
@@ -807,18 +938,25 @@ def _wrap_sync_openai(
 
         result = original_create(*args, **kwargs)
 
-        # Fire-and-forget analyze
+        # Fire-and-forget auto-save
         if auto_save and _is_last_message_user(messages):
             user_text = _find_last_user_message(messages)
             if user_text:
-                def _analyze() -> None:
+                def _save() -> None:
+                    # _run_auto_save swallows request failures itself; this guards
+                    # the loop/http-client plumbing around it so a failure there
+                    # can't take down the background thread.
                     try:
-                        _run_memwal(lambda: memwal.analyze(user_text, namespace))
-                    except Exception as e:
+                        _run_memwal(
+                            lambda: _run_auto_save(
+                                memwal, user_text, namespace, save_mode, pending, log
+                            )
+                        )
+                    except Exception as e:  # noqa: BLE001
                         log(f"[Walrus Memory] Auto-save failed: {e}")
                         pending.note_error(e)
 
-                pending.spawn_thread(_analyze)
+                pending.spawn_thread(_save)
 
         return result
 

memwal/mock.py

@@ -12,6 +12,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Sequence, Union
 
+from .client import _check_limit
 from .types import (
     AnalyzedFact,
     AnalyzeResult,
@@ -279,8 +280,7 @@ class MemWalMock:
             sort = None
             query_text = query
         _validate_text(query_text, "query")
-        if not isinstance(limit, int) or limit < 0:
-            raise ValueError("limit must be a non-negative integer")
+        _check_limit(limit)
         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
@@ -383,7 +383,7 @@ class MemWalMock:
         )
 
     async def restore(self, namespace: str, limit: int = 10) -> RestoreResult:
-        del limit
+        _check_limit(limit)
         return RestoreResult(
             restored=0,
             skipped=0,
@@ -399,6 +399,8 @@ class MemWalMock:
         cursor: Optional[str] = None,
         limit: Optional[int] = None,
     ) -> NamespacesResult:
+        if limit is not None:
+            _check_limit(limit)
         grouped: Dict[str, List[_Memory]] = {}
         for memory in self._memories:
             grouped.setdefault(memory.namespace, []).append(memory)

{memwal-0.2.0.dev0.dist-info → memwal-0.2.1.dev0.dist-info}/METADATA

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

@@ -0,0 +1,10 @@
+memwal/__init__.py,sha256=IAJWdWRnUVTD5bZN7EVWQ6Q511j27npZgD5aG_DMltk,3142
+memwal/client.py,sha256=GryxHSCyGjDmlWOTBSJp7J7ItopwUs0D1JdynrgjYTk,88398
+memwal/compatibility.py,sha256=FsKApCcHOFZeIeNOph3YydWVnZtMJdT0KCt0e6jylho,2799
+memwal/middleware.py,sha256=z2xdbvaobBg4byJXnrX7amWdVYE4jfeO4t31DoDBv_o,38413
+memwal/mock.py,sha256=5bXVej1Xs1a3o1tLL0Vvr1QB9IXyRUTBM7qooTEtysQ,24015
+memwal/types.py,sha256=xvs9BqFLXDsfkHp3-8Bd_Pv5RhDDWOKr0-bUsvic1P4,13732
+memwal/utils.py,sha256=Dyv-DWIMwivtYLxruHXlNXE9i8hZu8QDv1TapVKMeOQ,12064
+memwal-0.2.1.dev0.dist-info/METADATA,sha256=OiHVIIM8Tbpf4Mj0dsKObxQfxZD_1NqshTsKGthp9hE,10346
+memwal-0.2.1.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+memwal-0.2.1.dev0.dist-info/RECORD,,

memwal-0.2.0.dev0.dist-info/RECORD

@@ -1,10 +0,0 @@
-memwal/__init__.py,sha256=9v3THq6hHmf2gdlipB_r_M_o7rL8VH2FG9MVBBd7sjU,3142
-memwal/client.py,sha256=_cvh1Ye3cdf25wsioLBV7IKKeGonkF6TZd3w0UnUtR8,85589
-memwal/compatibility.py,sha256=FsKApCcHOFZeIeNOph3YydWVnZtMJdT0KCt0e6jylho,2799
-memwal/middleware.py,sha256=3KM_TdgAJ2EwG4uBrG-71gpEoLw5Ks3GFTmk9wZFsOc,32553
-memwal/mock.py,sha256=295USgDm14SfeOUMjx8bdsvjjGTRgl1FR34DYbGmWGM,24003
-memwal/types.py,sha256=xvs9BqFLXDsfkHp3-8Bd_Pv5RhDDWOKr0-bUsvic1P4,13732
-memwal/utils.py,sha256=Dyv-DWIMwivtYLxruHXlNXE9i8hZu8QDv1TapVKMeOQ,12064
-memwal-0.2.0.dev0.dist-info/METADATA,sha256=4y1c1a7ha5QjGeebDc43s_ZpZDLLDuZs-Sh6Mfj4g3Y,10346
-memwal-0.2.0.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-memwal-0.2.0.dev0.dist-info/RECORD,,