monkeyfs 0.2.3__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.3
+Version: 0.2.4
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT

{monkeyfs-0.2.3 → monkeyfs-0.2.4}/monkeyfs/base.py

@@ -162,7 +162,14 @@ OPTIONAL_WRITE_METHODS = frozenset(
 #: termish's shell over a filesystem. Not dispatched by any stdlib shim, but
 #: composable — a wrapper that routes by path can forward them.
 DIRECT_READ_METHODS = frozenset(
-    {"get_metadata_snapshot", "glob", "invalidate", "lexists", "list_detailed"}
+    {
+        "get_metadata_snapshot",
+        "glob",
+        "invalidate",
+        "lexists",
+        "list_detailed",
+        "read_many",
+    }
 )
 DIRECT_WRITE_METHODS = frozenset({"remove_many", "write_many"})
 

{monkeyfs-0.2.3 → monkeyfs-0.2.4}/monkeyfs/isolated.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import io
 import os
+from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -557,6 +558,22 @@ class IsolatedFS:
         """Create directory tree (alias for mkdir with parents=True)."""
         self.mkdir(path, parents=True, exist_ok=exist_ok)
 
+    def read_many(self, paths: Iterable[str]) -> dict[str, bytes]:
+        """Read several whole files: path (as given) to bytes, for the
+        paths that are files. A path that is not one is left out."""
+        found: dict[str, bytes] = {}
+        for path in paths:
+            # Regular files only (through a link, as ``isfile`` follows
+            # one): a socket cannot be read and a FIFO would block
+            # waiting for a writer.
+            if not self.isfile(path):
+                continue
+            try:
+                found[path] = self.read(path)
+            except (FileNotFoundError, IsADirectoryError, NotADirectoryError):
+                continue  # gone between the check and the read
+        return found
+
     def write_many(self, files: dict[str, bytes]) -> None:
         """Write multiple files at once."""
         for path, content in files.items():

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

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import errno
 import os
+from collections.abc import Iterable
 from datetime import datetime, timezone
 from typing import Any
 
@@ -16,6 +17,22 @@ from .base import FileInfo, FileMetadata
 from .virtualfile import open_file
 
 
+def _read_many(fs: Any, paths: list[str]) -> dict[str, bytes]:
+    """``fs.read_many(paths)``, or one ``read`` per path on a filesystem
+    that predates it -- a mount can be any backend, and ``read_many`` is
+    not one of the methods a backend has to have."""
+    batch = getattr(fs, "read_many", None)
+    if batch is not None:
+        return batch(paths)
+    found: dict[str, bytes] = {}
+    for path in paths:
+        try:
+            found[path] = fs.read(path)
+        except (FileNotFoundError, IsADirectoryError, NotADirectoryError):
+            continue
+    return found
+
+
 class MountFS:
     """Routes filesystem operations to backing filesystems by path prefix.
 
@@ -389,6 +406,27 @@ class MountFS:
             if drop is not None:
                 drop()
 
+    def read_many(self, paths: Iterable[str]) -> dict[str, bytes]:
+        # Group by filesystem, so each one answers its share in one call
+        groups: dict[int, tuple[Any, dict[str, list[str]]]] = {}
+        for path in paths:
+            if self._is_mount_point(self._to_absolute(path)):
+                # A mount point, or a directory the composition makes on
+                # the way to one: never a file here, whatever the base
+                # holds under the same name, just as ``isfile`` says.
+                continue
+            fs, inner = self._resolve(path)
+            key = id(fs)
+            if key not in groups:
+                groups[key] = (fs, {})
+            groups[key][1].setdefault(inner, []).append(path)
+        found: dict[str, bytes] = {}
+        for fs, inner_paths in groups.values():
+            for inner, content in _read_many(fs, list(inner_paths)).items():
+                for path in inner_paths[inner]:
+                    found[path] = content
+        return found
+
     # -- Write operations --
 
     def write(self, path: str, content: bytes, mode: str = "w") -> None:

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

@@ -8,7 +8,7 @@ import fnmatch
 import io
 import json
 import os
-from collections.abc import MutableMapping
+from collections.abc import Iterable, MutableMapping
 from datetime import datetime, timezone
 from typing import Any
 
@@ -678,6 +678,30 @@ class VirtualFS:
             return content[offset:]
         return content[offset : offset + size]
 
+    def read_many(self, paths: Iterable[str]) -> dict[str, bytes]:
+        """Read several whole files in one call to the backing state.
+
+        What ``read(path)`` returns for each path, gathered with a single
+        ``get_many`` when the state offers one -- so a caller reading a
+        whole tree pays one round trip to a remote store rather than one
+        per file.
+
+        Args:
+            paths: File paths to read, resolved against the current
+                working directory as ``read`` resolves them.
+
+        Returns:
+            Path (as given) to its bytes, for the paths that are files. A
+            path that is not one -- missing, or a directory -- is left out
+            rather than raised on: the caller asked about many at once and
+            learns which exist from the answer.
+        """
+        wanted: dict[str, list[str]] = {}
+        for path in paths:
+            wanted.setdefault(self._encode_path(path), []).append(path)
+        found = self._read_many(list(wanted))
+        return {path: content for key, content in found.items() for path in wanted[key]}
+
     def write(self, path: str, content: bytes, mode: str = "w") -> None:
         """Write bytes to a file.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.3
+Version: 0.2.4
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT

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

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

monkeyfs-0.2.4/tests/test_bulk_operations.py

@@ -0,0 +1,239 @@
+"""Tests for VirtualFS bulk operations (write_many, remove_many)."""
+
+import pytest
+
+from monkeyfs import VirtualFS
+
+
+class TestBulkOperations:
+    """Test VirtualFS bulk operations."""
+
+    def test_write_many_basic(self):
+        """Test writing multiple files at once."""
+        vfs = VirtualFS({})
+
+        files = {
+            "file1.txt": b"content 1",
+            "file2.txt": b"content 2",
+            "dir/file3.txt": b"content 3",
+        }
+
+        vfs.write_many(files)
+
+        # All files should exist
+        assert vfs.read("file1.txt") == b"content 1"
+        assert vfs.read("file2.txt") == b"content 2"
+        assert vfs.read("dir/file3.txt") == b"content 3"
+
+    def test_write_many_validates_all_bytes(self):
+        """Test that write_many validates all content is bytes."""
+        vfs = VirtualFS({})
+
+        files = {
+            "file1.txt": b"content 1",
+            "file2.txt": "not bytes",  # Invalid!
+        }
+
+        with pytest.raises(TypeError, match="Expected bytes for 'file2.txt'"):
+            vfs.write_many(files)
+
+        # No files should be written (validation happens first)
+        assert not vfs.exists("file1.txt")
+
+    def test_write_many_with_dict_state(self):
+        """Test that write_many works with dict state (no snapshot method)."""
+        vfs = VirtualFS({})
+
+        files = {
+            "file1.txt": b"content 1",
+            "file2.txt": b"content 2",
+        }
+
+        # Should not raise - dict doesn't have snapshot()
+        vfs.write_many(files)
+
+        assert vfs.exists("file1.txt")
+        assert vfs.exists("file2.txt")
+
+    def test_remove_many_basic(self):
+        """Test removing multiple files at once."""
+        vfs = VirtualFS({})
+
+        # Create files
+        vfs.write("file1.txt", b"content 1")
+        vfs.write("file2.txt", b"content 2")
+        vfs.write("file3.txt", b"content 3")
+
+        # Remove two of them
+        vfs.remove_many(["file1.txt", "file2.txt"])
+
+        # Removed files should not exist
+        assert not vfs.exists("file1.txt")
+        assert not vfs.exists("file2.txt")
+        # Remaining file should still exist
+        assert vfs.exists("file3.txt")
+
+    def test_remove_many_missing_file_removes_preceding(self):
+        """Test that remove_many removes files up to the missing one."""
+        vfs = VirtualFS({})
+
+        vfs.write("file1.txt", b"content 1")
+
+        with pytest.raises(FileNotFoundError):
+            vfs.remove_many(["file1.txt", "file2.txt"])
+
+        # file1.txt was removed before file2.txt failed
+        assert not vfs.exists("file1.txt")
+
+    def test_remove_many_empty_list(self):
+        """Test that removing empty list works."""
+        vfs = VirtualFS({})
+
+        # Should not raise
+        vfs.remove_many([])
+
+
+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}
+
+
+class TestReadMany:
+    def test_reads_every_file_in_one_call(self):
+        state = BatchingState()
+        vfs = VirtualFS(state)
+        for i in range(20):
+            vfs.write(f"/d{i % 2}/f{i}.txt", f"file {i}".encode())
+        state.gets.clear()
+        state.batches.clear()
+
+        found = vfs.read_many([f"/d{i % 2}/f{i}.txt" for i in range(20)])
+
+        assert found == {f"/d{i % 2}/f{i}.txt": f"file {i}".encode() for i in range(20)}
+        assert len(state.batches) == 1
+        assert state.gets == []
+
+    def test_leaves_out_what_is_not_a_file(self):
+        vfs = VirtualFS({})
+        vfs.write("/d/a.txt", b"a")
+
+        assert vfs.read_many(["/d/a.txt", "/d", "/nope.txt"]) == {"/d/a.txt": b"a"}
+
+    def test_answers_under_the_paths_as_given(self):
+        vfs = VirtualFS({})
+        vfs.write("/d/a.txt", b"a")
+        vfs.chdir("/d")
+
+        assert vfs.read_many(["a.txt", "/d/a.txt"]) == {
+            "a.txt": b"a",
+            "/d/a.txt": b"a",
+        }
+
+    def test_matches_read_without_get_many(self):
+        vfs = VirtualFS({})
+        vfs.write_many({"x.txt": b"x", "y/z.txt": b"z"})
+
+        assert vfs.read_many(["x.txt", "y/z.txt"]) == {
+            "x.txt": vfs.read("x.txt"),
+            "y/z.txt": vfs.read("y/z.txt"),
+        }
+
+    def test_empty(self):
+        assert VirtualFS({}).read_many([]) == {}
+
+    def test_isolated(self, tmp_path):
+        from monkeyfs import IsolatedFS
+
+        fs = IsolatedFS(str(tmp_path))
+        fs.write("a.txt", b"a")
+        fs.mkdir("d")
+
+        assert fs.read_many(["a.txt", "d", "missing.txt"]) == {"a.txt": b"a"}
+
+    def test_mount_routes_each_path_to_its_filesystem(self):
+        from monkeyfs import MountFS
+
+        base_state, mounted_state = BatchingState(), BatchingState()
+        base, mounted = VirtualFS(base_state), VirtualFS(mounted_state)
+        base.write("/top.txt", b"top")
+        mounted.write("/inner.txt", b"inner")
+        fs = MountFS(base, {"/m": mounted})
+        base_state.batches.clear()
+        mounted_state.batches.clear()
+
+        assert fs.read_many(["/top.txt", "/m/inner.txt", "/m/gone.txt"]) == {
+            "/top.txt": b"top",
+            "/m/inner.txt": b"inner",
+        }
+        assert len(base_state.batches) == 1
+        assert len(mounted_state.batches) == 1
+
+    def test_isolated_skips_what_is_not_a_regular_file(self, tmp_path):
+        import os
+
+        from monkeyfs import IsolatedFS
+
+        fs = IsolatedFS(str(tmp_path))
+        fs.write("a.txt", b"a")
+        os.mkfifo(tmp_path / "pipe")  # a read would block for a writer
+        os.symlink(tmp_path / "a.txt", tmp_path / "link")
+
+        assert fs.read_many(["a.txt", "pipe", "link"]) == {
+            "a.txt": b"a",
+            "link": b"a",
+        }
+
+    def test_mount_leaves_out_a_directory_a_mount_makes(self):
+        from monkeyfs import MountFS
+
+        base = VirtualFS({})
+        base.write("/a", b"hidden by the mount below")
+        base.write("/top.txt", b"top")
+        mounted = VirtualFS({})
+        mounted.write("/c.txt", b"c")
+        fs = MountFS(base, {"/a/b": mounted})
+
+        assert not fs.isfile("/a")
+        assert fs.read_many(["/a", "/a/b", "/a/b/c.txt", "/top.txt"]) == {
+            "/a/b/c.txt": b"c",
+            "/top.txt": b"top",
+        }
+
+    def test_mount_reads_a_filesystem_without_it_file_by_file(self):
+        from monkeyfs import MountFS
+
+        class Plain:
+            """A mounted backend with ``read`` and no ``read_many``."""
+
+            def __init__(self, files):
+                self.files = files
+
+            def read(self, path):
+                try:
+                    return self.files[path]
+                except KeyError:
+                    raise FileNotFoundError(path) from None
+
+        fs = MountFS(VirtualFS({}), {"/p": Plain({"/x.txt": b"x"})})
+
+        assert fs.read_many(["/p/x.txt", "/p/y.txt"]) == {"/p/x.txt": b"x"}
+
+    def test_read_only_forwards_it(self):
+        from monkeyfs import ReadOnlyFS
+
+        vfs = VirtualFS({})
+        vfs.write("a.txt", b"a")
+
+        assert ReadOnlyFS(vfs).read_many(["a.txt"]) == {"a.txt": b"a"}

{monkeyfs-0.2.3 → monkeyfs-0.2.4}/tests/test_readonly.py

@@ -436,6 +436,7 @@ READING_METHODS = {
     "open",
     "path_for_metadata_key",
     "read",
+    "read_many",
     "readlink",
     "realpath",
     "resolve_path",

monkeyfs-0.2.3/tests/test_bulk_operations.py

@@ -1,93 +0,0 @@
-"""Tests for VirtualFS bulk operations (write_many, remove_many)."""
-
-import pytest
-
-from monkeyfs import VirtualFS
-
-
-class TestBulkOperations:
-    """Test VirtualFS bulk operations."""
-
-    def test_write_many_basic(self):
-        """Test writing multiple files at once."""
-        vfs = VirtualFS({})
-
-        files = {
-            "file1.txt": b"content 1",
-            "file2.txt": b"content 2",
-            "dir/file3.txt": b"content 3",
-        }
-
-        vfs.write_many(files)
-
-        # All files should exist
-        assert vfs.read("file1.txt") == b"content 1"
-        assert vfs.read("file2.txt") == b"content 2"
-        assert vfs.read("dir/file3.txt") == b"content 3"
-
-    def test_write_many_validates_all_bytes(self):
-        """Test that write_many validates all content is bytes."""
-        vfs = VirtualFS({})
-
-        files = {
-            "file1.txt": b"content 1",
-            "file2.txt": "not bytes",  # Invalid!
-        }
-
-        with pytest.raises(TypeError, match="Expected bytes for 'file2.txt'"):
-            vfs.write_many(files)
-
-        # No files should be written (validation happens first)
-        assert not vfs.exists("file1.txt")
-
-    def test_write_many_with_dict_state(self):
-        """Test that write_many works with dict state (no snapshot method)."""
-        vfs = VirtualFS({})
-
-        files = {
-            "file1.txt": b"content 1",
-            "file2.txt": b"content 2",
-        }
-
-        # Should not raise - dict doesn't have snapshot()
-        vfs.write_many(files)
-
-        assert vfs.exists("file1.txt")
-        assert vfs.exists("file2.txt")
-
-    def test_remove_many_basic(self):
-        """Test removing multiple files at once."""
-        vfs = VirtualFS({})
-
-        # Create files
-        vfs.write("file1.txt", b"content 1")
-        vfs.write("file2.txt", b"content 2")
-        vfs.write("file3.txt", b"content 3")
-
-        # Remove two of them
-        vfs.remove_many(["file1.txt", "file2.txt"])
-
-        # Removed files should not exist
-        assert not vfs.exists("file1.txt")
-        assert not vfs.exists("file2.txt")
-        # Remaining file should still exist
-        assert vfs.exists("file3.txt")
-
-    def test_remove_many_missing_file_removes_preceding(self):
-        """Test that remove_many removes files up to the missing one."""
-        vfs = VirtualFS({})
-
-        vfs.write("file1.txt", b"content 1")
-
-        with pytest.raises(FileNotFoundError):
-            vfs.remove_many(["file1.txt", "file2.txt"])
-
-        # file1.txt was removed before file2.txt failed
-        assert not vfs.exists("file1.txt")
-
-    def test_remove_many_empty_list(self):
-        """Test that removing empty list works."""
-        vfs = VirtualFS({})
-
-        # Should not raise
-        vfs.remove_many([])