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

modal/cli/config.py

@@ -1,9 +1,9 @@
 # Copyright Modal Labs 2022
-import pprint
-
 import typer
+from rich.console import Console
 
 from modal.config import _profile, _store_user_config, config
+from modal.environments import Environment
 
 config_cli = typer.Typer(
     name="config",
@@ -17,10 +17,15 @@ config_cli = typer.Typer(
 )
 
 
-@config_cli.command(help="Show configuration values for the current profile (debug command).")
-def show():
+@config_cli.command(help="Show current configuration values (debugging command).")
+def show(redact: bool = typer.Option(True, help="Redact the `token_secret` value.")):
     # This is just a test command
-    pprint.pprint(config.to_dict())
+    config_dict = config.to_dict()
+    if redact and config_dict.get("token_secret"):
+        config_dict["token_secret"] = "***"
+
+    console = Console()
+    console.print(config_dict)
 
 
 SET_DEFAULT_ENV_HELP = """Set the default Modal environment for the active profile
@@ -34,6 +39,8 @@ when running a command that requires an environment.
 
 @config_cli.command(help=SET_DEFAULT_ENV_HELP)
 def set_environment(environment_name: str):
+    # Confirm that the environment exists by looking it up
+    Environment.lookup(environment_name)
     _store_user_config({"environment": environment_name})
     typer.echo(f"New default environment for profile {_profile}: {environment_name}")
 

modal/cli/container.py

@@ -1,28 +1,37 @@
 # Copyright Modal Labs 2022
-
-from typing import List, Union
+from typing import Optional, Union
 
 import typer
 from rich.text import Text
 
-from modal._container_exec import container_exec
+from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
-from modal.cli.utils import display_table, timestamp_to_local
+from modal._utils.grpc_utils import retry_transient_errors
+from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs, timestamp_to_local
 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
 
-container_cli = typer.Typer(name="container", help="Manage running containers.", no_args_is_help=True)
+container_cli = typer.Typer(name="container", help="Manage and connect to running containers.", no_args_is_help=True)
 
 
 @container_cli.command("list")
 @synchronizer.create_blocking
-async def list():
+async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
     """List all containers that are currently running."""
+    env = ensure_env(env)
     client = await _Client.from_env()
-    res: api_pb2.TaskListResponse = await client.stub.TaskList(api_pb2.TaskListRequest())
+    environment_name = _get_environment_name(env)
+    res: api_pb2.TaskListResponse = await client.stub.TaskList(
+        api_pb2.TaskListRequest(environment_name=environment_name)
+    )
 
     column_names = ["Container ID", "App ID", "App Name", "Start Time"]
-    rows: List[List[Union[Text, str]]] = []
+    rows: list[list[Union[Text, str]]] = []
     res.tasks.sort(key=lambda task: task.started_at, reverse=True)
     for task_stats in res.tasks:
         rows.append(
@@ -30,20 +39,59 @@ async def list():
                 task_stats.task_id,
                 task_stats.app_id,
                 task_stats.app_description,
-                timestamp_to_local(task_stats.started_at) if task_stats.started_at else "Pending",
+                timestamp_to_local(task_stats.started_at, json) if task_stats.started_at else "Pending",
             ]
         )
 
-    display_table(column_names, rows, json=False, title="Active Containers")
+    display_table(column_names, rows, json=json, title=f"Active Containers in environment: {environment_name}")
+
+
+@container_cli.command("logs")
+def logs(container_id: str = typer.Argument(help="Container ID")):
+    """Show logs for a specific container, streaming while active."""
+    stream_app_logs(task_id=container_id)
 
 
 @container_cli.command("exec")
 @synchronizer.create_blocking
 async def exec(
-    container_id: str = typer.Argument(help="Container ID."),
-    command: List[str] = typer.Argument(help="A command to run inside the container."),
-    pty: bool = typer.Option(is_flag=True, default=True, help="Run the command using a PTY."),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
+    container_id: str = typer.Argument(help="Container ID"),
+    command: list[str] = typer.Argument(
+        help="A command to run inside the container.\n\n"
+        "To pass command-line flags or options, add `--` before the start of your commands. "
+        "For example: `modal container exec <id> -- /bin/bash -c 'echo hi'`"
+    ),
 ):
     """Execute a command in a container."""
+
+    if pty is None:
+        pty = is_tty()
+
+    client = await _Client.from_env()
+
+    req = api_pb2.ContainerExecRequest(
+        task_id=container_id,
+        command=command,
+        pty_info=get_pty_info(shell=True) if pty else None,
+        runtime_debug=config.get("function_runtime_debug"),
+    )
+    res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
+
+    if pty:
+        await _ContainerProcess(res.exec_id, client).attach()
+    else:
+        # TODO: redirect stderr to its own stream?
+        await _ContainerProcess(res.exec_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT).wait()
+
+
+@container_cli.command("stop")
+@synchronizer.create_blocking
+async def stop(container_id: str = typer.Argument(help="Container ID")):
+    """Stop a currently-running container and reassign its in-progress inputs.
+
+    This will send the container a SIGINT signal that Modal will handle.
+    """
     client = await _Client.from_env()
-    await container_exec(container_id, command, pty=pty, client=client)
+    request = api_pb2.ContainerStopRequest(task_id=container_id)
+    await retry_transient_errors(client.stub.ContainerStop, request)

modal/cli/dict.py

@@ -0,0 +1,128 @@
+# Copyright Modal Labs 2024
+from typing import Optional
+
+import typer
+from rich.console import Console
+from typer import Argument, Option, Typer
+
+from modal._resolver import Resolver
+from modal._utils.async_utils import synchronizer
+from modal._utils.grpc_utils import retry_transient_errors
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
+from modal.client import _Client
+from modal.dict import _Dict
+from modal.environments import ensure_env
+from modal_proto import api_pb2
+
+dict_cli = Typer(
+    name="dict",
+    no_args_is_help=True,
+    help="Manage `modal.Dict` objects and inspect their contents.",
+)
+
+
+@dict_cli.command(name="create", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def create(name: str, *, env: Optional[str] = ENV_OPTION):
+    """Create a named Dict object.
+
+    Note: This is a no-op when the Dict already exists.
+    """
+    d = _Dict.from_name(name, environment_name=env, create_if_missing=True)
+    client = await _Client.from_env()
+    resolver = Resolver(client=client)
+    await resolver.load(d)
+
+
+@dict_cli.command(name="list", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
+    """List all named Dicts."""
+    env = ensure_env(env)
+    client = await _Client.from_env()
+    request = api_pb2.DictListRequest(environment_name=env)
+    response = await retry_transient_errors(client.stub.DictList, request)
+
+    rows = [(d.name, timestamp_to_local(d.created_at, json)) for d in response.dicts]
+    display_table(["Name", "Created at"], rows, json)
+
+
+@dict_cli.command("clear", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def clear(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+    """Clear the contents of a named Dict by deleting all of its data."""
+    d = await _Dict.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the contents of modal.Dict '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await d.clear()
+
+
+@dict_cli.command(name="delete", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+    """Delete a named Dict and all of its data."""
+    # Lookup first to validate the name, even though delete is a staticmethod
+    await _Dict.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.Dict '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await _Dict.delete(name, environment_name=env)
+
+
+@dict_cli.command(name="get", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def get(name: str, key: str, *, env: Optional[str] = ENV_OPTION):
+    """Print the value for a specific key.
+
+    Note: When using the CLI, keys are always interpreted as having a string type.
+    """
+    d = await _Dict.lookup(name, environment_name=env)
+    console = Console()
+    val = await d.get(key)
+    console.print(val)
+
+
+def _display(input: str, use_repr: bool) -> str:
+    val = repr(input) if use_repr else str(input)
+    return val[:80] + "..." if len(val) > 80 else val
+
+
+@dict_cli.command(name="items", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def items(
+    name: str,
+    n: int = Argument(default=20, help="Limit the number of entries shown"),
+    *,
+    all: bool = Option(False, "-a", "--all", help="Ignore N and print all entries in the Dict (may be slow)"),
+    use_repr: bool = Option(False, "-r", "--repr", help="Display items using `repr()` to see more details"),
+    json: bool = False,
+    env: Optional[str] = ENV_OPTION,
+):
+    """Print the contents of a Dict.
+
+    Note: By default, this command truncates the contents. Use the `N` argument to control the
+    amount of data shown or the `--all` option to retrieve the entire Dict, which may be slow.
+    """
+    d = await _Dict.lookup(name, environment_name=env)
+
+    i, items = 0, []
+    async for key, val in d.items():
+        i += 1
+        if not json and not all and i > n:
+            items.append(("...", "..."))
+            break
+        else:
+            if json:
+                display_item = key, val
+            else:
+                display_item = _display(key, use_repr), _display(val, use_repr)  # type: ignore  # mypy/issue/12056
+            items.append(display_item)
+
+    display_table(["Key", "Value"], items, json)

modal/cli/entry_point.py

@@ -12,10 +12,12 @@ from . import run
 from .app import app_cli
 from .config import config_cli
 from .container import container_cli
+from .dict import dict_cli
 from .environment import environment_cli
 from .launch import launch_cli
 from .network_file_system import nfs_cli
 from .profile import profile_cli
+from .queues import queue_cli
 from .secret import secret_cli
 from .token import _new_token, token_cli
 from .volume import volume_cli
@@ -81,22 +83,33 @@ async def setup(profile: Optional[str] = None):
     await _new_token(profile=profile, next_url="/home")
 
 
-entrypoint_cli_typer.add_typer(app_cli)
-entrypoint_cli_typer.add_typer(config_cli)
-entrypoint_cli_typer.add_typer(container_cli)
-entrypoint_cli_typer.add_typer(environment_cli)
-entrypoint_cli_typer.add_typer(launch_cli)
-entrypoint_cli_typer.add_typer(nfs_cli)
-entrypoint_cli_typer.add_typer(profile_cli)
-entrypoint_cli_typer.add_typer(secret_cli)
-entrypoint_cli_typer.add_typer(token_cli)
-entrypoint_cli_typer.add_typer(volume_cli)
-
-entrypoint_cli_typer.command("deploy", help="Deploy a Modal stub as an application.", no_args_is_help=True)(run.deploy)
+# Commands
+entrypoint_cli_typer.command("deploy", help="Deploy a Modal application.", no_args_is_help=True)(run.deploy)
 entrypoint_cli_typer.command("serve", no_args_is_help=True)(run.serve)
-entrypoint_cli_typer.command("setup", help="Bootstrap Modal's configuration.")(setup)
 entrypoint_cli_typer.command("shell")(run.shell)
+entrypoint_cli_typer.add_typer(launch_cli)
+
+# Deployments
+entrypoint_cli_typer.add_typer(app_cli, rich_help_panel="Deployments")
+entrypoint_cli_typer.add_typer(container_cli, rich_help_panel="Deployments")
+
+# Storage
+entrypoint_cli_typer.add_typer(dict_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(nfs_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(secret_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(queue_cli, rich_help_panel="Storage")
+entrypoint_cli_typer.add_typer(volume_cli, rich_help_panel="Storage")
+
+# Configuration
+entrypoint_cli_typer.add_typer(config_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(environment_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(profile_cli, rich_help_panel="Configuration")
+entrypoint_cli_typer.add_typer(token_cli, rich_help_panel="Configuration")
+
+# Hide setup from help as it's redundant with modal token new, but nicer for onboarding
+entrypoint_cli_typer.command("setup", help="Bootstrap Modal's configuration.", rich_help_panel="Onboarding")(setup)
 
+# Special handling for modal run, which is more complicated
 entrypoint_cli = typer.main.get_command(entrypoint_cli_typer)
 entrypoint_cli.add_command(run.run, name="run")  # type: ignore
 entrypoint_cli.list_commands(None)  # type: ignore

modal/cli/environment.py

@@ -1,13 +1,16 @@
 # Copyright Modal Labs 2023
-from typing import Optional
+from typing import Annotated, Optional, Union
 
 import typer
 from click import UsageError
-from typing_extensions import Annotated
+from grpclib import GRPCError, Status
+from rich.text import Text
 
 from modal import environments
+from modal._utils.name_utils import check_environment_name
 from modal.cli.utils import display_table
 from modal.config import config
+from modal.exception import InvalidError
 
 ENVIRONMENT_HELP_TEXT = """Create and interact with Environments
 
@@ -24,7 +27,7 @@ while still being able to deploy changes to a live environment.
 environment_cli = typer.Typer(name="environment", help=ENVIRONMENT_HELP_TEXT, no_args_is_help=True)
 
 
-class RenderableBool:
+class RenderableBool(Text):
     def __init__(self, value: bool):
         self.value = value
 
@@ -33,12 +36,21 @@ class RenderableBool:
 
 
 @environment_cli.command(name="list", help="List all environments in the current workspace")
-def list(json: Optional[bool] = False):
+def list_(json: Optional[bool] = False):
     envs = environments.list_environments()
+
+    # determine which environment is currently active, prioritizing the local default
+    # over the server default
+    active_env = config.get("environment")
+    for env in envs:
+        if env.default is True and active_env is None:
+            active_env = env.name
+
     table_data = []
     for item in envs:
-        is_active = item.name == config.get("environment")
-        row = [item.name, item.webhook_suffix, is_active if json else RenderableBool(is_active)]
+        is_active = item.name == active_env
+        is_active_display: Union[Text, str] = str(is_active) if json else RenderableBool(is_active)
+        row = [item.name, item.webhook_suffix, is_active_display]
         table_data.append(row)
     display_table(["name", "web suffix", "active"], table_data, json=json)
 
@@ -48,7 +60,14 @@ ENVIRONMENT_CREATE_HELP = """Create a new environment in the current workspace""
 
 @environment_cli.command(name="create", help=ENVIRONMENT_CREATE_HELP)
 def create(name: Annotated[str, typer.Argument(help="Name of the new environment. Must be unique. Case sensitive")]):
-    environments.create_environment(name)
+    check_environment_name(name)
+
+    try:
+        environments.create_environment(name)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT:
+            raise InvalidError(exc.message)
+        raise
     typer.echo(f"Environment created: {name}")
 
 
@@ -65,7 +84,10 @@ def delete(
 ):
     if not confirm:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the environment '{name}' and all its associated apps and secrets?",
+            (
+                f"Are you sure you want to irrevocably delete the environment '{name}' and"
+                " all its associated apps and secrets?"
+            ),
             default=False,
             abort=True,
         )
@@ -88,5 +110,14 @@ def update(
     if set_name is None and set_web_suffix is None:
         raise UsageError("You need to at least one new property (using --set-name or --set-web-suffix)")
 
-    environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
+    if set_name:
+        check_environment_name(set_name)
+
+    try:
+        environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
+    except GRPCError as exc:
+        if exc.status == Status.INVALID_ARGUMENT:
+            raise InvalidError(exc.message)
+        raise
+
     typer.echo("Environment updated")