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

modal/cli/import_refs.py

@@ -1,8 +1,8 @@
 # Copyright Modal Labs 2023
 """Load or import Python modules from the CLI.
 
-For example, the function reference of `modal run some_file.py::stub.foo_func`
-or the stub lookup of `modal deploy some_file.py`.
+For example, the function reference of `modal run some_file.py::app.foo_func`
+or the app lookup of `modal deploy some_file.py`.
 
 These functions are only called by the Modal CLI, not in tasks.
 """
@@ -18,10 +18,9 @@ import click
 from rich.console import Console
 from rich.markdown import Markdown
 
-import modal
-from modal.exception import _CliUserExecutionError
+from modal.app import App, LocalEntrypoint
+from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
-from modal.stub import LocalEntrypoint, Stub
 
 
 @dataclasses.dataclass
@@ -34,14 +33,14 @@ def parse_import_ref(object_ref: str) -> ImportRef:
     if object_ref.find("::") > 1:
         file_or_module, object_path = object_ref.split("::", 1)
     elif object_ref.find(":") > 1:
-        raise modal.exception.InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
+        raise InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
     else:
         file_or_module, object_path = object_ref, None
 
     return ImportRef(file_or_module, object_path)
 
 
-DEFAULT_STUB_NAME = "stub"
+DEFAULT_APP_NAME = "app"
 
 
 def import_file_or_module(file_or_module: str):
@@ -52,8 +51,14 @@ def import_file_or_module(file_or_module: str):
         sys.path.insert(0, "")  # "" means the current working directory
 
     if file_or_module.endswith(".py"):
-        # when using a script path, that scripts directory should also be on the path as it is with `python some/script.py`
+        # when using a script path, that scripts directory should also be on the path as it is
+        # with `python some/script.py`
         full_path = Path(file_or_module).resolve()
+        if "." in full_path.name.removesuffix(".py"):
+            raise InvalidError(
+                f"Invalid Modal source filename: {full_path.name!r}."
+                "\n\nSource filename cannot contain additional period characters."
+            )
         sys.path.insert(0, str(full_path.parent))
 
         module_name = inspect.getmodulename(file_or_module)
@@ -84,7 +89,7 @@ def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
     for segment in obj_path.split("."):
         attr = prefix + segment
         try:
-            if isinstance(obj, Stub):
+            if isinstance(obj, App):
                 if attr in obj.registered_entrypoints:
                     # local entrypoints are not on stub blueprint
                     obj = obj.registered_entrypoints[attr]
@@ -103,19 +108,19 @@ def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
 
 
 def _infer_function_or_help(
-    stub: Stub, module, accept_local_entrypoint: bool, accept_webhook: bool
+    app: App, module, accept_local_entrypoint: bool, accept_webhook: bool
 ) -> Union[Function, LocalEntrypoint]:
-    function_choices = set(stub.registered_functions.keys())
+    function_choices = set(app.registered_functions)
     if not accept_webhook:
-        function_choices -= set(stub.registered_web_endpoints)
+        function_choices -= set(app.registered_web_endpoints)
     if accept_local_entrypoint:
-        function_choices |= set(stub.registered_entrypoints.keys())
+        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 stub.registered_entrypoints.items()
+        for name, entrypoint in app.registered_entrypoints.items()
         if entrypoint.info.module_name == module.__name__
     ]
 
@@ -123,82 +128,84 @@ def _infer_function_or_help(
         # 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(stub.registered_entrypoints) == 1:
+    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(stub.registered_entrypoints.keys())[0]
+        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 stub.registered_web_endpoints:
-            err_msg = "Modal stub has only web endpoints. Use `modal serve` instead of `modal run`."
+        if app.registered_web_endpoints:
+            err_msg = "Modal app has only web endpoints. Use `modal serve` instead of `modal run`."
         else:
-            err_msg = "Modal stub has no registered functions. Nothing to run."
+            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.
 
 modal run app.py::my_function [...args]
 
-Registered functions and local entrypoints on the selected stub are:
+Registered functions and local entrypoints on the selected app are:
 {registered_functions_str}
 """
         raise click.UsageError(help_text)
 
-    if function_name in stub.registered_entrypoints:
+    if function_name in app.registered_entrypoints:
         # entrypoint is in entrypoint registry, for now
-        return stub.registered_entrypoints[function_name]
+        return app.registered_entrypoints[function_name]
 
-    function = stub.indexed_objects[function_name]  # functions are in blueprint
+    function = app.registered_functions[function_name]
     assert isinstance(function, Function)
     return function
 
 
-def _show_no_auto_detectable_stub(stub_ref: ImportRef) -> None:
-    object_path = stub_ref.object_path
-    import_path = stub_ref.file_or_module
+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 stub '{object_path}' in {import_path}.[/bold red]")
+    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 a stub variable named **`{DEFAULT_STUB_NAME}`** (the default stub name). If your `modal.Stub` is named differently, "
-            "you must specify it in the stub ref argument. "
-            f"For example a stub variable `app_stub = modal.Stub()` in `{import_path}` would "
-            f"be specified as `{import_path}::app_stub`."
+            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)
 
 
-def import_stub(stub_ref: str) -> Stub:
-    import_ref = parse_import_ref(stub_ref)
+def import_app(app_ref: str) -> App:
+    import_ref = parse_import_ref(app_ref)
 
     module = import_file_or_module(import_ref.file_or_module)
-    obj_path = import_ref.object_path or DEFAULT_STUB_NAME  # get variable named "stub" by default
-    stub = get_by_object_path(module, obj_path)
+    app = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
 
-    if stub is None:
-        _show_no_auto_detectable_stub(import_ref)
+    if app is None:
+        _show_no_auto_detectable_app(import_ref)
         sys.exit(1)
 
-    if not isinstance(stub, Stub):
-        raise click.UsageError(f"{stub} is not a Modal Stub")
+    if not isinstance(app, App):
+        raise click.UsageError(f"{app} is not a Modal App")
 
-    return stub
+    return app
 
 
-def _show_function_ref_help(stub_ref: ImportRef, base_cmd: str) -> None:
-    object_path = stub_ref.object_path
-    import_path = stub_ref.file_or_module
+def _show_function_ref_help(app_ref: ImportRef, base_cmd: str) -> None:
+    object_path = app_ref.object_path
+    import_path = app_ref.file_or_module
     error_console = Console(stderr=True)
     if object_path:
         error_console.print(
-            f"[bold red]Could not find Modal function or local entrypoint '{object_path}' in '{import_path}'.[/bold red]"
+            f"[bold red]Could not find Modal function or local entrypoint"
+            f" '{object_path}' in '{import_path}'.[/bold red]"
         )
     else:
         error_console.print(
-            f"[bold red]No function was specified, and no [green]`stub`[/green] variable could be found in '{import_path}'.[/bold red]"
+            f"[bold red]No function was specified, and no [green]`app`[/green] variable "
+            f"could be found in '{import_path}'.[/bold red]"
         )
     guidance_msg = f"""
 Usage:
@@ -206,9 +213,9 @@ Usage:
 
 Given the following example `app.py`:
 ```
-stub = modal.Stub()
+app = modal.App()
 
-@stub.function()
+@app.function()
 def foo():
     ...
 ```
@@ -222,25 +229,24 @@ def import_function(
     import_ref = parse_import_ref(func_ref)
 
     module = import_file_or_module(import_ref.file_or_module)
-    obj_path = import_ref.object_path or DEFAULT_STUB_NAME  # get variable named "stub" by default
-    stub_or_function = get_by_object_path(module, obj_path)
+    app_or_function = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
 
-    if stub_or_function is None:
+    if app_or_function is None:
         _show_function_ref_help(import_ref, base_cmd)
         sys.exit(1)
 
-    if isinstance(stub_or_function, Stub):
+    if isinstance(app_or_function, App):
         # infer function or display help for how to select one
-        stub = stub_or_function
-        function_handle = _infer_function_or_help(stub, module, accept_local_entrypoint, accept_webhook)
+        app = app_or_function
+        function_handle = _infer_function_or_help(app, module, accept_local_entrypoint, accept_webhook)
         return function_handle
-    elif isinstance(stub_or_function, Function):
-        return stub_or_function
-    elif isinstance(stub_or_function, LocalEntrypoint):
+    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 stub_or_function
+        return app_or_function
     else:
-        raise click.UsageError(f"{stub_or_function} is not a Modal entity (should be a Stub or Function)")
+        raise click.UsageError(f"{app_or_function} is not a Modal entity (should be an App or Function)")

modal/cli/launch.py

@@ -4,45 +4,47 @@ import inspect
 import json
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from typer import Typer
 
+from ..app import App
 from ..exception import _CliUserExecutionError
-from ..runner import run_stub
-from ..stub import Stub
+from ..output import enable_output
+from ..runner import run_app
 from .import_refs import import_function
 
 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.
     """,
 )
 
 
-def _launch_program(name: str, filename: str, args: Dict[str, Any]) -> None:
-    os.environ["MODAL_LAUNCH_LOCAL_ARGS"] = json.dumps(args)
+def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]) -> None:
+    os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
     entrypoint = import_function(program_path, "modal launch")
-    stub: Stub = entrypoint.stub
-    stub.set_description(f"modal launch {name}")
+    app: App = entrypoint.app
+    app.set_description(f"modal launch {name}")
 
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.
     func = entrypoint.info.raw_f
     isasync = inspect.iscoroutinefunction(func)
-    with run_stub(stub):
-        try:
-            if isasync:
-                asyncio.run(func())
-            else:
-                func()
-        except Exception as exc:
-            raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
+    with enable_output():
+        with run_app(app, detach=detach):
+            try:
+                if isasync:
+                    asyncio.run(func())
+                else:
+                    func()
+            except Exception as exc:
+                raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
 
 
 @launch_cli.command(name="jupyter", help="Start Jupyter Lab on Modal.")
@@ -53,6 +55,9 @@ def jupyter(
     timeout: int = 3600,
     image: str = "ubuntu:22.04",
     add_python: Optional[str] = "3.11",
+    mount: Optional[str] = None,  # Adds a local directory to the jupyter container
+    volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
@@ -61,8 +66,10 @@ def jupyter(
         "timeout": timeout,
         "image": image,
         "add_python": add_python,
+        "mount": mount,
+        "volume": volume,
     }
-    _launch_program("jupyter", "run_jupyter.py", args)
+    _launch_program("jupyter", "run_jupyter.py", detach, args)
 
 
 @launch_cli.command(name="vscode", help="Start Visual Studio Code on Modal.")
@@ -70,12 +77,19 @@ def vscode(
     cpu: int = 8,
     memory: int = 32768,
     gpu: Optional[str] = None,
+    image: str = "debian:12",
     timeout: int = 3600,
+    mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
+    volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
         "memory": memory,
         "gpu": gpu,
+        "image": image,
         "timeout": timeout,
+        "mount": mount,
+        "volume": volume,
     }
-    _launch_program("vscode", "vscode.py", args)
+    _launch_program("vscode", "vscode.py", detach, args)

modal/cli/network_file_system.py

@@ -1,43 +1,35 @@
 # Copyright Modal Labs 2022
 import os
-import shutil
 import sys
-from contextlib import contextmanager
-from datetime import datetime
 from pathlib import Path
-from tempfile import NamedTemporaryFile
 from typing import Optional
 
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
 from rich.console import Console
-from rich.live import Live
 from rich.syntax import Syntax
 from rich.table import Table
-from typer import Typer
+from typer import Argument, Typer
 
 import modal
 from modal._location import display_location
-from modal._output import step_completed, step_progress
+from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
-from modal.cli._download import _glob_download
-from modal.cli.utils import ENV_OPTION, display_table
+from modal.cli._download import _volume_download
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.network_file_system import _NetworkFileSystem
 from modal_proto import api_pb2
 
-FileType = api_pb2.SharedVolumeListFilesEntry.FileType
-
-
 nfs_cli = Typer(name="nfs", help="Read and edit `modal.NetworkFileSystem` file systems.", no_args_is_help=True)
 
 
-@nfs_cli.command(name="list", help="List the names of all network file systems.")
+@nfs_cli.command(name="list", help="List the names of all network file systems.", rich_help_panel="Management")
 @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()
@@ -47,13 +39,12 @@ async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     env_part = f" in environment '{env}'" if env else ""
     column_names = ["Name", "Location", "Created at"]
     rows = []
-    locale_tz = datetime.now().astimezone().tzinfo
     for item in response.items:
         rows.append(
             [
                 item.label,
                 display_location(item.cloud_provider),
-                str(datetime.fromtimestamp(item.created_at, tz=locale_tz)),
+                timestamp_to_local(item.created_at, json),
             ]
         )
     display_table(column_names, rows, json, title=f"Shared Volumes{env_part}")
@@ -61,13 +52,13 @@ async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
 
 def gen_usage_code(label):
     return f"""
-@stub.function(network_file_systems={{"/my_vol": modal.NetworkFileSystem.from_name("{label}")}})
+@app.function(network_file_systems={{"/my_vol": modal.NetworkFileSystem.from_name("{label}")}})
 def some_func():
     os.listdir("/my_vol")
 """
 
 
-@nfs_cli.command(name="create", help="Create a named network file system.")
+@nfs_cli.command(name="create", help="Create a named network file system.", rich_help_panel="Management")
 def create(
     name: str,
     env: Optional[str] = ENV_OPTION,
@@ -89,7 +80,11 @@ async def _volume_from_name(deployment_name: str) -> _NetworkFileSystem:
     return network_file_system
 
 
-@nfs_cli.command(name="ls", help="List files and directories in a network file system.")
+@nfs_cli.command(
+    name="ls",
+    help="List files and directories in a network file system.",
+    rich_help_panel="File operations",
+)
 @synchronizer.create_blocking
 async def ls(
     volume_name: str,
@@ -114,7 +109,7 @@ async def ls(
         table.add_column("type")
 
         for entry in entries:
-            filetype = "dir" if entry.type == FileType.DIRECTORY else "file"
+            filetype = "dir" if entry.type == api_pb2.FileEntry.FileType.DIRECTORY else "file"
             table.add_row(entry.path, filetype)
         console.print(table)
     else:
@@ -122,17 +117,16 @@ async def ls(
             print(entry.path)
 
 
-PIPE_PATH = Path("-")
-
-
 @nfs_cli.command(
     name="put",
     help="""Upload a file or directory to a network file system.
 
 Remote parent directories will be created as needed.
 
-Ending the REMOTE_PATH with a forward slash (/), it's assumed to be a directory and the file will be uploaded with its current name under that directory.
+Ending the REMOTE_PATH with a forward slash (/), it's assumed to be a directory and the file
+will be uploaded with its current name under that directory.
 """,
+    rich_help_panel="File operations",
 )
 @synchronizer.create_blocking
 async def put(
@@ -148,19 +142,23 @@ async def put(
     console = Console()
 
     if Path(local_path).is_dir():
-        spinner = step_progress(f"Uploading directory '{local_path}' to '{remote_path}'...")
-        with Live(spinner, console=console):
-            await volume.add_local_dir(local_path, remote_path)
-        console.print(step_completed(f"Uploaded directory '{local_path}' to '{remote_path}'"))
+        progress_handler = ProgressHandler(type="upload", console=console)
+        with progress_handler.live:
+            await volume.add_local_dir(local_path, remote_path, progress_cb=progress_handler.progress)
+            progress_handler.progress(complete=True)
+        console.print(OutputManager.step_completed(f"Uploaded directory '{local_path}' to '{remote_path}'"))
 
     elif "*" in local_path:
         raise UsageError("Glob uploads are currently not supported")
     else:
-        spinner = step_progress(f"Uploading file '{local_path}' to '{remote_path}'...")
-        with Live(spinner, console=console):
-            written_bytes = await volume.add_local_file(local_path, remote_path)
+        progress_handler = ProgressHandler(type="upload", console=console)
+        with progress_handler.live:
+            written_bytes = await volume.add_local_file(local_path, remote_path, progress_cb=progress_handler.progress)
+            progress_handler.progress(complete=True)
         console.print(
-            step_completed(f"Uploaded file '{local_path}' to '{remote_path}' ({written_bytes} bytes written)")
+            OutputManager.step_completed(
+                f"Uploaded file '{local_path}' to '{remote_path}' ({written_bytes} bytes written)"
+            )
         )
 
 
@@ -169,7 +167,7 @@ class CliError(Exception):
         self.message = message
 
 
-@nfs_cli.command(name="get")
+@nfs_cli.command(name="get", rich_help_panel="File operations")
 @synchronizer.create_blocking
 async def get(
     volume_name: str,
@@ -180,68 +178,30 @@ async def get(
 ):
     """Download a file from a network file system.
 
-    Specifying a glob pattern (using any `*` or `**` patterns) as the `remote_path` will download all matching *files*, preserving
-    the source directory structure for the matched files.
+    Specifying a glob pattern (using any `*` or `**` patterns) as the `remote_path` will download
+    all matching files, preserving their directory structure.
 
     For example, to download an entire network file system into `dump_volume`:
 
-    ```bash
+    ```
     modal nfs get <volume-name> "**" dump_volume
     ```
 
-    Use "-" (a hyphen) as LOCAL_DESTINATION to write contents of file to stdout (only for non-glob paths).
+    Use "-" as LOCAL_DESTINATION to write file contents to standard output.
     """
     ensure_env(env)
     destination = Path(local_destination)
     volume = await _volume_from_name(volume_name)
-
-    def is_file_fn(entry):
-        return entry.type == FileType.FILE
-
-    if "*" in remote_path:
-        await _glob_download(
-            volume,
-            is_file_fn,
-            remote_path,
-            destination,
-            force,
-        )
-        return
-
-    if destination != PIPE_PATH:
-        if destination.is_dir():
-            destination = destination / remote_path.rsplit("/")[-1]
-
-        if destination.exists() and not force:
-            raise UsageError(f"'{destination}' already exists")
-
-        if not destination.parent.exists():
-            raise UsageError(f"Local directory '{destination.parent}' does not exist")
-
-    @contextmanager
-    def _destination_stream():
-        if destination == PIPE_PATH:
-            yield sys.stdout.buffer
-        else:
-            with NamedTemporaryFile(delete=False) as fp:
-                yield fp
-            shutil.move(fp.name, destination)
-
-    b = 0
-    try:
-        with _destination_stream() as fp:
-            async for chunk in volume.read_file(remote_path):
-                fp.write(chunk)
-                b += len(chunk)
-    except GRPCError as exc:
-        if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
-            raise UsageError(exc.message)
-
-    if destination != PIPE_PATH:
-        print(f"Wrote {b} bytes to '{destination}'", file=sys.stderr)
+    console = Console()
+    progress_handler = ProgressHandler(type="download", console=console)
+    with progress_handler.live:
+        await _volume_download(volume, remote_path, destination, force, progress_cb=progress_handler.progress)
+    console.print(OutputManager.step_completed("Finished downloading files to local!"))
 
 
-@nfs_cli.command(name="rm", help="Delete a file or directory from a network file system.")
+@nfs_cli.command(
+    name="rm", help="Delete a file or directory from a network file system.", rich_help_panel="File operations"
+)
 @synchronizer.create_blocking
 async def rm(
     volume_name: str,
@@ -257,3 +217,24 @@ async def rm(
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)
         raise
+
+
+@nfs_cli.command(
+    name="delete",
+    help="Delete a named, persistent modal.NetworkFileSystem.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def delete(
+    nfs_name: str = Argument(help="Name of the modal.NetworkFileSystem to be deleted. Case sensitive"),
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.NetworkFileSystem '{nfs_name}'?",
+            default=False,
+            abort=True,
+        )
+
+    await _NetworkFileSystem.delete(nfs_name, environment_name=env)

modal/cli/profile.py

@@ -28,7 +28,7 @@ def current():
 
 @profile_cli.command(name="list", help="Show all Modal profiles and highlight the active one.")
 @synchronizer.create_blocking
-async def list(json: Optional[bool] = False):
+async def list_(json: Optional[bool] = False):
     config = Config()
     profiles = config_profiles()
     lookup_coros = [