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

test/cpu_test.py

@@ -1,23 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-from modal import App
-from modal.exception import InvalidError
-
-
-def dummy():
-    pass
-
-
-def test_cpu_lower_bound(client, servicer):
-    app = App()
-
-    app.function(cpu=0.0)(dummy)
-
-    with pytest.raises(InvalidError):
-        with app.run(client=client):
-            pass
-
-    app.function(cpu=42)(dummy)
-    with app.run(client=client):
-        pass

test/decorator_test.py

@@ -1,85 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-from modal import App, asgi_app, method, web_endpoint, wsgi_app
-from modal.exception import InvalidError
-
-
-def test_local_entrypoint_forgot_parentheses():
-    app = App()
-
-    with pytest.raises(InvalidError, match="local_entrypoint()"):
-
-        @app.local_entrypoint  # type: ignore
-        def f():
-            pass
-
-
-def test_function_forgot_parentheses():
-    app = App()
-
-    with pytest.raises(InvalidError, match="function()"):
-
-        @app.function  # type: ignore
-        def f():
-            pass
-
-
-def test_cls_forgot_parentheses():
-    app = App()
-
-    with pytest.raises(InvalidError, match="cls()"):
-
-        @app.cls  # type: ignore
-        class XYZ:
-            pass
-
-
-def test_method_forgot_parentheses():
-    app = App()
-
-    with pytest.raises(InvalidError, match="method()"):
-
-        @app.cls()
-        class XYZ:
-            @method  # type: ignore
-            def f(self):
-                pass
-
-
-def test_invalid_web_decorator_usage():
-    app = App()
-
-    with pytest.raises(InvalidError, match="web_endpoint()"):
-
-        @app.function()  # type: ignore
-        @web_endpoint  # type: ignore
-        def my_handle():
-            pass
-
-    with pytest.raises(InvalidError, match="asgi_app()"):
-
-        @app.function()  # type: ignore
-        @asgi_app  # type: ignore
-        def my_handle_asgi():
-            pass
-
-    with pytest.raises(InvalidError, match="wsgi_app()"):
-
-        @app.function()  # type: ignore
-        @wsgi_app  # type: ignore
-        def my_handle_wsgi():
-            pass
-
-
-def test_web_endpoint_method():
-    app = App()
-
-    with pytest.raises(InvalidError, match="remove the `@method`"):
-
-        @app.cls()
-        class Container:
-            @method()  # type: ignore
-            @web_endpoint()
-            def generate(self):
-                pass

test/deprecation_test.py

@@ -1,34 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-
-from modal.exception import DeprecationError
-
-from .supports.functions import deprecated_function
-
-# Not a pytest unit test, but an extra assertion that we catch issues in global scope too
-# See #2228
-exc = None
-try:
-    deprecated_function(42)
-except Exception as e:
-    exc = e
-finally:
-    assert isinstance(exc, DeprecationError)  # If you see this, try running `pytest client/client_test`
-
-
-def test_deprecation():
-    # See conftest.py in the root of the repo
-    # All deprecation warnings in modal during tests will trigger exceptions
-    with pytest.raises(DeprecationError):
-        deprecated_function(42)
-
-    # With this context manager, it doesn't raise an exception, but we record
-    # the warning. This is the normal behavior outside of pytest.
-    with pytest.warns(DeprecationError) as record:
-        res = deprecated_function(42)
-        assert res == 1764
-
-    # Make sure it raises in the right file
-    from .supports import functions
-
-    assert record[0].filename == functions.__file__

test/dict_test.py

@@ -1,51 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import time
-
-from modal import Dict
-from modal.exception import NotFoundError
-
-
-def test_dict_app(servicer, client):
-    d = Dict.lookup("my-amazing-dict", {"xyz": 123}, create_if_missing=True, client=client)
-    d["foo"] = 42
-    d["foo"] += 5
-    assert d["foo"] == 47
-    assert d.len() == 2
-
-    assert sorted(d.keys()) == ["foo", "xyz"]
-    assert sorted(d.values()) == [47, 123]
-    assert sorted(d.items()) == [("foo", 47), ("xyz", 123)]
-
-    d.clear()
-    assert d.len() == 0
-    with pytest.raises(KeyError):
-        _ = d["foo"]
-
-    assert d.get("foo", default=True)
-    d["foo"] = None
-    assert d["foo"] is None
-
-    Dict.delete("my-amazing-dict", client=client)
-    with pytest.raises(NotFoundError):
-        Dict.lookup("my-amazing-dict", client=client)
-
-
-def test_dict_ephemeral(servicer, client):
-    assert servicer.n_dict_heartbeats == 0
-    with Dict.ephemeral({"bar": 123}, client=client, _heartbeat_sleep=1) as d:
-        d["foo"] = 42
-        assert d.len() == 2
-        assert d["foo"] == 42
-        assert d["bar"] == 123
-        time.sleep(1.5)  # Make time for 2 heartbeats
-    assert servicer.n_dict_heartbeats == 2
-
-
-def test_dict_lazy_hydrate_named(set_env_client, servicer):
-    with servicer.intercept() as ctx:
-        d = Dict.from_name("foo", create_if_missing=True)
-        assert len(ctx.get_requests("DictGetOrCreate")) == 0  # sanity check that the get request is lazy
-        d["foo"] = 42
-        assert d["foo"] == 42
-        assert len(ctx.get_requests("DictGetOrCreate")) == 1  # just sanity check that object is only hydrated once...

test/e2e_test.py

@@ -1,68 +0,0 @@
-# Copyright Modal Labs 2022
-import os
-import pathlib
-import subprocess
-import sys
-from typing import Tuple
-
-
-def _cli(args, server_url, extra_env={}, check=True) -> Tuple[int, str, str]:
-    lib_dir = pathlib.Path(__file__).parent.parent
-    args = [sys.executable] + args
-    env = {
-        "MODAL_SERVER_URL": server_url,
-        **os.environ,
-        "PYTHONUTF8": "1",  # For windows
-        **extra_env,
-    }
-    ret = subprocess.run(args, cwd=lib_dir, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-    stdout = ret.stdout.decode()
-    stderr = ret.stderr.decode()
-    if check and ret.returncode != 0:
-        raise Exception(f"Failed with {ret.returncode} stdout: {stdout} stderr: {stderr}")
-    return ret.returncode, stdout, stderr
-
-
-def test_run_e2e(servicer):
-    _, _, err = _cli(["-m", "test.supports.script"], servicer.remote_addr)
-    assert err == ""
-
-
-def test_run_progress_info(servicer):
-    returncode, stdout, stderr = _cli(["-m", "test.supports.progress_info"], servicer.remote_addr)
-    assert returncode == 0
-    assert stderr == ""
-    lines = stdout.splitlines()
-    assert "Initialized. View run at https://modaltest.com/apps/ap-123" in lines[0]
-    assert "App completed" in lines[-1]
-
-
-def test_run_profiler(servicer):
-    _cli(["-m", "cProfile", "-m", "test.supports.script"], servicer.remote_addr)
-
-
-def test_run_unconsumed_map(servicer):
-    _, _, err = _cli(["-m", "test.supports.unconsumed_map"], servicer.remote_addr)
-    assert "map" in err
-    assert "for-loop" in err
-
-    _, _, err = _cli(["-m", "test.supports.consumed_map"], servicer.remote_addr)
-    assert "map" not in err
-    assert "for-loop" not in err
-
-
-def test_auth_failure_last_line(servicer):
-    returncode, out, err = _cli(
-        ["-m", "test.supports.script"],
-        servicer.remote_addr,
-        extra_env={"MODAL_TOKEN_ID": "bad", "MODAL_TOKEN_SECRET": "bad"},
-        check=False,
-    )
-    try:
-        assert returncode != 0
-        assert "bad bad bad" in err.strip().split("\n")[-1]  # err msg should be on the last line
-    except Exception:
-        print("out:", repr(out))
-        print("err:", repr(err))
-        raise

test/error_test.py

@@ -1,7 +0,0 @@
-# Copyright Modal Labs 2022
-from modal import Error
-from modal.exception import NotFoundError
-
-
-def test_modal_errors():
-    assert issubclass(NotFoundError, Error)

test/function_serialization_test.py

@@ -1,32 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-from modal import App
-from modal._serialization import deserialize
-
-
-@pytest.mark.asyncio
-async def test_serialize_deserialize_function(servicer, client):
-    app = App()
-
-    @app.function(serialized=True, name="foo")
-    def foo():
-        2 * foo.remote()
-
-    assert foo.object_id is None
-
-    with app.run(client=client):
-        object_id = foo.object_id
-
-    assert object_id is not None
-    assert {object_id} == servicer.precreated_functions
-
-    foo_def = servicer.app_functions[object_id]
-
-    assert len(servicer.client_calls) == 0
-
-    deserialized_function_body = deserialize(foo_def.function_serialized, client)
-    deserialized_function_body()  # call locally as if in container, this should trigger a "remote" foo() call
-    assert len(servicer.client_calls) == 1
-    function_call_id = list(servicer.client_calls.keys())[0]
-    assert servicer.function_id_for_function_call[function_call_id] == object_id