modal 1.5.6.dev17__tar.gz → 1.5.6.dev19__tar.gz

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev17
+Version: 1.5.6.dev19
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/_workspace.py

@@ -137,17 +137,20 @@ class _WorkspaceProxyTokenManager:
         """mdmd:hidden"""
         self._workspace = workspace
 
-    async def create(self) -> TokenData:
+    async def create(self, name: str = "") -> TokenData:
         """Create a new proxy token for the Workspace.
 
+        Args:
+            name: An optional name to help identify the token.
+
         Examples:
             ```python notest
-            token = modal.Workspace.from_context().proxy_tokens.create()
+            token = modal.Workspace.from_context().proxy_tokens.create(name="production-webhooks")
             print(token.token_id, token.token_secret)
             ```
         """
         await self._workspace.hydrate()
-        resp = await self._workspace.client.stub.WebhookTokenCreate(api_pb2.WebhookTokenCreateRequest())
+        resp = await self._workspace.client.stub.WebhookTokenCreate(api_pb2.WebhookTokenCreateRequest(name=name))
         return TokenData(token_id=resp.token_id, token_secret=resp.token_secret)
 
     async def list(self, environment_name: Optional[str] = None) -> builtins.list[ProxyTokenInfo]:
@@ -180,6 +183,8 @@ class _WorkspaceProxyTokenManager:
                 token_id=token.token_id,
                 created_at=timestamp_to_localized_dt(token.created_at),
                 scoped=token.scoped,
+                name=token.name,
+                created_by=token.created_by.username,
             )
             for token in resp.tokens
         ]

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/cli/app.py

@@ -3,13 +3,15 @@ import re
 import sys
 import time
 import warnings
+from collections.abc import Mapping
 from json import dumps
 from typing import Literal, get_args
 
 import click
 import rich
 from click import UsageError
-from rich.table import Column
+from google.protobuf.json_format import MessageToDict
+from rich.table import Column, Table
 from rich.text import Text
 
 from modal._environments import ensure_env
@@ -620,8 +622,9 @@ async def dashboard(
 @click.argument("app_identifier")
 @env_option
 @click.option("--json", is_flag=True, default=False)
+@click.option("--no-color", is_flag=True, default=False, help="Disable colors in the output.")
 @synchronizer.create_blocking
-async def info(app_identifier: str, *, env: str | None = None, json: bool = False):
+async def info(app_identifier: str, *, env: str | None = None, json: bool = False, no_color: bool = False):
     """Show an App's lifecycle, Functions, and Servers.
 
     Examples:
@@ -650,6 +653,17 @@ async def info(app_identifier: str, *, env: str | None = None, json: bool = Fals
     state = APP_STATE_TO_MESSAGE.get(lifecycle.app_state, Text("unknown", style="gray"))
 
     if json:
+        summaries = {
+            function_id: MessageToDict(summary, preserving_proto_field_name=True)
+            for function_id, summary in resp.function_info_summaries.items()
+        }
+
+        def entries_with_info(entries: Mapping[str, str]) -> dict[str, dict]:
+            return {
+                name: {"id": function_id, "summary": summaries.get(function_id, {})}
+                for name, function_id in sorted(entries.items())
+            }
+
         output.print_json(
             dumps(
                 {
@@ -665,28 +679,71 @@ async def info(app_identifier: str, *, env: str | None = None, json: bool = Fals
                         "stopped_at": timestamp_to_localized_str(lifecycle.stopped_at, json),
                         "stopped_by": lifecycle.stopped_by or None,
                     },
-                    "functions": dict(sorted(app_info.functions.items())),
-                    "servers": dict(sorted(app_info.servers.items())),
+                    "functions": entries_with_info(app_info.functions),
+                    "servers": entries_with_info(app_info.servers),
                 }
             )
         )
         return
 
-    output.print(
-        Text.assemble("App: ", (app_info.app_id, "bold"), " - ", (app_info.description, "bold"), " (", state, ")")
-    )
+    header = Table(show_header=False, box=None, pad_edge=False, padding=(0, 1))
+    header.add_row(Text("App:"), Text(app_info.description))
+    header.add_row(Text("App ID:"), Text(app_info.app_id))
+    header.add_row(Text("State:"), Text(state.plain))
 
-    if app_info.functions:
-        display_table(["Name", "Function ID"], sorted(app_info.functions.items()), title="Functions")
-    if app_info.servers:
-        display_table(["Name", "Function ID"], sorted(app_info.servers.items()), title="Servers")
+    def event(label: str, timestamp: float, actor: str, version: int = 0) -> None:
+        parts = [timestamp_to_localized_str(timestamp, isotz=False), actor]
+        if version:
+            parts.insert(0, f"v{version}")
+        header.add_row(Text(label + ":"), Text(" · ".join(p for p in parts if p)))
 
-    events: list[list[Text | str | None]] = [
-        ["Created", timestamp_to_localized_str(lifecycle.created_at, json), lifecycle.created_by]
-    ]
-    if lifecycle.deployed_at:
-        label = f"Deployed (v{lifecycle.version})" if lifecycle.version else "Deployed"
-        events.append([label, timestamp_to_localized_str(lifecycle.deployed_at, json), lifecycle.deployed_by])
     if lifecycle.stopped_at:
-        events.append(["Stopped", timestamp_to_localized_str(lifecycle.stopped_at, json), lifecycle.stopped_by])
-    display_table(["Event", "Time", "By"], events, title="Lifecycle")
+        event("Stopped", lifecycle.stopped_at, lifecycle.stopped_by)
+    if lifecycle.deployed_at:
+        event("Deployment", lifecycle.deployed_at, lifecycle.deployed_by, lifecycle.version)
+    event("Created", lifecycle.created_at, lifecycle.created_by)
+    output.print(header)
+
+    name_width = max((len(name) for name in [*app_info.functions, *app_info.servers]), default=0)
+    for title, entries in (("Functions", app_info.functions), ("Servers", app_info.servers)):
+        if not entries:
+            continue
+        output.print("")
+        output.print(Text(f"{title} ({len(entries)}):"))
+        for index, (name, function_id) in enumerate(sorted(entries.items())):
+            if index:
+                output.print("")
+            identity = Table(show_header=False, box=None, pad_edge=False, padding=(0, 1))
+            identity.add_column(width=name_width + 2)
+            identity.add_column(no_wrap=True)
+            identity.add_row(Text(f"  {name}"), Text(function_id))
+            output.print(identity)
+            if function_id not in resp.function_info_summaries:
+                continue
+            summary = resp.function_info_summaries[function_id]
+            hardware = [f"{gpu.count} × {gpu.gpu_type} GPU" for gpu in summary.gpu_config]
+            metadata = Text(f"    {hardware[0] if hardware else 'CPU'}")
+            if len(hardware) > 1:
+                metadata.append(f" ({', '.join(hardware[1:])})", style=None if no_color else "bright_black")
+            if summary.web_function:
+                metadata.append(" · Web function")
+            if schedule := _app_function_schedule(summary.schedule):
+                metadata.append(" · ")
+                metadata.append(schedule)
+            if summary.HasField("requires_proxy_auth") and not summary.requires_proxy_auth:
+                metadata.append(" · ")
+                metadata.append("Unauthenticated", style=None if no_color else "yellow")
+            output.print(metadata)
+
+
+def _app_function_schedule(schedule: api_pb2.Schedule) -> str | None:
+    if schedule.HasField("cron"):
+        return f"{schedule.cron.cron_string} ({schedule.cron.timezone or 'UTC'})"
+    if schedule.HasField("period"):
+        parts = [
+            f"{value:g} {field.name.removesuffix('s') if value == 1 else field.name}"
+            for field, value in schedule.period.ListFields()
+            if value
+        ]
+        return "Every " + ", ".join(parts)
+    return None

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/cli/entry_point.py

@@ -11,7 +11,6 @@ from . import run, shell as shell_module
 from ._help import ModalCommand, ModalGroup, ModalProfileOption
 from .app import app_cli
 from .billing import billing_cli
-from .bootstrap import bootstrap
 from .changelog import changelog
 from .cluster import cluster_cli
 from .config import config_cli
@@ -131,8 +130,6 @@ entrypoint_cli.add_command(secret_cli, panel="Storage")
 entrypoint_cli.add_command(queue_cli, panel="Storage")
 entrypoint_cli.add_command(volume_cli, panel="Storage")
 
-entrypoint_cli.add_command(setup, panel="Onboarding")
-entrypoint_cli.add_command(bootstrap, panel="Onboarding")
 
 entrypoint_cli.add_command(workspace_cli, panel="Configuration")
 entrypoint_cli.add_command(environment_cli, panel="Configuration")
@@ -140,6 +137,7 @@ entrypoint_cli.add_command(profile_cli, panel="Configuration")
 entrypoint_cli.add_command(config_cli, panel="Configuration")
 entrypoint_cli.add_command(token_cli, panel="Configuration")
 entrypoint_cli.add_command(skills_cli, panel="Configuration")
+entrypoint_cli.add_command(setup, panel="Configuration")
 
 entrypoint_cli.add_command(billing_cli, panel="Observability")
 entrypoint_cli.add_command(changelog, panel="Observability")

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/cli/workspace.py

@@ -76,15 +76,23 @@ proxy_tokens_cli = ModalGroup(name="proxy-tokens", help=PROXY_TOKENS_HELP_TEXT)
 workspace_cli.add_command(proxy_tokens_cli)
 
 
-@proxy_tokens_cli.command("create", help="Create a proxy token in the current Workspace.")
+@proxy_tokens_cli.command("create")
+@click.option("--name", default="", help="Name to help identify the token.")
 @click.option("--json", is_flag=True, default=False)
-def proxy_tokens_create(*, json: bool = False):
+def proxy_tokens_create(*, name: str = "", json: bool = False):
     """Create a proxy token in the current Workspace.
 
     The new token's ID and secret will be printed to stdout. The secret is only
     shown at creation time and cannot be retrieved later.
+
+    Examples:
+
+    ```
+    modal workspace proxy-tokens create --name production-webhooks
+    modal workspace proxy-tokens create --json
+    ```
     """
-    token = Workspace.from_context().proxy_tokens.create()
+    token = Workspace.from_context().proxy_tokens.create(name=name)
     output_manager = OutputManager.get()
     bearer = f"Bearer {token.token_id}.{token.token_secret}"
     if json:
@@ -104,7 +112,7 @@ def proxy_tokens_create(*, json: bool = False):
         output_manager.print(table)
 
 
-@proxy_tokens_cli.command("list", help="List the proxy tokens of the current Workspace.")
+@proxy_tokens_cli.command("list")
 @click.option(
     "-e",
     "--environment",
@@ -113,39 +121,75 @@ def proxy_tokens_create(*, json: bool = False):
 )
 @click.option("--json", is_flag=True, default=False)
 def proxy_tokens_list(environment: str | None = None, json: bool = False):
+    """List the proxy tokens of the current Workspace.
+
+    Examples:
+
+    ```
+    modal workspace proxy-tokens list
+    modal workspace proxy-tokens list --environment prod
+    modal workspace proxy-tokens list --json
+    ```
+    """
     tokens = Workspace.from_context().proxy_tokens.list(environment_name=environment)
     # Emit a real boolean for JSON output, but a string for the rich table (which can't render a bare bool).
     rows = [
         [
+            token.name,
             token.token_id,
             timestamp_to_localized_str(token.created_at.timestamp(), json),
+            token.created_by,
             token.scoped if json else str(token.scoped),
         ]
         for token in tokens
     ]
-    display_table(["Token ID", "Created at", "Scoped"], rows, json=json)
+    display_table(["Name", "Token ID", "Created at", "Created by", "Scoped"], rows, json=json)
 
 
-@proxy_tokens_cli.command("allow", help="Allow a proxy token to authenticate to an environment.", no_args_is_help=True)
+@proxy_tokens_cli.command("allow", no_args_is_help=True)
 @click.argument("token_id")
 @click.argument("environment_name")
 def proxy_tokens_allow(token_id: str, environment_name: str):
+    """Allow a proxy token to authenticate to an environment.
+
+    Example:
+
+    ```
+    modal workspace proxy-tokens allow wk-123 prod
+    ```
+    """
     Workspace.from_context().proxy_tokens.allow(token_id, environment_name)
     rich.print(f"[green]✓[/green] Allowed proxy token {token_id!r} to authenticate to environment {environment_name!r}")
 
 
-@proxy_tokens_cli.command("revoke", help="Revoke a proxy token's access to an environment.", no_args_is_help=True)
+@proxy_tokens_cli.command("revoke", no_args_is_help=True)
 @click.argument("token_id")
 @click.argument("environment_name")
 def proxy_tokens_revoke(token_id: str, environment_name: str):
+    """Revoke a proxy token's access to an environment.
+
+    Example:
+
+    ```
+    modal workspace proxy-tokens revoke wk-123 prod
+    ```
+    """
     Workspace.from_context().proxy_tokens.revoke(token_id, environment_name)
     rich.print(f"[green]✓[/green] Revoked proxy token {token_id!r} access to environment {environment_name!r}")
 
 
-@proxy_tokens_cli.command("delete", help="Delete a proxy token from the current Workspace.", no_args_is_help=True)
+@proxy_tokens_cli.command("delete", no_args_is_help=True)
 @click.argument("token_id")
 @yes_option
 def proxy_tokens_delete(token_id: str, yes: bool = False):
+    """Delete a proxy token from the current Workspace.
+
+    Example:
+
+    ```
+    modal workspace proxy-tokens delete wk-123
+    ```
+    """
     if not yes:
         message = (
             f"Are you sure you want to delete proxy token {token_id!r}? Requests using this token will be rejected."

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/client.pyi

@@ -77,7 +77,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev17",
+        version: str = "1.5.6.dev19",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -277,7 +277,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev17",
+        version: str = "1.5.6.dev19",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/config.py

@@ -377,6 +377,7 @@ _SETTINGS = {
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
     "sandbox_v2": _Setting(None, transform=_to_boolean),
+    "use_control_plane_sidecar_create": _Setting(False, transform=_to_boolean),  # For internal/experimental use
     "snapshot_debug": _Setting(False, transform=_to_boolean),
     "cuda_checkpoint_path": _Setting("/__modal/.bin/cuda-checkpoint"),  # Used for snapshotting GPU memory.
     # Used to indicate gVisor cuda-checkpoint automation.

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/sandbox.py

@@ -2979,6 +2979,15 @@ class _SidecarContainer:
 _MAIN_CONTAINER_NAME: str = "main"
 
 
+def _use_control_plane_sidecar_create(is_v2: bool) -> bool:
+    """Whether a sidecar create request goes to the Modal server rather than over the Sandbox connection.
+
+    Opt-in via the `use_control_plane_sidecar_create` config setting. Only V2
+    Sandboxes can; V1 Sandboxes always create sidecars over the Sandbox connection.
+    """
+    return is_v2 and config.get("use_control_plane_sidecar_create")
+
+
 class _SidecarManager:
     """Creates and manages sidecar containers in a Sandbox."""
 
@@ -3060,8 +3069,13 @@ class _SidecarManager:
                 "or `.snapshot_filesystem()`\n"
             )
 
-        secrets = secrets or []
-        hydrate_coros = [secret.hydrate(client=self._sandbox._client) for secret in secrets] + [
+        env_dict, resolvable_secrets = _split_env_dict_and_resolvable_secrets(list(secrets or []))
+        if env:
+            # `env` takes precedence over environment variables from secrets
+            env_dict |= env
+        _validate_sandbox_env(env_dict)
+
+        hydrate_coros = [secret.hydrate(client=self._sandbox._client) for secret in resolvable_secrets] + [
             volume.hydrate(client=self._sandbox._client) for _, volume in validated_volumes
         ]
         await TaskContext.gather(*hydrate_coros)
@@ -3073,21 +3087,48 @@ class _SidecarManager:
         # Relies on dicts being ordered (true as of Python 3.6).
         volume_mounts = [_volume_to_mount_proto(path, volume) for path, volume in validated_volumes]
 
-        task_id, command_router_client = await self._get_command_router()
+        network_access = _build_outbound_network_access(False, outbound_cidr_allowlist, outbound_domain_allowlist)
+        pty_info = _Sandbox._default_pty_info() if pty else None
+
+        if _use_control_plane_sidecar_create(self._sandbox._is_v2):
+            definition = api_pb2.Sandbox(
+                entrypoint_args=list(args),
+                image_id=image.object_id,
+                secret_ids=[secret.object_id for secret in resolvable_secrets],
+                workdir=workdir,
+                volume_mounts=volume_mounts,
+                network_access=network_access,
+                pty_info=pty_info,
+            )
+            create_req = api_pb2.SandboxContainerCreateV2Request(
+                sandbox_id=self._sandbox.object_id,
+                container_name=name,
+                definition=definition,
+                ephemeral_secrets=api_pb2.StringMap(contents=env_dict) if env_dict else None,
+            )
+            client = self._sandbox._client
+            assert client._auth_token_manager
+            auth_token = await client._auth_token_manager.get_token()
+            create_resp = await client.stub.SandboxContainerCreateV2(
+                create_req, metadata=[("x-modal-auth-token", auth_token)]
+            )
+        else:
+            task_id, command_router_client = await self._get_command_router()
+            create_resp = await command_router_client.container_create(
+                sr_pb2.TaskContainerCreateRequest(
+                    task_id=task_id,
+                    container_name=name,
+                    image_id=image.object_id,
+                    args=list(args),
+                    env=env_dict,
+                    workdir=workdir or "",
+                    secret_ids=[secret.object_id for secret in resolvable_secrets],
+                    volume_mounts=volume_mounts,
+                    network_access=network_access,
+                    pty_info=pty_info,
+                )
+            )
 
-        create_req = sr_pb2.TaskContainerCreateRequest(
-            task_id=task_id,
-            container_name=name,
-            image_id=image.object_id,
-            args=list(args),
-            env=env or {},
-            workdir=workdir or "",
-            secret_ids=[secret.object_id for secret in secrets],
-            volume_mounts=volume_mounts,
-            network_access=_build_outbound_network_access(False, outbound_cidr_allowlist, outbound_domain_allowlist),
-            pty_info=_Sandbox._default_pty_info() if pty else None,
-        )
-        create_resp = await command_router_client.container_create(create_req)
         container_id = create_resp.container_id
         container_name = create_resp.container_name or name
         return _SidecarContainer(self._sandbox, container_id, container_name)

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/sandbox.pyi

@@ -1222,6 +1222,14 @@ class _SidecarContainer:
         """
         ...
 
+def _use_control_plane_sidecar_create(is_v2: bool) -> bool:
+    """Whether a sidecar create request goes to the Modal server rather than over the Sandbox connection.
+
+    Opt-in via the `use_control_plane_sidecar_create` config setting. Only V2
+    Sandboxes can; V1 Sandboxes always create sidecars over the Sandbox connection.
+    """
+    ...
+
 class _SidecarManager:
     """Creates and manages sidecar containers in a Sandbox."""
     def __init__(self, sandbox: _Sandbox) -> None:

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/types.py

@@ -310,6 +310,8 @@ class ProxyTokenInfo:
     token_id: str
     created_at: datetime
     scoped: bool
+    name: str = ""
+    created_by: str = ""
 
 
 @dataclass(frozen=True)

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal/workspace.pyi

@@ -12,8 +12,12 @@ class ProxyTokenInfo:
     token_id: str
     created_at: datetime.datetime
     scoped: bool
+    name: str
+    created_by: str
 
-    def __init__(self, token_id: str, created_at: datetime.datetime, scoped: bool) -> None:
+    def __init__(
+        self, token_id: str, created_at: datetime.datetime, scoped: bool, name: str = "", created_by: str = ""
+    ) -> None:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
@@ -395,23 +399,29 @@ class WorkspaceProxyTokenManager:
         ...
 
     class __create_spec(typing_extensions.Protocol):
-        def __call__(self, /) -> modal.types.TokenData:
+        def __call__(self, /, name: str = "") -> modal.types.TokenData:
             """Create a new proxy token for the Workspace.
 
+            Args:
+                name: An optional name to help identify the token.
+
             Examples:
                 ```python notest
-                token = modal.Workspace.from_context().proxy_tokens.create()
+                token = modal.Workspace.from_context().proxy_tokens.create(name="production-webhooks")
                 print(token.token_id, token.token_secret)
                 ```
             """
             ...
 
-        async def aio(self, /) -> modal.types.TokenData:
+        async def aio(self, /, name: str = "") -> modal.types.TokenData:
             """Create a new proxy token for the Workspace.
 
+            Args:
+                name: An optional name to help identify the token.
+
             Examples:
                 ```python notest
-                token = modal.Workspace.from_context().proxy_tokens.create()
+                token = modal.Workspace.from_context().proxy_tokens.create(name="production-webhooks")
                 print(token.token_id, token.token_secret)
                 ```
             """

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev17
+Version: 1.5.6.dev19
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.6.dev17 → modal-1.5.6.dev19}/modal.egg-info/SOURCES.txt

@@ -173,7 +173,6 @@ modal/cli/_stats.py
 modal/cli/_traceback.py
 modal/cli/app.py
 modal/cli/billing.py
-modal/cli/bootstrap.py
 modal/cli/changelog.py
 modal/cli/cluster.py
 modal/cli/config.py