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

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,

modal/file_io.pyi

@@ -7,21 +7,16 @@ import typing_extensions
 T = typing.TypeVar("T")
 
 async def _delete_bytes(file: _FileIO, start: typing.Optional[int] = None, end: typing.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.
     """
     ...
 
 async def _replace_bytes(
     file: _FileIO, data: bytes, start: typing.Optional[int] = None, end: typing.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.
     """
     ...
 
@@ -174,18 +169,14 @@ class _FileIO(typing.Generic[T]):
 
 class __delete_bytes_spec(typing_extensions.Protocol):
     def __call__(self, /, file: FileIO, start: typing.Optional[int] = None, end: typing.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.
         """
         ...
 
     async def aio(self, /, file: FileIO, start: typing.Optional[int] = None, end: typing.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.
         """
         ...
 
@@ -195,29 +186,21 @@ class __replace_bytes_spec(typing_extensions.Protocol):
     def __call__(
         self, /, file: FileIO, data: bytes, start: typing.Optional[int] = None, end: typing.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.
         """
         ...
 
     async def aio(
         self, /, file: FileIO, data: bytes, start: typing.Optional[int] = None, end: typing.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.
         """
         ...
 
 replace_bytes: __replace_bytes_spec
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
 class FileIO(typing.Generic[T]):
@@ -252,56 +235,70 @@ class FileIO(typing.Generic[T]):
     def __init__(self, client: modal.client.Client, task_id: str) -> None: ...
     def _validate_mode(self, mode: str) -> None: ...
 
-    class ___consume_output_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___consume_output_spec(typing_extensions.Protocol):
         def __call__(self, /, exec_id: str) -> typing.Iterator[typing.Union[bytes, None, Exception]]: ...
         def aio(self, /, exec_id: str) -> typing.AsyncIterator[typing.Union[bytes, None, Exception]]: ...
 
-    _consume_output: ___consume_output_spec[typing_extensions.Self]
+    _consume_output: ___consume_output_spec
 
-    class ___consume_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___consume_watch_output_spec(typing_extensions.Protocol):
         def __call__(self, /, exec_id: str) -> None: ...
         async def aio(self, /, exec_id: str) -> None: ...
 
-    _consume_watch_output: ___consume_watch_output_spec[typing_extensions.Self]
+    _consume_watch_output: ___consume_watch_output_spec
 
-    class ___parse_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___parse_watch_output_spec(typing_extensions.Protocol):
         def __call__(self, /, event: bytes) -> typing.Optional[FileWatchEvent]: ...
         async def aio(self, /, event: bytes) -> typing.Optional[FileWatchEvent]: ...
 
-    _parse_watch_output: ___parse_watch_output_spec[typing_extensions.Self]
+    _parse_watch_output: ___parse_watch_output_spec
 
-    class ___wait_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___wait_spec(typing_extensions.Protocol):
         def __call__(self, /, exec_id: str) -> bytes: ...
         async def aio(self, /, exec_id: str) -> bytes: ...
 
-    _wait: ___wait_spec[typing_extensions.Self]
+    _wait: ___wait_spec
 
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
 
-    class ___open_file_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___open_file_spec(typing_extensions.Protocol):
         def __call__(self, /, path: str, mode: str) -> None: ...
         async def aio(self, /, path: str, mode: str) -> None: ...
 
-    _open_file: ___open_file_spec[typing_extensions.Self]
+    _open_file: ___open_file_spec
+
+    class __create_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            path: str,
+            mode: typing.Union[_typeshed.OpenTextMode, _typeshed.OpenBinaryMode],
+            client: modal.client.Client,
+            task_id: str,
+        ) -> FileIO:
+            """Create a new FileIO handle."""
+            ...
 
-    @classmethod
-    def create(
-        cls,
-        path: str,
-        mode: typing.Union[_typeshed.OpenTextMode, _typeshed.OpenBinaryMode],
-        client: modal.client.Client,
-        task_id: str,
-    ) -> FileIO:
-        """Create a new FileIO handle."""
-        ...
+        async def aio(
+            self,
+            /,
+            path: str,
+            mode: typing.Union[_typeshed.OpenTextMode, _typeshed.OpenBinaryMode],
+            client: modal.client.Client,
+            task_id: str,
+        ) -> FileIO:
+            """Create a new FileIO handle."""
+            ...
+
+    create: typing.ClassVar[__create_spec]
 
-    class ___make_read_request_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___make_read_request_spec(typing_extensions.Protocol):
         def __call__(self, /, n: typing.Optional[int]) -> bytes: ...
         async def aio(self, /, n: typing.Optional[int]) -> bytes: ...
 
-    _make_read_request: ___make_read_request_spec[typing_extensions.Self]
+    _make_read_request: ___make_read_request_spec
 
-    class __read_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
+    class __read_spec(typing_extensions.Protocol[T_INNER]):
         def __call__(self, /, n: typing.Optional[int] = None) -> T_INNER:
             """Read n bytes from the current position, or the entire remaining file if n is None."""
             ...
@@ -310,9 +307,9 @@ class FileIO(typing.Generic[T]):
             """Read n bytes from the current position, or the entire remaining file if n is None."""
             ...
 
-    read: __read_spec[T, typing_extensions.Self]
+    read: __read_spec[T]
 
-    class __readline_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
+    class __readline_spec(typing_extensions.Protocol[T_INNER]):
         def __call__(self, /) -> T_INNER:
             """Read a single line from the current position."""
             ...
@@ -321,9 +318,9 @@ class FileIO(typing.Generic[T]):
             """Read a single line from the current position."""
             ...
 
-    readline: __readline_spec[T, typing_extensions.Self]
+    readline: __readline_spec[T]
 
-    class __readlines_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
+    class __readlines_spec(typing_extensions.Protocol[T_INNER]):
         def __call__(self, /) -> typing.Sequence[T_INNER]:
             """Read all lines from the current position."""
             ...
@@ -332,9 +329,9 @@ class FileIO(typing.Generic[T]):
             """Read all lines from the current position."""
             ...
 
-    readlines: __readlines_spec[T, typing_extensions.Self]
+    readlines: __readlines_spec[T]
 
-    class __write_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __write_spec(typing_extensions.Protocol):
         def __call__(self, /, data: typing.Union[bytes, str]) -> None:
             """Write data to the current position.
 
@@ -353,9 +350,9 @@ class FileIO(typing.Generic[T]):
             """
             ...
 
-    write: __write_spec[typing_extensions.Self]
+    write: __write_spec
 
-    class __flush_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __flush_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Flush the buffer to disk."""
             ...
@@ -364,11 +361,11 @@ class FileIO(typing.Generic[T]):
             """Flush the buffer to disk."""
             ...
 
-    flush: __flush_spec[typing_extensions.Self]
+    flush: __flush_spec
 
     def _get_whence(self, whence: int): ...
 
-    class __seek_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __seek_spec(typing_extensions.Protocol):
         def __call__(self, /, offset: int, whence: int = 0) -> None:
             """Move to a new position in the file.
 
@@ -385,41 +382,72 @@ class FileIO(typing.Generic[T]):
             """
             ...
 
-    seek: __seek_spec[typing_extensions.Self]
+    seek: __seek_spec
 
-    @classmethod
-    def ls(cls, path: str, client: modal.client.Client, task_id: str) -> list[str]:
-        """List the contents of the provided directory."""
-        ...
+    class __ls_spec(typing_extensions.Protocol):
+        def __call__(self, /, path: str, client: modal.client.Client, task_id: str) -> list[str]:
+            """List the contents of the provided directory."""
+            ...
 
-    @classmethod
-    def mkdir(cls, path: str, client: modal.client.Client, task_id: str, parents: bool = False) -> None:
-        """Create a new directory."""
-        ...
+        async def aio(self, /, path: str, client: modal.client.Client, task_id: str) -> list[str]:
+            """List the contents of the provided directory."""
+            ...
 
-    @classmethod
-    def rm(cls, path: str, client: modal.client.Client, task_id: str, recursive: bool = False) -> None:
-        """Remove a file or directory in the Sandbox."""
-        ...
+    ls: typing.ClassVar[__ls_spec]
 
-    @classmethod
-    def watch(
-        cls,
-        path: str,
-        client: modal.client.Client,
-        task_id: str,
-        filter: typing.Optional[list[FileWatchEventType]] = None,
-        recursive: bool = False,
-        timeout: typing.Optional[int] = None,
-    ) -> typing.Iterator[FileWatchEvent]: ...
+    class __mkdir_spec(typing_extensions.Protocol):
+        def __call__(self, /, path: str, client: modal.client.Client, task_id: str, parents: bool = False) -> None:
+            """Create a new directory."""
+            ...
+
+        async def aio(self, /, path: str, client: modal.client.Client, task_id: str, parents: bool = False) -> None:
+            """Create a new directory."""
+            ...
+
+    mkdir: typing.ClassVar[__mkdir_spec]
+
+    class __rm_spec(typing_extensions.Protocol):
+        def __call__(self, /, path: str, client: modal.client.Client, task_id: str, recursive: bool = False) -> None:
+            """Remove a file or directory in the Sandbox."""
+            ...
+
+        async def aio(self, /, path: str, client: modal.client.Client, task_id: str, recursive: bool = False) -> None:
+            """Remove a file or directory in the Sandbox."""
+            ...
 
-    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
+    rm: typing.ClassVar[__rm_spec]
+
+    class __watch_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            path: str,
+            client: modal.client.Client,
+            task_id: str,
+            filter: typing.Optional[list[FileWatchEventType]] = None,
+            recursive: bool = False,
+            timeout: typing.Optional[int] = None,
+        ) -> typing.Iterator[FileWatchEvent]: ...
+        def aio(
+            self,
+            /,
+            path: str,
+            client: modal.client.Client,
+            task_id: str,
+            filter: typing.Optional[list[FileWatchEventType]] = None,
+            recursive: bool = False,
+            timeout: typing.Optional[int] = None,
+        ) -> typing.AsyncIterator[FileWatchEvent]: ...
+
+    watch: typing.ClassVar[__watch_spec]
+
+    class ___close_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None: ...
         async def aio(self, /) -> None: ...
 
-    _close: ___close_spec[typing_extensions.Self]
+    _close: ___close_spec
 
-    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __close_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Flush the buffer and close the file."""
             ...
@@ -428,7 +456,7 @@ class FileIO(typing.Generic[T]):
             """Flush the buffer and close the file."""
             ...
 
-    close: __close_spec[typing_extensions.Self]
+    close: __close_spec
 
     def _check_writable(self) -> None: ...
     def _check_readable(self) -> None: ...