modal 1.2.1.dev10__py3-none-any.whl → 1.2.1.dev12__py3-none-any.whl

modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev10",
+        version: str = "1.2.1.dev12",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev10",
+        version: str = "1.2.1.dev12",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

modal/container_process.py

@@ -155,8 +155,16 @@ class _ContainerProcess(Generic[T]):
         on_connect = asyncio.Event()
 
         async def _write_to_fd_loop(stream: _StreamReader):
+            # This is required to make modal shell to an existing task work,
+            # since that uses ContainerExec RPCs directly, but this is hacky.
+            #
+            # TODO(saltzm): Once we use the new exec path for that use case, this code can all be removed.
+            from .io_streams import _StreamReaderThroughServer
+
+            assert isinstance(stream._impl, _StreamReaderThroughServer)
+            stream_impl = stream._impl
             # Don't skip empty messages so we can detect when the process has booted.
-            async for chunk in stream._get_logs(skip_empty_messages=False):
+            async for chunk in stream_impl._get_logs(skip_empty_messages=False):
                 if chunk is None:
                     break
 

modal/io_streams.py

@@ -1,7 +1,9 @@
 # Copyright Modal Labs 2022
 import asyncio
+import codecs
 import time
 from collections.abc import AsyncGenerator, AsyncIterator
+from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -15,11 +17,12 @@ from typing import (
 from grpclib import Status
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
-from modal.exception import ClientClosed, InvalidError
+from modal.exception import ClientClosed, ExecTimeoutError, InvalidError
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
+from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
 from .config import logger
 from .stream_type import StreamType
@@ -83,27 +86,8 @@ async def _container_process_logs_iterator(
 T = TypeVar("T", str, bytes)
 
 
-class _StreamReader(Generic[T]):
-    """Retrieve logs from a stream (`stdout` or `stderr`).
-
-    As an asynchronous iterable, the object supports the `for` and `async for`
-    statements. Just loop over the object to read in chunks.
-
-    **Usage**
-
-    ```python fixture:running_app
-    from modal import Sandbox
-
-    sandbox = Sandbox.create(
-        "bash",
-        "-c",
-        "for i in $(seq 1 10); do echo foo; sleep 0.1; done",
-        app=running_app,
-    )
-    for message in sandbox.stdout:
-        print(f"Message: {message}")
-    ```
-    """
+class _StreamReaderThroughServer(Generic[T]):
+    """A StreamReader implementation that reads from the server."""
 
     _stream: Optional[AsyncGenerator[Optional[bytes], None]]
 
@@ -133,10 +117,6 @@ class _StreamReader(Generic[T]):
         if object_type == "sandbox" and not text:
             raise ValueError("Sandbox streams must have text mode enabled.")
 
-        # line-buffering is only supported when text=True
-        if by_line and not text:
-            raise ValueError("line-buffering is only supported when text=True")
-
         self._text = text
         self._by_line = by_line
 
@@ -166,19 +146,7 @@ class _StreamReader(Generic[T]):
         return self._file_descriptor
 
     async def read(self) -> T:
-        """Fetch the entire contents of the stream until EOF.
-
-        **Usage**
-
-        ```python fixture:running_app
-        from modal import Sandbox
-
-        sandbox = Sandbox.create("echo", "hello", app=running_app)
-        sandbox.wait()
-
-        print(sandbox.stdout.read())
-        ```
-        """
+        """Fetch the entire contents of the stream until EOF."""
         data_str = ""
         data_bytes = b""
         logger.debug(f"{self._object_id} StreamReader fd={self._file_descriptor} read starting")
@@ -330,11 +298,6 @@ class _StreamReader(Generic[T]):
                 self._stream = self._get_logs()
         return self._stream
 
-    def __aiter__(self) -> AsyncIterator[T]:
-        """mdmd:hidden"""
-        self._ensure_stream()
-        return self
-
     async def __anext__(self) -> T:
         """mdmd:hidden"""
         stream = self._ensure_stream()
@@ -356,6 +319,289 @@ class _StreamReader(Generic[T]):
             await self._stream.aclose()
 
 
+async def _decode_bytes_stream_to_str(stream: AsyncGenerator[bytes, None]) -> 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``.
+    """
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="strict")
+    async for item in stream:
+        text = decoder.decode(item, final=False)
+        if text:
+            yield text
+    # Flush any buffered partial character at end-of-stream
+    tail = decoder.decode(b"", final=True)
+    if tail:
+        yield tail
+
+
+async def _stream_by_line(stream: AsyncGenerator[bytes, None]) -> AsyncGenerator[bytes, None]:
+    """Yield complete lines only (ending with \n), buffering partial lines until complete."""
+    line_buffer = b""
+    async for message in stream:
+        assert isinstance(message, bytes)
+        line_buffer += message
+        while b"\n" in line_buffer:
+            line, line_buffer = line_buffer.split(b"\n", 1)
+            yield line + b"\n"
+
+    if line_buffer:
+        yield line_buffer
+
+
+@dataclass
+class _StreamReaderThroughCommandRouterParams:
+    file_descriptor: "api_pb2.FileDescriptor.ValueType"
+    task_id: str
+    object_id: str
+    command_router_client: TaskCommandRouterClient
+    deadline: Optional[float]
+
+
+async def _stdio_stream_from_command_router(
+    params: _StreamReaderThroughCommandRouterParams,
+) -> AsyncGenerator[bytes, None]:
+    """Stream raw bytes from the router client."""
+    stream = params.command_router_client.exec_stdio_read(
+        params.task_id, params.object_id, params.file_descriptor, params.deadline
+    )
+    try:
+        async for item in stream:
+            if len(item.data) == 0:
+                # This is an error.
+                raise ValueError("Received empty message streaming stdio from sandbox.")
+
+            yield item.data
+    except ExecTimeoutError:
+        logger.debug(f"Deadline exceeded while streaming stdio for exec {params.object_id}")
+        # TODO(saltzm): This is a weird API, but customers currently may rely on it. We
+        # should probably raise this error rather than just ending the stream.
+        return
+
+
+class _BytesStreamReaderThroughCommandRouter(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:
+        self._params = params
+        self._stream = None
+
+    @property
+    def file_descriptor(self) -> int:
+        return self._params.file_descriptor
+
+    async def read(self) -> T:
+        data_bytes = b""
+        async for part in self:
+            data_bytes += cast(bytes, part)
+        return cast(T, data_bytes)
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        return self
+
+    async def __anext__(self) -> T:
+        if self._stream is None:
+            self._stream = _stdio_stream_from_command_router(self._params)
+        # This raises StopAsyncIteration if the stream is at EOF.
+        return cast(T, await self._stream.__anext__())
+
+    async def aclose(self):
+        if self._stream:
+            await self._stream.aclose()
+
+
+class _TextStreamReaderThroughCommandRouter(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:
+        self._params = params
+        self._by_line = by_line
+        self._stream = None
+
+    @property
+    def file_descriptor(self) -> int:
+        return self._params.file_descriptor
+
+    async def read(self) -> T:
+        data_str = ""
+        async for part in self:
+            data_str += cast(str, part)
+        return cast(T, data_str)
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        return self
+
+    async def __anext__(self) -> T:
+        if self._stream is None:
+            bytes_stream = _stdio_stream_from_command_router(self._params)
+            if self._by_line:
+                self._stream = _decode_bytes_stream_to_str(_stream_by_line(bytes_stream))
+            else:
+                self._stream = _decode_bytes_stream_to_str(bytes_stream)
+        # This raises StopAsyncIteration if the stream is at EOF.
+        return cast(T, await self._stream.__anext__())
+
+    async def aclose(self):
+        if self._stream:
+            await self._stream.aclose()
+
+
+class _DevnullStreamReader(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: "api_pb2.FileDescriptor.ValueType") -> None:
+        self._file_descriptor = file_descriptor
+
+    @property
+    def file_descriptor(self) -> int:
+        return self._file_descriptor
+
+    async def read(self) -> T:
+        raise ValueError("read is not supported for a stream configured with StreamType.DEVNULL")
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        raise ValueError("__aiter__ is not supported for a stream configured with StreamType.DEVNULL")
+
+    async def __anext__(self) -> T:
+        raise ValueError("__anext__ is not supported for a stream configured with StreamType.DEVNULL")
+
+    async def aclose(self):
+        raise ValueError("aclose is not supported for a stream configured with StreamType.DEVNULL")
+
+
+class _StreamReader(Generic[T]):
+    """Retrieve logs from a stream (`stdout` or `stderr`).
+
+    As an asynchronous iterable, the object supports the `for` and `async for`
+    statements. Just loop over the object to read in chunks.
+
+    **Usage**
+
+    ```python fixture:running_app
+    from modal import Sandbox
+
+    sandbox = Sandbox.create(
+        "bash",
+        "-c",
+        "for i in $(seq 1 10); do echo foo; sleep 0.1; done",
+        app=running_app,
+    )
+    for message in sandbox.stdout:
+        print(f"Message: {message}")
+    ```
+    """
+
+    def __init__(
+        self,
+        file_descriptor: "api_pb2.FileDescriptor.ValueType",
+        object_id: str,
+        object_type: Literal["sandbox", "container_process"],
+        client: _Client,
+        stream_type: StreamType = StreamType.PIPE,
+        text: bool = True,
+        by_line: bool = False,
+        deadline: Optional[float] = None,
+        command_router_client: Optional[TaskCommandRouterClient] = None,
+        task_id: Optional[str] = None,
+    ) -> None:
+        """mdmd:hidden"""
+        if by_line and not text:
+            raise ValueError("line-buffering is only supported when text=True")
+
+        if command_router_client is None:
+            self._impl = _StreamReaderThroughServer(
+                file_descriptor, object_id, object_type, client, stream_type, text, by_line, deadline
+            )
+        else:
+            # The only reason task_id is optional is because StreamReader is
+            # also used for sandbox logs, which don't have a task ID available
+            # when the StreamReader is created.
+            assert task_id is not None
+            assert object_type == "container_process"
+            if stream_type == StreamType.DEVNULL:
+                self._impl = _DevnullStreamReader(file_descriptor)
+            else:
+                assert stream_type == StreamType.PIPE or stream_type == StreamType.STDOUT
+                # TODO(saltzm): The original implementation of STDOUT StreamType in
+                # _StreamReaderThroughServer prints to stdout immediately. This doesn't match
+                # python subprocess.run, which uses None to print to stdout immediately, and uses
+                # STDOUT as an argument to stderr to redirect stderr to the stdout stream. We should
+                # implement the old behavior here before moving out of beta, but after that
+                # we should consider changing the API to match python subprocess.run. I don't expect
+                # many customers are using this in any case, so I think it's fine to leave this
+                # unimplemented for now.
+                if stream_type == StreamType.STDOUT:
+                    raise NotImplementedError(
+                        "Currently only the PIPE stream type is supported when using exec "
+                        "through a task command router, which is currently in beta."
+                    )
+                params = _StreamReaderThroughCommandRouterParams(
+                    file_descriptor, task_id, object_id, command_router_client, deadline
+                )
+                if text:
+                    self._impl = _TextStreamReaderThroughCommandRouter(params, by_line)
+                else:
+                    self._impl = _BytesStreamReaderThroughCommandRouter(params)
+
+    @property
+    def file_descriptor(self) -> int:
+        """Possible values are `1` for stdout and `2` for stderr."""
+        return self._impl.file_descriptor
+
+    async def read(self) -> T:
+        """Fetch the entire contents of the stream until EOF.
+
+        **Usage**
+
+        ```python fixture:running_app
+        from modal import Sandbox
+
+        sandbox = Sandbox.create("echo", "hello", app=running_app)
+        sandbox.wait()
+
+        print(sandbox.stdout.read())
+        ```
+        """
+        return await self._impl.read()
+
+    # TODO(saltzm): I'd prefer to have the implementation classes only implement __aiter__
+    # and have them return generator functions directly, but synchronicity doesn't let us
+    # return self._impl.__aiter__() here because it won't properly wrap the implementation
+    # classes.
+    def __aiter__(self) -> AsyncIterator[T]:
+        """mdmd:hidden"""
+        return self
+
+    async def __anext__(self) -> T:
+        """mdmd:hidden"""
+        return await self._impl.__anext__()
+
+    async def aclose(self):
+        """mdmd:hidden"""
+        await self._impl.aclose()
+
+
 MAX_BUFFER_SIZE = 2 * 1024 * 1024