modal 1.2.5.dev4__tar.gz → 1.2.5.dev6__tar.gz

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/PKG-INFO

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

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/_utils/grpc_utils.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import asyncio
 import contextlib
+import os
 import platform
 import socket
 import time
@@ -396,7 +397,8 @@ async def _retry_transient_errors(
                 ):
                     last_server_retry_warning_time = now
                     logger.warning(
-                        f"Warning: Received {exc.status} status: {exc.message}. "
+                        f"Warning: Received {exc.status}{os.linesep}"
+                        f"{exc.message}{os.linesep}"
                         f"Will retry in {server_delay:0.2f} seconds."
                     )
 

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/_utils/task_command_router_client.py

@@ -5,7 +5,7 @@ import json
 import ssl
 import time
 import urllib.parse
-from typing import AsyncIterator, Optional
+from typing import AsyncGenerator, Optional
 
 import grpclib.client
 import grpclib.config
@@ -18,6 +18,7 @@ from modal.exception import ExecTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
+from .async_utils import aclosing
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
 
 
@@ -242,7 +243,7 @@ class TaskCommandRouterClient:
         # Quotes around the type required for protobuf 3.19.
         file_descriptor: "api_pb2.FileDescriptor.ValueType",
         deadline: Optional[float] = None,
-    ) -> AsyncIterator[sr_pb2.TaskExecStdioReadResponse]:
+    ) -> AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]:
         """Stream stdout/stderr batches from the task, properly retrying on transient errors.
 
         Args:
@@ -253,7 +254,7 @@ class TaskCommandRouterClient:
               None, wait forever. If the deadline is exceeded, raises an
               ExecTimeoutError.
         Returns:
-            AsyncIterator[sr_pb2.TaskExecStdioReadResponse]: A stream of stdout/stderr batches.
+            AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]: A stream of stdout/stderr batches.
         Raises:
             ExecTimeoutError: If the deadline is exceeded.
             Other errors: If retries are exhausted on transient errors or if there's an error
@@ -268,8 +269,9 @@ class TaskCommandRouterClient:
         else:
             raise ValueError(f"Invalid file descriptor: {file_descriptor}")
 
-        async for item in self._stream_stdio(task_id, exec_id, sr_fd, deadline):
-            yield item
+        async with aclosing(self._stream_stdio(task_id, exec_id, sr_fd, deadline)) as stream:
+            async for item in stream:
+                yield item
 
     async def exec_stdin_write(
         self, task_id: str, exec_id: str, offset: int, data: bytes, eof: bool
@@ -453,7 +455,7 @@ class TaskCommandRouterClient:
         # Quotes around the type required for protobuf 3.19.
         file_descriptor: "sr_pb2.TaskExecStdioFileDescriptor.ValueType",
         deadline: Optional[float] = None,
-    ) -> AsyncIterator[sr_pb2.TaskExecStdioReadResponse]:
+    ) -> AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]:
         """Stream stdio from the task, properly updating the offset and retrying on transient errors.
         Raises ExecTimeoutError if the deadline is exceeded.
         """

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev4",
+        version: str = "1.2.5.dev6",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev4",
+        version: str = "1.2.5.dev6",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/functions.pyi

@@ -408,7 +408,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         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."""
             ...
@@ -417,7 +417,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -444,7 +444,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         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.
 
@@ -468,7 +468,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -477,7 +477,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         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.
 
@@ -498,7 +498,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/io_streams.py

@@ -11,6 +11,7 @@ from typing import (
     Generic,
     Literal,
     Optional,
+    TextIO,
     TypeVar,
     Union,
     cast,
@@ -22,7 +23,7 @@ from grpclib.exceptions import GRPCError, StreamTerminatedError
 from modal.exception import ClientClosed, ExecTimeoutError, InvalidError
 from modal_proto import api_pb2
 
-from ._utils.async_utils import synchronize_api
+from ._utils.async_utils import aclosing, synchronize_api
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
@@ -292,7 +293,7 @@ class _StreamReaderThroughServer(Generic[T]):
             yield self._line_buffer
             self._line_buffer = b""
 
-    def _ensure_stream(self) -> AsyncGenerator[T, None]:
+    def __aiter__(self) -> AsyncGenerator[T, None]:
         if not self._stream:
             if self._by_line:
                 # TODO: This is quite odd - it does line buffering in binary mode
@@ -306,11 +307,6 @@ class _StreamReaderThroughServer(Generic[T]):
             self._stream = cast(AsyncGenerator[T, None], stream)
         return self._stream
 
-    async def __anext__(self) -> T:
-        """mdmd:hidden"""
-        stream = self._ensure_stream()
-        return cast(T, await stream.__anext__())
-
     async def aclose(self):
         """mdmd:hidden"""
         if self._stream:
@@ -336,17 +332,23 @@ async def _decode_bytes_stream_to_str(stream: AsyncGenerator[bytes, None]) -> As
 
 
 async def _stream_by_line(stream: AsyncGenerator[bytes, None]) -> AsyncGenerator[bytes, None]:
-    """Yield complete lines only (ending with \n), buffering partial lines until complete."""
+    """Yield complete lines only (ending with \n), buffering partial lines until complete.
+
+    When this generator returns, the underlying generator is closed.
+    """
     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"
+    try:
+        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
+        if line_buffer:
+            yield line_buffer
+    finally:
+        await stream.aclose()
 
 
 @dataclass
@@ -362,21 +364,23 @@ 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
+    async with aclosing(
+        params.command_router_client.exec_stdio_read(
+            params.task_id, params.object_id, params.file_descriptor, params.deadline
+        )
+    ) as stream:
+        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:
@@ -404,18 +408,13 @@ class _BytesStreamReaderThroughCommandRouter:
             data_bytes += cast(bytes, part)
         return data_bytes
 
-    def __aiter__(self) -> AsyncIterator[bytes]:
-        return self
+    def __aiter__(self) -> AsyncGenerator[bytes, None]:
+        return _stdio_stream_from_command_router(self._params)
 
-    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 await self._stream.__anext__()
-
-    async def aclose(self):
-        if self._stream:
-            await self._stream.aclose()
+    async def _print_all(self, output_stream: TextIO) -> None:
+        async for part in self:
+            output_stream.buffer.write(part)
+            output_stream.buffer.flush()
 
 
 class _TextStreamReaderThroughCommandRouter:
@@ -433,7 +432,6 @@ class _TextStreamReaderThroughCommandRouter:
     ) -> None:
         self._params = params
         self._by_line = by_line
-        self._stream = None
 
     @property
     def file_descriptor(self) -> int:
@@ -445,22 +443,21 @@ class _TextStreamReaderThroughCommandRouter:
             data_str += cast(str, part)
         return data_str
 
-    def __aiter__(self) -> AsyncIterator[str]:
-        return self
-
-    async def __anext__(self) -> str:
-        if self._stream is None:
-            bytes_stream = _stdio_stream_from_command_router(self._params)
+    async def __aiter__(self) -> AsyncGenerator[str, None]:
+        async with aclosing(_stdio_stream_from_command_router(self._params)) as bytes_stream:
             if self._by_line:
-                self._stream = _decode_bytes_stream_to_str(_stream_by_line(bytes_stream))
+                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 await self._stream.__anext__()
+                stream = _decode_bytes_stream_to_str(bytes_stream)
 
-    async def aclose(self):
-        if self._stream:
-            await self._stream.aclose()
+            async with aclosing(stream):
+                async for part in stream:
+                    yield part
+
+    async def _print_all(self, output_stream: TextIO) -> None:
+        async with aclosing(self.__aiter__()) as stream:
+            async for part in stream:
+                output_stream.write(part)
 
 
 class _StdoutPrintingStreamReaderThroughCommandRouter(Generic[T]):
@@ -479,7 +476,6 @@ class _StdoutPrintingStreamReaderThroughCommandRouter(Generic[T]):
     ) -> 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()
 
@@ -490,31 +486,9 @@ class _StdoutPrintingStreamReaderThroughCommandRouter(Generic[T]):
     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)
+                await self._reader._print_all(sys.stdout)
             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())
 
@@ -533,9 +507,6 @@ class _StdoutPrintingStreamReaderThroughCommandRouter(Generic[T]):
             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]):
@@ -578,6 +549,7 @@ class _StreamReader(Generic[T]):
         _BytesStreamReaderThroughCommandRouter,
         _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
+    _read_gen: Optional[AsyncGenerator[T, None]] = None
 
     def __init__(
         self,
@@ -631,21 +603,27 @@ class _StreamReader(Generic[T]):
         """Fetch the entire contents of the stream until EOF."""
         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
-    # return self._impl.__aiter__() here because it won't properly wrap the implementation
-    # classes.
-    def __aiter__(self) -> AsyncIterator[T]:
-        """mdmd:hidden"""
-        return self
+    def __aiter__(self) -> AsyncGenerator[T, None]:
+        if not self._read_gen:
+            self._read_gen = cast(AsyncGenerator[T, None], self._impl.__aiter__())
+        return self._read_gen
 
     async def __anext__(self) -> T:
-        """mdmd:hidden"""
-        return cast(T, await self._impl.__anext__())
+        """Deprecated: This exists for backwards compatibility and will be removed in a future version of Modal
+
+        Only use next/anext on the return value of iter/aiter on the StreamReader object (treat streamreader as
+        an iterable, not an iterator).
+        """
+        if not self._read_gen:
+            self.__aiter__()  # initialize the read generator
+        assert self._read_gen
+        return await self._read_gen.__anext__()
 
     async def aclose(self):
         """mdmd:hidden"""
-        await self._impl.aclose()
+        if self._read_gen:
+            await self._read_gen.aclose()
+            self._read_gen = None
 
 
 MAX_BUFFER_SIZE = 2 * 1024 * 1024

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal/io_streams.pyi

@@ -68,11 +68,7 @@ class _StreamReaderThroughServer(typing.Generic[T]):
         """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"""
-        ...
-
+    def __aiter__(self) -> collections.abc.AsyncGenerator[T, None]: ...
     async def aclose(self):
         """mdmd:hidden"""
         ...
@@ -90,6 +86,9 @@ def _decode_bytes_stream_to_str(
 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.
+
+        When this generator returns, the underlying generator is closed.
+
     """
     ...
 
@@ -140,9 +139,8 @@ class _BytesStreamReaderThroughCommandRouter:
     @property
     def file_descriptor(self) -> int: ...
     async def read(self) -> bytes: ...
-    def __aiter__(self) -> collections.abc.AsyncIterator[bytes]: ...
-    async def __anext__(self) -> bytes: ...
-    async def aclose(self): ...
+    def __aiter__(self) -> collections.abc.AsyncGenerator[bytes, None]: ...
+    async def _print_all(self, output_stream: typing.TextIO) -> None: ...
 
 class _TextStreamReaderThroughCommandRouter:
     """StreamReader implementation that will read directly from the worker
@@ -157,9 +155,8 @@ class _TextStreamReaderThroughCommandRouter:
     @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): ...
+    def __aiter__(self) -> collections.abc.AsyncGenerator[str, None]: ...
+    async def _print_all(self, output_stream: typing.TextIO) -> None: ...
 
 class _StdoutPrintingStreamReaderThroughCommandRouter(typing.Generic[T]):
     """StreamReader implementation for StreamType.STDOUT when using the task command router.
@@ -214,6 +211,7 @@ class _StreamReader(typing.Generic[T]):
         _BytesStreamReaderThroughCommandRouter,
         _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
+    _read_gen: typing.Optional[collections.abc.AsyncGenerator[T, None]]
 
     def __init__(
         self,
@@ -240,12 +238,13 @@ class _StreamReader(typing.Generic[T]):
         """Fetch the entire contents of the stream until EOF."""
         ...
 
-    def __aiter__(self) -> collections.abc.AsyncIterator[T]:
-        """mdmd:hidden"""
-        ...
-
+    def __aiter__(self) -> collections.abc.AsyncGenerator[T, None]: ...
     async def __anext__(self) -> T:
-        """mdmd:hidden"""
+        """Deprecated: This exists for backwards compatibility and will be removed in a future version of Modal
+
+        Only use next/anext on the return value of iter/aiter on the StreamReader object (treat streamreader as
+        an iterable, not an iterator).
+        """
         ...
 
     async def aclose(self):
@@ -383,6 +382,7 @@ class StreamReader(typing.Generic[T]):
         _BytesStreamReaderThroughCommandRouter,
         _StdoutPrintingStreamReaderThroughCommandRouter,
     ]
+    _read_gen: typing.Optional[collections.abc.AsyncGenerator[T, None]]
 
     def __init__(
         self,
@@ -416,20 +416,22 @@ class StreamReader(typing.Generic[T]):
 
     read: __read_spec[T, typing_extensions.Self]
 
-    def __iter__(self) -> typing.Iterator[T]:
-        """mdmd:hidden"""
-        ...
-
-    def __aiter__(self) -> collections.abc.AsyncIterator[T]:
-        """mdmd:hidden"""
-        ...
-
+    def __iter__(self) -> typing.Generator[T, None, None]: ...
+    def __aiter__(self) -> collections.abc.AsyncGenerator[T, None]: ...
     def __next__(self) -> T:
-        """mdmd:hidden"""
+        """Deprecated: This exists for backwards compatibility and will be removed in a future version of Modal
+
+        Only use next/anext on the return value of iter/aiter on the StreamReader object (treat streamreader as
+        an iterable, not an iterator).
+        """
         ...
 
     async def __anext__(self) -> T:
-        """mdmd:hidden"""
+        """Deprecated: This exists for backwards compatibility and will be removed in a future version of Modal
+
+        Only use next/anext on the return value of iter/aiter on the StreamReader object (treat streamreader as
+        an iterable, not an iterator).
+        """
         ...
 
     def close(self):

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal.egg-info/PKG-INFO

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

{modal-1.2.5.dev4 → modal-1.2.5.dev6}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.2.5.dev4"
+__version__ = "1.2.5.dev6"