modal 1.2.1.dev8__py3-none-any.whl → 1.2.2.dev19__py3-none-any.whl

modal/experimental/__init__.py

@@ -13,7 +13,6 @@ from .._object import _get_environment_name
 from .._partial_function import _clustered
 from .._runtime.container_io_manager import _ContainerIOManager
 from .._utils.async_utils import synchronize_api, synchronizer
-from .._utils.grpc_utils import retry_transient_errors
 from ..app import _App
 from ..client import _Client
 from ..cls import _Cls
@@ -116,7 +115,7 @@ async def get_app_objects(
 
     app = await _App.lookup(app_name, environment_name=environment_name, client=client)
     req = api_pb2.AppGetLayoutRequest(app_id=app.app_id)
-    app_layout_resp = await retry_transient_errors(client.stub.AppGetLayout, req)
+    app_layout_resp = await client.stub.AppGetLayout(req)
 
     app_objects: dict[str, Union[_Function, _Cls]] = {}
 
@@ -361,4 +360,4 @@ async def image_delete(
         client = await _Client.from_env()
 
     req = api_pb2.ImageDeleteRequest(image_id=image_id)
-    await retry_transient_errors(client.stub.ImageDelete, req)
+    await client.stub.ImageDelete(req)

modal/experimental/flash.py

@@ -16,7 +16,6 @@ from modal_proto import api_pb2
 
 from .._tunnel import _forward as _forward_tunnel
 from .._utils.async_utils import synchronize_api, synchronizer
-from .._utils.grpc_utils import retry_transient_errors
 from ..client import _Client
 from ..config import logger
 from ..exception import InvalidError
@@ -126,10 +125,8 @@ class _FlashManager:
                         f"due to error: {port_check_error}, num_failures: {self.num_failures}"
                     )
                     self.num_failures += 1
-                    await retry_transient_errors(
-                        self.client.stub.FlashContainerDeregister,
-                        api_pb2.FlashContainerDeregisterRequest(),
-                    )
+                    await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
+
             except asyncio.CancelledError:
                 logger.warning("[Modal Flash] Shutting down...")
                 break
@@ -148,8 +145,7 @@ class _FlashManager:
 
     async def stop(self):
         self.heartbeat_task.cancel()
-        await retry_transient_errors(
-            self.client.stub.FlashContainerDeregister,
+        await self.client.stub.FlashContainerDeregister(
             api_pb2.FlashContainerDeregisterRequest(),
         )
 
@@ -321,7 +317,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 +330,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 +402,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,23 +457,14 @@ 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)
+        resp = await self.client.stub.FlashContainerList(req)
         return resp.containers
 
     async def _set_target_slots(self, target_slots: int):
         req = api_pb2.FlashSetTargetSlotsMetricsRequest(function_id=self.fn.object_id, target_slots=target_slots)
-        await retry_transient_errors(self.client.stub.FlashSetTargetSlotsMetrics, req)
+        await self.client.stub.FlashSetTargetSlotsMetrics(req)
         return
 
     def _make_scaling_decision(
@@ -572,14 +546,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,
@@ -645,5 +615,5 @@ async def flash_get_containers(app_name: str, cls_name: str) -> list[dict[str, A
     assert fn is not None
     await fn.hydrate(client=client)
     req = api_pb2.FlashContainerListRequest(function_id=fn.object_id)
-    resp = await retry_transient_errors(client.stub.FlashContainerList, req)
+    resp = await client.stub.FlashContainerList(req)
     return resp.containers

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/file_io.py

@@ -13,7 +13,6 @@ 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.exception import ClientClosed
 from modal_proto import api_pb2
 
@@ -57,8 +56,7 @@ 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 retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_delete_bytes_request=api_pb2.ContainerFileDeleteBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -85,8 +83,7 @@ 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 retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_write_replace_bytes_request=api_pb2.ContainerFileWriteReplaceBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -261,8 +258,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 +281,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 +304,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 +345,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 +360,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 +385,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 +401,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 +417,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 +429,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 +448,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,
@@ -503,8 +490,7 @@ class _FileIO(Generic[T]):
 
     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/functions.pyi

@@ -401,7 +401,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -410,7 +410,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -437,7 +437,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -461,7 +461,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
+        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -470,7 +470,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -491,7 +491,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

modal/image.py

@@ -38,7 +38,8 @@ from ._utils.docker_utils import (
     find_dockerignore_file,
 )
 from ._utils.function_utils import FunctionInfo
-from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
+from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
+from ._utils.mount_utils import validate_only_modal_volumes
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
@@ -487,6 +488,7 @@ class _Image(_Object, type_prefix="im"):
         context_mount_function: Optional[Callable[[], Optional[_Mount]]] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: Optional[Sequence[tuple[str, _Volume]]] = None,
         # For internal use only.
         _namespace: "api_pb2.DeploymentNamespace.ValueType" = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         _do_assert_no_mount_layers: bool = True,
@@ -494,6 +496,9 @@ class _Image(_Object, type_prefix="im"):
         if base_images is None:
             base_images = {}
 
+        if validated_volumes is None:
+            validated_volumes = []
+
         if secrets is None:
             secrets = []
         if gpu_config is None:
@@ -514,6 +519,8 @@ class _Image(_Object, type_prefix="im"):
                 deps += (build_function,)
             if image_registry_config and image_registry_config.secret:
                 deps += (image_registry_config.secret,)
+            for _, vol in validated_volumes:
+                deps += (vol,)
             return deps
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
@@ -592,6 +599,17 @@ class _Image(_Object, type_prefix="im"):
                 build_function_id = ""
                 _build_function = None
 
+            # Relies on dicts being ordered (true as of Python 3.6).
+            volume_mounts = [
+                api_pb2.VolumeMount(
+                    mount_path=path,
+                    volume_id=volume.object_id,
+                    allow_background_commits=True,
+                    read_only=volume._read_only,
+                )
+                for path, volume in validated_volumes
+            ]
+
             image_definition = api_pb2.Image(
                 base_images=base_images_pb2s,
                 dockerfile_commands=dockerfile.commands,
@@ -604,6 +622,7 @@ class _Image(_Object, type_prefix="im"):
                 runtime_debug=config.get("function_runtime_debug"),
                 build_function=_build_function,
                 build_args=build_args,
+                volume_mounts=volume_mounts,
             )
 
             req = api_pb2.ImageGetOrCreateRequest(
@@ -619,7 +638,7 @@ class _Image(_Object, type_prefix="im"):
                 allow_global_deployment=os.environ.get("MODAL_IMAGE_ALLOW_GLOBAL_DEPLOYMENT") == "1",
                 ignore_cache=config.get("ignore_cache"),
             )
-            resp = await retry_transient_errors(resolver.client.stub.ImageGetOrCreate, req)
+            resp = await resolver.client.stub.ImageGetOrCreate(req)
             image_id = resp.image_id
             result: api_pb2.GenericResult
             metadata: Optional[api_pb2.ImageMetadata] = None
@@ -848,7 +867,7 @@ class _Image(_Object, type_prefix="im"):
             client = await _Client.from_env()
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
-            resp = await retry_transient_errors(client.stub.ImageFromId, api_pb2.ImageFromIdRequest(image_id=image_id))
+            resp = await client.stub.ImageFromId(api_pb2.ImageFromIdRequest(image_id=image_id))
             self._hydrate(resp.image_id, resolver.client, resp.metadata)
 
         rep = f"Image.from_id({image_id!r})"
@@ -1690,6 +1709,7 @@ class _Image(_Object, type_prefix="im"):
         *commands: Union[str, list[str]],
         env: Optional[dict[str, Optional[str]]] = None,
         secrets: Optional[Collection[_Secret]] = None,
+        volumes: Optional[dict[Union[str, PurePosixPath], _Volume]] = None,
         gpu: GPU_T = None,
         force_build: bool = False,  # Ignore cached builds, similar to 'docker build --no-cache'
     ) -> "_Image":
@@ -1712,6 +1732,7 @@ class _Image(_Object, type_prefix="im"):
             secrets=secrets,
             gpu_config=parse_gpu_config(gpu),
             force_build=self.force_build or force_build,
+            validated_volumes=validate_only_modal_volumes(volumes, "Image.run_commands"),
         )
 
     @staticmethod

modal/image.pyi

@@ -176,6 +176,7 @@ class _Image(modal._object._Object):
         ] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: typing.Optional[collections.abc.Sequence[tuple[str, modal.volume._Volume]]] = None,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
@@ -668,6 +669,7 @@ class _Image(modal._object._Object):
         *commands: typing.Union[str, list[str]],
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
+        volumes: typing.Optional[dict[typing.Union[str, pathlib.PurePosixPath], modal.volume._Volume]] = None,
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         force_build: bool = False,
     ) -> _Image:
@@ -1091,6 +1093,7 @@ class Image(modal.object.Object):
         ] = None,
         force_build: bool = False,
         build_args: dict[str, str] = {},
+        validated_volumes: typing.Optional[collections.abc.Sequence[tuple[str, modal.volume.Volume]]] = None,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
@@ -1648,6 +1651,7 @@ class Image(modal.object.Object):
         *commands: typing.Union[str, list[str]],
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
+        volumes: typing.Optional[dict[typing.Union[str, pathlib.PurePosixPath], modal.volume.Volume]] = None,
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         force_build: bool = False,
     ) -> Image: