modal 1.5.6.dev18__tar.gz → 1.5.6.dev20__tar.gz

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/PKG-INFO

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

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/modal/__init__.py

@@ -23,6 +23,7 @@ try:
     from .functions import Function, FunctionCall
     from .image import Image
     from .network_file_system import NetworkFileSystem
+    from .outbound_policy import OutboundPolicy
     from .output import enable_output
     from .partial_function import (
         asgi_app,
@@ -71,6 +72,7 @@ __all__ = [
     "FunctionCall",
     "Image",
     "NetworkFileSystem",
+    "OutboundPolicy",
     "Period",
     "Probe",
     "Proxy",

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/modal/_functions.py

@@ -1103,8 +1103,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         is_class=function_definition.is_class,
                         class_parameter_info=function_definition.class_parameter_info,
                         is_method=function_definition.is_method,
-                        use_function_id=function_definition.use_function_id,
-                        use_method_name=function_definition.use_method_name,
                         method_definitions=function_definition.method_definitions,
                         method_definitions_set=function_definition.method_definitions_set,
                         experimental_options=experimental_options or {},

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/modal/_runtime/user_code_imports.py

@@ -562,7 +562,6 @@ def _get_cls_or_user_cls(
                 f"Internal error: Invalid 'service function' identifier {qual_name}. Please contact Modal support"
             )
 
-        assert not function_def.use_method_name  # new "placeholder methods" should not be invoked directly!
         cls_name = parts[0]
         cls_or_user_cls = getattr(module, cls_name)
     return cls_or_user_cls

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/modal/_utils/task_command_router_client.py

@@ -1077,6 +1077,12 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskSetNetworkAccess, request)
             )
 
+    async def set_outbound_policy(self, request: sr_pb2.TaskSetOutboundPolicyRequest):
+        with grpc_error_converter():
+            return await call_with_retries_on_transient_errors(
+                lambda: self._call_with_auth_retry(self._stub.TaskSetOutboundPolicy, request)
+            )
+
     async def reload_volumes(
         self, task_id: str, timeout: float, container_id: str = ""
     ) -> sr_pb2.TaskReloadVolumesResponse:

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/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.dev18 → modal-1.5.6.dev20}/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.dev18 → modal-1.5.6.dev20}/modal/cli/utils.py

@@ -248,12 +248,21 @@ async def _resolve_function_id(
             raise
 
         print_server_warnings(response.server_warnings)
-        return response.function_id, response.handle_metadata
-
-    if _is_function_id(function_identifier):
+        function_id = response.function_id
+        function = response.function
+        metadata = response.handle_metadata
+    elif _is_function_id(function_identifier):
         get_by_id_response = await client.stub.FunctionGetById(
             api_pb2.FunctionGetByIdRequest(function_id=function_identifier)
         )
-        return function_identifier, get_by_id_response.handle_metadata
+        function_id = function_identifier
+        function = get_by_id_response.function
+        metadata = get_by_id_response.handle_metadata
+    else:
+        raise UsageError(usage)
+
+    if function.is_server != (object_type == "Server"):
+        actual_type = "Server" if function.is_server else "Function"
+        raise UsageError(f"'{function_identifier}' is a {actual_type}. Use `modal {actual_type.lower()} {command}`.")
 
-    raise UsageError(usage)
+    return function_id, metadata

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/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.dev18",
+        version: str = "1.5.6.dev20",
         *,
         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.dev18",
+        version: str = "1.5.6.dev20",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/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.dev18 → modal-1.5.6.dev20}/modal/network_file_system.py

@@ -22,6 +22,7 @@ from ._object import (
 from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing, async_map, sync_or_async_iter, synchronize_api
 from ._utils.blob_utils import LARGE_FILE_LIMIT, blob_iter, blob_upload_file
+from ._utils.deprecation import deprecation_warning
 from ._utils.hash_utils import get_sha256_hex
 from ._utils.name_utils import check_object_name
 from .client import _Client
@@ -33,6 +34,14 @@ NETWORK_FILE_SYSTEM_PUT_FILE_CLIENT_TIMEOUT = (
 )  # 10 min max for transferring files (does not include upload time to s3)
 
 
+def _warn_network_file_system_deprecated() -> None:
+    deprecation_warning(
+        (2026, 9, 16),
+        "`modal.NetworkFileSystem` is deprecated and will be removed in a future release. Use `modal.Volume` instead.",
+        show_source=False,
+    )
+
+
 def network_file_system_mount_protos(
     validated_network_file_systems: list[tuple[str, "_NetworkFileSystem"]],
 ) -> list[api_pb2.SharedVolumeMount]:
@@ -119,6 +128,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             ```
         """
         check_object_name(name, "NetworkFileSystem")
+        _warn_network_file_system_deprecated()
 
         async def _load(
             self: _NetworkFileSystem, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None
@@ -175,6 +185,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
                 assert await nfs.listdir("/") == []
             ```
         """
+        _warn_network_file_system_deprecated()
         if client is None:
             client = await _Client.from_env()
         request = api_pb2.SharedVolumeGetOrCreateRequest(
@@ -201,6 +212,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
     ) -> str:
         """mdmd:hidden"""
         check_object_name(deployment_name, "NetworkFileSystem")
+        _warn_network_file_system_deprecated()
         if client is None:
             client = await _Client.from_env()
         request = api_pb2.SharedVolumeGetOrCreateRequest(

{modal-1.5.6.dev18 → modal-1.5.6.dev20}/modal/network_file_system.pyi

@@ -9,6 +9,7 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
+def _warn_network_file_system_deprecated() -> None: ...
 def network_file_system_mount_protos(
     validated_network_file_systems: list[tuple[str, _NetworkFileSystem]],
 ) -> list[modal_proto.api_pb2.SharedVolumeMount]:

modal-1.5.6.dev20/modal/outbound_policy.py

@@ -0,0 +1,167 @@
+# Copyright Modal Labs 2026
+"""Immutable configuration for replacing headers in outbound HTTPS traffic."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Mapping, Sequence
+
+from modal_proto import api_pb2
+
+from ._utils.async_utils import synchronize_api
+from .exception import InvalidError
+from .secret import _Secret
+
+_DOMAIN_RE = re.compile(
+    r"^(\*\.)?([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\Z"
+)
+_HEADER_NAME_RE = re.compile(r"^[A-Za-z0-9!#$%&'*+.^_`|~-]+\Z")
+
+_MAX_HEADER_REPLACEMENTS = 25
+
+
+def _header_value_has_invalid_chars(value: str) -> bool:
+    return any((ord(c) < 0x20 and c != "\t") or ord(c) == 0x7F for c in value)
+
+
+def _template_references_key(template: str) -> bool:
+    """Whether a header value template references a `$KEY`."""
+    i = template.find("$")
+    while i != -1 and i + 1 < len(template):
+        c = template[i + 1]
+        if c == "$":
+            i = template.find("$", i + 2)
+            continue
+        if c.isascii() and (c.isalpha() or c == "_"):
+            return True
+        i = template.find("$", i + 1)
+    return False
+
+
+@dataclass(frozen=True)
+class _HeaderReplacement:
+    domain: str
+    headers: dict[str, str]
+    secret: _Secret | None
+
+
+class _OutboundPolicy:
+    """Immutable configuration for replacing headers in outbound HTTPS requests
+    from a Sandbox.
+
+    Header values support templating with keys in a replacement's secret: a
+    `$`-prefixed key name in the secret is replaced with the secret value.
+    Literal `$` characters are written `$$`.
+
+    Secret values never enter the Sandbox: they are resolved and injected into
+    matching requests outside the container.
+
+    Examples:
+        ```python
+        import modal
+
+        secret = modal.Secret.from_name("api-token")
+
+        outbound_policy = (
+            modal.OutboundPolicy()
+            # Inject a secret-backed Authorization header.
+            .with_header_replacement(
+                domain="example.com",
+                secret=secret,
+                headers={"Authorization": "Bearer $API_TOKEN"},
+            )
+            # Inject a static header into requests to another domain.
+            .with_header_replacement(
+                domain="modal.com",
+                headers={"X-Trace-Token": "trace_abcd"},
+            )
+        )
+
+        sb = modal.Sandbox.create(outbound_policy=outbound_policy)
+        ```
+    """
+
+    _replacements: tuple[_HeaderReplacement, ...]
+
+    def __init__(self, _replacements: tuple[_HeaderReplacement, ...] = ()):
+        self._replacements = _replacements
+
+    def with_header_replacement(
+        self,
+        *,
+        domain: str,
+        headers: Mapping[str, str],
+        secret: _Secret | None = None,
+    ) -> _OutboundPolicy:
+        """Return a new `OutboundPolicy` with an added header replacement.
+
+        Args:
+            domain: Domain the replacements are scoped to. Supports `*.` wildcard
+                prefixes (matching the apex domain and subdomains) and a bare `"*"`.
+            headers: Header name -> header value. Values support `$KEY` templates
+                referencing keys in the replacement's `secret`.
+            secret: Named Secret (e.g. from `Secret.from_name`) whose keys may be
+                referenced in the header value templates. Static replacements pass no
+                secret.
+        """
+        replacement = _HeaderReplacement(domain=domain, headers=dict(headers), secret=secret)
+        return _OutboundPolicy(self._replacements + (replacement,))
+
+    def _validate(self) -> None:
+        """Check all replacements, raising `InvalidError` on the first violation found."""
+        total = 0
+        for replacement in self._replacements:
+            if replacement.domain != "*" and not _DOMAIN_RE.match(replacement.domain):
+                raise InvalidError(f"Invalid domain: {replacement.domain!r}")
+            if not replacement.headers:
+                raise InvalidError("`headers` must contain at least one header")
+            for name, value in replacement.headers.items():
+                if not _HEADER_NAME_RE.match(name):
+                    raise InvalidError(f"Invalid header name: {name!r}")
+                if _header_value_has_invalid_chars(value):
+                    raise InvalidError(f"Header value for {name!r} must not contain control characters (except tab)")
+                if replacement.secret is None and _template_references_key(value):
+                    raise InvalidError(f"Header value for {name!r} references a secret key, but no `secret` was passed")
+            if replacement.secret is not None and replacement.secret._is_ephemeral:
+                raise InvalidError(
+                    "Outbound policies only support named secrets (e.g. `Secret.from_name`); "
+                    "ephemeral secrets (e.g. `Secret.from_dict`) are not yet supported"
+                )
+            total += len(replacement.headers)
+        if total > _MAX_HEADER_REPLACEMENTS:
+            raise InvalidError(f"Outbound policy cannot have more than {_MAX_HEADER_REPLACEMENTS} header replacements")
+
+    def _secrets(self) -> list[_Secret]:
+        """Deduplicated list of secrets referenced by the policy's replacements."""
+        return list(dict.fromkeys(r.secret for r in self._replacements if r.secret is not None))
+
+    def _to_proto(self) -> api_pb2.OutboundPolicy:
+        """Convert to the wire format. Referenced secrets must be hydrated first."""
+        return api_pb2.OutboundPolicy(
+            header_replacements=[
+                api_pb2.OutboundPolicy.HeaderReplacement(
+                    domain=replacement.domain,
+                    secret_id=(replacement.secret.object_id if replacement.secret is not None else ""),
+                    headers=replacement.headers,
+                )
+                for replacement in self._replacements
+            ]
+        )
+
+
+def _validate_compatible_network_access(
+    outbound_policy: _OutboundPolicy | None,
+    block_network: bool,
+    outbound_domain_allowlist: Sequence[str] | None,
+) -> None:
+    """Reject combinations of network configuration and outbound policy that the server does not support."""
+    if outbound_policy is None:
+        return
+    if block_network:
+        raise InvalidError("`outbound_policy` cannot be used when `block_network` is enabled")
+    if outbound_domain_allowlist:
+        raise InvalidError("`outbound_policy` cannot be used with `outbound_domain_allowlist`")
+
+
+OutboundPolicy = synchronize_api(_OutboundPolicy)