modal 1.5.2.dev21__tar.gz → 1.5.2.dev22__tar.gz

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/PKG-INFO

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

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/_utils/task_command_router_client.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2025
 import asyncio
 import base64
+import io
 import json
 import socket
 import ssl
@@ -8,9 +9,9 @@ import time
 import typing
 import urllib.parse
 import weakref
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncGenerator, AsyncIterable, Callable
 from contextlib import suppress
-from typing import TypeVar
+from typing import BinaryIO, TypeVar
 
 import grpclib.client
 import grpclib.config
@@ -18,7 +19,7 @@ from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
 from modal.config import logger
-from modal.exception import ExecTimeoutError, TimeoutError as ModalTimeoutError
+from modal.exception import AuthError, ExecTimeoutError, InternalError, ServiceError, TimeoutError as ModalTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
@@ -27,6 +28,17 @@ from .._utils.grpc_utils import ModalChannel
 from .async_utils import aclosing, retry
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
+STREAMING_STDIN_CHUNK_SIZE = 256 * 1024
+
+_STREAMING_STDIN_RESUMABLE_EXCEPTIONS = (
+    AuthError,
+    InternalError,
+    ServiceError,
+    StreamTerminatedError,
+    OSError,
+    asyncio.TimeoutError,
+)
+
 
 @retry(n_attempts=34, base_delay=1, max_delay=10, attempt_timeout=10, total_timeout=310)
 async def _connect_channel(channel: grpclib.client.Channel):
@@ -472,6 +484,118 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskExecStdinWrite, request)
             )
 
+    async def exec_stdin_write_stream(
+        self,
+        task_id: str,
+        exec_id: str,
+        source: BinaryIO,
+        chunk_size: int = STREAMING_STDIN_CHUNK_SIZE,
+        max_resume_attempts: int = 9,
+    ) -> int:
+        """Stream `source` into the exec's stdin, with bounded resume on transient failures.
+
+        Streams the full contents of `source` in one client-streaming RPC and
+        closes stdin (EOF) on success. On a resumable error, queries
+        `exec_stdin_status` for the server's canonical offset, seeks `source`
+        to that point, and reopens the stream.
+
+        Args:
+            task_id: The task ID of the task running the exec'd command.
+            exec_id: The execution ID of the command to write to.
+            source: A seekable byte source (file, BytesIO, etc.).
+            chunk_size: Bytes per outbound message.
+            max_resume_attempts: Upper bound on resume retries before giving up.
+
+        Returns:
+            The total number of bytes streamed into the exec's stdin.
+        """
+        offset = 0
+        attempt = 0
+        while True:
+
+            async def _chunks():
+                while True:
+                    chunk = source.read(chunk_size)
+                    if not chunk:
+                        return
+                    yield chunk
+
+            try:
+                source.seek(offset)
+                await self._exec_stdin_write_stream(task_id, exec_id, offset, _chunks())
+                return source.tell()
+            except (*_STREAMING_STDIN_RESUMABLE_EXCEPTIONS, AttributeError) as e:
+                # StreamTerminatedError surfaces as AttributeError in grpclib<=0.4.7;
+                # see call_with_retries_on_transient_errors.
+                if isinstance(e, AttributeError) and "_write_appdata" not in str(e):
+                    raise
+                attempt += 1
+                if attempt > max_resume_attempts:
+                    raise
+                status = await self.exec_stdin_status(task_id=task_id, exec_id=exec_id)
+                if status.closed:
+                    pos = source.tell()
+                    if status.num_bytes_written == pos and source.seek(0, io.SEEK_END) == pos:
+                        logger.debug(f"exec_stdin_write_stream completed but response was lost: {e}")
+                        return pos
+                    raise
+                offset = status.num_bytes_written
+                logger.debug(f"exec_stdin_write_stream resuming from offset {offset} after error: {e}")
+
+    async def _exec_stdin_write_stream(
+        self,
+        task_id: str,
+        exec_id: str,
+        start_offset: int,
+        chunks: AsyncIterable[bytes],
+    ) -> sr_pb2.TaskExecStdinWriteStreamResponse | None:
+        """Single client-streaming attempt: Start, Data chunks, then End (EOF).
+
+        Does not retry; `exec_stdin_write_stream` owns resume.
+        """
+        with grpc_error_converter():
+            stream = self._stub.TaskExecStdinWriteStream.open(metadata=self._get_metadata())
+            async with stream as s:
+                start = sr_pb2.TaskExecStdinWriteStreamRequest(
+                    start=sr_pb2.TaskExecStdinWriteStreamStart(
+                        task_id=task_id,
+                        exec_id=exec_id,
+                        offset=start_offset,
+                    ),
+                )
+                await s.send_message(start)
+                async for data in chunks:
+                    if not data:
+                        continue
+                    await s.send_message(sr_pb2.TaskExecStdinWriteStreamRequest(data=data))
+                # The server closes stdin only on this explicit End message. A
+                # stream that breaks before it leaves stdin open for resume.
+                await s.send_message(
+                    sr_pb2.TaskExecStdinWriteStreamRequest(end=sr_pb2.TaskExecStdinWriteStreamEnd()),
+                    end=True,
+                )
+                return await s.recv_message()
+
+    async def exec_stdin_status(self, task_id: str, exec_id: str) -> sr_pb2.TaskExecStdinStatusResponse:
+        """Read the current stdin write status for an exec'd command, to support retries from the right offset.
+
+        Used by streaming clients to find the resume offset after a stream
+        failure. Evicts any in-flight stdin stream for the exec, so it is not
+        safe to call for read-only observability.
+
+        Args:
+            task_id: The task ID of the task running the exec'd command.
+            exec_id: The execution ID of the command to query.
+        Raises:
+            Other errors: If retries are exhausted on transient errors or if there's an error
+              from the RPC itself.
+        """
+        request = sr_pb2.TaskExecStdinStatusRequest(task_id=task_id, exec_id=exec_id)
+        with grpc_error_converter():
+            return await call_with_retries_on_transient_errors(
+                lambda: self._call_with_auth_retry(self._stub.TaskExecStdinStatus, request)
+            )
+
     async def sandbox_stdin_write_v2(
         self, task_id: str, offset: int, data: bytes, eof: bool
     ) -> sr_pb2.SandboxStdinWriteV2Response:

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/cli/_help.py

@@ -70,7 +70,13 @@ def _option_label(param: click.Parameter, ctx: click.Context) -> Text:
             text.append(opt, style=_OPTION_FLAG_STYLE)
     if not getattr(param, "is_flag", False) and not getattr(param, "count", False):
         text.append(" ")
-        text.append(param.make_metavar(ctx), style=_OPTION_METAVAR_STYLE)
+        if "ctx" in inspect.signature(click.Parameter.make_metavar).parameters:
+            # click >= 8.2.0
+            metavar = param.make_metavar(ctx)
+        else:
+            # backwards compatibility
+            metavar = param.make_metavar()  # type: ignore[call-arg]
+        text.append(metavar, style=_OPTION_METAVAR_STYLE)
     return text
 
 

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev21",
+        version: str = "1.5.2.dev22",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev21",
+        version: str = "1.5.2.dev22",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/container_process.py

@@ -1,7 +1,7 @@
 # Copyright Modal Labs 2024
 import asyncio
 import platform
-from typing import Generic, TypeVar
+from typing import BinaryIO, Generic, TypeVar
 
 from modal_proto import api_pb2
 
@@ -117,6 +117,18 @@ class _ContainerProcess(Generic[T]):
             )
         return self._returncode
 
+    async def _stdin_write_stream(self, source: BinaryIO) -> int:
+        """mdmd:hidden
+        Stream `source` into the process's stdin and close it (EOF) on success.
+
+        Returns the total bytes streamed.
+        """
+        return await self._command_router_client.exec_stdin_write_stream(
+            task_id=self._task_id,
+            exec_id=self._process_id,
+            source=source,
+        )
+
     async def poll(self) -> int | None:
         """Check if the container process has finished running.
 

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/container_process.pyi

@@ -53,6 +53,14 @@ class _ContainerProcess(typing.Generic[T]):
 
     @property
     def returncode(self) -> int: ...
+    async def _stdin_write_stream(self, source: typing.BinaryIO) -> int:
+        """mdmd:hidden
+        Stream `source` into the process's stdin and close it (EOF) on success.
+
+        Returns the total bytes streamed.
+        """
+        ...
+
     async def poll(self) -> typing.Optional[int]:
         """Check if the container process has finished running.
 
@@ -105,6 +113,25 @@ class ContainerProcess(typing.Generic[T]):
     @property
     def returncode(self) -> int: ...
 
+    class ___stdin_write_stream_spec(typing_extensions.Protocol):
+        def __call__(self, /, source: typing.BinaryIO) -> int:
+            """mdmd:hidden
+            Stream `source` into the process's stdin and close it (EOF) on success.
+
+            Returns the total bytes streamed.
+            """
+            ...
+
+        async def aio(self, /, source: typing.BinaryIO) -> int:
+            """mdmd:hidden
+            Stream `source` into the process's stdin and close it (EOF) on success.
+
+            Returns the total bytes streamed.
+            """
+            ...
+
+    _stdin_write_stream: ___stdin_write_stream_spec
+
     class __poll_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Optional[int]:
             """Check if the container process has finished running.

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/sandbox.py

@@ -816,6 +816,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         *args: str,
         app: "modal.app._App | None" = None,
         name: str | None = None,
+        tags: dict[str, str] | None = None,
         image: _Image | None = None,
         env: dict[str, str | None] | None = None,
         secrets: Collection[_Secret] | None = None,
@@ -851,7 +852,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
         filesystem snapshots.
 
-        Features like tags, memory snapshots, network file systems, GPUs, and custom
+        Features like memory snapshots, network file systems, GPUs, and custom
         domains are not supported.
 
         Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -993,10 +994,12 @@ class _Sandbox(_Object, type_prefix="sb"):
                 ),
             )
 
+            tag_protos = [api_pb2.SandboxTag(tag_name=k, tag_value=v) for k, v in tags.items()] if tags else []
             create_req = api_pb2.SandboxCreateV2Request(
                 app_id=load_context.app_id,
                 definition=definition,
                 ephemeral_secrets=api_pb2.StringMap(contents=env_dict) if env_dict else None,
+                tags=tag_protos,
             )
             assert load_context.client._auth_token_manager
             auth_token = await load_context.client._auth_token_manager.get_token()
@@ -1267,22 +1270,27 @@ class _Sandbox(_Object, type_prefix="sb"):
         Returns:
             Tags as a map from tag name to tag value.
         """
-        self._ensure_v1("get_tags")
         req = api_pb2.SandboxTagsGetRequest(sandbox_id=self.object_id)
-        resp = await self._client.stub.SandboxTagsGet(req)
+        stub = self._client.stub
+        if self._is_v2:
+            assert self._client._auth_token_manager
+            auth_token = await self._client._auth_token_manager.get_token()
+            resp = await stub.SandboxTagsGetV2(req, metadata=[("x-modal-auth-token", auth_token)])
+        else:
+            resp = await stub.SandboxTagsGet(req)
 
         return {tag.tag_name: tag.tag_value for tag in resp.tags}
 
     async def set_tags(self, tags: dict[str, str], *, client: _Client | None = None) -> None:
         """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+        Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
         Args:
             tags: Tag names and values to set on this sandbox.
             client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
 
         """
-        self._ensure_v1("set_tags")
-        environment_name = _get_environment_name()
         if client is not None:
             deprecation_warning(
                 (2025, 9, 18),
@@ -1291,13 +1299,19 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
 
         tags_list = [api_pb2.SandboxTag(tag_name=name, tag_value=value) for name, value in tags.items()]
-
-        req = api_pb2.SandboxTagsSetRequest(
-            environment_name=environment_name,
-            sandbox_id=self.object_id,
-            tags=tags_list,
-        )
-        await self._client.stub.SandboxTagsSet(req)
+        stub = self._client.stub
+        if self._is_v2:
+            assert self._client._auth_token_manager
+            auth_token = await self._client._auth_token_manager.get_token()
+            req = api_pb2.SandboxTagsSetRequest(sandbox_id=self.object_id, tags=tags_list)
+            await stub.SandboxTagsSetV2(req, metadata=[("x-modal-auth-token", auth_token)])
+        else:
+            req = api_pb2.SandboxTagsSetRequest(
+                environment_name=_get_environment_name(),
+                sandbox_id=self.object_id,
+                tags=tags_list,
+            )
+            await stub.SandboxTagsSet(req)
 
     async def _experimental_set_outbound_network_policy(
         self,

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/sandbox.pyi

@@ -361,6 +361,7 @@ class _Sandbox(modal._object._Object):
         *args: str,
         app: typing.Optional[modal.app._App] = None,
         name: typing.Optional[str] = None,
+        tags: typing.Optional[dict[str, str]] = None,
         image: typing.Optional[modal._image._Image] = None,
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
@@ -399,7 +400,7 @@ class _Sandbox(modal._object._Object):
         `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
         filesystem snapshots.
 
-        Features like tags, memory snapshots, network file systems, GPUs, and custom
+        Features like memory snapshots, network file systems, GPUs, and custom
         domains are not supported.
 
         Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -518,6 +519,8 @@ class _Sandbox(modal._object._Object):
     async def set_tags(self, tags: dict[str, str], *, client: typing.Optional[modal.client._Client] = None) -> None:
         """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+        Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
         Args:
             tags: Tag names and values to set on this sandbox.
             client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
@@ -1711,6 +1714,7 @@ class Sandbox(modal.object.Object):
             *args: str,
             app: typing.Optional[modal.app.App] = None,
             name: typing.Optional[str] = None,
+            tags: typing.Optional[dict[str, str]] = None,
             image: typing.Optional[modal.image.Image] = None,
             env: typing.Optional[dict[str, typing.Optional[str]]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
@@ -1749,7 +1753,7 @@ class Sandbox(modal.object.Object):
             `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
             filesystem snapshots.
 
-            Features like tags, memory snapshots, network file systems, GPUs, and custom
+            Features like memory snapshots, network file systems, GPUs, and custom
             domains are not supported.
 
             Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -1772,6 +1776,7 @@ class Sandbox(modal.object.Object):
             *args: str,
             app: typing.Optional[modal.app.App] = None,
             name: typing.Optional[str] = None,
+            tags: typing.Optional[dict[str, str]] = None,
             image: typing.Optional[modal.image.Image] = None,
             env: typing.Optional[dict[str, typing.Optional[str]]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
@@ -1810,7 +1815,7 @@ class Sandbox(modal.object.Object):
             `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
             filesystem snapshots.
 
-            Features like tags, memory snapshots, network file systems, GPUs, and custom
+            Features like memory snapshots, network file systems, GPUs, and custom
             domains are not supported.
 
             Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -2035,6 +2040,8 @@ class Sandbox(modal.object.Object):
         def __call__(self, /, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None) -> None:
             """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+            Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
             Args:
                 tags: Tag names and values to set on this sandbox.
                 client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
@@ -2044,6 +2051,8 @@ class Sandbox(modal.object.Object):
         async def aio(self, /, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None) -> None:
             """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+            Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
             Args:
                 tags: Tag names and values to set on this sandbox.
                 client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/sandbox_fs.py

@@ -1,5 +1,6 @@
 # Copyright Modal Labs 2026
 import asyncio
+import io
 import json
 import os
 import random
@@ -7,7 +8,7 @@ import string
 import time
 import weakref
 from pathlib import Path
-from typing import TYPE_CHECKING, AsyncIterator, Optional, Union, cast
+from typing import TYPE_CHECKING, AsyncIterator, BinaryIO, Optional, Union, cast
 
 if TYPE_CHECKING:
     import modal.sandbox
@@ -33,7 +34,6 @@ from ._utils.sandbox_fs_utils import (
     validate_absolute_remote_path,
 )
 from .exception import ConflictError
-from .io_streams import TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE
 from .types import FileInfo, FileType, FileWatchEvent, FileWatchEventType
 
 _SANDBOX_FS_TOOLS_PATH = "/__modal/.bin/modal-sandbox-fs-tools"
@@ -111,69 +111,8 @@ class _SandboxFilesystem:
         validate_absolute_remote_path(remote_path, "copy_from_local")
 
         t0 = time.monotonic()
-        total_bytes = 0
         with open(local_path, "rb") as file_obj:
-            with translate_exec_errors("copy_from_local", remote_path):
-                process = await self._container.exec(_SANDBOX_FS_TOOLS_PATH, make_write_file_command(remote_path))
-                try:
-                    while True:
-                        logger.debug(
-                            f"sandbox copy_from_local('{local_path}', '{remote_path}'): reading "
-                            f"{TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE} bytes from {local_path} at offset {total_bytes}"
-                        )
-                        # TODO(saltzm): If this fails, the ContainerProcess will remain alive indefinitely since
-                        # stdin will remain open. Unfortunately we can't just call write_eof either, since that
-                        # would lead to a partially written file being persisted. We should catch exceptions
-                        # from this and kill the ContainerProcess when we have a way to do this.
-                        chunk = file_obj.read(TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE)
-                        if not chunk:
-                            logger.debug(
-                                f"sandbox copy_from_local('{local_path}', '{remote_path}'): read no data from "
-                                f"{local_path}, finished reading file"
-                            )
-                            break
-                        total_bytes += len(chunk)
-                        logger.debug(
-                            f"sandbox copy_from_local('{local_path}', '{remote_path}'): writing {len(chunk)} bytes "
-                            f"from {local_path} to remote {remote_path}"
-                        )
-                        process.stdin.write(chunk)
-                        await process.stdin.drain()
-                        logger.debug(
-                            f"sandbox copy_from_local('{local_path}', '{remote_path}'): finished writing "
-                            f"{len(chunk)} bytes from {local_path} to remote {remote_path}"
-                        )
-                    logger.debug(
-                        f"sandbox copy_from_local('{local_path}', '{remote_path}'): writing eof to remote {remote_path}"
-                    )
-                    process.stdin.write_eof()
-                    await process.stdin.drain()
-                    logger.debug(
-                        f"sandbox copy_from_local('{local_path}', '{remote_path}'): finished writing eof to remote "
-                        f"{remote_path}"
-                    )
-                # When the FS tools binary exits early on an error, the worker
-                # reports the dropped stdin write as ConflictError.
-                except ConflictError:
-                    pass
-
-                async def read_stderr():
-                    stderr = await process.stderr.read()
-                    logger.debug(f"sandbox copy_from_local('{local_path}', '{remote_path}'): finished reading stderr")
-                    return stderr
-
-                async def wait_for_process_completion():
-                    returncode = await process.wait()
-                    logger.debug(
-                        f"sandbox copy_from_local('{local_path}', '{remote_path}'): finished waiting for process "
-                        "completion"
-                    )
-                    return returncode
-
-                stderr, returncode = await asyncio.gather(read_stderr(), wait_for_process_completion())
-
-            if returncode != 0:
-                raise_write_file_error(returncode, stderr, remote_path)
+            total_bytes = await self._exec_fs_tool_write(file_obj, remote_path, "copy_from_local")
 
         dur_s = max(time.monotonic() - t0, 0.001)
         _log_throughput(f"copy_from_local('{local_path}', '{remote_path}')", total_bytes, dur_s)
@@ -638,22 +577,7 @@ class _SandboxFilesystem:
             raise TypeError("data must be bytes-like")
 
         t0 = time.monotonic()
-        with translate_exec_errors("write_bytes", remote_path):
-            process = await self._container.exec(_SANDBOX_FS_TOOLS_PATH, make_write_file_command(remote_path))
-            try:
-                for offset in range(0, max(len(data), 1), TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE):
-                    process.stdin.write(data[offset : offset + TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE])
-                    await process.stdin.drain()
-                process.stdin.write_eof()
-                await process.stdin.drain()
-            # When the FS tools binary exits early on an error, the worker
-            # reports the dropped stdin write as ConflictError.
-            except ConflictError:
-                pass
-            stderr, returncode = await asyncio.gather(process.stderr.read(), process.wait())
-
-        if returncode != 0:
-            raise_write_file_error(returncode, stderr, remote_path)
+        await self._exec_fs_tool_write(io.BytesIO(data), remote_path, "write_bytes")
 
         dur_s = max(time.monotonic() - t0, 0.001)
         _log_throughput(f"write_bytes {remote_path}", len(data), dur_s)
@@ -686,5 +610,33 @@ class _SandboxFilesystem:
             raise TypeError("data must be str")
         await self.write_bytes(data.encode("utf-8"), remote_path)
 
+    async def _exec_fs_tool_write(self, source: BinaryIO, remote_path: str, op_name: str) -> int:
+        """Exec the FS-tools write command and stream `source` into its stdin.
+
+        Returns the number of bytes streamed.
+        """
+        with translate_exec_errors(op_name, remote_path):
+            process = await self._container.exec(_SANDBOX_FS_TOOLS_PATH, make_write_file_command(remote_path))
+            # TODO(saltzm): If streaming fails after resume attempts are exhausted, the
+            # ContainerProcess will remain alive indefinitely since stdin will remain open.
+            # We should catch exceptions from this and kill the ContainerProcess when we
+            # have a way to do this.
+            try:
+                total_bytes = await process._stdin_write_stream(source)
+            # When the FS tools binary exits early on an error, the worker
+            # reports the dropped stdin write as ConflictError.
+            except ConflictError:
+                # ConflictError can come from a failure in fs-tools or server-side.
+                # - if server-side, the process won't exit, so the gather below would hang forever -> raise
+                # - else if fs-tools, process will be closed, use raise_write_file_error below
+                if await process.poll() is None:
+                    raise
+                total_bytes = source.tell()
+            stderr, returncode = await asyncio.gather(process.stderr.read(), process.wait())
+
+        if returncode != 0:
+            raise_write_file_error(returncode, stderr, remote_path)
+        return total_bytes
+
 
 SandboxFilesystem = synchronize_api(_SandboxFilesystem)

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal/sandbox_fs.pyi

@@ -348,6 +348,13 @@ class _SandboxFilesystem:
         """
         ...
 
+    async def _exec_fs_tool_write(self, source: typing.BinaryIO, remote_path: str, op_name: str) -> int:
+        """Exec the FS-tools write command and stream `source` into its stdin.
+
+        Returns the number of bytes streamed.
+        """
+        ...
+
 class SandboxFilesystem:
     """mdmd:namespace
     Namespace for Sandbox filesystem APIs.
@@ -1041,3 +1048,20 @@ class SandboxFilesystem:
             ...
 
     write_text: __write_text_spec
+
+    class ___exec_fs_tool_write_spec(typing_extensions.Protocol):
+        def __call__(self, /, source: typing.BinaryIO, remote_path: str, op_name: str) -> int:
+            """Exec the FS-tools write command and stream `source` into its stdin.
+
+            Returns the number of bytes streamed.
+            """
+            ...
+
+        async def aio(self, /, source: typing.BinaryIO, remote_path: str, op_name: str) -> int:
+            """Exec the FS-tools write command and stream `source` into its stdin.
+
+            Returns the number of bytes streamed.
+            """
+            ...
+
+    _exec_fs_tool_write: ___exec_fs_tool_write_spec

{modal-1.5.2.dev21 → modal-1.5.2.dev22}/modal.egg-info/PKG-INFO

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