modal 0.71.7__py3-none-any.whl → 0.71.12__py3-none-any.whl

modal/_container_entrypoint.py

@@ -116,7 +116,7 @@ class UserCodeEventLoop:
 
     def __enter__(self):
         self.loop = asyncio.new_event_loop()
-        self.tasks = []
+        self.tasks = set()
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
@@ -130,7 +130,10 @@ class UserCodeEventLoop:
         self.loop.close()
 
     def create_task(self, coro):
-        self.tasks.append(self.loop.create_task(coro))
+        task = self.loop.create_task(coro)
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.discard)
+        return task
 
     def run(self, coro):
         task = asyncio.ensure_future(coro, loop=self.loop)
@@ -531,10 +534,13 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
         with container_io_manager.handle_user_exception():
             finalized_functions = service.get_finalized_functions(function_def, container_io_manager)
         # Execute the function.
+        lifespan_background_tasks = []
         try:
             for finalized_function in finalized_functions.values():
                 if finalized_function.lifespan_manager:
-                    event_loop.create_task(finalized_function.lifespan_manager.background_task())
+                    lifespan_background_tasks.append(
+                        event_loop.create_task(finalized_function.lifespan_manager.background_task())
+                    )
                     with container_io_manager.handle_user_exception():
                         event_loop.run(finalized_function.lifespan_manager.lifespan_startup())
             call_function(
@@ -559,6 +565,10 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                             with container_io_manager.handle_user_exception():
                                 event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
                 finally:
+                    # no need to keep the lifespan asgi call around - we send it no more messages
+                    for lifespan_background_task in lifespan_background_tasks:
+                        lifespan_background_task.cancel()  # prevent dangling tasks
+
                     # Identify "exit" methods and run them.
                     # want to make sure this is called even if the lifespan manager fails
                     if service.user_cls_instance is not None and not is_auto_snapshot:

modal/_runtime/asgi.py

@@ -22,11 +22,11 @@ FIRST_MESSAGE_TIMEOUT_SECONDS = 5.0
 
 
 class LifespanManager:
-    startup: asyncio.Future
-    shutdown: asyncio.Future
-    queue: asyncio.Queue
-    has_run_init: bool = False
-    lifespan_supported: bool = False
+    _startup: asyncio.Future
+    _shutdown: asyncio.Future
+    _queue: asyncio.Queue
+    _has_run_init: bool = False
+    _lifespan_supported: bool = False
 
     def __init__(self, asgi_app, state):
         self.asgi_app = asgi_app
@@ -37,59 +37,63 @@ class LifespanManager:
         # no async code since it has to run inside
         # the event loop to tie the
         # objects to the correct loop in python 3.9
-        if not self.has_run_init:
-            self.queue = asyncio.Queue()
-            self.startup = asyncio.Future()
-            self.shutdown = asyncio.Future()
-            self.has_run_init = True
+        if not self._has_run_init:
+            self._queue = asyncio.Queue()
+            self._startup = asyncio.Future()
+            self._shutdown = asyncio.Future()
+            self._has_run_init = True
 
     async def background_task(self):
         await self.ensure_init()
 
         async def receive():
-            self.lifespan_supported = True
-            return await self.queue.get()
+            self._lifespan_supported = True
+            return await self._queue.get()
 
         async def send(message):
             if message["type"] == "lifespan.startup.complete":
-                self.startup.set_result(None)
+                self._startup.set_result(None)
             elif message["type"] == "lifespan.startup.failed":
-                self.startup.set_exception(ExecutionError("ASGI lifespan startup failed"))
+                self._startup.set_exception(ExecutionError("ASGI lifespan startup failed"))
             elif message["type"] == "lifespan.shutdown.complete":
-                self.shutdown.set_result(None)
+                self._shutdown.set_result(None)
             elif message["type"] == "lifespan.shutdown.failed":
-                self.shutdown.set_exception(ExecutionError("ASGI lifespan shutdown failed"))
+                self._shutdown.set_exception(ExecutionError("ASGI lifespan shutdown failed"))
             else:
                 raise ExecutionError(f"Unexpected message type: {message['type']}")
 
         try:
             await self.asgi_app({"type": "lifespan", "state": self.state}, receive, send)
         except Exception as e:
-            if not self.lifespan_supported:
+            if not self._lifespan_supported:
                 logger.info(f"ASGI lifespan task exited before receiving any messages with exception:\n{e}")
-                self.startup.set_result(None)
-                self.shutdown.set_result(None)
+                if not self._startup.done():
+                    self._startup.set_result(None)
+                if not self._shutdown.done():
+                    self._shutdown.set_result(None)
                 return
 
             logger.error(f"Error in ASGI lifespan task: {e}")
-            if not self.startup.done():
-                self.startup.set_exception(ExecutionError("ASGI lifespan task exited startup"))
-            if not self.shutdown.done():
-                self.shutdown.set_exception(ExecutionError("ASGI lifespan task exited shutdown"))
+            if not self._startup.done():
+                self._startup.set_exception(ExecutionError("ASGI lifespan task exited startup"))
+            if not self._shutdown.done():
+                self._shutdown.set_exception(ExecutionError("ASGI lifespan task exited shutdown"))
         else:
             logger.info("ASGI Lifespan protocol is probably not supported by this library")
-            self.startup.set_result(None)
-            self.shutdown.set_result(None)
+            if not self._startup.done():
+                self._startup.set_result(None)
+            if not self._shutdown.done():
+                self._shutdown.set_result(None)
 
     async def lifespan_startup(self):
         await self.ensure_init()
-        self.queue.put_nowait({"type": "lifespan.startup"})
-        await self.startup
+        self._queue.put_nowait({"type": "lifespan.startup"})
+        await self._startup
 
     async def lifespan_shutdown(self):
         await self.ensure_init()
-        self.queue.put_nowait({"type": "lifespan.shutdown"})
-        await self.shutdown
+        self._queue.put_nowait({"type": "lifespan.shutdown"})
+        await self._shutdown
 
 
 def asgi_app_wrapper(asgi_app, container_io_manager) -> tuple[Callable[..., AsyncGenerator], LifespanManager]:

modal/cli/volume.py

@@ -287,3 +287,26 @@ async def delete(
         )
 
     await _Volume.delete(volume_name, environment_name=env)
+
+
+@volume_cli.command(
+    name="rename",
+    help="Rename a modal.Volume.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def rename(
+    old_name: str,
+    new_name: str,
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want rename the modal.Volume '{old_name}'?"
+            " This may break any Apps currently using it.",
+            default=False,
+            abort=True,
+        )
+
+    await _Volume.rename(old_name, new_name, environment_name=env)

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.7"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.12"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.7"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.71.12"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/file_io.py

@@ -12,8 +12,9 @@ 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.io_streams_helper import consume_stream_with_retries
+from modal.exception import ClientClosed
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -56,7 +57,8 @@ 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 file._make_request(
+    resp = await retry_transient_errors(
+        file._client.stub.ContainerFilesystemExec,
         api_pb2.ContainerFilesystemExecRequest(
             file_delete_bytes_request=api_pb2.ContainerFileDeleteBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -64,7 +66,7 @@ async def _delete_bytes(file: "_FileIO", start: Optional[int] = None, end: Optio
                 end_exclusive=end,
             ),
             task_id=file._task_id,
-        )
+        ),
     )
     await file._wait(resp.exec_id)
 
@@ -83,7 +85,8 @@ 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 file._make_request(
+    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,
@@ -92,7 +95,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
                 end_exclusive=end,
             ),
             task_id=file._task_id,
-        )
+        ),
     )
     await file._wait(resp.exec_id)
 
@@ -140,9 +143,13 @@ class _FileIO(Generic[T]):
 
     _task_id: str = ""
     _file_descriptor: str = ""
-    _client: Optional[_Client] = None
+    _client: _Client
     _watch_output_buffer: list[Optional[bytes]] = []
 
+    def __init__(self, client: _Client, task_id: str) -> None:
+        self._client = client
+        self._task_id = task_id
+
     def _validate_mode(self, mode: str) -> None:
         if not any(char in mode for char in "rwax"):
             raise ValueError(f"Invalid file mode: {mode}")
@@ -175,7 +182,6 @@ class _FileIO(Generic[T]):
             exec_id=exec_id,
             timeout=55,
         )
-        assert self._client is not None
         async for batch in self._client.stub.ContainerFilesystemExecGetOutput.unary_stream(req):
             if batch.eof:
                 yield None
@@ -186,17 +192,30 @@ class _FileIO(Generic[T]):
                 yield message
 
     async def _consume_watch_output(self, exec_id: str) -> None:
-        def item_handler(item: Optional[bytes]):
-            self._watch_output_buffer.append(item)
-
-        def completion_check(item: Optional[bytes]):
-            return item is None
+        completed = False
+        retries_remaining = 10
+        while not completed:
+            try:
+                iterator = self._consume_output(exec_id)
+                async for message in iterator:
+                    self._watch_output_buffer.append(message)
+                    if message is None:
+                        completed = True
+                        break
 
-        await consume_stream_with_retries(
-            self._consume_output(exec_id),
-            item_handler,
-            completion_check,
-        )
+            except (GRPCError, 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
+                    elif isinstance(exc, StreamTerminatedError):
+                        continue
+                    elif isinstance(exc, ClientClosed):
+                        # If the client was closed, the user has triggered a cleanup.
+                        break
+                raise exc
 
     async def _parse_watch_output(self, event: bytes) -> Optional[FileWatchEvent]:
         try:
@@ -206,23 +225,6 @@ class _FileIO(Generic[T]):
             # skip invalid events
             return None
 
-    async def _stream_watch_output(self) -> AsyncIterator[FileWatchEvent]:
-        buffer = b""
-        while True:
-            if len(self._watch_output_buffer) > 0:
-                item = self._watch_output_buffer.pop(0)
-                if item is None:
-                    break
-                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"):
-                    event = await self._parse_watch_output(buffer.strip())
-                    if event is not None:
-                        yield event
-                    buffer = b""
-            else:
-                await asyncio.sleep(0.1)
-
     async def _wait(self, exec_id: str) -> bytes:
         # The logic here is similar to how output is read from `exec`
         output = b""
@@ -254,11 +256,12 @@ class _FileIO(Generic[T]):
             raise TypeError("Expected str when in text mode")
 
     async def _open_file(self, path: str, mode: str) -> None:
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_open_request=api_pb2.ContainerFileOpenRequest(path=path, mode=mode),
                 task_id=self._task_id,
-            )
+            ),
         )
         if not resp.HasField("file_descriptor"):
             raise FilesystemExecutionError("Failed to open file")
@@ -270,26 +273,19 @@ class _FileIO(Generic[T]):
         cls, path: str, mode: Union["_typeshed.OpenTextMode", "_typeshed.OpenBinaryMode"], client: _Client, task_id: str
     ) -> "_FileIO":
         """Create a new FileIO handle."""
-        self = cls.__new__(cls)
-        self._client = client
-        self._task_id = task_id
+        self = _FileIO(client, task_id)
         self._validate_mode(mode)
         await self._open_file(path, mode)
         self._closed = False
         return self
 
-    async def _make_request(
-        self, request: api_pb2.ContainerFilesystemExecRequest
-    ) -> api_pb2.ContainerFilesystemExecResponse:
-        assert self._client is not None
-        return await retry_transient_errors(self._client.stub.ContainerFilesystemExec, request)
-
     async def _make_read_request(self, n: Optional[int]) -> bytes:
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            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,
-            )
+            ),
         )
         return await self._wait(resp.exec_id)
 
@@ -308,11 +304,12 @@ class _FileIO(Generic[T]):
         """Read a single line from the current position."""
         self._check_closed()
         self._check_readable()
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_read_line_request=api_pb2.ContainerFileReadLineRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
-            )
+            ),
         )
         output = await self._wait(resp.exec_id)
         if self._binary:
@@ -349,14 +346,15 @@ 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 self._make_request(
+            resp = await retry_transient_errors(
+                self._client.stub.ContainerFilesystemExec,
                 api_pb2.ContainerFilesystemExecRequest(
                     file_write_request=api_pb2.ContainerFileWriteRequest(
                         file_descriptor=self._file_descriptor,
                         data=chunk,
                     ),
                     task_id=self._task_id,
-                )
+                ),
             )
             await self._wait(resp.exec_id)
 
@@ -364,11 +362,12 @@ class _FileIO(Generic[T]):
         """Flush the buffer to disk."""
         self._check_closed()
         self._check_writable()
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_flush_request=api_pb2.ContainerFileFlushRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
-            )
+            ),
         )
         await self._wait(resp.exec_id)
 
@@ -389,7 +388,8 @@ class _FileIO(Generic[T]):
         (relative to the current position) and 2 (relative to the file's end).
         """
         self._check_closed()
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_seek_request=api_pb2.ContainerFileSeekRequest(
                     file_descriptor=self._file_descriptor,
@@ -397,21 +397,20 @@ class _FileIO(Generic[T]):
                     whence=self._get_whence(whence),
                 ),
                 task_id=self._task_id,
-            )
+            ),
         )
         await self._wait(resp.exec_id)
 
     @classmethod
     async def ls(cls, path: str, client: _Client, task_id: str) -> list[str]:
         """List the contents of the provided directory."""
-        self = cls.__new__(cls)
-        self._client = client
-        self._task_id = task_id
-        resp = await self._make_request(
+        self = _FileIO(client, task_id)
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_ls_request=api_pb2.ContainerFileLsRequest(path=path),
                 task_id=task_id,
-            )
+            ),
         )
         output = await self._wait(resp.exec_id)
         try:
@@ -422,28 +421,26 @@ class _FileIO(Generic[T]):
     @classmethod
     async def mkdir(cls, path: str, client: _Client, task_id: str, parents: bool = False) -> None:
         """Create a new directory."""
-        self = cls.__new__(cls)
-        self._client = client
-        self._task_id = task_id
-        resp = await self._make_request(
+        self = _FileIO(client, task_id)
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_mkdir_request=api_pb2.ContainerFileMkdirRequest(path=path, make_parents=parents),
                 task_id=self._task_id,
-            )
+            ),
         )
         await self._wait(resp.exec_id)
 
     @classmethod
     async def rm(cls, path: str, client: _Client, task_id: str, recursive: bool = False) -> None:
         """Remove a file or directory in the Sandbox."""
-        self = cls.__new__(cls)
-        self._client = client
-        self._task_id = task_id
-        resp = await self._make_request(
+        self = _FileIO(client, task_id)
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_rm_request=api_pb2.ContainerFileRmRequest(path=path, recursive=recursive),
                 task_id=self._task_id,
-            )
+            ),
         )
         await self._wait(resp.exec_id)
 
@@ -457,10 +454,9 @@ class _FileIO(Generic[T]):
         recursive: bool = False,
         timeout: Optional[int] = None,
     ) -> AsyncIterator[FileWatchEvent]:
-        self = cls.__new__(cls)
-        self._client = client
-        self._task_id = task_id
-        resp = await self._make_request(
+        self = _FileIO(client, task_id)
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_watch_request=api_pb2.ContainerFileWatchRequest(
                     path=path,
@@ -468,22 +464,44 @@ class _FileIO(Generic[T]):
                     timeout_secs=timeout,
                 ),
                 task_id=self._task_id,
-            )
+            ),
         )
-        task = asyncio.create_task(self._consume_watch_output(resp.exec_id))
-        async for event in self._stream_watch_output():
-            if filter and event.type not in filter:
-                continue
-            yield event
-        task.cancel()
+        async with TaskContext() as tc:
+            tc.create_task(self._consume_watch_output(resp.exec_id))
+
+            buffer = b""
+            while True:
+                if len(self._watch_output_buffer) > 0:
+                    item = self._watch_output_buffer.pop(0)
+                    if item is None:
+                        break
+                    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"):
+                        try:
+                            event_json = json.loads(buffer.strip().decode())
+                            event = FileWatchEvent(
+                                type=FileWatchEventType(event_json["event_type"]),
+                                paths=event_json["paths"],
+                            )
+                            if not filter or event.type in filter:
+                                yield event
+                        except (json.JSONDecodeError, KeyError, ValueError):
+                            # skip invalid events
+                            pass
+                        buffer = b""
+                else:
+                    await asyncio.sleep(0.1)
 
     async def _close(self) -> None:
         # Buffer is flushed by the runner on close
-        resp = await self._make_request(
+        resp = await retry_transient_errors(
+            self._client.stub.ContainerFilesystemExec,
             api_pb2.ContainerFilesystemExecRequest(
                 file_close_request=api_pb2.ContainerFileCloseRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
-            )
+            ),
         )
         self._closed = True
         await self._wait(resp.exec_id)

modal/file_io.pyi

@@ -32,15 +32,15 @@ class FileWatchEvent:
 class _FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
-    _client: typing.Optional[modal.client._Client]
+    _client: modal.client._Client
     _watch_output_buffer: list[typing.Optional[bytes]]
 
+    def __init__(self, client: modal.client._Client, task_id: str) -> None: ...
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
     def _consume_output(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
     async def _consume_watch_output(self, exec_id: str) -> None: ...
     async def _parse_watch_output(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
-    def _stream_watch_output(self) -> typing.AsyncIterator[FileWatchEvent]: ...
     async def _wait(self, exec_id: str) -> bytes: ...
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
     async def _open_file(self, path: str, mode: str) -> None: ...
@@ -52,9 +52,6 @@ class _FileIO(typing.Generic[T]):
         client: modal.client._Client,
         task_id: str,
     ) -> _FileIO: ...
-    async def _make_request(
-        self, request: modal_proto.api_pb2.ContainerFilesystemExecRequest
-    ) -> modal_proto.api_pb2.ContainerFilesystemExecResponse: ...
     async def _make_read_request(self, n: typing.Optional[int]) -> bytes: ...
     async def read(self, n: typing.Optional[int] = None) -> T: ...
     async def readline(self) -> T: ...
@@ -108,10 +105,10 @@ T_INNER = typing.TypeVar("T_INNER", covariant=True)
 class FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
-    _client: typing.Optional[modal.client.Client]
+    _client: modal.client.Client
     _watch_output_buffer: list[typing.Optional[bytes]]
 
-    def __init__(self, /, *args, **kwargs): ...
+    def __init__(self, client: modal.client.Client, task_id: str) -> None: ...
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
 
@@ -133,12 +130,6 @@ class FileIO(typing.Generic[T]):
 
     _parse_watch_output: ___parse_watch_output_spec
 
-    class ___stream_watch_output_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Iterator[FileWatchEvent]: ...
-        def aio(self) -> typing.AsyncIterator[FileWatchEvent]: ...
-
-    _stream_watch_output: ___stream_watch_output_spec
-
     class ___wait_spec(typing_extensions.Protocol):
         def __call__(self, exec_id: str) -> bytes: ...
         async def aio(self, exec_id: str) -> bytes: ...
@@ -162,16 +153,6 @@ class FileIO(typing.Generic[T]):
         task_id: str,
     ) -> FileIO: ...
 
-    class ___make_request_spec(typing_extensions.Protocol):
-        def __call__(
-            self, request: modal_proto.api_pb2.ContainerFilesystemExecRequest
-        ) -> modal_proto.api_pb2.ContainerFilesystemExecResponse: ...
-        async def aio(
-            self, request: modal_proto.api_pb2.ContainerFilesystemExecRequest
-        ) -> modal_proto.api_pb2.ContainerFilesystemExecResponse: ...
-
-    _make_request: ___make_request_spec
-
     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: ...