modal 1.2.1.dev22__tar.gz → 1.2.2.dev2__tar.gz

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/PKG-INFO

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

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/_utils/mount_utils.py

@@ -3,7 +3,9 @@ import posixpath
 import typing
 from collections.abc import Mapping, Sequence
 from pathlib import PurePath, PurePosixPath
-from typing import Union
+from typing import Optional, Union
+
+from typing_extensions import TypeGuard
 
 from ..cloud_bucket_mount import _CloudBucketMount
 from ..exception import InvalidError
@@ -76,3 +78,26 @@ def validate_volumes(
             )
 
     return validated_volumes
+
+
+def validate_only_modal_volumes(
+    volumes: Optional[Optional[dict[Union[str, PurePosixPath], _Volume]]],
+    caller_name: str,
+) -> Sequence[tuple[str, _Volume]]:
+    """Validate all volumes are `modal.Volume`."""
+    if volumes is None:
+        return []
+
+    validated_volumes = validate_volumes(volumes)
+
+    # Although the typing forbids `_CloudBucketMount` for type checking, one can still pass a `_CloudBucketMount`
+    # during runtime, so we'll check the type here.
+    def all_modal_volumes(
+        vols: Sequence[tuple[str, Union[_Volume, _CloudBucketMount]]],
+    ) -> TypeGuard[Sequence[tuple[str, _Volume]]]:
+        return all(isinstance(v, _Volume) for _, v in vols)
+
+    if not all_modal_volumes(validated_volumes):
+        raise InvalidError(f"{caller_name} only supports volumes that are modal.Volume")
+
+    return validated_volumes

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

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/container_process.py

@@ -101,6 +101,7 @@ class _ContainerProcessThroughServer(Generic[T]):
 
         Returns `None` if the process is still running, else returns the exit code.
         """
+        assert self._process_id
         if self._returncode is not None:
             return self._returncode
         if self._exec_deadline and time.monotonic() >= self._exec_deadline:
@@ -119,6 +120,7 @@ class _ContainerProcessThroughServer(Generic[T]):
         return None
 
     async def _wait_for_completion(self) -> int:
+        assert self._process_id
         while True:
             req = api_pb2.ContainerExecWaitRequest(exec_id=self._process_id, timeout=10)
             resp: api_pb2.ContainerExecWaitResponse = await retry_transient_errors(
@@ -169,9 +171,6 @@ class _ContainerProcessThroughServer(Generic[T]):
             stream_impl = stream._impl
             # Don't skip empty messages so we can detect when the process has booted.
             async for chunk in stream_impl._get_logs(skip_empty_messages=False):
-                if chunk is None:
-                    break
-
                 if not on_connect.is_set():
                     connecting_status.stop()
                     on_connect.set()

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/functions.pyi

@@ -401,7 +401,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_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."""
             ...
@@ -410,7 +410,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -437,7 +437,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_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.
 
@@ -461,7 +461,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
+        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -470,7 +470,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_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.
 
@@ -491,7 +491,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, 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.1.dev22 → modal-1.2.2.dev2}/modal/image.py

@@ -39,6 +39,7 @@ from ._utils.docker_utils import (
 )
 from ._utils.function_utils import FunctionInfo
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
+from ._utils.mount_utils import validate_only_modal_volumes
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
@@ -487,6 +488,7 @@ class _Image(_Object, type_prefix="im"):
         context_mount_function: Optional[Callable[[], Optional[_Mount]]] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: Optional[Sequence[tuple[str, _Volume]]] = None,
         # For internal use only.
         _namespace: "api_pb2.DeploymentNamespace.ValueType" = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         _do_assert_no_mount_layers: bool = True,
@@ -494,6 +496,9 @@ class _Image(_Object, type_prefix="im"):
         if base_images is None:
             base_images = {}
 
+        if validated_volumes is None:
+            validated_volumes = []
+
         if secrets is None:
             secrets = []
         if gpu_config is None:
@@ -514,6 +519,8 @@ class _Image(_Object, type_prefix="im"):
                 deps += (build_function,)
             if image_registry_config and image_registry_config.secret:
                 deps += (image_registry_config.secret,)
+            for _, vol in validated_volumes:
+                deps += (vol,)
             return deps
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
@@ -592,6 +599,17 @@ class _Image(_Object, type_prefix="im"):
                 build_function_id = ""
                 _build_function = None
 
+            # Relies on dicts being ordered (true as of Python 3.6).
+            volume_mounts = [
+                api_pb2.VolumeMount(
+                    mount_path=path,
+                    volume_id=volume.object_id,
+                    allow_background_commits=True,
+                    read_only=volume._read_only,
+                )
+                for path, volume in validated_volumes
+            ]
+
             image_definition = api_pb2.Image(
                 base_images=base_images_pb2s,
                 dockerfile_commands=dockerfile.commands,
@@ -604,6 +622,7 @@ class _Image(_Object, type_prefix="im"):
                 runtime_debug=config.get("function_runtime_debug"),
                 build_function=_build_function,
                 build_args=build_args,
+                volume_mounts=volume_mounts,
             )
 
             req = api_pb2.ImageGetOrCreateRequest(
@@ -1690,6 +1709,7 @@ class _Image(_Object, type_prefix="im"):
         *commands: Union[str, list[str]],
         env: Optional[dict[str, Optional[str]]] = None,
         secrets: Optional[Collection[_Secret]] = None,
+        volumes: Optional[dict[Union[str, PurePosixPath], _Volume]] = None,
         gpu: GPU_T = None,
         force_build: bool = False,  # Ignore cached builds, similar to 'docker build --no-cache'
     ) -> "_Image":
@@ -1712,6 +1732,7 @@ class _Image(_Object, type_prefix="im"):
             secrets=secrets,
             gpu_config=parse_gpu_config(gpu),
             force_build=self.force_build or force_build,
+            validated_volumes=validate_only_modal_volumes(volumes, "Image.run_commands"),
         )
 
     @staticmethod

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/image.pyi

@@ -176,6 +176,7 @@ class _Image(modal._object._Object):
         ] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: typing.Optional[collections.abc.Sequence[tuple[str, modal.volume._Volume]]] = None,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
@@ -668,6 +669,7 @@ class _Image(modal._object._Object):
         *commands: typing.Union[str, list[str]],
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
+        volumes: typing.Optional[dict[typing.Union[str, pathlib.PurePosixPath], modal.volume._Volume]] = None,
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         force_build: bool = False,
     ) -> _Image:
@@ -1091,6 +1093,7 @@ class Image(modal.object.Object):
         ] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: typing.Optional[collections.abc.Sequence[tuple[str, modal.volume.Volume]]] = None,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
@@ -1648,6 +1651,7 @@ class Image(modal.object.Object):
         *commands: typing.Union[str, list[str]],
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
+        volumes: typing.Optional[dict[typing.Union[str, pathlib.PurePosixPath], modal.volume.Volume]] = None,
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         force_build: bool = False,
     ) -> Image:

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/io_streams.py

@@ -64,7 +64,6 @@ async def _container_process_logs_iterator(
         get_raw_bytes=True,
         last_batch_index=last_index,
     )
-
     stream = client.stub.ContainerExecGetOutput.unary_stream(req)
     while True:
         # Check deadline before attempting to receive the next batch
@@ -76,11 +75,13 @@ async def _container_process_logs_iterator(
             break
         except StopAsyncIteration:
             break
+
+        for item in batch.items:
+            yield item.message_bytes, batch.batch_index
+
         if batch.HasField("exit_code"):
             yield None, batch.batch_index
             break
-        for item in batch.items:
-            yield item.message_bytes, batch.batch_index
 
 
 T = TypeVar("T", str, bytes)
@@ -89,7 +90,7 @@ T = TypeVar("T", str, bytes)
 class _StreamReaderThroughServer(Generic[T]):
     """A StreamReader implementation that reads from the server."""
 
-    _stream: Optional[AsyncGenerator[Optional[bytes], None]]
+    _stream: Optional[AsyncGenerator[T, None]]
 
     def __init__(
         self,
@@ -134,10 +135,9 @@ class _StreamReaderThroughServer(Generic[T]):
         self._stream_type = stream_type
 
         if self._object_type == "container_process":
-            # Container process streams need to be consumed as they are produced,
-            # otherwise the process will block. Use a buffer to store the stream
-            # until the client consumes it.
-            self._container_process_buffer: list[Optional[bytes]] = []
+            # TODO: we should not have this async code in constructors!
+            #  it only works as long as all the construction happens inside of synchronicity code
+            self._container_process_buffer: list[Optional[bytes]] = []  # TODO: change this to an asyncio.Queue
             self._consume_container_process_task = asyncio.create_task(self._consume_container_process_stream())
 
     @property
@@ -147,21 +147,18 @@ class _StreamReaderThroughServer(Generic[T]):
 
     async def read(self) -> T:
         """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")
-        async for message in self._get_logs():
-            if message is None:
-                break
-            if self._text:
-                data_str += message.decode("utf-8")
-            else:
-                data_bytes += message
-
-        logger.debug(f"{self._object_id} StreamReader fd={self._file_descriptor} read completed after EOF")
         if self._text:
+            data_str = ""
+            async for message in _decode_bytes_stream_to_str(self._get_logs()):
+                data_str += message
+            logger.debug(f"{self._object_id} StreamReader fd={self._file_descriptor} read completed after EOF")
             return cast(T, data_str)
         else:
+            data_bytes = b""
+            async for message in self._get_logs():
+                data_bytes += message
+            logger.debug(f"{self._object_id} StreamReader fd={self._file_descriptor} read completed after EOF")
             return cast(T, data_bytes)
 
     async def _consume_container_process_stream(self):
@@ -181,6 +178,7 @@ class _StreamReaderThroughServer(Generic[T]):
                 )
                 async for message, batch_index in iterator:
                     if self._stream_type == StreamType.STDOUT and message:
+                        # TODO: rearchitect this, since these bytes aren't necessarily decodable
                         print(message.decode("utf-8"), end="")
                     elif self._stream_type == StreamType.PIPE:
                         self._container_process_buffer.append(message)
@@ -208,6 +206,9 @@ class _StreamReaderThroughServer(Generic[T]):
 
     async def _stream_container_process(self) -> AsyncGenerator[tuple[Optional[bytes], str], None]:
         """Streams the container process buffer to the reader."""
+        # Container process streams need to be consumed as they are produced,
+        # otherwise the process will block. Use a buffer to store the stream
+        # until the client consumes it.
         entry_id = 0
         if self._last_entry_id:
             entry_id = int(self._last_entry_id) + 1
@@ -225,7 +226,7 @@ class _StreamReaderThroughServer(Generic[T]):
 
             entry_id += 1
 
-    async def _get_logs(self, skip_empty_messages: bool = True) -> AsyncGenerator[Optional[bytes], None]:
+    async def _get_logs(self, skip_empty_messages: bool = True) -> 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.
@@ -237,7 +238,6 @@ class _StreamReaderThroughServer(Generic[T]):
             raise InvalidError("Logs can only be retrieved using the PIPE stream type.")
 
         if self.eof:
-            yield None
             return
 
         completed = False
@@ -262,6 +262,8 @@ class _StreamReaderThroughServer(Generic[T]):
                     if message is None:
                         completed = True
                         self.eof = True
+                        return
+
                     yield message
 
             except (GRPCError, StreamTerminatedError) as exc:
@@ -275,43 +277,37 @@ class _StreamReaderThroughServer(Generic[T]):
                         continue
                 raise
 
-    async def _get_logs_by_line(self) -> AsyncGenerator[Optional[bytes], None]:
+    async def _get_logs_by_line(self) -> AsyncGenerator[bytes, None]:
         """Process logs from the server and yield complete lines only."""
         async for message in self._get_logs():
-            if message is None:
-                if self._line_buffer:
-                    yield self._line_buffer
-                    self._line_buffer = b""
-                yield None
-            else:
-                assert isinstance(message, bytes)
-                self._line_buffer += message
-                while b"\n" in self._line_buffer:
-                    line, self._line_buffer = self._line_buffer.split(b"\n", 1)
-                    yield line + b"\n"
+            assert isinstance(message, bytes)
+            self._line_buffer += message
+            while b"\n" in self._line_buffer:
+                line, self._line_buffer = self._line_buffer.split(b"\n", 1)
+                yield line + b"\n"
 
-    def _ensure_stream(self) -> AsyncGenerator[Optional[bytes], None]:
+        if self._line_buffer:
+            yield self._line_buffer
+            self._line_buffer = b""
+
+    def _ensure_stream(self) -> AsyncGenerator[T, None]:
         if not self._stream:
             if self._by_line:
-                self._stream = self._get_logs_by_line()
+                # TODO: This is quite odd - it does line buffering in binary mode
+                # but we then always add the buffered text decoding on top of that.
+                # feels a bit upside down...
+                stream = self._get_logs_by_line()
             else:
-                self._stream = self._get_logs()
+                stream = self._get_logs()
+            if self._text:
+                stream = _decode_bytes_stream_to_str(stream)
+            self._stream = cast(AsyncGenerator[T, None], stream)
         return self._stream
 
     async def __anext__(self) -> T:
         """mdmd:hidden"""
         stream = self._ensure_stream()
-
-        value = await stream.__anext__()
-
-        # The stream yields None if it receives an EOF batch.
-        if value is None:
-            raise StopAsyncIteration
-
-        if self._text:
-            return cast(T, value.decode("utf-8"))
-        else:
-            return cast(T, value)
+        return cast(T, await stream.__anext__())
 
     async def aclose(self):
         """mdmd:hidden"""
@@ -330,6 +326,7 @@ async def _decode_bytes_stream_to_str(stream: AsyncGenerator[bytes, None]) -> As
         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:
@@ -512,6 +509,13 @@ class _StreamReader(Generic[T]):
     ```
     """
 
+    _impl: Union[
+        _StreamReaderThroughServer,
+        _DevnullStreamReader,
+        _TextStreamReaderThroughCommandRouter,
+        _BytesStreamReaderThroughCommandRouter,
+    ]
+
     def __init__(
         self,
         file_descriptor: "api_pb2.FileDescriptor.ValueType",

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/io_streams.pyi

@@ -21,7 +21,7 @@ T = typing.TypeVar("T")
 class _StreamReaderThroughServer(typing.Generic[T]):
     """A StreamReader implementation that reads from the server."""
 
-    _stream: typing.Optional[collections.abc.AsyncGenerator[typing.Optional[bytes], None]]
+    _stream: typing.Optional[collections.abc.AsyncGenerator[T, None]]
 
     def __init__(
         self,
@@ -54,9 +54,7 @@ class _StreamReaderThroughServer(typing.Generic[T]):
         """Streams the container process buffer to the reader."""
         ...
 
-    def _get_logs(
-        self, skip_empty_messages: bool = True
-    ) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
+    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.
@@ -66,11 +64,11 @@ class _StreamReaderThroughServer(typing.Generic[T]):
         """
         ...
 
-    def _get_logs_by_line(self) -> collections.abc.AsyncGenerator[typing.Optional[bytes], None]:
+    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[typing.Optional[bytes], None]: ...
+    def _ensure_stream(self) -> collections.abc.AsyncGenerator[T, None]: ...
     async def __anext__(self) -> T:
         """mdmd:hidden"""
         ...
@@ -200,6 +198,14 @@ class _StreamReader(typing.Generic[T]):
         print(f"Message: {message}")
     ```
     """
+
+    _impl: typing.Union[
+        _StreamReaderThroughServer,
+        _DevnullStreamReader,
+        _TextStreamReaderThroughCommandRouter,
+        _BytesStreamReaderThroughCommandRouter,
+    ]
+
     def __init__(
         self,
         file_descriptor: int,
@@ -392,6 +398,14 @@ class StreamReader(typing.Generic[T]):
         print(f"Message: {message}")
     ```
     """
+
+    _impl: typing.Union[
+        _StreamReaderThroughServer,
+        _DevnullStreamReader,
+        _TextStreamReaderThroughCommandRouter,
+        _BytesStreamReaderThroughCommandRouter,
+    ]
+
     def __init__(
         self,
         file_descriptor: int,

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/sandbox.py

@@ -516,10 +516,10 @@ class _Sandbox(_Object, type_prefix="sb"):
         return obj
 
     def _hydrate_metadata(self, handle_metadata: Optional[Message]):
-        self._stdout: _StreamReader[str] = StreamReader[str](
+        self._stdout = StreamReader(
             api_pb2.FILE_DESCRIPTOR_STDOUT, self.object_id, "sandbox", self._client, by_line=True
         )
-        self._stderr: _StreamReader[str] = StreamReader[str](
+        self._stderr = StreamReader(
             api_pb2.FILE_DESCRIPTOR_STDERR, self.object_id, "sandbox", self._client, by_line=True
         )
         self._stdin = StreamWriter(self.object_id, "sandbox", self._client)

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal/volume.py

@@ -1265,7 +1265,7 @@ async def _put_missing_blocks(
         file_progress.pending_blocks.add(missing_block.block_index)
         task_progress_cb = functools.partial(progress_cb, task_id=file_progress.task_id)
 
-        @retry(n_attempts=5, base_delay=0.5, timeout=None)
+        @retry(n_attempts=11, base_delay=0.5, timeout=None)
         async def put_missing_block_attempt(payload: BytesIOSegmentPayload) -> bytes:
             with payload.reset_on_error(subtract_progress=True):
                 async with ClientSessionRegistry.get_session().put(

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal.egg-info/PKG-INFO

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

{modal-1.2.1.dev22 → modal-1.2.2.dev2}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.2.1.dev22"
+__version__ = "1.2.2.dev2"