modAL 1.5.3.dev5__py3-none-any.whl → 1.5.3.dev6__py3-none-any.whl

modal/_functions.py

@@ -2073,11 +2073,13 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
     @live_method
     async def get_call_graph(self) -> list[InputInfo]:
-        """Returns a structure representing the call graph from a given root
-        call ID, along with the status of execution for each node.
+        """Fetch information about the graph of Inputs this FunctionCall is part of.
 
-        See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-        for documentation on the structure of the returned `InputInfo` items.
+        Note: the call graph data is not populated in real-time, and its capture is best-effort.
+        We do not recommend relying on this method for critical use cases.
+
+        See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+        on the return values.
 
         Returns:
             A list of `InputInfo` nodes describing the call graph.
@@ -2088,19 +2090,13 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         return _reconstruct_call_graph(response)
 
     @live_method
-    async def cancel(
-        self,
-        # if true, containers running the inputs are forcibly terminated
-        terminate_containers: bool = False,
-    ):
-        """Cancels the function call, which will stop its execution and mark its inputs as
-        [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-        If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-        causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+    async def cancel(self, terminate_containers: bool = False):
+        """Cancel the FunctionCall and terminate its inputs without retrying.
 
         Args:
-            terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+            terminate_containers: If True, terminate the containers running the cancelled
+                inputs. Any other inputs running concurrently on those containers will be
+                rescheduled.
         """
         request = api_pb2.FunctionCallCancelRequest(
             function_call_id=self.object_id, terminate_containers=terminate_containers

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,16 +9,16 @@ 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
 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
 
@@ -26,6 +27,17 @@ from .._utils.grpc_utils import ModalChannel, create_channel_config
 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):
@@ -468,6 +480,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/client.pyi

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

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/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/functions.pyi

@@ -1044,11 +1044,13 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     class __get_call_graph_spec(typing_extensions.Protocol):
         def __call__(self, /) -> list[modal.types.InputInfo]:
-            """Returns a structure representing the call graph from a given root
-            call ID, along with the status of execution for each node.
+            """Fetch information about the graph of Inputs this FunctionCall is part of.
 
-            See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-            for documentation on the structure of the returned `InputInfo` items.
+            Note: the call graph data is not populated in real-time, and its capture is best-effort.
+            We do not recommend relying on this method for critical use cases.
+
+            See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+            on the return values.
 
             Returns:
                 A list of `InputInfo` nodes describing the call graph.
@@ -1056,11 +1058,13 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             ...
 
         async def aio(self, /) -> list[modal.types.InputInfo]:
-            """Returns a structure representing the call graph from a given root
-            call ID, along with the status of execution for each node.
+            """Fetch information about the graph of Inputs this FunctionCall is part of.
+
+            Note: the call graph data is not populated in real-time, and its capture is best-effort.
+            We do not recommend relying on this method for critical use cases.
 
-            See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-            for documentation on the structure of the returned `InputInfo` items.
+            See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+            on the return values.
 
             Returns:
                 A list of `InputInfo` nodes describing the call graph.
@@ -1071,26 +1075,22 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     class __cancel_spec(typing_extensions.Protocol):
         def __call__(self, /, terminate_containers: bool = False):
-            """Cancels the function call, which will stop its execution and mark its inputs as
-            [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-            If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-            causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+            """Cancel the FunctionCall and terminate its inputs without retrying.
 
             Args:
-                terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+                terminate_containers: If True, terminate the containers running the cancelled
+                    inputs. Any other inputs running concurrently on those containers will be
+                    rescheduled.
             """
             ...
 
         async def aio(self, /, terminate_containers: bool = False):
-            """Cancels the function call, which will stop its execution and mark its inputs as
-            [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-            If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-            causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+            """Cancel the FunctionCall and terminate its inputs without retrying.
 
             Args:
-                terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+                terminate_containers: If True, terminate the containers running the cancelled
+                    inputs. Any other inputs running concurrently on those containers will be
+                    rescheduled.
             """
             ...
 

modal/sandbox.py

@@ -332,6 +332,7 @@ class _Sandbox(_Object, type_prefix="sb"):
     _attached: bool
     _filesystem: _SandboxFilesystem | None
     _is_v2: bool = False
+    _app_id: str | None
 
     @staticmethod
     def _default_pty_info() -> api_pb2.PTYInfo:
@@ -500,7 +501,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             create_resp = await load_context.client.stub.SandboxCreate(create_req)
             rpc_elapsed = time.monotonic() - rpc_start
             sandbox_id = create_resp.sandbox_id
-            self._hydrate(sandbox_id, load_context.client, None)
+            self._hydrate(sandbox_id, load_context.client, create_resp.metadata)
 
             if logger.isEnabledFor(logging.DEBUG):
                 total_elapsed = time.monotonic() - load_start
@@ -1017,7 +1018,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
             rpc_elapsed = time.monotonic() - rpc_start
             sandbox_id = create_resp.sandbox_id
-            self._hydrate(sandbox_id, load_context.client, None)
+            self._hydrate(sandbox_id, load_context.client, create_resp.metadata)
             self._is_v2 = True
             self._task_id = create_resp.task_id
             self._hydrate_metadata_v2()
@@ -1070,7 +1071,22 @@ class _Sandbox(_Object, type_prefix="sb"):
             await resolver.load(obj, load_context)
         return obj
 
-    def _hydrate_metadata(self, handle_metadata: Message | None):
+    def _get_metadata(self) -> api_pb2.SandboxHandleMetadata:
+        metadata = api_pb2.SandboxHandleMetadata(app_id=self._app_id or "")
+        if hasattr(self, "_result") and self._result is not None:
+            metadata.result.CopyFrom(self._result)
+        return metadata
+
+    def _hydrate_metadata(self, handle_metadata: Message | None) -> None:
+        self._app_id = None
+        self._result = None
+        if handle_metadata is not None:
+            assert isinstance(handle_metadata, api_pb2.SandboxHandleMetadata), (
+                f"{type(handle_metadata)} is not SandboxHandleMetadata"
+            )
+            self._app_id = handle_metadata.app_id
+            if handle_metadata.HasField("result"):
+                self._result = handle_metadata.result
         self._stdout = StreamReader(
             _StreamReaderThroughServerParams(
                 file_descriptor=api_pb2.FILE_DESCRIPTOR_STDOUT,
@@ -1088,13 +1104,14 @@ class _Sandbox(_Object, type_prefix="sb"):
             by_line=True,
         )
         self._stdin = StreamWriter(_StreamWriterThroughServerParams(object_id=self.object_id, client=self._client))
-        self._result = None
         self._task_id = None
         self._tunnels = None
         self._enable_snapshot = False
         self._command_router_client = None
         self._filesystem = None
-        self._is_v2 = False
+        self._is_v2 = _is_v2_sandbox_id(self.object_id)
+        if self._is_v2:
+            self._hydrate_metadata_v2()
 
     def _hydrate_metadata_v2(self) -> None:
         """Wire up V2 stdio readers that read directly from the worker. Cheap
@@ -1133,11 +1150,13 @@ class _Sandbox(_Object, type_prefix="sb"):
         super()._initialize_from_other(other)
         self._attached = other._attached
         self._is_v2 = other._is_v2
+        self._app_id = other._app_id
 
     def _initialize_from_empty(self):
         super()._initialize_from_empty()
         self._attached = True
         self._is_v2 = False
+        self._app_id = None
 
     async def detach(self):
         """Disconnects your client from the sandbox and cleans up resources assoicated with the connection.
@@ -1200,7 +1219,7 @@ class _Sandbox(_Object, type_prefix="sb"):
 
         req = api_pb2.SandboxGetFromNameRequest(sandbox_name=name, app_name=app_name, environment_name=env_name)
         resp = await client.stub.SandboxGetFromName(req)
-        return _Sandbox._new_hydrated(resp.sandbox_id, client, None)
+        return _Sandbox._new_hydrated(resp.sandbox_id, client, resp.metadata)
 
     @staticmethod
     async def _experimental_from_name(
@@ -1235,7 +1254,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         auth_token = await client._auth_token_manager.get_token()
         resp = await client.stub.SandboxGetFromNameV2(req, metadata=[("x-modal-auth-token", auth_token)])
 
-        obj = _Sandbox._new_hydrated(resp.sandbox_id, client, None)
+        obj = _Sandbox._new_hydrated(resp.sandbox_id, client, resp.metadata)
         obj._is_v2 = True
         obj._hydrate_metadata_v2()
         return obj
@@ -1266,7 +1285,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         else:
             resp = await client.stub.SandboxWait(req)
 
-        obj = _Sandbox._new_hydrated(sandbox_id, client, None)
+        obj = _Sandbox._new_hydrated(sandbox_id, client, resp.metadata)
         obj._is_v2 = is_v2
         if is_v2:
             obj._hydrate_metadata_v2()
@@ -2360,7 +2379,7 @@ class _Sandbox(_Object, type_prefix="sb"):
 
             for sandbox_info in resp.sandboxes:
                 sandbox_info: api_pb2.SandboxInfo
-                obj = _Sandbox._new_hydrated(sandbox_info.id, client, None)
+                obj = _Sandbox._new_hydrated(sandbox_info.id, client, sandbox_info.metadata)
                 obj._result = sandbox_info.task_info.result  # TODO: send SandboxInfo as metadata to _new_hydrated?
                 yield obj
 
@@ -2415,7 +2434,7 @@ class _Sandbox(_Object, type_prefix="sb"):
 
             for sandbox_info in resp.sandboxes:
                 sandbox_info: api_pb2.SandboxInfo
-                obj = _Sandbox._new_hydrated(sandbox_info.id, client, None)
+                obj = _Sandbox._new_hydrated(sandbox_info.id, client, sandbox_info.metadata)
                 # SandboxListV2 only returns V2 sandboxes; mark them as such so
                 # operations like wait/terminate/exec use the V2 RPCs and stdio.
                 obj._is_v2 = True

modal/sandbox.pyi

@@ -150,6 +150,7 @@ class _Sandbox(modal._object._Object):
     _attached: bool
     _filesystem: typing.Optional[modal.sandbox_fs._SandboxFilesystem]
     _is_v2: bool
+    _app_id: typing.Optional[str]
 
     @staticmethod
     def _default_pty_info() -> modal_proto.api_pb2.PTYInfo: ...
@@ -424,7 +425,8 @@ class _Sandbox(modal._object._Object):
         """
         ...
 
-    def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]): ...
+    def _get_metadata(self) -> modal_proto.api_pb2.SandboxHandleMetadata: ...
+    def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]) -> None: ...
     def _hydrate_metadata_v2(self) -> None:
         """Wire up V2 stdio readers that read directly from the worker. Cheap
         to call eagerly: the router connection is opened lazily on first read.
@@ -1342,6 +1344,7 @@ class Sandbox(modal.object.Object):
     _attached: bool
     _filesystem: typing.Optional[modal.sandbox_fs.SandboxFilesystem]
     _is_v2: bool
+    _app_id: typing.Optional[str]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
@@ -1872,7 +1875,8 @@ class Sandbox(modal.object.Object):
 
     _experimental_create: typing.ClassVar[___experimental_create_spec]
 
-    def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]): ...
+    def _get_metadata(self) -> modal_proto.api_pb2.SandboxHandleMetadata: ...
+    def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]) -> None: ...
     def _hydrate_metadata_v2(self) -> None:
         """Wire up V2 stdio readers that read directly from the worker. Cheap
         to call eagerly: the router connection is opened lazily on first read.

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/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.3.dev5.dist-info → modal-1.5.3.dev6.dist-info}/METADATA

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

{modal-1.5.3.dev5.dist-info → modal-1.5.3.dev6.dist-info}/RECORD

@@ -6,7 +6,7 @@ modal/_clustered_functions.pyi,sha256=akbff8aXkp5aJapn72YMXPnzeYa6OFAfuakcy7Jx6w
 modal/_container_entrypoint.py,sha256=AyhMFBiaApVn1mueur2yrVy7IXR9qdXdwY4IePtVv74,22760
 modal/_environments.py,sha256=mD5pmecDSzZNU26jtfhuGRNPAMNXlTk-UX4U4h5TEDM,20253
 modal/_function_variants.py,sha256=ixkwW9naMMBzRB-92BZd5k3iVWtOoYukveT52hLDIbc,12549
-modal/_functions.py,sha256=MCvwVytan1PoOb9y9Usi7PUXVypsh-CiogFHzfp7WBE,95261
+modal/_functions.py,sha256=XE_4HPrYbHaxhSsMoF25Y8z8Snb0ANu-j9yWnEllvwg,95010
 modal/_grpc_client.py,sha256=QL5btzOz6zZzTDcgSwFjI3PBy2gkaycyrlP7Jw-jkbY,6962
 modal/_image.py,sha256=TW-0QiFa3Lo1w9khZcE8mgSHQgj-PJ0eChb8IkS2eqo,128738
 modal/_ipython.py,sha256=Bu9fc3hm3xt2O47qLe_d-Mu2jS81LwMsmXNJ1sawBA0,575
@@ -31,14 +31,14 @@ modal/billing.py,sha256=E1-P_P8bJFLp-bTaggYd4BaaViImPB5UdtXiY8VeAZQ,390
 modal/billing.pyi,sha256=4m7VLYNS8IiJ2I3CJx0awvrOM6BILWRVLfdeqtAYr8M,7189
 modal/call_graph.py,sha256=XGALIDn1bLchWo_goyX23bcPjzCZcfqKUo8INIfDapo,1775
 modal/client.py,sha256=9FGuDQpF0fvg45ylf-WLzxkF5U-CGvjHcH5n_y4jgSQ,16366
-modal/client.pyi,sha256=7JEGp-3z5VHBPw5q08PO5YNCKk0TArtSxUKsi4QxQQI,17997
+modal/client.pyi,sha256=FXPShD0ZtT9JmV6pfGrV4x9By0Mg4OsPKIJFS_qlolg,17997
 modal/cloud_bucket_mount.py,sha256=03gECcV9l2Lnt9k23YrDOTGFW7ajfXMW5O8b1prhtwQ,6254
 modal/cloud_bucket_mount.pyi,sha256=lMOb44pbNE9kDVEqWfcmvpsnh1sdNNFzuKoVyZZ3d5M,8058
 modal/cls.py,sha256=lNsIz0rm5pbayfrODwb3MVGOqNnhosWJQTFpVLfjJvk,40981
 modal/cls.pyi,sha256=FzYY7OkxuoqTZ-196Nsp6iC4yLud-Rq4qui_x7jxNzc,29421
 modal/config.py,sha256=iklz4iNM9ozr9-ubz-kmVZ6r7gsyyrXwoaG6GDQgsIs,16026
-modal/container_process.py,sha256=E2YZImDLG4vq8V_4PqEL65z_tEOpA0rzxf2190BAaA4,8403
-modal/container_process.pyi,sha256=-8UstN3w-SbKbW2qbf1OSirqDQuLBBdvJE3ysJXTWHQ,4617
+modal/container_process.py,sha256=gy7Dwh4kYtKj-9J4RHMowDFf5Gd4bfK1PV8Y23lpBl8,8822
+modal/container_process.pyi,sha256=lzMigs10shDgQ3kt-1ajkMFk-JJMHiD7dBJ3Lec7yNw,5489
 modal/dict.py,sha256=LILESg1hALZHwlW7uslbUyxc2mpgtNisEmk8xl-559Y,23953
 modal/dict.pyi,sha256=SPafrdRoStNJFt3YtO2H6PucXfbP-rDPB9zAWgY91sY,38253
 modal/environments.py,sha256=CMOYbsx3fg9M8-SSPOjOUGqay8r1zewWtbwp9XnEUNs,1486
@@ -48,7 +48,7 @@ modal/file_io.py,sha256=GYTa67mrmbTTTBsYQnb51VmwGIo0YY-1qQ3YBhagkmA,21795
 modal/file_io.pyi,sha256=3181-DS07flFWLf2BKjqCOiWIjieEOolf33wx6fBp5c,15377
 modal/file_pattern_matcher.py,sha256=6g_awxudMy_ontBvkznybyeNnwGMj297YrmIHCbREI0,8132
 modal/functions.py,sha256=EZRcHFfnoYbvawUJnAHF5nIvoo9GX2Djy7mUmOCXmXc,258
-modal/functions.pyi,sha256=PN3qQg4NAuBkQEhXCHR8kt4DHPNfLApAu187wi2qeHs,48252
+modal/functions.pyi,sha256=R-vSYjEU_jnu5bVUHtpPHNEDlbM6ccpI2i6ydEogwLU,47942
 modal/image.py,sha256=c0lUSAoU-Ip3g5DGZ0uhdCzoWSQWh1g0i-7Rxo-Sz-I,160
 modal/image.pyi,sha256=Whbfmda2YLAyzctLEF9uF4FQ5b1canwLojSksRJ4gx8,59716
 modal/io_streams.py,sha256=3fhhb7SDJ69pVUu9J3PiMLBePD9bpiIxPN05SCzf8FE,29118
@@ -73,10 +73,10 @@ modal/retries.py,sha256=tSGB5bGM5xZZUDXMkuelIEoQJY0vOukOssZhwc6tXAo,5014
 modal/runner.py,sha256=YdBqWOWkcGgSDKLEz1zrGNHrh0-d2tSNx24XPB6QyoM,30284
 modal/runner.pyi,sha256=0hIfkl-7VTyw1n-1B0AV7f53t3i3hCzRPyBu3DUyHnk,9669
 modal/running_app.py,sha256=xSR1VVlhxEFytmjx2x697_0GpD25Vc9crhp6r117_QY,1145
-modal/sandbox.py,sha256=DfLoN7H8nh63Jyo9RAzT39AtwBjCodc1pL8nLsypFe8,115696
-modal/sandbox.pyi,sha256=XdW0eKDgdcq9RC9qN-xlv1CJZPFCaZ6HupmUwVlBFfQ,138397
-modal/sandbox_fs.py,sha256=MkDTAiboDdnMYf34TSz9LHGc1sqpmAIXRdr9X3x2bno,29780
-modal/sandbox_fs.pyi,sha256=wWPqovzu4GcPPWl06yKwvyvgqjM_JvLnmbq0tZrnLlQ,44481
+modal/sandbox.py,sha256=zyBUCRqwQCa34nxxBYZI8OTp1OdJHfba0tmmuohk1vg,116648
+modal/sandbox.pyi,sha256=vMAWDXLRAt-FnAnDdTAexBfxU9qZVG9p2iIuaGPX_1c,138637
+modal/sandbox_fs.py,sha256=vA-L-OCFR3QMqof8db6d_qw0VaEaac3mBtZrfl00Jts,27045
+modal/sandbox_fs.pyi,sha256=5_h1UAKD5UXDVeP4x6_UyLQLD92O9_Mm0d1dH6JXU4A,45381
 modal/schedule.py,sha256=3F15Vh4g8C34jGcO-vgFkBHZl7XvP7qieXayQ9gKsyw,3248
 modal/scheduler_placement.py,sha256=S2-MZQcWCt6NVwIWXUP11KsKZeRDQViJLlOngGUvjkM,1173
 modal/secret.py,sha256=tHBzXOFALjIshuUfz6htAB6PKoTMsZeml4Y_X1ED2ic,20215
@@ -138,7 +138,7 @@ modal/_utils/proxy_support.py,sha256=hLA_XojYxzPysOiLqyUbB-SgMLmn_X8WtXTk92xh7g4
 modal/_utils/rand_pb_testing.py,sha256=kwAKIros_g6XPXluiJAktQ79YPkD9SGopKGl83GQ1l0,4361
 modal/_utils/sandbox_fs_utils.py,sha256=rsfo1uDbVSoiY21XERDzsmp-DALcNmlPfJ6jn_2p5T0,15680
 modal/_utils/shell_utils.py,sha256=_2yHrlx4Crx5JWQXECLPQ51kclu8H-U3N7jOkBN7q5U,3390
-modal/_utils/task_command_router_client.py,sha256=9pXrjqK_LFU40tuOU1cmokqqjCQPmLzkru6Ek8rdZtQ,38690
+modal/_utils/task_command_router_client.py,sha256=BElu8TCO6tTYJqT1pwqY4TXOerj3T-TsRv8Z60Kn3jI,43983
 modal/_utils/time_utils.py,sha256=3T2RkXRpOFwBiQ5fTZCPkObaeemLXNWW9UyDhG8qsv4,9042
 modal/_vendor/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_vendor/a2wsgi_wsgi.py,sha256=RVLIYVJA8a8o96QxEXYT5tuog2zev2S24XOuAVTXZAs,21872
@@ -194,16 +194,16 @@ modal/experimental/flash.py,sha256=GAJ1c-EGL8M3_loAkqr5gdUfySMHY3U_oc6RywfZ8-0,3
 modal/experimental/flash.pyi,sha256=lpTqJFZRMGWscw0xpYZVdBMnAYjj16asXE4_64A6itQ,17774
 modal/experimental/ipython.py,sha256=kJ6o9wkAY_MiSb7paewI7f1MJAeqdi8TX5pBdhr_mUI,2925
 modal/skills/modal/SKILL.md,sha256=WzLjYJ1utjc_ZOf6qZTPwB6wxxwRYB5PibdvIf_FLy0,5316
-modal-1.5.3.dev5.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-1.5.3.dev6.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=9-b8vl2EsLWD9zJqpCK8IUi5h44Bjn3i3rSdedZV4bA,6415
 modal_docs/gen_cli_docs_main.py,sha256=UPGr7O1DYTIRLwfINe2rbdh89J3cPVTU1OWL-SjxnOQ,198
-modal_docs/gen_reference_docs.py,sha256=tzzPApAuyKEmjSmduQ_jK3GE6dr5ggkrLPSG5vVS1As,13734
+modal_docs/gen_reference_docs.py,sha256=HRTjnzPzmGkYjL8tumqbiBlEXqclTMHD11t8LjpgF-Q,13684
 modal_docs/gen_reference_docs_main.py,sha256=56Cr3YKgq4qgb01bEcumTo1Px87boGGOFeHQ0Wcjg74,210
 modal_docs/mdmd/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
-modal_docs/mdmd/mdmd.py,sha256=MmoDhKpA-YKXgJW-pdVqgKN0Wizoxl91q-RkHFPZ9iA,24738
+modal_docs/mdmd/mdmd.py,sha256=yo0-5zYSy4PEiK6X-otdpgvaE_qvSKQ_zVRT2FSKf5E,24989
 modal_docs/mdmd/signatures.py,sha256=OASroKle763Kfumn4Ek4PABJXEGP56JMCTug44QoBx4,11327
-modal_docs/mdmd/types.py,sha256=MIh5VOnWvFd8T1aZT_vTB2OeLbPB5TASdOaX8jGvpQk,710
+modal_docs/mdmd/types.py,sha256=tv7fvziPr-MeDzOp4e2pK5h3d1DXTUOO74rPqDoBn6g,736
 modal_proto/__init__.py,sha256=tFdSv9eaHBvYcwhgq-XqIlYDNDw57clrvO91Fb-oUV4,130
 modal_proto/api_grpc.py,sha256=q_AsVyWC73bpEsWJEISHhrukmb1WgDAy_euZcekIpsk,180684
 modal_proto/api_pb2.py,sha256=UxZIkyXj4UB3x96KBFamvhoKDmeC-c6xTXA_UlPeQvA,491803
@@ -217,10 +217,10 @@ modal_proto/task_command_router_pb2.py,sha256=gWtT_LkHjPpt5WoG0WYP5jBLgJOtkJ3bfU
 modal_proto/task_command_router_pb2.pyi,sha256=q9_C58oT0j9gJor3Tkm7SW8dbZEmgZvMBUh5QNAq-u4,45132
 modal_proto/task_command_router_pb2_grpc.py,sha256=zuFkJgKcswB2ftjnyEgs70dp61VMA7gK0h0uzR3gYFw,42563
 modal_proto/task_command_router_pb2_grpc.pyi,sha256=UjAJFqz9DpOFXP04fVm5lB2eAyTtjOg3oKjfWei8yLU,14262
-modal_version/__init__.py,sha256=8uUVhURQ--zddhBARbeuQFxOdjV7Gr-bRu9rMoWXdLQ,120
+modal_version/__init__.py,sha256=JL9s9bbDS3RB-1ET4OdzoflhuqWVHtjNRR0z-v8jSBU,120
 modal_version/__main__.py,sha256=nLUbubxKx7GXNzJIkTB7M7_u8080LyLM0IS0rzFkC_c,119
-modal-1.5.3.dev5.dist-info/METADATA,sha256=geSlRpKZh3HjsCkFHCkaG_i7WAF1A3K-agH1hniSczY,2512
-modal-1.5.3.dev5.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-1.5.3.dev5.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-1.5.3.dev5.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-1.5.3.dev5.dist-info/RECORD,,
+modal-1.5.3.dev6.dist-info/METADATA,sha256=tkxpaVyoGJQNIAoF7Nofg1KPuBgmOLOIB2unkyPyf2w,2512
+modal-1.5.3.dev6.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-1.5.3.dev6.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-1.5.3.dev6.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-1.5.3.dev6.dist-info/RECORD,,

modal_docs/gen_reference_docs.py

@@ -254,7 +254,6 @@ def run(output_dir: str | None = None):
     # Standalone module reference pages, sorted into the sidebar with top-level `modal.X` entries.
     module_docs = [
         ("modal.billing", "modal.billing"),
-        ("modal.call_graph", "modal.call_graph"),
         ("modal.config", "modal.config"),
         ("modal.container_process", "modal.container_process"),
         ("modal.exception", "modal.exception"),

modal_docs/mdmd/mdmd.py

@@ -109,14 +109,15 @@ def parse_docstring(name: str, signature: str, docstring: str) -> ParsedDoc:
         return "\n".join(normalized_lines).strip()
 
     args_section, args_range = extract_section(["Args:"])
-    returns_section, returns_range = extract_section(["Returns:", "Yields:"])
+    returns_section, returns_range = extract_section(["Returns:"])
+    yields_section, yields_range = extract_section(["Yields:"])
     raises_section, raises_range = extract_section(["Raises:"])
     examples_section, examples_range = extract_section(["Examples:", "Example:"])
     see_also_section, see_also_range = extract_section(["See Also:", "See also:"])
 
     section_ranges = [
         section_range
-        for section_range in [args_range, returns_range, raises_range, examples_range, see_also_range]
+        for section_range in [args_range, returns_range, yields_range, raises_range, examples_range, see_also_range]
         if section_range
     ]
 
@@ -240,6 +241,7 @@ def parse_docstring(name: str, signature: str, docstring: str) -> ParsedDoc:
         description=description,
         params=params,
         returns=section_body_without_header(returns_section),
+        yields=section_body_without_header(yields_section),
         raises=parse_raises(raises_section),
         examples=section_body_without_header(examples_section),
         see_also=section_body_without_header(see_also_section),
@@ -266,6 +268,11 @@ def _markdown_body_from_parsed_doc(parsed: ParsedDoc) -> str:
             output.append(_parameter_tag(param))
         output.append("")
 
+    if parsed.yields:
+        output.append("**Yields**\n")
+        output.append(parsed.yields)
+        output.append("")
+
     if parsed.returns:
         output.append("**Returns**\n")
         output.append(parsed.returns)

modal_docs/mdmd/types.py

@@ -29,6 +29,7 @@ class ParsedDoc:
     description: Optional[str]
     params: list[ParsedParam]
     returns: Optional[str]
+    yields: Optional[str]
     raises: list[ParsedRaise]
     examples: Optional[str]
     see_also: Optional[str]

modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2026
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.5.3.dev5"
+__version__ = "1.5.3.dev6"