modal 1.5.6.dev10__tar.gz → 1.5.6.dev12__tar.gz

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/PKG-INFO

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

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/_functions.py

@@ -16,6 +16,7 @@ from google.protobuf.message import Message
 from grpclib import Status
 from synchronicity.combined_types import MethodWithAio
 
+from modal._utils.logger import logger
 from modal.types import CloudBucketMountInfo, FunctionInfo, HttpInfo, VolumeMountInfo
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
@@ -2306,7 +2307,8 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         """Fetch information about the graph of Inputs this FunctionCall is part of.
 
         Note: the call graph data is not populated in real-time, and its capture is best-effort.
-        We do not recommend relying on this method for critical use cases.
+        Large call graphs may be truncated. We do not recommend relying on this method
+        for critical use cases.
 
         See the [`modal.types`](/docs/sdk/py/latest/types) reference for information
         on the return values.
@@ -2317,6 +2319,11 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         assert self._client and self._client.stub
         request = api_pb2.FunctionGetCallGraphRequest(function_call_id=self.object_id)
         response = await self._client.stub.FunctionGetCallGraph(request)
+        if response.truncated:
+            logger.warning(
+                f"Call graph for {self.object_id} was truncated; "
+                f"returning the first {len(response.inputs)} inputs. The graph may be incomplete."
+            )
         return _reconstruct_call_graph(response)
 
     @live_method

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/_runtime/execution_context.py

@@ -109,7 +109,7 @@ _current_input_id: ContextVar = ContextVar("_current_input_id")
 _current_function_call_id: ContextVar = ContextVar("_current_function_call_id")
 _current_attempt_token: ContextVar = ContextVar("_current_attempt_token")
 
-_is_currently_importing = False  # we set this to True while a container is importing user code
+_is_currently_importing = False
 
 
 @contextmanager

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/_server.py

@@ -15,7 +15,7 @@ from ._supports_logs import _LogQueryData
 from .client import _Client
 from .cls import is_parameter
 from .exception import InvalidError
-from .types import ServerAutoscalerSettings
+from .types import ServerAutoscalerSettings, ServerInfo
 
 if typing.TYPE_CHECKING:
     import modal.app
@@ -101,6 +101,24 @@ class _Server:
         """
         return _ServerLogsManager(self)
 
+    async def info(self, *, refresh: bool = False) -> ServerInfo:
+        """Get an overview of a Server's resource requests, associated mounts, http config, etc.
+
+        This method performs a network request to populate this information if the Server handle is
+        a remote lookup whose information has not yet been fetched (e.g. from `Server.from_name(...)`),
+        or if `refresh=True`.
+
+        Args:
+            refresh: Always perform a network request. Pass `refresh=True` to ensure that this method
+                returns the most up to date information.
+
+        Returns:
+            This returns a [`modal.types.ServerInfo`](https://modal.com/docs/sdk/py/latest/types#ServerInfo)
+            dataclass.
+        """
+
+        return ServerInfo._from_function_info(await self._get_service_function().info(refresh=refresh))
+
     @staticmethod
     def _extract_user_cls(wrapped_user_cls: "type | _PartialFunction") -> type:
         if isinstance(wrapped_user_cls, _PartialFunction):

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/_utils/task_command_router_client.py

@@ -840,8 +840,11 @@ class TaskCommandRouterClient:
                             # We successfully authenticated after a JWT refresh, reset the auth retry flag.
                             if did_auth_retry:
                                 did_auth_retry = False
-                            # Reset retry backoff after any successful chunk.
+                            # Any received chunk is progress: reset the backoff and refill the
+                            # retry budget so it bounds consecutive failures, not failures over
+                            # the stream's lifetime.
                             delay_secs = self.stream_stdio_retry_delay_secs
+                            num_retries_remaining = self.stream_stdio_max_retries
                             # Track it so transient reconnects request the
                             # correct next byte.
                             if is_first_chunk_of_attempt and isinstance(item, sr_pb2.SandboxStdioReadV2Response):

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/_utils/time_utils.py

@@ -3,6 +3,17 @@ import re
 from datetime import datetime, timedelta, timezone, tzinfo
 from zoneinfo import ZoneInfo
 
+_DURATION_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400}
+_DURATION_EXPR = re.compile(r"^(?P<n>\d+)(?P<unit>s|m|h|d)$")
+
+
+def parse_duration(value: str) -> timedelta:
+    """Parse a compact duration such as ``30m``, ``2h``, or ``1d``."""
+    match = _DURATION_EXPR.match(value)
+    if not match:
+        raise ValueError(f"Invalid duration: '{value}'")
+    return timedelta(seconds=int(match.group("n")) * _DURATION_UNITS[match.group("unit")])
+
 
 def is_leap(year: int):
     return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

modal-1.5.6.dev12/modal/cli/_stats.py

@@ -0,0 +1,50 @@
+# Copyright Modal Labs 2026
+"""Shared color styling for stats CLI commands."""
+
+from rich.style import Style
+
+STATS_HEADING_STYLE = "white"
+STATS_METADATA_STYLE = "bright_black"
+STATS_SECTION_STYLE = "bold white"
+STATS_SUCCESS_STYLE = "green"
+STATS_PROGRESS_STYLE = "cyan"
+STATS_WARNING_STYLE = "yellow"
+STATS_PROBLEM_STYLE = "red"
+
+_HIGH_PROBLEM_RATE = 0.05
+
+
+def stats_style(style: str, use_color: bool) -> str | Style:
+    if use_color:
+        return style
+    if style == STATS_SECTION_STYLE:
+        return "bold"
+    return Style()
+
+
+def success_style(count: int, total: int, use_color: bool) -> str | None:
+    if use_color and total and count / total > 0.5:
+        return STATS_SUCCESS_STYLE
+    return None
+
+
+def progress_style(count: int, use_color: bool) -> str | None:
+    if use_color and count:
+        return STATS_PROGRESS_STYLE
+    return None
+
+
+def problem_style(count: int, total: int, use_color: bool) -> str | None:
+    if not use_color or count == 0:
+        return None
+    if not total or count / total >= _HIGH_PROBLEM_RATE:
+        return STATS_PROBLEM_STYLE
+    return STATS_WARNING_STYLE
+
+
+def percentile_style(p50: float | None, p99: float | None, use_color: bool) -> str | Style:
+    if not use_color or p50 is None or p99 is None or p99 <= 0:
+        return Style()
+    if p50 == 0 or p99 >= 2 * p50:
+        return STATS_WARNING_STYLE
+    return Style()

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/cli/app.py

@@ -3,7 +3,7 @@ import re
 import sys
 import time
 import warnings
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from json import dumps
 from typing import Literal, get_args
 
@@ -25,7 +25,7 @@ from modal.runner import DEPLOYMENT_STRATEGY_TYPE, _stop_and_wait_for_containers
 from modal_proto import api_pb2
 
 from .._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
-from .._utils.time_utils import locale_tz, timestamp_to_localized_str
+from .._utils.time_utils import locale_tz, parse_duration, timestamp_to_localized_str
 from ._help import ModalGroup
 from .utils import (
     _fetch_app_logs,
@@ -136,9 +136,6 @@ async def list_(env: str | None = None, json: bool = False):
     display_table(columns, rows, json, title=f"Apps{env_part}")
 
 
-_RELATIVE_TIME_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400}
-
-
 def _parse_time_arg(value: str | None, default: datetime) -> datetime:
     """Parse a time argument that can be a relative duration (e.g. '2h', '30m') or ISO 8601 datetime.
 
@@ -148,10 +145,12 @@ def _parse_time_arg(value: str | None, default: datetime) -> datetime:
     if value is None:
         return default
 
-    # Try relative duration: digits followed by a unit letter
-    if len(value) >= 2 and value[-1] in _RELATIVE_TIME_UNITS and value[:-1].isdigit():
-        seconds = int(value[:-1]) * _RELATIVE_TIME_UNITS[value[-1]]
-        return datetime.now(timezone.utc) - timedelta(seconds=seconds)
+    try:
+        duration = parse_duration(value)
+    except ValueError:
+        pass
+    else:
+        return datetime.now(timezone.utc) - duration
 
     # Try ISO 8601 datetime
     try:

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/cli/entry_point.py

@@ -21,6 +21,7 @@ from .dashboard import dashboard
 from .dict import dict_cli
 from .endpoint import endpoint_cli
 from .environment import environment_cli
+from .function import function_cli
 from .image import image_cli
 from .launch import launch_cli
 from .logo import print_logo
@@ -117,6 +118,7 @@ entrypoint_cli.add_command(launch_cli, hidden=True)
 entrypoint_cli.add_command(app_cli, panel="Deployments")
 entrypoint_cli.add_command(container_cli, panel="Deployments")
 entrypoint_cli.add_command(endpoint_cli, panel="Deployments")
+entrypoint_cli.add_command(function_cli, panel="Deployments")
 # cluster is hidden while multi-node is in beta/experimental
 entrypoint_cli.add_command(cluster_cli, panel="Deployments", hidden=True)
 

modal-1.5.6.dev12/modal/cli/function.py

@@ -0,0 +1,402 @@
+# Copyright Modal Labs 2026
+import json as json_lib
+from datetime import datetime, timedelta, timezone
+from typing import cast
+
+import click
+from click import UsageError
+from google.protobuf.timestamp_pb2 import Timestamp
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+from modal._environments import ensure_env
+from modal._object import _get_environment_name
+from modal._utils.async_utils import synchronizer
+from modal._utils.time_utils import parse_duration
+from modal.client import _Client
+from modal.output import OutputManager
+from modal_proto import api_pb2
+
+from ._help import ModalGroup
+from ._stats import (
+    STATS_HEADING_STYLE,
+    STATS_METADATA_STYLE,
+    STATS_SECTION_STYLE,
+    percentile_style,
+    problem_style,
+    progress_style,
+    stats_style,
+    success_style,
+)
+from .app import _parse_time_arg
+from .utils import env_option
+
+function_cli = ModalGroup(name="function", help="Inspect deployed Modal Functions.")
+
+_DEFAULT_STATS_WINDOW = timedelta(hours=1)
+_DEFAULT_METRIC_PRECISION = 2
+_DISPLAYED_PERCENTILES = ((5000, "p50"), (9000, "p90"), (9900, "p99"))
+_INPUT_METRIC_ORDER = ("Execution time (s)", "End-to-end latency (s)")
+_CONTAINER_METRIC_ORDER = (
+    "Startup time (s)",
+    "CPU Usage (cores)",
+    "Memory Usage (GiB)",
+    "GPU Utilization (%)",
+)
+
+
+async def _resolve_function_id(client: _Client, function_identifier: str, environment_name: str) -> str:
+    if function_identifier == "":
+        raise UsageError("FUNCTION must be a Function ID (fu-…) or a deployed Function name (APP_NAME/FUNCTION_NAME).")
+
+    if "/" in function_identifier:
+        app_name, function_name = function_identifier.split("/", 1)
+
+        if not (app_name and function_name):
+            raise UsageError(
+                "FUNCTION must be a Function ID (fu-…) or a deployed Function name (APP_NAME/FUNCTION_NAME)."
+            )
+
+        response = await client.stub.FunctionGet(
+            api_pb2.FunctionGetRequest(
+                app_name=app_name,
+                object_tag=function_name,
+                environment_name=environment_name,
+            )
+        )
+        return response.function_id
+
+    if function_identifier.startswith("fu-"):
+        return function_identifier
+
+    raise UsageError("FUNCTION must be a Function ID (fu-…) or a deployed Function name (APP_NAME/FUNCTION_NAME).")
+
+
+def _timestamp(value: datetime) -> Timestamp:
+    timestamp = Timestamp()
+    timestamp.FromDatetime(value.astimezone(timezone.utc))
+    return timestamp
+
+
+def _percentile_table(rows: list[tuple[Text, Text, Text, Text]], use_color: bool) -> Table:
+    table = Table(box=None, pad_edge=False, padding=(0, 2), header_style="")
+    table.add_column("", min_width=30)
+    percentile_header_style = stats_style(STATS_METADATA_STYLE, use_color)
+    table.add_column(Text("p50", style=percentile_header_style), justify="right", min_width=8)
+    table.add_column(Text("p90", style=percentile_header_style), justify="right", min_width=8)
+    table.add_column(Text("p99", style=percentile_header_style), justify="right", min_width=8)
+    for row in rows:
+        table.add_row(*row)
+    return table
+
+
+def _count_with_percentage(count: int, total: int, label: str) -> str:
+    percentage = count / total if total else 0
+    return f"{count:,} {label} ({percentage:.1%})"
+
+
+def _percentile_name(percentile_basis_points: int) -> str:
+    return f"p{percentile_basis_points / 100:g}"
+
+
+def _distribution_json(distribution: api_pb2.StatsPercentileDistribution) -> dict[str, object]:
+    return {
+        "unit": distribution.unit,
+        "percentiles": {
+            _percentile_name(percentile.percentile_basis_points): percentile.value
+            for percentile in distribution.percentiles
+        },
+    }
+
+
+def _distribution_map_json(
+    distributions: dict[str, api_pb2.StatsPercentileDistribution],
+) -> dict[str, object]:
+    return {name: _distribution_json(distribution) for name, distribution in distributions.items()}
+
+
+def _time_range_stats_json(response: api_pb2.FunctionGetTimeRangeStatsResponse) -> dict[str, object]:
+    return {
+        "since": response.since.ToDatetime(tzinfo=timezone.utc).isoformat(),
+        "until": response.until.ToDatetime(tzinfo=timezone.utc).isoformat(),
+        "input_success_count": response.input_success_count,
+        "input_failure_count": response.input_failure_count,
+        "input_timeout_count": response.input_timeout_count,
+        "input_running_at_end_count": response.input_running_at_end_count,
+        "input_percentile_stats": _distribution_map_json(
+            cast(dict[str, api_pb2.StatsPercentileDistribution], response.input_percentile_stats)
+        ),
+        "container_started_count": response.container_started_count,
+        "container_error_count": response.container_error_count,
+        "container_creating_at_end_count": response.container_creating_at_end_count,
+        "container_percentile_stats": _distribution_map_json(
+            cast(dict[str, api_pb2.StatsPercentileDistribution], response.container_percentile_stats)
+        ),
+    }
+
+
+def _stats_json(
+    function_id: str,
+    history: api_pb2.FunctionGetTimeRangeStatsResponse,
+    all_variants: bool,
+) -> dict[str, object]:
+    return {
+        "function_id": function_id,
+        "all_variants": all_variants,
+        "variant_count": history.variant_count,
+        **_time_range_stats_json(history),
+    }
+
+
+def _metric_rows(
+    distributions: dict[str, api_pb2.StatsPercentileDistribution],
+    expected_order: tuple[str, ...],
+    use_color: bool,
+) -> list[tuple[Text, Text, Text, Text]]:
+    rows: list[tuple[Text, Text, Text, Text]] = []
+    ordered_names = [name for name in expected_order if name in distributions]
+    ordered_names.extend(sorted(set(distributions) - set(expected_order)))
+    for name in ordered_names:
+        distribution = distributions[name]
+        values_by_percentile = {
+            percentile.percentile_basis_points: percentile.value for percentile in distribution.percentiles
+        }
+        if not any(basis_points in values_by_percentile for basis_points, _ in _DISPLAYED_PERCENTILES):
+            continue
+
+        p50 = values_by_percentile.get(5000)
+        p99 = values_by_percentile.get(9900)
+        values = []
+        for basis_points, _ in _DISPLAYED_PERCENTILES:
+            value = values_by_percentile.get(basis_points)
+            value_text = "—" if value is None else f"{value:.{_DEFAULT_METRIC_PRECISION}f}"
+            style = percentile_style(p50, p99, use_color) if basis_points == 9900 else Style()
+            values.append(Text(value_text, style=style))
+        rows.append(
+            (
+                Text(f"  {name}", style=stats_style(STATS_METADATA_STYLE, use_color)),
+                values[0],
+                values[1],
+                values[2],
+            )
+        )
+    return rows
+
+
+@function_cli.command("stats", no_args_is_help=True)
+@click.argument("function_identifier", metavar="FUNCTION")
+@click.option(
+    "--since",
+    default=None,
+    help="Start of time range. Treated as UTC if timezone not supplied."
+    "Accepts an ISO 8601 datetime or relative time such as '2h' or '30m'.",
+)
+@click.option(
+    "--until",
+    default=None,
+    help="End of time range. Treated as UTC if timezone not supplied. Accepts the same argument types as --since.",
+)
+@click.option(
+    "--all-variants",
+    is_flag=True,
+    default=False,
+    help="Aggregate the base Function and its variants.",
+)
+@click.option(
+    "--container",
+    type=str,
+    default=None,
+    metavar="CONTAINER",
+    help="Compute the stats only for this container. Takes precedence over --all-variants.",
+)
+@click.option("--no-color", is_flag=True, default=False, help="Disable colors in the output.")
+@click.option("--json", "json_output", is_flag=True, default=False, help="Output stats as JSON.")
+@env_option
+@synchronizer.create_blocking
+async def stats(
+    function_identifier: str,
+    since: str | None = None,
+    until: str | None = None,
+    all_variants: bool = False,
+    container: str | None = None,
+    no_color: bool = False,
+    json_output: bool = False,
+    *,
+    env: str | None = None,
+):
+    """Show aggregate statistics for a modal Function.
+
+    FUNCTION may be a Function ID or a deployed Function name in the form
+    ``APP_NAME/FUNCTION_NAME``. By default, stats describe the specified Function ID.
+    Pass ``--all-variants`` to aggregate across all its direct variants.
+
+    If --since and --until are omitted, the stats are returned for the last hour.
+
+    The available metrics and their definitions are subject to change and are provided
+    on a best-effort basis. They may be delayed or incomplete. Do not rely on this command
+    for autoscaler management.
+
+    Examples:
+
+    Show stats from the last hour using a Function ID:
+
+    ```
+    modal function stats fu-abc123
+    ```
+
+    Show stats for a deployed Function by name:
+
+    ```
+    modal function stats my-app/my-function
+    ```
+
+    Show stats across all parameterized instances of a deployed `modal.Cls`:
+
+    ```
+    modal function stats 'my-app/MyClass.*' --all-variants
+    ```
+
+    Show stats from a specific relative window:
+
+    ```
+    modal function stats my-app/my-function --since 5h --until 2h
+    ```
+
+    Show stats for an explicit time range as JSON:
+
+    ```
+    modal function stats my-app/my-function \
+        --since 2026-08-28T14:00:00Z \
+        --until 2026-08-28T16:00:00Z \
+        --json
+    ```
+
+    Show stats for a specific container:
+
+    ```
+    modal function stats my-app/my-function --container ta-12345
+    ```
+    """
+    now = datetime.now(timezone.utc)
+    until_dt = _parse_time_arg(until, default=now)
+    since_dt = _parse_time_arg(since, default=until_dt - _DEFAULT_STATS_WINDOW)
+    if since_dt >= until_dt:
+        raise UsageError("--since must be before --until.")
+
+    history_duration: timedelta | None = _DEFAULT_STATS_WINDOW if since is None else None
+    if since is not None and until is None:
+        try:
+            history_duration = parse_duration(since)
+        except ValueError:
+            pass
+
+    environment_name = _get_environment_name(ensure_env(env))
+    client = await _Client.from_env()
+    function_id = await _resolve_function_id(client, function_identifier, environment_name)
+    req = api_pb2.FunctionGetTimeRangeStatsRequest(
+        function_id=function_id,
+        since=_timestamp(since_dt),
+        until=_timestamp(until_dt),
+        rollup=all_variants,
+    )
+    if container:
+        req.container_id = container
+
+    resp = await client.stub.FunctionGetTimeRangeStats(req)
+
+    if json_output:
+        OutputManager.get().print_json(json_lib.dumps(_stats_json(function_id, resp, all_variants)))
+        return
+
+    output = OutputManager.get()
+    output.print("")
+    heading = f"Function stats for {function_id}"
+    if all_variants:
+        variant_label = "variant" if resp.variant_count == 1 else "variants"
+        heading += f" · all variants ({resp.variant_count:,} {variant_label})"
+    use_color = not no_color
+    output.print(Text(heading, style=stats_style(STATS_HEADING_STYLE, use_color)))
+    output.print("")
+    since_label = resp.since.ToDatetime(tzinfo=timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    until_label = resp.until.ToDatetime(tzinfo=timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    range_heading = ""
+    if history_duration is not None:
+        range_heading = f"Duration {str(history_duration)} · "
+    output.print(
+        Text(
+            f"{range_heading}{since_label} to {until_label} UTC",
+            style=stats_style(STATS_METADATA_STYLE, use_color),
+        )
+    )
+    output.print("")
+
+    completed_input_count = resp.input_success_count + resp.input_failure_count + resp.input_timeout_count
+    input_count = completed_input_count + resp.input_running_at_end_count
+    input_heading = Text("Inputs", style=stats_style(STATS_SECTION_STYLE, use_color))
+    input_heading.append(" " * (46 - len("Inputs")))
+    input_heading.append(f"{input_count:,} total (")
+    input_heading.append(
+        f"{resp.input_running_at_end_count:,} running",
+        style=progress_style(resp.input_running_at_end_count, use_color),
+    )
+    input_heading.append(")")
+    output.print(input_heading)
+
+    input_counts = Text("  ")
+    input_counts.append(
+        _count_with_percentage(resp.input_success_count, completed_input_count, "succeeded"),
+        style=success_style(resp.input_success_count, completed_input_count, use_color),
+    )
+    input_counts.append(" · ")
+    input_counts.append(
+        _count_with_percentage(resp.input_failure_count, completed_input_count, "failed"),
+        style=problem_style(resp.input_failure_count, completed_input_count, use_color),
+    )
+    input_counts.append(" · ")
+    input_counts.append(
+        _count_with_percentage(resp.input_timeout_count, completed_input_count, "timed out"),
+        style=problem_style(resp.input_timeout_count, completed_input_count, use_color),
+    )
+    output.print(input_counts)
+    input_rows = _metric_rows(
+        cast(dict[str, api_pb2.StatsPercentileDistribution], resp.input_percentile_stats),
+        _INPUT_METRIC_ORDER,
+        use_color,
+    )
+    if input_rows:
+        output.print("")
+        output.print(_percentile_table(input_rows, use_color))
+
+    output.print("")
+    container_count = resp.container_started_count + resp.container_error_count
+    container_heading = Text("Containers", style=stats_style(STATS_SECTION_STYLE, use_color))
+    container_heading.append(" " * (46 - len("Containers")))
+    container_heading.append(f"{container_count:,} total (")
+    container_heading.append(
+        f"{resp.container_creating_at_end_count:,} creating",
+        style=progress_style(resp.container_creating_at_end_count, use_color),
+    )
+    container_heading.append(")")
+    output.print(container_heading)
+
+    container_counts = Text("  ")
+    container_counts.append(
+        _count_with_percentage(resp.container_started_count, container_count, "started"),
+        style=success_style(resp.container_started_count, container_count, use_color),
+    )
+    container_counts.append(" · ")
+    container_counts.append(
+        _count_with_percentage(resp.container_error_count, container_count, "errored"),
+        style=problem_style(resp.container_error_count, container_count, use_color),
+    )
+    output.print(container_counts)
+
+    container_rows = _metric_rows(
+        cast(dict[str, api_pb2.StatsPercentileDistribution], resp.container_percentile_stats),
+        _CONTAINER_METRIC_ORDER,
+        use_color,
+    )
+    if container_rows:
+        output.print("")
+        output.print(_percentile_table(container_rows, use_color))

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/cli/image.py

@@ -58,7 +58,7 @@ async def logs(image_id: str, layers: int | None, all_layers: bool) -> None:
     effective_layers = None if all_layers else layers or 1
     image = Image.from_id(image_id)
     output_mgr = OutputManager.get()
-    last_message = ""
+    last_message: str | None = None
     async for entry in image.logs.fetch.aio(layers=effective_layers):
         last_message = entry.message
         await output_mgr.put_fetched_log(
@@ -69,7 +69,9 @@ async def logs(image_id: str, layers: int | None, all_layers: bool) -> None:
             )
         )
     output_mgr.flush_lines()
-    if last_message and not last_message.endswith("\n"):
+    if last_message is None:
+        output_mgr.print(f"No build logs found for Image {image_id}.")
+    elif not last_message.endswith("\n"):
         output_mgr.print("")
 
 

{modal-1.5.6.dev10 → modal-1.5.6.dev12}/modal/cli/import_refs.py

@@ -27,6 +27,7 @@ from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 from modal.output import OutputManager
 
+from .._runtime import execution_context
 from .._utils.async_utils import synchronizer
 
 
@@ -74,7 +75,8 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
                 f"Use `{base_cmd} -m {import_ref.file_or_module}` instead.",
             )
         try:
-            module = importlib.import_module(import_ref.file_or_module)
+            with execution_context._import_context():
+                module = importlib.import_module(import_ref.file_or_module)
         except Exception as exc:
             raise _CliUserExecutionError(import_ref.file_or_module) from exc
     else:
@@ -97,7 +99,8 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
         sys.modules[module_name] = module
         try:
             assert spec.loader
-            spec.loader.exec_module(module)
+            with execution_context._import_context():
+                spec.loader.exec_module(module)
         except Exception as exc:
             if isinstance(exc, ImportError) and "attempted relative import with no known parent package" in str(exc):
                 if import_ref.file_or_module and import_ref.command and not import_ref.use_module_mode: