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

test/mounted_files_test.py

@@ -1,327 +0,0 @@
-# Copyright Modal Labs 2022
-import os
-import pytest
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest_asyncio
-
-import modal
-from modal import Mount
-from modal.mount import get_auto_mounts
-
-from . import helpers
-from .supports.skip import skip_windows
-
-
-@pytest.fixture
-def venv_path(tmp_path, repo_root):
-    venv_path = tmp_path
-    subprocess.run([sys.executable, "-m", "venv", venv_path, "--copies", "--system-site-packages"], check=True)
-    # Install Modal and a tiny package in the venv.
-    subprocess.run([venv_path / "bin" / "python", "-m", "pip", "install", "-e", repo_root], check=True)
-    subprocess.run([venv_path / "bin" / "python", "-m", "pip", "install", "--force-reinstall", "six"], check=True)
-    yield venv_path
-
-
-@pytest.fixture
-def path_with_symlinked_files(tmp_path):
-    src = tmp_path / "foo.txt"
-    src.write_text("Hello")
-    trg = tmp_path / "bar.txt"
-    trg.symlink_to(src)
-    return tmp_path, {src, trg}
-
-
-script_path = "pkg_a/script.py"
-
-
-def f():
-    pass
-
-
-@pytest_asyncio.fixture
-async def env_mount_files():
-    # If something is installed using pip -e, it will be bundled up as a part of the environment.
-    # Those are env-specific so we ignore those as a part of the test
-    filenames = []
-    for mount in get_auto_mounts():
-        async for file_info in mount._get_files(mount.entries):
-            filenames.append(file_info.mount_filename)
-
-    return filenames
-
-
-def test_mounted_files_script(servicer, supports_dir, env_mount_files, server_url_env):
-    helpers.deploy_app_externally(servicer, script_path, cwd=supports_dir)
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-
-    # Assert we include everything from `pkg_a` and `pkg_b` but not `pkg_c`:
-    assert files == {
-        "/root/a.py",
-        "/root/b/c.py",
-        "/root/b/e.py",
-        "/root/pkg_b/__init__.py",
-        "/root/pkg_b/f.py",
-        "/root/pkg_b/g/h.py",
-        "/root/script.py",
-    }
-
-
-serialized_fn_path = "pkg_a/serialized_fn.py"
-
-
-def test_mounted_files_serialized(servicer, supports_dir, env_mount_files, server_url_env):
-    helpers.deploy_app_externally(servicer, serialized_fn_path, cwd=supports_dir)
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-
-    # Assert we include everything from `pkg_a` and `pkg_b` but not `pkg_c`:
-    assert (
-        files
-        == {
-            "/root/serialized_fn.py",  # should serialized_fn be included? It's not needed to run the function, but it's loaded into sys.modules at definition time...
-            "/root/b/c.py",  # this is mounted under root since it's imported as `import b` and not `import pkg_a.b` from serialized_fn.py
-            "/root/b/e.py",  # same as above
-            "/root/a.py",  # same as above
-            "/root/pkg_b/__init__.py",
-            "/root/pkg_b/f.py",
-            "/root/pkg_b/g/h.py",
-        }
-    )
-
-
-def test_mounted_files_package(supports_dir, env_mount_files, servicer, server_url_env):
-    p = subprocess.run(["modal", "run", "pkg_a.package"], cwd=supports_dir)
-    assert p.returncode == 0
-
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-    # Assert we include everything from `pkg_a` and `pkg_b` but not `pkg_c`:
-    assert files == {
-        "/root/pkg_a/__init__.py",
-        "/root/pkg_a/a.py",
-        "/root/pkg_a/b/c.py",
-        "/root/pkg_a/d.py",
-        "/root/pkg_a/b/e.py",
-        "/root/pkg_a/script.py",
-        "/root/pkg_a/serialized_fn.py",
-        "/root/pkg_a/package.py",
-        "/root/pkg_b/__init__.py",
-        "/root/pkg_b/f.py",
-        "/root/pkg_b/g/h.py",
-    }
-
-
-def test_mounted_files_package_no_automount(supports_dir, env_mount_files, servicer, server_url_env):
-    # when triggered like a module, the target module should be put at the correct package path
-    p = subprocess.run(
-        ["modal", "run", "pkg_a.package"],
-        cwd=supports_dir,
-        capture_output=True,
-        env={**os.environ, "MODAL_AUTOMOUNT": "0"},
-    )
-    assert p.returncode == 0
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-    assert files == {
-        "/root/pkg_a/__init__.py",
-        "/root/pkg_a/package.py",
-    }
-
-
-@skip_windows("venvs behave differently on Windows.")
-def test_mounted_files_sys_prefix(servicer, supports_dir, venv_path, env_mount_files, server_url_env):
-    # Run with venv activated, so it's on sys.prefix, and modal is dev-installed in the VM
-    subprocess.run(
-        [venv_path / "bin" / "modal", "run", script_path],
-        cwd=supports_dir,
-    )
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-    # Assert we include everything from `pkg_a` and `pkg_b` but not `pkg_c`:
-    assert files == {
-        "/root/a.py",
-        "/root/b/c.py",
-        "/root/b/e.py",
-        "/root/script.py",
-        "/root/pkg_b/__init__.py",
-        "/root/pkg_b/f.py",
-        "/root/pkg_b/g/h.py",
-    }
-
-
-@pytest.fixture
-def symlinked_python_installation_venv_path(tmp_path, repo_root):
-    # sets up a symlink to the python *installation* (not just the python binary)
-    # and initialize the virtualenv using a path via that symlink
-    # This makes the file paths of any stdlib modules use the symlinked path
-    # instead of the original, which is similar to what some tools do (e.g. mise)
-    # and has the potential to break automounting behavior, so we keep this
-    # test as a regression test for that
-    venv_path = tmp_path / "venv"
-    actual_executable = Path(sys.executable).resolve()
-    assert actual_executable.parent.name == "bin"
-    python_install_dir = actual_executable.parent.parent
-    # create a symlink to the python install *root*
-    symlink_python_install = tmp_path / "python-install"
-    symlink_python_install.symlink_to(python_install_dir)
-
-    # use a python executable specified via the above symlink
-    symlink_python_executable = symlink_python_install / "bin" / "python"
-    # create a new venv
-    subprocess.check_call([symlink_python_executable, "-m", "venv", venv_path, "--copies"])
-    # check that a builtin module, like ast, is indeed identified to be in the non-resolved install path
-    # since this is the source of bugs that we want to assert we don't run into!
-    ast_path = subprocess.check_output(
-        [venv_path / "bin" / "python", "-c", "import ast; print(ast.__file__);"], encoding="utf8"
-    )
-    assert ast_path != Path(ast_path).resolve()
-
-    # install modal from current dir
-    subprocess.check_call([venv_path / "bin" / "pip", "install", repo_root])
-    yield venv_path
-
-
-@skip_windows("venvs behave differently on Windows.")
-def test_mounted_files_symlinked_python_install(
-    symlinked_python_installation_venv_path, supports_dir, server_url_env, servicer
-):
-    subprocess.check_call(
-        [symlinked_python_installation_venv_path / "bin" / "modal", "run", supports_dir / "imports_ast.py"]
-    )
-    assert "/root/ast.py" not in servicer.files_name2sha
-
-
-def test_mounted_files_config(servicer, supports_dir, env_mount_files, server_url_env):
-    p = subprocess.run(
-        ["modal", "run", "pkg_a/script.py"], cwd=supports_dir, env={**os.environ, "MODAL_AUTOMOUNT": "0"}
-    )
-    assert p.returncode == 0
-    files = set(servicer.files_name2sha.keys()) - set(env_mount_files)
-    assert files == {
-        "/root/script.py",
-    }
-
-
-def test_e2e_modal_run_py_file_mounts(servicer, supports_dir):
-    helpers.deploy_app_externally(servicer, "hello.py", cwd=supports_dir)
-    # Reactivate the following mount assertions when we remove auto-mounting of dev-installed packages
-    # assert len(servicer.files_name2sha) == 1
-    # assert servicer.n_mounts == 1  # there should be a single mount
-    # assert servicer.n_mount_files == 1
-    assert "/root/hello.py" in servicer.files_name2sha
-
-
-def test_e2e_modal_run_py_module_mounts(servicer, supports_dir):
-    helpers.deploy_app_externally(servicer, "hello", cwd=supports_dir)
-    # Reactivate the following mount assertions when we remove auto-mounting of dev-installed packages
-    # assert len(servicer.files_name2sha) == 1
-    # assert servicer.n_mounts == 1  # there should be a single mount
-    # assert servicer.n_mount_files == 1
-    assert "/root/hello.py" in servicer.files_name2sha
-
-
-def foo():
-    pass
-
-
-def test_mounts_are_not_traversed_on_declaration(test_dir, monkeypatch, client, server_url_env):
-    return_values = []
-    original = modal.mount._MountDir.get_files_to_upload
-
-    def mock_get_files_to_upload(self):
-        r = list(original(self))
-        return_values.append(r)
-        return r
-
-    monkeypatch.setattr("modal.mount._MountDir.get_files_to_upload", mock_get_files_to_upload)
-    app = modal.App()
-    mount_with_many_files = Mount.from_local_dir(test_dir, remote_path="/test")
-    app.function(mounts=[mount_with_many_files])(foo)
-    assert len(return_values) == 0  # ensure we don't look at the files yet
-
-    with app.run(client=client):
-        pass
-
-    assert return_values  # at this point we should have gotten all the mount files
-    # flatten inspected files
-    files = set()
-    for r in return_values:
-        for fn, _ in r:
-            files.add(fn)
-    # sanity check - this test file should be included since we mounted the test dir
-    assert __file__ in files  # this test file should have been included
-
-
-def test_mount_dedupe(servicer, test_dir, server_url_env):
-    supports_dir = test_dir / "supports"
-    normally_not_included_file = supports_dir / "pkg_a" / "normally_not_included.pyc"
-    normally_not_included_file.touch(exist_ok=True)
-    print(
-        helpers.deploy_app_externally(
-            # no explicit mounts, rely on auto-mounting
-            servicer,
-            "mount_dedupe.py",
-            cwd=test_dir / "supports",
-            env={"USE_EXPLICIT": "0"},
-        )
-    )
-    assert servicer.n_mounts == 2
-    assert servicer.mount_contents["mo-1"].keys() == {"/root/mount_dedupe.py"}
-    pkg_a_mount = servicer.mount_contents["mo-2"]
-    for fn in pkg_a_mount.keys():
-        assert fn.startswith("/root/pkg_a")
-    assert "/root/pkg_a/normally_not_included.pyc" not in pkg_a_mount.keys()
-
-
-def test_mount_dedupe_explicit(servicer, test_dir, server_url_env):
-    supports_dir = test_dir / "supports"
-    normally_not_included_file = supports_dir / "pkg_a" / "normally_not_included.pyc"
-    normally_not_included_file.touch(exist_ok=True)
-    print(
-        helpers.deploy_app_externally(
-            # two explicit mounts of the same package
-            servicer,
-            "mount_dedupe.py",
-            cwd=supports_dir,
-            env={"USE_EXPLICIT": "1"},
-        )
-    )
-    assert servicer.n_mounts == 3
-    assert servicer.mount_contents["mo-1"].keys() == {"/root/mount_dedupe.py"}
-    pkg_a_mount = servicer.mount_contents["mo-2"]
-    for fn in pkg_a_mount.keys():
-        assert fn.startswith("/root/pkg_a")
-    assert "/root/pkg_a/normally_not_included.pyc" not in pkg_a_mount.keys()
-
-    custom_pkg_a_mount = servicer.mount_contents["mo-3"]
-    assert len(custom_pkg_a_mount) == len(pkg_a_mount) + 1
-    assert "/root/pkg_a/normally_not_included.pyc" in custom_pkg_a_mount.keys()
-
-
-@skip_windows("pip-installed pdm seems somewhat broken on windows")
-def test_pdm_cache_automount_exclude(tmp_path, monkeypatch, supports_dir, servicer, server_url_env):
-    # check that `pdm`'s cached packages are not included in automounts
-    project_dir = Path(__file__).parent.parent
-    monkeypatch.chdir(tmp_path)
-    subprocess.run(["pdm", "init", "-n"], check=True)
-    subprocess.run(
-        ["pdm", "add", "--dev", project_dir], check=True
-    )  # install workdir modal into venv, not using cache...
-    subprocess.run(["pdm", "config", "--local", "install.cache", "on"], check=True)
-    subprocess.run(["pdm", "add", "six"], check=True)  # single file module
-    subprocess.run(
-        ["pdm", "run", "modal", "deploy", supports_dir / "imports_six.py"], check=True
-    )  # deploy a basically empty function
-
-    files = set(servicer.files_name2sha.keys())
-    assert files == {
-        "/root/imports_six.py",
-    }
-
-
-def test_mount_directory_with_symlinked_file(path_with_symlinked_files, servicer, server_url_env):
-    path, files = path_with_symlinked_files
-    mount = Mount.from_local_dir(path)
-    mount._deploy("mo-1")
-    pkg_a_mount = servicer.mount_contents["mo-1"]
-    for src_f in files:
-        assert any(mnt_f.endswith(src_f.name) for mnt_f in pkg_a_mount)

test/network_file_system_test.py

@@ -1,188 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import time
-from io import BytesIO
-from unittest import mock
-
-import modal
-from modal.exception import DeprecationError, InvalidError, NotFoundError
-from modal.runner import deploy_app
-
-
-def dummy():
-    pass
-
-
-def test_network_file_system_files(client, test_dir, servicer):
-    app = modal.App()
-    nfs = modal.NetworkFileSystem.from_name("xyz", create_if_missing=True)
-
-    dummy_modal = app.function(network_file_systems={"/root/foo": nfs})(dummy)
-
-    with app.run(client=client):
-        dummy_modal.remote()
-
-
-def test_network_file_system_bad_paths():
-    app = modal.App()
-    nfs = modal.NetworkFileSystem.from_name("xyz", create_if_missing=True)
-
-    def _f():
-        pass
-
-    with pytest.raises(InvalidError):
-        app.function(network_file_systems={"/root/../../foo": nfs})(dummy)
-
-    with pytest.raises(InvalidError):
-        app.function(network_file_systems={"/": nfs})(dummy)
-
-    with pytest.raises(InvalidError):
-        app.function(network_file_systems={"/tmp/": nfs})(dummy)
-
-
-def test_network_file_system_handle_single_file(client, tmp_path, servicer):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    with modal.NetworkFileSystem.ephemeral(client=client) as nfs:
-        nfs.add_local_file(local_file_path)
-        nfs.add_local_file(local_file_path.as_posix(), remote_path="/foo/other_destination")
-        object_id = nfs.object_id
-
-    assert servicer.nfs_files[object_id].keys() == {
-        "/some_file",
-        "/foo/other_destination",
-    }
-    assert servicer.nfs_files[object_id]["/some_file"].data == b"hello world"
-    assert servicer.nfs_files[object_id]["/foo/other_destination"].data == b"hello world"
-
-
-@pytest.mark.asyncio
-async def test_network_file_system_handle_dir(client, tmp_path, servicer):
-    local_dir = tmp_path / "some_dir"
-    local_dir.mkdir()
-    (local_dir / "smol").write_text("###")
-
-    subdir = local_dir / "subdir"
-    subdir.mkdir()
-    (subdir / "other").write_text("####")
-
-    with modal.NetworkFileSystem.ephemeral(client=client) as nfs:
-        nfs.add_local_dir(local_dir)
-        object_id = nfs.object_id
-
-    assert servicer.nfs_files[object_id].keys() == {
-        "/some_dir/smol",
-        "/some_dir/subdir/other",
-    }
-    assert servicer.nfs_files[object_id]["/some_dir/smol"].data == b"###"
-    assert servicer.nfs_files[object_id]["/some_dir/subdir/other"].data == b"####"
-
-
-@pytest.mark.asyncio
-async def test_network_file_system_handle_big_file(client, tmp_path, servicer, blob_server, *args):
-    with mock.patch("modal.network_file_system.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.NetworkFileSystem.ephemeral(client=client) as nfs:
-            await nfs.add_local_file.aio(local_file_path)
-            object_id = nfs.object_id
-
-        assert servicer.nfs_files[object_id].keys() == {"/bigfile"}
-        assert servicer.nfs_files[object_id]["/bigfile"].data == b""
-        assert servicer.nfs_files[object_id]["/bigfile"].data_blob_id == "bl-1"
-
-        _, blobs = blob_server
-        assert blobs["bl-1"] == b"hello world, this is a lot of text"
-
-
-def test_old_syntax(client, servicer):
-    app = modal.App()
-    with pytest.raises(DeprecationError):
-        app.vol1 = modal.SharedVolume()  # type: ignore  # This is just a post-deprecation husk
-    with pytest.raises(DeprecationError):
-        app.vol2 = modal.SharedVolume.new()
-
-
-def test_redeploy(servicer, client):
-    app = modal.App()
-    with pytest.warns(DeprecationError):
-        n1 = modal.NetworkFileSystem.new()
-        n2 = modal.NetworkFileSystem.new()
-        n3 = modal.NetworkFileSystem.new()
-        app.n1, app.n2, app.n3 = n1, n2, n3
-
-    # Deploy app once
-    deploy_app(app, "my-app", client=client)
-    app1_ids = [n1.object_id, n2.object_id, n3.object_id]
-
-    # Deploy app again
-    deploy_app(app, "my-app", client=client)
-    app2_ids = [n1.object_id, n2.object_id, n3.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 = [n1.object_id, n2.object_id, n3.object_id]
-
-    # Should be unique and different
-    assert len(set(app3_ids)) == 3
-    assert set(app1_ids) & set(app3_ids) == set()
-
-
-def test_read_file(client, tmp_path, servicer):
-    with modal.NetworkFileSystem.ephemeral(client=client) as nfs:
-        with pytest.raises(FileNotFoundError):
-            for _ in nfs.read_file("idontexist.txt"):
-                ...
-
-
-def test_write_file(client, tmp_path, servicer):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    with modal.NetworkFileSystem.ephemeral(client=client) as nfs:
-        nfs.write_file("remote_path.txt", open(local_file_path, "rb"))
-
-        # Make sure we can write through the provider too
-        nfs.write_file("remote_path.txt", open(local_file_path, "rb"))
-
-
-def test_persisted(servicer, client):
-    # Lookup should fail since it doesn't exist
-    with pytest.raises(NotFoundError):
-        modal.NetworkFileSystem.lookup("xyz", client=client)
-
-    # Create it
-    modal.NetworkFileSystem.lookup("xyz", create_if_missing=True, client=client)
-
-    # Lookup should succeed now
-    modal.NetworkFileSystem.lookup("xyz", client=client)
-
-
-def test_nfs_ephemeral(servicer, client, tmp_path):
-    local_file_path = tmp_path / "some_file"
-    local_file_path.write_text("hello world")
-
-    assert servicer.n_nfs_heartbeats == 0
-    with modal.NetworkFileSystem.ephemeral(client=client, _heartbeat_sleep=1) as nfs:
-        assert nfs.listdir("/") == []
-        nfs.write_file("xyz.txt", open(local_file_path, "rb"))
-        (entry,) = nfs.listdir("/")
-        assert entry.path == "xyz.txt"
-
-        time.sleep(1.5)  # Make time for 2 heartbeats
-    assert servicer.n_nfs_heartbeats == 2
-
-
-def test_nfs_lazy_hydration_from_name(set_env_client):
-    nfs = modal.NetworkFileSystem.from_name("nfs", create_if_missing=True)
-    bio = BytesIO(b"content")
-    nfs.write_file("blah", bio)

test/notebook_test.py

@@ -1,66 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import warnings
-from pathlib import Path
-
-import jupytext
-
-try:
-    from nbclient.exceptions import CellExecutionError
-except ModuleNotFoundError:
-    # TODO(erikbern): sometimes my local jupyter packages end up in a bad state,
-    # but we don't want that to cause pytest to fail on startup.
-    warnings.warn("failed importing nbclient")
-
-
-@pytest.fixture
-def notebook_runner(servicer):
-    import nbformat
-    from nbclient import NotebookClient
-
-    def runner(notebook_path: Path):
-        output_notebook_path = notebook_path.with_suffix(".output.ipynb")
-
-        nb = jupytext.read(
-            notebook_path,
-        )
-
-        parameter_cell = nb["cells"][0]
-        assert "parameters" in parameter_cell["metadata"]["tags"]  # like in papermill
-        parameter_cell["source"] = f'server_addr = "{servicer.remote_addr}"'
-
-        client = NotebookClient(nb)
-
-        try:
-            client.execute()
-        except CellExecutionError:
-            nbformat.write(nb, output_notebook_path)
-            pytest.fail(
-                f"""There was an error when executing the notebook.
-
-Inspect the output notebook: {output_notebook_path}
-"""
-            )
-        tagged_cells = {}
-        for cell in nb["cells"]:
-            for tag in cell["metadata"].get("tags", []):
-                tagged_cells[tag] = cell
-
-        return tagged_cells
-
-    return runner
-
-
-# for some reason this import is failing due to a circular import of IPython.terminal.embed
-# but only when running in CI (sometimes?), causing these tests to fail:
-# from IPython.terminal import interactiveshell
-
-
-@pytest.mark.skip("temporarily disabled until IPython import issues in CI are resolved")
-def test_notebook_outputs_status(notebook_runner, test_dir):
-    input_notebook_path = test_dir / "supports" / "notebooks" / "simple.notebook.py"
-    tagged_cells = notebook_runner(input_notebook_path)
-    combined_output = "\n".join(c["data"]["text/plain"] for c in tagged_cells["main"]["outputs"])
-    assert "Initialized" in combined_output
-    assert "Created objects." in combined_output
-    assert "App completed." in combined_output

test/object_test.py

@@ -1,41 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-
-from modal import App, Queue, Secret
-from modal.exception import DeprecationError, InvalidError
-
-
-@pytest.mark.asyncio
-async def test_async_factory(client):
-    app = App()
-    with pytest.warns(DeprecationError):
-        app.my_factory = Queue.new()
-        async with app.run(client=client):
-            assert isinstance(app.my_factory, Queue)
-            assert app.my_factory.object_id == "qu-1"
-
-
-def test_new_hydrated(client):
-    from modal.dict import _Dict
-    from modal.object import _Object
-    from modal.queue import _Queue
-
-    assert isinstance(_Dict._new_hydrated("di-123", client, None), _Dict)
-    assert isinstance(_Queue._new_hydrated("qu-123", client, None), _Queue)
-
-    with pytest.raises(InvalidError):
-        _Queue._new_hydrated("di-123", client, None)  # Wrong prefix for type
-
-    assert isinstance(_Object._new_hydrated("qu-123", client, None), _Queue)
-    assert isinstance(_Object._new_hydrated("di-123", client, None), _Dict)
-
-    with pytest.raises(InvalidError):
-        _Object._new_hydrated("xy-123", client, None)
-
-
-def test_constructor():
-    with pytest.raises(InvalidError) as excinfo:
-        Secret({"foo": 123})
-
-    assert "Secret" in str(excinfo.value)
-    assert "constructor" in str(excinfo.value)

test/package_utils_test.py

@@ -1,25 +0,0 @@
-# Copyright Modal Labs 2022
-import platform
-import pytest
-
-from modal._utils.package_utils import get_module_mount_info
-from modal.exception import ModuleNotMountable
-
-
-def test_get_module_mount_info():
-    res = get_module_mount_info("modal")
-    assert len(res) == 1
-    assert res[0][0] == True
-
-    res = get_module_mount_info("asyncio")
-    assert len(res) == 1
-    assert res[0][0] == True
-
-    res = get_module_mount_info("six")
-    assert len(res) == 1
-    assert res[0][0] == False
-
-    if platform.system() != "Windows":
-        # TODO This assertion fails on windows; I assume that compiled file formats are different there?
-        with pytest.raises(ModuleNotMountable, match="aiohttp can't be mounted because it contains binary file"):
-            get_module_mount_info("aiohttp")