modal 1.2.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

modal/io_streams.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal._utils.task_command_router_client
 import modal.client
 import modal.stream_type
 import typing
@@ -17,6 +18,165 @@ def _container_process_logs_iterator(
 
 T = typing.TypeVar("T")
 
+class _StreamReaderThroughServer(typing.Generic[T]):
+    """A StreamReader implementation that reads from the server."""
+
+    _stream: typing.Optional[collections.abc.AsyncGenerator[T, None]]
+
+    def __init__(
+        self,
+        file_descriptor: int,
+        object_id: str,
+        object_type: typing.Literal["sandbox", "container_process"],
+        client: modal.client._Client,
+        stream_type: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        text: bool = True,
+        by_line: bool = False,
+        deadline: typing.Optional[float] = None,
+    ) -> None:
+        """mdmd:hidden"""
+        ...
+
+    @property
+    def file_descriptor(self) -> int:
+        """Possible values are `1` for stdout and `2` for stderr."""
+        ...
+
+    async def read(self) -> T:
+        """Fetch the entire contents of the stream until EOF."""
+        ...
+
+    async def _consume_container_process_stream(self):
+        """Consume the container process stream and store messages in the buffer."""
+        ...
+
+    def _stream_container_process(self) -> collections.abc.AsyncGenerator[tuple[typing.Optional[bytes], str], None]:
+        """Streams the container process buffer to the reader."""
+        ...
+
+    def _get_logs(self, skip_empty_messages: bool = True) -> collections.abc.AsyncGenerator[bytes, None]:
+        """Streams sandbox or process logs from the server to the reader.
+
+        Logs returned by this method may contain partial or multiple lines at a time.
+
+        When the stream receives an EOF, it yields None. Once an EOF is received,
+        subsequent invocations will not yield logs.
+        """
+        ...
+
+    def _get_logs_by_line(self) -> collections.abc.AsyncGenerator[bytes, None]:
+        """Process logs from the server and yield complete lines only."""
+        ...
+
+    def _ensure_stream(self) -> collections.abc.AsyncGenerator[T, None]: ...
+    async def __anext__(self) -> T:
+        """mdmd:hidden"""
+        ...
+
+    async def aclose(self):
+        """mdmd:hidden"""
+        ...
+
+def _decode_bytes_stream_to_str(
+    stream: collections.abc.AsyncGenerator[bytes, None],
+) -> collections.abc.AsyncGenerator[str, None]:
+    """Incrementally decode a bytes async generator as UTF-8 without breaking on chunk boundaries.
+
+    This function uses a streaming UTF-8 decoder so that multi-byte characters split across
+    chunks are handled correctly instead of raising ``UnicodeDecodeError``.
+    """
+    ...
+
+def _stream_by_line(stream: collections.abc.AsyncGenerator[bytes, None]) -> collections.abc.AsyncGenerator[bytes, None]:
+    """Yield complete lines only (ending with
+    ), buffering partial lines until complete.
+    """
+    ...
+
+class _StreamReaderThroughCommandRouterParams:
+    """_StreamReaderThroughCommandRouterParams(file_descriptor: 'api_pb2.FileDescriptor.ValueType', task_id: str, object_id: str, command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient, deadline: Optional[float])"""
+
+    file_descriptor: int
+    task_id: str
+    object_id: str
+    command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient
+    deadline: typing.Optional[float]
+
+    def __init__(
+        self,
+        file_descriptor: int,
+        task_id: str,
+        object_id: str,
+        command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
+        deadline: typing.Optional[float],
+    ) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def __repr__(self):
+        """Return repr(self)."""
+        ...
+
+    def __eq__(self, other):
+        """Return self==value."""
+        ...
+
+def _stdio_stream_from_command_router(
+    params: _StreamReaderThroughCommandRouterParams,
+) -> collections.abc.AsyncGenerator[bytes, None]:
+    """Stream raw bytes from the router client."""
+    ...
+
+class _BytesStreamReaderThroughCommandRouter(typing.Generic[T]):
+    """StreamReader implementation that will read directly from the worker that
+    hosts the sandbox.
+
+    This implementation is used for non-text streams.
+    """
+    def __init__(self, params: _StreamReaderThroughCommandRouterParams) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    @property
+    def file_descriptor(self) -> int: ...
+    async def read(self) -> T: ...
+    def __aiter__(self) -> collections.abc.AsyncIterator[T]: ...
+    async def __anext__(self) -> T: ...
+    async def aclose(self): ...
+
+class _TextStreamReaderThroughCommandRouter(typing.Generic[T]):
+    """StreamReader implementation that will read directly from the worker
+    that hosts the sandbox.
+
+    This implementation is used for text streams.
+    """
+    def __init__(self, params: _StreamReaderThroughCommandRouterParams, by_line: bool) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    @property
+    def file_descriptor(self) -> int: ...
+    async def read(self) -> T: ...
+    def __aiter__(self) -> collections.abc.AsyncIterator[T]: ...
+    async def __anext__(self) -> T: ...
+    async def aclose(self): ...
+
+class _DevnullStreamReader(typing.Generic[T]):
+    """StreamReader implementation for a stream configured with
+    StreamType.DEVNULL. Throws an error if read or any other method is
+    called.
+    """
+    def __init__(self, file_descriptor: int) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    @property
+    def file_descriptor(self) -> int: ...
+    async def read(self) -> T: ...
+    def __aiter__(self) -> collections.abc.AsyncIterator[T]: ...
+    async def __anext__(self) -> T: ...
+    async def aclose(self): ...
+
 class _StreamReader(typing.Generic[T]):
     """Retrieve logs from a stream (`stdout` or `stderr`).
 
@@ -38,9 +198,6 @@ class _StreamReader(typing.Generic[T]):
         print(f"Message: {message}")
     ```
     """
-
-    _stream: typing.Optional[collections.abc.AsyncGenerator[typing.Optional[bytes], None]]
-
     def __init__(
         self,
         file_descriptor: int,
@@ -51,6 +208,8 @@ class _StreamReader(typing.Generic[T]):
         text: bool = True,
         by_line: bool = False,
         deadline: typing.Optional[float] = None,
+        command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient] = None,
+        task_id: typing.Optional[str] = None,
     ) -> None:
         """mdmd:hidden"""
         ...
@@ -76,52 +235,79 @@ class _StreamReader(typing.Generic[T]):
         """
         ...
 
-    async def _consume_container_process_stream(self):
-        """Consume the container process stream and store messages in the buffer."""
+    def __aiter__(self) -> collections.abc.AsyncIterator[T]:
+        """mdmd:hidden"""
         ...
 
-    def _stream_container_process(self) -> collections.abc.AsyncGenerator[tuple[typing.Optional[bytes], str], None]:
-        """Streams the container process buffer to the reader."""
+    async def __anext__(self) -> T:
+        """mdmd:hidden"""
         ...
 
-    def _get_logs(
-        self, skip_empty_messages: bool = True
-    ) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
-        """Streams sandbox or process logs from the server to the reader.
+    async def aclose(self):
+        """mdmd:hidden"""
+        ...
 
-        Logs returned by this method may contain partial or multiple lines at a time.
+class _StreamWriterThroughServer:
+    """Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`)."""
+    def __init__(
+        self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client._Client
+    ) -> None:
+        """mdmd:hidden"""
+        ...
 
-        When the stream receives an EOF, it yields None. Once an EOF is received,
-        subsequent invocations will not yield logs.
+    def _get_next_index(self) -> int: ...
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None:
+        """Write data to the stream but does not send it immediately.
+
+        This is non-blocking and queues the data to an internal buffer. Must be
+        used along with the `drain()` method, which flushes the buffer.
         """
         ...
 
-    def _get_logs_by_line(self) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
-        """Process logs from the server and yield complete lines only."""
-        ...
+    def write_eof(self) -> None:
+        """Close the write end of the stream after the buffered data is drained.
 
-    def _ensure_stream(self) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]: ...
-    def __aiter__(self) -> collections.abc.AsyncIterator[T]:
-        """mdmd:hidden"""
+        If the process was blocked on input, it will become unblocked after
+        `write_eof()`. This method needs to be used along with the `drain()`
+        method, which flushes the EOF to the process.
+        """
         ...
 
-    async def __anext__(self) -> T:
-        """mdmd:hidden"""
+    async def drain(self) -> None:
+        """Flush the write buffer and send data to the running process.
+
+        This is a flow control method that blocks until data is sent. It returns
+        when it is appropriate to continue writing data to the stream.
+        """
         ...
 
-    async def aclose(self):
-        """mdmd:hidden"""
+class _StreamWriterThroughCommandRouter:
+    def __init__(
+        self,
+        object_id: str,
+        command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
+        task_id: str,
+    ) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None: ...
+    def write_eof(self) -> None: ...
+    async def drain(self) -> None: ...
+
 class _StreamWriter:
     """Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`)."""
     def __init__(
-        self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client._Client
+        self,
+        object_id: str,
+        object_type: typing.Literal["sandbox", "container_process"],
+        client: modal.client._Client,
+        command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient] = None,
+        task_id: typing.Optional[str] = None,
     ) -> None:
         """mdmd:hidden"""
         ...
 
-    def _get_next_index(self) -> int: ...
     def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None:
         """Write data to the stream but does not send it immediately.
 
@@ -204,9 +390,6 @@ class StreamReader(typing.Generic[T]):
         print(f"Message: {message}")
     ```
     """
-
-    _stream: typing.Optional[collections.abc.AsyncGenerator[typing.Optional[bytes], None]]
-
     def __init__(
         self,
         file_descriptor: int,
@@ -217,6 +400,8 @@ class StreamReader(typing.Generic[T]):
         text: bool = True,
         by_line: bool = False,
         deadline: typing.Optional[float] = None,
+        command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient] = None,
+        task_id: typing.Optional[str] = None,
     ) -> None:
         """mdmd:hidden"""
         ...
@@ -261,70 +446,6 @@ class StreamReader(typing.Generic[T]):
 
     read: __read_spec[T, typing_extensions.Self]
 
-    class ___consume_container_process_stream_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /):
-            """Consume the container process stream and store messages in the buffer."""
-            ...
-
-        async def aio(self, /):
-            """Consume the container process stream and store messages in the buffer."""
-            ...
-
-    _consume_container_process_stream: ___consume_container_process_stream_spec[typing_extensions.Self]
-
-    class ___stream_container_process_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /) -> typing.Generator[tuple[typing.Optional[bytes], str], None, None]:
-            """Streams the container process buffer to the reader."""
-            ...
-
-        def aio(self, /) -> collections.abc.AsyncGenerator[tuple[typing.Optional[bytes], str], None]:
-            """Streams the container process buffer to the reader."""
-            ...
-
-    _stream_container_process: ___stream_container_process_spec[typing_extensions.Self]
-
-    class ___get_logs_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, skip_empty_messages: bool = True) -> typing.Generator[typing.Optional[bytes], None, None]:
-            """Streams sandbox or process logs from the server to the reader.
-
-            Logs returned by this method may contain partial or multiple lines at a time.
-
-            When the stream receives an EOF, it yields None. Once an EOF is received,
-            subsequent invocations will not yield logs.
-            """
-            ...
-
-        def aio(
-            self, /, skip_empty_messages: bool = True
-        ) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
-            """Streams sandbox or process logs from the server to the reader.
-
-            Logs returned by this method may contain partial or multiple lines at a time.
-
-            When the stream receives an EOF, it yields None. Once an EOF is received,
-            subsequent invocations will not yield logs.
-            """
-            ...
-
-    _get_logs: ___get_logs_spec[typing_extensions.Self]
-
-    class ___get_logs_by_line_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /) -> typing.Generator[typing.Optional[bytes], None, None]:
-            """Process logs from the server and yield complete lines only."""
-            ...
-
-        def aio(self, /) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
-            """Process logs from the server and yield complete lines only."""
-            ...
-
-    _get_logs_by_line: ___get_logs_by_line_spec[typing_extensions.Self]
-
-    class ___ensure_stream_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /) -> typing.Generator[typing.Optional[bytes], None, None]: ...
-        def aio(self, /) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]: ...
-
-    _ensure_stream: ___ensure_stream_spec[typing_extensions.Self]
-
     def __iter__(self) -> typing.Iterator[T]:
         """mdmd:hidden"""
         ...
@@ -352,12 +473,16 @@ class StreamReader(typing.Generic[T]):
 class StreamWriter:
     """Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`)."""
     def __init__(
-        self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client.Client
+        self,
+        object_id: str,
+        object_type: typing.Literal["sandbox", "container_process"],
+        client: modal.client.Client,
+        command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient] = None,
+        task_id: typing.Optional[str] = None,
     ) -> None:
         """mdmd:hidden"""
         ...
 
-    def _get_next_index(self) -> int: ...
     def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None:
         """Write data to the stream but does not send it immediately.
 

modal/partial_function.pyi

@@ -329,7 +329,10 @@ def batched(
     ...
 
 def concurrent(
-    _warn_parentheses_missing=None, *, max_inputs: int, target_inputs: typing.Optional[int] = None
+    _warn_parentheses_missing=None,
+    *,
+    max_inputs: typing.Optional[int] = None,
+    target_inputs: typing.Optional[int] = None,
 ) -> collections.abc.Callable[
     [
         typing.Union[

modal/runner.py

@@ -35,7 +35,7 @@ from .client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
 from .cls import _Cls
 from .config import config, logger
 from .environments import _get_environment_cached
-from .exception import InteractiveTimeoutError, InvalidError, RemoteError, _CliUserExecutionError
+from .exception import ConnectionError, InteractiveTimeoutError, InvalidError, RemoteError, _CliUserExecutionError
 from .output import _get_output_manager, enable_output
 from .running_app import RunningApp, running_app_from_layout
 from .sandbox import _Sandbox
@@ -43,9 +43,7 @@ from .secret import _Secret
 from .stream_type import StreamType
 
 if TYPE_CHECKING:
-    from .app import _App
-else:
-    _App = TypeVar("_App")
+    import modal.app
 
 
 V = TypeVar("V")
@@ -126,12 +124,11 @@ async def _init_local_app_from_name(
 async def _create_all_objects(
     client: _Client,
     running_app: RunningApp,
-    functions: dict[str, _Function],
-    classes: dict[str, _Cls],
+    local_app_state: "modal.app._LocalAppState",
     environment_name: str,
 ) -> None:
     """Create objects that have been defined but not created on the server."""
-    indexed_objects: dict[str, _Object] = {**functions, **classes}
+    indexed_objects: dict[str, _Object] = {**local_app_state.functions, **local_app_state.classes}
     resolver = Resolver(
         client,
         environment_name=environment_name,
@@ -182,21 +179,19 @@ async def _publish_app(
     client: _Client,
     running_app: RunningApp,
     app_state: int,  # api_pb2.AppState.value
-    functions: dict[str, _Function],
-    classes: dict[str, _Cls],
+    app_local_state: "modal.app._LocalAppState",
     name: str = "",
-    tags: dict[str, str] = {},  # Additional App metadata
     deployment_tag: str = "",  # Only relevant for deployments
     commit_info: Optional[api_pb2.CommitInfo] = None,  # Git commit information
 ) -> tuple[str, list[api_pb2.Warning]]:
     """Wrapper for AppPublish RPC."""
-
+    functions = app_local_state.functions
     definition_ids = {obj.object_id: obj._get_metadata().definition_id for obj in functions.values()}  # type: ignore
 
     request = api_pb2.AppPublishRequest(
         app_id=running_app.app_id,
         name=name,
-        tags=tags,
+        tags=app_local_state.tags,
         deployment_tag=deployment_tag,
         commit_info=commit_info,
         app_state=app_state,  # type: ignore  : should be a api_pb2.AppState.value
@@ -260,13 +255,13 @@ async def _status_based_disconnect(client: _Client, app_id: str, exc_info: Optio
 
 @asynccontextmanager
 async def _run_app(
-    app: _App,
+    app: "modal.app._App",
     *,
     client: Optional[_Client] = None,
     detach: bool = False,
     environment_name: Optional[str] = None,
     interactive: bool = False,
-) -> AsyncGenerator[_App, None]:
+) -> AsyncGenerator["modal.app._App", None]:
     """mdmd:hidden"""
     if environment_name is None:
         environment_name = typing.cast(str, config.get("environment"))
@@ -338,12 +333,13 @@ async def _run_app(
                 get_app_logs_loop(client, output_mgr, app_id=running_app.app_id, app_logs_url=running_app.app_logs_url)
             )
 
+        local_app_state = app._local_state
         try:
             # Create all members
-            await _create_all_objects(client, running_app, app._functions, app._classes, environment_name)
+            await _create_all_objects(client, running_app, local_app_state, environment_name)
 
             # Publish the app
-            await _publish_app(client, running_app, app_state, app._functions, app._classes, tags=app._tags)
+            await _publish_app(client, running_app, app_state, local_app_state)
         except asyncio.CancelledError as e:
             # this typically happens on sigint/ctrl-C during setup (the KeyboardInterrupt happens in the main thread)
             if output_mgr := _get_output_manager():
@@ -355,6 +351,15 @@ async def _run_app(
             await _status_based_disconnect(client, running_app.app_id, e)
             raise
 
+        detached_disconnect_msg = (
+            "The detached App will keep running. You can track its progress on the Dashboard: "
+            f"[magenta underline]{running_app.app_page_url}[/magenta underline]"
+            "\n\nStream App logs:\n"
+            f"[green]modal app logs {running_app.app_id}[/green]"
+            "\n\nStop the App:\n"
+            f"[green]modal app stop {running_app.app_id}[/green]"
+        )
+
         try:
             # Show logs from dynamically created images.
             # TODO: better way to do this
@@ -377,11 +382,7 @@ async def _run_app(
             if detach:
                 if output_mgr := _get_output_manager():
                     output_mgr.print(output_mgr.step_completed("Shutting down Modal client."))
-                    output_mgr.print(
-                        "The detached app keeps running. You can track its progress at: "
-                        f"[magenta]{running_app.app_page_url}[/magenta]"
-                        ""
-                    )
+                    output_mgr.print(detached_disconnect_msg)
                 if logs_loop:
                     logs_loop.cancel()
                 await _status_based_disconnect(client, running_app.app_id, e)
@@ -405,6 +406,14 @@ async def _run_app(
                         )
                     )
             return
+        except ConnectionError as e:
+            # If we lose connection to the server after a detached App has started running, it will continue
+            # I think we can only exit "nicely" if we are able to print output though, otherwise we should raise
+            if detach and (output_mgr := _get_output_manager()):
+                output_mgr.print(":white_exclamation_mark: Connection lost!")
+                output_mgr.print(detached_disconnect_msg)
+                return
+            raise
         except BaseException as e:
             logger.info("Exception during app run")
             await _status_based_disconnect(client, running_app.app_id, e)
@@ -428,7 +437,7 @@ async def _run_app(
 
 
 async def _serve_update(
-    app: _App,
+    app: "modal.app._App",
     existing_app_id: str,
     is_ready: Event,
     environment_name: str,
@@ -438,13 +447,12 @@ async def _serve_update(
     client = await _Client.from_env()
     try:
         running_app: RunningApp = await _init_local_app_existing(client, existing_app_id, environment_name)
-
+        local_app_state = app._local_state
         # Create objects
         await _create_all_objects(
             client,
             running_app,
-            app._functions,
-            app._classes,
+            local_app_state,
             environment_name,
         )
 
@@ -453,9 +461,7 @@ async def _serve_update(
             client,
             running_app,
             app_state=api_pb2.APP_STATE_UNSPECIFIED,
-            functions=app._functions,
-            classes=app._classes,
-            tags=app._tags,
+            app_local_state=local_app_state,
         )
 
         # Communicate to the parent process
@@ -476,7 +482,7 @@ class DeployResult:
 
 
 async def _deploy_app(
-    app: _App,
+    app: "modal.app._App",
     name: Optional[str] = None,
     namespace: Any = None,  # mdmd:line-hidden
     client: Optional[_Client] = None,
@@ -534,8 +540,7 @@ async def _deploy_app(
             await _create_all_objects(
                 client,
                 running_app,
-                app._functions,
-                app._classes,
+                app._local_state,
                 environment_name=environment_name,
             )
 
@@ -548,11 +553,9 @@ async def _deploy_app(
             app_url, warnings = await _publish_app(
                 client,
                 running_app,
-                app_state=api_pb2.APP_STATE_DEPLOYED,
-                functions=app._functions,
-                classes=app._classes,
+                api_pb2.APP_STATE_DEPLOYED,
+                app._local_state,
                 name=name,
-                tags=app._tags,
                 deployment_tag=tag,
                 commit_info=commit_info,
             )
@@ -574,7 +577,7 @@ async def _deploy_app(
 
 
 async def _interactive_shell(
-    _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
+    _app: "modal.app._App", cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
 ) -> None:
     """Run an interactive shell (like `bash`) within the image for this app.