modAL 1.2.3.dev9__tar.gz → 1.2.3.dev11__tar.gz

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/PKG-INFO

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

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal/_utils/grpc_utils.py

@@ -9,7 +9,8 @@ import urllib.parse
 import uuid
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
-from typing import Any, Optional, TypeVar
+from functools import cache
+from typing import Any, Optional, Sequence, TypeVar
 
 import grpclib.client
 import grpclib.config
@@ -17,11 +18,14 @@ import grpclib.events
 import grpclib.protocol
 import grpclib.stream
 from google.protobuf.message import Message
+from google.protobuf.symbol_database import SymbolDatabase
 from grpclib import GRPCError, Status
+from grpclib.encoding.base import StatusDetailsCodecBase
 from grpclib.exceptions import StreamTerminatedError
 from grpclib.protocol import H2Protocol
 
 from modal.exception import AuthError, ConnectionError
+from modal_proto import api_pb2
 from modal_version import __version__
 
 from .._traceback import suppress_tb_frames
@@ -107,6 +111,56 @@ class ConnectionManager:
         self._channels.clear()
 
 
+@cache
+def _sym_db() -> SymbolDatabase:
+    from google.protobuf.symbol_database import Default
+
+    return Default()
+
+
+class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
+    """grpclib compatible details codec.
+
+    The server can encode the details using `google.rpc.Status` using grpclib's default codec and this custom codec
+    can decode it into a `api_pb2.RPCStatus`.
+    """
+
+    def encode(
+        self,
+        status: Status,
+        message: Optional[str],
+        details: Optional[Sequence[Message]],
+    ) -> bytes:
+        details_proto = api_pb2.RPCStatus(code=status.value, message=message or "")
+        if details is not None:
+            for detail in details:
+                detail_container = details_proto.details.add()
+                detail_container.Pack(detail)
+        return details_proto.SerializeToString()
+
+    def decode(
+        self,
+        status: Status,
+        message: Optional[str],
+        data: bytes,
+    ) -> Any:
+        sym_db = _sym_db()
+        details_proto = api_pb2.RPCStatus.FromString(data)
+
+        details = []
+        for detail_container in details_proto.details:
+            # If we do not know how to decode an emssage, we'll ignore it.
+            with contextlib.suppress(Exception):
+                msg_type = sym_db.GetSymbol(detail_container.TypeName())
+                detail = msg_type()
+                detail_container.Unpack(detail)
+                details.append(detail)
+        return details
+
+
+custom_detail_codec = CustomProtoStatusDetailsCodec()
+
+
 def create_channel(
     server_url: str,
     metadata: dict[str, str] = {},
@@ -125,7 +179,7 @@ def create_channel(
     )
 
     if o.scheme == "unix":
-        channel = grpclib.client.Channel(path=o.path, config=config)  # probably pointless to use a pool ever
+        channel = grpclib.client.Channel(path=o.path, config=config, status_details_codec=custom_detail_codec)
     elif o.scheme in ("http", "https"):
         target = o.netloc
         parts = target.split(":")
@@ -133,7 +187,7 @@ def create_channel(
         ssl = o.scheme.endswith("s")
         host = parts[0]
         port = int(parts[1]) if len(parts) == 2 else 443 if ssl else 80
-        channel = grpclib.client.Channel(host, port, ssl=ssl, config=config)
+        channel = grpclib.client.Channel(host, port, ssl=ssl, config=config, status_details_codec=custom_detail_codec)
     else:
         raise Exception(f"Unknown scheme: {o.scheme}")
 
@@ -258,7 +312,6 @@ async def _retry_transient_errors(
                     raise AuthError(exc.message)
                 else:
                     raise exc
-
             if retry.max_retries is not None and n_retries >= retry.max_retries:
                 final_attempt = True
             elif total_deadline is not None and time.time() + delay + retry.attempt_timeout_floor >= total_deadline:

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/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.3.dev9",
+        version: str = "1.2.3.dev11",
     ):
         """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.3.dev9",
+        version: str = "1.2.3.dev11",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal/io_streams.py

@@ -1,6 +1,8 @@
 # Copyright Modal Labs 2022
 import asyncio
 import codecs
+import contextlib
+import sys
 import time
 from collections.abc import AsyncGenerator, AsyncIterator
 from dataclasses import dataclass
@@ -377,7 +379,7 @@ async def _stdio_stream_from_command_router(
         return
 
 
-class _BytesStreamReaderThroughCommandRouter(Generic[T]):
+class _BytesStreamReaderThroughCommandRouter:
     """
     StreamReader implementation that will read directly from the worker that
     hosts the sandbox.
@@ -396,27 +398,27 @@ class _BytesStreamReaderThroughCommandRouter(Generic[T]):
     def file_descriptor(self) -> int:
         return self._params.file_descriptor
 
-    async def read(self) -> T:
+    async def read(self) -> bytes:
         data_bytes = b""
         async for part in self:
             data_bytes += cast(bytes, part)
-        return cast(T, data_bytes)
+        return data_bytes
 
-    def __aiter__(self) -> AsyncIterator[T]:
+    def __aiter__(self) -> AsyncIterator[bytes]:
         return self
 
-    async def __anext__(self) -> T:
+    async def __anext__(self) -> bytes:
         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__())
+        return await self._stream.__anext__()
 
     async def aclose(self):
         if self._stream:
             await self._stream.aclose()
 
 
-class _TextStreamReaderThroughCommandRouter(Generic[T]):
+class _TextStreamReaderThroughCommandRouter:
     """
     StreamReader implementation that will read directly from the worker
     that hosts the sandbox.
@@ -437,16 +439,16 @@ class _TextStreamReaderThroughCommandRouter(Generic[T]):
     def file_descriptor(self) -> int:
         return self._params.file_descriptor
 
-    async def read(self) -> T:
+    async def read(self) -> str:
         data_str = ""
         async for part in self:
             data_str += cast(str, part)
-        return cast(T, data_str)
+        return data_str
 
-    def __aiter__(self) -> AsyncIterator[T]:
+    def __aiter__(self) -> AsyncIterator[str]:
         return self
 
-    async def __anext__(self) -> T:
+    async def __anext__(self) -> str:
         if self._stream is None:
             bytes_stream = _stdio_stream_from_command_router(self._params)
             if self._by_line:
@@ -454,13 +456,88 @@ class _TextStreamReaderThroughCommandRouter(Generic[T]):
             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__())
+        return await self._stream.__anext__()
 
     async def aclose(self):
         if self._stream:
             await self._stream.aclose()
 
 
+class _StdoutPrintingStreamReaderThroughCommandRouter(Generic[T]):
+    """
+    StreamReader implementation for StreamType.STDOUT when using the task command router.
+
+    This mirrors the behavior from the server-backed implementation: the stream is printed to
+    the local stdout immediately and is not readable via StreamReader methods.
+    """
+
+    _reader: Union[_TextStreamReaderThroughCommandRouter, _BytesStreamReaderThroughCommandRouter]
+
+    def __init__(
+        self,
+        reader: Union[_TextStreamReaderThroughCommandRouter, _BytesStreamReaderThroughCommandRouter],
+    ) -> None:
+        self._reader = reader
+        self._task: Optional[asyncio.Task[None]] = None
+        self._closed = False
+        # Kick off a background task that reads from the underlying text stream and prints to stdout.
+        self._start_printing_task()
+
+    @property
+    def file_descriptor(self) -> int:
+        return self._reader.file_descriptor
+
+    def _start_printing_task(self) -> None:
+        async def _run():
+            try:
+
+                def print_text_part(part: Union[str, bytes]) -> None:
+                    assert isinstance(part, str)
+                    print(cast(str, part), end="")
+
+                def print_bytes_part(part: Union[str, bytes]) -> None:
+                    assert isinstance(part, bytes)
+                    sys.stdout.buffer.write(cast(bytes, part))
+                    sys.stdout.buffer.flush()
+
+                if isinstance(self._reader, _BytesStreamReaderThroughCommandRouter):
+                    print_part = print_bytes_part
+                elif isinstance(self._reader, _TextStreamReaderThroughCommandRouter):
+                    print_part = print_text_part
+                else:
+                    raise ValueError("Unsupported reader type")
+
+                async for part in self._reader:
+                    print_part(part)
+            except Exception as e:
+                logger.exception(f"Error printing stream: {e}")
+            finally:
+                closed, self._closed = self._closed, True
+                if not closed:
+                    await self._reader.aclose()
+
+        self._task = asyncio.create_task(_run())
+
+    async def read(self) -> T:
+        raise InvalidError("Output can only be retrieved using the PIPE stream type.")
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        raise InvalidError("Output can only be retrieved using the PIPE stream type.")
+
+    async def __anext__(self) -> T:
+        raise InvalidError("Output can only be retrieved using the PIPE stream type.")
+
+    async def aclose(self):
+        if self._task is not None:
+            self._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._task
+            self._task = None
+        closed, self._closed = self._closed, True
+        if not closed:
+            await self._reader.aclose()
+
+
 class _DevnullStreamReader(Generic[T]):
     """StreamReader implementation for a stream configured with
     StreamType.DEVNULL. Throws an error if read or any other method is
@@ -499,6 +576,7 @@ class _StreamReader(Generic[T]):
         _DevnullStreamReader,
         _TextStreamReaderThroughCommandRouter,
         _BytesStreamReaderThroughCommandRouter,
+        _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
 
     def __init__(
@@ -523,35 +601,26 @@ class _StreamReader(Generic[T]):
                 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.
+            # 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 the STDOUT stream type is not 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)
+                    reader = _TextStreamReaderThroughCommandRouter(params, by_line)
+                else:
+                    reader = _BytesStreamReaderThroughCommandRouter(params)
+
+                if stream_type == StreamType.STDOUT:
+                    self._impl = _StdoutPrintingStreamReaderThroughCommandRouter(reader)
                 else:
-                    self._impl = _BytesStreamReaderThroughCommandRouter(params)
+                    self._impl = reader
 
     @property
     def file_descriptor(self) -> int:
@@ -560,7 +629,7 @@ class _StreamReader(Generic[T]):
 
     async def read(self) -> T:
         """Fetch the entire contents of the stream until EOF."""
-        return await self._impl.read()
+        return cast(T, 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
@@ -572,7 +641,7 @@ class _StreamReader(Generic[T]):
 
     async def __anext__(self) -> T:
         """mdmd:hidden"""
-        return await self._impl.__anext__()
+        return cast(T, await self._impl.__anext__())
 
     async def aclose(self):
         """mdmd:hidden"""

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal/io_streams.pyi

@@ -127,7 +127,7 @@ def _stdio_stream_from_command_router(
     """Stream raw bytes from the router client."""
     ...
 
-class _BytesStreamReaderThroughCommandRouter(typing.Generic[T]):
+class _BytesStreamReaderThroughCommandRouter:
     """StreamReader implementation that will read directly from the worker that
     hosts the sandbox.
 
@@ -139,12 +139,12 @@ class _BytesStreamReaderThroughCommandRouter(typing.Generic[T]):
 
     @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 read(self) -> bytes: ...
+    def __aiter__(self) -> collections.abc.AsyncIterator[bytes]: ...
+    async def __anext__(self) -> bytes: ...
     async def aclose(self): ...
 
-class _TextStreamReaderThroughCommandRouter(typing.Generic[T]):
+class _TextStreamReaderThroughCommandRouter:
     """StreamReader implementation that will read directly from the worker
     that hosts the sandbox.
 
@@ -156,6 +156,29 @@ class _TextStreamReaderThroughCommandRouter(typing.Generic[T]):
 
     @property
     def file_descriptor(self) -> int: ...
+    async def read(self) -> str: ...
+    def __aiter__(self) -> collections.abc.AsyncIterator[str]: ...
+    async def __anext__(self) -> str: ...
+    async def aclose(self): ...
+
+class _StdoutPrintingStreamReaderThroughCommandRouter(typing.Generic[T]):
+    """StreamReader implementation for StreamType.STDOUT when using the task command router.
+
+    This mirrors the behavior from the server-backed implementation: the stream is printed to
+    the local stdout immediately and is not readable via StreamReader methods.
+    """
+
+    _reader: typing.Union[_TextStreamReaderThroughCommandRouter, _BytesStreamReaderThroughCommandRouter]
+
+    def __init__(
+        self, reader: typing.Union[_TextStreamReaderThroughCommandRouter, _BytesStreamReaderThroughCommandRouter]
+    ) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    @property
+    def file_descriptor(self) -> int: ...
+    def _start_printing_task(self) -> None: ...
     async def read(self) -> T: ...
     def __aiter__(self) -> collections.abc.AsyncIterator[T]: ...
     async def __anext__(self) -> T: ...
@@ -189,6 +212,7 @@ class _StreamReader(typing.Generic[T]):
         _DevnullStreamReader,
         _TextStreamReaderThroughCommandRouter,
         _BytesStreamReaderThroughCommandRouter,
+        _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
 
     def __init__(
@@ -357,6 +381,7 @@ class StreamReader(typing.Generic[T]):
         _DevnullStreamReader,
         _TextStreamReaderThroughCommandRouter,
         _BytesStreamReaderThroughCommandRouter,
+        _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
 
     def __init__(

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal/sandbox.py

@@ -928,12 +928,8 @@ class _Sandbox(_Object, type_prefix="sb"):
         elif stdout == StreamType.DEVNULL:
             stdout_config = sr_pb2.TaskExecStdoutConfig.TASK_EXEC_STDOUT_CONFIG_DEVNULL
         elif stdout == StreamType.STDOUT:
-            # TODO(saltzm): This is a behavior change from the old implementation. We should
-            # probably implement the old behavior of printing to stdout before moving out of beta.
-            raise NotImplementedError(
-                "Currently the STDOUT stream type is not supported when using exec "
-                "through a task command router, which is currently in beta."
-            )
+            # Stream stdout to the client so that it can be printed locally in the reader.
+            stdout_config = sr_pb2.TaskExecStdoutConfig.TASK_EXEC_STDOUT_CONFIG_PIPE
         else:
             raise ValueError("Unsupported StreamType for stdout")
 

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal.egg-info/PKG-INFO

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

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal_proto/api.proto

@@ -4,6 +4,7 @@ option go_package = "github.com/modal-labs/modal/go/proto";
 
 package modal.client;
 
+import "google/protobuf/any.proto";
 import "google/protobuf/empty.proto";
 import "google/protobuf/struct.proto";
 import "google/protobuf/timestamp.proto";
@@ -2045,6 +2046,7 @@ message GPUConfig {
   string gpu_type = 4;
 }
 
+
 message GeneratorDone {  // Sent as the output when a generator finishes running.
   uint64 items_total = 1;
 }
@@ -2086,6 +2088,7 @@ message GenericResult {  // Used for both tasks and function outputs
   string propagation_reason = 13; // (?)
 }
 
+
 message Image {
   repeated BaseImage base_images = 5;
   repeated string dockerfile_commands = 6;
@@ -2631,6 +2634,16 @@ message QueuePutRequest {
   int32 partition_ttl_seconds = 6;
 }
 
+// A copy google.rpc.Status for GRPCError.details:
+// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
+// RPCStatus is compatible with google.rpc.Status, so one can encode messages using
+// google.rpc.Status. The `details` field can be a list of any message, but for client
+// to decode it, the messages should be defined here (`modal_proto`).
+message RPCStatus {
+  int32 code = 1;
+  string message = 2;
+  repeated google.protobuf.Any details = 3;
+}
 
 message RateLimit {
   int32 limit = 1;

{modal-1.2.3.dev9 → modal-1.2.3.dev11}/modal_proto/api_grpc.py

@@ -9,6 +9,7 @@ import grpclib.client
 if typing.TYPE_CHECKING:
     import grpclib.server
 
+import google.protobuf.any_pb2
 import google.protobuf.empty_pb2
 import google.protobuf.struct_pb2
 import google.protobuf.timestamp_pb2