modal 1.0.3.dev10__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/experimental/flash.pyi

@@ -0,0 +1,380 @@
+import modal.client
+import subprocess
+import typing
+import typing_extensions
+
+class _FlashManager:
+    def __init__(
+        self,
+        client: modal.client._Client,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    async def is_port_connection_healthy(
+        self, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
+    ) -> tuple[bool, typing.Optional[Exception]]: ...
+    async def _start(self): ...
+    async def _drain_container(self):
+        """Background task that checks if we've encountered too many failures and drains the container if so."""
+        ...
+
+    async def _run_heartbeat(self, host: str, port: int): ...
+    def get_container_url(self): ...
+    async def stop(self): ...
+    async def close(self): ...
+
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
+class FlashManager:
+    def __init__(
+        self,
+        client: modal.client.Client,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ): ...
+
+    class __is_port_connection_healthy_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
+        ) -> tuple[bool, typing.Optional[Exception]]: ...
+        async def aio(
+            self, /, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
+        ) -> tuple[bool, typing.Optional[Exception]]: ...
+
+    is_port_connection_healthy: __is_port_connection_healthy_spec[typing_extensions.Self]
+
+    class ___start_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _start: ___start_spec[typing_extensions.Self]
+
+    class ___drain_container_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /):
+            """Background task that checks if we've encountered too many failures and drains the container if so."""
+            ...
+
+        async def aio(self, /):
+            """Background task that checks if we've encountered too many failures and drains the container if so."""
+            ...
+
+    _drain_container: ___drain_container_spec[typing_extensions.Self]
+
+    class ___run_heartbeat_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, host: str, port: int): ...
+        async def aio(self, /, host: str, port: int): ...
+
+    _run_heartbeat: ___run_heartbeat_spec[typing_extensions.Self]
+
+    def get_container_url(self): ...
+
+    class __stop_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    stop: __stop_spec[typing_extensions.Self]
+
+    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    close: __close_spec[typing_extensions.Self]
+
+class __flash_forward_spec(typing_extensions.Protocol):
+    def __call__(
+        self,
+        /,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ) -> FlashManager:
+        """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+    async def aio(
+        self,
+        /,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ) -> FlashManager:
+        """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+flash_forward: __flash_forward_spec
+
+class _FlashPrometheusAutoscaler:
+    def __init__(
+        self,
+        client: modal.client._Client,
+        app_name: str,
+        cls_name: str,
+        metrics_endpoint: str,
+        target_metric: str,
+        target_metric_value: float,
+        min_containers: typing.Optional[int],
+        max_containers: typing.Optional[int],
+        buffer_containers: typing.Optional[int],
+        scale_up_tolerance: float,
+        scale_down_tolerance: float,
+        scale_up_stabilization_window_seconds: int,
+        scale_down_stabilization_window_seconds: int,
+        autoscaling_interval_seconds: int,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    async def start(self): ...
+    async def _run_autoscaler_loop(self): ...
+    async def _compute_target_containers(self, current_replicas: int) -> int:
+        """Gets metrics from container to autoscale up or down."""
+        ...
+
+    def _calculate_desired_replicas(
+        self,
+        n_current_replicas: int,
+        sum_metric: float,
+        n_containers_with_metrics: int,
+        n_total_containers: int,
+        target_metric_value: float,
+    ) -> int:
+        """Calculate the desired number of replicas to autoscale to."""
+        ...
+
+    async def _get_scaling_info(self, containers) -> tuple[float, int]:
+        """Get metrics using container exposed metrics endpoints."""
+        ...
+
+    async def _get_metrics(self, url: str) -> typing.Optional[dict[str, list[typing.Any]]]: ...
+    async def _get_all_containers(self): ...
+    async def _set_target_slots(self, target_slots: int): ...
+    def _make_scaling_decision(
+        self,
+        current_replicas: int,
+        autoscaling_decisions: list[tuple[float, int]],
+        scale_up_stabilization_window_seconds: int = 0,
+        scale_down_stabilization_window_seconds: int = 300,
+        min_containers: typing.Optional[int] = None,
+        max_containers: typing.Optional[int] = None,
+        buffer_containers: typing.Optional[int] = None,
+    ) -> int:
+        """Return the target number of containers following (simplified) Kubernetes HPA
+        stabilization-window semantics.
+
+        Args:
+            current_replicas: Current number of running Pods/containers.
+            autoscaling_decisions: List of (timestamp, desired_replicas) pairs, where
+                                   timestamp is a UNIX epoch float (seconds).
+                                   The list *must* contain at least one entry and should
+                                   already include the most-recent measurement.
+            scale_up_stabilization_window_seconds: 0 disables the up-window.
+            scale_down_stabilization_window_seconds: 0 disables the down-window.
+            min_containers / max_containers: Clamp the final decision to this range.
+
+        Returns:
+            The target number of containers.
+        """
+        ...
+
+    async def stop(self): ...
+
+class FlashPrometheusAutoscaler:
+    def __init__(
+        self,
+        client: modal.client.Client,
+        app_name: str,
+        cls_name: str,
+        metrics_endpoint: str,
+        target_metric: str,
+        target_metric_value: float,
+        min_containers: typing.Optional[int],
+        max_containers: typing.Optional[int],
+        buffer_containers: typing.Optional[int],
+        scale_up_tolerance: float,
+        scale_down_tolerance: float,
+        scale_up_stabilization_window_seconds: int,
+        scale_down_stabilization_window_seconds: int,
+        autoscaling_interval_seconds: int,
+    ): ...
+
+    class __start_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    start: __start_spec[typing_extensions.Self]
+
+    class ___run_autoscaler_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _run_autoscaler_loop: ___run_autoscaler_loop_spec[typing_extensions.Self]
+
+    class ___compute_target_containers_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, current_replicas: int) -> int:
+            """Gets metrics from container to autoscale up or down."""
+            ...
+
+        async def aio(self, /, current_replicas: int) -> int:
+            """Gets metrics from container to autoscale up or down."""
+            ...
+
+    _compute_target_containers: ___compute_target_containers_spec[typing_extensions.Self]
+
+    def _calculate_desired_replicas(
+        self,
+        n_current_replicas: int,
+        sum_metric: float,
+        n_containers_with_metrics: int,
+        n_total_containers: int,
+        target_metric_value: float,
+    ) -> int:
+        """Calculate the desired number of replicas to autoscale to."""
+        ...
+
+    class ___get_scaling_info_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, containers) -> tuple[float, int]:
+            """Get metrics using container exposed metrics endpoints."""
+            ...
+
+        async def aio(self, /, containers) -> tuple[float, int]:
+            """Get metrics using container exposed metrics endpoints."""
+            ...
+
+    _get_scaling_info: ___get_scaling_info_spec[typing_extensions.Self]
+
+    class ___get_metrics_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, url: str) -> typing.Optional[dict[str, list[typing.Any]]]: ...
+        async def aio(self, /, url: str) -> typing.Optional[dict[str, list[typing.Any]]]: ...
+
+    _get_metrics: ___get_metrics_spec[typing_extensions.Self]
+
+    class ___get_all_containers_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _get_all_containers: ___get_all_containers_spec[typing_extensions.Self]
+
+    class ___set_target_slots_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, target_slots: int): ...
+        async def aio(self, /, target_slots: int): ...
+
+    _set_target_slots: ___set_target_slots_spec[typing_extensions.Self]
+
+    def _make_scaling_decision(
+        self,
+        current_replicas: int,
+        autoscaling_decisions: list[tuple[float, int]],
+        scale_up_stabilization_window_seconds: int = 0,
+        scale_down_stabilization_window_seconds: int = 300,
+        min_containers: typing.Optional[int] = None,
+        max_containers: typing.Optional[int] = None,
+        buffer_containers: typing.Optional[int] = None,
+    ) -> int:
+        """Return the target number of containers following (simplified) Kubernetes HPA
+        stabilization-window semantics.
+
+        Args:
+            current_replicas: Current number of running Pods/containers.
+            autoscaling_decisions: List of (timestamp, desired_replicas) pairs, where
+                                   timestamp is a UNIX epoch float (seconds).
+                                   The list *must* contain at least one entry and should
+                                   already include the most-recent measurement.
+            scale_up_stabilization_window_seconds: 0 disables the up-window.
+            scale_down_stabilization_window_seconds: 0 disables the down-window.
+            min_containers / max_containers: Clamp the final decision to this range.
+
+        Returns:
+            The target number of containers.
+        """
+        ...
+
+    class __stop_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    stop: __stop_spec[typing_extensions.Self]
+
+class __flash_prometheus_autoscaler_spec(typing_extensions.Protocol):
+    def __call__(
+        self,
+        /,
+        app_name: str,
+        cls_name: str,
+        metrics_endpoint: str,
+        target_metric: str,
+        target_metric_value: float,
+        min_containers: typing.Optional[int] = None,
+        max_containers: typing.Optional[int] = None,
+        scale_up_tolerance: float = 0.1,
+        scale_down_tolerance: float = 0.1,
+        scale_up_stabilization_window_seconds: int = 0,
+        scale_down_stabilization_window_seconds: int = 300,
+        autoscaling_interval_seconds: int = 15,
+        buffer_containers: typing.Optional[int] = None,
+    ) -> FlashPrometheusAutoscaler:
+        """Autoscale a Flash service based on containers' Prometheus metrics.
+
+        The package `prometheus_client` is required to use this method.
+
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+    async def aio(
+        self,
+        /,
+        app_name: str,
+        cls_name: str,
+        metrics_endpoint: str,
+        target_metric: str,
+        target_metric_value: float,
+        min_containers: typing.Optional[int] = None,
+        max_containers: typing.Optional[int] = None,
+        scale_up_tolerance: float = 0.1,
+        scale_down_tolerance: float = 0.1,
+        scale_up_stabilization_window_seconds: int = 0,
+        scale_down_stabilization_window_seconds: int = 300,
+        autoscaling_interval_seconds: int = 15,
+        buffer_containers: typing.Optional[int] = None,
+    ) -> FlashPrometheusAutoscaler:
+        """Autoscale a Flash service based on containers' Prometheus metrics.
+
+        The package `prometheus_client` is required to use this method.
+
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+flash_prometheus_autoscaler: __flash_prometheus_autoscaler_spec
+
+class __flash_get_containers_spec(typing_extensions.Protocol):
+    def __call__(self, /, app_name: str, cls_name: str) -> list[dict[str, typing.Any]]:
+        """Return a list of flash containers for a deployed Flash service.
+
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+    async def aio(self, /, app_name: str, cls_name: str) -> list[dict[str, typing.Any]]:
+        """Return a list of flash containers for a deployed Flash service.
+
+        This is a highly experimental method that can break or be removed at any time without warning.
+        Do not use this method unless explicitly instructed to do so by Modal support.
+        """
+        ...
+
+flash_get_containers: __flash_get_containers_spec

modal/experimental/ipython.py

@@ -21,7 +21,7 @@ class ModalMagics(Magics):
         **Example:**
 
         ```python notest
-        %modal from main/my-app import my_function, MyClass as Foo
+        %modal from my-app import my_function, MyClass as Foo
 
         # Now you can call my_function() and Foo from your notebook.
         my_function.remote()
@@ -30,7 +30,7 @@ class ModalMagics(Magics):
         """
         line = line.strip()
         if not line.startswith("from "):
-            print("Invalid syntax. Use: %modal from <env>/<app> import <function|Class>[, <function|Class> [as alias]]")
+            print("Invalid syntax. Use: %modal from [env/]<app> import <function|Class>[, <function|Class> [as alias]]")
             return
 
         # Remove the initial "from "
@@ -40,11 +40,12 @@ class ModalMagics(Magics):
             print("Invalid syntax. Missing 'import' keyword.")
             return
 
-        # Parse environment and app from "env/app"
+        # Parse environment and app from "[env/]app"
+        environment: str | None
         if "/" not in env_app_part:
-            print("Invalid app specification. Expected format: <env>/<app>")
-            return
-        environment, app = env_app_part.split("/", 1)
+            environment, app = None, env_app_part
+        else:
+            environment, app = env_app_part.split("/", 1)
 
         # Parse the import items (multiple imports separated by commas)
         import_items = [item.strip() for item in import_part.split(",")]
@@ -73,7 +74,10 @@ class ModalMagics(Magics):
 
             # Set the loaded object in the notebook namespace
             self.shell.user_ns[alias] = obj  # type: ignore
-            print(f"Loaded {alias!r} from environment {environment!r} and app {app!r}.")
+            if environment:
+                print(f"Loaded {alias!r} from environment {environment!r} and app {app!r}.")
+            else:
+                print(f"Loaded {alias!r} from app {app!r}.")
 
 
 def load_ipython_extension(ipython):

modal/file_io.py

@@ -13,7 +13,6 @@ import json
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal._utils.async_utils import TaskContext
-from modal._utils.grpc_utils import retry_transient_errors
 from modal.exception import ClientClosed
 from modal_proto import api_pb2
 
@@ -57,8 +56,7 @@ async def _delete_bytes(file: "_FileIO", start: Optional[int] = None, end: Optio
     if start is not None and end is not None:
         if start >= end:
             raise ValueError("start must be less than end")
-    resp = await retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_delete_bytes_request=api_pb2.ContainerFileDeleteBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -85,8 +83,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
             raise InvalidError("start must be less than end")
     if len(data) > WRITE_CHUNK_SIZE:
         raise InvalidError("Write request payload exceeds 16 MiB limit")
-    resp = await retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_write_replace_bytes_request=api_pb2.ContainerFileWriteReplaceBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -117,13 +114,18 @@ class FileWatchEvent:
 # The FileIO class is designed to mimic Python's io.FileIO
 # See https://github.com/python/cpython/blob/main/Lib/_pyio.py#L1459
 class _FileIO(Generic[T]):
-    """FileIO handle, used in the Sandbox filesystem API.
+    """[Alpha] FileIO handle, used in the Sandbox filesystem API.
 
     The API is designed to mimic Python's io.FileIO.
 
+    Currently this API is in Alpha and is subject to change. File I/O operations
+    may be limited in size to 100 MiB, and the throughput of requests is
+    restricted in the current implementation. For our recommendations on large file transfers
+    see the Sandbox [filesystem access guide](https://modal.com/docs/guide/sandbox-files).
+
     **Usage**
 
-    ```python
+    ```python notest
     import modal
 
     app = modal.App.lookup("my-app", create_if_missing=True)
@@ -144,11 +146,12 @@ class _FileIO(Generic[T]):
     _task_id: str = ""
     _file_descriptor: str = ""
     _client: _Client
-    _watch_output_buffer: list[Optional[bytes]] = []
+    _watch_output_buffer: list[Union[Optional[bytes], Exception]] = []
 
     def __init__(self, client: _Client, task_id: str) -> None:
         self._client = client
         self._task_id = task_id
+        self._watch_output_buffer = []
 
     def _validate_mode(self, mode: str) -> None:
         if not any(char in mode for char in "rwax"):
@@ -173,11 +176,7 @@ class _FileIO(Generic[T]):
                 raise ValueError(f"Invalid file mode: {mode}")
             seen_chars.add(char)
 
-    def _handle_error(self, error: api_pb2.SystemErrorMessage) -> None:
-        error_class = ERROR_MAPPING.get(error.error_code, FilesystemExecutionError)
-        raise error_class(error.error_message)
-
-    async def _consume_output(self, exec_id: str) -> AsyncIterator[Optional[bytes]]:
+    async def _consume_output(self, exec_id: str) -> AsyncIterator[Union[Optional[bytes], Exception]]:
         req = api_pb2.ContainerFilesystemExecGetOutputRequest(
             exec_id=exec_id,
             timeout=55,
@@ -187,7 +186,8 @@ class _FileIO(Generic[T]):
                 yield None
                 break
             if batch.HasField("error"):
-                self._handle_error(batch.error)
+                error_class = ERROR_MAPPING.get(batch.error.error_code, FilesystemExecutionError)
+                yield error_class(batch.error.error_message)
             for message in batch.output:
                 yield message
 
@@ -236,6 +236,8 @@ class _FileIO(Generic[T]):
                     if data is None:
                         completed = True
                         break
+                    if isinstance(data, Exception):
+                        raise data
                     output += data
             except (GRPCError, StreamTerminatedError) as exc:
                 if retries_remaining > 0:
@@ -256,8 +258,7 @@ class _FileIO(Generic[T]):
             raise TypeError("Expected str when in text mode")
 
     async def _open_file(self, path: str, mode: str) -> None:
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_open_request=api_pb2.ContainerFileOpenRequest(path=path, mode=mode),
                 task_id=self._task_id,
@@ -280,8 +281,7 @@ class _FileIO(Generic[T]):
         return self
 
     async def _make_read_request(self, n: Optional[int]) -> bytes:
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_read_request=api_pb2.ContainerFileReadRequest(file_descriptor=self._file_descriptor, n=n),
                 task_id=self._task_id,
@@ -304,8 +304,7 @@ class _FileIO(Generic[T]):
         """Read a single line from the current position."""
         self._check_closed()
         self._check_readable()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_read_line_request=api_pb2.ContainerFileReadLineRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
@@ -346,8 +345,7 @@ class _FileIO(Generic[T]):
             raise ValueError("Write request payload exceeds 1 GiB limit")
         for i in range(0, len(data), WRITE_CHUNK_SIZE):
             chunk = data[i : i + WRITE_CHUNK_SIZE]
-            resp = await retry_transient_errors(
-                self._client.stub.ContainerFilesystemExec,
+            resp = await self._client.stub.ContainerFilesystemExec(
                 api_pb2.ContainerFilesystemExecRequest(
                     file_write_request=api_pb2.ContainerFileWriteRequest(
                         file_descriptor=self._file_descriptor,
@@ -362,8 +360,7 @@ class _FileIO(Generic[T]):
         """Flush the buffer to disk."""
         self._check_closed()
         self._check_writable()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_flush_request=api_pb2.ContainerFileFlushRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
@@ -388,8 +385,7 @@ class _FileIO(Generic[T]):
         (relative to the current position) and 2 (relative to the file's end).
         """
         self._check_closed()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_seek_request=api_pb2.ContainerFileSeekRequest(
                     file_descriptor=self._file_descriptor,
@@ -405,8 +401,7 @@ class _FileIO(Generic[T]):
     async def ls(cls, path: str, client: _Client, task_id: str) -> list[str]:
         """List the contents of the provided directory."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_ls_request=api_pb2.ContainerFileLsRequest(path=path),
                 task_id=task_id,
@@ -422,8 +417,7 @@ class _FileIO(Generic[T]):
     async def mkdir(cls, path: str, client: _Client, task_id: str, parents: bool = False) -> None:
         """Create a new directory."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_mkdir_request=api_pb2.ContainerFileMkdirRequest(path=path, make_parents=parents),
                 task_id=self._task_id,
@@ -435,8 +429,7 @@ class _FileIO(Generic[T]):
     async def rm(cls, path: str, client: _Client, task_id: str, recursive: bool = False) -> None:
         """Remove a file or directory in the Sandbox."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_rm_request=api_pb2.ContainerFileRmRequest(path=path, recursive=recursive),
                 task_id=self._task_id,
@@ -455,8 +448,7 @@ class _FileIO(Generic[T]):
         timeout: Optional[int] = None,
     ) -> AsyncIterator[FileWatchEvent]:
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_watch_request=api_pb2.ContainerFileWatchRequest(
                     path=path,
@@ -475,6 +467,8 @@ class _FileIO(Generic[T]):
                     item = self._watch_output_buffer.pop(0)
                     if item is None:
                         break
+                    if isinstance(item, Exception):
+                        raise item
                     buffer += item
                     # a single event may be split across multiple messages
                     # the end of an event is marked by two newlines
@@ -496,8 +490,7 @@ class _FileIO(Generic[T]):
 
     async def _close(self) -> None:
         # Buffer is flushed by the runner on close
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_close_request=api_pb2.ContainerFileCloseRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,