modal 1.5.5.dev0__tar.gz → 1.5.5.dev2__tar.gz

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/PKG-INFO

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

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/_container_entrypoint.py

@@ -145,7 +145,7 @@ def call_function(
                             item_count += 1
 
                 await container_io_manager._send_outputs.aio(
-                    io_context.output_items_generator_done(started_at, item_count)
+                    io_context, io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
                 value = await io_context.call_function_async()
@@ -182,7 +182,9 @@ def call_function(
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                container_io_manager._send_outputs(io_context.output_items_generator_done(started_at, item_count))
+                container_io_manager._send_outputs(
+                    io_context, io_context.output_items_generator_done(started_at, item_count)
+                )
             else:
                 values = io_context.call_function_sync()
                 container_io_manager.push_outputs(io_context, started_at, values)

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/_logs_manager.py

@@ -93,6 +93,8 @@ def _entry_context_ids(object_id: str, item: api_pb2.TaskLogs, batch: api_pb2.Ta
             ]
         case "fc":
             context_ids = [item.input_id or batch.input_id, item.container_id or batch.task_id]
+        case "sb":
+            context_ids = [item.container_id or batch.task_id]
         case _:
             context_ids = []
     # filter for empty strings, can happen for Server which have function_ids but no input/container
@@ -802,6 +804,71 @@ class _ImageLogsManager:
 ImageLogsManager = synchronize_api(_ImageLogsManager, target_module=__name__)
 
 
+class _SandboxLogsManager:
+    """mdmd:namespace"""
+
+    def __init__(self, source: _SupportsLogs):
+        """mdmd:hidden"""
+        self._manager = _LogsManager(source)
+
+    async def fetch(
+        self,
+        *,
+        since: datetime,
+        until: datetime | None = None,
+        source: LogSource | None = None,
+        search_text: str = "",
+    ) -> AsyncGenerator[LogEntry, None]:
+        """Fetch Sandbox logs corresponding to the date range and filters.
+
+        Args:
+            since: Start date to fetch logs from. Must be in UTC or timezone-naive,
+                which is interpreted as local time.
+            until: Defaults to current date if None. Must be in UTC or timezone-naive, which is interpreted
+                as local time.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+            search_text: Filter by search text.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+
+        Examples:
+
+            ```python notest
+            sandbox = modal.Sandbox.from_name("my-app", "sandbox")
+
+            for entry in sandbox.logs.fetch(
+                since=datetime.now() - timedelta(minutes=25),
+                source="stdout",
+            ):
+                print(entry.message, end="")
+            ```
+        """
+        async for log_entry in self._manager.fetch(since=since, until=until, source=source, search_text=search_text):
+            yield log_entry
+
+    async def tail(
+        self,
+        entries: int = 100,
+        *,
+        source: LogSource | None = None,
+    ) -> AsyncGenerator[LogEntry, None]:
+        """Fetch the most recent Sandbox logs.
+
+        Args:
+            entries: The number of log entries to return.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+        """
+        async for log_entry in self._manager.tail(entries, source=source):
+            yield log_entry
+
+
+SandboxLogsManager = synchronize_api(_SandboxLogsManager, target_module=__name__)
+
+
 class _AppLogsManager:
     """mdmd:namespace"""
 

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/_logs_manager.pyi

@@ -996,6 +996,173 @@ class ImageLogsManager:
 
     tail: __tail_spec
 
+class _SandboxLogsManager:
+    """mdmd:namespace"""
+    def __init__(self, source: modal._supports_logs._SupportsLogs):
+        """mdmd:hidden"""
+        ...
+
+    def fetch(
+        self,
+        *,
+        since: datetime.datetime,
+        until: typing.Optional[datetime.datetime] = None,
+        source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None,
+        search_text: str = "",
+    ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+        """Fetch Sandbox logs corresponding to the date range and filters.
+
+        Args:
+            since: Start date to fetch logs from. Must be in UTC or timezone-naive,
+                which is interpreted as local time.
+            until: Defaults to current date if None. Must be in UTC or timezone-naive, which is interpreted
+                as local time.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+            search_text: Filter by search text.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+
+        Examples:
+
+            ```python notest
+            sandbox = modal.Sandbox.from_name("my-app", "sandbox")
+
+            for entry in sandbox.logs.fetch(
+                since=datetime.now() - timedelta(minutes=25),
+                source="stdout",
+            ):
+                print(entry.message, end="")
+            ```
+        """
+        ...
+
+    def tail(
+        self, entries: int = 100, *, source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None
+    ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+        """Fetch the most recent Sandbox logs.
+
+        Args:
+            entries: The number of log entries to return.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+        """
+        ...
+
+class SandboxLogsManager:
+    """mdmd:namespace"""
+    def __init__(self, source: modal._supports_logs._SupportsLogs):
+        """mdmd:hidden"""
+        ...
+
+    class __fetch_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            *,
+            since: datetime.datetime,
+            until: typing.Optional[datetime.datetime] = None,
+            source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None,
+            search_text: str = "",
+        ) -> typing.Generator[modal.types.LogEntry, None, None]:
+            """Fetch Sandbox logs corresponding to the date range and filters.
+
+            Args:
+                since: Start date to fetch logs from. Must be in UTC or timezone-naive,
+                    which is interpreted as local time.
+                until: Defaults to current date if None. Must be in UTC or timezone-naive, which is interpreted
+                    as local time.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+                search_text: Filter by search text.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+
+            Examples:
+
+                ```python notest
+                sandbox = modal.Sandbox.from_name("my-app", "sandbox")
+
+                for entry in sandbox.logs.fetch(
+                    since=datetime.now() - timedelta(minutes=25),
+                    source="stdout",
+                ):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+        def aio(
+            self,
+            /,
+            *,
+            since: datetime.datetime,
+            until: typing.Optional[datetime.datetime] = None,
+            source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None,
+            search_text: str = "",
+        ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+            """Fetch Sandbox logs corresponding to the date range and filters.
+
+            Args:
+                since: Start date to fetch logs from. Must be in UTC or timezone-naive,
+                    which is interpreted as local time.
+                until: Defaults to current date if None. Must be in UTC or timezone-naive, which is interpreted
+                    as local time.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+                search_text: Filter by search text.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+
+            Examples:
+
+                ```python notest
+                sandbox = modal.Sandbox.from_name("my-app", "sandbox")
+
+                for entry in sandbox.logs.fetch(
+                    since=datetime.now() - timedelta(minutes=25),
+                    source="stdout",
+                ):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+    fetch: __fetch_spec
+
+    class __tail_spec(typing_extensions.Protocol):
+        def __call__(
+            self, /, entries: int = 100, *, source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None
+        ) -> typing.Generator[modal.types.LogEntry, None, None]:
+            """Fetch the most recent Sandbox logs.
+
+            Args:
+                entries: The number of log entries to return.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+            """
+            ...
+
+        def aio(
+            self, /, entries: int = 100, *, source: typing.Optional[typing.Literal["stdout", "stderr", "system"]] = None
+        ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+            """Fetch the most recent Sandbox logs.
+
+            Args:
+                entries: The number of log entries to return.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+            """
+            ...
+
+    tail: __tail_spec
+
 class _AppLogsManager:
     """mdmd:namespace"""
     def __init__(self, source: modal._supports_logs._SupportsLogs):

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/_runtime/container_io_manager.py

@@ -96,6 +96,7 @@ class IOContext:
 
     _cancel_issued: bool = False
     _cancel_callback: Callable[[], None] | None = None
+    _exited: bool = False
 
     def __init__(
         self,
@@ -889,25 +890,35 @@ class _ContainerIOManager:
                         if item.kill_switch:
                             logger.debug(f"Task {self.task_id} input kill signal input.")
                             return
-                        inputs.append(
-                            (
-                                item.input_id,
-                                item.retry_count,
-                                item.function_call_id,
-                                item.attempt_token,
-                                item.input,
-                                item.function_call_invocation_type,
+                        live_io_context = self.current_inputs.get(item.input_id)
+                        if live_io_context is not None and (
+                            live_io_context.retry_counts[live_io_context.input_ids.index(item.input_id)]
+                            == item.retry_count
+                        ):
+                            # An expired fetch lease redelivers a still-running attempt under the same
+                            # input id and retry count; a retry of a failed attempt gets a new retry count.
+                            logger.warning(f"Skipping duplicate delivery of input {item.input_id}")
+                        else:
+                            inputs.append(
+                                (
+                                    item.input_id,
+                                    item.retry_count,
+                                    item.function_call_id,
+                                    item.attempt_token,
+                                    item.input,
+                                    item.function_call_invocation_type,
+                                )
                             )
-                        )
                         if item.input.final_input:
                             if request.batch_max_size > 0:
                                 logger.debug(f"Task {self.task_id} Final input not expected in batch input stream")
                             final_input_received = True
                             break
 
-                    # If yielded, allow input slots to be released via exit_context
-                    yield inputs
-                    yielded = True
+                    if inputs:
+                        # If yielded, allow input slots to be released via exit_context
+                        yield inputs
+                        yielded = True
 
                     # TODO(michael): Remove use of max_inputs after worker rollover
                     single_use_container = self.function_def.single_use_containers or self.function_def.max_inputs == 1
@@ -950,7 +961,7 @@ class _ContainerIOManager:
             # collect all active input slots, meaning all inputs have wrapped up.
             await self._input_slots.close()
 
-    async def _send_outputs(self, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(self, io_context: IOContext, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
         """Send pre-built output items with retry and chunking."""
         # There are multiple outputs for a single IOContext in the case of @modal.batched.
         # Limit the batch size to 20 to stay within message size limits and buffer size limits.
@@ -963,8 +974,7 @@ class _ContainerIOManager:
                     max_retries=None,  # Retry indefinitely, trying every 1s.
                 ),
             )
-        input_ids = [output.input_id for output in outputs]
-        self.exit_context(input_ids)
+        self.exit_context(io_context)
 
     @asynccontextmanager
     async def handle_input_exception(
@@ -984,7 +994,7 @@ class _ContainerIOManager:
             raise
         except (InputCancellation, asyncio.CancelledError):
             outputs = await io_context.output_items_cancellation(started_at)
-            await self._send_outputs(outputs)
+            await self._send_outputs(io_context, outputs)
             logger.warning(f"Successfully canceled input {io_context.input_ids}")
             return
         except BaseException as exc:
@@ -995,13 +1005,24 @@ class _ContainerIOManager:
             # print exception so it's logged
             print_exception(*sys.exc_info())
             outputs = await io_context.output_items_exception(started_at, self.task_id, exc)
-            await self._send_outputs(outputs)
+            await self._send_outputs(io_context, outputs)
 
-    def exit_context(self, input_ids: list[str]):
-        for input_id in input_ids:
-            self.current_inputs.pop(input_id)
-
-        self._input_slots.release()
+    def exit_context(self, io_context: IOContext):
+        # A cancellation can land after outputs were already sent, re-entering here for the same
+        # context; exit at most once so the input slot is not released twice.
+        if io_context._exited:
+            return
+        io_context._exited = True
+        try:
+            for input_id in io_context.input_ids:
+                # A retry admitted before its predecessor finished exiting takes over the
+                # tracking entry, so remove it only if this context still owns it.
+                if self.current_inputs.get(input_id) is io_context:
+                    self.current_inputs.pop(input_id)
+                else:
+                    logger.warning(f"Input {input_id} missing from active input tracking")
+        finally:
+            self._input_slots.release()
 
     # skip inspection of user-generated output_data for synchronicity input translation
     @synchronizer.no_io_translation
@@ -1013,7 +1034,7 @@ class _ContainerIOManager:
     ) -> None:
         # The standard output encoding+sending method for successful function outputs
         outputs = await io_context.output_items(started_at, output_data)
-        await self._send_outputs(outputs)
+        await self._send_outputs(io_context, outputs)
 
     @asynccontextmanager
     async def snapshot_context_manager(self) -> AsyncGenerator[None, None]:

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/_runtime/container_io_manager.pyi

@@ -33,6 +33,7 @@ class IOContext:
     finalized_function: modal._runtime.user_code_imports.FinalizedFunction
     _cancel_issued: bool
     _cancel_callback: typing.Optional[collections.abc.Callable[[], None]]
+    _exited: bool
 
     def __init__(
         self,
@@ -202,7 +203,9 @@ class _ContainerIOManager:
         batch_max_size: int = 0,
         batch_wait_ms: int = 0,
     ) -> collections.abc.AsyncIterator[IOContext]: ...
-    async def _send_outputs(self, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(
+        self, io_context: IOContext, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]
+    ) -> None:
         """Send pre-built output items with retry and chunking."""
         ...
 
@@ -210,7 +213,7 @@ class _ContainerIOManager:
         """Handle an exception while processing a function input."""
         ...
 
-    def exit_context(self, input_ids: list[str]): ...
+    def exit_context(self, io_context: IOContext): ...
     async def push_outputs(self, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
     def snapshot_context_manager(self) -> typing.AsyncContextManager[None]: ...
     async def interact(self, from_breakpoint: bool = False): ...
@@ -445,11 +448,13 @@ class ContainerIOManager:
     run_inputs_outputs: __run_inputs_outputs_spec
 
     class ___send_outputs_spec(typing_extensions.Protocol):
-        def __call__(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        def __call__(self, /, io_context: IOContext, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
-        async def aio(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        async def aio(
+            self, /, io_context: IOContext, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]
+        ) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
@@ -468,7 +473,7 @@ class ContainerIOManager:
 
     handle_input_exception: __handle_input_exception_spec
 
-    def exit_context(self, input_ids: list[str]): ...
+    def exit_context(self, io_context: IOContext): ...
 
     class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/client.pyi

@@ -38,7 +38,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.5.dev0",
+        version: str = "1.5.5.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -209,7 +209,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.5.dev0",
+        version: str = "1.5.5.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/functions.pyi

@@ -546,7 +546,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -571,7 +571,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -621,7 +621,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -654,7 +654,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -662,7 +662,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -695,7 +695,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.

{modal-1.5.5.dev0 → modal-1.5.5.dev2}/modal/sandbox.py

@@ -15,6 +15,8 @@ from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any, Literal, Union, overload
 
+from modal._logs_manager import _SandboxLogsManager
+from modal._supports_logs import LogsFilters, _LogQueryData
 from modal.secret import _split_env_dict_and_resolvable_secrets
 
 from ._output.pty import get_pty_info
@@ -1931,6 +1933,27 @@ class _Sandbox(_Object, type_prefix="sb"):
                 await asyncio.sleep(0.5)
         return self._task_id
 
+    async def _resolve_task_id_for_logs(self) -> str:
+        """Try to resolve the task ID in one shot for historical log fetches.
+
+        For a historical log api, we should not wait for the task to be created.
+        If the Sandbox created logs worth fetching, the task ID should be available.
+        """
+        if self._task_id:
+            return self._task_id
+
+        req = api_pb2.SandboxGetTaskIdRequest(sandbox_id=self.object_id)
+        stub = self.__client.stub
+        if self._is_v2:
+            assert self.__client._auth_token_manager
+            auth_token = await self.__client._auth_token_manager.get_token()
+            resp = await stub.SandboxGetTaskIdV2(req, metadata=[("x-modal-auth-token", auth_token)])
+        else:
+            resp = await stub.SandboxGetTaskId(req)
+        if not resp.task_id:
+            raise ExecutionError("Sandbox task_id is not available yet.")
+        return resp.task_id
+
     async def _get_command_router_client(self, task_id: str) -> TaskCommandRouterClient:
         if self._command_router_client is None:
             try:
@@ -2605,6 +2628,36 @@ class _Sandbox(_Object, type_prefix="sb"):
             # Fetch the next batch starting from the end of the current one.
             before_timestamp = resp.sandboxes[-1].created_at
 
+    async def _get_log_query_data(self) -> _LogQueryData:
+        if not self._app_id:
+            if not self._attached:
+                raise ExecutionError("Cannot fetch logs for a detached Sandbox without hydrated app_id")
+            await self.hydrate()
+
+        if not self._app_id:
+            raise ExecutionError("app_id should have been set during sandbox hydration")
+
+        task_id = await self._resolve_task_id_for_logs()
+        return _LogQueryData(self.__client, self._app_id, LogsFilters(task_id=task_id), self.object_id)
+
+    @property
+    def logs(self) -> _SandboxLogsManager:
+        """Access logs for a `Sandbox` entrypoint.
+
+        Useful for inspecting logs after a Sandbox terminates.
+        Use [`fetch()`](#logsfetch)
+        to read logs from a UTC time range, [`tail()`](#logstail)
+        to read the most recent logs.
+
+        Note that the logs from executed commands in the sandbox (via `exec()`) are not included in the
+        entrypoint logs.
+
+        See also:
+            - [`modal app logs`](https://modal.com/docs/cli/latest/app#modal-app-logs):
+              CLI access to logs for an App.
+        """
+        return _SandboxLogsManager(self)
+
 
 class _SidecarContainer:
     """Handle to an additional container running in a Sandbox."""