modal 0.62.16__py3-none-any.whl → 0.72.11__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, FunctionEnv
+from ..functions import Function, _FunctionSpec
 from ..image import Image
-from ..runner import deploy_stub, interactive_shell, run_stub
-from ..serving import serve_stub
-from ..stub import LocalEntrypoint, Stub
-from .import_refs import import_function, import_stub
-from .utils import ENV_OPTION, ENV_OPTION_HELP
+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, 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
@@ -118,7 +123,7 @@ def _add_click_options(func, signature: Dict[str, ParameterMetadata]):
     return func
 
 
-def _get_clean_stub_description(func_ref: str) -> str:
+def _get_clean_app_description(func_ref: str) -> str:
     # If possible, consider the 'ref' argument the start of the app's args. Everything
     # before it Modal CLI cruft (eg. `modal run --detach`).
     try:
@@ -128,17 +133,46 @@ def _get_clean_stub_description(func_ref: str) -> str:
         return " ".join(sys.argv)
 
 
-def _get_click_command_for_function(stub: Stub, function_tag):
-    function = stub.indexed_objects[function_tag]
+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.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,28 +180,34 @@ def _get_click_command_for_function(stub: Stub, function_tag):
 
     @click.pass_context
     def f(ctx, **kwargs):
-        with run_stub(
-            stub,
-            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)
 
 
-def _get_click_command_for_local_entrypoint(stub: Stub, entrypoint: LocalEntrypoint):
+def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoint):
     func = entrypoint.info.raw_f
     isasync = inspect.iscoroutinefunction(func)
 
@@ -175,23 +215,28 @@ def _get_click_command_for_local_entrypoint(stub: Stub, entrypoint: LocalEntrypo
     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_stub(
-            stub,
-            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)
@@ -205,14 +250,14 @@ class RunGroup(click.Group):
         ctx.ensure_object(dict)
         ctx.obj["env"] = ensure_env(ctx.params["env"])
         function_or_entrypoint = import_function(func_ref, accept_local_entrypoint=True, base_cmd="modal run")
-        stub: Stub = function_or_entrypoint.stub
-        if stub.description is None:
-            stub.set_description(_get_clean_stub_description(func_ref))
+        app: App = function_or_entrypoint.app
+        if app.description is None:
+            app.set_description(_get_clean_app_description(func_ref))
         if isinstance(function_or_entrypoint, LocalEntrypoint):
-            click_command = _get_click_command_for_local_entrypoint(stub, function_or_entrypoint)
+            click_command = _get_click_command_for_local_entrypoint(app, function_or_entrypoint)
         else:
             tag = function_or_entrypoint.info.get_tag()
-            click_command = _get_click_command_for_function(stub, tag)
+            click_command = _get_click_command_for_function(app, tag)
 
         return click_command
 
@@ -221,181 +266,239 @@ 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}`.
-    Alternatively, you can refer to the function via the stub:
+    Alternatively, you can refer to the function via the app:
 
-    `{file or module}::{stub variable name}.{function name}`
+    `{file or module}::{app variable name}.{function name}`
 
     **Examples:**
 
     To run the hello_world function (or local entrypoint) in my_app.py:
 
-    ```bash
+    ```
     modal run my_app.py::hello_world
     ```
 
-    If your module only has a single stub called `stub` and your stub has a
-    single local entrypoint (or single function), you can omit the stub and
+    If your module only has a single app called `app` and your app has a
+    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
 
 
 def deploy(
-    stub_ref: str = typer.Argument(..., help="Path to a Python file with a stub."),
-    name: str = typer.Option(None, help="Name of the deployment."),
+    app_ref: str = typer.Argument(..., help="Path to a Python file with an app."),
+    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)
 
-    stub = import_stub(stub_ref)
+    app = import_app(app_ref)
 
     if name is None:
-        name = stub.name
+        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_stub(stub, 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(
-    stub_ref: str = typer.Argument(..., help="Path to a Python file with a stub."),
+    app_ref: str = typer.Argument(..., help="Path to a Python file with an app."),
     timeout: Optional[float] = None,
     env: str = ENV_OPTION,
 ):
-    """Run a web endpoint(s) associated with a Modal stub and hot-reload code.
+    """Run a web endpoint(s) associated with a Modal app and hot-reload code.
 
     **Examples:**
 
-    ```bash
+    ```
     modal serve hello_world.py
     ```
     """
     env = ensure_env(env)
 
-    stub = import_stub(stub_ref)
-    if stub.description is None:
-        stub.set_description(_get_clean_stub_description(stub_ref))
+    app = import_app(app_ref)
+    if app.description is None:
+        app.set_description(_get_clean_app_description(app_ref))
 
-    with serve_stub(stub, stub_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 a Stub 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 stub:
+    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 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
 
-    stub = Stub("modal shell")
+            exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
+            return
 
-    if func_ref is not None:
-        function = import_function(func_ref, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell")
+        function = import_function(
+            container_or_function, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell"
+        )
         assert isinstance(function, Function)
-        function_env: FunctionEnv = function.env
+        function_spec: _FunctionSpec = function.spec
         start_shell = partial(
             interactive_shell,
-            image=function_env.image,
-            mounts=function_env.mounts,
-            secrets=function_env.secrets,
-            network_file_systems=function_env.network_file_systems,
-            gpu=function_env.gpu,
-            cloud=function_env.cloud,
-            cpu=function_env.cpu,
-            memory=function_env.memory,
-            volumes=function_env.volumes,
-            _allow_background_volume_commits=True,
+            image=function_spec.image,
+            mounts=function_spec.mounts,
+            secrets=function_spec.secrets,
+            network_file_systems=function_spec.network_file_systems,
+            gpu=function_spec.gpus,
+            cloud=function_spec.cloud,
+            cpu=function_spec.cpu,
+            memory=function_spec.memory,
+            volumes=function_spec.volumes,
+            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(stub, 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))
@@ -34,8 +34,8 @@ async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
         rows.append(
             [
                 item.label,
-                timestamp_to_local(item.created_at),
-                timestamp_to_local(item.last_used_at) if item.last_used_at else "-",
+                timestamp_to_local(item.created_at, json),
+                timestamp_to_local(item.last_used_at, json) if item.last_used_at else "-",
             ]
         )
 
@@ -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."),
 ):
@@ -79,7 +79,7 @@ modal secret create my-credentials username=john password=-
     console = Console()
     env_var_code = "\n    ".join(f'os.getenv("{name}")' for name in env_dict.keys()) if env_dict else "..."
     example_code = f"""
-@stub.function(secrets=[modal.Secret.from_name("{secret_name}")])
+@app.function(secrets=[modal.Secret.from_name("{secret_name}")])
 def some_function():
     {env_var_code}
 """
@@ -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(