monkeyfs 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.1
+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.1 → 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.1 → monkeyfs-0.2.3}/monkeyfs/conformance.py

@@ -212,12 +212,21 @@ def _check_listing_paths(fs: Any, scratch: str) -> None:
             f"{absolute.get('probe.bin')!r}",
         )
 
-        deep = [info.path for info in fs.list_detailed(scratch, True)]
+        entries = fs.list_detailed(scratch, True)
+        deep = [info.path for info in entries]
         _require(
             f"{scratch}/nested/leaf.bin" in deep,
             f"a recursive list_detailed({scratch!r}) must name a nested entry "
             f"{scratch + '/nested/leaf.bin'!r}, got {deep!r}",
         )
+        for info in entries:
+            _require(
+                info.name == info.path.rsplit("/", 1)[-1],
+                f"list_detailed(...).name is the entry's own name, the last "
+                f"component of its path, at every depth: for path "
+                f"{info.path!r} expected {info.path.rsplit('/', 1)[-1]!r}, "
+                f"got {info.name!r}",
+            )
 
         start = fs.getcwd()
         fs.chdir(scratch)

{monkeyfs-0.2.1 → monkeyfs-0.2.3}/monkeyfs/mount.py

@@ -285,10 +285,11 @@ class MountFS:
         for name in names:
             full_abs = f"{norm}/{name}" if norm else f"/{name}"
             display = f"{user_prefix}/{name}" if user_prefix != "." else name
+            basename = name.rsplit("/", 1)[-1]
             meta = self.stat(full_abs)
             result.append(
                 FileInfo(
-                    name=name,
+                    name=basename,
                     path=display,
                     size=meta.size,
                     created_at=meta.created_at,

{monkeyfs-0.2.1 → 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.
 
@@ -1325,7 +1350,10 @@ class VirtualFS:
             recursive: If True, list all nested files and directories.
 
         Returns:
-            List of FileInfo objects sorted by name.
+            List of FileInfo objects sorted by path relative to the queried
+            directory, so a directory precedes its contents. ``name`` is the
+            entry's own name, the last component of ``path``, at every depth;
+            it is not what the list is ordered by.
 
         Example:
             >>> files = vfs.list_detailed("/shared")
@@ -1350,7 +1378,9 @@ class VirtualFS:
             internal_path = f"{base}/{name}" if base else name
             absolute = "/" + internal_path
 
-            # Display path preserves the user's queried prefix
+            # Display path preserves the user's queried prefix; the name
+            # is the last component alone, whatever depth the entry sits at.
+            basename = name.rsplit("/", 1)[-1]
             display = f"{user_prefix}/{name}" if user_prefix != "." else name
 
             meta = self._meta_at(internal_path)
@@ -1360,7 +1390,7 @@ class VirtualFS:
                 now = self._now_iso()
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=0,
                         created_at=meta.created_at if meta is not None else now,
@@ -1371,7 +1401,7 @@ class VirtualFS:
             elif meta is not None:
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=meta.size,
                         created_at=meta.created_at,
@@ -1385,7 +1415,7 @@ class VirtualFS:
                 now = self._now_iso()
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=len(content),
                         created_at=now,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.1
+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.1 → monkeyfs-0.2.3}/pyproject.toml

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

{monkeyfs-0.2.1 → monkeyfs-0.2.3}/tests/test_directory_ops.py

@@ -466,3 +466,51 @@ class TestImplicitDirectories:
         assert vfs.list("/") == ["pkg", "top.py"]
         assert vfs.list("pkg") == ["__init__.py", "sub", "utils.py"]
         assert vfs.list("pkg/sub") == ["mod.py"]
+
+
+# -- list_detailed().name is the entry's own name at every depth ---------------
+
+
+def _nested_tree(fs):
+    fs.makedirs("/probe/sub")
+    fs.write("/probe/one.txt", b"1")
+    fs.write("/probe/sub/two.txt", b"2")
+    return fs
+
+
+def _names_and_paths(fs):
+    # The sequence as returned, not a sorted copy: every backend orders a
+    # recursive listing by path relative to the queried directory, so a
+    # directory precedes its contents, and a backend that drifts from
+    # that order fails here rather than being tidied into agreement.
+    return [(i.name, i.path) for i in fs.list_detailed("/probe", recursive=True)]
+
+
+def test_virtualfs_recursive_listing_names_are_basenames():
+    from monkeyfs import VirtualFS
+
+    assert _names_and_paths(_nested_tree(VirtualFS({}))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]
+
+
+def test_mountfs_recursive_listing_names_are_basenames():
+    from monkeyfs import MountFS, VirtualFS
+
+    assert _names_and_paths(_nested_tree(MountFS(VirtualFS({})))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]
+
+
+def test_isolatedfs_recursive_listing_names_are_basenames(tmp_path):
+    from monkeyfs import IsolatedFS
+
+    assert _names_and_paths(_nested_tree(IsolatedFS(str(tmp_path)))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]

{monkeyfs-0.2.1 → 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"}

{monkeyfs-0.2.1 → monkeyfs-0.2.3}/tests/test_open_optional.py

@@ -190,7 +190,7 @@ class TermishFS:
             meta = self.stat(full)
             entries.append(
                 FileInfo(
-                    name=name,
+                    name=posixpath.basename(name),
                     path=display,
                     size=meta.size,
                     created_at=meta.created_at,