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

test/queue_test.py

@@ -1,115 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import queue
-import time
-
-from modal import Queue
-from modal.exception import NotFoundError
-
-from .supports.skip import skip_macos, skip_windows
-
-
-def test_queue(servicer, client):
-    q = Queue.lookup("some-random-queue", create_if_missing=True, client=client)
-    assert isinstance(q, Queue)
-    assert q.len() == 0
-    q.put(42)
-    assert q.len() == 1
-    assert q.get() == 42
-    with pytest.raises(queue.Empty):
-        q.get(timeout=0)
-    assert q.len() == 0
-
-    # test iter
-    q.put_many([1, 2, 3])
-    t0 = time.time()
-    assert [v for v in q.iterate(item_poll_timeout=1.0)] == [1, 2, 3]
-    assert 1.0 < time.time() - t0 < 2.0
-    assert [v for v in q.iterate(item_poll_timeout=0.0)] == [1, 2, 3]
-
-    Queue.delete("some-random-queue", client=client)
-    with pytest.raises(NotFoundError):
-        Queue.lookup("some-random-queue", client=client)
-
-
-def test_queue_ephemeral(servicer, client):
-    with Queue.ephemeral(client=client, _heartbeat_sleep=1) as q:
-        q.put("hello")
-        assert q.len() == 1
-        assert q.get() == "hello"
-        time.sleep(1.5)  # enough to trigger two heartbeats
-
-    assert servicer.n_queue_heartbeats == 2
-
-
-@skip_macos("TODO(erikbern): this consistently fails on OSX. Unclear why.")
-@skip_windows("TODO(Jonathon): figure out why timeouts don't occur on Windows.")
-@pytest.mark.parametrize(
-    ["put_timeout_secs", "min_queue_full_exc_count", "max_queue_full_exc_count"],
-    [
-        (0.02, 1, 100),  # a low timeout causes some exceptions
-        (10.0, 0, 0),  # a high timeout causes zero exceptions
-        (0.00, 1, 100),  # zero-len timeout causes some exceptions
-        (None, 0, 0),  # no timeout causes zero exceptions
-    ],
-)
-def test_queue_blocking_put(put_timeout_secs, min_queue_full_exc_count, max_queue_full_exc_count, servicer, client):
-    import queue
-    import threading
-
-    producer_delay = 0.001
-    consumer_delay = producer_delay * 5
-
-    queue_full_exceptions = 0
-    with Queue.ephemeral(client=client) as q:
-
-        def producer():
-            nonlocal queue_full_exceptions
-            for i in range(servicer.queue_max_len * 2):
-                item = f"Item {i}"
-                try:
-                    q.put(item, block=True, timeout=put_timeout_secs)  # type: ignore
-                except queue.Full:
-                    queue_full_exceptions += 1
-                time.sleep(producer_delay)
-
-        def consumer():
-            while True:
-                time.sleep(consumer_delay)
-                item = q.get(block=True)  # type: ignore
-                if item is None:
-                    break  # Exit if a None item is received
-
-        producer_thread = threading.Thread(target=producer)
-        consumer_thread = threading.Thread(target=consumer)
-        producer_thread.start()
-        consumer_thread.start()
-        producer_thread.join()
-        # Stop the consumer by sending a None item
-        q.put(None)  # type: ignore
-        consumer_thread.join()
-
-        assert queue_full_exceptions >= min_queue_full_exc_count
-        assert queue_full_exceptions <= max_queue_full_exc_count
-
-
-def test_queue_nonblocking_put(servicer, client):
-    with Queue.ephemeral(client=client) as q:
-        # Non-blocking PUTs don't tolerate a full queue and will raise exception.
-        with pytest.raises(queue.Full) as excinfo:
-            for i in range(servicer.queue_max_len + 1):
-                q.put(i, block=False)  # type: ignore
-
-    assert str(servicer.queue_max_len) in str(excinfo.value)
-    assert i == servicer.queue_max_len
-
-
-def test_queue_deploy(servicer, client):
-    d = Queue.lookup("xyz", create_if_missing=True, client=client)
-    d.put(123)
-
-
-def test_queue_lazy_hydrate_from_name(set_env_client):
-    q = Queue.from_name("foo", create_if_missing=True)
-    q.put(123)
-    assert q.get() == 123

test/resolver_test.py

@@ -1,59 +0,0 @@
-# Copyright Modal Labs 2023
-import asyncio
-import pytest
-import time
-from typing import Optional
-
-from modal._output import OutputManager
-from modal._resolver import Resolver
-from modal.object import _Object
-
-
-@pytest.mark.flaky(max_runs=2)
-@pytest.mark.asyncio
-async def test_multi_resolve_sequential_loads_once():
-    output_manager = OutputManager(None, show_progress=False)
-    resolver = Resolver(None, output_mgr=output_manager, environment_name="", app_id=None)
-
-    load_count = 0
-
-    class _DumbObject(_Object, type_prefix="zz"):
-        pass
-
-    async def _load(self: _DumbObject, resolver: Resolver, existing_object_id: Optional[str]):
-        nonlocal load_count
-        load_count += 1
-        self._hydrate("zz-123", resolver.client, None)
-        await asyncio.sleep(0.1)
-
-    obj = _DumbObject._from_loader(_load, "DumbObject()")
-
-    t0 = time.monotonic()
-    await resolver.load(obj)
-    await resolver.load(obj)
-    assert 0.08 < time.monotonic() - t0 < 0.15
-
-    assert load_count == 1
-
-
-@pytest.mark.asyncio
-async def test_multi_resolve_concurrent_loads_once():
-    output_manager = OutputManager(None, show_progress=False)
-    resolver = Resolver(None, output_mgr=output_manager, environment_name="", app_id=None)
-
-    load_count = 0
-
-    class _DumbObject(_Object, type_prefix="zz"):
-        pass
-
-    async def _load(self: _DumbObject, resolver: Resolver, existing_object_id: Optional[str]):
-        nonlocal load_count
-        load_count += 1
-        self._hydrate("zz-123", resolver.client, None)
-        await asyncio.sleep(0.1)
-
-    obj = _DumbObject._from_loader(_load, "DumbObject()")
-    t0 = time.monotonic()
-    await asyncio.gather(resolver.load(obj), resolver.load(obj))
-    assert 0.08 < time.monotonic() - t0 < 0.17
-    assert load_count == 1

test/retries_test.py

@@ -1,67 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-
-import modal
-from modal.exception import InvalidError
-
-
-def default_retries_from_int():
-    pass
-
-
-def fixed_delay_retries():
-    pass
-
-
-def exponential_backoff():
-    return 67
-
-
-def exponential_with_max_delay():
-    return 67
-
-
-def dummy():
-    pass
-
-
-def zero_retries():
-    pass
-
-
-def test_retries(client):
-    app = modal.App()
-
-    default_retries_from_int_modal = app.function(retries=5)(default_retries_from_int)
-    fixed_delay_retries_modal = app.function(retries=modal.Retries(max_retries=5, backoff_coefficient=1.0))(
-        fixed_delay_retries
-    )
-
-    exponential_backoff_modal = app.function(
-        retries=modal.Retries(max_retries=2, initial_delay=2.0, backoff_coefficient=2.0)
-    )(exponential_backoff)
-
-    exponential_with_max_delay_modal = app.function(
-        retries=modal.Retries(max_retries=2, backoff_coefficient=2.0, max_delay=30.0)
-    )(exponential_with_max_delay)
-
-    zero_retries_modal = app.function(retries=0)(zero_retries)
-
-    with pytest.raises(TypeError):
-        # Reject no-args constructions, which is unreadable and harder to support long-term
-        app.function(retries=modal.Retries())(dummy)  # type: ignore
-
-    # Reject weird inputs:
-    # Don't need server to detect and reject nonsensical input. Can do client-side.
-    with pytest.raises(InvalidError):
-        app.function(retries=modal.Retries(max_retries=-2))(dummy)
-
-    with pytest.raises(InvalidError):
-        app.function(retries=modal.Retries(max_retries=2, backoff_coefficient=0.0))(dummy)
-
-    with app.run(client=client):
-        default_retries_from_int_modal.remote()
-        fixed_delay_retries_modal.remote()
-        exponential_backoff_modal.remote()
-        exponential_with_max_delay_modal.remote()
-        zero_retries_modal.remote()

test/runner_test.py

@@ -1,85 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-import typing
-
-import modal
-from modal.client import Client
-from modal.exception import ExecutionError
-from modal.runner import run_app
-from modal_proto import api_pb2
-
-T = typing.TypeVar("T")
-
-
-def test_run_app(servicer, client):
-    dummy_app = modal.App()
-    with servicer.intercept() as ctx:
-        with run_app(dummy_app, client=client):
-            pass
-
-    ctx.pop_request("AppCreate")
-    ctx.pop_request("AppSetObjects")
-    ctx.pop_request("AppClientDisconnect")
-
-
-def test_run_app_unauthenticated(servicer):
-    dummy_app = modal.App()
-    with Client.anonymous(servicer.remote_addr) as client:
-        with pytest.raises(ExecutionError, match=".+unauthenticated client"):
-            with run_app(dummy_app, client=client):
-                pass
-
-
-def dummy():
-    ...
-
-
-def test_run_app_profile_env_with_refs(servicer, client, monkeypatch):
-    monkeypatch.setenv("MODAL_ENVIRONMENT", "profile_env")
-    with servicer.intercept() as ctx:
-        dummy_app = modal.App()
-        ref = modal.Secret.from_name("some_secret")
-        dummy_app.function(secrets=[ref])(dummy)
-
-    assert ctx.calls == []  # all calls should be deferred
-
-    with servicer.intercept() as ctx:
-        ctx.add_response("SecretGetOrCreate", api_pb2.SecretGetOrCreateResponse(secret_id="st-123"))
-        with run_app(dummy_app, client=client):
-            pass
-
-    with pytest.raises(Exception):
-        ctx.pop_request("SecretCreate")  # should not create a new secret...
-
-    app_create = ctx.pop_request("AppCreate")
-    assert app_create.environment_name == "profile_env"
-
-    secret_get_or_create = ctx.pop_request("SecretGetOrCreate")
-    assert secret_get_or_create.environment_name == "profile_env"
-
-
-def test_run_app_custom_env_with_refs(servicer, client, monkeypatch):
-    monkeypatch.setenv("MODAL_ENVIRONMENT", "profile_env")
-    dummy_app = modal.App()
-    own_env_secret = modal.Secret.from_name("own_env_secret")
-    other_env_secret = modal.Secret.from_name("other_env_secret", environment_name="third")  # explicit lookup
-
-    dummy_app.function(secrets=[own_env_secret, other_env_secret])(dummy)
-
-    with servicer.intercept() as ctx:
-        ctx.add_response("SecretGetOrCreate", api_pb2.SecretGetOrCreateResponse(secret_id="st-123"))
-        ctx.add_response("SecretGetOrCreate", api_pb2.SecretGetOrCreateResponse(secret_id="st-456"))
-        with run_app(dummy_app, client=client, environment_name="custom"):
-            pass
-
-    with pytest.raises(Exception):
-        ctx.pop_request("SecretCreate")
-
-    app_create = ctx.pop_request("AppCreate")
-    assert app_create.environment_name == "custom"
-
-    secret_get_or_create = ctx.pop_request("SecretGetOrCreate")
-    assert secret_get_or_create.environment_name == "custom"
-
-    secret_get_or_create_2 = ctx.pop_request("SecretGetOrCreate")
-    assert secret_get_or_create_2.environment_name == "third"

test/sandbox_test.py

@@ -1,191 +0,0 @@
-# Copyright Modal Labs 2022
-
-import hashlib
-import platform
-import pytest
-import time
-from pathlib import Path
-
-from modal import App, Image, Mount, NetworkFileSystem, Sandbox, Secret
-from modal.exception import InvalidError
-
-app = App()
-
-
-skip_non_linux = pytest.mark.skipif(platform.system() != "Linux", reason="sandbox mock uses subprocess")
-
-
-@skip_non_linux
-def test_spawn_sandbox(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "echo bye >&2 && sleep 1 && echo hi && exit 42", timeout=600)
-
-        assert sb.poll() is None
-
-        t0 = time.time()
-        sb.wait()
-        # Test that we actually waited for the sandbox to finish.
-        assert time.time() - t0 > 0.3
-
-        assert sb.stdout.read() == "hi\n"
-        assert sb.stderr.read() == "bye\n"
-        # read a second time
-        assert sb.stdout.read() == ""
-        assert sb.stderr.read() == ""
-
-        assert sb.returncode == 42
-        assert sb.poll() == 42
-
-
-@skip_non_linux
-def test_sandbox_mount(client, servicer, tmpdir):
-    tmpdir.join("a.py").write(b"foo")
-
-    with app.run(client=client):
-        sb = app.spawn_sandbox(
-            "echo",
-            "hi",
-            mounts=[Mount.from_local_dir(Path(tmpdir), remote_path="/m")],
-        )
-        sb.wait()
-
-    sha = hashlib.sha256(b"foo").hexdigest()
-    assert servicer.files_sha2data[sha]["data"] == b"foo"
-
-
-@skip_non_linux
-def test_sandbox_image(client, servicer, tmpdir):
-    tmpdir.join("a.py").write(b"foo")
-
-    with app.run(client=client):
-        sb = app.spawn_sandbox("echo", "hi", image=Image.debian_slim().pip_install("foo", "bar", "potato"))
-        sb.wait()
-
-    idx = max(servicer.images.keys())
-    last_image = servicer.images[idx]
-
-    assert all(c in last_image.dockerfile_commands[-1] for c in ["foo", "bar", "potato"])
-
-
-@skip_non_linux
-def test_sandbox_secret(client, servicer, tmpdir):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("echo", "$FOO", secrets=[Secret.from_dict({"FOO": "BAR"})])
-        sb.wait()
-
-    assert len(servicer.sandbox_defs[0].secret_ids) == 1
-
-
-@skip_non_linux
-def test_sandbox_nfs(client, servicer, tmpdir):
-    with app.run(client=client):
-        with NetworkFileSystem.ephemeral(client=client) as nfs:
-            with pytest.raises(InvalidError):
-                app.spawn_sandbox("echo", "foo > /cache/a.txt", network_file_systems={"/": nfs})
-
-            app.spawn_sandbox("echo", "foo > /cache/a.txt", network_file_systems={"/cache": nfs})
-
-    assert len(servicer.sandbox_defs[0].nfs_mounts) == 1
-
-
-@skip_non_linux
-def test_sandbox_from_id(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "echo foo && exit 42", timeout=600)
-        sb.wait()
-
-    sb2 = Sandbox.from_id(sb.object_id, client=client)
-    assert sb2.stdout.read() == "foo\n"
-    assert sb2.returncode == 42
-
-
-@skip_non_linux
-def test_sandbox_terminate(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "sleep 10000")
-        sb.terminate()
-
-        assert sb.returncode != 0
-
-
-@skip_non_linux
-@pytest.mark.asyncio
-async def test_sandbox_stdin_async(client, servicer):
-    async with app.run.aio(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "while read line; do echo $line; done && exit 13")
-
-        sb.stdin.write(b"foo\n")
-        sb.stdin.write(b"bar\n")
-
-        sb.stdin.write_eof()
-
-        await sb.stdin.drain.aio()
-
-        sb.wait()
-
-        assert sb.stdout.read() == "foo\nbar\n"
-        assert sb.returncode == 13
-
-
-@skip_non_linux
-def test_sandbox_stdin(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "while read line; do echo $line; done && exit 13")
-
-        sb.stdin.write(b"foo\n")
-        sb.stdin.write(b"bar\n")
-
-        sb.stdin.write_eof()
-
-        sb.stdin.drain()
-
-        sb.wait()
-
-        assert sb.stdout.read() == "foo\nbar\n"
-        assert sb.returncode == 13
-
-
-@skip_non_linux
-def test_sandbox_stdin_invalid_write(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "echo foo")
-        with pytest.raises(TypeError):
-            sb.stdin.write("foo\n")  # type: ignore
-
-
-@skip_non_linux
-def test_sandbox_stdin_write_after_eof(client, servicer):
-    with app.run(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "echo foo")
-        sb.stdin.write_eof()
-        with pytest.raises(EOFError):
-            sb.stdin.write(b"foo")
-
-
-@skip_non_linux
-@pytest.mark.asyncio
-async def test_sandbox_async_for(client, servicer):
-    async with app.run.aio(client=client):
-        sb = app.spawn_sandbox("bash", "-c", "echo hello && echo world && echo bye >&2")
-
-        out = ""
-
-        async for message in sb.stdout:
-            out += message
-        assert out == "hello\nworld\n"
-
-        # test streaming stdout a second time
-        out2 = ""
-        async for message in sb.stdout:
-            out2 += message
-        assert out2 == ""
-
-        err = ""
-        async for message in sb.stderr:
-            err += message
-
-        assert err == "bye\n"
-
-        # test reading after receiving EOF
-        assert sb.stdout.read() == ""
-        assert sb.stderr.read() == ""

test/schedule_test.py

@@ -1,15 +0,0 @@
-# Copyright Modal Labs 2022
-from modal import App, Period
-from modal_proto import api_pb2
-
-app = App()
-
-
-@app.function(schedule=Period(seconds=5))
-def f():
-    pass
-
-
-def test_schedule(servicer, client):
-    with app.run(client=client):
-        assert servicer.function2schedule == {"fu-1": api_pb2.Schedule(period=api_pb2.Schedule.Period(seconds=5.0))}

test/scheduler_placement_test.py

@@ -1,57 +0,0 @@
-# Copyright Modal Labs 2024
-from modal import App, SchedulerPlacement
-from modal_proto import api_pb2
-
-from .sandbox_test import skip_non_linux
-
-app = App()
-
-
-@app.function(
-    _experimental_scheduler=True,
-    _experimental_scheduler_placement=SchedulerPlacement(
-        region="us-east-1",
-        zone="us-east-1a",
-        spot=False,
-    ),
-)
-def f():
-    pass
-
-
-def test_fn_scheduler_placement(servicer, client):
-    with app.run(client=client):
-        assert len(servicer.app_functions) == 1
-        fn = servicer.app_functions["fu-1"]
-        assert fn._experimental_scheduler
-        assert fn._experimental_scheduler_placement == api_pb2.SchedulerPlacement(
-            _region="us-east-1",
-            _zone="us-east-1a",
-            _lifecycle="on-demand",
-        )
-
-
-@skip_non_linux
-def test_sandbox_scheduler_placement(client, servicer):
-    with app.run(client=client):
-        _ = app.spawn_sandbox(
-            "bash",
-            "-c",
-            "echo bye >&2 && sleep 1 && echo hi && exit 42",
-            timeout=600,
-            _experimental_scheduler=True,
-            _experimental_scheduler_placement=SchedulerPlacement(
-                region="us-east-1",
-                zone="us-east-1a",
-                spot=False,
-            ),
-        )
-
-        assert len(servicer.sandbox_defs) == 1
-        sb_def = servicer.sandbox_defs[0]
-        assert sb_def._experimental_scheduler
-        assert sb_def._experimental_scheduler_placement == api_pb2.SchedulerPlacement(
-            _region="us-east-1",
-            _zone="us-east-1a",
-            _lifecycle="on-demand",
-        )

test/secret_test.py

@@ -1,89 +0,0 @@
-# Copyright Modal Labs 2022
-import os
-import pytest
-import tempfile
-from unittest import mock
-
-from modal import App, Secret
-from modal.exception import InvalidError
-
-from .supports.skip import skip_old_py
-
-
-def dummy():
-    ...
-
-
-def test_secret_from_dict(servicer, client):
-    app = App()
-    secret = Secret.from_dict({"FOO": "hello, world"})
-    app.function(secrets=[secret])(dummy)
-    with app.run(client=client):
-        assert secret.object_id == "st-0"
-        assert servicer.secrets["st-0"] == {"FOO": "hello, world"}
-
-
-@skip_old_py("python-dotenv requires python3.8 or higher", (3, 8))
-def test_secret_from_dotenv(servicer, client):
-    with tempfile.TemporaryDirectory() as tmpdirname:
-        with open(os.path.join(tmpdirname, ".env"), "w") as f:
-            f.write("# My settings\nUSER=user\nPASSWORD=abc123\n")
-
-        with open(os.path.join(tmpdirname, ".env-dev"), "w") as f:
-            f.write("# My settings\nUSER=user2\nPASSWORD=abc456\n")
-
-        app = App()
-        secret = Secret.from_dotenv(tmpdirname)
-        app.function(secrets=[secret])(dummy)
-        with app.run(client=client):
-            assert secret.object_id == "st-0"
-            assert servicer.secrets["st-0"] == {"USER": "user", "PASSWORD": "abc123"}
-
-        app = App()
-        secret = Secret.from_dotenv(tmpdirname, filename=".env-dev")
-        app.function(secrets=[secret])(dummy)
-        with app.run(client=client):
-            assert secret.object_id == "st-1"
-            assert servicer.secrets["st-1"] == {"USER": "user2", "PASSWORD": "abc456"}
-
-
-@mock.patch.dict(os.environ, {"FOO": "easy", "BAR": "1234"})
-def test_secret_from_local_environ(servicer, client):
-    app = App()
-    secret = Secret.from_local_environ(["FOO", "BAR"])
-    app.function(secrets=[secret])(dummy)
-    with app.run(client=client):
-        assert secret.object_id == "st-0"
-        assert servicer.secrets["st-0"] == {"FOO": "easy", "BAR": "1234"}
-
-    with pytest.raises(InvalidError, match="NOTFOUND"):
-        Secret.from_local_environ(["FOO", "NOTFOUND"])
-
-
-def test_init_types():
-    with pytest.raises(InvalidError):
-        Secret.from_dict({"foo": 1.0})  # type: ignore
-
-
-def test_secret_from_dict_none(servicer, client):
-    app = App()
-    secret = Secret.from_dict({"FOO": os.getenv("xyz"), "BAR": os.environ.get("abc"), "BAZ": "baz"})
-    app.function(secrets=[secret])(dummy)
-    with app.run(client=client):
-        assert servicer.secrets["st-0"] == {"BAZ": "baz"}
-
-
-def test_secret_from_name(servicer, client):
-    # Deploy secret
-    secret_id = Secret.create_deployed("my-secret", {"FOO": "123"}, client=client)
-
-    # Look up secret
-    secret = Secret.lookup("my-secret", client=client)
-    assert secret.object_id == secret_id
-
-    # Look up secret through app
-    app = App()
-    secret = Secret.from_name("my-secret")
-    app.function(secrets=[secret])(dummy)
-    with app.run(client=client):
-        assert secret.object_id == secret_id