modal 0.72.5__py3-none-any.whl → 0.72.48__py3-none-any.whl

modal/app.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal._object
 import modal._utils.function_utils
 import modal.client
 import modal.cloud_bucket_mount
@@ -66,10 +67,12 @@ class _FunctionDecoratorType:
     ) -> modal.functions.Function[P, ReturnType, OriginalReturnType]: ...
     @typing.overload
     def __call__(
-        self, func: typing.Callable[P, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]
+        self, func: collections.abc.Callable[P, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]
     ) -> modal.functions.Function[P, ReturnType, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]: ...
     @typing.overload
-    def __call__(self, func: typing.Callable[P, ReturnType]) -> modal.functions.Function[P, ReturnType, ReturnType]: ...
+    def __call__(
+        self, func: collections.abc.Callable[P, ReturnType]
+    ) -> modal.functions.Function[P, ReturnType, ReturnType]: ...
 
 class _App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[_App]]]
@@ -114,10 +117,6 @@ class _App:
     ) -> _App: ...
     def set_description(self, description: str): ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
-    def __getitem__(self, tag: str): ...
-    def __setitem__(self, tag: str, obj: modal.object._Object): ...
-    def __getattr__(self, tag: str): ...
-    def __setattr__(self, tag: str, obj: modal.object._Object): ...
     @property
     def image(self) -> modal.image._Image: ...
     @image.setter
@@ -132,6 +131,7 @@ class _App:
         show_progress: typing.Optional[bool] = None,
         detach: bool = False,
         interactive: bool = False,
+        environment_name: typing.Optional[str] = None,
     ) -> typing.AsyncContextManager[_App]: ...
     def _get_default_image(self): ...
     def _get_watch_mounts(self): ...
@@ -141,16 +141,16 @@ class _App:
     @property
     def registered_functions(self) -> dict[str, modal.functions._Function]: ...
     @property
-    def registered_classes(self) -> dict[str, modal.functions._Function]: ...
+    def registered_classes(self) -> dict[str, modal.cls._Cls]: ...
     @property
     def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]: ...
     @property
-    def indexed_objects(self) -> dict[str, modal.object._Object]: ...
+    def indexed_objects(self) -> dict[str, modal._object._Object]: ...
     @property
     def registered_web_endpoints(self) -> list[str]: ...
     def local_entrypoint(
         self, _warn_parentheses_missing: typing.Any = None, *, name: typing.Optional[str] = None
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], _LocalEntrypoint]: ...
+    ) -> collections.abc.Callable[[collections.abc.Callable[..., typing.Any]], _LocalEntrypoint]: ...
     def function(
         self,
         _warn_parentheses_missing: typing.Any = None,
@@ -236,7 +236,7 @@ class _App:
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> typing.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
     async def spawn_sandbox(
         self,
         *entrypoint_args: str,
@@ -270,6 +270,8 @@ class _App:
     @classmethod
     def _reset_container_app(cls): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[App]]]
     _container_app: typing.ClassVar[typing.Optional[App]]
@@ -325,17 +327,13 @@ class App:
 
     def set_description(self, description: str): ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
-    def __getitem__(self, tag: str): ...
-    def __setitem__(self, tag: str, obj: modal.object.Object): ...
-    def __getattr__(self, tag: str): ...
-    def __setattr__(self, tag: str, obj: modal.object.Object): ...
     @property
     def image(self) -> modal.image.Image: ...
     @image.setter
     def image(self, value): ...
     def _uncreate_all_objects(self): ...
 
-    class ___set_local_app_spec(typing_extensions.Protocol):
+    class ___set_local_app_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, client: modal.client.Client, running_app: modal.running_app.RunningApp
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
@@ -343,15 +341,16 @@ class App:
             self, client: modal.client.Client, running_app: modal.running_app.RunningApp
         ) -> typing.AsyncContextManager[None]: ...
 
-    _set_local_app: ___set_local_app_spec
+    _set_local_app: ___set_local_app_spec[typing_extensions.Self]
 
-    class __run_spec(typing_extensions.Protocol):
+    class __run_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             client: typing.Optional[modal.client.Client] = None,
             show_progress: typing.Optional[bool] = None,
             detach: bool = False,
             interactive: bool = False,
+            environment_name: typing.Optional[str] = None,
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[App]: ...
         def aio(
             self,
@@ -359,9 +358,10 @@ class App:
             show_progress: typing.Optional[bool] = None,
             detach: bool = False,
             interactive: bool = False,
+            environment_name: typing.Optional[str] = None,
         ) -> typing.AsyncContextManager[App]: ...
 
-    run: __run_spec
+    run: __run_spec[typing_extensions.Self]
 
     def _get_default_image(self): ...
     def _get_watch_mounts(self): ...
@@ -371,7 +371,7 @@ class App:
     @property
     def registered_functions(self) -> dict[str, modal.functions.Function]: ...
     @property
-    def registered_classes(self) -> dict[str, modal.functions.Function]: ...
+    def registered_classes(self) -> dict[str, modal.cls.Cls]: ...
     @property
     def registered_entrypoints(self) -> dict[str, LocalEntrypoint]: ...
     @property
@@ -380,7 +380,7 @@ class App:
     def registered_web_endpoints(self) -> list[str]: ...
     def local_entrypoint(
         self, _warn_parentheses_missing: typing.Any = None, *, name: typing.Optional[str] = None
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], LocalEntrypoint]: ...
+    ) -> collections.abc.Callable[[collections.abc.Callable[..., typing.Any]], LocalEntrypoint]: ...
     def function(
         self,
         _warn_parentheses_missing: typing.Any = None,
@@ -466,9 +466,9 @@ class App:
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> typing.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
 
-    class __spawn_sandbox_spec(typing_extensions.Protocol):
+    class __spawn_sandbox_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             *entrypoint_args: str,
@@ -518,11 +518,11 @@ class App:
             _experimental_scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
         ) -> None: ...
 
-    spawn_sandbox: __spawn_sandbox_spec
+    spawn_sandbox: __spawn_sandbox_spec[typing_extensions.Self]
 
     def include(self, /, other_app: App): ...
 
-    class ___logs_spec(typing_extensions.Protocol):
+    class ___logs_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, client: typing.Optional[modal.client.Client] = None
         ) -> typing.Generator[str, None, None]: ...
@@ -530,7 +530,7 @@ class App:
             self, client: typing.Optional[modal.client.Client] = None
         ) -> collections.abc.AsyncGenerator[str, None]: ...
 
-    _logs: ___logs_spec
+    _logs: ___logs_spec[typing_extensions.Self]
 
     @classmethod
     def _get_container_app(cls) -> typing.Optional[App]: ...

modal/cli/app.py

@@ -9,11 +9,11 @@ from rich.table import Column
 from rich.text import Text
 from typer import Argument
 
+from modal._object import _get_environment_name
 from modal._utils.async_utils import synchronizer
 from modal._utils.deprecation import deprecation_warning
 from modal.client import _Client
 from modal.environments import ensure_env
-from modal.object import _get_environment_name
 from modal_proto import api_pb2
 
 from .utils import ENV_OPTION, display_table, get_app_id_from_name, stream_app_logs, timestamp_to_local
@@ -26,9 +26,10 @@ app_cli = typer.Typer(name="app", help="Manage deployed and running apps.", no_a
 APP_STATE_TO_MESSAGE = {
     api_pb2.APP_STATE_DEPLOYED: Text("deployed", style="green"),
     api_pb2.APP_STATE_DETACHED: Text("ephemeral (detached)", style="green"),
+    api_pb2.APP_STATE_DETACHED_DISCONNECTED: Text("ephemeral (detached)", style="green"),
     api_pb2.APP_STATE_DISABLED: Text("disabled", style="dim"),
     api_pb2.APP_STATE_EPHEMERAL: Text("ephemeral", style="green"),
-    api_pb2.APP_STATE_INITIALIZING: Text("initializing...", style="green"),
+    api_pb2.APP_STATE_INITIALIZING: Text("initializing...", style="yellow"),
     api_pb2.APP_STATE_STOPPED: Text("stopped", style="blue"),
     api_pb2.APP_STATE_STOPPING: Text("stopping...", style="blue"),
 }

modal/cli/container.py

@@ -4,6 +4,7 @@ from typing import Optional, Union
 import typer
 from rich.text import Text
 
+from modal._object import _get_environment_name
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
@@ -12,7 +13,6 @@ from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess
 from modal.environments import ensure_env
-from modal.object import _get_environment_name
 from modal.stream_type import StreamType
 from modal_proto import api_pb2
 

modal/cli/import_refs.py

@@ -9,16 +9,21 @@ These functions are only called by the Modal CLI, not in tasks.
 
 import dataclasses
 import importlib
+import importlib.util
 import inspect
 import sys
+import types
+from collections import defaultdict
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union, cast
 
 import click
 from rich.console import Console
 from rich.markdown import Markdown
 
 from modal.app import App, LocalEntrypoint
+from modal.cls import Cls
 from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 
@@ -26,7 +31,13 @@ from modal.functions import Function
 @dataclasses.dataclass
 class ImportRef:
     file_or_module: str
-    object_path: Optional[str]
+
+    # object_path is a .-delimited path to the object to execute, or a parent from which to infer the object
+    # e.g.
+    # function or local_entrypoint in module scope
+    # app in module scope [+ method name]
+    # app [+ function/entrypoint on that app]
+    object_path: str
 
 
 def parse_import_ref(object_ref: str) -> ImportRef:
@@ -35,7 +46,7 @@ def parse_import_ref(object_ref: str) -> ImportRef:
     elif object_ref.find(":") > 1:
         raise InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
     else:
-        file_or_module, object_path = object_ref, None
+        file_or_module, object_path = object_ref, ""
 
     return ImportRef(file_or_module, object_path)
 
@@ -62,11 +73,14 @@ def import_file_or_module(file_or_module: str):
         sys.path.insert(0, str(full_path.parent))
 
         module_name = inspect.getmodulename(file_or_module)
+        assert module_name is not None
         # Import the module - see https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
         spec = importlib.util.spec_from_file_location(module_name, file_or_module)
+        assert spec is not None
         module = importlib.util.module_from_spec(spec)
         sys.modules[module_name] = module
         try:
+            assert spec.loader
             spec.loader.exec_module(module)
         except Exception as exc:
             raise _CliUserExecutionError(str(full_path)) from exc
@@ -79,112 +93,149 @@ def import_file_or_module(file_or_module: str):
     return module
 
 
-def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
-    # Try to evaluate a `.`-delimited object path in a Modal context
-    # With the caveat that some object names can actually have `.` in their name (lifecycled methods' tags)
+@dataclass(frozen=True)
+class MethodReference:
+    """This helps with deferring method reference until after the class gets instantiated by the CLI"""
 
-    # Note: this is eager, so no backtracking is performed in case an
-    # earlier match fails at some later point in the path expansion
-    prefix = ""
-    for segment in obj_path.split("."):
-        attr = prefix + segment
-        try:
-            if isinstance(obj, App):
-                if attr in obj.registered_entrypoints:
-                    # local entrypoints are not on stub blueprint
-                    obj = obj.registered_entrypoints[attr]
-                    continue
-            obj = getattr(obj, attr)
-
-        except Exception:
-            prefix = f"{prefix}{segment}."
-        else:
-            prefix = ""
+    cls: Cls
+    method_name: str
 
-    if prefix:
-        return None
 
-    return obj
+Runnable = Union[Function, MethodReference, LocalEntrypoint]
 
 
-def _infer_function_or_help(
-    app: App, module, accept_local_entrypoint: bool, accept_webhook: bool
-) -> Union[Function, LocalEntrypoint]:
-    function_choices = set(app.registered_functions)
-    if not accept_webhook:
-        function_choices -= set(app.registered_web_endpoints)
-    if accept_local_entrypoint:
-        function_choices |= set(app.registered_entrypoints.keys())
-
-    sorted_function_choices = sorted(function_choices)
-    registered_functions_str = "\n".join(sorted_function_choices)
-    filtered_local_entrypoints = [
-        name
-        for name, entrypoint in app.registered_entrypoints.items()
-        if entrypoint.info.module_name == module.__name__
-    ]
-
-    if accept_local_entrypoint and len(filtered_local_entrypoints) == 1:
-        # If there is just a single local entrypoint in the target module, use
-        # that regardless of other functions.
-        function_name = list(filtered_local_entrypoints)[0]
-    elif accept_local_entrypoint and len(app.registered_entrypoints) == 1:
-        # Otherwise, if there is just a single local entrypoint in the stub as a whole,
-        # use that one.
-        function_name = list(app.registered_entrypoints.keys())[0]
-    elif len(function_choices) == 1:
-        function_name = sorted_function_choices[0]
-    elif len(function_choices) == 0:
-        if app.registered_web_endpoints:
-            err_msg = "Modal app has only web endpoints. Use `modal serve` instead of `modal run`."
-        else:
-            err_msg = "Modal app has no registered functions. Nothing to run."
-        raise click.UsageError(err_msg)
-    else:
-        help_text = f"""You need to specify a Modal function or local entrypoint to run, e.g.
+@dataclass(frozen=True)
+class CLICommand:
+    names: list[str]
+    runnable: Runnable
+    is_web_endpoint: bool
 
-modal run app.py::my_function [...args]
 
-Registered functions and local entrypoints on the selected app are:
-{registered_functions_str}
-"""
-        raise click.UsageError(help_text)
+def list_cli_commands(
+    module: types.ModuleType,
+) -> list[CLICommand]:
+    """
+    Extracts all runnables found either directly in the input module, or in any of the Apps listed in that module
 
-    if function_name in app.registered_entrypoints:
-        # entrypoint is in entrypoint registry, for now
-        return app.registered_entrypoints[function_name]
+    Runnables includes all Functions, (class) Methods and Local Entrypoints, including web endpoints.
 
-    function = app.registered_functions[function_name]
-    assert isinstance(function, Function)
-    return function
+    The returned list consists of tuples:
+    ([name1, name2...], Runnable)
 
+    Where the first name is always the module level name if such a name exists
+    """
+    apps = cast(list[tuple[str, App]], inspect.getmembers(module, lambda x: isinstance(x, App)))
 
-def _show_no_auto_detectable_app(app_ref: ImportRef) -> None:
-    object_path = app_ref.object_path
-    import_path = app_ref.file_or_module
-    error_console = Console(stderr=True)
-    error_console.print(f"[bold red]Could not find Modal app '{object_path}' in {import_path}.[/bold red]")
-
-    if object_path is None:
-        guidance_msg = (
-            f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). "
-            "If your `modal.App` is named differently, "
-            "you must specify it in the app ref argument. "
-            f"For example an App variable `app_2 = modal.App()` in `{import_path}` would "
-            f"be specified as `{import_path}::app_2`."
-        )
-        md = Markdown(guidance_msg)
-        error_console.print(md)
+    all_runnables: dict[Runnable, list[str]] = defaultdict(list)
+    for app_name, app in apps:
+        for name, local_entrypoint in app.registered_entrypoints.items():
+            all_runnables[local_entrypoint].append(f"{app_name}.{name}")
+        for name, function in app.registered_functions.items():
+            if name.endswith(".*"):
+                continue
+            all_runnables[function].append(f"{app_name}.{name}")
+        for cls_name, cls in app.registered_classes.items():
+            for method_name in cls._get_method_names():
+                method_ref = MethodReference(cls, method_name)
+                all_runnables[method_ref].append(f"{app_name}.{cls_name}.{method_name}")
+
+    # If any class or function is exported as a module level object, use that
+    # as the preferred name by putting it first in the list
+    module_level_entities = cast(
+        list[tuple[str, Runnable]],
+        inspect.getmembers(module, lambda x: isinstance(x, (Function, Cls, LocalEntrypoint))),
+    )
+    for name, entity in module_level_entities:
+        if isinstance(entity, Cls):
+            for method_name in entity._get_method_names():
+                method_ref = MethodReference(entity, method_name)
+                all_runnables.setdefault(method_ref, []).insert(0, f"{name}.{method_name}")
+        else:
+            all_runnables.setdefault(entity, []).insert(0, name)
+
+    def _is_web_endpoint(runnable: Runnable) -> bool:
+        if isinstance(runnable, Function) and runnable._is_web_endpoint():
+            return True
+        elif isinstance(runnable, MethodReference):
+            # this is a bit yucky but can hopefully get cleaned up with Cls cleanup:
+            method_partial = runnable.cls._get_partial_functions()[runnable.method_name]
+            if method_partial._is_web_endpoint():
+                return True
+
+        return False
+
+    return [CLICommand(names, runnable, _is_web_endpoint(runnable)) for runnable, names in all_runnables.items()]
+
+
+def filter_cli_commands(
+    cli_commands: list[CLICommand],
+    name_prefix: str,
+    accept_local_entrypoints: bool = True,
+    accept_web_endpoints: bool = True,
+) -> list[CLICommand]:
+    """Filters by name and type of runnable
+
+    Returns generator of (matching names list, CLICommand)
+    """
+
+    def _is_accepted_type(cli_command: CLICommand) -> bool:
+        if not accept_local_entrypoints and isinstance(cli_command.runnable, LocalEntrypoint):
+            return False
+        if not accept_web_endpoints and cli_command.is_web_endpoint:
+            return False
+        return True
+
+    res = []
+    for cli_command in cli_commands:
+        if not _is_accepted_type(cli_command):
+            continue
+
+        if name_prefix in cli_command.names:
+            # exact name match
+            res.append(cli_command)
+            continue
+
+        if not name_prefix:
+            # no name specified, return all reachable runnables
+            res.append(cli_command)
+            continue
+
+        # partial matches e.g. app or class name - should we even allow this?
+        prefix_matches = [x for x in cli_command.names if x.startswith(f"{name_prefix}.")]
+        if prefix_matches:
+            res.append(cli_command)
+    return res
 
 
 def import_app(app_ref: str) -> App:
     import_ref = parse_import_ref(app_ref)
 
+    # TODO: default could be to just pick up any app regardless if it's called DEFAULT_APP_NAME
+    #  as long as there is a single app in the module?
+    import_path = import_ref.file_or_module
+    object_path = import_ref.object_path or DEFAULT_APP_NAME
+
     module = import_file_or_module(import_ref.file_or_module)
-    app = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
+
+    if "." in object_path:
+        raise click.UsageError(f"{object_path} is not a Modal App")
+
+    app = getattr(module, object_path)
 
     if app is None:
-        _show_no_auto_detectable_app(import_ref)
+        error_console = Console(stderr=True)
+        error_console.print(f"[bold red]Could not find Modal app '{object_path}' in {import_path}.[/bold red]")
+
+        if object_path is None:
+            guidance_msg = Markdown(
+                f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). "
+                "If your `modal.App` is assigned to a different variable name, "
+                "you must specify it in the app ref argument. "
+                f"For example an App variable `app_2 = modal.App()` in `{import_path}` would "
+                f"be specified as `{import_path}::app_2`."
+            )
+            error_console.print(guidance_msg)
+
         sys.exit(1)
 
     if not isinstance(app, App):
@@ -223,30 +274,51 @@ You would run foo as [bold green]{base_cmd} app.py::foo[/bold green]"""
     error_console.print(guidance_msg)
 
 
-def import_function(
-    func_ref: str, base_cmd: str, accept_local_entrypoint=True, accept_webhook=False
-) -> Union[Function, LocalEntrypoint]:
-    import_ref = parse_import_ref(func_ref)
+def _get_runnable_app(runnable: Runnable) -> App:
+    if isinstance(runnable, Function):
+        return runnable.app
+    elif isinstance(runnable, MethodReference):
+        return runnable.cls._get_app()
+    else:
+        assert isinstance(runnable, LocalEntrypoint)
+        return runnable.app
+
+
+def import_and_filter(
+    import_ref: ImportRef, accept_local_entrypoint=True, accept_webhook=False
+) -> tuple[Optional[Runnable], list[CLICommand]]:
+    """Takes a function ref string and returns a single determined "runnable" to use, and a list of all available
+    runnables.
+
+    The function ref can leave out partial information (apart from the file name/module)
+    as long as the runnable is uniquely identifiable by the provided information.
 
+    When there are multiple runnables within the provided ref, the following rules should
+    be followed:
+
+    1. if there is a single local_entrypoint, that one is used
+    2. if there is a single {function, class} that one is used
+    3. if there is a single method (within a class) that one is used
+    """
+    # all commands:
     module = import_file_or_module(import_ref.file_or_module)
-    app_or_function = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
+    cli_commands = list_cli_commands(module)
 
-    if app_or_function is None:
-        _show_function_ref_help(import_ref, base_cmd)
-        sys.exit(1)
+    # all commands that satisfy local entrypoint/accept webhook limitations AND object path prefix
+    filtered_commands = filter_cli_commands(
+        cli_commands, import_ref.object_path, accept_local_entrypoint, accept_webhook
+    )
+    all_usable_commands = filter_cli_commands(cli_commands, "", accept_local_entrypoint, accept_webhook)
 
-    if isinstance(app_or_function, App):
-        # infer function or display help for how to select one
-        app = app_or_function
-        function_handle = _infer_function_or_help(app, module, accept_local_entrypoint, accept_webhook)
-        return function_handle
-    elif isinstance(app_or_function, Function):
-        return app_or_function
-    elif isinstance(app_or_function, LocalEntrypoint):
-        if not accept_local_entrypoint:
-            raise click.UsageError(
-                f"{func_ref} is not a Modal Function (a Modal local_entrypoint can't be used in this context)"
-            )
-        return app_or_function
-    else:
-        raise click.UsageError(f"{app_or_function} is not a Modal entity (should be an App or Function)")
+    if len(filtered_commands) == 1:
+        cli_command = filtered_commands[0]
+        return cli_command.runnable, all_usable_commands
+
+    # we are here if there is more than one matching function
+    if accept_local_entrypoint:
+        local_entrypoint_cmds = [cmd for cmd in filtered_commands if isinstance(cmd.runnable, LocalEntrypoint)]
+        if len(local_entrypoint_cmds) == 1:
+            # if there is a single local entrypoint - use that
+            return local_entrypoint_cmds[0].runnable, all_usable_commands
+
+    return None, all_usable_commands

modal/cli/launch.py

@@ -8,17 +8,17 @@ from typing import Any, Optional
 
 from typer import Typer
 
-from ..app import App
+from ..app import LocalEntrypoint
 from ..exception import _CliUserExecutionError
 from ..output import enable_output
 from ..runner import run_app
-from .import_refs import import_function
+from .import_refs import _get_runnable_app, import_and_filter, parse_import_ref
 
 launch_cli = Typer(
     name="launch",
     no_args_is_help=True,
     help="""
-    [Preview] Open a serverless app instance on Modal.
+    Open a serverless app instance on Modal.
 
     This command is in preview and may change in the future.
     """,
@@ -29,8 +29,13 @@ def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]
     os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
-    entrypoint = import_function(program_path, "modal launch")
-    app: App = entrypoint.app
+    entrypoint, _ = import_and_filter(
+        parse_import_ref(program_path), accept_local_entrypoint=True, accept_webhook=False
+    )
+    if not isinstance(entrypoint, LocalEntrypoint):
+        raise ValueError(f"{program_path} has no single local_entrypoint")
+
+    app = _get_runnable_app(entrypoint)
     app.set_description(f"modal launch {name}")
 
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.

modal/cli/programs/run_jupyter.py

@@ -65,6 +65,8 @@ def run_jupyter(q: Queue):
     with forward(8888) as tunnel:
         url = tunnel.url + "/?token=" + token
         threading.Thread(target=wait_for_port, args=(url, q)).start()
+        print("\nJupyter on Modal, opening in browser...")
+        print(f"   -> {url}\n")
         subprocess.run(
             [
                 "jupyter",
@@ -89,7 +91,5 @@ def main():
         run_jupyter.spawn(q)
         url = q.get()
         time.sleep(1)  # Give Jupyter a chance to start up
-        print("\nJupyter on Modal, opening in browser...")
-        print(f"   -> {url}\n")
         webbrowser.open(url)
         assert q.get() == "done"

modal/cli/programs/vscode.py

@@ -89,6 +89,9 @@ def run_vscode(q: Queue):
     token = secrets.token_urlsafe(13)
     with forward(8080) as tunnel:
         url = tunnel.url
+        print("\nVS Code on Modal, opening in browser...")
+        print(f"   -> {url}")
+        print(f"   -> password: {token}\n")
         threading.Thread(target=wait_for_port, args=((url, token), q)).start()
         subprocess.run(
             ["/code-server.sh", "--bind-addr", "0.0.0.0:8080", "."],
@@ -103,8 +106,5 @@ def main():
         run_vscode.spawn(q)
         url, token = q.get()
         time.sleep(1)  # Give VS Code a chance to start up
-        print("\nVS Code on Modal, opening in browser...")
-        print(f"   -> {url}")
-        print(f"   -> password: {token}\n")
         webbrowser.open(url)
         assert q.get() == "done"