modAL 1.3.6.dev6__py3-none-any.whl → 1.3.6.dev8__py3-none-any.whl

modal/_logs.py

@@ -0,0 +1,498 @@
+# Copyright Modal Labs 2026
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Optional
+
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from modal._utils.async_utils import TaskContext
+from modal.exception import LogsFetchError
+from modal_proto import api_pb2
+
+if TYPE_CHECKING:
+    from modal.client import _Client
+
+
+@dataclasses.dataclass(frozen=True)
+class LogsFilters:
+    source: "api_pb2.FileDescriptor.ValueType" = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED
+    function_id: str = ""
+    function_call_id: str = ""
+    task_id: str = ""
+    sandbox_id: str = ""
+    search_text: str = ""
+
+
+# Maximum number of logs to request per fetch RPC call. This is a safety cap
+# to avoid silently dropping logs from dense intervals, not a target size.
+# Derived from a ~4 MiB target response size at ~200 bytes per log entry.
+_FETCH_LIMIT = 20_000
+
+# Minimum number of logs to accumulate per interval before splitting into
+# a new one. Buckets are merged until this threshold is reached. Intervals
+# with a single bucket exceeding this value are emitted as-is.
+_INTERVAL_LOG_THRESHOLD = 2_000
+
+# Maximum number of fetch RPCs per fetch_logs call. Together with _FETCH_LIMIT,
+# this bounds total retrievable entries to _MAX_FETCHES * _FETCH_LIMIT = 10M.
+_MAX_FETCHES = 500
+
+# Maximum allowed range between `since` and `until`, enforced server-side.
+_MAX_FETCH_RANGE = timedelta(days=35)
+
+# Lookback windows for tailing logs, tried in order from shortest to longest.
+_TAIL_LOOKBACKS = [
+    timedelta(hours=1),
+    timedelta(days=1),
+    timedelta(days=7),
+    timedelta(days=30),
+]
+
+# Maximum number of concurrent AppFetchLogs requests.
+_MAX_CONCURRENT_FETCHES = 10
+
+# Maximum number of concurrent AppCountLogs requests (responses are small).
+_MAX_CONCURRENT_COUNTS = 20
+
+# Maximum number of refinement iterations (each fires a parallel batch of AppCountLogs RPCs).
+_MAX_REFINE_ITERATIONS = 3
+
+# Number of buckets for the initial count
+_APPROX_INITIAL_BUCKETS = 100
+
+# Predefined bucket sizes (in seconds)
+# We pick the smallest size such that the total number of buckets stays <= _APPROX_INITIAL_BUCKETS.
+_BUCKET_SIZES_SECS = [
+    2,
+    4,
+    6,
+    12,
+    20,
+    30,
+    60,
+    120,
+    180,
+    240,
+    300,
+    360,
+    600,
+    720,
+    900,
+    1200,
+    1800,
+    3600,
+    7200,
+    10800,
+    14400,
+    28800,
+    43200,
+    86400,
+]
+
+
+def _datetime_to_timestamp(dt: datetime) -> Timestamp:
+    ts = Timestamp()
+    ts.FromDatetime(dt)
+    return ts
+
+
+def _timestamp_to_seconds(ts: Timestamp) -> float:
+    return ts.seconds + ts.nanos / 1e9
+
+
+def _seconds_to_timestamp(secs: float) -> Timestamp:
+    ts = Timestamp()
+    ts.seconds = int(secs)
+    ts.nanos = int((secs - int(secs)) * 1e9)
+    return ts
+
+
+def _pick_bucket_secs(since: datetime, until: datetime) -> int:
+    """Pick the smallest bucket size that yields _APPROX_INITIAL_BUCKETS."""
+    duration_secs = (until - since).total_seconds()
+    for bucket_secs in _BUCKET_SIZES_SECS:
+        if duration_secs / bucket_secs <= _APPROX_INITIAL_BUCKETS:
+            return bucket_secs
+    return _BUCKET_SIZES_SECS[-1]
+
+
+def _bucket_count(bucket: api_pb2.AppCountLogsResponse.LogBucket) -> int:
+    return bucket.stdout_logs + bucket.stderr_logs + bucket.system_logs
+
+
+def _buckets_to_ranges(
+    buckets: list[api_pb2.AppCountLogsResponse.LogBucket],
+    bucket_secs: int,
+) -> list[tuple[float, float, int]]:
+    """Convert proto buckets to (start, end, count) tuples."""
+    return [
+        (
+            _timestamp_to_seconds(b.bucket_start_at),
+            _timestamp_to_seconds(b.bucket_start_at) + bucket_secs,
+            _bucket_count(b),
+        )
+        for b in buckets
+    ]
+
+
+def _build_fetch_intervals(
+    ranges: list[tuple[float, float, int]],
+) -> list[tuple[float, float]]:
+    """Build time intervals for parallel fetching from (start, end, count) ranges.
+
+    Merges adjacent non-empty ranges into intervals, splitting when the
+    accumulated log count reaches _INTERVAL_LOG_THRESHOLD or when adding the
+    next range would push the interval over _FETCH_LIMIT.
+    """
+    intervals: list[tuple[float, float]] = []
+    current_start: Optional[float] = None
+    current_end: float = 0.0
+    current_count = 0
+
+    for range_start, range_end, total in ranges:
+        if total == 0:
+            if current_start is not None:
+                intervals.append((current_start, current_end))
+                current_start = None
+                current_count = 0
+            continue
+
+        if current_start is not None and current_count + total > _FETCH_LIMIT:
+            intervals.append((current_start, current_end))
+            current_start = None
+            current_count = 0
+
+        if current_start is None:
+            current_start = range_start
+            current_count = total
+        else:
+            current_count += total
+        current_end = range_end
+
+        if current_count >= _INTERVAL_LOG_THRESHOLD:
+            intervals.append((current_start, current_end))
+            current_start = None
+            current_count = 0
+
+    # Flush remaining interval
+    if current_start is not None:
+        intervals.append((current_start, current_end))
+
+    return intervals
+
+
+def _next_smaller_bucket_secs(current_bucket_secs: int) -> Optional[int]:
+    """Return the next smaller bucket size, or None if already at the smallest."""
+    for size in reversed(_BUCKET_SIZES_SECS):
+        if size < current_bucket_secs:
+            return size
+    return None
+
+
+async def _refine_dense_ranges(
+    client: _Client,
+    app_id: str,
+    ranges: list[tuple[float, float, int]],
+    filters: LogsFilters,
+    max_ranges: int,
+    max_iterations: int,
+) -> list[tuple[float, float, int]]:
+    """Refine ranges exceeding _FETCH_LIMIT by subdividing with smaller buckets.
+
+    Uses breadth-first refinement: each iteration splits ALL over-limit ranges
+    one level, ensuring fair treatment across dense regions. Stops when all
+    ranges fit within _FETCH_LIMIT, no further subdivision is possible,
+    the total range count would exceed max_ranges, or the iteration budget
+    is exhausted.
+    """
+    refined = list(ranges)
+    iterations = 0
+
+    while iterations < max_iterations:
+        # Identify dense ranges that can be subdivided
+        to_refine: list[tuple[int, int]] = []  # (index, smaller_secs)
+        for i, (start, end, count) in enumerate(refined):
+            if count <= _FETCH_LIMIT:
+                continue
+            duration = end - start
+            smaller_secs = _next_smaller_bucket_secs(int(duration))
+            if smaller_secs is not None and smaller_secs < duration:
+                to_refine.append((i, smaller_secs))
+
+        if not to_refine:
+            break
+
+        # Estimate new range count: each refined range of duration D
+        # with bucket size S produces ceil(D/S) sub-ranges, replacing 1.
+        estimated_new = len(refined)
+        for i, smaller_secs in to_refine:
+            start, end, _ = refined[i]
+            duration = end - start
+            sub_count = -(-int(duration) // smaller_secs)  # ceil division
+            estimated_new += sub_count - 1  # replacing 1 range with sub_count
+        if estimated_new > max_ranges:
+            break
+
+        # Fire off all re-count RPCs in parallel with bounded concurrency
+        semaphore = asyncio.Semaphore(_MAX_CONCURRENT_COUNTS)
+
+        async def _recount(start: float, end: float, smaller_secs: int) -> list[tuple[float, float, int]]:
+            async with semaphore:
+                sub_req = api_pb2.AppCountLogsRequest(
+                    app_id=app_id,
+                    since=_seconds_to_timestamp(start),
+                    until=_seconds_to_timestamp(end),
+                    bucket_secs=smaller_secs,
+                    source=filters.source,
+                    function_id=filters.function_id,
+                    function_call_id=filters.function_call_id,
+                    task_id=filters.task_id,
+                    sandbox_id=filters.sandbox_id,
+                    search_text=filters.search_text,
+                )
+                sub_resp = await client.stub.AppCountLogs(sub_req)
+                sub_ranges = _buckets_to_ranges(list(sub_resp.buckets), smaller_secs)
+                # Clamp the last sub-range to the parent's end. When bucket_secs
+                # doesn't evenly divide the parent duration, the last bucket
+                # boundary overshoots (e.g. parent (0,30) with 20s buckets
+                # produces (20,40)), causing overlaps with sibling ranges.
+                if sub_ranges:
+                    s, _, c = sub_ranges[-1]
+                    sub_ranges[-1] = (s, min(s + smaller_secs, end), c)
+                return sub_ranges
+
+        refine_set = {i for i, _ in to_refine}
+        tasks = [_recount(refined[i][0], refined[i][1], s) for i, s in to_refine]
+        iterations += 1
+        sub_results = await TaskContext.gather(*tasks)
+
+        # Rebuild the list, splicing in sub-ranges for refined entries
+        result_iter = iter(sub_results)
+        new_refined: list[tuple[float, float, int]] = []
+        for i, r in enumerate(refined):
+            if i in refine_set:
+                new_refined.extend(next(result_iter))
+            else:
+                new_refined.append(r)
+
+        refined = new_refined
+
+    return refined
+
+
+async def _fetch_interval(
+    client: _Client,
+    app_id: str,
+    since: float,
+    until: float,
+    limit: int,
+    filters: LogsFilters,
+) -> list[api_pb2.TaskLogsBatch]:
+    """Fetch logs for a single time interval."""
+    req = api_pb2.AppFetchLogsRequest(
+        app_id=app_id,
+        since=_seconds_to_timestamp(since),
+        until=_seconds_to_timestamp(until),
+        limit=limit,
+        source=filters.source,
+        function_id=filters.function_id,
+        function_call_id=filters.function_call_id,
+        task_id=filters.task_id,
+        sandbox_id=filters.sandbox_id,
+        search_text=filters.search_text,
+    )
+    resp: api_pb2.AppFetchLogsResponse = await client.stub.AppFetchLogs(req)
+    return list(resp.batches)
+
+
+async def tail_logs(
+    client: _Client,
+    app_id: str,
+    n: int,
+    *,
+    since: Optional[datetime] = None,
+    until: Optional[datetime] = None,
+    filters: Optional[LogsFilters] = None,
+) -> AsyncGenerator[api_pb2.TaskLogsBatch]:
+    """Fetch up to `n` of the most recent log entries for an app.
+
+    When `since` is provided, it is used as a hard floor (no progressive
+    widening). When omitted, starts with a short lookback window and widens
+    until `n` results are returned or all windows are exhausted. `until`
+    defaults to now.
+
+    `n` must not exceed _FETCH_LIMIT.
+    """
+    if filters is None:
+        filters = LogsFilters()
+    if n > _FETCH_LIMIT:
+        raise LogsFetchError(f"--tail value must not exceed {_FETCH_LIMIT}.")
+
+    now = datetime.now(timezone.utc)
+
+    if since is not None and since.tzinfo is None:
+        raise ValueError("since must be timezone-aware")
+    if until is not None and until.tzinfo is None:
+        raise ValueError("until must be timezone-aware")
+
+    until_ts = _datetime_to_timestamp(until) if until else _datetime_to_timestamp(now)
+
+    if since is not None:
+        # Explicit floor — single fetch, no widening.
+        effective_until = until or now
+        if effective_until - since > _MAX_FETCH_RANGE:
+            raise LogsFetchError(f"Time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+        req = api_pb2.AppFetchLogsRequest(
+            app_id=app_id,
+            since=_datetime_to_timestamp(since),
+            until=until_ts,
+            limit=n,
+            source=filters.source,
+            function_id=filters.function_id,
+            function_call_id=filters.function_call_id,
+            task_id=filters.task_id,
+            sandbox_id=filters.sandbox_id,
+            search_text=filters.search_text,
+        )
+        resp = await client.stub.AppFetchLogs(req)
+        for batch in resp.batches:
+            yield batch
+        return
+
+    # No explicit since — progressively widen the lookback.
+    anchor = until or now
+    for lookback in _TAIL_LOOKBACKS:
+        lookback_since = anchor - lookback
+        req = api_pb2.AppFetchLogsRequest(
+            app_id=app_id,
+            since=_datetime_to_timestamp(lookback_since),
+            until=until_ts,
+            limit=n,
+            source=filters.source,
+            function_id=filters.function_id,
+            function_call_id=filters.function_call_id,
+            task_id=filters.task_id,
+            sandbox_id=filters.sandbox_id,
+            search_text=filters.search_text,
+        )
+        resp = await client.stub.AppFetchLogs(req)
+
+        total_items = sum(len(b.items) for b in resp.batches)
+        if total_items >= n or lookback == _TAIL_LOOKBACKS[-1]:
+            for batch in resp.batches:
+                yield batch
+            return
+
+
+async def fetch_logs(
+    client: _Client,
+    app_id: str,
+    since: datetime,
+    until: datetime,
+    *,
+    filters: Optional[LogsFilters] = None,
+) -> AsyncGenerator[api_pb2.TaskLogsBatch]:
+    """Fetch logs for an app over a time range using count-then-fetch strategy.
+
+    Yields TaskLogsBatch objects in chronological order.
+    """
+    if filters is None:
+        filters = LogsFilters()
+
+    if since.tzinfo is None:
+        raise ValueError("since must be timezone-aware")
+    if until.tzinfo is None:
+        raise ValueError("until must be timezone-aware")
+
+    if until - since > _MAX_FETCH_RANGE:
+        raise LogsFetchError(f"Time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+
+    # Phase 1: Count logs per bucket
+    bucket_secs = _pick_bucket_secs(since, until)
+    count_req = api_pb2.AppCountLogsRequest(
+        app_id=app_id,
+        since=_datetime_to_timestamp(since),
+        until=_datetime_to_timestamp(until),
+        bucket_secs=bucket_secs,
+        source=filters.source,
+        function_id=filters.function_id,
+        function_call_id=filters.function_call_id,
+        task_id=filters.task_id,
+        sandbox_id=filters.sandbox_id,
+        search_text=filters.search_text,
+    )
+    count_resp: api_pb2.AppCountLogsResponse = await client.stub.AppCountLogs(count_req)
+
+    ranges = _buckets_to_ranges(list(count_resp.buckets), bucket_secs)
+    total_logs = sum(count for _, _, count in ranges)
+    if total_logs == 0:
+        return
+
+    # Trim leading/trailing empty buckets so they don't consume refinement
+    # budget. Interior zeros are kept to prevent merging across gaps.
+    while ranges and ranges[0][2] == 0:
+        ranges.pop(0)
+    while ranges and ranges[-1][2] == 0:
+        ranges.pop()
+
+    # Phase 1b: Refine any ranges that exceed the per-fetch limit.
+    # Budget: at most _MAX_FETCHES intervals, each fetching up to _FETCH_LIMIT entries.
+    ranges = await _refine_dense_ranges(
+        client,
+        app_id,
+        ranges,
+        filters,
+        max_ranges=_MAX_FETCHES,
+        max_iterations=_MAX_REFINE_ITERATIONS,
+    )
+    fetch_error_message = "Too many logs to fetch in time range. Consider narrowing the range or adding filters."
+    # Check that all ranges fit within the per-fetch limit.
+    over_limit = [r for r in ranges if r[2] > _FETCH_LIMIT]
+    if over_limit:
+        raise LogsFetchError(fetch_error_message)
+
+    # Phase 2: Build intervals from non-empty ranges and fetch in parallel
+    since_secs = since.timestamp()
+    until_secs = until.timestamp()
+    intervals = _build_fetch_intervals(ranges)
+    # Clamp intervals to the requested time range. Bucket boundaries may
+    # extend beyond the user's since/until (e.g. an 86400s bucket could
+    # include up to a full extra day).
+    intervals = [(max(s, since_secs), min(u, until_secs)) for s, u in intervals]
+    intervals = [(s, u) for s, u in intervals if s < u]
+    if not intervals:
+        return
+
+    if len(intervals) > _MAX_FETCHES:
+        raise LogsFetchError(fetch_error_message)
+
+    # Fetch all intervals concurrently (bounded by semaphore), but yield
+    # results in interval order so logs stay chronological. Awaiting each
+    # task in sequence lets us stream batches to the caller as soon as all
+    # preceding intervals have completed.
+    semaphore = asyncio.Semaphore(_MAX_CONCURRENT_FETCHES)
+
+    async def _bounded_fetch(since_s: float, until_s: float) -> list[api_pb2.TaskLogsBatch]:
+        async with semaphore:
+            return await _fetch_interval(
+                client,
+                app_id,
+                since_s,
+                until_s,
+                _FETCH_LIMIT,
+                filters,
+            )
+
+    tasks = [asyncio.create_task(_bounded_fetch(s, u)) for s, u in intervals]
+
+    try:
+        for task in tasks:
+            for batch in await task:
+                yield batch
+    finally:
+        for task in tasks:
+            task.cancel()

modal/_output/manager.py

@@ -298,13 +298,31 @@ class OutputManager(ABC):
         ...
 
     @abstractmethod
-    async def put_log_content(self, log: "api_pb2.TaskLogs") -> None:
-        """Process and display log content.
+    async def put_streaming_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        """Process and display log content with immediate output.
+
+        Use this for streaming paths (--follow, image logs) where logs arrive
+        in real time and should be displayed immediately.
 
         Note: In RichOutputManager, log output is always displayed even when quiet mode
         is enabled. This is intentional - quiet mode suppresses progress indicators and
         status messages, but not actual log output from running functions/images.
         In contrast, DisabledOutputManager suppresses all output including logs.
+
+        prefix: optional string to prepend to each log line (e.g. object IDs).
+        """
+        ...
+
+    @abstractmethod
+    async def put_fetched_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        """Process and display log content with batched output.
+
+        Use this for bulk historical log fetching where thousands of entries
+        are processed in a tight loop. Output is buffered internally and
+        flushed periodically to avoid per-line stdout overhead. Call
+        flush_lines() after the loop to drain any remaining buffered output.
+
+        prefix: optional string to prepend to each log line (e.g. object IDs).
         """
         ...
 
@@ -382,7 +400,7 @@ class OutputManager(ABC):
         - All print() output is suppressed, including stderr
         - Progress indicators (spinners, progress bars) are suppressed
         - Warnings (via show_warning) are still displayed
-        - Log output (via put_log_content) is still displayed
+        - Log output (via put_streaming_log) is still displayed
         - Interactive/raw PTY content (via put_pty_content) is still forwarded to stdout
         - Error output (via print_error) is still displayed
 
@@ -516,7 +534,10 @@ class DisabledOutputManager(OutputManager):
     ) -> None:
         pass
 
-    async def put_log_content(self, log: "api_pb2.TaskLogs") -> None:
+    async def put_streaming_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        pass
+
+    async def put_fetched_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
         pass
 
     def flush_lines(self) -> None:

modal/_output/pty.py

@@ -64,6 +64,30 @@ async def stream_pty_shell_input(client: "_Client", exec_id: str, finish_event:
         await finish_event.wait()
 
 
+_PREFIX_FIELD_GETTERS = {
+    "fu": lambda batch, log: batch.function_id,
+    "ta": lambda batch, log: batch.task_id,
+    "fc": lambda batch, log: log.function_call_id,
+}
+
+
+def _build_log_prefix(batch: api_pb2.TaskLogsBatch, log: api_pb2.TaskLogs, prefix_fields: list[str]) -> str:
+    """Build a prefix string from batch/log fields based on requested prefix types.
+
+    The order of prefix_fields controls the order of the output.
+    """
+    if not prefix_fields:
+        return ""
+    parts = []
+    for field in prefix_fields:
+        getter = _PREFIX_FIELD_GETTERS.get(field)
+        if getter:
+            value = getter(batch, log)
+            if value:
+                parts.append(value)
+    return " ".join(parts)
+
+
 async def get_app_logs_loop(
     client: "_Client",
     output_mgr: "OutputManager",
@@ -71,8 +95,15 @@ async def get_app_logs_loop(
     task_id: Optional[str] = None,
     sandbox_id: Optional[str] = None,
     follow: bool = True,
+    last_entry_id: str = "",
+    prefix_fields: Optional[list[str]] = None,
+    file_descriptor: "api_pb2.FileDescriptor.ValueType" = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED,
+    function_id: str = "",
+    function_call_id: str = "",
+    search_text: str = "",
 ):
-    last_log_batch_entry_id = ""
+    last_log_batch_entry_id = last_entry_id
+    _prefixes = prefix_fields or []
 
     pty_shell_finish_event: Optional[asyncio.Event] = None
     pty_shell_task_id: Optional[str] = None
@@ -112,10 +143,15 @@ async def get_app_logs_loop(
             else:  # Ensure forward-compatible with new types.
                 logger.debug(f"Received unrecognized progress type: {log.task_progress.progress_type}")
         elif log.data:
+            # Client-side search filter for Redis streaming (AppGetLogs
+            # doesn't support server-side search)
+            if search_text and search_text not in log.data:
+                return
             if pty_shell_finish_event:
                 await output_mgr.put_pty_content(log)
             else:
-                await output_mgr.put_log_content(log)
+                log_prefix = _build_log_prefix(log_batch, log, _prefixes)
+                await output_mgr.put_streaming_log(log, prefix=log_prefix)
 
     async def _get_logs():
         nonlocal last_log_batch_entry_id
@@ -127,6 +163,9 @@ async def get_app_logs_loop(
             sandbox_id=sandbox_id or "",
             timeout=55 if follow else 0,
             last_entry_id=last_log_batch_entry_id,
+            file_descriptor=file_descriptor,
+            function_id=function_id,
+            function_call_id=function_call_id,
         )
         log_batch: api_pb2.TaskLogsBatch
         async for log_batch in client.stub.AppGetLogs.unary_stream(request):

modal/_output/rich.py

@@ -10,12 +10,13 @@ from __future__ import annotations
 
 import contextlib
 import functools
+import io
 import platform
 import re
-from collections.abc import Generator
+import sys
 from datetime import timedelta
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Callable, Generator, NamedTuple
 
 from rich.console import Console, Group, RenderableType
 from rich.live import Live
@@ -96,18 +97,36 @@ class LineBufferedOutput:
     def __init__(self, callback: Callable[[str], None], show_timestamps: bool):
         self._callback = callback
         self._buf = ""
+        self._buf_prefix = ""
         self._show_timestamps = show_timestamps
 
-    def write(self, log: api_pb2.TaskLogs):
+    def write(self, log: api_pb2.TaskLogs, prefix: str = ""):
+        line_prefix = ""
+        if self._show_timestamps:
+            ts_str = timestamp_to_localized_str(log.timestamp)
+            if ts_str:
+                line_prefix = f"{ts_str} "
+        if prefix:
+            line_prefix = f"{line_prefix}{prefix} "
+
+        # If the new prefix differs from the buffered remainder's prefix,
+        # flush the old remainder as its own line so it isn't emitted under
+        # the wrong prefix. This is rare — it means a previous log entry
+        # wrote partial output without a trailing newline, and a log from a
+        # different source arrived on the same fd.
+        if self._buf and line_prefix != self._buf_prefix:
+            self._callback(f"{self._buf_prefix}{self._buf}\n")
+            self._buf = ""
+
         chunks = self.LINE_REGEX.split(self._buf + log.data)
 
         # re.split("(<exp>)") returns the matched groups, and also the separators.
         # e.g. re.split("(+)", "a+b") returns ["a", "+", "b"].
         # This means that chunks is guaranteed to be odd in length.
 
-        if self._show_timestamps:
+        if line_prefix:
             for i in range(0, len(chunks) - 1, 2):
-                chunks[i] = f"{timestamp_to_localized_str(log.timestamp)} {chunks[i]}"
+                chunks[i] = f"{line_prefix}{chunks[i]}"
 
         completed_lines = "".join(chunks[:-1])
         remainder = chunks[-1]
@@ -123,14 +142,16 @@ class LineBufferedOutput:
 
         self._callback(completed_lines)
         self._buf = remainder
+        self._buf_prefix = line_prefix
 
     def flush(self):
         pass
 
     def finalize(self):
         if self._buf:
-            self._callback(self._buf)
+            self._callback(f"{self._buf_prefix}{self._buf}")
             self._buf = ""
+            self._buf_prefix = ""
 
 
 class _RichStatusContext(StatusContext):
@@ -180,6 +201,22 @@ class RichStatusRow(StatusRow):
             self._step_node.label = f"🔨 {message}"
 
 
+_LOG_FLUSH_THRESHOLD = 32768  # 32KB — flush batched log output roughly every ~400 lines
+
+
+class AnsiColor(NamedTuple):
+    name: str
+    code: str
+
+
+_FD_COLORS: dict[int, AnsiColor] = {
+    api_pb2.FILE_DESCRIPTOR_STDOUT: AnsiColor("blue", "\033[34m"),
+    api_pb2.FILE_DESCRIPTOR_STDERR: AnsiColor("red", "\033[31m"),
+    api_pb2.FILE_DESCRIPTOR_INFO: AnsiColor("yellow", "\033[33m"),
+}
+_ANSI_RESET = "\033[0m"
+
+
 class RichOutputManager(OutputManager):
     """Rich-based implementation of OutputManager.
 
@@ -195,7 +232,9 @@ class RichOutputManager(OutputManager):
     _function_progress: Progress | None
     _function_queueing_progress: Progress | None
     _snapshot_progress: Progress | None
-    _line_buffers: dict[int, LineBufferedOutput]
+    _line_buffers: dict[tuple[int, str], LineBufferedOutput]
+    _log_buffer: io.StringIO
+    _use_ansi_color: bool
     _status_spinner: Spinner | None
     _app_page_url: str | None
     __show_image_logs: bool
@@ -228,6 +267,9 @@ class RichOutputManager(OutputManager):
         self._function_queueing_progress = None
         self._snapshot_progress = None
         self._line_buffers = {}
+        self._log_buffer = io.StringIO()
+        # Respect Rich's color detection (TTY, NO_COLOR, FORCE_COLOR, etc.)
+        self._use_ansi_color = self._console.color_system is not None and not self._console.no_color
         self._status_spinner: Spinner | None = None
         self._app_page_url = None
         self.__show_image_logs = False
@@ -453,17 +495,27 @@ class RichOutputManager(OutputManager):
 
         return update_counts
 
-    def _print_log(self, fd: int, data: str) -> None:
-        if fd == api_pb2.FILE_DESCRIPTOR_STDOUT:
-            style = "blue"
-        elif fd == api_pb2.FILE_DESCRIPTOR_STDERR:
-            style = "red"
-        elif fd == api_pb2.FILE_DESCRIPTOR_INFO:
-            style = "yellow"
-        else:
-            raise Exception(f"Weird file descriptor {fd} for log output")
-
-        self._console.out(data, style=style, end="")
+    def _styled_log_text(self, fd: int, data: str) -> str:
+        """Wrap log text in ANSI color codes, bypassing Rich's rendering pipeline."""
+        if self._use_ansi_color:
+            color = _FD_COLORS.get(fd)
+            if color is None:
+                logger.debug(f"Unknown file descriptor {fd} as log_source")
+                return data
+            return f"{color.code}{data}{_ANSI_RESET}"
+        return data
+
+    def _print_log_buffered(self, fd: int, data: str) -> None:
+        """Append styled log text to the output buffer for batched flushing."""
+        self._log_buffer.write(self._styled_log_text(fd, data))
+
+    def _flush_log_buffer(self) -> None:
+        """Write buffered log output to stdout."""
+        if self._log_buffer.tell() > 0:
+            sys.stdout.write(self._log_buffer.getvalue())
+            sys.stdout.flush()
+            self._log_buffer.seek(0)
+            self._log_buffer.truncate()
 
     def update_app_page_url(self, app_page_url: str) -> None:
         self._app_page_url = app_page_url
@@ -542,22 +594,56 @@ class RichOutputManager(OutputManager):
             progress_task_id = self._function_queueing_progress_bar.add_task(task_desc, start=True, total=None)
             self._task_progress_items[task_key] = progress_task_id
 
-    async def put_log_content(self, log: api_pb2.TaskLogs) -> None:
-        """Process and display log content.
+    def _get_line_buffer(self, fd: int, mode: str, callback: Callable[[str], None]) -> LineBufferedOutput:
+        """Get or create a LineBufferedOutput for the given file descriptor and mode.
+
+        mode should be "streaming" or "fetched" — this ensures the two output
+        paths maintain separate buffers even for the same file descriptor.
+        """
+        key = (fd, mode)
+        stream = self._line_buffers.get(key)
+        if stream is None:
+            stream = LineBufferedOutput(callback, self._show_timestamps)
+            self._line_buffers[key] = stream
+        return stream
+
+    def _console_print_log(self, fd: int, data: str) -> None:
+        """Write log text via Rich Console, cooperating with any active Live context."""
+        color = _FD_COLORS.get(fd)
+        if color is None:
+            logger.debug(f"Unknown file descriptor {fd} as log_source")
+            color = AnsiColor("white", "\033[37m")
+        self._console.out(data, style=color.name, end="")
+
+    async def put_streaming_log(self, log: api_pb2.TaskLogs, prefix: str = "") -> None:
+        """Process and display log content with immediate output.
+
+        Uses Rich Console.out() which cooperates with any active Live context
+        (e.g. the status spinner in --follow mode).
 
         Note: Log output is always displayed even when quiet mode is enabled.
         Quiet mode suppresses progress indicators and status messages, but not
         actual log output from running functions/images.
         """
-        stream = self._line_buffers.get(log.file_descriptor)
-        if stream is None:
-            stream = LineBufferedOutput(functools.partial(self._print_log, log.file_descriptor), self._show_timestamps)
-            self._line_buffers[log.file_descriptor] = stream
-        stream.write(log)
+        callback = functools.partial(self._console_print_log, log.file_descriptor)
+        self._get_line_buffer(log.file_descriptor, "streaming", callback).write(log, prefix=prefix)
+
+    async def put_fetched_log(self, log: api_pb2.TaskLogs, prefix: str = "") -> None:
+        """Process and display log content with batched output.
+
+        Bypasses Rich's rendering pipeline and buffers ANSI-colored text,
+        flushing periodically. Use this for bulk historical log fetching
+        where thousands of entries are processed in a tight loop.
+        """
+        callback = functools.partial(self._print_log_buffered, log.file_descriptor)
+        self._get_line_buffer(log.file_descriptor, "fetched", callback).write(log, prefix=prefix)
+        if self._log_buffer.tell() >= _LOG_FLUSH_THRESHOLD:
+            self._flush_log_buffer()
 
     def flush_lines(self) -> None:
         for stream in self._line_buffers.values():
             stream.finalize()
+        self._flush_log_buffer()
 
     @contextlib.contextmanager
     def transfer_progress(self, type: str) -> Generator[TransferProgressContext, None, None]:

modal/cli/app.py

@@ -1,5 +1,6 @@
 # Copyright Modal Labs 2022
 import re
+from datetime import datetime, timedelta, timezone
 from typing import Optional, Union
 
 import rich
@@ -16,8 +17,9 @@ from modal.client import _Client
 from modal.environments import ensure_env
 from modal_proto import api_pb2
 
-from .._utils.time_utils import timestamp_to_localized_str
-from .utils import ENV_OPTION, display_table, get_app_id_from_name, stream_app_logs
+from .._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
+from .._utils.time_utils import locale_tz, timestamp_to_localized_str
+from .utils import ENV_OPTION, display_table, fetch_app_logs, get_app_id_from_name, stream_app_logs, tail_app_logs
 
 APP_IDENTIFIER = Argument("", help="App name or ID")
 NAME_OPTION = typer.Option("", "-n", "--name", help="Deprecated: Pass App name as a positional argument")
@@ -81,33 +83,206 @@ async def list_(env: Optional[str] = ENV_OPTION, 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: Optional[str], default: datetime) -> datetime:
+    """Parse a time argument that can be a relative duration (e.g. '2h', '30m') or ISO 8601 datetime.
+
+    Naive datetime values are interpreted in the user's local timezone.
+    Relative durations are always UTC-relative.
+    """
+    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 ISO 8601 datetime
+    try:
+        dt = datetime.fromisoformat(value)
+        if dt.tzinfo is None:
+            # Interpret naive datetimes in the user's local timezone
+            dt = dt.replace(tzinfo=locale_tz())
+        return dt
+    except ValueError:
+        raise UsageError(f"Invalid time format: '{value}'. Use a relative duration (e.g. '2h') or ISO 8601 datetime.")
+
+
+_DEFAULT_LOGS_TAIL = 100
+
+
+_SOURCE_OPTIONS = {
+    "stdout": api_pb2.FILE_DESCRIPTOR_STDOUT,
+    "stderr": api_pb2.FILE_DESCRIPTOR_STDERR,
+    "system": api_pb2.FILE_DESCRIPTOR_INFO,
+}
+
+
 @app_cli.command("logs", no_args_is_help=True)
 def logs(
     app_identifier: str = APP_IDENTIFIER,
     follow: bool = typer.Option(False, "-f", "--follow", help="Stream log output until App stops"),
-    timestamps: bool = typer.Option(False, "--timestamps", help="Show timestamps for each log line"),
+    since: Optional[str] = typer.Option(
+        None,
+        "--since",
+        help=(
+            "Start of time range. Accepts ISO 8601 datetime or relative time, e.g. '1d' (1 day ago), '2h', '30m', etc."
+        ),
+    ),
+    until: Optional[str] = typer.Option(
+        None,
+        "--until",
+        help="End of time range; accepts same argument types as --since",
+    ),
+    search: Optional[str] = typer.Option(None, "--search", help="Filter by search text"),
+    function_id: Optional[str] = typer.Option("", "--function", help="Filter by Function ID (fu-*)"),
+    function_call_id: Optional[str] = typer.Option("", "--function-call", help="Filter by FunctionCall ID (fc-*)"),
+    source: Optional[str] = typer.Option(
+        None, "--source", "-s", help="Filter by source: 'stdout', 'stderr', or 'system'"
+    ),
+    tail: Optional[int] = typer.Option(None, "--tail", "-n", help="Show only the last N log entries"),
+    timestamps: bool = typer.Option(False, "--timestamps", help="Prefix each line with its timestamp"),
+    show_function_id: bool = typer.Option(False, "--show-function-id", help="Prefix each line with its Function ID"),
+    show_function_call_id: bool = typer.Option(
+        False, "--show-function-call-id", help="Prefix each line with its FunctionCall ID"
+    ),
+    show_container_id: bool = typer.Option(False, "--show-container-id", help="Prefix each line with its Container ID"),
     *,
     env: Optional[str] = ENV_OPTION,
 ):
-    """Show App logs, streaming while active.
+    """Fetch or stream App logs.
+
+    By default, this command fetches the last 100 log entries and exits. Use ``-f`` to
+    live-stream logs from a running App instead. Fetch and follow are mutually exclusive.
 
     **Examples:**
 
-    Get the logs based on an app ID:
+    Get recent logs based on an app ID:
 
     ```
-    modal app logs ap-123456
+    modal app logs ap-123456 --tail 100
     ```
 
-    Get the logs for a currently deployed App based on its name:
+    Get recent logs for a currently deployed App based on its name:
 
     ```
     modal app logs my-app
     ```
 
+    Follow (stream) logs from a running App:
+
+    ```
+    modal app logs my-app -f
+    ```
+
+    Fetch logs from the last 2 hours:
+
+    ```
+    modal app logs my-app --since 2h
+    ```
+
+    Fetch logs in a specific time range:
+
+    ```
+    modal app logs my-app --since 2026-03-01T05:00:00 --until 2026-03-01T08:00:00
+    ```
+
+    Filter the logs by source and function:
+
+    ```
+    modal app logs my-app --source stderr --function fu-abc123
+    ```
+
+    Include timestamps along with Function and Container IDs on each line:
+
+    ```
+    modal app logs my-app --timestamps --show-function-id --show-container-id
+    ```
+
     """
+    if not app_identifier:
+        raise UsageError("Either an App ID or name must be provided.")
+
+    if follow and (since or until or tail):
+        raise UsageError("--follow cannot be combined with --since, --until, or --tail.")
+
+    if tail is not None and tail <= 0:
+        raise UsageError("--tail value must be positive.")
+
+    if tail is not None and tail > _FETCH_LIMIT:
+        raise UsageError(f"--tail value must not exceed {_FETCH_LIMIT}.")
+
     app_id = get_app_id(app_identifier, env)
-    stream_app_logs(app_id, show_timestamps=timestamps, follow=follow)
+
+    if source is not None:
+        if source not in _SOURCE_OPTIONS:
+            raise UsageError(f"Invalid source: '{source}'. Must be 'stdout', 'stderr', or 'system'.")
+        source_fd = _SOURCE_OPTIONS[source]
+    else:
+        source_fd = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED
+
+    prefix_fields: list[str] = []
+    if show_function_id:
+        prefix_fields.append("fu")
+    if show_function_call_id:
+        prefix_fields.append("fc")
+    if show_container_id:
+        prefix_fields.append("ta")
+
+    log_filters = LogsFilters(
+        source=source_fd,
+        function_id=function_id or "",
+        function_call_id=function_call_id or "",
+        search_text=search or "",
+    )
+
+    if follow:
+        stream_app_logs(
+            app_id,
+            show_timestamps=timestamps,
+            follow=True,
+            prefix_fields=prefix_fields,
+            filters=log_filters,
+        )
+    else:
+        now = datetime.now(timezone.utc)
+        since_dt = _parse_time_arg(since, default=now) if since else None
+        until_dt = _parse_time_arg(until, default=now) if until else None
+
+        if since_dt is not None and until_dt is not None and since_dt >= until_dt:
+            raise UsageError("--since must be before --until.")
+
+        if since_dt is not None:
+            effective_until = until_dt or now
+            if effective_until - since_dt > _MAX_FETCH_RANGE:
+                raise UsageError(f"Log fetch time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+
+        if since and tail is None:
+            # Range mode: --since without --tail fetches everything in the range.
+            fetch_app_logs(
+                app_id,
+                since_dt,
+                until_dt or now,
+                show_timestamps=timestamps,
+                prefix_fields=prefix_fields,
+                filters=log_filters,
+            )
+        else:
+            # Tail mode: single fetch with limit.
+            # --since is a hard floor, --until shifts the anchor.
+            effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
+            tail_app_logs(
+                app_id,
+                effective_tail,
+                show_timestamps=timestamps,
+                since=since_dt,
+                until=until_dt,
+                prefix_fields=prefix_fields,
+                filters=log_filters,
+            )
 
 
 @app_cli.command("rollback", no_args_is_help=True, context_settings={"ignore_unknown_options": True})

modal/cli/utils.py

@@ -4,6 +4,7 @@ import io
 from collections.abc import Sequence
 from contextlib import nullcontext
 from csv import writer as csv_writer
+from datetime import datetime
 from json import dumps
 from typing import Optional, Union
 
@@ -13,7 +14,8 @@ from rich.text import Text
 
 from modal_proto import api_pb2
 
-from .._output.pty import get_app_logs_loop
+from .._logs import LogsFilters, fetch_logs, tail_logs
+from .._output.pty import _build_log_prefix, get_app_logs_loop
 from .._utils.async_utils import synchronizer
 from ..client import _Client
 from ..environments import ensure_env
@@ -29,7 +31,11 @@ async def stream_app_logs(
     app_logs_url: Optional[str] = None,
     show_timestamps: bool = False,
     follow: bool = False,
+    prefix_fields: Optional[list[str]] = None,
+    filters: Optional[LogsFilters] = None,
 ):
+    if filters is None:
+        filters = LogsFilters()
     client = await _Client.from_env()
     output_mgr = OutputManager.get()
     output_mgr.set_timestamps(show_timestamps)
@@ -52,11 +58,73 @@ async def stream_app_logs(
                 task_id=task_id,
                 sandbox_id=sandbox_id,
                 follow=follow,
+                prefix_fields=prefix_fields or [],
+                file_descriptor=filters.source,
+                function_id=filters.function_id,
+                function_call_id=filters.function_call_id,
+                search_text=filters.search_text,
             )
     except (asyncio.CancelledError, KeyboardInterrupt):
         pass
 
 
+async def _drain_batches(output_mgr, batches, prefixes, search_text=""):
+    """Iterate over log batches and display them via the output manager."""
+    last_data = ""
+    async for batch in batches:
+        for log in batch.items:
+            if log.data:
+                # Search results may lack trailing newlines
+                if search_text and not log.data.endswith("\n"):
+                    log.data += "\n"
+                last_data = log.data
+                log_prefix = _build_log_prefix(batch, log, prefixes)
+                await output_mgr.put_fetched_log(log, prefix=log_prefix)
+    output_mgr.flush_lines()
+    # Ensure the terminal prompt starts on a new line
+    if last_data and not last_data.endswith("\n"):
+        output_mgr.print("")
+
+
+@synchronizer.create_blocking
+async def tail_app_logs(
+    app_id: str,
+    n: int,
+    show_timestamps: bool = False,
+    since: Optional[datetime] = None,
+    until: Optional[datetime] = None,
+    prefix_fields: Optional[list[str]] = None,
+    filters: Optional[LogsFilters] = None,
+):
+    """Fetch up to the last n log entries for an app."""
+    if filters is None:
+        filters = LogsFilters()
+    client = await _Client.from_env()
+    output_mgr = OutputManager.get()
+    output_mgr.set_timestamps(show_timestamps)
+    batches = tail_logs(client, app_id, n, since=since, until=until, filters=filters)
+    await _drain_batches(output_mgr, batches, prefix_fields or [], filters.search_text)
+
+
+@synchronizer.create_blocking
+async def fetch_app_logs(
+    app_id: str,
+    since: datetime,
+    until: datetime,
+    show_timestamps: bool = False,
+    prefix_fields: Optional[list[str]] = None,
+    filters: Optional[LogsFilters] = None,
+):
+    """Fetch historical logs for an app over a time range."""
+    if filters is None:
+        filters = LogsFilters()
+    client = await _Client.from_env()
+    output_mgr = OutputManager.get()
+    output_mgr.set_timestamps(show_timestamps)
+    batches = fetch_logs(client, app_id, since, until, filters=filters)
+    await _drain_batches(output_mgr, batches, prefix_fields or [], filters.search_text)
+
+
 @synchronizer.create_blocking
 async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_Client] = None) -> str:
     if client is None:

modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev6",
+        version: str = "1.3.6.dev8",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -171,7 +171,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev6",
+        version: str = "1.3.6.dev8",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

modal/exception.py

@@ -206,6 +206,10 @@ class VolumeUploadTimeoutError(TimeoutError):
     """Raised when a Volume upload times out."""
 
 
+class LogsFetchError(Error):
+    """Raised when trying to fetch too many logs."""
+
+
 class InteractiveTimeoutError(TimeoutError):
     """Raised when interactive frontends time out while trying to connect to a container."""
 

modal/image.py

@@ -388,7 +388,7 @@ async def _image_await_build_result(image_id: str, client: _Client) -> api_pb2.I
                     assert task_log.task_progress.progress_type == api_pb2.IMAGE_SNAPSHOT_UPLOAD
                     output_mgr.update_snapshot_progress(image_id, task_log.task_progress)
                 elif task_log.data:
-                    await output_mgr.put_log_content(task_log)
+                    await output_mgr.put_streaming_log(task_log)
         OutputManager.get().flush_lines()
 
     # Handle up to n exceptions while fetching logs

{modal-1.3.6.dev6.dist-info → modal-1.3.6.dev8.dist-info}/METADATA

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

{modal-1.3.6.dev6.dist-info → modal-1.3.6.dev8.dist-info}/RECORD

@@ -9,6 +9,7 @@ modal/_grpc_client.py,sha256=G8gWQXChtsuRgyXK9kcPiPNYXOYbl_m9Bz2AVBJb-zs,6924
 modal/_ipython.py,sha256=Bu9fc3hm3xt2O47qLe_d-Mu2jS81LwMsmXNJ1sawBA0,575
 modal/_load_context.py,sha256=DvfOWNTevEmHqdlu0-AeO_03JChrmAjoupgppPVW2Pc,4867
 modal/_location.py,sha256=joiX-0ZeutEUDTrrqLF1GHXCdVLF-rHzstocbMcd_-k,366
+modal/_logs.py,sha256=hQ09VfJiB3ic1QvAm85W7mJ3usoWLiZrlkM10j-B1qA,16966
 modal/_object.py,sha256=144YrNnTG77vK_PAHRU9GFxHBOlt2PWFgTUXpgX4BQk,14315
 modal/_partial_function.py,sha256=6HsV3xqwzmaTgytZ-CL5sNKIttxNjVQv_QgUF-sR20E,37489
 modal/_resolver.py,sha256=u9GdlHo3Ul_40B97LH0vSrjtEJB__WeRf-Oo79vSmPE,5516
@@ -25,7 +26,7 @@ modal/app.pyi,sha256=8lv2eLKP-y3BLT1irRnzdULSD45OgU4_VbCIYEy_Ic0,56387
 modal/billing.py,sha256=B2zXa7KeMnpqi2AQINycEk-KSXVYaLTTTAQTtuf2Gfs,257
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=-IxazxLhdkNFAHS2AP2FpyTVpCDVR58RF6ecSVV59r0,14862
-modal/client.pyi,sha256=cCVbhdJo__FcT48OAE1vDkMTJsSVELD6x_ztE6wuib4,14930
+modal/client.pyi,sha256=LLr14WrQldwtchJ1O4Uxs-xsxuoMtZuWI-BB4qPvhls,14930
 modal/cloud_bucket_mount.py,sha256=KkaJVy5vpO_u2NtDYtv1JM-M3y4J0UtWBapTDKpQRcA,6034
 modal/cloud_bucket_mount.pyi,sha256=mGDeEd1XvxGpCE6O5jRBSfIvMXvZ5AtIybea5k-0w9w,7560
 modal/cls.py,sha256=ozx5ZVGyG6w5SQ1ouj9Y6M3yPtnpL9PfblnmqFzf694,42338
@@ -37,14 +38,14 @@ modal/dict.py,sha256=dOzPHAckMo5MgwlQckSTLv-TCvzOwM8AXbsehY48_OI,24102
 modal/dict.pyi,sha256=Cbyer90PA_H-S-PCbj9ZjvD6KknEsnH7CWDbcfy_d0Y,34085
 modal/environments.py,sha256=wMiMNpPkvIl_BdxRb81CY9Djzhczp_y4GEYKWp0JyBc,6135
 modal/environments.pyi,sha256=bMIxvwahckgaolGD3-hP2iovRHDXewvgbVs_nx4ze0o,3808
-modal/exception.py,sha256=YijJMGg2_dpr541d0_qYORZNhNsWVe7Djg8Lx5DBDOg,11363
+modal/exception.py,sha256=AMvcFzlJxiFqaYe2An7fNgC4_2VFLUoNUDxr6ODwVkU,11447
 modal/file_io.py,sha256=AKTaKR4y2JO1vsmJ8tRxMhgJtHmtb-TCe1ZZYDte-w4,22221
 modal/file_io.pyi,sha256=DPaq0BhySaiCX3g56QHhyIMdU1izbfWsjpSp30JoJUU,15745
 modal/file_pattern_matcher.py,sha256=A_Kdkej6q7YQyhM_2-BvpFmPqJ0oHb54B6yf9VqvPVE,8116
 modal/functions.py,sha256=kcNHvqeGBxPI7Cgd57NIBBghkfbeFJzXO44WW0jSmao,325
 modal/functions.pyi,sha256=jnC5QZvfs_yPPwXmEoHO16xUXzX448aP6eWawVmeGko,36498
 modal/gpu.py,sha256=JW8C1hIObmXGduXWyJZysvAsLxyBEiaCmtnUAGFqh-8,6852
-modal/image.py,sha256=-ssy6tDTwCB_y8Bu-ULsXYArceXdQiEWEaTJZzJ9l9I,109358
+modal/image.py,sha256=zgCZy0OZz010fRdlzOscD-cTbC-cCTT7mRWaANJRW7Y,109360
 modal/image.pyi,sha256=QAY8F2e2kkfQHOQnT2t4B1I-VbzvbNjksJHivx-ZA4k,78536
 modal/io_streams.py,sha256=JcYbvvjMZFugv53yHc9Id0N4nIvDMwV63ZtnN1bPmZc,30940
 modal/io_streams.pyi,sha256=aBxCcbHTprL08FLvPlkzu4bypCTT7xUdelNe5kc7OZY,18506
@@ -88,9 +89,9 @@ modal/token_flow.pyi,sha256=5zdXJ5SLLHM4j6xSPuEvnpSeEJBbzE6NkSX-MSyE5wM,2282
 modal/volume.py,sha256=W55RPwGQfSeuZjZEyslsCtLnK-WOFTaBJm9jMYWVOYw,55699
 modal/volume.pyi,sha256=34G4oA5WUL5Bs0kDlniUMuE_uWsxzbr9hLJFrY77yIo,56014
 modal/_output/__init__.py,sha256=xtGN6SPv2zvByrJ32JPao0yJKpxyCIZ-2JMTScrisuQ,28
-modal/_output/manager.py,sha256=sEi1udrEkJ7AIbuDtT2lS578uBimVyLxjzaALhDXoho,17204
-modal/_output/pty.py,sha256=hNfj7yHqgPCVV8oRrs9vLET4vdz4uE5Oo2OZc9rWTMw,8429
-modal/_output/rich.py,sha256=lnNvJUJZv56obSN-8_pqj5jYA7OIImEE9qpWRAP3Uw8,28100
+modal/_output/manager.py,sha256=8JGUm8S1PfiibvyI1t_pcniktZbe8KAV1TvLtoZ80rk,18161
+modal/_output/pty.py,sha256=AAxJsCm4__HCZL2AoPzZgii5zoNH-ldTSTiCX0Zfwi8,9888
+modal/_output/rich.py,sha256=5pzIxJqlJSc1Fn02KnQq3VodslCtvo8dVpYitd85L0U,31920
 modal/_output/status.py,sha256=xk3sksl8bOftfnJSGz57IFDWtpM3YPJze-IzYaKT9DY,4520
 modal/_runtime/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_runtime/asgi.py,sha256=kaSjq_3bnWogx0YF24y1PscArt6Lx5INHnU9YIofg7A,22613
@@ -144,7 +145,7 @@ modal/builder/base-images.json,sha256=9zgY2-a2U_iEBBe60VNLQvErJQosRhQuXXRqcG6mHG
 modal/cli/__init__.py,sha256=6FRleWQxBDT19y7OayO4lBOzuL6Bs9r0rLINYYYbHwQ,769
 modal/cli/_download.py,sha256=5PQL3tkTJkG-Wb6I0vxfHY4L8kUzd4Fy83jlT6vh9Og,5062
 modal/cli/_traceback.py,sha256=fkqKcf4a6sBonha32NmBqGu5G_wqUVNBDpCcY94Hro0,6006
-modal/cli/app.py,sha256=yt5_49FU1urQWCesdvAcIcYExtCh3s-kqO7mzUZOgzA,8657
+modal/cli/app.py,sha256=3EZ4PgevioGq9ZvKLya2tKyCKiYS0Bv0kedrGlVW0-g,14958
 modal/cli/billing.py,sha256=9Gj1H_Y8ziRAupJj90XhnPOw6nBMQfGU_Ys_ImheLYk,5690
 modal/cli/changelog.py,sha256=Ilzy1_3xF3y49w-_nwQkEVjoCupwdht7UuBrfV53nT0,5686
 modal/cli/cluster.py,sha256=FdCe4a0I_o9dT6Vi3r3k-19D64fOGEWFaPYFvBlnTBE,3337
@@ -164,7 +165,7 @@ modal/cli/secret.py,sha256=yBpjzzkbA2dNb_Q_2qqltMvCfhzUxDH7-xehLiqrvhI,8061
 modal/cli/selector.py,sha256=2P4fAgvntNLBJaMjZdDHHopCSoefHKpCMfKGzXzk9jc,4178
 modal/cli/shell.py,sha256=L5Dw8yeuu9-f6vNlBGbUT4oh9AVSK4GuB5J6m6vYLBk,12613
 modal/cli/token.py,sha256=KIEOgHJ-k1t2h6tolBmQJSSOJlpU3kvmH_IKQzaHhig,4098
-modal/cli/utils.py,sha256=sTpL7q0k8GOhg6mFSizyzliuoI01CpEIDLNDvnogvXg,3850
+modal/cli/utils.py,sha256=aLTpttgH2lkOAC6HRtaAMCIKgo-zluvC_d-yQ3gsrz4,6462
 modal/cli/volume.py,sha256=Tp97ekMTEHT0NXwgyEudO8yIZ75OGOfjIfH44WS5r9Y,11026
 modal/cli/programs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal/cli/programs/run_jupyter.py,sha256=IJw8nds8Cjl9j4dxBqMGxhz-bIyVX0kle7jbt8HFOhM,2688
@@ -173,7 +174,7 @@ modal/experimental/__init__.py,sha256=4UyAPlExXYM0tJH7s6WSDt2dIfSVXvzARkRLsLMyuq
 modal/experimental/flash.py,sha256=ATGhVO8AleJ-TOe2PGolI5T7zfCEtj0kl_ivMPp7Rqg,33362
 modal/experimental/flash.pyi,sha256=R4h2nQl7-oiwqq_twCp0YqID_LnPjPGqxywXvxbiLIk,17011
 modal/experimental/ipython.py,sha256=TrCfmol9LGsRZMeDoeMPx3Hv3BFqQhYnmD_iH0pqdhk,2904
-modal-1.3.6.dev6.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-1.3.6.dev8.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=5sVABw4uGUqPXjcWT0Nqjkpe5KLs89C3tFnla58-D0M,3756
 modal_docs/gen_cli_docs_main.py,sha256=UPGr7O1DYTIRLwfINe2rbdh89J3cPVTU1OWL-SjxnOQ,198
@@ -195,10 +196,10 @@ modal_proto/task_command_router_pb2.py,sha256=uSSR8Y9Yp07cIL60ds7__wUr5rj1uL2CQY
 modal_proto/task_command_router_pb2.pyi,sha256=utNwipYgMZUEUuWBE7sJ5cNjRctozHKPKDRpLy6cPLM,25667
 modal_proto/task_command_router_pb2_grpc.py,sha256=YoinPeLc-uwFShig8gE0MluOi6n-qqJZQ3YvnKwKUz8,23194
 modal_proto/task_command_router_pb2_grpc.pyi,sha256=VUSE5l1O6ATPT8Wbj4M3faMiIy5vFxSoS5ZlKfTEpHc,7449
-modal_version/__init__.py,sha256=Tx1QZEugcyev19-iVVlRqrvkmoOpDp0QVPwiFC6pwDo,120
+modal_version/__init__.py,sha256=TQcAaacjQbH68W3yWBnqkf13UFtTR4NEtj4t4iaD0kM,120
 modal_version/__main__.py,sha256=nLUbubxKx7GXNzJIkTB7M7_u8080LyLM0IS0rzFkC_c,119
-modal-1.3.6.dev6.dist-info/METADATA,sha256=oRFOtR0iYrXusm-oTYbjt2pJF92FhlQXHBCYp1EhzF8,2529
-modal-1.3.6.dev6.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-1.3.6.dev6.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-1.3.6.dev6.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-1.3.6.dev6.dist-info/RECORD,,
+modal-1.3.6.dev8.dist-info/METADATA,sha256=LwbIIVZv_hDJcsQMQ4rillVUUikSOxTm_NB7O2kgv0w,2529
+modal-1.3.6.dev8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-1.3.6.dev8.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-1.3.6.dev8.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-1.3.6.dev8.dist-info/RECORD,,

modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2026
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.3.6.dev6"
+__version__ = "1.3.6.dev8"