monkeyfs 0.2.3__tar.gz → 0.2.5__tar.gz

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

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

{monkeyfs-0.2.3 → monkeyfs-0.2.5}/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.5}/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.5}/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.5}/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
 
@@ -536,6 +536,18 @@ class VirtualFS:
         """
         return dict(self._meta_all())
 
+    @staticmethod
+    def _absolute(normalized: str) -> str:
+        """A normalized key as an absolute path, for handing back to a
+        method that resolves its argument.
+
+        ``resolve_path`` returns the key form, which has no leading
+        slash; passed on as it is, the next method reads it as relative
+        to the working directory and names a different path whenever
+        that is not ``/``.
+        """
+        return "/" + normalized.strip("/")
+
     def _normalize_path(self, path: str) -> str:
         """Normalize file path for consistent internal keys.
 
@@ -678,6 +690,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.
 
@@ -1070,11 +1106,12 @@ class VirtualFS:
         if parent and not self.isdir("/" + parent):
             raise FileNotFoundError(f"No such file or directory: '{path}'")
 
-        # Check if already exists
-        absolute = "/" + normalized
-        if self.isfile(path):
+        # Check if already exists (on the absolute path: ``path`` is the
+        # key form, and checked as it is it would resolve a second time)
+        absolute = self._absolute(normalized)
+        if self.isfile(absolute):
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
-        if self.isdir(path):
+        if self.isdir(absolute):
             if exist_ok:
                 return
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
@@ -1106,8 +1143,8 @@ class VirtualFS:
         """
         path = self.resolve_path(path)
 
-        if not exist_ok and self.isdir(path):
-            absolute = "/" + path.strip("/")
+        if not exist_ok and self.isdir(self._absolute(path)):
+            absolute = self._absolute(path)
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
 
         parts = path.strip("/").split("/")
@@ -1133,16 +1170,19 @@ class VirtualFS:
         """
         path = self.resolve_path(path)
         normalized = self._normalize_path(path)
-
-        if not self.exists(path):
-            raise FileNotFoundError(f"No such directory: {path}")
-        if self.isfile(path):
-            raise NotADirectoryError(f"Not a directory: {path}")
-        if not self.isdir(path):
-            raise FileNotFoundError(f"No such directory: {path}")
+        # Checked on the absolute path: ``path`` is the key form, and the
+        # checks resolve their argument again.
+        absolute = self._absolute(normalized)
+
+        if not self.exists(absolute):
+            raise FileNotFoundError(f"No such directory: {absolute}")
+        if self.isfile(absolute):
+            raise NotADirectoryError(f"Not a directory: {absolute}")
+        if not self.isdir(absolute):
+            raise FileNotFoundError(f"No such directory: {absolute}")
 
         # Check if directory is empty
-        children = self.list(path)
+        children = self.list(absolute)
         if children:
             raise OSError(f"Directory not empty: {path}")
 

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

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

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

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

monkeyfs-0.2.5/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.5}/tests/test_directory_ops.py

@@ -514,3 +514,63 @@ def test_isolatedfs_recursive_listing_names_are_basenames(tmp_path):
         ("sub", "/probe/sub"),
         ("two.txt", "/probe/sub/two.txt"),
     ]
+
+
+# -- a working directory other than / (issue #30) -------------------------
+#
+# rmdir, mkdir and makedirs resolved a path, then handed the result (the
+# key form, with no leading slash) to checks that resolved it again,
+# relative to the working directory. From / the two resolutions agreed;
+# from anywhere else they named different paths.
+
+
+@pytest.fixture(params=["/", "/workspace", "/workspace/src"])
+def cwd_fs(request):
+    fs = VirtualFS({})
+    fs.makedirs("/workspace/src/inner", exist_ok=True)
+    fs.write("/workspace/f.txt", b"data")
+    fs.chdir(request.param)
+    return fs
+
+
+def test_rmdir_removes_an_empty_directory_from_any_cwd(cwd_fs):
+    cwd_fs.rmdir("/workspace/src/inner")
+    assert not cwd_fs.exists("/workspace/src/inner")
+
+
+def test_rmdir_refuses_a_missing_directory_by_its_absolute_path(cwd_fs):
+    with pytest.raises(FileNotFoundError, match="/workspace/nope"):
+        cwd_fs.rmdir("/workspace/nope")
+
+
+def test_rmdir_refuses_a_file_from_any_cwd(cwd_fs):
+    with pytest.raises(NotADirectoryError):
+        cwd_fs.rmdir("/workspace/f.txt")
+
+
+def test_mkdir_refuses_an_existing_directory_from_any_cwd(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.mkdir("/workspace/src")
+
+
+def test_mkdir_refuses_an_existing_file_and_leaves_it_a_file(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.mkdir("/workspace/f.txt")
+    assert cwd_fs.isfile("/workspace/f.txt")
+    assert not cwd_fs.isdir("/workspace/f.txt")
+    assert cwd_fs.read("/workspace/f.txt") == b"data"
+
+
+def test_makedirs_without_exist_ok_refuses_an_existing_directory(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.makedirs("/workspace/src", exist_ok=False)
+
+
+def test_a_relative_rmdir_and_mkdir_resolve_against_the_cwd():
+    fs = VirtualFS({})
+    fs.makedirs("/workspace/src", exist_ok=True)
+    fs.chdir("/workspace")
+    fs.mkdir("new")
+    assert fs.isdir("/workspace/new")
+    fs.rmdir("src")
+    assert not fs.exists("/workspace/src")

{monkeyfs-0.2.3 → monkeyfs-0.2.5}/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([])