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

modal/runner.py

@@ -2,32 +2,49 @@
 import asyncio
 import dataclasses
 import os
+import time
+import typing
+from collections.abc import AsyncGenerator
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, AsyncGenerator, List, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
-from rich.console import Console
+from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
+import modal_proto.api_pb2
 from modal_proto import api_pb2
 
-from ._output import OutputManager, get_app_logs_loop, step_completed, step_progress
 from ._pty import get_pty_info
-from ._sandbox_shell import connect_to_sandbox
-from ._utils.app_utils import is_valid_app_name
-from ._utils.async_utils import TaskContext, synchronize_api
+from ._resolver import Resolver
+from ._runtime.execution_context import is_local
+from ._traceback import print_server_warnings, traceback_contains_remote_call
+from ._utils.async_utils import TaskContext, gather_cancel_on_exc, synchronize_api
+from ._utils.deprecation import deprecation_error
 from ._utils.grpc_utils import retry_transient_errors
-from .app import _LocalApp, is_local
+from ._utils.name_utils import check_object_name, is_valid_tag
 from .client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
-from .config import config
-from .exception import InteractiveTimeoutError, InvalidError, _CliUserExecutionError
+from .cls import _Cls
+from .config import config, logger
+from .environments import _get_environment_cached
+from .exception import InteractiveTimeoutError, InvalidError, RemoteError, _CliUserExecutionError
+from .functions import _Function
+from .object import _get_environment_name, _Object
+from .output import _get_output_manager, enable_output
+from .running_app import RunningApp, running_app_from_layout
+from .sandbox import _Sandbox
+from .secret import _Secret
+from .stream_type import StreamType
 
 if TYPE_CHECKING:
-    from .stub import _Stub
+    from .app import _App
 else:
-    _Stub = TypeVar("_Stub")
+    _App = TypeVar("_App")
 
 
-async def _heartbeat(client, app_id):
+V = TypeVar("V")
+
+
+async def _heartbeat(client: _Client, app_id: str) -> None:
     request = api_pb2.AppHeartbeatRequest(app_id=app_id)
     # TODO(erikbern): we should capture exceptions here
     # * if request fails: destroy the client
@@ -35,142 +52,367 @@ async def _heartbeat(client, app_id):
     await retry_transient_errors(client.stub.AppHeartbeat, request, attempt_timeout=HEARTBEAT_TIMEOUT)
 
 
+async def _init_local_app_existing(client: _Client, existing_app_id: str, environment_name: str) -> RunningApp:
+    # Get all the objects first
+    obj_req = api_pb2.AppGetLayoutRequest(app_id=existing_app_id)
+    obj_resp, _ = await gather_cancel_on_exc(
+        retry_transient_errors(client.stub.AppGetLayout, obj_req),
+        # Cache the environment associated with the app now as we will use it later
+        _get_environment_cached(environment_name, client),
+    )
+    app_page_url = f"https://modal.com/apps/{existing_app_id}"  # TODO (elias): this should come from the backend
+    return running_app_from_layout(
+        existing_app_id,
+        obj_resp.app_layout,
+        app_page_url=app_page_url,
+    )
+
+
+async def _init_local_app_new(
+    client: _Client,
+    description: str,
+    app_state: int,  # ValueType
+    environment_name: str = "",
+    interactive: bool = False,
+) -> RunningApp:
+    app_req = api_pb2.AppCreateRequest(
+        description=description,
+        environment_name=environment_name,
+        app_state=app_state,  # type: ignore
+    )
+    app_resp, _ = await gather_cancel_on_exc(  # TODO: use TaskGroup?
+        retry_transient_errors(client.stub.AppCreate, app_req),
+        # Cache the environment associated with the app now as we will use it later
+        _get_environment_cached(environment_name, client),
+    )
+    logger.debug(f"Created new app with id {app_resp.app_id}")
+    return RunningApp(
+        app_resp.app_id,
+        app_page_url=app_resp.app_page_url,
+        app_logs_url=app_resp.app_logs_url,
+        interactive=interactive,
+    )
+
+
+async def _init_local_app_from_name(
+    client: _Client,
+    name: str,
+    namespace: Any,
+    environment_name: str = "",
+) -> RunningApp:
+    # Look up any existing deployment
+    app_req = api_pb2.AppGetByDeploymentNameRequest(
+        name=name,
+        namespace=namespace,
+        environment_name=environment_name,
+    )
+    app_resp = await retry_transient_errors(client.stub.AppGetByDeploymentName, app_req)
+    existing_app_id = app_resp.app_id or None
+
+    # Grab the app
+    if existing_app_id is not None:
+        return await _init_local_app_existing(client, existing_app_id, environment_name)
+    else:
+        return await _init_local_app_new(
+            client, name, api_pb2.APP_STATE_INITIALIZING, environment_name=environment_name
+        )
+
+
+async def _create_all_objects(
+    client: _Client,
+    running_app: RunningApp,
+    functions: dict[str, _Function],
+    classes: dict[str, _Cls],
+    environment_name: str,
+) -> None:
+    """Create objects that have been defined but not created on the server."""
+    indexed_objects: dict[str, _Object] = {**functions, **classes}
+    resolver = Resolver(
+        client,
+        environment_name=environment_name,
+        app_id=running_app.app_id,
+    )
+    with resolver.display():
+        # Get current objects, and reset all objects
+        tag_to_object_id = {**running_app.function_ids, **running_app.class_ids}
+        running_app.function_ids = {}
+        running_app.class_ids = {}
+
+        # Assign all objects
+        for tag, obj in indexed_objects.items():
+            # Reset object_id in case the app runs twice
+            # TODO(erikbern): clean up the interface
+            obj._unhydrate()
+
+        # Preload all functions to make sure they have ids assigned before they are loaded.
+        # This is important to make sure any enclosed function handle references in serialized
+        # functions have ids assigned to them when the function is serialized.
+        # Note: when handles/objs are merged, all objects will need to get ids pre-assigned
+        # like this in order to be referrable within serialized functions
+        async def _preload(tag, obj):
+            existing_object_id = tag_to_object_id.get(tag)
+            # Note: preload only currently implemented for Functions, returns None otherwise
+            # this is to ensure that directly referenced functions from the global scope has
+            # ids associated with them when they are serialized into other functions
+            await resolver.preload(obj, existing_object_id)
+            if obj.object_id is not None:
+                tag_to_object_id[tag] = obj.object_id
+
+        await TaskContext.gather(*(_preload(tag, obj) for tag, obj in indexed_objects.items()))
+
+        async def _load(tag, obj):
+            existing_object_id = tag_to_object_id.get(tag)
+            await resolver.load(obj, existing_object_id)
+            if _Function._is_id_type(obj.object_id):
+                running_app.function_ids[tag] = obj.object_id
+            elif _Cls._is_id_type(obj.object_id):
+                running_app.class_ids[tag] = obj.object_id
+            else:
+                raise RuntimeError(f"Unexpected object {obj.object_id}")
+
+        await TaskContext.gather(*(_load(tag, obj) for tag, obj in indexed_objects.items()))
+
+
+async def _publish_app(
+    client: _Client,
+    running_app: RunningApp,
+    app_state: int,  # api_pb2.AppState.value
+    functions: dict[str, _Function],
+    classes: dict[str, _Cls],
+    name: str = "",  # Only relevant for deployments
+    tag: str = "",  # Only relevant for deployments
+) -> tuple[str, list[api_pb2.Warning]]:
+    """Wrapper for AppPublish RPC."""
+
+    definition_ids = {obj.object_id: obj._get_metadata().definition_id for obj in functions.values()}  # type: ignore
+
+    request = api_pb2.AppPublishRequest(
+        app_id=running_app.app_id,
+        name=name,
+        deployment_tag=tag,
+        app_state=app_state,  # type: ignore  : should be a api_pb2.AppState.value
+        function_ids=running_app.function_ids,
+        class_ids=running_app.class_ids,
+        definition_ids=definition_ids,
+    )
+    try:
+        response = await retry_transient_errors(client.stub.AppPublish, request)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT or exc.status == Status.FAILED_PRECONDITION:
+            raise InvalidError(exc.message)
+        raise
+
+    print_server_warnings(response.server_warnings)
+    return response.url, response.server_warnings
+
+
+async def _disconnect(
+    client: _Client,
+    app_id: str,
+    reason: "modal_proto.api_pb2.AppDisconnectReason.ValueType",
+    exc_str: str = "",
+) -> None:
+    """Tell the server the client has disconnected for this app. Terminates all running tasks
+    for ephemeral apps."""
+
+    if exc_str:
+        exc_str = exc_str[:1000]  # Truncate to 1000 chars
+
+    logger.debug("Sending app disconnect/stop request")
+    req_disconnect = api_pb2.AppClientDisconnectRequest(app_id=app_id, reason=reason, exception=exc_str)
+    await retry_transient_errors(client.stub.AppClientDisconnect, req_disconnect)
+    logger.debug("App disconnected")
+
+
+async def _status_based_disconnect(client: _Client, app_id: str, exc_info: Optional[BaseException] = None):
+    """Disconnect local session of a running app, sending relevant metadata
+
+    exc_info: Exception if an exception caused the disconnect
+    """
+    if isinstance(exc_info, (KeyboardInterrupt, asyncio.CancelledError)):
+        reason = api_pb2.APP_DISCONNECT_REASON_KEYBOARD_INTERRUPT
+    elif exc_info is not None:
+        if traceback_contains_remote_call(exc_info.__traceback__):
+            reason = api_pb2.APP_DISCONNECT_REASON_REMOTE_EXCEPTION
+        else:
+            reason = api_pb2.APP_DISCONNECT_REASON_LOCAL_EXCEPTION
+    else:
+        reason = api_pb2.APP_DISCONNECT_REASON_ENTRYPOINT_COMPLETED
+    if isinstance(exc_info, _CliUserExecutionError):
+        exc_str = repr(exc_info.__cause__)
+    elif exc_info:
+        exc_str = repr(exc_info)
+    else:
+        exc_str = ""
+
+    await _disconnect(client, app_id, reason, exc_str)
+
+
 @asynccontextmanager
-async def _run_stub(
-    stub: _Stub,
+async def _run_app(
+    app: _App,
+    *,
     client: Optional[_Client] = None,
-    stdout=None,
-    show_progress: bool = True,
     detach: bool = False,
-    output_mgr: Optional[OutputManager] = None,
     environment_name: Optional[str] = None,
-    shell=False,
-    interactive=False,
-) -> AsyncGenerator[_Stub, None]:
+    interactive: bool = False,
+) -> AsyncGenerator[_App, None]:
     """mdmd:hidden"""
     if environment_name is None:
-        environment_name = config.get("environment")
+        environment_name = typing.cast(str, config.get("environment"))
 
     if not is_local():
         raise InvalidError(
             "Can not run an app from within a container."
-            " Are you calling stub.run() directly?"
+            " Are you calling app.run() directly?"
             " Consider using the `modal run` shell command."
         )
-    if stub._local_app:
+    if app._running_app:
         raise InvalidError(
             "App is already running and can't be started again.\n"
-            "You should not use `stub.run` or `run_stub` within a Modal `local_entrypoint`"
+            "You should not use `app.run` or `run_app` within a Modal `local_entrypoint`"
         )
 
-    if stub.description is None:
+    if app.description is None:
         import __main__
 
         if "__file__" in dir(__main__):
-            stub.set_description(os.path.basename(__main__.__file__))
+            app.set_description(os.path.basename(__main__.__file__))
         else:
             # Interactive mode does not have __file__.
             # https://docs.python.org/3/library/__main__.html#import-main
-            stub.set_description(__main__.__name__)
+            app.set_description(__main__.__name__)
 
     if client is None:
         client = await _Client.from_env()
-    if output_mgr is None:
-        output_mgr = OutputManager(stdout, show_progress, "Running app...")
-    if shell:
-        output_mgr._visible_progress = False
+
     app_state = api_pb2.APP_STATE_DETACHED if detach else api_pb2.APP_STATE_EPHEMERAL
-    app = await _LocalApp._init_new(
+    running_app: RunningApp = await _init_local_app_new(
         client,
-        stub.description,
-        environment_name=environment_name,
+        app.description or "",
+        environment_name=environment_name or "",
         app_state=app_state,
         interactive=interactive,
     )
-    async with stub._set_local_app(app), TaskContext(grace=config["logs_timeout"]) as tc:
+
+    logs_timeout = config["logs_timeout"]
+    async with app._set_local_app(client, running_app), TaskContext(grace=logs_timeout) as tc:
         # Start heartbeats loop to keep the client alive
-        tc.infinite_loop(lambda: _heartbeat(client, app.app_id), sleep=HEARTBEAT_INTERVAL)
+        # we don't log heartbeat exceptions in detached mode
+        # as losing the local connection will not affect the running app
+        def heartbeat():
+            return _heartbeat(client, running_app.app_id)
+
+        tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL, log_exception=not detach)
+        logs_loop: Optional[asyncio.Task] = None
+
+        if output_mgr := _get_output_manager():
+            # Defer import so this module is rich-safe
+            # TODO(michael): The get_app_logs_loop function is itself rich-safe aside from accepting an OutputManager
+            # as an argument, so with some refactoring we could avoid the need for this deferred import.
+            from modal._output import get_app_logs_loop
+
+            with output_mgr.make_live(output_mgr.step_progress("Initializing...")):
+                initialized_msg = (
+                    f"Initialized. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+                )
+                output_mgr.print(output_mgr.step_completed(initialized_msg))
+                output_mgr.update_app_page_url(running_app.app_page_url or "ERROR:NO_APP_PAGE")
 
-        with output_mgr.ctx_if_visible(output_mgr.make_live(step_progress("Initializing..."))):
-            initialized_msg = f"Initialized. [grey70]View run at [underline]{app.log_url()}[/underline][/grey70]"
-            output_mgr.print_if_visible(step_completed(initialized_msg))
-            output_mgr.update_app_page_url(app.log_url())
+            # Start logs loop
 
-        # Start logs loop
-        if not shell:
-            logs_loop = tc.create_task(get_app_logs_loop(app.app_id, client, output_mgr))
+            logs_loop = tc.create_task(
+                get_app_logs_loop(client, output_mgr, app_id=running_app.app_id, app_logs_url=running_app.app_logs_url)
+            )
 
-        exc_info: Optional[BaseException] = None
         try:
             # Create all members
-            await app._create_all_objects(stub._indexed_objects, app_state, environment_name, output_mgr=output_mgr)
+            await _create_all_objects(client, running_app, app._functions, app._classes, environment_name)
 
-            # Update all functions client-side to have the output mgr
-            for obj in stub.registered_functions.values():
-                obj._set_output_mgr(output_mgr)
+            # Publish the app
+            await _publish_app(client, running_app, app_state, app._functions, app._classes)
+        except asyncio.CancelledError as e:
+            # this typically happens on sigint/ctrl-C during setup (the KeyboardInterrupt happens in the main thread)
+            if output_mgr := _get_output_manager():
+                output_mgr.print("Aborting app initialization...\n")
 
-            # Update all the classes client-side to propagate output manager to their methods.
-            for obj in stub.registered_classes.values():
-                obj._set_output_mgr(output_mgr)
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
+        except BaseException as e:
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
 
+        try:
             # Show logs from dynamically created images.
             # TODO: better way to do this
-            output_mgr.enable_image_logs()
+            if output_mgr := _get_output_manager():
+                output_mgr.enable_image_logs()
 
             # Yield to context
-            if shell:
-                yield stub
-            else:
+            if output_mgr := _get_output_manager():
                 with output_mgr.show_status_spinner():
-                    yield stub
+                    yield app
+            else:
+                yield app
+            # successful completion!
+            await _status_based_disconnect(client, running_app.app_id, exc_info=None)
         except KeyboardInterrupt as e:
-            exc_info = e
-            # mute cancellation errors on all function handles to prevent exception spam
-            for obj in stub.registered_functions.values():
-                obj._set_mute_cancellation(True)
-
+            # this happens only if sigint comes in during the yield block above
             if detach:
-                output_mgr.print_if_visible(step_completed("Shutting down Modal client."))
-                output_mgr.print_if_visible(
-                    f"""The detached app keeps running. You can track its progress at: [magenta]{app.log_url()}[/magenta]"""
-                )
-                if not shell:
+                if output_mgr := _get_output_manager():
+                    output_mgr.print(output_mgr.step_completed("Shutting down Modal client."))
+                    output_mgr.print(
+                        "The detached app keeps running. You can track its progress at: "
+                        f"[magenta]{running_app.app_page_url}[/magenta]"
+                        ""
+                    )
+                if logs_loop:
                     logs_loop.cancel()
+                await _status_based_disconnect(client, running_app.app_id, e)
             else:
-                output_mgr.print_if_visible(
-                    step_completed(f"App aborted. [grey70]View run at [underline]{app.log_url()}[/underline][/grey70]")
-                )
-                output_mgr.print_if_visible(
-                    "Disconnecting from Modal - This will terminate your Modal app in a few seconds.\n"
-                )
+                if output_mgr := _get_output_manager():
+                    output_mgr.print(
+                        "Disconnecting from Modal - This will terminate your Modal app in a few seconds.\n"
+                    )
+                await _status_based_disconnect(client, running_app.app_id, e)
+                if logs_loop:
+                    try:
+                        await asyncio.wait_for(logs_loop, timeout=logs_timeout)
+                    except asyncio.TimeoutError:
+                        logger.warning("Timed out waiting for final app logs.")
+
+                if output_mgr:
+                    output_mgr.print(
+                        output_mgr.step_completed(
+                            "App aborted. "
+                            f"[grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+                        )
+                    )
+            return
         except BaseException as e:
-            exc_info = e
-            raise e
-        finally:
-            if isinstance(exc_info, KeyboardInterrupt):
-                reason = api_pb2.APP_DISCONNECT_REASON_KEYBOARD_INTERRUPT
-            elif exc_info is not None:
-                reason = api_pb2.APP_DISCONNECT_REASON_LOCAL_EXCEPTION
-            else:
-                reason = api_pb2.APP_DISCONNECT_REASON_ENTRYPOINT_COMPLETED
-
-            if isinstance(exc_info, _CliUserExecutionError):
-                exc_str = repr(exc_info.__cause__)
-            elif exc_info:
-                exc_str = repr(exc_info)
-            else:
-                exc_str = ""
-
-            await app.disconnect(reason, exc_str)
-            stub._uncreate_all_objects()
-
-    output_mgr.print_if_visible(
-        step_completed(f"App completed. [grey70]View run at [underline]{app.log_url()}[/underline][/grey70]")
-    )
+            logger.info("Exception during app run")
+            await _status_based_disconnect(client, running_app.app_id, e)
+            raise
+
+        # wait for logs gracefully, even though the task context would do the same
+        # this allows us to log a more specific warning in case the app doesn't
+        # provide all logs before exit
+        if logs_loop:
+            try:
+                await asyncio.wait_for(logs_loop, timeout=logs_timeout)
+            except asyncio.TimeoutError:
+                logger.warning("Timed out waiting for final app logs.")
+
+    if output_mgr := _get_output_manager():
+        output_mgr.print(
+            output_mgr.step_completed(
+                f"App completed. [grey70]View run at [underline]{running_app.app_page_url}[/underline][/grey70]"
+            )
+        )
 
 
 async def _serve_update(
-    stub,
+    app: _App,
     existing_app_id: str,
     is_ready: Event,
     environment_name: str,
@@ -179,14 +421,20 @@ async def _serve_update(
     # Used by child process to reinitialize a served app
     client = await _Client.from_env()
     try:
-        app = await _LocalApp._init_existing(client, existing_app_id)
+        running_app: RunningApp = await _init_local_app_existing(client, existing_app_id, environment_name)
 
         # Create objects
-        output_mgr = OutputManager(None, True)
-        await app._create_all_objects(
-            stub._indexed_objects, api_pb2.APP_STATE_UNSPECIFIED, environment_name, output_mgr=output_mgr
+        await _create_all_objects(
+            client,
+            running_app,
+            app._functions,
+            app._classes,
+            environment_name,
         )
 
+        # Publish the updated app
+        await _publish_app(client, running_app, api_pb2.APP_STATE_UNSPECIFIED, app._functions, app._classes)
+
         # Communicate to the parent process
         is_ready.set()
     except asyncio.exceptions.CancelledError:
@@ -199,17 +447,18 @@ class DeployResult:
     """Dataclass representing the result of deploying an app."""
 
     app_id: str
+    app_page_url: str
+    app_logs_url: str
+    warnings: list[str]
 
 
-async def _deploy_stub(
-    stub: _Stub,
-    name: str = None,
-    namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
-    client=None,
-    stdout=None,
-    show_progress=True,
+async def _deploy_app(
+    app: _App,
+    name: Optional[str] = None,
+    namespace: Any = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
+    client: Optional[_Client] = None,
     environment_name: Optional[str] = None,
-    public: bool = False,
+    tag: str = "",
 ) -> DeployResult:
     """Deploy an app and export its objects persistently.
 
@@ -220,7 +469,7 @@ async def _deploy_stub(
 
     ```python
     if __name__ == "__main__":
-        deploy_stub(stub)
+        deploy_app(app)
     ```
 
     Deployment has two primary purposes:
@@ -233,59 +482,78 @@ async def _deploy_stub(
       referred to and used by other apps.
     """
     if environment_name is None:
-        environment_name = config.get("environment")
+        environment_name = typing.cast(str, config.get("environment"))
 
-    if name is None:
-        name = stub.name
-    if name is None:
+    name = name or app.name
+    if not name:
         raise InvalidError(
-            "You need to either supply an explicit deployment name to the deploy command, or have a name set on the app.\n"
+            "You need to either supply an explicit deployment name to the deploy command, "
+            "or have a name set on the app.\n"
             "\n"
             "Examples:\n"
-            'stub.deploy("some_name")\n\n'
+            'app.deploy("some_name")\n\n'
             "or\n"
-            'stub = Stub("some-name")'
+            'app = App("some-name")'
         )
+    else:
+        check_object_name(name, "App")
 
-    if not is_valid_app_name(name):
+    if tag and not is_valid_tag(tag):
         raise InvalidError(
-            f"Invalid app name {name}. App names may only contain alphanumeric characters, dashes, periods, and underscores, and must be less than 64 characters in length. "
+            f"Deployment tag {tag!r} is invalid."
+            "\n\nTags may only contain alphanumeric characters, dashes, periods, and underscores, "
+            "and must be 50 characters or less"
         )
 
     if client is None:
         client = await _Client.from_env()
 
-    output_mgr = OutputManager(stdout, show_progress)
+    t0 = time.time()
 
-    app = await _LocalApp._init_from_name(client, name, namespace, environment_name=environment_name)
+    running_app: RunningApp = await _init_local_app_from_name(
+        client, name, namespace, environment_name=environment_name
+    )
 
     async with TaskContext(0) as tc:
         # Start heartbeats loop to keep the client alive
-        tc.infinite_loop(lambda: _heartbeat(client, app.app_id), sleep=HEARTBEAT_INTERVAL)
+        def heartbeat():
+            return _heartbeat(client, running_app.app_id)
 
-        # Don't change the app state - deploy state is set by AppDeploy
-        post_init_state = api_pb2.APP_STATE_UNSPECIFIED
+        tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL)
 
         try:
             # Create all members
-            await app._create_all_objects(
-                stub._indexed_objects, post_init_state, environment_name=environment_name, output_mgr=output_mgr
+            await _create_all_objects(
+                client,
+                running_app,
+                app._functions,
+                app._classes,
+                environment_name=environment_name,
             )
 
-            # Deploy app
-            # TODO(erikbern): not needed if the app already existed
-            url = await app.deploy(name, namespace, public)
+            app_url, warnings = await _publish_app(
+                client, running_app, api_pb2.APP_STATE_DEPLOYED, app._functions, app._classes, name, tag
+            )
         except Exception as e:
             # Note that AppClientDisconnect only stops the app if it's still initializing, and is a no-op otherwise.
-            await app.disconnect(reason=api_pb2.APP_DISCONNECT_REASON_DEPLOYMENT_EXCEPTION)
+            await _disconnect(client, running_app.app_id, reason=api_pb2.APP_DISCONNECT_REASON_DEPLOYMENT_EXCEPTION)
             raise e
 
-    output_mgr.print_if_visible(step_completed("App deployed! 🎉"))
-    output_mgr.print_if_visible(f"\nView Deployment: [magenta]{url}[/magenta]")
-    return DeployResult(app_id=app.app_id)
+    if output_mgr := _get_output_manager():
+        t = time.time() - t0
+        output_mgr.print(output_mgr.step_completed(f"App deployed in {t:.3f}s! 🎉"))
+        output_mgr.print(f"\nView Deployment: [magenta]{app_url}[/magenta]")
+    return DeployResult(
+        app_id=running_app.app_id,
+        app_page_url=running_app.app_page_url,
+        app_logs_url=running_app.app_logs_url,  # type: ignore
+        warnings=[warning.message for warning in warnings],
+    )
 
 
-async def _interactive_shell(_stub: _Stub, cmd: List[str], environment_name: str = "", **kwargs):
+async def _interactive_shell(
+    _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
+) -> None:
     """Run an interactive shell (like `bash`) within the image for this app.
 
     This is useful for online debugging and interactive exploration of the
@@ -297,40 +565,75 @@ async def _interactive_shell(_stub: _Stub, cmd: List[str], environment_name: str
     ```python
     import modal
 
-    stub = modal.Stub(image=modal.Image.debian_slim().apt_install("vim"))
+    app = modal.App(image=modal.Image.debian_slim().apt_install("vim"))
     ```
 
     You can now run this using
 
-    ```bash
+    ```
     modal shell script.py --cmd /bin/bash
     ```
 
-    **kwargs will be passed into spawn_sandbox().
+    When calling programmatically, `kwargs` are passed to `Sandbox.create()`.
     """
+
     client = await _Client.from_env()
-    async with _run_stub(_stub, client, environment_name=environment_name, shell=True):
-        console = Console()
-        loading_status = console.status("Starting container...")
-        loading_status.start()
-
-        sandbox_cmds = cmd if len(cmd) > 0 else ["/bin/bash"]
-        sb = await _stub.spawn_sandbox(*sandbox_cmds, pty_info=get_pty_info(shell=True), **kwargs)
-        for _ in range(40):
-            await asyncio.sleep(0.5)
-            resp = await sb._client.stub.SandboxGetTaskId(api_pb2.SandboxGetTaskIdRequest(sandbox_id=sb._object_id))
-            if resp.task_id != "":
-                break
-            # else: sandbox hasn't been assigned a task yet
-        else:
-            loading_status.stop()
-            raise InteractiveTimeoutError("Timed out while waiting for sandbox to start")
+    async with _run_app(_app, client=client, environment_name=environment_name):
+        sandbox_cmds = cmds if len(cmds) > 0 else ["/bin/bash"]
+        sandbox_env = {
+            "MODAL_TOKEN_ID": config["token_id"],
+            "MODAL_TOKEN_SECRET": config["token_secret"],
+            "MODAL_ENVIRONMENT": _get_environment_name(),
+        }
+        secrets = kwargs.pop("secrets", []) + [_Secret.from_dict(sandbox_env)]
+        with enable_output():  # show any image build logs
+            sandbox = await _Sandbox.create(
+                "sleep",
+                "100000",
+                app=_app,
+                secrets=secrets,
+                **kwargs,
+            )
+
+        try:
+            if pty:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, pty_info=get_pty_info(shell=True) if pty else None
+                )
+                await container_process.attach()
+            else:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+                )
+                await container_process.wait()
+        except InteractiveTimeoutError:
+            # Check on status of Sandbox. It may have crashed, causing connection failure.
+            req = api_pb2.SandboxWaitRequest(sandbox_id=sandbox._object_id, timeout=0)
+            resp = await retry_transient_errors(sandbox._client.stub.SandboxWait, req)
+            if resp.result.exception:
+                raise RemoteError(resp.result.exception)
+            else:
+                raise
+
 
-        loading_status.stop()
-        await connect_to_sandbox(sb)
+def _run_stub(*args: Any, **kwargs: Any):
+    """mdmd:hidden
+    `run_stub` has been renamed to `run_app` and is deprecated. Please update your code.
+    """
+    deprecation_error(
+        (2024, 5, 1), "`run_stub` has been renamed to `run_app` and is deprecated. Please update your code."
+    )
 
 
-run_stub = synchronize_api(_run_stub)
+def _deploy_stub(*args: Any, **kwargs: Any):
+    """mdmd:hidden"""
+    message = "`deploy_stub` has been renamed to `deploy_app`. Please update your code."
+    deprecation_error((2024, 5, 1), message)
+
+
+run_app = synchronize_api(_run_app)
 serve_update = synchronize_api(_serve_update)
-deploy_stub = synchronize_api(_deploy_stub)
+deploy_app = synchronize_api(_deploy_app)
 interactive_shell = synchronize_api(_interactive_shell)
+run_stub = synchronize_api(_run_stub)
+deploy_stub = synchronize_api(_deploy_stub)