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

test/serialization_test.py

@@ -1,50 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import random
-
-from modal import Queue
-from modal._serialization import deserialize, deserialize_data_format, serialize, serialize_data_format
-from modal._utils.rand_pb_testing import rand_pb
-from modal.exception import DeserializationError
-from modal_proto import api_pb2
-
-from .supports.skip import skip_old_py
-
-
-@pytest.mark.asyncio
-async def test_roundtrip(servicer, client):
-    async with Queue.ephemeral(client=client) as q:
-        data = serialize(q)
-        # TODO: strip synchronizer reference from synchronicity entities!
-        assert len(data) < 350  # Used to be 93...
-        # Note: if this blows up significantly, it's most likely because
-        # cloudpickle can't find a class in the global scope. When this
-        # happens, it tries to serialize the entire class along with the
-        # object. The reason it doesn't find the class in the global scope
-        # is most likely because the name doesn't match. To fix this, make
-        # sure that cls.__name__ (which is something synchronicity sets)
-        # is the same as the symbol defined in the global scope.
-        q_roundtrip = deserialize(data, client)
-        assert isinstance(q_roundtrip, Queue)
-        assert q.object_id == q_roundtrip.object_id
-
-
-@skip_old_py("random.randbytes() was introduced in python 3.9", (3, 9))
-@pytest.mark.asyncio
-async def test_asgi_roundtrip():
-    rand = random.Random(42)
-    for _ in range(10000):
-        msg = rand_pb(api_pb2.Asgi, rand)
-        buf = msg.SerializeToString()
-        asgi_obj = deserialize_data_format(buf, api_pb2.DATA_FORMAT_ASGI, None)
-        assert asgi_obj is None or (isinstance(asgi_obj, dict) and asgi_obj["type"])
-        buf = serialize_data_format(asgi_obj, api_pb2.DATA_FORMAT_ASGI)
-        asgi_obj_roundtrip = deserialize_data_format(buf, api_pb2.DATA_FORMAT_ASGI, None)
-        assert asgi_obj == asgi_obj_roundtrip
-
-
-def test_deserialization_error(client):
-    # Curated object that we should not be able to deserialize
-    obj = b"\x80\x04\x95(\x00\x00\x00\x00\x00\x00\x00\x8c\x17undeserializable_module\x94\x8c\x05Dummy\x94\x93\x94)\x81\x94."
-    with pytest.raises(DeserializationError, match="'undeserializable_module' .+ local environment"):
-        deserialize(obj, client)

test/stub_composition_test.py

@@ -1,10 +0,0 @@
-# Copyright Modal Labs 2024
-from test.helpers import deploy_app_externally
-
-
-def test_app_composition_includes_all_functions(servicer, supports_dir, monkeypatch, client):
-    print(deploy_app_externally(servicer, "main.py", cwd=supports_dir / "multifile_project"))
-    assert servicer.n_functions == 3
-    assert {"/root/main.py", "/root/a.py", "/root/b.py", "/root/c.py"} == set(servicer.files_name2sha.keys())
-    assert len(servicer.secrets) == 1  # secret from B should be included
-    assert servicer.n_mounts == 4  # mounts should not be duplicated

test/stub_test.py

@@ -1,361 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-import logging
-import pytest
-
-from google.protobuf.empty_pb2 import Empty
-from grpclib import GRPCError, Status
-
-from modal import App, Dict, Image, Mount, Queue, Secret, Volume, web_endpoint
-from modal.app import list_apps  # type: ignore
-from modal.config import config
-from modal.exception import DeprecationError, ExecutionError, InvalidError, NotFoundError
-from modal.partial_function import _parse_custom_domains
-from modal.runner import deploy_app
-from modal_proto import api_pb2
-
-from .supports import module_1, module_2
-
-
-@pytest.mark.asyncio
-async def test_kwargs(servicer, client):
-    with pytest.raises(DeprecationError):
-        App(
-            d=Dict.new(),
-            q=Queue.new(),
-        )
-
-
-@pytest.mark.asyncio
-async def test_attrs(servicer, client):
-    app = App()
-    with pytest.warns(DeprecationError):
-        app.d = Dict.new()
-        app.q = Queue.new()
-    async with app.run(client=client):
-        with pytest.warns(DeprecationError):
-            await app.d.put.aio("foo", "bar")  # type: ignore
-            await app.q.put.aio("baz")  # type: ignore
-            assert await app.d.get.aio("foo") == "bar"  # type: ignore
-            assert await app.q.get.aio() == "baz"  # type: ignore
-
-
-def square(x):
-    return x**2
-
-
-@pytest.mark.asyncio
-async def test_redeploy(servicer, client):
-    app = App(image=Image.debian_slim().pip_install("pandas"))
-    app.function()(square)
-
-    # Deploy app
-    res = await deploy_app.aio(app, "my-app", client=client)
-    assert res.app_id == "ap-1"
-    assert servicer.app_objects["ap-1"]["square"] == "fu-1"
-    assert servicer.app_state_history[res.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DEPLOYED]
-
-    # Redeploy, make sure all ids are the same
-    res = await deploy_app.aio(app, "my-app", client=client)
-    assert res.app_id == "ap-1"
-    assert servicer.app_objects["ap-1"]["square"] == "fu-1"
-    assert servicer.app_state_history[res.app_id] == [
-        api_pb2.APP_STATE_INITIALIZING,
-        api_pb2.APP_STATE_DEPLOYED,
-        api_pb2.APP_STATE_DEPLOYED,
-    ]
-
-    # Deploy to a different name, ids should change
-    res = await deploy_app.aio(app, "my-app-xyz", client=client)
-    assert res.app_id == "ap-2"
-    assert servicer.app_objects["ap-2"]["square"] == "fu-2"
-    assert servicer.app_state_history[res.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DEPLOYED]
-
-
-def dummy():
-    pass
-
-
-# Should exit without waiting for the "logs_timeout" grace period.
-@pytest.mark.timeout(5)
-def test_create_object_exception(servicer, client):
-    servicer.function_create_error = True
-
-    app = App()
-    app.function()(dummy)
-
-    with pytest.raises(GRPCError) as excinfo:
-        with app.run(client=client):
-            pass
-
-    assert excinfo.value.status == Status.INTERNAL
-
-
-def test_deploy_falls_back_to_app_name(servicer, client):
-    named_app = App(name="foo_app")
-    deploy_app(named_app, client=client)
-    assert "foo_app" in servicer.deployed_apps
-
-
-def test_deploy_uses_deployment_name_if_specified(servicer, client):
-    named_app = App(name="foo_app")
-    deploy_app(named_app, "bar_app", client=client)
-    assert "bar_app" in servicer.deployed_apps
-    assert "foo_app" not in servicer.deployed_apps
-
-
-def test_run_function_without_app_error():
-    app = App()
-    dummy_modal = app.function()(dummy)
-
-    with pytest.raises(ExecutionError) as excinfo:
-        dummy_modal.remote()
-
-    assert "hydrated" in str(excinfo.value)
-
-
-def test_is_inside_basic():
-    app = App()
-    with pytest.raises(DeprecationError, match="imports()"):
-        app.is_inside()
-
-
-def test_missing_attr():
-    """Trying to call a non-existent function on the App should produce
-    an understandable error message."""
-
-    app = App()
-    with pytest.raises(AttributeError):
-        app.fun()  # type: ignore
-
-
-def test_same_function_name(caplog):
-    app = App()
-
-    # Add first function
-    with caplog.at_level(logging.WARNING):
-        app.function()(module_1.square)
-    assert len(caplog.records) == 0
-
-    # Add second function: check warning
-    with caplog.at_level(logging.WARNING):
-        app.function()(module_2.square)
-    assert len(caplog.records) == 1
-    assert "module_1" in caplog.text
-    assert "module_2" in caplog.text
-    assert "square" in caplog.text
-
-
-def test_run_state(client, servicer):
-    app = App()
-    with app.run(client=client):
-        assert servicer.app_state_history[app.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_EPHEMERAL]
-
-
-def test_deploy_state(client, servicer):
-    app = App()
-    res = deploy_app(app, "foobar", client=client)
-    assert servicer.app_state_history[res.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DEPLOYED]
-
-
-def test_detach_state(client, servicer):
-    app = App()
-    with app.run(client=client, detach=True):
-        assert servicer.app_state_history[app.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DETACHED]
-
-
-@pytest.mark.asyncio
-async def test_grpc_protocol(client, servicer):
-    app = App()
-    async with app.run(client=client):
-        await asyncio.sleep(0.01)  # wait for heartbeat
-    assert len(servicer.requests) == 4
-    assert isinstance(servicer.requests[0], Empty)  # ClientHello
-    assert isinstance(servicer.requests[1], api_pb2.AppCreateRequest)
-    assert isinstance(servicer.requests[2], api_pb2.AppHeartbeatRequest)
-    assert isinstance(servicer.requests[3], api_pb2.AppClientDisconnectRequest)
-
-
-async def web1(x):
-    return {"square": x**2}
-
-
-async def web2(x):
-    return {"cube": x**3}
-
-
-def test_registered_web_endpoints(client, servicer):
-    app = App()
-    app.function()(square)
-    app.function()(web_endpoint()(web1))
-    app.function()(web_endpoint()(web2))
-
-    assert app.registered_web_endpoints == ["web1", "web2"]
-
-
-def test_init_types():
-    with pytest.raises(InvalidError):
-        # singular secret to plural argument
-        App(secrets=Secret.from_dict())  # type: ignore
-    with pytest.raises(InvalidError):
-        # not a Secret Object
-        App(secrets=[{"foo": "bar"}])  # type: ignore
-    with pytest.raises(InvalidError):
-        # should be an Image
-        App(image=Secret.from_dict())  # type: ignore
-
-    App(
-        image=Image.debian_slim().pip_install("pandas"),
-        secrets=[Secret.from_dict()],
-        mounts=[Mount.from_local_file(__file__)],
-    )
-
-
-def test_set_image_on_app_as_attribute():
-    # TODO: do we want to deprecate this syntax? It's kind of random for image to
-    #     have a reserved name in the blueprint, and being the only of the construction
-    #     arguments that can be set on the instance after construction
-    custom_img = Image.debian_slim().apt_install("emacs")
-    app = App(image=custom_img)
-    assert app._get_default_image() == custom_img
-
-
-def test_redeploy_delete_objects(servicer, client):
-    # Deploy an app with objects d1 and d2
-    app = App()
-    app.function(name="d1")(dummy)
-    app.function(name="d2")(dummy)
-    res = deploy_app(app, "xyz", client=client)
-
-    # Check objects
-    assert set(servicer.app_objects[res.app_id].keys()) == set(["d1", "d2"])
-
-    # Deploy an app with objects d2 and d3
-    app = App()
-    app.function(name="d2")(dummy)
-    app.function(name="d3")(dummy)
-    res = deploy_app(app, "xyz", client=client)
-
-    # Make sure d1 is deleted
-    assert set(servicer.app_objects[res.app_id].keys()) == set(["d2", "d3"])
-
-
-@pytest.mark.asyncio
-async def test_unhydrate(servicer, client):
-    app = App()
-
-    f = app.function()(dummy)
-
-    assert not f.is_hydrated
-    async with app.run(client=client):
-        assert f.is_hydrated
-
-    # After app finishes, it should unhydrate
-    assert not f.is_hydrated
-
-
-def test_keyboard_interrupt(servicer, client):
-    app = App()
-    app.function()(square)
-    with app.run(client=client):
-        # The exit handler should catch this interrupt and exit gracefully
-        raise KeyboardInterrupt()
-
-
-def test_function_image_positional():
-    app = App()
-    image = Image.debian_slim()
-
-    with pytest.raises(InvalidError) as excinfo:
-
-        @app.function(image)  # type: ignore
-        def f():
-            pass
-
-    assert "function(image=image)" in str(excinfo.value)
-
-
-@pytest.mark.asyncio
-async def test_deploy_disconnect(servicer, client):
-    app = App()
-    app.function(secrets=[Secret.from_name("nonexistent-secret")])(square)
-
-    with pytest.raises(NotFoundError):
-        await deploy_app.aio(app, "my-app", client=client)
-
-    assert servicer.app_state_history["ap-1"] == [
-        api_pb2.APP_STATE_INITIALIZING,
-        api_pb2.APP_STATE_STOPPED,
-    ]
-
-
-def test_redeploy_from_name_change(servicer, client):
-    # Deploy queue
-    Queue.lookup("foo-queue", create_if_missing=True, client=client)
-
-    # Use it from app
-    app = App()
-    with pytest.warns(DeprecationError):
-        app.q = Queue.from_name("foo-queue")
-    deploy_app(app, "my-app", client=client)
-
-    # Change the object id of foo-queue
-    k = ("foo-queue", api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE, config.get("environment"))
-    assert servicer.deployed_queues[k]
-    servicer.deployed_queues[k] = "qu-baz123"
-
-    # Redeploy app
-    # This should not fail because the object_id changed - it's a different app
-    deploy_app(app, "my-app", client=client)
-
-
-def test_parse_custom_domains():
-    assert len(_parse_custom_domains(None)) == 0
-    assert len(_parse_custom_domains(["foo.com", "bar.com"])) == 2
-    with pytest.raises(AssertionError):
-        assert _parse_custom_domains("foo.com")
-
-
-def test_hydrated_other_app_object_gets_referenced(servicer, client):
-    app = App("my-app")
-    with servicer.intercept() as ctx:
-        with Volume.ephemeral(client=client) as vol:
-            app.function(volumes={"/vol": vol})(dummy)  # implicitly load vol
-            deploy_app(app, client=client)
-            app_set_objects_req = ctx.pop_request("AppSetObjects")
-            assert vol.object_id in app_set_objects_req.unindexed_object_ids
-
-
-def test_hasattr():
-    app = App()
-    assert not hasattr(app, "xyz")
-
-
-def test_app(client):
-    app = App()
-    square_modal = app.function()(square)
-
-    with app.run(client=client):
-        square_modal.remote(42)
-
-
-def test_list_apps(client):
-    apps_0 = [app.name for app in list_apps(client=client)]
-    app = App()
-    deploy_app(app, "foobar", client=client)
-    apps_1 = [app.name for app in list_apps(client=client)]
-
-    assert len(apps_1) == len(apps_0) + 1
-    assert set(apps_1) - set(apps_0) == set(["foobar"])
-
-
-def test_function_named_app():
-    # Make sure we have a helpful warning when a user's function is named "app"
-    # as it might collide with the App variable name (in particular if people
-    # find & replace "stub" with "app").
-    app = App()
-
-    with pytest.warns(match="app"):
-        @app.function(serialized=True)
-        def app():
-            ...

test/test_asgi_wrapper.py

@@ -1,234 +0,0 @@
-# Copyright Modal Labs 2024
-import asyncio
-import pytest
-
-import fastapi
-from starlette.requests import ClientDisconnect
-
-from modal._asgi import asgi_app_wrapper
-from modal.execution_context import _set_current_context_ids
-
-
-class DummyException(Exception):
-    pass
-
-
-app = fastapi.FastAPI()
-
-
-@app.get("/")
-def sync_index():
-    return {"some_result": "foo"}
-
-
-@app.get("/error")
-def sync_error():
-    raise DummyException()
-
-
-@app.post("/async_reading_body")
-async def async_index_reading_body(req: fastapi.Request):
-    body = await req.body()
-    return {"some_result": body}
-
-
-@app.get("/async_error")
-async def async_error():
-    raise DummyException()
-
-
-@app.get("/streaming_response")
-async def streaming_response():
-    from fastapi.responses import StreamingResponse
-
-    async def stream_bytes():
-        yield b"foo"
-        yield b"bar"
-
-    return StreamingResponse(stream_bytes())
-
-
-def _asgi_get_scope(path, method="GET"):
-    return {
-        "type": "http",
-        "method": method,
-        "path": path,
-        "query_string": "",
-        "headers": [],
-    }
-
-
-class MockIOManager:
-    class get_data_in:
-        @staticmethod
-        async def aio(_function_call_id):
-            yield {"type": "http.request", "body": b"some_body"}
-            await asyncio.sleep(10)
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(1)
-async def test_success():
-    mock_manager = MockIOManager()
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, mock_manager)
-    asgi_scope = _asgi_get_scope("/")
-    outputs = [output async for output in wrapped_app(asgi_scope)]
-    assert len(outputs) == 2
-    before_body = outputs[0]
-    assert before_body["status"] == 200
-    assert before_body["type"] == "http.response.start"
-    body = outputs[1]
-    assert body["body"] == b'{"some_result":"foo"}'
-    assert body["type"] == "http.response.body"
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("endpoint_url", ["/error", "/async_error"])
-@pytest.mark.timeout(1)
-async def test_endpoint_exception(endpoint_url):
-    mock_manager = MockIOManager()
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, mock_manager)
-    asgi_scope = _asgi_get_scope(endpoint_url)
-    outputs = []
-
-    with pytest.raises(DummyException):
-        async for output in wrapped_app(asgi_scope):
-            outputs.append(output)
-
-    assert len(outputs) == 2
-    before_body = outputs[0]
-    assert before_body["status"] == 500
-    assert before_body["type"] == "http.response.start"
-    body = outputs[1]
-    assert body["body"] == b"Internal Server Error"
-    assert body["type"] == "http.response.body"
-
-
-class BrokenIOManager:
-    class get_data_in:
-        @staticmethod
-        async def aio(_function_call_id):
-            raise DummyException("error while fetching data")
-            yield  # noqa (makes this a generator)
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(1)
-async def test_broken_io_unused(caplog):
-    # if IO channel breaks, but the endpoint doesn't actually use
-    # any of the body data, it should be allowed to output its data
-    # and not raise an exception - but print a warning since it's unexpected
-    mock_manager = BrokenIOManager()
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, mock_manager)
-    asgi_scope = _asgi_get_scope("/")
-    outputs = []
-
-    async for output in wrapped_app(asgi_scope):
-        outputs.append(output)
-
-    assert len(outputs) == 2
-    assert outputs[0]["status"] == 200
-    assert outputs[1]["body"] == b'{"some_result":"foo"}'
-    assert "Internal error" in caplog.text
-    assert "DummyException: error while fetching data" in caplog.text
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(10)
-async def test_broken_io_used():
-    mock_manager = BrokenIOManager()
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, mock_manager)
-    asgi_scope = _asgi_get_scope("/async_reading_body", "POST")
-    outputs = []
-    with pytest.raises(ClientDisconnect):
-        async for output in wrapped_app(asgi_scope):
-            outputs.append(output)
-
-    assert len(outputs) == 2
-    assert outputs[0]["status"] == 500
-
-
-class SlowIOManager:
-    class get_data_in:
-        @staticmethod
-        async def aio(_function_call_id):
-            await asyncio.sleep(5)
-            yield  # makes this an async generator
-
-
-@pytest.mark.asyncio
-@pytest.mark.timeout(2)
-async def test_first_message_timeout(monkeypatch):
-    monkeypatch.setattr("modal._asgi.FIRST_MESSAGE_TIMEOUT_SECONDS", 0.1)  # simulate timeout
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, SlowIOManager())
-    asgi_scope = _asgi_get_scope("/async_reading_body", "POST")
-    outputs = []
-    with pytest.raises(ClientDisconnect):
-        async for output in wrapped_app(asgi_scope):
-            outputs.append(output)
-
-    assert outputs[0]["status"] == 502
-    assert b"Missing request" in outputs[1]["body"]
-
-
-@pytest.mark.asyncio
-async def test_cancellation_cleanup(caplog):
-    # this test mostly exists to get some coverage on the cancellation/error paths and ensure nothing unexpected happens there
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, SlowIOManager())
-    asgi_scope = _asgi_get_scope("/async_reading_body", "POST")
-    outputs = []
-
-    async def app_runner():
-        async for output in wrapped_app(asgi_scope):
-            outputs.append(output)
-
-    app_runner_task = asyncio.create_task(app_runner())
-    await asyncio.sleep(0.1)  # let it get started
-    app_runner_task.cancel()
-    await asyncio.sleep(0.1)  # let it shut down
-    assert len(outputs) == 0
-    assert caplog.text == ""  # make sure there are no junk traces about dangling tasks etc.
-
-
-@pytest.mark.asyncio
-async def test_streaming_response():
-    _set_current_context_ids("in-123", "fc-123")
-    wrapped_app = asgi_app_wrapper(app, SlowIOManager())
-    asgi_scope = _asgi_get_scope("/streaming_response", "GET")
-    outputs = []
-    async for output in wrapped_app(asgi_scope):
-        outputs.append(output)
-    assert outputs == [
-        {"headers": [], "status": 200, "type": "http.response.start"},
-        {"body": b"foo", "more_body": True, "type": "http.response.body"},
-        {"body": b"bar", "more_body": True, "type": "http.response.body"},
-        {"body": b"", "more_body": False, "type": "http.response.body"},
-    ]
-
-
-class StreamingIOManager:
-    class get_data_in:
-        @staticmethod
-        async def aio(_function_call_id):
-            yield {"type": "http.request", "body": b"foo", "more_body": True}
-            yield {"type": "http.request", "body": b"bar", "more_body": True}
-            yield {"type": "http.request", "body": b"baz", "more_body": False}
-            yield {"type": "http.request", "body": b"this should not be read", "more_body": False}
-
-
-@pytest.mark.asyncio
-async def test_streaming_body():
-    _set_current_context_ids("in-123", "fc-123")
-
-    wrapped_app = asgi_app_wrapper(app, StreamingIOManager())
-    asgi_scope = _asgi_get_scope("/async_reading_body", "POST")
-    outputs = []
-    async for output in wrapped_app(asgi_scope):
-        outputs.append(output)
-    assert outputs[1] == {"type": "http.response.body", "body": b'{"some_result":"foobarbaz"}'}

test/token_flow_test.py

@@ -1,18 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-import aiohttp
-
-from modal.token_flow import TokenFlow
-
-
-@pytest.mark.asyncio
-async def test_token_flow_server(servicer, client):
-    tf = TokenFlow(client)
-    async with tf.start() as (token_flow_id, _, _):
-        # Make a request against the local web server and make sure it validates
-        localhost_url = f"http://localhost:{servicer.token_flow_localhost_port}"
-        async with aiohttp.ClientSession() as session:
-            async with session.get(localhost_url) as resp:
-                text = await resp.text()
-                assert text == token_flow_id