modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

test/traceback_test.py

@@ -1,135 +0,0 @@
-# Copyright Modal Labs 2024
-import pytest
-from pathlib import Path
-from traceback import extract_tb
-from typing import Dict, List, Tuple
-
-from modal._traceback import append_modal_tb, extract_traceback, reduce_traceback_to_user_code
-from modal._vendor import tblib
-
-from .supports.raise_error import raise_error
-
-SUPPORT_MODULE = "supports.raise_error"
-
-
-def call_raise_error():
-    raise_error()
-
-
-def test_extract_traceback():
-    task_id = "ta-123"
-    try:
-        call_raise_error()
-    except Exception as exc:
-        tb_dict, line_cache = extract_traceback(exc, task_id)
-
-    test_path = Path(__file__)
-    support_path = test_path.parent / (SUPPORT_MODULE.replace(".", "/") + ".py")
-
-    frame = tb_dict["tb_frame"]
-    assert tb_dict["tb_lineno"] == frame["f_lineno"] - 2
-    assert frame["f_code"]["co_filename"] == f"<{task_id}>:{test_path}"
-    assert frame["f_code"]["co_name"] == "test_extract_traceback"
-    assert frame["f_globals"]["__file__"] == str(test_path)
-    assert frame["f_globals"]["__name__"] == f"test.{test_path.name[:-3]}"
-    assert frame["f_locals"] == {}
-
-    frame = tb_dict["tb_next"]["tb_frame"]
-    assert frame["f_code"]["co_filename"] == f"<{task_id}>:{test_path}"
-    assert frame["f_code"]["co_name"] == "call_raise_error"
-    assert frame["f_globals"]["__file__"] == str(test_path)
-    assert frame["f_globals"]["__name__"] == f"test.{test_path.name[:-3]}"
-    assert frame["f_locals"] == {}
-
-    frame = tb_dict["tb_next"]["tb_next"]["tb_frame"]
-    assert frame["f_code"]["co_filename"] == f"<{task_id}>:{support_path}"
-    assert frame["f_code"]["co_name"] == "raise_error"
-    assert frame["f_globals"]["__file__"] == str(support_path)
-    assert frame["f_globals"]["__name__"] == f"test.{SUPPORT_MODULE}"
-    assert frame["f_locals"] == {}
-
-    assert tb_dict["tb_next"]["tb_next"]["tb_next"] is None
-
-    line_cache_list = list(line_cache.items())
-    assert line_cache_list[0][0][0] == str(test_path)
-    assert line_cache_list[0][1] == "call_raise_error()"
-    assert line_cache_list[1][0][0] == str(test_path)
-    assert line_cache_list[1][1] == "raise_error()"
-    assert line_cache_list[2][0][0] == str(support_path)
-    assert line_cache_list[2][1] == 'raise RuntimeError("Boo!")'
-
-
-def test_append_modal_tb():
-    task_id = "ta-123"
-    try:
-        call_raise_error()
-    except Exception as exc:
-        tb_dict, line_cache = extract_traceback(exc, task_id)
-
-    try:
-        raise RuntimeError("Remote error")
-    except Exception as exc:
-        remote_exc = exc
-        append_modal_tb(exc, tb_dict, line_cache)
-
-    assert remote_exc.__line_cache__ == line_cache  # type: ignore
-    frames = [f.name for f in extract_tb(remote_exc.__traceback__)]
-    assert frames == ["test_append_modal_tb", "call_raise_error", "raise_error"]
-
-
-def make_tb_stack(frames: List[Tuple[str, str]]) -> List[Dict]:
-    """Given a minimal specification of (code filename, code name), return dict formatted for tblib."""
-    tb_frames = []
-    for lineno, (filename, name) in enumerate(frames):
-        tb_frames.append(
-            {
-                "tb_lineno": lineno,
-                "tb_frame": {
-                    "f_lineno": lineno,
-                    "f_globals": {},
-                    "f_locals": {},
-                    "f_code": {"co_filename": filename, "co_name": name},
-                },
-            }
-        )
-    return tb_frames
-
-
-def tb_dict_from_stack_dicts(stack: List[Dict]) -> Dict:
-    tb_root = tb = stack.pop(0)
-    while stack:
-        tb["tb_next"] = stack.pop(0)
-        tb = tb["tb_next"]
-    tb["tb_next"] = None
-    return tb_root
-
-
-@pytest.mark.parametrize("user_mode", ["script", "module"])
-def test_reduce_traceback_to_user_code(user_mode):
-    if user_mode == "script":
-        user_source, user_filename, user_name = ("/root/user/ai.py", "/root/user/ai.py", "train")
-    elif user_mode == "module":
-        user_source, user_filename, user_name = ("ai.training", "/root/user/ai/training.py", "<module>")
-
-    stack = [
-        ("/modal/__main__.py", "main"),
-        ("/modal/entrypoint.py", "run"),
-        ("/site-packages/synchronicity/wizard.py", "magic"),
-        (user_filename, user_name),
-        ("/modal/function.py", "execute"),
-        ("/site-packages/synchronicity/devil.py", "pitchfork"),
-    ]
-
-    tb_dict = tb_dict_from_stack_dicts(make_tb_stack(stack))
-    tb = tblib.Traceback.from_dict(tb_dict)
-    tb_out = reduce_traceback_to_user_code(tb, user_source)
-
-    f = tb_out.tb_frame
-    assert f.f_code.co_filename == user_filename
-    assert f.f_code.co_name == user_name
-
-    f = tb_out.tb_next.tb_frame
-    assert f.f_code.co_filename == "/modal/function.py"
-    assert f.f_code.co_name == "execute"
-
-    assert tb_out.tb_next.tb_next is None

test/tunnel_test.py

@@ -1,29 +0,0 @@
-# Copyright Modal Labs 2023
-
-import pytest
-
-from modal import forward
-from modal.exception import InvalidError
-
-from .supports.skip import skip_windows_unix_socket
-
-
-def test_tunnel_outside_container(client):
-    with pytest.raises(InvalidError):
-        with forward(8000, client=client):
-            pass
-
-
-@skip_windows_unix_socket
-def test_invalid_port_numbers(container_client):
-    for port in (-1, 0, 65536):
-        with pytest.raises(InvalidError):
-            with forward(port, client=container_client):
-                pass
-
-
-@skip_windows_unix_socket
-def test_create_tunnel(container_client):
-    with forward(8000, client=container_client) as tunnel:
-        assert tunnel.host == "8000.modal.test"
-        assert tunnel.url == "https://8000.modal.test"

test/utils_test.py

@@ -1,88 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-import hashlib
-import io
-import pytest
-
-from modal._utils.app_utils import is_valid_app_name, is_valid_subdomain_label
-from modal._utils.blob_utils import BytesIOSegmentPayload
-
-
-def test_subdomain_label():
-    assert is_valid_subdomain_label("banana")
-    assert is_valid_subdomain_label("foo-123-456")
-    assert not is_valid_subdomain_label("BaNaNa")
-    assert not is_valid_subdomain_label(" ")
-    assert not is_valid_subdomain_label("ban/ana")
-
-
-def test_app_name():
-    assert is_valid_app_name("baNaNa")
-    assert is_valid_app_name("foo-123_456")
-    assert is_valid_app_name("a" * 64)
-    assert not is_valid_app_name("hello world")
-    assert not is_valid_app_name("a" * 65)
-
-
-@pytest.mark.asyncio
-async def test_file_segment_payloads():
-    data = io.BytesIO(b"abc123")
-    data2 = io.BytesIO(data.getbuffer())
-
-    class DummyOutput:  # AbstractStreamWriter
-        def __init__(self):
-            self.value = b""
-
-        async def write(self, chunk: bytes):
-            self.value += chunk
-
-    out1 = DummyOutput()
-    out2 = DummyOutput()
-    p1 = BytesIOSegmentPayload(data, 0, 3)
-    p2 = BytesIOSegmentPayload(data2, 3, 3)
-
-    # "out of order" writes
-    await p2.write(out2)  # type: ignore
-    await p1.write(out1)  # type: ignore
-    assert out1.value == b"abc"
-    assert out2.value == b"123"
-    assert p1.md5_checksum().digest() == hashlib.md5(b"abc").digest()
-    assert p2.md5_checksum().digest() == hashlib.md5(b"123").digest()
-
-    data = io.BytesIO(b"abc123")
-
-    # test reset_on_error
-    all_data = BytesIOSegmentPayload(data, 0, 6)
-
-    class DummyExc(Exception):
-        pass
-
-    try:
-        with all_data.reset_on_error():
-            await all_data.write(DummyOutput())  # type: ignore
-    except DummyExc:
-        pass
-
-    out = DummyOutput()
-    await all_data.write(out)  # type: ignore
-    assert out.value == b"abc123"
-
-
-@pytest.mark.asyncio
-async def test_file_segment_payloads_concurrency():
-    data = io.BytesIO((b"123" * 1024 * 350)[: 1024 * 1024])  # 1 MiB
-    data2 = io.BytesIO(data.getbuffer())
-
-    class DummyOutput:  # AbstractStreamWriter
-        def __init__(self):
-            self.value = b""
-
-        async def write(self, chunk: bytes):
-            self.value += chunk
-
-    out1 = DummyOutput()
-    out2 = DummyOutput()
-    p1 = BytesIOSegmentPayload(data, 0, len(data.getvalue()) // 2, chunk_size=100 * 1024)  # 100 KiB chunks
-    p2 = BytesIOSegmentPayload(data2, len(data.getvalue()) // 2, len(data.getvalue()) // 2, chunk_size=100 * 1024)
-    await asyncio.gather(p2.write(out2), p1.write(out1))  # type: ignore
-    assert out1.value + out2.value == data.getvalue()

test/version_test.py

@@ -1,14 +0,0 @@
-# Copyright Modal Labs 2022
-import pkg_resources
-
-import modal
-
-
-def test_version():
-    mod_version = modal.__version__
-    pkg_version = pkg_resources.require("modal")[0].version
-
-    assert pkg_resources.parse_version(mod_version) > pkg_resources.parse_version("0.0.0")
-    assert pkg_resources.parse_version(pkg_version) > pkg_resources.parse_version("0.0.0")
-
-    assert mod_version == pkg_version

test/volume_test.py

@@ -1,397 +0,0 @@
-# Copyright Modal Labs 2023
-import asyncio
-import io
-import os
-import platform
-import pytest
-import re
-import sys
-import time
-from pathlib import Path
-from unittest import mock
-
-import modal
-from modal.exception import DeprecationError, InvalidError, NotFoundError, VolumeUploadTimeoutError
-from modal.runner import deploy_app
-from modal.volume import _open_files_error_annotation
-from modal_proto import api_pb2
-
-
-def dummy():
-    pass
-
-
-def test_volume_mount(client, servicer):
-    app = modal.App()
-    vol = modal.Volume.from_name("xyz", create_if_missing=True)
-
-    _ = app.function(volumes={"/root/foo": vol})(dummy)
-
-    with app.run(client=client):
-        pass
-
-
-def test_volume_bad_paths():
-    app = modal.App()
-    vol = modal.Volume.from_name("xyz")
-
-    with pytest.raises(InvalidError):
-        app.function(volumes={"/root/../../foo": vol})(dummy)
-
-    with pytest.raises(InvalidError):
-        app.function(volumes={"/": vol})(dummy)
-
-    with pytest.raises(InvalidError):
-        app.function(volumes={"/tmp/": vol})(dummy)
-
-
-def test_volume_duplicate_mount():
-    app = modal.App()
-    vol = modal.Volume.from_name("xyz")
-
-    with pytest.raises(InvalidError):
-        app.function(volumes={"/foo": vol, "/bar": vol})(dummy)
-
-
-@pytest.mark.parametrize("skip_reload", [False, True])
-def test_volume_commit(client, servicer, skip_reload):
-    with servicer.intercept() as ctx:
-        ctx.add_response("VolumeCommit", api_pb2.VolumeCommitResponse(skip_reload=skip_reload))
-        ctx.add_response("VolumeCommit", api_pb2.VolumeCommitResponse(skip_reload=skip_reload))
-
-        with modal.Volume.ephemeral(client=client) as vol:
-            # Note that in practice this will not work unless run in a task.
-            vol.commit()
-
-            # Make sure we can commit through the provider too
-            vol.commit()
-
-            assert ctx.pop_request("VolumeCommit").volume_id == vol.object_id
-            assert ctx.pop_request("VolumeCommit").volume_id == vol.object_id
-
-            # commit should implicitly reload on successful commit if skip_reload=False
-            assert servicer.volume_reloads[vol.object_id] == 0 if skip_reload else 2
-
-
-@pytest.mark.asyncio
-async def test_volume_get(servicer, client, tmp_path):
-    await modal.Volume.create_deployed.aio("my-vol", client=client)
-    vol = await modal.Volume.lookup.aio("my-vol", client=client)  # type: ignore
-
-    file_contents = b"hello world"
-    file_path = b"foo.txt"
-    local_file_path = tmp_path / file_path.decode("utf-8")
-    local_file_path.write_bytes(file_contents)
-
-    async with vol.batch_upload() as batch:
-        batch.put_file(local_file_path, file_path.decode("utf-8"))
-
-    data = b""
-    for chunk in vol.read_file(file_path):
-        data += chunk
-    assert data == file_contents
-
-    output = io.BytesIO()
-    vol.read_file_into_fileobj(file_path, output)
-    assert output.getvalue() == file_contents
-
-    with pytest.raises(FileNotFoundError):
-        for _ in vol.read_file("/abc/def/i-dont-exist-at-all"):
-            ...
-
-
-def test_volume_reload(client, servicer):
-    with modal.Volume.ephemeral(client=client) as vol:
-        # Note that in practice this will not work unless run in a task.
-        vol.reload()
-
-        assert servicer.volume_reloads[vol.object_id] == 1
-
-
-def test_redeploy(servicer, client):
-    app = modal.App()
-
-    with pytest.warns(DeprecationError):
-        v1 = modal.Volume.new()
-        v2 = modal.Volume.new()
-        v3 = modal.Volume.new()
-        app.v1, app.v2, app.v3 = v1, v2, v3
-
-    # Deploy app once
-    deploy_app(app, "my-app", client=client)
-    app1_ids = [v1.object_id, v2.object_id, v3.object_id]
-
-    # Deploy app again
-    deploy_app(app, "my-app", client=client)
-    app2_ids = [v1.object_id, v2.object_id, v3.object_id]
-
-    # Make sure ids are stable
-    assert app1_ids == app2_ids
-
-    # Make sure ids are unique
-    assert len(set(app1_ids)) == 3
-    assert len(set(app2_ids)) == 3
-
-    # Deploy to a different app
-    deploy_app(app, "my-other-app", client=client)
-    app3_ids = [v1.object_id, v2.object_id, v3.object_id]
-
-    # Should be unique and different
-    assert len(set(app3_ids)) == 3
-    assert set(app1_ids) & set(app3_ids) == set()
-
-
-@pytest.mark.asyncio
-async def test_volume_batch_upload(servicer, client, tmp_path):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    local_dir = tmp_path / "some_dir"
-    local_dir.mkdir()
-    (local_dir / "smol").write_text("###")
-
-    subdir = local_dir / "subdir"
-    subdir.mkdir()
-    (subdir / "other").write_text("####")
-
-    async with modal.Volume.ephemeral(client=client) as vol:
-        with open(local_file_path, "rb") as fp:
-            with vol.batch_upload() as batch:
-                batch.put_file(local_file_path, "/some_file")
-                batch.put_directory(local_dir, "/some_dir")
-                batch.put_file(io.BytesIO(b"data from a file-like object"), "/filelike", mode=0o600)
-                batch.put_directory(local_dir, "/non-recursive", recursive=False)
-                batch.put_file(fp, "/filelike2")
-        object_id = vol.object_id
-
-    assert servicer.volume_files[object_id].keys() == {
-        "/some_file",
-        "/some_dir/smol",
-        "/some_dir/subdir/other",
-        "/filelike",
-        "/non-recursive/smol",
-        "/filelike2",
-    }
-    assert servicer.volume_files[object_id]["/some_file"].data == b"hello world"
-    assert servicer.volume_files[object_id]["/some_dir/smol"].data == b"###"
-    assert servicer.volume_files[object_id]["/some_dir/subdir/other"].data == b"####"
-    assert servicer.volume_files[object_id]["/filelike"].data == b"data from a file-like object"
-    assert servicer.volume_files[object_id]["/filelike"].mode == 0o600
-    assert servicer.volume_files[object_id]["/non-recursive/smol"].data == b"###"
-    assert servicer.volume_files[object_id]["/filelike2"].data == b"hello world"
-    assert servicer.volume_files[object_id]["/filelike2"].mode == 0o644
-
-
-@pytest.mark.asyncio
-async def test_volume_batch_upload_force(servicer, client, tmp_path):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    local_file_path2 = tmp_path / "some_file2"
-    local_file_path2.write_text("overwritten")
-
-    async with modal.Volume.ephemeral(client=client) as vol:
-        with servicer.intercept() as ctx:
-            # Seed the volume
-            with vol.batch_upload() as batch:
-                batch.put_file(local_file_path, "/some_file")
-            assert ctx.pop_request("VolumePutFiles").disallow_overwrite_existing_files
-
-            # Attempting to overwrite the file with force=False should result in an error
-            with pytest.raises(FileExistsError):
-                with vol.batch_upload(force=False) as batch:
-                    batch.put_file(local_file_path, "/some_file")
-            assert ctx.pop_request("VolumePutFiles").disallow_overwrite_existing_files
-            assert servicer.volume_files[vol.object_id]["/some_file"].data == b"hello world"
-
-            # Overwriting should work with force=True
-            with vol.batch_upload(force=True) as batch:
-                batch.put_file(local_file_path2, "/some_file")
-            assert not ctx.pop_request("VolumePutFiles").disallow_overwrite_existing_files
-            assert servicer.volume_files[vol.object_id]["/some_file"].data == b"overwritten"
-
-
-@pytest.mark.asyncio
-async def test_volume_upload_removed_file(servicer, client, tmp_path):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    async with modal.Volume.ephemeral(client=client) as vol:
-        with pytest.raises(FileNotFoundError):
-            with vol.batch_upload() as batch:
-                batch.put_file(local_file_path, "/dest")
-                local_file_path.unlink()
-
-
-@pytest.mark.asyncio
-async def test_volume_upload_large_file(client, tmp_path, servicer, blob_server, *args):
-    with mock.patch("modal._utils.blob_utils.LARGE_FILE_LIMIT", 10):
-        local_file_path = tmp_path / "bigfile"
-        local_file_path.write_text("hello world, this is a lot of text")
-
-        async with modal.Volume.ephemeral(client=client) as vol:
-            async with vol.batch_upload() as batch:
-                batch.put_file(local_file_path, "/a")
-            object_id = vol.object_id
-
-        assert servicer.volume_files[object_id].keys() == {"/a"}
-        assert servicer.volume_files[object_id]["/a"].data == b""
-        assert servicer.volume_files[object_id]["/a"].data_blob_id == "bl-1"
-
-        _, blobs = blob_server
-        assert blobs["bl-1"] == b"hello world, this is a lot of text"
-
-
-@pytest.mark.asyncio
-async def test_volume_upload_file_timeout(client, tmp_path, servicer, blob_server, *args):
-    call_count = 0
-
-    async def mount_put_file(self, stream):
-        await stream.recv_message()
-        nonlocal call_count
-        call_count += 1
-        await stream.send_message(api_pb2.MountPutFileResponse(exists=False))
-
-    with servicer.intercept() as ctx:
-        ctx.set_responder("MountPutFile", mount_put_file)
-        with mock.patch("modal._utils.blob_utils.LARGE_FILE_LIMIT", 10):
-            with mock.patch("modal.volume.VOLUME_PUT_FILE_CLIENT_TIMEOUT", 0.5):
-                local_file_path = tmp_path / "bigfile"
-                local_file_path.write_text("hello world, this is a lot of text")
-
-                async with modal.Volume.ephemeral(client=client) as vol:
-                    with pytest.raises(VolumeUploadTimeoutError):
-                        async with vol.batch_upload() as batch:
-                            batch.put_file(local_file_path, "/dest")
-
-                assert call_count > 2
-
-
-@pytest.mark.asyncio
-async def test_volume_copy_1(client, tmp_path, servicer):
-    ## test 1: copy src path to dst path ##
-    src_path = "original.txt"
-    dst_path = "copied.txt"
-    local_file_path = tmp_path / src_path
-    local_file_path.write_text("test copy")
-
-    async with modal.Volume.ephemeral(client=client) as vol:
-        # add local file to volume
-        async with vol.batch_upload() as batch:
-            batch.put_file(local_file_path, src_path)
-        object_id = vol.object_id
-
-        # copy file from src_path to dst_path
-        vol.copy_files([src_path], dst_path)
-
-    assert servicer.volume_files[object_id].keys() == {src_path, dst_path}
-
-    assert servicer.volume_files[object_id][src_path].data == b"test copy"
-    assert servicer.volume_files[object_id][dst_path].data == b"test copy"
-
-
-@pytest.mark.asyncio
-async def test_volume_copy_2(client, tmp_path, servicer):
-    ## test 2: copy multiple files into a directory ##
-    file_paths = ["file1.txt", "file2.txt"]
-
-    async with modal.Volume.ephemeral(client=client) as vol:
-        for file_path in file_paths:
-            local_file_path = tmp_path / file_path
-            local_file_path.write_text("test copy")
-            async with vol.batch_upload() as batch:
-                batch.put_file(local_file_path, file_path)
-            object_id = vol.object_id
-
-        vol.copy_files(file_paths, "test_dir")
-
-    returned_volume_files = [Path(file) for file in servicer.volume_files[object_id].keys()]
-    expected_volume_files = [
-        Path(file) for file in ["file1.txt", "file2.txt", "test_dir/file1.txt", "test_dir/file2.txt"]
-    ]
-
-    assert returned_volume_files == expected_volume_files
-
-    returned_file_data = {
-        Path(entry): servicer.volume_files[object_id][entry] for entry in servicer.volume_files[object_id]
-    }
-    assert returned_file_data[Path("test_dir/file1.txt")].data == b"test copy"
-    assert returned_file_data[Path("test_dir/file2.txt")].data == b"test copy"
-
-
-@pytest.mark.parametrize("delete_as_instance_method", [True, False])
-def test_persisted(servicer, client, delete_as_instance_method):
-    # Lookup should fail since it doesn't exist
-    with pytest.raises(NotFoundError):
-        modal.Volume.lookup("xyz", client=client)
-
-    # Create it
-    modal.Volume.lookup("xyz", create_if_missing=True, client=client)
-
-    # Lookup should succeed now
-    v = modal.Volume.lookup("xyz", client=client)
-
-    # Delete it
-    if delete_as_instance_method:
-        with pytest.warns(DeprecationError):
-            v.delete()
-    else:
-        modal.Volume.delete("xyz", client=client)
-
-    # Lookup should fail again
-    with pytest.raises(NotFoundError):
-        modal.Volume.lookup("xyz", client=client)
-
-
-def test_ephemeral(servicer, client):
-    assert servicer.n_vol_heartbeats == 0
-    with modal.Volume.ephemeral(client=client, _heartbeat_sleep=1) as vol:
-        assert vol.listdir("/") == []
-        # TODO(erikbern): perform some operations
-        time.sleep(1.5)  # Make time for 2 heartbeats
-    assert servicer.n_vol_heartbeats == 2
-
-
-def test_lazy_hydration_from_named(set_env_client):
-    vol = modal.Volume.from_name("my-vol", create_if_missing=True)
-    assert vol.listdir("/") == []
-
-
-@pytest.mark.skipif(platform.system() != "Linux", reason="needs /proc")
-@pytest.mark.asyncio
-async def test_open_files_error_annotation(tmp_path):
-    assert _open_files_error_annotation(tmp_path) is None
-
-    # Current process keeps file open
-    with (tmp_path / "foo.txt").open("w") as _f:
-        assert _open_files_error_annotation(tmp_path) == "path foo.txt is open"
-
-    # cwd of current process is inside volume
-    cwd = os.getcwd()
-    os.chdir(tmp_path)
-    assert _open_files_error_annotation(tmp_path) == "cwd is inside volume"
-    os.chdir(cwd)
-
-    # Subprocess keeps open file
-    open_path = tmp_path / "bar.txt"
-    open_path.write_text("")
-    proc = await asyncio.create_subprocess_exec("tail", "-f", open_path.as_posix())
-    await asyncio.sleep(0.01)  # Give process some time to start
-    assert _open_files_error_annotation(tmp_path) == f"path bar.txt is open from 'tail -f {open_path.as_posix()}'"
-    proc.kill()
-    await proc.wait()
-    assert _open_files_error_annotation(tmp_path) is None
-
-    # Subprocess cwd inside volume
-    proc = await asyncio.create_subprocess_exec(
-        sys.executable, "-c", f"import time; import os; os.chdir('{tmp_path}'); time.sleep(60)"
-    )
-    # Wait for process to chdir
-    for _ in range(100):
-        if os.readlink(f"/proc/{proc.pid}/cwd") == tmp_path.as_posix():
-            break
-        await asyncio.sleep(0.05)
-    assert re.match(f"^cwd of '{sys.executable} -c .*' is inside volume$", _open_files_error_annotation(tmp_path))
-    proc.kill()
-    await proc.wait()
-    assert _open_files_error_annotation(tmp_path) is None