modal 1.1.5.dev83__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/experimental/flash.pyi

@@ -11,6 +11,9 @@ class _FlashManager:
         port: int,
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
+        startup_timeout: int = 30,
+        exit_grace_period: int = 0,
+        h2_enabled: bool = False,
     ):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
@@ -28,8 +31,6 @@ class _FlashManager:
     async def stop(self): ...
     async def close(self): ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class FlashManager:
     def __init__(
         self,
@@ -37,9 +38,12 @@ class FlashManager:
         port: int,
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
+        startup_timeout: int = 30,
+        exit_grace_period: int = 0,
+        h2_enabled: bool = False,
     ): ...
 
-    class __is_port_connection_healthy_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __is_port_connection_healthy_spec(typing_extensions.Protocol):
         def __call__(
             self, /, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
         ) -> tuple[bool, typing.Optional[Exception]]: ...
@@ -47,15 +51,15 @@ class FlashManager:
             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]
+    is_port_connection_healthy: __is_port_connection_healthy_spec
 
-    class ___start_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___start_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _start: ___start_spec[typing_extensions.Self]
+    _start: ___start_spec
 
-    class ___drain_container_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___drain_container_spec(typing_extensions.Protocol):
         def __call__(self, /):
             """Background task that checks if we've encountered too many failures and drains the container if so."""
             ...
@@ -64,27 +68,27 @@ class FlashManager:
             """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]
+    _drain_container: ___drain_container_spec
 
-    class ___run_heartbeat_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___run_heartbeat_spec(typing_extensions.Protocol):
         def __call__(self, /, host: str, port: int): ...
         async def aio(self, /, host: str, port: int): ...
 
-    _run_heartbeat: ___run_heartbeat_spec[typing_extensions.Self]
+    _run_heartbeat: ___run_heartbeat_spec
 
     def get_container_url(self): ...
 
-    class __stop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __stop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    stop: __stop_spec[typing_extensions.Self]
+    stop: __stop_spec
 
-    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __close_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    close: __close_spec[typing_extensions.Self]
+    close: __close_spec
 
 class __flash_forward_spec(typing_extensions.Protocol):
     def __call__(
@@ -93,6 +97,9 @@ class __flash_forward_spec(typing_extensions.Protocol):
         port: int,
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
+        startup_timeout: int = 30,
+        exit_grace_period: int = 0,
+        h2_enabled: bool = False,
     ) -> 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.
@@ -106,6 +113,9 @@ class __flash_forward_spec(typing_extensions.Protocol):
         port: int,
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
+        startup_timeout: int = 30,
+        exit_grace_period: int = 0,
+        h2_enabled: bool = False,
     ) -> 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.
@@ -139,7 +149,7 @@ class _FlashPrometheusAutoscaler:
     async def start(self): ...
     async def _run_autoscaler_loop(self): ...
     async def _compute_target_containers(self, current_replicas: int) -> int:
-        """Gets internal metrics from container to autoscale up or down."""
+        """Gets metrics from container to autoscale up or down."""
         ...
 
     def _calculate_desired_replicas(
@@ -154,13 +164,10 @@ class _FlashPrometheusAutoscaler:
         ...
 
     async def _get_scaling_info(self, containers) -> tuple[float, int]:
-        """Get metrics using either internal container metrics API or prometheus HTTP endpoints."""
+        """Get metrics using container exposed metrics endpoints."""
         ...
 
     async def _get_metrics(self, url: str) -> typing.Optional[dict[str, list[typing.Any]]]: ...
-    async def _get_container_metrics(
-        self, container_id: str
-    ) -> typing.Optional[modal_proto.api_pb2.TaskGetAutoscalingMetricsResponse]: ...
     async def _get_all_containers(self): ...
     async def _set_target_slots(self, target_slots: int): ...
     def _make_scaling_decision(
@@ -212,28 +219,28 @@ class FlashPrometheusAutoscaler:
         autoscaling_interval_seconds: int,
     ): ...
 
-    class __start_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __start_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    start: __start_spec[typing_extensions.Self]
+    start: __start_spec
 
-    class ___run_autoscaler_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___run_autoscaler_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _run_autoscaler_loop: ___run_autoscaler_loop_spec[typing_extensions.Self]
+    _run_autoscaler_loop: ___run_autoscaler_loop_spec
 
-    class ___compute_target_containers_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___compute_target_containers_spec(typing_extensions.Protocol):
         def __call__(self, /, current_replicas: int) -> int:
-            """Gets internal metrics from container to autoscale up or down."""
+            """Gets metrics from container to autoscale up or down."""
             ...
 
         async def aio(self, /, current_replicas: int) -> int:
-            """Gets internal metrics from container to autoscale up or down."""
+            """Gets metrics from container to autoscale up or down."""
             ...
 
-    _compute_target_containers: ___compute_target_containers_spec[typing_extensions.Self]
+    _compute_target_containers: ___compute_target_containers_spec
 
     def _calculate_desired_replicas(
         self,
@@ -246,44 +253,34 @@ class FlashPrometheusAutoscaler:
         """Calculate the desired number of replicas to autoscale to."""
         ...
 
-    class ___get_scaling_info_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___get_scaling_info_spec(typing_extensions.Protocol):
         def __call__(self, /, containers) -> tuple[float, int]:
-            """Get metrics using either internal container metrics API or prometheus HTTP endpoints."""
+            """Get metrics using container exposed metrics endpoints."""
             ...
 
         async def aio(self, /, containers) -> tuple[float, int]:
-            """Get metrics using either internal container metrics API or prometheus HTTP endpoints."""
+            """Get metrics using container exposed metrics endpoints."""
             ...
 
-    _get_scaling_info: ___get_scaling_info_spec[typing_extensions.Self]
+    _get_scaling_info: ___get_scaling_info_spec
 
-    class ___get_metrics_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___get_metrics_spec(typing_extensions.Protocol):
         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_container_metrics_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(
-            self, /, container_id: str
-        ) -> typing.Optional[modal_proto.api_pb2.TaskGetAutoscalingMetricsResponse]: ...
-        async def aio(
-            self, /, container_id: str
-        ) -> typing.Optional[modal_proto.api_pb2.TaskGetAutoscalingMetricsResponse]: ...
-
-    _get_container_metrics: ___get_container_metrics_spec[typing_extensions.Self]
+    _get_metrics: ___get_metrics_spec
 
-    class ___get_all_containers_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___get_all_containers_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _get_all_containers: ___get_all_containers_spec[typing_extensions.Self]
+    _get_all_containers: ___get_all_containers_spec
 
-    class ___set_target_slots_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___set_target_slots_spec(typing_extensions.Protocol):
         def __call__(self, /, target_slots: int): ...
         async def aio(self, /, target_slots: int): ...
 
-    _set_target_slots: ___set_target_slots_spec[typing_extensions.Self]
+    _set_target_slots: ___set_target_slots_spec
 
     def _make_scaling_decision(
         self,
@@ -313,11 +310,11 @@ class FlashPrometheusAutoscaler:
         """
         ...
 
-    class __stop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __stop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    stop: __stop_spec[typing_extensions.Self]
+    stop: __stop_spec
 
 class __flash_prometheus_autoscaler_spec(typing_extensions.Protocol):
     def __call__(
@@ -392,3 +389,54 @@ class __flash_get_containers_spec(typing_extensions.Protocol):
         ...
 
 flash_get_containers: __flash_get_containers_spec
+
+def _http_server(
+    port: typing.Optional[int] = None,
+    *,
+    proxy_regions: list[str] = [],
+    startup_timeout: int = 30,
+    exit_grace_period: typing.Optional[int] = None,
+    h2_enabled: bool = False,
+):
+    """Decorator for Flash-enabled HTTP servers on Modal classes.
+
+    Args:
+        port: The local port to forward to the HTTP server.
+        proxy_regions: The regions to proxy the HTTP server to.
+        startup_timeout: The maximum time to wait for the HTTP server to start.
+        exit_grace_period: The time to wait for the HTTP server to exit gracefully.
+    """
+    ...
+
+def http_server(
+    port: typing.Optional[int] = None,
+    *,
+    proxy_regions: list[str] = [],
+    startup_timeout: int = 30,
+    exit_grace_period: typing.Optional[int] = None,
+    h2_enabled: bool = False,
+):
+    """Decorator for Flash-enabled HTTP servers on Modal classes.
+
+    Args:
+        port: The local port to forward to the HTTP server.
+        proxy_regions: The regions to proxy the HTTP server to.
+        startup_timeout: The maximum time to wait for the HTTP server to start.
+        exit_grace_period: The time to wait for the HTTP server to exit gracefully.
+    """
+    ...
+
+class _FlashContainerEntry:
+    """A class that manages the lifecycle of Flash manager for Flash containers.
+
+    It is intentional that stop() runs before exit handlers and close().
+    This ensures the container is deregistered first, preventing new requests from being routed to it
+    while exit handlers execute and the exit grace period elapses, before finally closing the tunnel.
+    """
+    def __init__(self, http_config: modal_proto.api_pb2.HTTPConfig):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def enter(self): ...
+    def stop(self): ...
+    def close(self): ...

modal/file_io.py

@@ -10,17 +10,16 @@ if TYPE_CHECKING:
 
 import json
 
-from grpclib.exceptions import GRPCError, StreamTerminatedError
+from grpclib.exceptions import 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
 
 from ._utils.async_utils import synchronize_api
-from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
+from ._utils.deprecation import deprecation_error
 from .client import _Client
-from .exception import FilesystemExecutionError, InvalidError
+from .exception import FilesystemExecutionError, InternalError, ServiceError
 
 WRITE_CHUNK_SIZE = 16 * 1024 * 1024  # 16 MiB
 WRITE_FILE_SIZE_LIMIT = 1024 * 1024 * 1024  # 1 GiB
@@ -47,57 +46,17 @@ T = TypeVar("T", str, bytes)
 
 
 async def _delete_bytes(file: "_FileIO", start: Optional[int] = None, end: Optional[int] = None) -> None:
-    """Delete a range of bytes from the file.
-
-    `start` and `end` are byte offsets. `start` is inclusive, `end` is exclusive.
-    If either is None, the start or end of the file is used, respectively.
+    """mdmd:hidden
+    This method has been removed.
     """
-    assert file._file_descriptor is not None
-    file._check_closed()
-    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,
-        api_pb2.ContainerFilesystemExecRequest(
-            file_delete_bytes_request=api_pb2.ContainerFileDeleteBytesRequest(
-                file_descriptor=file._file_descriptor,
-                start_inclusive=start,
-                end_exclusive=end,
-            ),
-            task_id=file._task_id,
-        ),
-    )
-    await file._wait(resp.exec_id)
+    deprecation_error((2025, 12, 3), "delete_bytes has been removed.")
 
 
 async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = None, end: Optional[int] = None) -> None:
-    """Replace a range of bytes in the file with new data. The length of the data does not
-    have to be the same as the length of the range being replaced.
-
-    `start` and `end` are byte offsets. `start` is inclusive, `end` is exclusive.
-    If either is None, the start or end of the file is used, respectively.
+    """mdmd:hidden
+    This method has been removed.
     """
-    assert file._file_descriptor is not None
-    file._check_closed()
-    if start is not None and end is not None:
-        if start >= end:
-            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,
-        api_pb2.ContainerFilesystemExecRequest(
-            file_write_replace_bytes_request=api_pb2.ContainerFileWriteReplaceBytesRequest(
-                file_descriptor=file._file_descriptor,
-                data=data,
-                start_inclusive=start,
-                end_exclusive=end,
-            ),
-            task_id=file._task_id,
-        ),
-    )
-    await file._wait(resp.exec_id)
+    deprecation_error((2025, 12, 3), "replace_bytes has been removed.")
 
 
 class FileWatchEventType(enum.Enum):
@@ -206,13 +165,12 @@ class _FileIO(Generic[T]):
                         completed = True
                         break
 
-            except (GRPCError, StreamTerminatedError, ClientClosed) as exc:
+            except (ServiceError, InternalError, StreamTerminatedError, ClientClosed) as exc:
                 if retries_remaining > 0:
                     retries_remaining -= 1
-                    if isinstance(exc, GRPCError):
-                        if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                            await asyncio.sleep(1.0)
-                            continue
+                    if isinstance(exc, (ServiceError, InternalError)):
+                        await asyncio.sleep(1.0)
+                        continue
                     elif isinstance(exc, StreamTerminatedError):
                         continue
                     elif isinstance(exc, ClientClosed):
@@ -230,7 +188,7 @@ class _FileIO(Generic[T]):
 
     async def _wait(self, exec_id: str) -> bytes:
         # The logic here is similar to how output is read from `exec`
-        output = b""
+        output_buffer = io.BytesIO()
         completed = False
         retries_remaining = 10
         while not completed:
@@ -241,18 +199,17 @@ class _FileIO(Generic[T]):
                         break
                     if isinstance(data, Exception):
                         raise data
-                    output += data
-            except (GRPCError, StreamTerminatedError) as exc:
+                    output_buffer.write(data)
+            except (ServiceError, InternalError, StreamTerminatedError) as exc:
                 if retries_remaining > 0:
                     retries_remaining -= 1
-                    if isinstance(exc, GRPCError):
-                        if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                            await asyncio.sleep(1.0)
-                            continue
+                    if isinstance(exc, (ServiceError, InternalError)):
+                        await asyncio.sleep(1.0)
+                        continue
                     elif isinstance(exc, StreamTerminatedError):
                         continue
                 raise
-        return output
+        return output_buffer.getvalue()
 
     def _validate_type(self, data: Union[bytes, str]) -> None:
         if self._binary and isinstance(data, str):
@@ -261,8 +218,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,
@@ -285,8 +241,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,
@@ -309,8 +264,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,
@@ -351,8 +305,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,
@@ -367,8 +320,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,
@@ -393,8 +345,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,
@@ -410,8 +361,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,
@@ -427,8 +377,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,
@@ -440,8 +389,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,
@@ -460,8 +408,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,
@@ -471,10 +418,22 @@ class _FileIO(Generic[T]):
                 task_id=self._task_id,
             ),
         )
+
+        def end_of_event(item: bytes, buffer: io.BytesIO, boundary_token: bytes) -> bool:
+            if not item.endswith(b"\n"):
+                return False
+            boundary_token_size = len(boundary_token)
+            if buffer.tell() < boundary_token_size:
+                return False
+            buffer.seek(-boundary_token_size, io.SEEK_END)
+            if buffer.read(boundary_token_size) == boundary_token:
+                return True
+            return False
+
         async with TaskContext() as tc:
             tc.create_task(self._consume_watch_output(resp.exec_id))
 
-            buffer = b""
+            item_buffer = io.BytesIO()
             while True:
                 if len(self._watch_output_buffer) > 0:
                     item = self._watch_output_buffer.pop(0)
@@ -482,12 +441,12 @@ class _FileIO(Generic[T]):
                         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
-                    if buffer.endswith(b"\n\n"):
+                    item_buffer.write(item)
+                    assert isinstance(item, bytes)
+                    # Single events may span multiple messages so we need to check for a special event boundary token
+                    if end_of_event(item, item_buffer, boundary_token=b"\n\n"):
                         try:
-                            event_json = json.loads(buffer.strip().decode())
+                            event_json = json.loads(item_buffer.getvalue().strip().decode())
                             event = FileWatchEvent(
                                 type=FileWatchEventType(event_json["event_type"]),
                                 paths=event_json["paths"],
@@ -497,14 +456,13 @@ class _FileIO(Generic[T]):
                         except (json.JSONDecodeError, KeyError, ValueError):
                             # skip invalid events
                             pass
-                        buffer = b""
+                        item_buffer = io.BytesIO()
                 else:
                     await asyncio.sleep(0.1)
 
     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,