monkeyfs 0.2.2__tar.gz → 0.2.3__tar.gz

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.2
+Version: 0.2.3
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT
@@ -142,7 +142,7 @@ It raises `AssertionError` naming the method and what was expected of it -- incl
 
 ## Part of the agex stack
 
-monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including [kvgit](https://github.com/ashenfad/kvgit) `Staged` instances for a versioned filesystem with commit/rollback.
+monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including a [kvgit](https://github.com/ashenfad/kvgit) worktree for a versioned filesystem with commit/rollback. A store that offers `get_many(*keys)`, as kvgit worktrees do, has its metadata read in one batched call rather than one per file.
 
 ## Documentation
 

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/README.md

@@ -108,7 +108,7 @@ It raises `AssertionError` naming the method and what was expected of it -- incl
 
 ## Part of the agex stack
 
-monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including [kvgit](https://github.com/ashenfad/kvgit) `Staged` instances for a versioned filesystem with commit/rollback.
+monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including a [kvgit](https://github.com/ashenfad/kvgit) worktree for a versioned filesystem with commit/rollback. A store that offers `get_many(*keys)`, as kvgit worktrees do, has its metadata read in one batched call rather than one per file.
 
 ## Documentation
 

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/monkeyfs/virtual.py

@@ -10,6 +10,7 @@ import json
 import os
 from collections.abc import MutableMapping
 from datetime import datetime, timezone
+from typing import Any
 
 from .base import FileInfo, FileMetadata
 from .virtualfile import LazyBinaryFile, VirtualFile, open_file
@@ -19,7 +20,8 @@ class VirtualFS:
     """State-backed virtual filesystem with metadata tracking.
 
     Provides file operations backed by agent state. Each file is stored
-    as a separate state key, enabling granular versioning with Staged state.
+    as a separate state key, enabling granular versioning with a versioned
+    state such as a kvgit worktree.
 
     File metadata (size, creation time, modification time) is automatically
     tracked for all files and can be accessed via stat() or list_detailed().
@@ -77,6 +79,11 @@ class VirtualFS:
 
         Args:
             state: State backend for file storage. Defaults to an empty dict.
+                A state may also offer ``get_many(*keys)``, returning a
+                mapping of the keys that exist to their values (as kvgit
+                worktrees do). Scans that read many keys then ask for them
+                in one call, which over a networked store is one round
+                trip instead of one per key.
             max_size_mb: Maximum total size of all files in megabytes.
                 None means unlimited.
         """
@@ -417,10 +424,10 @@ class VirtualFS:
             return self._all_meta
 
         rows: dict[str, FileMetadata] = {}
-        for key in list(self._state.keys()):
-            if not self.is_metadata_key(key):
-                continue
-            raw = self._state.get(key)
+        keys = [key for key in list(self._state.keys()) if self.is_metadata_key(key)]
+        found = self._read_many(keys)
+        for key in keys:
+            raw = found.get(key)
             if raw is None:
                 continue
             try:
@@ -436,6 +443,24 @@ class VirtualFS:
         self._all_meta = rows
         return rows
 
+    def _read_many(self, keys: list[str]) -> dict[str, Any]:
+        """The values of ``keys`` that exist in the state.
+
+        One ``get_many`` call when the state offers it, else one ``get``
+        per key.
+        """
+        if not keys:
+            return {}
+        get_many = getattr(self._state, "get_many", None)
+        if callable(get_many):
+            return dict(get_many(*keys))
+        found: dict[str, Any] = {}
+        for key in keys:
+            value = self._state.get(key)
+            if value is not None:
+                found[key] = value
+        return found
+
     def _get_current_size(self) -> int:
         """Get total size of all files in the VFS.
 

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/monkeyfs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.2
+Version: 0.2.3
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT
@@ -142,7 +142,7 @@ It raises `AssertionError` naming the method and what was expected of it -- incl
 
 ## Part of the agex stack
 
-monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including [kvgit](https://github.com/ashenfad/kvgit) `Staged` instances for a versioned filesystem with commit/rollback.
+monkeyfs provides filesystem interception for [sandtrap](https://github.com/ashenfad/sandtrap) and [agex](https://github.com/ashenfad/agex), giving sandboxed agent code an isolated virtual filesystem. `VirtualFS` accepts any dict-like backing store -- including a [kvgit](https://github.com/ashenfad/kvgit) worktree for a versioned filesystem with commit/rollback. A store that offers `get_many(*keys)`, as kvgit worktrees do, has its metadata read in one batched call rather than one per file.
 
 ## Documentation
 

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "monkeyfs"
-version = "0.2.2"
+version = "0.2.3"
 description = "Transparent filesystem interception via monkey-patching."
 readme = "README.md"
 license = "MIT"

{monkeyfs-0.2.2 → monkeyfs-0.2.3}/tests/test_metadata.py

@@ -707,3 +707,70 @@ class TestLegacyTableMigration:
         assert vfs.isdir("d")
         assert set(rows(state)) == {"d/a.txt"}
         assert set(legacy_table(state)) == {"d"}
+
+
+class BatchingState(dict):
+    """A dict that also answers ``get_many``, counting how it is read."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.gets: list[str] = []
+        self.batches: list[tuple[str, ...]] = []
+
+    def get(self, key, default=None):
+        self.gets.append(key)
+        return super().get(key, default)
+
+    def get_many(self, *keys):
+        self.batches.append(keys)
+        return {k: dict.__getitem__(self, k) for k in keys if k in self}
+
+
+def _tree(vfs):
+    vfs.mkdir("/empty")
+    for i in range(30):
+        vfs.write(f"/d{i % 3}/f{i}.txt", b"x" * i)
+
+
+class TestBatchedMetadataScan:
+    def test_a_scan_reads_every_row_in_one_call(self):
+        state = BatchingState()
+        _tree(VirtualFS(state))
+        state.gets.clear()
+
+        fresh = VirtualFS(state)  # nothing cached
+        fresh.list("/", recursive=True)
+
+        assert len(state.batches) == 1
+        assert set(state.batches[0]) == {
+            k for k in state if VirtualFS.is_metadata_key(k)
+        }
+        assert not [k for k in state.gets if VirtualFS.is_metadata_key(k)]
+
+    def test_a_batching_state_answers_as_a_plain_one_does(self):
+        plain: dict = {}
+        _tree(VirtualFS(plain))
+        batching = BatchingState(plain)
+
+        def listing(state):
+            vfs = VirtualFS(state)
+            return [
+                (info.path, info.size, info.is_dir)
+                for info in vfs.list_detailed("/", recursive=True)
+            ]
+
+        assert listing(batching) == listing(plain)
+        assert (
+            VirtualFS(batching)._get_current_size()
+            == VirtualFS(plain)._get_current_size()
+        )
+
+    def test_the_legacy_table_still_fills_paths_without_rows(self):
+        state = BatchingState(
+            _legacy_state({"/old.txt": _entry(3)}, blobs={"/old.txt": b"abc"})
+        )
+        vfs = VirtualFS(state)
+        vfs.write("/new.txt", b"hello")
+        fresh = VirtualFS(state)
+        assert fresh.stat("/old.txt").size == 3
+        assert {i.path for i in fresh.list_detailed("/")} == {"/old.txt", "/new.txt"}