modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

test/stub_test.py

@@ -1,360 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-import logging
-import pytest
-
-from google.protobuf.empty_pb2 import Empty
-from grpclib import GRPCError, Status
-
-import modal.app
-from modal import Dict, Image, Queue, Stub, web_endpoint
-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_stub
-from modal_proto import api_pb2
-
-from .supports import module_1, module_2
-
-
-@pytest.mark.asyncio
-async def test_kwargs(servicer, client):
-    with pytest.warns(DeprecationError):
-        stub = Stub(
-            d=Dict.new(),
-            q=Queue.new(),
-        )
-    async with stub.run(client=client):
-        with pytest.warns(DeprecationError):
-            await stub["d"].put.aio("foo", "bar")  # type: ignore
-            await stub["q"].put.aio("baz")  # type: ignore
-            assert await stub["d"].get.aio("foo") == "bar"  # type: ignore
-            assert await stub["q"].get.aio() == "baz"  # type: ignore
-
-
-@pytest.mark.asyncio
-async def test_attrs(servicer, client):
-    stub = Stub()
-    with pytest.warns(DeprecationError):
-        stub.d = Dict.new()
-        stub.q = Queue.new()
-    async with stub.run(client=client):
-        with pytest.warns(DeprecationError):
-            await stub.d.put.aio("foo", "bar")  # type: ignore
-            await stub.q.put.aio("baz")  # type: ignore
-            assert await stub.d.get.aio("foo") == "bar"  # type: ignore
-            assert await stub.q.get.aio() == "baz"  # type: ignore
-
-
-@pytest.mark.asyncio
-async def test_stub_type_validation(servicer, client):
-    with pytest.raises(InvalidError):
-        with pytest.warns(DeprecationError):
-            stub = Stub(
-                foo=4242,  # type: ignore
-            )
-
-    stub = Stub()
-
-    with pytest.raises(InvalidError) as excinfo:
-        stub.bar = 4242  # type: ignore
-
-    assert "4242" in str(excinfo.value)
-
-
-def square(x):
-    return x**2
-
-
-@pytest.mark.asyncio
-async def test_redeploy(servicer, client):
-    stub = Stub(image=Image.debian_slim().pip_install("pandas"))
-    stub.function()(square)
-
-    # Deploy app
-    app = await deploy_stub.aio(stub, "my-app", client=client)
-    assert app.app_id == "ap-1"
-    assert servicer.app_objects["ap-1"]["square"] == "fu-1"
-    assert servicer.app_state_history[app.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DEPLOYED]
-
-    # Redeploy, make sure all ids are the same
-    app = await deploy_stub.aio(stub, "my-app", client=client)
-    assert app.app_id == "ap-1"
-    assert servicer.app_objects["ap-1"]["square"] == "fu-1"
-    assert servicer.app_state_history[app.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
-    app = await deploy_stub.aio(stub, "my-app-xyz", client=client)
-    assert app.app_id == "ap-2"
-    assert servicer.app_objects["ap-2"]["square"] == "fu-2"
-    assert servicer.app_state_history[app.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
-
-    stub = Stub()
-    stub.function()(dummy)
-
-    with pytest.raises(GRPCError) as excinfo:
-        with stub.run(client=client):
-            pass
-
-    assert excinfo.value.status == Status.INTERNAL
-
-
-def test_deploy_falls_back_to_app_name(servicer, client):
-    named_stub = Stub(name="foo_app")
-    deploy_stub(named_stub, client=client)
-    assert "foo_app" in servicer.deployed_apps
-
-
-def test_deploy_uses_deployment_name_if_specified(servicer, client):
-    named_stub = Stub(name="foo_app")
-    deploy_stub(named_stub, "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():
-    stub = Stub()
-    dummy_modal = stub.function()(dummy)
-
-    with pytest.raises(ExecutionError) as excinfo:
-        dummy_modal.remote()
-
-    assert "hydrated" in str(excinfo.value)
-
-
-def test_is_inside_basic():
-    stub = Stub()
-    with pytest.raises(DeprecationError, match="imports()"):
-        stub.is_inside()
-
-
-def test_missing_attr():
-    """Trying to call a non-existent function on the Stub should produce
-    an understandable error message."""
-
-    stub = Stub()
-    with pytest.raises(AttributeError):
-        stub.fun()  # type: ignore
-
-
-def test_same_function_name(caplog):
-    stub = Stub()
-
-    # Add first function
-    with caplog.at_level(logging.WARNING):
-        stub.function()(module_1.square)
-    assert len(caplog.records) == 0
-
-    # Add second function: check warning
-    with caplog.at_level(logging.WARNING):
-        stub.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):
-    stub = Stub()
-    with stub.run(client=client):
-        assert servicer.app_state_history[stub.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_EPHEMERAL]
-
-
-def test_deploy_state(client, servicer):
-    stub = Stub()
-    app = deploy_stub(stub, "foobar", client=client)
-    assert servicer.app_state_history[app.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DEPLOYED]
-
-
-def test_detach_state(client, servicer):
-    stub = Stub()
-    with stub.run(client=client, detach=True):
-        assert servicer.app_state_history[stub.app_id] == [api_pb2.APP_STATE_INITIALIZING, api_pb2.APP_STATE_DETACHED]
-
-
-@pytest.mark.asyncio
-async def test_grpc_protocol(client, servicer):
-    stub = Stub()
-    async with stub.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):
-    stub = Stub()
-    stub.function()(square)
-    stub.function()(web_endpoint()(web1))
-    stub.function()(web_endpoint()(web2))
-
-    assert stub.registered_web_endpoints == ["web1", "web2"]
-
-
-def test_init_types():
-    with pytest.raises(InvalidError):
-        # singular secret to plural argument
-        Stub(secrets=modal.Secret.from_dict())  # type: ignore
-    with pytest.raises(InvalidError):
-        # not a Secret Object
-        Stub(secrets=[{"foo": "bar"}])  # type: ignore
-    with pytest.raises(InvalidError):
-        # blueprint needs to use _Providers
-        with pytest.warns(DeprecationError):
-            Stub(some_arg=5)  # type: ignore
-    with pytest.raises(InvalidError):
-        # should be an Image
-        Stub(image=modal.Secret.from_dict())  # type: ignore
-
-    with pytest.warns(DeprecationError):
-        Stub(
-            image=modal.Image.debian_slim().pip_install("pandas"),
-            secrets=[modal.Secret.from_dict()],
-            mounts=[modal.Mount.from_local_file(__file__)],
-            some_dict=modal.Dict.new(),
-            some_queue=modal.Queue.new(),
-        )
-
-
-def test_set_image_on_stub_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 = modal.Image.debian_slim().apt_install("emacs")
-    stub = Stub(image=custom_img)
-    assert stub._get_default_image() == custom_img
-
-
-def test_redeploy_delete_objects(servicer, client):
-    # Deploy an app with objects d1 and d2
-    stub = Stub()
-    stub.function(name="d1")(dummy)
-    stub.function(name="d2")(dummy)
-    app = deploy_stub(stub, "xyz", client=client)
-
-    # Check objects
-    assert set(servicer.app_objects[app.app_id].keys()) == set(["d1", "d2"])
-
-    # Deploy an app with objects d2 and d3
-    stub = Stub()
-    stub.function(name="d2")(dummy)
-    stub.function(name="d3")(dummy)
-    app = deploy_stub(stub, "xyz", client=client)
-
-    # Make sure d1 is deleted
-    assert set(servicer.app_objects[app.app_id].keys()) == set(["d2", "d3"])
-
-
-@pytest.mark.asyncio
-async def test_unhydrate(servicer, client):
-    stub = Stub()
-
-    f = stub.function()(dummy)
-
-    assert not f.is_hydrated
-    async with stub.run(client=client):
-        assert f.is_hydrated
-
-    # After app finishes, it should unhydrate
-    assert not f.is_hydrated
-
-
-def test_keyboard_interrupt(servicer, client):
-    stub = Stub()
-    stub.function()(square)
-    with stub.run(client=client):
-        # The exit handler should catch this interrupt and exit gracefully
-        raise KeyboardInterrupt()
-
-
-def test_function_image_positional():
-    stub = Stub()
-    image = Image.debian_slim()
-
-    with pytest.raises(InvalidError) as excinfo:
-
-        @stub.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):
-    stub = Stub()
-    stub.function(secrets=[modal.Secret.from_name("nonexistent-secret")])(square)
-
-    with pytest.raises(NotFoundError):
-        await deploy_stub.aio(stub, "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
-    modal.Queue.lookup("foo-queue", create_if_missing=True, client=client)
-
-    # Use it from stub
-    stub = Stub()
-    with pytest.warns(DeprecationError):
-        stub.q = modal.Queue.from_name("foo-queue")
-    deploy_stub(stub, "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_stub(stub, "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):
-    stub = Stub("my-stub")
-    with servicer.intercept() as ctx:
-        with modal.Volume.ephemeral(client=client) as vol:
-            stub.function(volumes={"/vol": vol})(dummy)  # implicitly load vol
-            deploy_stub(stub, 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():
-    stub = Stub()
-    assert not hasattr(stub, "xyz")

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.functions 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