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

test/live_reload_test.py

@@ -1,80 +0,0 @@
-# Copyright Modal Labs 2023
-import asyncio
-import pytest
-import threading
-import time
-from unittest import mock
-
-from modal import Function
-from modal.serving import serve_app
-
-from .supports.app_run_tests.webhook import app
-from .supports.skip import skip_windows
-
-
-@pytest.fixture
-def app_ref(test_dir):
-    return str(test_dir / "supports" / "app_run_tests" / "webhook.py")
-
-
-@pytest.mark.asyncio
-async def test_live_reload(app_ref, server_url_env, servicer):
-    async with serve_app.aio(app, app_ref):
-        await asyncio.sleep(3.0)
-    assert servicer.app_set_objects_count == 1
-    assert servicer.app_client_disconnect_count == 1
-    assert servicer.app_get_logs_initial_count == 1
-
-
-@skip_windows("live-reload not supported on windows")
-def test_file_changes_trigger_reloads(app_ref, server_url_env, servicer):
-    watcher_done = threading.Event()
-
-    async def fake_watch():
-        for i in range(3):
-            yield {"/some/file"}
-        watcher_done.set()
-
-    with serve_app(app, app_ref, _watcher=fake_watch()):
-        watcher_done.wait()  # wait until watcher loop is done
-
-    # TODO ideally we would assert the specific expected number here, but this test
-    # is consistently flaking in CI and I cannot reproduce locally to debug.
-    # I'm relaxing the assertion for now to stop the test from blocking deployments.
-    # assert servicer.app_set_objects_count == 4  # 1 + number of file changes
-    assert servicer.app_set_objects_count > 1
-    assert servicer.app_client_disconnect_count == 1
-    assert servicer.app_get_logs_initial_count == 1
-    foo = app.indexed_objects["foo"]
-    assert isinstance(foo, Function)
-    assert foo.web_url.startswith("http://")
-
-
-@pytest.mark.asyncio
-async def test_no_change(app_ref, server_url_env, servicer):
-    async def fake_watch():
-        # Iterator that returns immediately, yielding nothing
-        if False:
-            yield
-
-    async with serve_app.aio(app, app_ref, _watcher=fake_watch()):
-        pass
-
-    assert servicer.app_set_objects_count == 1  # Should create the initial app once
-    assert servicer.app_client_disconnect_count == 1
-    assert servicer.app_get_logs_initial_count == 1
-
-
-@pytest.mark.asyncio
-async def test_heartbeats(app_ref, server_url_env, servicer):
-    with mock.patch("modal.runner.HEARTBEAT_INTERVAL", 1):
-        t0 = time.time()
-        async with serve_app.aio(app, app_ref):
-            await asyncio.sleep(3.1)
-        total_secs = int(time.time() - t0)
-
-    apps = list(servicer.app_heartbeats.keys())
-    assert len(apps) == 1
-    # Typically [0s, 1s, 2s, 3s], but asyncio.sleep may lag.
-    actual_heartbeats = servicer.app_heartbeats[apps[0]]
-    assert abs(actual_heartbeats - (total_secs + 1)) <= 1

test/lookup_test.py

@@ -1,70 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-from modal import App, Function, Volume, web_endpoint
-from modal.exception import ExecutionError, NotFoundError
-from modal.runner import deploy_app
-
-
-def test_persistent_object(servicer, client):
-    volume_id = Volume.create_deployed("my-volume", client=client)
-
-    v: Volume = Volume.lookup("my-volume", client=client)
-    assert isinstance(v, Volume)
-    assert v.object_id == volume_id
-
-    with pytest.raises(NotFoundError):
-        Volume.lookup("bazbazbaz", client=client)
-
-
-def square(x):
-    # This function isn't deployed anyway
-    pass
-
-
-def test_lookup_function(servicer, client):
-    app = App()
-
-    app.function()(square)
-    deploy_app(app, "my-function", client=client)
-
-    f = Function.lookup("my-function", "square", client=client)
-    assert f.object_id == "fu-1"
-
-    # Call it using two arguments
-    f = Function.lookup("my-function", "square", client=client)
-    assert f.object_id == "fu-1"
-    with pytest.raises(NotFoundError):
-        f = Function.lookup("my-function", "cube", client=client)
-
-    # Make sure we can call this function
-    assert f.remote(2, 4) == 20
-    assert [r for r in f.map([5, 2], [4, 3])] == [41, 13]
-
-    # Make sure the new-style local calls raise an error
-    with pytest.raises(ExecutionError):
-        assert f.local(2, 4) == 20
-
-
-def test_webhook_lookup(servicer, client):
-    app = App()
-    app.function()(web_endpoint(method="POST")(square))
-    deploy_app(app, "my-webhook", client=client)
-
-    f = Function.lookup("my-webhook", "square", client=client)
-    assert f.web_url
-
-
-def test_deploy_exists(servicer, client):
-    with pytest.raises(NotFoundError):
-        Volume.lookup("my-volume", client=client)
-    Volume.create_deployed("my-volume", client=client)
-    v1: Volume = Volume.lookup("my-volume", client=client)
-    v2: Volume = Volume.lookup("my-volume", client=client)
-    assert v1.object_id == v2.object_id
-
-
-def test_create_if_missing(servicer, client):
-    v1: Volume = Volume.lookup("my-volume", create_if_missing=True, client=client)
-    v2: Volume = Volume.lookup("my-volume", client=client)
-    assert v1.object_id == v2.object_id

test/mdmd_test.py

@@ -1,329 +0,0 @@
-# Copyright Modal Labs 2023
-import importlib
-import os
-import pytest
-import sys
-from enum import IntEnum
-
-from modal_docs.mdmd import mdmd
-
-# Skipping a few tests on 3.7 - doesn't matter since we don't generate docs on 3.7
-skip_37 = pytest.mark.skipif(sys.version_info < (3, 8), reason="Requires Python 3.8")
-
-
-def test_simple_function():
-    def foo():
-        pass
-
-    assert (
-        mdmd.function_str("bar", foo)
-        == """```python
-def bar():
-```\n\n"""
-    )
-
-
-def test_simple_async_function():
-    async def foo():
-        pass
-
-    assert (
-        mdmd.function_str("bar", foo)
-        == """```python
-async def bar():
-```\n\n"""
-    )
-
-
-def test_async_gen_function():
-    async def foo():
-        yield
-
-    assert (
-        mdmd.function_str("bar", foo)
-        == """```python
-async def bar():
-```\n\n"""
-    )
-
-
-def test_complex_function_signature():
-    def foo(a: str, *args, **kwargs):
-        pass
-
-    assert (
-        mdmd.function_str("foo", foo)
-        == """```python
-def foo(a: str, *args, **kwargs):
-```\n\n"""
-    )
-
-
-@skip_37
-def test_function_has_docstring():
-    def foo():
-        """short description
-
-        longer description"""
-
-    assert (
-        mdmd.function_str("foo", foo)
-        == """```python
-def foo():
-```
-
-short description
-
-longer description
-"""
-    )
-
-
-def test_simple_class_with_docstring():
-    class Foo:
-        """The all important Foo"""
-
-        def bar(self, baz: str):
-            """Bars the foo with the baz"""
-
-    assert (
-        mdmd.class_str("Foo", Foo)
-        == """```python
-class Foo(object)
-```
-
-The all important Foo
-
-### bar
-
-```python
-def bar(self, baz: str):
-```
-
-Bars the foo with the baz
-"""
-    )
-
-
-def test_enum():
-    class Eee(IntEnum):
-        FOO = 1
-        BAR = 2
-        XYZ = 3
-
-    expected = """```python
-class bar(enum.IntEnum)
-```
-
-An enumeration.
-
-The possible values are:
-
-* `FOO`
-* `BAR`
-* `XYZ`
-"""
-
-    assert mdmd.class_str("bar", Eee) == expected
-
-
-def test_class_with_classmethod():
-    class Foo:
-        @classmethod
-        def create_foo(cls, some_arg):
-            pass
-
-    assert (
-        mdmd.class_str("Foo", Foo)
-        == """```python
-class Foo(object)
-```
-
-### create_foo
-
-```python
-@classmethod
-def create_foo(cls, some_arg):
-```
-
-"""
-    )
-
-
-def test_class_with_baseclass_includes_base_methods():
-    class Foo:
-        def foo(self):
-            pass
-
-    class Bar(Foo):
-        def bar(self):
-            pass
-
-    out = mdmd.class_str("Bar", Bar)
-    assert "def foo(self):" in out
-
-
-@skip_37
-def test_module(monkeypatch):
-    test_data_dir = os.path.join(os.path.dirname(__file__), "mdmd_data")
-    monkeypatch.chdir(test_data_dir)
-    monkeypatch.syspath_prepend(test_data_dir)
-    test_module = importlib.import_module("foo")
-    expected_output = open("./foo-expected.md").read()
-    assert mdmd.module_str("foo", test_module) == expected_output
-
-
-def test_docstring_format_reindents_code():
-    assert (
-        mdmd.format_docstring(
-            """```python
-        foo
-            bar
-        ```"""
-        )
-        == """```python
-foo
-    bar
-```
-"""
-    )
-
-
-def test_synchronicity_async_and_blocking_interfaces():
-    from synchronicity import Synchronizer
-
-    class Foo:
-        """docky mcdocface"""
-
-        async def foo(self):
-            pass
-
-        def bar(self):
-            pass
-
-    s = Synchronizer()
-    AsyncFoo = s.create_async(Foo, "AsyncFoo")
-    BlockingFoo = s.create_blocking(Foo, "BlockingFoo")
-
-    assert (
-        mdmd.class_str("AsyncFoo", AsyncFoo)
-        == """```python
-class AsyncFoo(object)
-```
-
-docky mcdocface
-
-### foo
-
-```python
-async def foo(self):
-```
-
-### bar
-
-```python
-def bar(self):
-```
-
-"""
-    )
-
-    assert (
-        mdmd.class_str("BlockingFoo", BlockingFoo)
-        == """```python
-class BlockingFoo(object)
-```
-
-docky mcdocface
-
-### foo
-
-```python
-def foo(self):
-```
-
-### bar
-
-```python
-def bar(self):
-```
-
-"""
-    )
-
-
-def test_synchronicity_constructors():
-    from synchronicity import Synchronizer
-
-    class Foo:
-        """docky mcdocface"""
-
-        def __init__(self):
-            """constructy mcconstructorface"""
-
-    s = Synchronizer()
-    AsyncFoo = s.create_async(Foo, "AsyncFoo")
-
-    assert (
-        mdmd.class_str("AsyncFoo", AsyncFoo)
-        == """```python
-class AsyncFoo(object)
-```
-
-docky mcdocface
-
-```python
-def __init__(self):
-```
-
-constructy mcconstructorface
-"""
-    )
-
-
-def test_get_all_signature_comments():
-    def foo(
-        # prefix comment
-        one,  # one comment
-        two,  # two comment
-        # postfix comment
-    ) -> str:  # return value comment
-        pass
-
-    assert (
-        mdmd.function_str("foo", foo)
-        == """```python
-def foo(
-    # prefix comment
-    one,  # one comment
-    two,  # two comment
-    # postfix comment
-) -> str:  # return value comment
-```
-
-"""
-    )
-
-
-def test_get_decorators():
-    BLA = 1
-
-    def my_deco(arg):
-        def wrapper(f):
-            return f
-
-        return wrapper
-
-    @my_deco(BLA)
-    def foo():
-        pass
-
-    assert (
-        mdmd.function_str("foo", foo)
-        == """```python
-@my_deco(BLA)
-def foo():
-```
-
-"""
-    )

test/mount_test.py

@@ -1,162 +0,0 @@
-# Copyright Modal Labs 2022
-import hashlib
-import os
-import platform
-import pytest
-import sys
-from pathlib import Path
-
-from modal import App
-from modal._utils.blob_utils import LARGE_FILE_LIMIT
-from modal.exception import ModuleNotMountable
-from modal.mount import Mount
-
-
-@pytest.mark.asyncio
-async def test_get_files(servicer, client, tmpdir):
-    small_content = b"# not much here"
-    large_content = b"a" * (LARGE_FILE_LIMIT + 1)
-
-    tmpdir.join("small.py").write(small_content)
-    tmpdir.join("large.py").write(large_content)
-    tmpdir.join("fluff").write("hello")
-
-    files = {}
-    m = Mount.from_local_dir(Path(tmpdir), remote_path="/", condition=lambda fn: fn.endswith(".py"), recursive=True)
-    async for upload_spec in Mount._get_files.aio(m.entries):
-        files[upload_spec.mount_filename] = upload_spec
-
-    os.umask(umask := os.umask(0o022))  # Get the current umask
-    expected_mode = 0o644 if platform.system() == "Windows" else 0o666 - umask
-
-    assert "/small.py" in files
-    assert "/large.py" in files
-    assert "/fluff" not in files
-    assert files["/small.py"].use_blob is False
-    assert files["/small.py"].content == small_content
-    assert files["/small.py"].sha256_hex == hashlib.sha256(small_content).hexdigest()
-    assert files["/small.py"].mode == expected_mode
-
-    assert files["/large.py"].use_blob is True
-    assert files["/large.py"].content is None
-    assert files["/large.py"].sha256_hex == hashlib.sha256(large_content).hexdigest()
-    assert files["/large.py"].mode == expected_mode
-
-    await m._deploy.aio("my-mount", client=client)
-    blob_id = max(servicer.blobs.keys())  # last uploaded one
-    assert len(servicer.blobs[blob_id]) == len(large_content)
-    assert servicer.blobs[blob_id] == large_content
-
-    assert servicer.files_sha2data[files["/large.py"].sha256_hex] == {"data": b"", "data_blob_id": blob_id}
-    assert servicer.files_sha2data[files["/small.py"].sha256_hex] == {
-        "data": small_content,
-        "data_blob_id": "",
-    }
-
-
-def test_create_mount(servicer, client):
-    local_dir, cur_filename = os.path.split(__file__)
-
-    def condition(fn):
-        return fn.endswith(".py")
-
-    m = Mount.from_local_dir(local_dir, remote_path="/foo", condition=condition)
-
-    m._deploy("my-mount", client=client)
-
-    assert m.object_id == "mo-1"
-    assert f"/foo/{cur_filename}" in servicer.files_name2sha
-    sha256_hex = servicer.files_name2sha[f"/foo/{cur_filename}"]
-    assert sha256_hex in servicer.files_sha2data
-    assert servicer.files_sha2data[sha256_hex]["data"] == open(__file__, "rb").read()
-    assert repr(Path(local_dir)) in repr(m)
-
-
-def test_create_mount_file_errors(servicer, tmpdir, client):
-    m = Mount.from_local_dir(Path(tmpdir) / "xyz", remote_path="/xyz")
-    with pytest.raises(FileNotFoundError):
-        m._deploy("my-mount", client=client)
-
-    with open(tmpdir / "abc", "w"):
-        pass
-    m = Mount.from_local_dir(Path(tmpdir) / "abc", remote_path="/abc")
-    with pytest.raises(NotADirectoryError):
-        m._deploy("my-mount", client=client)
-
-
-def dummy():
-    pass
-
-
-def test_from_local_python_packages(servicer, client, test_dir):
-    app = App()
-
-    sys.path.append((test_dir / "supports").as_posix())
-
-    app.function(mounts=[Mount.from_local_python_packages("pkg_a", "pkg_b", "standalone_file")])(dummy)
-
-    with app.run(client=client):
-        files = set(servicer.files_name2sha.keys())
-        expected_files = {
-            "/root/pkg_a/a.py",
-            "/root/pkg_a/b/c.py",
-            "/root/pkg_b/f.py",
-            "/root/pkg_b/g/h.py",
-            "/root/standalone_file.py",
-        }
-        assert expected_files.issubset(files)
-
-        assert "/root/pkg_c/i.py" not in files
-        assert "/root/pkg_c/j/k.py" not in files
-
-
-def test_app_mounts(servicer, client, test_dir):
-    sys.path.append((test_dir / "supports").as_posix())
-
-    app = App(mounts=[Mount.from_local_python_packages("pkg_b")])
-
-    app.function(mounts=[Mount.from_local_python_packages("pkg_a")])(dummy)
-
-    with app.run(client=client):
-        files = set(servicer.files_name2sha.keys())
-        expected_files = {
-            "/root/pkg_a/a.py",
-            "/root/pkg_a/b/c.py",
-            "/root/pkg_b/f.py",
-            "/root/pkg_b/g/h.py",
-        }
-        assert expected_files.issubset(files)
-
-        assert "/root/pkg_c/i.py" not in files
-        assert "/root/pkg_c/j/k.py" not in files
-
-
-def test_from_local_python_packages_missing_module(servicer, client, test_dir, server_url_env):
-    app = App()
-    app.function(mounts=[Mount.from_local_python_packages("nonexistent_package")])(dummy)
-
-    with pytest.raises(ModuleNotMountable):
-        with app.run(client=client):
-            pass
-
-
-def test_chained_entries(test_dir):
-    a_txt = str(test_dir / "a.txt")
-    b_txt = str(test_dir / "b.txt")
-    with open(a_txt, "w") as f:
-        f.write("A")
-    with open(b_txt, "w") as f:
-        f.write("B")
-    mount = Mount.from_local_file(a_txt).add_local_file(b_txt)
-    entries = mount.entries
-    assert len(entries) == 2
-    files = [file for file in Mount._get_files(entries)]
-    assert len(files) == 2
-    files.sort(key=lambda file: file.source_description)
-    assert files[0].source_description.name == "a.txt"
-    assert files[0].mount_filename.endswith("/a.txt")
-    assert files[0].content == b"A"
-    m = hashlib.sha256()
-    m.update(b"A")
-    assert files[0].sha256_hex == m.hexdigest()
-    assert files[0].use_blob is False