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

modal/cli/run.py

@@ -2,27 +2,32 @@
 import asyncio
 import functools
 import inspect
+import platform
 import re
+import shlex
 import sys
 import time
+import typing
 from functools import partial
-from typing import Any, Callable, Dict, Optional, get_type_hints
+from typing import Any, Callable, Optional, get_type_hints
 
 import click
 import typer
-from rich.console import Console
 from typing_extensions import TypedDict
 
+from .. import Cls
 from ..app import App, LocalEntrypoint
 from ..config import config
 from ..environments import ensure_env
 from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
 from ..functions import Function, _FunctionSpec
 from ..image import Image
+from ..output import enable_output
 from ..runner import deploy_app, interactive_shell, run_app
 from ..serving import serve_app
+from ..volume import Volume
 from .import_refs import import_app, import_function
-from .utils import ENV_OPTION, ENV_OPTION_HELP
+from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
 
 
 class ParameterMetadata(TypedDict):
@@ -53,7 +58,7 @@ class NoParserAvailable(InvalidError):
     pass
 
 
-def _get_signature(f: Callable, is_method: bool = False) -> Dict[str, ParameterMetadata]:
+def _get_signature(f: Callable[..., Any], is_method: bool = False) -> dict[str, ParameterMetadata]:
     try:
         type_hints = get_type_hints(f)
     except Exception as exc:
@@ -64,7 +69,7 @@ def _get_signature(f: Callable, is_method: bool = False) -> Dict[str, ParameterM
     if is_method:
         self = None  # Dummy, doesn't matter
         f = functools.partial(f, self)
-    signature: Dict[str, ParameterMetadata] = {}
+    signature: dict[str, ParameterMetadata] = {}
     for param in inspect.signature(f).parameters.values():
         signature[param.name] = {
             "name": param.name,
@@ -91,7 +96,7 @@ def _get_param_type_as_str(annot: Any) -> str:
     return annot_str
 
 
-def _add_click_options(func, signature: Dict[str, ParameterMetadata]):
+def _add_click_options(func, signature: dict[str, ParameterMetadata]):
     """Adds @click.option based on function signature
 
     Kind of like typer, but using options instead of positional arguments
@@ -128,17 +133,46 @@ def _get_clean_app_description(func_ref: str) -> str:
         return " ".join(sys.argv)
 
 
+def _write_local_result(result_path: str, res: Any):
+    if isinstance(res, str):
+        mode = "wt"
+    elif isinstance(res, bytes):
+        mode = "wb"
+    else:
+        res_type = type(res).__name__
+        raise InvalidError(f"Function must return str or bytes when using `--write-result`; got {res_type}.")
+    with open(result_path, mode) as fid:
+        fid.write(res)
+
+
 def _get_click_command_for_function(app: App, function_tag):
-    function = app.indexed_objects[function_tag]
+    function = app.registered_functions.get(function_tag)
+    if not function or (isinstance(function, Function) and function.info.user_cls is not None):
+        # This is either a function_tag for a class method function (e.g MyClass.foo) or a function tag for a
+        # class service function (MyClass.*)
+        class_name, method_name = function_tag.rsplit(".", 1)
+        if not function:
+            function = app.registered_functions.get(f"{class_name}.*")
     assert isinstance(function, Function)
-
+    function = typing.cast(Function, function)
     if function.is_generator:
         raise InvalidError("`modal run` is not supported for generator functions")
 
-    signature: Dict[str, ParameterMetadata]
-    if function.info.cls is not None:
-        cls_signature = _get_signature(function.info.cls)
-        fun_signature = _get_signature(function.info.raw_f, is_method=True)
+    signature: dict[str, ParameterMetadata]
+    cls: Optional[Cls] = None
+    if function.info.user_cls is not None:
+        cls = typing.cast(Cls, app.registered_classes[class_name])
+        cls_signature = _get_signature(function.info.user_cls)
+        if method_name == "*":
+            method_names = list(cls._get_partial_functions().keys())
+            if len(method_names) == 1:
+                method_name = method_names[0]
+            else:
+                class_name = function.info.user_cls.__name__
+                raise click.UsageError(
+                    f"Please specify a specific method of {class_name} to run, e.g. `modal run foo.py::MyClass.bar`"  # noqa: E501
+                )
+        fun_signature = _get_signature(getattr(cls, method_name).info.raw_f, is_method=True)
         signature = dict(**cls_signature, **fun_signature)  # Pool all arguments
         # TODO(erikbern): assert there's no overlap?
     else:
@@ -146,22 +180,28 @@ def _get_click_command_for_function(app: App, function_tag):
 
     @click.pass_context
     def f(ctx, **kwargs):
-        with run_app(
-            app,
-            detach=ctx.obj["detach"],
-            show_progress=ctx.obj["show_progress"],
-            environment_name=ctx.obj["env"],
-            interactive=ctx.obj["interactive"],
-        ):
-            if function.info.cls is None:
-                function.remote(**kwargs)
-            else:
-                # unpool class and method arguments
-                # TODO(erikbern): this code is a bit hacky
-                cls_kwargs = {k: kwargs[k] for k in cls_signature}
-                fun_kwargs = {k: kwargs[k] for k in fun_signature}
-                method = function.from_parametrized(None, False, None, tuple(), cls_kwargs)
-                method.remote(**fun_kwargs)
+        show_progress: bool = ctx.obj["show_progress"]
+        with enable_output(show_progress):
+            with run_app(
+                app,
+                detach=ctx.obj["detach"],
+                environment_name=ctx.obj["env"],
+                interactive=ctx.obj["interactive"],
+            ):
+                if cls is None:
+                    res = function.remote(**kwargs)
+                else:
+                    # unpool class and method arguments
+                    # TODO(erikbern): this code is a bit hacky
+                    cls_kwargs = {k: kwargs[k] for k in cls_signature}
+                    fun_kwargs = {k: kwargs[k] for k in fun_signature}
+
+                    instance = cls(**cls_kwargs)
+                    method: Function = getattr(instance, method_name)
+                    res = method.remote(**fun_kwargs)
+
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
 
     with_click_options = _add_click_options(f, signature)
     return click.command(with_click_options)
@@ -175,23 +215,28 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
     def f(ctx, *args, **kwargs):
         if ctx.obj["detach"]:
             print(
-                "Note that running a local entrypoint in detached mode only keeps the last triggered Modal function alive after the parent process has been killed or disconnected."
+                "Note that running a local entrypoint in detached mode only keeps the last "
+                "triggered Modal function alive after the parent process has been killed or disconnected."
             )
 
-        with run_app(
-            app,
-            detach=ctx.obj["detach"],
-            show_progress=ctx.obj["show_progress"],
-            environment_name=ctx.obj["env"],
-            interactive=ctx.obj["interactive"],
-        ):
-            try:
-                if isasync:
-                    asyncio.run(func(*args, **kwargs))
-                else:
-                    func(*args, **kwargs)
-            except Exception as exc:
-                raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
+        show_progress: bool = ctx.obj["show_progress"]
+        with enable_output(show_progress):
+            with run_app(
+                app,
+                detach=ctx.obj["detach"],
+                environment_name=ctx.obj["env"],
+                interactive=ctx.obj["interactive"],
+            ):
+                try:
+                    if isasync:
+                        res = asyncio.run(func(*args, **kwargs))
+                    else:
+                        res = func(*args, **kwargs)
+                except Exception as exc:
+                    raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
+
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
 
     with_click_options = _add_click_options(f, _get_signature(func))
     return click.command(with_click_options)
@@ -221,12 +266,13 @@ class RunGroup(click.Group):
     cls=RunGroup,
     subcommand_metavar="FUNC_REF",
 )
+@click.option("-w", "--write-result", help="Write return value (which must be str or bytes) to this local path.")
 @click.option("-q", "--quiet", is_flag=True, help="Don't show Modal progress indicators.")
 @click.option("-d", "--detach", is_flag=True, help="Don't stop the app if the local process dies or disconnects.")
 @click.option("-i", "--interactive", is_flag=True, help="Run the app in interactive mode.")
 @click.option("-e", "--env", help=ENV_OPTION_HELP, default=None)
 @click.pass_context
-def run(ctx, detach, quiet, interactive, env):
+def run(ctx, write_result, detach, quiet, interactive, env):
     """Run a Modal function or local entrypoint.
 
     `FUNC_REF` should be of the format `{file or module}::{function name}`.
@@ -238,7 +284,7 @@ def run(ctx, detach, quiet, interactive, env):
 
     To run the hello_world function (or local entrypoint) in my_app.py:
 
-    ```bash
+    ```
     modal run my_app.py::hello_world
     ```
 
@@ -246,17 +292,18 @@ def run(ctx, detach, quiet, interactive, env):
     single local entrypoint (or single function), you can omit the app and
     function parts:
 
-    ```bash
+    ```
     modal run my_app.py
     ```
 
     Instead of pointing to a file, you can also use the Python module path:
 
-    ```bash
+    ```
     modal run my_project.my_app
     ```
     """
     ctx.ensure_object(dict)
+    ctx.obj["result_path"] = write_result
     ctx.obj["detach"] = detach  # if subcommand would be a click command...
     ctx.obj["show_progress"] = False if quiet else True
     ctx.obj["interactive"] = interactive
@@ -264,12 +311,10 @@ def run(ctx, detach, quiet, interactive, env):
 
 def deploy(
     app_ref: str = typer.Argument(..., help="Path to a Python file with an app."),
-    name: str = typer.Option(None, help="Name of the deployment."),
+    name: str = typer.Option("", help="Name of the deployment."),
     env: str = ENV_OPTION,
-    public: bool = typer.Option(
-        False, help="[beta] Publicize the deployment so other workspaces can lookup the function."
-    ),
-    skip_confirm: bool = typer.Option(False, help="Skip public app confirmation dialog."),
+    stream_logs: bool = typer.Option(False, help="Stream logs from the app upon deployment."),
+    tag: str = typer.Option("", help="Tag the deployment with a version."),
 ):
     # this ensures that `modal.lookup()` without environment specification uses the same env as specified
     env = ensure_env(env)
@@ -279,15 +324,11 @@ def deploy(
     if name is None:
         name = app.name
 
-    if public and not skip_confirm:
-        if not click.confirm(
-            "⚠️ Public apps are a beta feature. ⚠️\n"
-            "Making an app public will allow any user (including from outside your workspace) to look up and use your functions.\n"
-            "Are you sure you want your app to be public?"
-        ):
-            return
+    with enable_output():
+        res = deploy_app(app, name=name, environment_name=env or "", tag=tag)
 
-    deploy_app(app, name=name, environment_name=env, public=public)
+    if stream_logs:
+        stream_app_logs(app_id=res.app_id, app_logs_url=res.app_logs_url)
 
 
 def serve(
@@ -299,7 +340,7 @@ def serve(
 
     **Examples:**
 
-    ```bash
+    ```
     modal serve hello_world.py
     ```
     """
@@ -309,76 +350,123 @@ def serve(
     if app.description is None:
         app.set_description(_get_clean_app_description(app_ref))
 
-    with serve_app(app, app_ref, environment_name=env):
-        if timeout is None:
-            timeout = config["serve_timeout"]
-        if timeout is None:
-            timeout = float("inf")
-        while timeout > 0:
-            t = min(timeout, 3600)
-            time.sleep(t)
-            timeout -= t
+    with enable_output():
+        with serve_app(app, app_ref, environment_name=env):
+            if timeout is None:
+                timeout = config["serve_timeout"]
+            if timeout is None:
+                timeout = float("inf")
+            while timeout > 0:
+                t = min(timeout, 3600)
+                time.sleep(t)
+                timeout -= t
 
 
 def shell(
-    func_ref: Optional[str] = typer.Argument(
+    container_or_function: Optional[str] = typer.Argument(
         default=None,
-        help="Path to a Python file with an App or Modal function whose container to run.",
-        metavar="FUNC_REF",
+        help=(
+            "ID of running container, or path to a Python file containing a Modal App."
+            " Can also include a function specifier, like `module.py::func`, if the file defines multiple functions."
+        ),
+        metavar="REF",
     ),
-    cmd: str = typer.Option(default="/bin/bash", help="Command to run inside the Modal image."),
+    cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
     env: str = ENV_OPTION,
     image: Optional[str] = typer.Option(
-        default=None, help="Container image tag for inside the shell (if not using FUNC_REF)."
+        default=None, help="Container image tag for inside the shell (if not using REF)."
     ),
-    add_python: Optional[str] = typer.Option(default=None, help="Add Python to the image (if not using FUNC_REF)."),
-    cpu: Optional[int] = typer.Option(
-        default=None, help="Number of CPUs to allocate to the shell (if not using FUNC_REF)."
+    add_python: Optional[str] = typer.Option(default=None, help="Add Python to the image (if not using REF)."),
+    volume: Optional[list[str]] = typer.Option(
+        default=None,
+        help=(
+            "Name of a `modal.Volume` to mount inside the shell at `/mnt/{name}` (if not using REF)."
+            " Can be used multiple times."
+        ),
     ),
+    cpu: Optional[int] = typer.Option(default=None, help="Number of CPUs to allocate to the shell (if not using REF)."),
     memory: Optional[int] = typer.Option(
-        default=None, help="Memory to allocate for the shell, in MiB (if not using FUNC_REF)."
+        default=None, help="Memory to allocate for the shell, in MiB (if not using REF)."
     ),
     gpu: Optional[str] = typer.Option(
         default=None,
-        help="GPUs to request for the shell, if any. Examples are `any`, `a10g`, `a100:4` (if not using FUNC_REF).",
+        help="GPUs to request for the shell, if any. Examples are `any`, `a10g`, `a100:4` (if not using REF).",
     ),
     cloud: Optional[str] = typer.Option(
         default=None,
-        help="Cloud provider to run the function on. Possible values are `aws`, `gcp`, `oci`, `auto` (if not using FUNC_REF).",
+        help=(
+            "Cloud provider to run the shell on. " "Possible values are `aws`, `gcp`, `oci`, `auto` (if not using REF)."
+        ),
+    ),
+    region: Optional[str] = typer.Option(
+        default=None,
+        help=(
+            "Region(s) to run the container on. "
+            "Can be a single region or a comma-separated list to choose from (if not using REF)."
+        ),
     ),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
 ):
-    """Run an interactive shell inside a Modal image.
+    """Run a command or interactive shell inside a Modal container.
 
     **Examples:**
 
-    Start a shell inside the default Debian-based image:
+    Start an interactive shell inside the default Debian-based image:
 
-    ```bash
+    ```
     modal shell
     ```
 
-    Start a bash shell using the spec for `my_function` in your app:
+    Start an interactive shell with the spec for `my_function` in your App
+    (uses the same image, volumes, mounts, etc.):
 
-    ```bash
+    ```
     modal shell hello_world.py::my_function
     ```
 
+    Or, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
+
+    ```
+    modal shell hello_world.py::MyClass.my_method
+    ```
+
     Start a `python` shell:
 
-    ```bash
+    ```
     modal shell hello_world.py --cmd=python
     ```
+
+    Run a command with your function's spec and pipe the output to a file:
+
+    ```
+    modal shell hello_world.py -c 'uv pip list' > env.txt
+    ```
     """
     env = ensure_env(env)
 
-    console = Console()
-    if not console.is_terminal:
-        raise click.UsageError("`modal shell` can only be run from a terminal.")
+    if pty is None:
+        pty = is_tty()
+
+    if platform.system() == "Windows":
+        raise InvalidError("`modal shell` is currently not supported on Windows")
 
     app = App("modal shell")
 
-    if func_ref is not None:
-        function = import_function(func_ref, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell")
+    if container_or_function is not None:
+        # `modal shell` with a container ID is a special case, alias for `modal container exec`.
+        if (
+            container_or_function.startswith("ta-")
+            and len(container_or_function[3:]) > 0
+            and container_or_function[3:].isalnum()
+        ):
+            from .container import exec
+
+            exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
+            return
+
+        function = import_function(
+            container_or_function, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell"
+        )
         assert isinstance(function, Function)
         function_spec: _FunctionSpec = function.spec
         start_shell = partial(
@@ -387,15 +475,30 @@ def shell(
             mounts=function_spec.mounts,
             secrets=function_spec.secrets,
             network_file_systems=function_spec.network_file_systems,
-            gpu=function_spec.gpu,
+            gpu=function_spec.gpus,
             cloud=function_spec.cloud,
             cpu=function_spec.cpu,
             memory=function_spec.memory,
             volumes=function_spec.volumes,
-            _allow_background_volume_commits=True,
+            region=function_spec.scheduler_placement.proto.regions if function_spec.scheduler_placement else None,
+            pty=pty,
+            proxy=function_spec.proxy,
         )
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
-        start_shell = partial(interactive_shell, image=modal_image, cpu=cpu, memory=memory, gpu=gpu, cloud=cloud)
+        volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
+        start_shell = partial(
+            interactive_shell,
+            image=modal_image,
+            cpu=cpu,
+            memory=memory,
+            gpu=gpu,
+            cloud=cloud,
+            volumes=volumes,
+            region=region.split(",") if region else [],
+            pty=pty,
+        )
 
-    start_shell(app, cmd=[cmd], environment_name=env, timeout=3600)
+    # NB: invoking under bash makes --cmd a lot more flexible.
+    cmds = shlex.split(f'/bin/bash -c "{cmd}"')
+    start_shell(app, cmds=cmds, environment_name=env, timeout=3600)

modal/cli/secret.py

@@ -3,7 +3,7 @@ import os
 import platform
 import subprocess
 from tempfile import NamedTemporaryFile
-from typing import List, Optional
+from typing import Optional
 
 import click
 import typer
@@ -23,7 +23,7 @@ secret_cli = typer.Typer(name="secret", help="Manage secrets.", no_args_is_help=
 
 @secret_cli.command("list", help="List your published secrets.")
 @synchronizer.create_blocking
-async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
+async def list_(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     env = ensure_env(env)
     client = await _Client.from_env()
     response = await retry_transient_errors(client.stub.SecretList, api_pb2.SecretListRequest(environment_name=env))
@@ -47,7 +47,7 @@ async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
 @synchronizer.create_blocking
 async def create(
     secret_name,
-    keyvalues: List[str] = typer.Argument(..., help="Space-separated KEY=VALUE items"),
+    keyvalues: list[str] = typer.Argument(..., help="Space-separated KEY=VALUE items"),
     env: Optional[str] = ENV_OPTION,
     force: bool = typer.Option(False, "--force", help="Overwrite the secret if it already exists."),
 ):
@@ -105,7 +105,8 @@ def get_text_from_editor(key) -> str:
 
         if status_code != 0:
             raise ValueError(
-                "Something went wrong with the external editor. Try again, or use '--' as the value to pass input through stdin instead"
+                "Something went wrong with the external editor. "
+                "Try again, or use '--' as the value to pass input through stdin instead"
             )
 
         bufferfile.seek(0)

modal/cli/token.py

@@ -12,7 +12,9 @@ token_cli = typer.Typer(name="token", help="Manage tokens.", no_args_is_help=Tru
 profile_option = typer.Option(
     None,
     help=(
-        "Modal profile to set credentials for. If unspecified (and MODAL_PROFILE environment variable is not set), uses the workspace name associated with the credentials."
+        "Modal profile to set credentials for. If unspecified "
+        "(and MODAL_PROFILE environment variable is not set), "
+        "uses the workspace name associated with the credentials."
     ),
 )
 activate_option = typer.Option(
@@ -28,7 +30,10 @@ verify_option = typer.Option(
 
 @token_cli.command(
     name="set",
-    help="Set account credentials for connecting to Modal. If not provided with the command, you will be prompted to enter your credentials.",
+    help=(
+        "Set account credentials for connecting to Modal. "
+        "If not provided with the command, you will be prompted to enter your credentials."
+    ),
 )
 @synchronizer.create_blocking
 async def set(

modal/cli/utils.py

@@ -1,13 +1,65 @@
 # Copyright Modal Labs 2022
+import asyncio
+from collections.abc import Sequence
 from datetime import datetime
-from typing import List, Union
+from json import dumps
+from typing import Optional, Union
 
 import typer
+from click import UsageError
+from grpclib import GRPCError, Status
 from rich.console import Console
-from rich.json import JSON
-from rich.table import Table
+from rich.table import Column, Table
 from rich.text import Text
 
+from modal_proto import api_pb2
+
+from .._output import OutputManager, get_app_logs_loop
+from .._utils.async_utils import synchronizer
+from ..client import _Client
+from ..environments import ensure_env
+from ..exception import NotFoundError
+
+
+@synchronizer.create_blocking
+async def stream_app_logs(
+    app_id: Optional[str] = None, task_id: Optional[str] = None, app_logs_url: Optional[str] = None
+):
+    client = await _Client.from_env()
+    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {app_id}")
+    try:
+        with output_mgr.show_status_spinner():
+            await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, app_logs_url=app_logs_url)
+    except asyncio.CancelledError:
+        pass
+    except GRPCError as exc:
+        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
+            raise UsageError(exc.message)
+        else:
+            raise
+    except KeyboardInterrupt:
+        pass
+
+
+@synchronizer.create_blocking
+async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_Client] = None) -> str:
+    if client is None:
+        client = await _Client.from_env()
+    env_name = ensure_env(env)
+    request = api_pb2.AppGetByDeploymentNameRequest(
+        namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE, name=name, environment_name=env_name
+    )
+    try:
+        resp = await client.stub.AppGetByDeploymentName(request)
+    except GRPCError as exc:
+        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
+            raise UsageError(exc.message or "")
+        raise
+    if not resp.app_id:
+        env_comment = f" in the '{env_name}' environment" if env_name else ""
+        raise NotFoundError(f"Could not find a deployed app named '{name}'{env_comment}.")
+    return resp.app_id
+
 
 def timestamp_to_local(ts: float, isotz: bool = True) -> str:
     if ts > 0:
@@ -25,13 +77,25 @@ def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 
 
-def display_table(column_names: List[str], rows: List[List[Union[Text, str]]], json: bool, title: str = None):
+def is_tty() -> bool:
+    return Console().is_terminal
+
+
+def display_table(
+    columns: Sequence[Union[Column, str]],
+    rows: Sequence[Sequence[Union[Text, str]]],
+    json: bool = False,
+    title: str = "",
+):
+    def col_to_str(col: Union[Column, str]) -> str:
+        return str(col.header) if isinstance(col, Column) else col
+
     console = Console()
     if json:
-        json_data = [{col: _plain(row[i]) for i, col in enumerate(column_names)} for row in rows]
-        console.print(JSON.from_data(json_data))
+        json_data = [{col_to_str(col): _plain(row[i]) for i, col in enumerate(columns)} for row in rows]
+        console.print_json(dumps(json_data))
     else:
-        table = Table(*column_names, title=title)
+        table = Table(*columns, title=title)
         for row in rows:
             table.add_row(*row)
         console.print(table)
@@ -42,4 +106,6 @@ ENV_OPTION_HELP = """Environment to interact with.
 If not specified, Modal will use the default environment of your current profile, or the `MODAL_ENVIRONMENT` variable.
 Otherwise, raises an error if the workspace has multiple environments.
 """
-ENV_OPTION = typer.Option(default=None, help=ENV_OPTION_HELP)
+ENV_OPTION = typer.Option(None, "-e", "--env", help=ENV_OPTION_HELP)
+
+YES_OPTION = typer.Option(False, "-y", "--yes", help="Run without pausing for confirmation.")