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

modal_proto/sandbox_router_pb2_grpc.py

@@ -0,0 +1,203 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from modal_proto import sandbox_router_pb2 as modal__proto_dot_sandbox__router__pb2
+
+
+class SandboxRouterStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SandboxExecPoll = channel.unary_unary(
+                '/modal.sandbox_router.SandboxRouter/SandboxExecPoll',
+                request_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecPollRequest.SerializeToString,
+                response_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecPollResponse.FromString,
+                )
+        self.SandboxExecStart = channel.unary_unary(
+                '/modal.sandbox_router.SandboxRouter/SandboxExecStart',
+                request_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStartRequest.SerializeToString,
+                response_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStartResponse.FromString,
+                )
+        self.SandboxExecStdinWrite = channel.unary_unary(
+                '/modal.sandbox_router.SandboxRouter/SandboxExecStdinWrite',
+                request_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteRequest.SerializeToString,
+                response_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteResponse.FromString,
+                )
+        self.SandboxExecStdioRead = channel.unary_stream(
+                '/modal.sandbox_router.SandboxRouter/SandboxExecStdioRead',
+                request_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadRequest.SerializeToString,
+                response_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadResponse.FromString,
+                )
+        self.SandboxExecWait = channel.unary_unary(
+                '/modal.sandbox_router.SandboxRouter/SandboxExecWait',
+                request_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecWaitRequest.SerializeToString,
+                response_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecWaitResponse.FromString,
+                )
+
+
+class SandboxRouterServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def SandboxExecPoll(self, request, context):
+        """Poll for the exit status of an exec'd command.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SandboxExecStart(self, request, context):
+        """Execute a command in the sandbox.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SandboxExecStdinWrite(self, request, context):
+        """Write to the stdin stream of an exec'd command.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SandboxExecStdioRead(self, request, context):
+        """Get a stream of output from the stdout or stderr stream of an exec'd command.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SandboxExecWait(self, request, context):
+        """Wait for an exec'd command to exit and return the exit code.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_SandboxRouterServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SandboxExecPoll': grpc.unary_unary_rpc_method_handler(
+                    servicer.SandboxExecPoll,
+                    request_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecPollRequest.FromString,
+                    response_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecPollResponse.SerializeToString,
+            ),
+            'SandboxExecStart': grpc.unary_unary_rpc_method_handler(
+                    servicer.SandboxExecStart,
+                    request_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStartRequest.FromString,
+                    response_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStartResponse.SerializeToString,
+            ),
+            'SandboxExecStdinWrite': grpc.unary_unary_rpc_method_handler(
+                    servicer.SandboxExecStdinWrite,
+                    request_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteRequest.FromString,
+                    response_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteResponse.SerializeToString,
+            ),
+            'SandboxExecStdioRead': grpc.unary_stream_rpc_method_handler(
+                    servicer.SandboxExecStdioRead,
+                    request_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadRequest.FromString,
+                    response_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadResponse.SerializeToString,
+            ),
+            'SandboxExecWait': grpc.unary_unary_rpc_method_handler(
+                    servicer.SandboxExecWait,
+                    request_deserializer=modal__proto_dot_sandbox__router__pb2.SandboxExecWaitRequest.FromString,
+                    response_serializer=modal__proto_dot_sandbox__router__pb2.SandboxExecWaitResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'modal.sandbox_router.SandboxRouter', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class SandboxRouter(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def SandboxExecPoll(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/modal.sandbox_router.SandboxRouter/SandboxExecPoll',
+            modal__proto_dot_sandbox__router__pb2.SandboxExecPollRequest.SerializeToString,
+            modal__proto_dot_sandbox__router__pb2.SandboxExecPollResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def SandboxExecStart(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/modal.sandbox_router.SandboxRouter/SandboxExecStart',
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStartRequest.SerializeToString,
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStartResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def SandboxExecStdinWrite(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/modal.sandbox_router.SandboxRouter/SandboxExecStdinWrite',
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteRequest.SerializeToString,
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStdinWriteResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def SandboxExecStdioRead(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/modal.sandbox_router.SandboxRouter/SandboxExecStdioRead',
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadRequest.SerializeToString,
+            modal__proto_dot_sandbox__router__pb2.SandboxExecStdioReadResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def SandboxExecWait(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/modal.sandbox_router.SandboxRouter/SandboxExecWait',
+            modal__proto_dot_sandbox__router__pb2.SandboxExecWaitRequest.SerializeToString,
+            modal__proto_dot_sandbox__router__pb2.SandboxExecWaitResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

modal_proto/sandbox_router_pb2_grpc.pyi

@@ -0,0 +1,75 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+import abc
+import collections.abc
+import grpc
+import modal_proto.sandbox_router_pb2
+
+class SandboxRouterStub:
+    def __init__(self, channel: grpc.Channel) -> None: ...
+    SandboxExecPoll: grpc.UnaryUnaryMultiCallable[
+        modal_proto.sandbox_router_pb2.SandboxExecPollRequest,
+        modal_proto.sandbox_router_pb2.SandboxExecPollResponse,
+    ]
+    """Poll for the exit status of an exec'd command."""
+    SandboxExecStart: grpc.UnaryUnaryMultiCallable[
+        modal_proto.sandbox_router_pb2.SandboxExecStartRequest,
+        modal_proto.sandbox_router_pb2.SandboxExecStartResponse,
+    ]
+    """Execute a command in the sandbox."""
+    SandboxExecStdinWrite: grpc.UnaryUnaryMultiCallable[
+        modal_proto.sandbox_router_pb2.SandboxExecStdinWriteRequest,
+        modal_proto.sandbox_router_pb2.SandboxExecStdinWriteResponse,
+    ]
+    """Write to the stdin stream of an exec'd command."""
+    SandboxExecStdioRead: grpc.UnaryStreamMultiCallable[
+        modal_proto.sandbox_router_pb2.SandboxExecStdioReadRequest,
+        modal_proto.sandbox_router_pb2.SandboxExecStdioReadResponse,
+    ]
+    """Get a stream of output from the stdout or stderr stream of an exec'd command."""
+    SandboxExecWait: grpc.UnaryUnaryMultiCallable[
+        modal_proto.sandbox_router_pb2.SandboxExecWaitRequest,
+        modal_proto.sandbox_router_pb2.SandboxExecWaitResponse,
+    ]
+    """Wait for an exec'd command to exit and return the exit code."""
+
+class SandboxRouterServicer(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def SandboxExecPoll(
+        self,
+        request: modal_proto.sandbox_router_pb2.SandboxExecPollRequest,
+        context: grpc.ServicerContext,
+    ) -> modal_proto.sandbox_router_pb2.SandboxExecPollResponse:
+        """Poll for the exit status of an exec'd command."""
+    @abc.abstractmethod
+    def SandboxExecStart(
+        self,
+        request: modal_proto.sandbox_router_pb2.SandboxExecStartRequest,
+        context: grpc.ServicerContext,
+    ) -> modal_proto.sandbox_router_pb2.SandboxExecStartResponse:
+        """Execute a command in the sandbox."""
+    @abc.abstractmethod
+    def SandboxExecStdinWrite(
+        self,
+        request: modal_proto.sandbox_router_pb2.SandboxExecStdinWriteRequest,
+        context: grpc.ServicerContext,
+    ) -> modal_proto.sandbox_router_pb2.SandboxExecStdinWriteResponse:
+        """Write to the stdin stream of an exec'd command."""
+    @abc.abstractmethod
+    def SandboxExecStdioRead(
+        self,
+        request: modal_proto.sandbox_router_pb2.SandboxExecStdioReadRequest,
+        context: grpc.ServicerContext,
+    ) -> collections.abc.Iterator[modal_proto.sandbox_router_pb2.SandboxExecStdioReadResponse]:
+        """Get a stream of output from the stdout or stderr stream of an exec'd command."""
+    @abc.abstractmethod
+    def SandboxExecWait(
+        self,
+        request: modal_proto.sandbox_router_pb2.SandboxExecWaitRequest,
+        context: grpc.ServicerContext,
+    ) -> modal_proto.sandbox_router_pb2.SandboxExecWaitResponse:
+        """Wait for an exec'd command to exit and return the exit code."""
+
+def add_SandboxRouterServicer_to_server(servicer: SandboxRouterServicer, server: grpc.Server) -> None: ...

modal_proto/task_command_router.proto

@@ -0,0 +1,144 @@
+syntax = "proto3";
+
+option go_package = "github.com/modal-labs/modal/go/proto";
+
+import "modal_proto/api.proto";
+
+package modal.task_command_router;
+
+enum TaskExecStderrConfig {
+  // The output will be discarded.
+  TASK_EXEC_STDERR_CONFIG_DEVNULL = 0;
+  // The output will be streamed to the client.
+  TASK_EXEC_STDERR_CONFIG_PIPE = 1;
+  // A special value that can be used to indicate that the stderr stream should
+  // be merged with the stdout stream.
+  TASK_EXEC_STDERR_CONFIG_STDOUT = 2;
+}
+
+enum TaskExecStdioFileDescriptor {
+  // Read from stdout.
+  TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDOUT = 0;
+  // Read from stderr.
+  TASK_EXEC_STDIO_FILE_DESCRIPTOR_STDERR = 1;
+}
+
+enum TaskExecStdoutConfig {
+  // The output will be discarded.
+  TASK_EXEC_STDOUT_CONFIG_DEVNULL = 0;
+  // The output will be streamed to the client.
+  TASK_EXEC_STDOUT_CONFIG_PIPE = 1;
+}
+
+message TaskExecPollRequest {
+  // The ID of the task running the exec'd command.
+  string task_id = 1;
+  // The execution ID of the command to wait on.
+  string exec_id = 2;
+}
+
+// The response to a TaskExecPollRequest. If the exec'd command has not
+// completed, exit_status will be unset.
+message TaskExecPollResponse {
+  oneof exit_status {
+    // The exit code of the command.
+    int32 code = 1;
+    // The signal that terminated the command.
+    int32 signal = 2;
+  }
+  // TODO(saltzm): Give a way for the user to distinguish between normal exit
+  // and termination by Modal (due to task timeout, exec exceeded deadline, etc.)
+}
+
+message TaskExecStartRequest {
+  // The ID of the task to execute the command in.
+  string task_id = 1;
+  // Execution ID. This ID will be used to identify the execution for other
+  // requests and ensure exec commands are idempotent.
+  string exec_id = 2;
+  // Command arguments to execute.
+  repeated string command_args= 3;
+  // Configures how the stdout of the command will be handled.
+  TaskExecStdoutConfig stdout_config = 4;
+  // Configures how the stderr of the command will be handled.
+  TaskExecStderrConfig stderr_config = 5;
+  // Timeout in seconds for the exec'd command to exit. If the command does not
+  // exit within this duration, the command will be killed. This is NOT the
+  // timeout for the ExecStartRequest RPC to complete.
+  optional uint32 timeout_secs = 6;
+  // Working directory for the command.
+  optional string workdir = 7;
+  // Secret IDs to mount into the task.
+  repeated string secret_ids = 8;
+  // PTY info for the command.
+  optional modal.client.PTYInfo pty_info = 9;
+  // Enable debugging capabilities on the container runtime. Used only for
+  // internal debugging.
+  bool runtime_debug = 10;
+}
+
+message TaskExecStartResponse { }
+
+message TaskExecStdinWriteRequest {
+  // The ID of the task running the exec'd command.
+  string task_id = 1;
+  // The execution ID of the command to write to.
+  string exec_id = 2;
+  // The offset to start writing to. This is used to resume writing from the
+  // last write position if the connection is closed and reopened.
+  uint64 offset = 3;
+  bytes data = 4;
+  // If true, close the stdin stream after writing any provided data.
+  // This signals EOF to the exec'd process.
+  bool eof = 5;
+}
+
+message TaskExecStdinWriteResponse { }
+
+message TaskExecStdioReadRequest {
+  // The ID of the task running the exec'd command.
+  string task_id = 1;
+  // The execution ID of the command to read from.
+  string exec_id = 2;
+  // The offset to start reading from. This is used to resume reading from the
+  // last read position if the connection is closed and reopened.
+  uint64 offset = 3;
+  // Which file descriptor to read from.
+  TaskExecStdioFileDescriptor file_descriptor = 4;
+}
+
+message TaskExecStdioReadResponse {
+  // The data read from the file descriptor.
+  bytes data = 1;
+}
+
+message TaskExecWaitRequest {
+  // The ID of the task running the exec'd command.
+  string task_id = 1;
+  // The execution ID of the command to wait on. 
+  string exec_id = 2;
+}
+
+message TaskExecWaitResponse {
+  oneof exit_status {
+    // The exit code of the command.
+    int32 code = 1;
+    // The signal that terminated the command.
+    int32 signal = 2;
+  }
+  // TODO(saltzm): Give a way for the user to distinguish between normal exit
+  // and termination by Modal (due to task timeout, exec exceeded deadline, etc.)
+}
+
+service TaskCommandRouter {
+  // Poll for the exit status of an exec'd command.
+  rpc TaskExecPoll(TaskExecPollRequest) returns (TaskExecPollResponse);
+  // Execute a command in the task.
+  rpc TaskExecStart(TaskExecStartRequest) returns (TaskExecStartResponse);
+ // Write to the stdin stream of an exec'd command.
+  rpc TaskExecStdinWrite(TaskExecStdinWriteRequest) returns (TaskExecStdinWriteResponse);
+  // Get a stream of output from the stdout or stderr stream of an exec'd command.
+  rpc TaskExecStdioRead(TaskExecStdioReadRequest) returns (stream TaskExecStdioReadResponse);
+  // Wait for an exec'd command to exit and return the exit code.
+  rpc TaskExecWait(TaskExecWaitRequest) returns (TaskExecWaitResponse);
+}

modal_proto/task_command_router_grpc.py

@@ -0,0 +1,105 @@
+# Generated by the Protocol Buffers compiler. DO NOT EDIT!
+# source: modal_proto/task_command_router.proto
+# plugin: grpclib.plugin.main
+import abc
+import typing
+
+import grpclib.const
+import grpclib.client
+if typing.TYPE_CHECKING:
+    import grpclib.server
+
+import modal_proto.api_pb2
+import modal_proto.task_command_router_pb2
+
+
+class TaskCommandRouterBase(abc.ABC):
+
+    @abc.abstractmethod
+    async def TaskExecPoll(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecPollRequest, modal_proto.task_command_router_pb2.TaskExecPollResponse]') -> None:
+        pass
+
+    @abc.abstractmethod
+    async def TaskExecStart(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecStartRequest, modal_proto.task_command_router_pb2.TaskExecStartResponse]') -> None:
+        pass
+
+    @abc.abstractmethod
+    async def TaskExecStdinWrite(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecStdinWriteRequest, modal_proto.task_command_router_pb2.TaskExecStdinWriteResponse]') -> None:
+        pass
+
+    @abc.abstractmethod
+    async def TaskExecStdioRead(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecStdioReadRequest, modal_proto.task_command_router_pb2.TaskExecStdioReadResponse]') -> None:
+        pass
+
+    @abc.abstractmethod
+    async def TaskExecWait(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecWaitRequest, modal_proto.task_command_router_pb2.TaskExecWaitResponse]') -> None:
+        pass
+
+    def __mapping__(self) -> typing.Dict[str, grpclib.const.Handler]:
+        return {
+            '/modal.task_command_router.TaskCommandRouter/TaskExecPoll': grpclib.const.Handler(
+                self.TaskExecPoll,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskExecPollRequest,
+                modal_proto.task_command_router_pb2.TaskExecPollResponse,
+            ),
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStart': grpclib.const.Handler(
+                self.TaskExecStart,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskExecStartRequest,
+                modal_proto.task_command_router_pb2.TaskExecStartResponse,
+            ),
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStdinWrite': grpclib.const.Handler(
+                self.TaskExecStdinWrite,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskExecStdinWriteRequest,
+                modal_proto.task_command_router_pb2.TaskExecStdinWriteResponse,
+            ),
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStdioRead': grpclib.const.Handler(
+                self.TaskExecStdioRead,
+                grpclib.const.Cardinality.UNARY_STREAM,
+                modal_proto.task_command_router_pb2.TaskExecStdioReadRequest,
+                modal_proto.task_command_router_pb2.TaskExecStdioReadResponse,
+            ),
+            '/modal.task_command_router.TaskCommandRouter/TaskExecWait': grpclib.const.Handler(
+                self.TaskExecWait,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskExecWaitRequest,
+                modal_proto.task_command_router_pb2.TaskExecWaitResponse,
+            ),
+        }
+
+
+class TaskCommandRouterStub:
+
+    def __init__(self, channel: grpclib.client.Channel) -> None:
+        self.TaskExecPoll = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskExecPoll',
+            modal_proto.task_command_router_pb2.TaskExecPollRequest,
+            modal_proto.task_command_router_pb2.TaskExecPollResponse,
+        )
+        self.TaskExecStart = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStart',
+            modal_proto.task_command_router_pb2.TaskExecStartRequest,
+            modal_proto.task_command_router_pb2.TaskExecStartResponse,
+        )
+        self.TaskExecStdinWrite = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStdinWrite',
+            modal_proto.task_command_router_pb2.TaskExecStdinWriteRequest,
+            modal_proto.task_command_router_pb2.TaskExecStdinWriteResponse,
+        )
+        self.TaskExecStdioRead = grpclib.client.UnaryStreamMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskExecStdioRead',
+            modal_proto.task_command_router_pb2.TaskExecStdioReadRequest,
+            modal_proto.task_command_router_pb2.TaskExecStdioReadResponse,
+        )
+        self.TaskExecWait = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskExecWait',
+            modal_proto.task_command_router_pb2.TaskExecWaitRequest,
+            modal_proto.task_command_router_pb2.TaskExecWaitResponse,
+        )