modal 1.5.4.dev22__tar.gz → 1.5.5.dev0__tar.gz

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/PKG-INFO

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

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_functions.py

@@ -640,7 +640,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await self.hydrate()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionLogsManager:
@@ -2077,7 +2082,12 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             await self._hydrate_from_id_metadata()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function call hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_call_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_call_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionCallLogsManager:

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_image.py

@@ -764,7 +764,10 @@ class _Image(_Object, type_prefix="im"):
                 if build_resp.HasField("metadata"):
                     metadata = build_resp.metadata
 
-            if result.status == api_pb2.GenericResult.GENERIC_STATUS_FAILURE:
+            if result.status in (
+                api_pb2.GenericResult.GENERIC_STATUS_FAILURE,
+                api_pb2.GenericResult.GENERIC_STATUS_MEMORY_MANAGER_EVICTION,
+            ):
                 if result.exception:
                     raise ImageBuildError(
                         f"Image build for {image_id} failed with the exception:\n{result.exception}", image_id

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_logs_manager.py

@@ -78,6 +78,13 @@ def _resolve_source(source: LogSource | None) -> api_pb2.FileDescriptor.ValueTyp
 
 def _entry_context_ids(object_id: str, item: api_pb2.TaskLogs, batch: api_pb2.TaskLogsBatch) -> list[str]:
     match object_id[:2]:
+        case "ap":
+            context_ids = [
+                batch.function_id,
+                item.function_call_id,
+                item.input_id or batch.input_id,
+                item.container_id or batch.task_id,
+            ]
         case "fu":
             context_ids = [
                 item.function_call_id,
@@ -140,10 +147,14 @@ class _LogsManager:
         since = _normalize_utc_datetime(since, "since")
         until = _normalize_utc_datetime(until or datetime.now(timezone.utc), "until")
         target = await self._params()
-        filters = dataclasses.replace(target.filters, source=_resolve_source(source), search_text=search_text)
+        filters = dataclasses.replace(
+            target.filters,
+            source=_resolve_source(source),
+            search_text=search_text,
+        )
         async for batch in fetch_logs(target.client, target.app_id, since=since, until=until, filters=filters):
             for item in batch.items:
-                yield _entry_from_item(self._source.object_id, item, batch)
+                yield _entry_from_item(target.source_object_id, item, batch)
 
     async def tail(
         self,
@@ -161,7 +172,7 @@ class _LogsManager:
             filters=filters,
         ):
             for item in batch.items:
-                yield _entry_from_item(self._source.object_id, item, batch)
+                yield _entry_from_item(params.source_object_id, item, batch)
 
     def _create_log_stream(
         self, params: _LogQueryData, last_entry_id: str, timeout: float
@@ -179,10 +190,10 @@ class _LogsManager:
         )
         return params.client.stub.AppGetLogs.unary_stream(request)
 
-    def _stream_entries(self, batch: api_pb2.TaskLogsBatch):
+    def _stream_entries(self, batch: api_pb2.TaskLogsBatch, source_object_id: str):
         for item in batch.items:
             if item.data:
-                yield _entry_from_item(self._source.object_id, item, batch)
+                yield _entry_from_item(source_object_id, item, batch)
 
     @staticmethod
     def _advance_batch(batch: api_pb2.TaskLogsBatch, last_entry_id: str) -> tuple[str, bool]:
@@ -205,7 +216,7 @@ class _LogsManager:
         log_stream = self._create_log_stream(params, last_entry_id, timeout)
         try:
             async for batch in log_stream:
-                for entry in self._stream_entries(batch):
+                for entry in self._stream_entries(batch, params.source_object_id):
                     yield entry
                 if batch.app_done:
                     return
@@ -243,7 +254,7 @@ class _LogsManager:
                             except StopAsyncIteration:
                                 break
                             last_entry_id, app_done = self._advance_batch(batch, last_entry_id)
-                            for log_entry in self._stream_entries(batch):
+                            for log_entry in self._stream_entries(batch, params.source_object_id):
                                 deadline.reset(timeout)
                                 yield log_entry
                             if app_done:
@@ -262,7 +273,7 @@ class _LogsManager:
                                 except StopAsyncIteration:
                                     break
                                 last_entry_id, app_done = self._advance_batch(batch, last_entry_id)
-                                for log_entry in self._stream_entries(batch):
+                                for log_entry in self._stream_entries(batch, params.source_object_id):
                                     deadline.reset(timeout)
                                     yield log_entry
                                 if app_done:
@@ -538,7 +549,7 @@ class _FunctionCallLogsManager:
                     await asyncio.sleep(1)
                     continue
                 raise
-        raise NotFoundError(f"Function call {self._source.object_id} not found after retries.")
+        raise AssertionError("unreachable")
 
     async def _determine_function_call_stop(self) -> bool:
         try:
@@ -789,3 +800,107 @@ class _ImageLogsManager:
 
 
 ImageLogsManager = synchronize_api(_ImageLogsManager, target_module=__name__)
+
+
+class _AppLogsManager:
+    """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 App 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
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.fetch(
+                since=datetime.now() - timedelta(hours=4),
+                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 App logs.
+
+        Args:
+            entries: The number of log entries to return.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+
+        Examples:
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.tail(20):
+                print(entry.message, end="")
+            ```
+        """
+        async for log_entry in self._manager.tail(
+            entries,
+            source=source,
+        ):
+            yield log_entry
+
+    async def stream(self, timeout: float | None = None) -> AsyncGenerator[LogEntry, None]:
+        """Stream new App logs until the timeout is reached.
+
+        Args:
+            timeout: Number of seconds to wait between log entries before terminating the stream.
+                By default, this will block until it is interrupted.
+
+        Yields:
+            `LogEntry` objects as they arrive.
+
+        Examples:
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.stream(timeout=60):
+                print(entry.message, end="")
+            ```
+        """
+        async for log_entry in self._manager.stream(timeout=timeout):
+            yield log_entry
+
+
+AppLogsManager = synchronize_api(_AppLogsManager, target_module=__name__)

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_logs_manager.pyi

@@ -78,7 +78,7 @@ class _LogsManager:
         """Helper for creating the log stream RPC."""
         ...
 
-    def _stream_entries(self, batch: modal_proto.api_pb2.TaskLogsBatch): ...
+    def _stream_entries(self, batch: modal_proto.api_pb2.TaskLogsBatch, source_object_id: str): ...
     @staticmethod
     def _advance_batch(batch: modal_proto.api_pb2.TaskLogsBatch, last_entry_id: str) -> tuple[str, bool]: ...
     @staticmethod
@@ -995,3 +995,269 @@ class ImageLogsManager:
             ...
 
     tail: __tail_spec
+
+class _AppLogsManager:
+    """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 App 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
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.fetch(
+                since=datetime.now() - timedelta(hours=4),
+                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 App logs.
+
+        Args:
+            entries: The number of log entries to return.
+            source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+        Yields:
+            `LogEntry` objects in chronological order.
+
+        Examples:
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.tail(20):
+                print(entry.message, end="")
+            ```
+        """
+        ...
+
+    def stream(
+        self, timeout: typing.Optional[float] = None
+    ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+        """Stream new App logs until the timeout is reached.
+
+        Args:
+            timeout: Number of seconds to wait between log entries before terminating the stream.
+                By default, this will block until it is interrupted.
+
+        Yields:
+            `LogEntry` objects as they arrive.
+
+        Examples:
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+
+            for entry in app.logs.stream(timeout=60):
+                print(entry.message, end="")
+            ```
+        """
+        ...
+
+class AppLogsManager:
+    """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 App 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
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.fetch(
+                    since=datetime.now() - timedelta(hours=4),
+                    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 App 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
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.fetch(
+                    since=datetime.now() - timedelta(hours=4),
+                    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 App logs.
+
+            Args:
+                entries: The number of log entries to return.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+
+            Examples:
+
+                ```python notest
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.tail(20):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+        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 App logs.
+
+            Args:
+                entries: The number of log entries to return.
+                source: Filter by source: 'stdout', 'stderr', or 'system'.
+
+            Yields:
+                `LogEntry` objects in chronological order.
+
+            Examples:
+
+                ```python notest
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.tail(20):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+    tail: __tail_spec
+
+    class __stream_spec(typing_extensions.Protocol):
+        def __call__(
+            self, /, timeout: typing.Optional[float] = None
+        ) -> typing.Generator[modal.types.LogEntry, None, None]:
+            """Stream new App logs until the timeout is reached.
+
+            Args:
+                timeout: Number of seconds to wait between log entries before terminating the stream.
+                    By default, this will block until it is interrupted.
+
+            Yields:
+                `LogEntry` objects as they arrive.
+
+            Examples:
+
+                ```python notest
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.stream(timeout=60):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+        def aio(
+            self, /, timeout: typing.Optional[float] = None
+        ) -> collections.abc.AsyncGenerator[modal.types.LogEntry, None]:
+            """Stream new App logs until the timeout is reached.
+
+            Args:
+                timeout: Number of seconds to wait between log entries before terminating the stream.
+                    By default, this will block until it is interrupted.
+
+            Yields:
+                `LogEntry` objects as they arrive.
+
+            Examples:
+
+                ```python notest
+                app = modal.App.lookup("my-app")
+
+                for entry in app.logs.stream(timeout=60):
+                    print(entry.message, end="")
+                ```
+            """
+            ...
+
+    stream: __stream_spec

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_runtime/asgi.py

@@ -523,6 +523,6 @@ def web_server_proxy(host: str, port: int):
         except aiohttp.ClientConnectorError as exc:
             # If the server is not running or not reachable, we should stop fetching new inputs.
             logger.warning(f"Terminating runner due to @web_server connection issue: {exc}")
-            stop_fetching_inputs()
+            await stop_fetching_inputs.aio()  # type: ignore
 
     return web_server_proxy_app

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

@@ -554,7 +554,6 @@ class _ContainerIOManager:
     _waiting_for_memory_snapshot: bool
 
     _is_interactivity_enabled: bool
-    _fetching_inputs: bool
 
     _singleton: ClassVar["_ContainerIOManager | None"] = None
 
@@ -595,7 +594,6 @@ class _ContainerIOManager:
         self._waiting_for_memory_snapshot = False
 
         self._is_interactivity_enabled = False
-        self._fetching_inputs = True
 
         self._max_object_size_bytes, self._max_async_object_size_bytes = _resolve_output_size_limits(container_args)
 
@@ -863,7 +861,7 @@ class _ContainerIOManager:
     ]:
         request = api_pb2.FunctionGetInputsRequest(function_id=self.function_id)
         iteration = 0
-        while self._fetching_inputs:
+        while True:
             await self._input_slots.acquire()
 
             request.input_concurrency = self.get_input_concurrency()
@@ -1112,10 +1110,15 @@ class _ContainerIOManager:
         io_manager._input_slots.set_value(concurrency)
 
     @classmethod
-    def stop_fetching_inputs(cls):
-        if not cls._singleton:
+    async def stop_fetching_inputs(cls):
+        io_manager = cls._singleton
+        if not io_manager:
             raise RuntimeError("Must be called from within a Modal container.")
-        cls._singleton._fetching_inputs = False
+        request = api_pb2.ContainerStopRequest(task_id=io_manager.task_id, graceful=True)
+        await io_manager._client.stub.ContainerStop(
+            request,
+            retry=Retry(total_timeout=5.0),
+        )
 
 
 ContainerIOManager = synchronize_api(_ContainerIOManager)

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

@@ -124,7 +124,6 @@ class _ContainerIOManager:
     _heartbeat_condition: typing.Optional[asyncio.locks.Condition]
     _waiting_for_memory_snapshot: bool
     _is_interactivity_enabled: bool
-    _fetching_inputs: bool
     _singleton: typing.ClassVar[typing.Optional[_ContainerIOManager]]
 
     def _init(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client._Client): ...
@@ -241,7 +240,7 @@ class _ContainerIOManager:
         ...
 
     @classmethod
-    def stop_fetching_inputs(cls): ...
+    async def stop_fetching_inputs(cls): ...
 
 class ContainerIOManager:
     """Synchronizes all RPC calls and network operations for a running container.
@@ -266,7 +265,6 @@ class ContainerIOManager:
     _heartbeat_condition: typing.Optional[asyncio.locks.Condition]
     _waiting_for_memory_snapshot: bool
     _is_interactivity_enabled: bool
-    _fetching_inputs: bool
     _singleton: typing.ClassVar[typing.Optional[ContainerIOManager]]
 
     def __init__(self, /, *args, **kwargs):
@@ -515,7 +513,10 @@ class ContainerIOManager:
         """
         ...
 
-    @classmethod
-    def stop_fetching_inputs(cls): ...
+    class __stop_fetching_inputs_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    stop_fetching_inputs: typing.ClassVar[__stop_fetching_inputs_spec]
 
 MAX_OUTPUT_BATCH_SIZE: int

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/_supports_logs.py

@@ -19,6 +19,7 @@ class _LogQueryData:
     client: _Client
     app_id: str
     filters: LogsFilters
+    source_object_id: str
 
 
 class _SupportsLogs(Protocol):
@@ -29,9 +30,6 @@ class _SupportsLogs(Protocol):
 
     async def _get_log_query_data(self) -> _LogQueryData: ...
 
-    @property
-    def object_id(self) -> str: ...
-
 
 @dataclasses.dataclass(frozen=True)
 class _ImageLogQueryData:

{modal-1.5.4.dev22 → modal-1.5.5.dev0}/modal/app.py

@@ -15,12 +15,14 @@ import typing_extensions
 from google.protobuf.message import Message
 from synchronicity.async_wrap import asynccontextmanager
 
+from modal._logs import LogsFilters
 from modal_proto import api_pb2
 
 from ._functions import _Function
 from ._image import _Image
 from ._ipython import is_interactive_ipython
 from ._load_context import LoadContext
+from ._logs_manager import _AppLogsManager
 from ._object import _get_environment_name, _Object
 from ._partial_function import (
     _find_partial_methods_for_user_cls,
@@ -29,6 +31,7 @@ from ._partial_function import (
     verify_concurrent_params,
 )
 from ._server import _Server, validate_http_server_config
+from ._supports_logs import _LogQueryData
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import (
     deprecation_warning,
@@ -1615,5 +1618,31 @@ class _App:
         """Only used for tests."""
         cls._container_app = None
 
+    async def _get_log_query_data(self) -> _LogQueryData:
+        """Get the data needed to query logs for this app."""
+        if not self._app_id:
+            raise InvalidError("`app._logs` requires a running/stopped app.")
+        client = self._client or await _Client.from_env()
+        filters = LogsFilters()
+        return _LogQueryData(client=client, app_id=self._app_id, filters=filters, source_object_id=self._app_id)
+
+    @property
+    def logs(self) -> _AppLogsManager:
+        """Access logs for an `App`.
+
+        Use [`fetch()`](#logsfetch)
+        to read logs from a UTC time range, [`tail()`](#logstail)
+        to read the most recent logs, and [`stream()`](#logsstream)
+        to follow new logs as they arrive.
+
+        See also:
+            - [`modal app logs`](https://modal.com/docs/cli/latest/app#modal-app-logs):
+                CLI access to logs for an App.
+        """
+        if not self._app_id:
+            raise InvalidError("`app.logs` requires a running/stopped app.")
+
+        return _AppLogsManager(self)
+
 
 App = synchronize_api(_App)