modal 1.2.1.dev14__py3-none-any.whl → 1.2.1.dev16__py3-none-any.whl

modal/_utils/task_command_router_client.py

@@ -442,12 +442,10 @@ class TaskCommandRouterClient:
                 logger.debug(f"Cancelled JWT refresh loop for exec with task ID {self._task_id}")
                 break
             except Exception as e:
+                # Exceptions here can stem from non-transient errors against the server sending
+                # the TaskGetCommandRouterAccess RPC, for instance, if the task has finished.
                 logger.warning(f"Background JWT refresh failed for exec with task ID {self._task_id}: {e}")
-                try:
-                    await asyncio.sleep(1.0)
-                except Exception:
-                    # Ignore sleep issues; loop will re-check closed flag.
-                    pass
+                break
 
     async def _stream_stdio(
         self,

modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev14",
+        version: str = "1.2.1.dev16",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev14",
+        version: str = "1.2.1.dev16",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

modal/container_process.py

@@ -273,6 +273,9 @@ class _ContainerProcessThroughCommandRouter(Generic[T]):
         )
         self._returncode = None
 
+    def __repr__(self) -> str:
+        return f"ContainerProcess(process_id={self._process_id!r})"
+
     @property
     def stdout(self) -> _StreamReader[T]:
         return self._stdout
@@ -314,7 +317,10 @@ class _ContainerProcessThroughCommandRouter(Generic[T]):
                 raise InvalidError("Unexpected exit status")
         except ExecTimeoutError:
             logger.debug(f"ContainerProcess poll for {self._process_id} did not complete within deadline")
-            return None
+            # TODO(saltzm): This is a weird API, but customers currently may rely on it. This
+            # should probably raise an ExecTimeoutError instead.
+            self._returncode = -1
+            return self._returncode
         except Exception as e:
             # Re-raise non-transient errors or errors resulting from exceeding retries on transient errors.
             logger.warning(f"ContainerProcess poll for {self._process_id} failed: {e}")

modal/container_process.pyi

@@ -112,6 +112,10 @@ class _ContainerProcessThroughCommandRouter(typing.Generic[T]):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    def __repr__(self) -> str:
+        """Return repr(self)."""
+        ...
+
     @property
     def stdout(self) -> modal.io_streams._StreamReader[T]: ...
     @property

modal/experimental/flash.py

@@ -321,7 +321,7 @@ class _FlashPrometheusAutoscaler:
 
     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.
         """
         containers = await self._get_all_containers()
         if len(containers) > current_replicas:
@@ -334,7 +334,7 @@ class _FlashPrometheusAutoscaler:
         if current_replicas == 0:
             return 1
 
-        # Get metrics based on autoscaler type (prometheus or internal)
+        # Get metrics based on autoscaler type
         sum_metric, n_containers_with_metrics = await self._get_scaling_info(containers)
 
         desired_replicas = self._calculate_desired_replicas(
@@ -406,39 +406,26 @@ class _FlashPrometheusAutoscaler:
         return desired_replicas
 
     async def _get_scaling_info(self, containers) -> tuple[float, int]:
-        """Get metrics using either internal container metrics API or prometheus HTTP endpoints."""
-        if self.metrics_endpoint == "internal":
-            container_metrics_results = await asyncio.gather(
-                *[self._get_container_metrics(container.task_id) for container in containers]
-            )
-            container_metrics_list = []
-            for container_metric in container_metrics_results:
-                if container_metric is None:
-                    continue
-                container_metrics_list.append(getattr(container_metric.metrics, self.target_metric))
-
-            sum_metric = sum(container_metrics_list)
-            n_containers_with_metrics = len(container_metrics_list)
-        else:
-            sum_metric = 0
-            n_containers_with_metrics = 0
-
-            container_metrics_list = await asyncio.gather(
-                *[
-                    self._get_metrics(f"https://{container.host}:{container.port}/{self.metrics_endpoint}")
-                    for container in containers
-                ]
-            )
+        """Get metrics using container exposed metrics endpoints."""
+        sum_metric = 0
+        n_containers_with_metrics = 0
+
+        container_metrics_list = await asyncio.gather(
+            *[
+                self._get_metrics(f"https://{container.host}:{container.port}/{self.metrics_endpoint}")
+                for container in containers
+            ]
+        )
 
-            for container_metrics in container_metrics_list:
-                if (
-                    container_metrics is None
-                    or self.target_metric not in container_metrics
-                    or len(container_metrics[self.target_metric]) == 0
-                ):
-                    continue
-                sum_metric += container_metrics[self.target_metric][0].value
-                n_containers_with_metrics += 1
+        for container_metrics in container_metrics_list:
+            if (
+                container_metrics is None
+                or self.target_metric not in container_metrics
+                or len(container_metrics[self.target_metric]) == 0
+            ):
+                continue
+            sum_metric += container_metrics[self.target_metric][0].value
+            n_containers_with_metrics += 1
 
         return sum_metric, n_containers_with_metrics
 
@@ -474,15 +461,6 @@ class _FlashPrometheusAutoscaler:
 
         return metrics
 
-    async def _get_container_metrics(self, container_id: str) -> Optional[api_pb2.TaskGetAutoscalingMetricsResponse]:
-        req = api_pb2.TaskGetAutoscalingMetricsRequest(task_id=container_id)
-        try:
-            resp = await retry_transient_errors(self.client.stub.TaskGetAutoscalingMetrics, req)
-            return resp
-        except Exception as e:
-            logger.warning(f"[Modal Flash] Error getting metrics for container {container_id}: {e}")
-            return None
-
     async def _get_all_containers(self):
         req = api_pb2.FlashContainerListRequest(function_id=self.fn.object_id)
         resp = await retry_transient_errors(self.client.stub.FlashContainerList, req)
@@ -572,14 +550,10 @@ async def flash_prometheus_autoscaler(
     app_name: str,
     cls_name: str,
     # Endpoint to fetch metrics from. Must be in Prometheus format. Example: "/metrics"
-    # If metrics_endpoint is "internal", we will use containers' internal metrics to autoscale instead.
     metrics_endpoint: str,
     # Target metric to autoscale on. Example: "vllm:num_requests_running"
-    # If metrics_endpoint is "internal", target_metrics options are: [cpu_usage_percent, memory_usage_percent]
     target_metric: str,
     # Target metric value. Example: 25
-    # If metrics_endpoint is "internal", target_metric_value is a percentage value between 0.1 and 1.0 (inclusive),
-    # indicating container's usage of that metric.
     target_metric_value: float,
     min_containers: Optional[int] = None,
     max_containers: Optional[int] = None,

modal/experimental/flash.pyi

@@ -1,5 +1,4 @@
 import modal.client
-import modal_proto.api_pb2
 import subprocess
 import typing
 import typing_extensions
@@ -139,7 +138,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 +153,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(
@@ -226,11 +222,11 @@ class FlashPrometheusAutoscaler:
 
     class ___compute_target_containers_spec(typing_extensions.Protocol[SUPERSELF]):
         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]
@@ -248,11 +244,11 @@ class FlashPrometheusAutoscaler:
 
     class ___get_scaling_info_spec(typing_extensions.Protocol[SUPERSELF]):
         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]
@@ -263,16 +259,6 @@ class FlashPrometheusAutoscaler:
 
     _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]
-
     class ___get_all_containers_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /): ...
         async def aio(self, /): ...

modal/io_streams.py

@@ -553,7 +553,7 @@ class _StreamReader(Generic[T]):
                 # unimplemented for now.
                 if stream_type == StreamType.STDOUT:
                     raise NotImplementedError(
-                        "Currently only the PIPE stream type is supported when using exec "
+                        "Currently the STDOUT stream type is not supported when using exec "
                         "through a task command router, which is currently in beta."
                     )
                 params = _StreamReaderThroughCommandRouterParams(

modal/sandbox.py

@@ -3,6 +3,7 @@ import asyncio
 import json
 import os
 import time
+import uuid
 from collections.abc import AsyncGenerator, Collection, Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, AsyncIterator, Literal, Optional, Union, overload
@@ -20,7 +21,7 @@ from modal._tunnel import Tunnel
 from modal.cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
 from modal.mount import _Mount
 from modal.volume import _Volume
-from modal_proto import api_pb2
+from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 
 from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
@@ -30,6 +31,7 @@ from ._utils.deprecation import deprecation_warning
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes
 from ._utils.name_utils import is_valid_object_name
+from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
 from .container_process import _ContainerProcess
 from .exception import AlreadyExistsError, ExecutionError, InvalidError, SandboxTerminatedError, SandboxTimeoutError
@@ -121,9 +123,10 @@ class _Sandbox(_Object, type_prefix="sb"):
     _stdout: _StreamReader[str]
     _stderr: _StreamReader[str]
     _stdin: _StreamWriter
-    _task_id: Optional[str] = None
-    _tunnels: Optional[dict[int, Tunnel]] = None
-    _enable_snapshot: bool = False
+    _task_id: Optional[str]
+    _tunnels: Optional[dict[int, Tunnel]]
+    _enable_snapshot: bool
+    _command_router_client: Optional[TaskCommandRouterClient]
 
     @staticmethod
     def _default_pty_info() -> api_pb2.PTYInfo:
@@ -521,6 +524,10 @@ class _Sandbox(_Object, type_prefix="sb"):
         )
         self._stdin = StreamWriter(self.object_id, "sandbox", self._client)
         self._result = None
+        self._task_id = None
+        self._tunnels = None
+        self._enable_snapshot = False
+        self._command_router_client = None
 
     @staticmethod
     async def from_name(
@@ -730,6 +737,13 @@ class _Sandbox(_Object, type_prefix="sb"):
                 await asyncio.sleep(0.5)
         return self._task_id
 
+    async def _get_command_router_client(self, task_id: str) -> Optional[TaskCommandRouterClient]:
+        if self._command_router_client is None:
+            # Attempt to initialize a router client. Returns None if the new exec path not enabled
+            # for this sandbox.
+            self._command_router_client = await TaskCommandRouterClient.try_init(self._client, task_id)
+        return self._command_router_client
+
     @overload
     async def exec(
         self,
@@ -855,14 +869,49 @@ class _Sandbox(_Object, type_prefix="sb"):
         await TaskContext.gather(*secret_coros)
 
         task_id = await self._get_task_id()
+        kwargs = {
+            "task_id": task_id,
+            "pty_info": pty_info,
+            "stdout": stdout,
+            "stderr": stderr,
+            "timeout": timeout,
+            "workdir": workdir,
+            "secret_ids": [secret.object_id for secret in secrets],
+            "text": text,
+            "bufsize": bufsize,
+            "runtime_debug": config.get("function_runtime_debug"),
+        }
+        # NB: This must come after the task ID is set, since the sandbox must be
+        # scheduled before we can create a router client.
+        if (command_router_client := await self._get_command_router_client(task_id)) is not None:
+            kwargs["command_router_client"] = command_router_client
+            return await self._exec_through_command_router(*args, **kwargs)
+        else:
+            return await self._exec_through_server(*args, **kwargs)
+
+    async def _exec_through_server(
+        self,
+        *args: str,
+        task_id: str,
+        pty_info: Optional[api_pb2.PTYInfo] = None,
+        stdout: StreamType = StreamType.PIPE,
+        stderr: StreamType = StreamType.PIPE,
+        timeout: Optional[int] = None,
+        workdir: Optional[str] = None,
+        secret_ids: Optional[Collection[str]] = None,
+        text: bool = True,
+        bufsize: Literal[-1, 1] = -1,
+        runtime_debug: bool = False,
+    ) -> Union[_ContainerProcess[bytes], _ContainerProcess[str]]:
+        """Execute a command through the Modal server."""
         req = api_pb2.ContainerExecRequest(
             task_id=task_id,
             command=args,
             pty_info=pty_info,
-            runtime_debug=config.get("function_runtime_debug"),
+            runtime_debug=runtime_debug,
             timeout_secs=timeout or 0,
             workdir=workdir,
-            secret_ids=[secret.object_id for secret in secrets],
+            secret_ids=secret_ids,
         )
         resp = await retry_transient_errors(self._client.stub.ContainerExec, req)
         by_line = bufsize == 1
@@ -879,6 +928,75 @@ class _Sandbox(_Object, type_prefix="sb"):
             by_line=by_line,
         )
 
+    async def _exec_through_command_router(
+        self,
+        *args: str,
+        task_id: str,
+        command_router_client: TaskCommandRouterClient,
+        pty_info: Optional[api_pb2.PTYInfo] = None,
+        stdout: StreamType = StreamType.PIPE,
+        stderr: StreamType = StreamType.PIPE,
+        timeout: Optional[int] = None,
+        workdir: Optional[str] = None,
+        secret_ids: Optional[Collection[str]] = None,
+        text: bool = True,
+        bufsize: Literal[-1, 1] = -1,
+        runtime_debug: bool = False,
+    ) -> Union[_ContainerProcess[bytes], _ContainerProcess[str]]:
+        """Execute a command through a task command router running on the Modal worker."""
+
+        # Generate a random process ID to use as a combination of idempotency key/process identifier.
+        process_id = str(uuid.uuid4())
+        if stdout == StreamType.PIPE:
+            stdout_config = sr_pb2.TaskExecStdoutConfig.TASK_EXEC_STDOUT_CONFIG_PIPE
+        elif stdout == StreamType.DEVNULL:
+            stdout_config = sr_pb2.TaskExecStdoutConfig.TASK_EXEC_STDOUT_CONFIG_DEVNULL
+        elif stdout == StreamType.STDOUT:
+            # TODO(saltzm): This is a behavior change from the old implementation. We should
+            # probably implement the old behavior of printing to stdout before moving out of beta.
+            raise NotImplementedError(
+                "Currently the STDOUT stream type is not supported when using exec "
+                "through a task command router, which is currently in beta."
+            )
+        else:
+            raise ValueError("Unsupported StreamType for stdout")
+
+        if stderr == StreamType.PIPE:
+            stderr_config = sr_pb2.TaskExecStderrConfig.TASK_EXEC_STDERR_CONFIG_PIPE
+        elif stderr == StreamType.DEVNULL:
+            stderr_config = sr_pb2.TaskExecStderrConfig.TASK_EXEC_STDERR_CONFIG_DEVNULL
+        elif stderr == StreamType.STDOUT:
+            stderr_config = sr_pb2.TaskExecStderrConfig.TASK_EXEC_STDERR_CONFIG_STDOUT
+        else:
+            raise ValueError("Unsupported StreamType for stderr")
+
+        # Start the process.
+        start_req = sr_pb2.TaskExecStartRequest(
+            task_id=task_id,
+            exec_id=process_id,
+            command_args=args,
+            stdout_config=stdout_config,
+            stderr_config=stderr_config,
+            timeout_secs=timeout,
+            workdir=workdir,
+            secret_ids=secret_ids,
+            pty_info=pty_info,
+            runtime_debug=runtime_debug,
+        )
+        _ = await command_router_client.exec_start(start_req)
+
+        return _ContainerProcess(
+            process_id,
+            task_id,
+            self._client,
+            command_router_client=command_router_client,
+            stdout=stdout,
+            stderr=stderr,
+            text=text,
+            by_line=bufsize == 1,
+            exec_deadline=time.monotonic() + int(timeout) if timeout else None,
+        )
+
     async def _experimental_snapshot(self) -> _SandboxSnapshot:
         await self._get_task_id()
         snap_req = api_pb2.SandboxSnapshotRequest(sandbox_id=self.object_id)

modal/sandbox.pyi

@@ -3,6 +3,7 @@ import collections.abc
 import google.protobuf.message
 import modal._object
 import modal._tunnel
+import modal._utils.task_command_router_client
 import modal.app
 import modal.client
 import modal.cloud_bucket_mount
@@ -83,6 +84,7 @@ class _Sandbox(modal._object._Object):
     _task_id: typing.Optional[str]
     _tunnels: typing.Optional[dict[int, modal._tunnel.Tunnel]]
     _enable_snapshot: bool
+    _command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]
 
     @staticmethod
     def _default_pty_info() -> modal_proto.api_pb2.PTYInfo: ...
@@ -305,6 +307,9 @@ class _Sandbox(modal._object._Object):
         ...
 
     async def _get_task_id(self) -> str: ...
+    async def _get_command_router_client(
+        self, task_id: str
+    ) -> typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]: ...
     @typing.overload
     async def exec(
         self,
@@ -356,6 +361,41 @@ class _Sandbox(modal._object._Object):
         """
         ...
 
+    async def _exec_through_server(
+        self,
+        *args: str,
+        task_id: str,
+        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        timeout: typing.Optional[int] = None,
+        workdir: typing.Optional[str] = None,
+        secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+        text: bool = True,
+        bufsize: typing.Literal[-1, 1] = -1,
+        runtime_debug: bool = False,
+    ) -> typing.Union[modal.container_process._ContainerProcess[bytes], modal.container_process._ContainerProcess[str]]:
+        """Execute a command through the Modal server."""
+        ...
+
+    async def _exec_through_command_router(
+        self,
+        *args: str,
+        task_id: str,
+        command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
+        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        timeout: typing.Optional[int] = None,
+        workdir: typing.Optional[str] = None,
+        secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+        text: bool = True,
+        bufsize: typing.Literal[-1, 1] = -1,
+        runtime_debug: bool = False,
+    ) -> typing.Union[modal.container_process._ContainerProcess[bytes], modal.container_process._ContainerProcess[str]]:
+        """Execute a command through a task command router running on the Modal worker."""
+        ...
+
     async def _experimental_snapshot(self) -> modal.snapshot._SandboxSnapshot: ...
     @staticmethod
     async def _experimental_from_snapshot(
@@ -444,6 +484,7 @@ class Sandbox(modal.object.Object):
     _task_id: typing.Optional[str]
     _tunnels: typing.Optional[dict[int, modal._tunnel.Tunnel]]
     _enable_snapshot: bool
+    _command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
@@ -907,6 +948,16 @@ class Sandbox(modal.object.Object):
 
     _get_task_id: ___get_task_id_spec[typing_extensions.Self]
 
+    class ___get_command_router_client_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, task_id: str
+        ) -> typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]: ...
+        async def aio(
+            self, /, task_id: str
+        ) -> typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]: ...
+
+    _get_command_router_client: ___get_command_router_client_spec[typing_extensions.Self]
+
     class __exec_spec(typing_extensions.Protocol[SUPERSELF]):
         @typing.overload
         def __call__(
@@ -1026,6 +1077,94 @@ class Sandbox(modal.object.Object):
 
     _exec: ___exec_spec[typing_extensions.Self]
 
+    class ___exec_through_server_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self,
+            /,
+            *args: str,
+            task_id: str,
+            pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+            stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            timeout: typing.Optional[int] = None,
+            workdir: typing.Optional[str] = None,
+            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+            text: bool = True,
+            bufsize: typing.Literal[-1, 1] = -1,
+            runtime_debug: bool = False,
+        ) -> typing.Union[
+            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
+        ]:
+            """Execute a command through the Modal server."""
+            ...
+
+        async def aio(
+            self,
+            /,
+            *args: str,
+            task_id: str,
+            pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+            stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            timeout: typing.Optional[int] = None,
+            workdir: typing.Optional[str] = None,
+            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+            text: bool = True,
+            bufsize: typing.Literal[-1, 1] = -1,
+            runtime_debug: bool = False,
+        ) -> typing.Union[
+            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
+        ]:
+            """Execute a command through the Modal server."""
+            ...
+
+    _exec_through_server: ___exec_through_server_spec[typing_extensions.Self]
+
+    class ___exec_through_command_router_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self,
+            /,
+            *args: str,
+            task_id: str,
+            command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
+            pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+            stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            timeout: typing.Optional[int] = None,
+            workdir: typing.Optional[str] = None,
+            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+            text: bool = True,
+            bufsize: typing.Literal[-1, 1] = -1,
+            runtime_debug: bool = False,
+        ) -> typing.Union[
+            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
+        ]:
+            """Execute a command through a task command router running on the Modal worker."""
+            ...
+
+        async def aio(
+            self,
+            /,
+            *args: str,
+            task_id: str,
+            command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
+            pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
+            stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+            timeout: typing.Optional[int] = None,
+            workdir: typing.Optional[str] = None,
+            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
+            text: bool = True,
+            bufsize: typing.Literal[-1, 1] = -1,
+            runtime_debug: bool = False,
+        ) -> typing.Union[
+            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
+        ]:
+            """Execute a command through a task command router running on the Modal worker."""
+            ...
+
+    _exec_through_command_router: ___exec_through_command_router_spec[typing_extensions.Self]
+
     class ___experimental_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /) -> modal.snapshot.SandboxSnapshot: ...
         async def aio(self, /) -> modal.snapshot.SandboxSnapshot: ...

{modal-1.2.1.dev14.dist-info → modal-1.2.1.dev16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.1.dev14
+Version: 1.2.1.dev16
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0