modal 1.4.3.dev29__tar.gz → 1.4.4.dev0__tar.gz

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.3.dev29
+Version: 1.4.4.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/_function_variants.py

@@ -18,7 +18,7 @@ from ._utils.mount_utils import validate_volumes, validate_volumes_by_object_id
 from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
 from .retries import Retries
 from .secret import _Secret
-from .volume import _Volume
+from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
     from ._functions import _Function
@@ -162,15 +162,7 @@ class _FunctionOptions:
         # Needs to be called late so that volumes are hydrated
         validate_volumes_by_object_id(self.validated_volumes)
 
-        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 self.validated_volumes
-        ]
+        volume_mounts = [_volume_to_mount_proto(path, volume) for path, volume in self.validated_volumes]
         return api_pb2.FunctionOptions(
             secret_ids=[secret.object_id for secret in self.secrets],
             replace_secret_ids=bool(self.secrets),

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/_functions.py

@@ -89,7 +89,7 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
-from .volume import _Volume
+from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
     import modal.app
@@ -667,6 +667,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_wait_ms: Optional[int] = None,
         cloud: Optional[str] = None,
         region: Optional[Union[str, Sequence[str]]] = None,
+        routing_region: Optional[str] = None,
         nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
@@ -946,13 +947,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
                 # 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_no_cloud_buckets
+                    _volume_to_mount_proto(path, volume) for path, volume in validated_volumes_no_cloud_buckets
                 ]
                 loaded_mount_ids = {m.object_id for m in all_mounts} | {m.object_id for m in image._mount_layers}
 
@@ -1033,6 +1028,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     supported_output_formats=supported_output_formats,
                     http_config=http_config,
                     is_server=is_server,
+                    routing_region=routing_region or "",
                 )
 
                 if isinstance(gpu, list):
@@ -1072,6 +1068,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         supported_output_formats=supported_output_formats,
                         http_config=http_config,
                         is_server=function_definition.is_server,
+                        routing_region=function_definition.routing_region,
                     )
 
                     ranked_functions = []

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/_grpc_client.py

@@ -44,10 +44,6 @@ _STATUS_TO_EXCEPTION: dict[Status, type[exception._GRPCErrorWrapper]] = {
 
 
 class grpc_error_converter:
-    def __init__(self, *, expect_timeouts: bool = False):
-        """expect_timeouts: if this is set we convert cancelled/deadline_exceeded statuses to exception.TimeoutError"""
-        self._expect_timeouts = expect_timeouts
-
     def __enter__(self):
         pass
 
@@ -56,9 +52,6 @@ class grpc_error_converter:
         use_full_traceback = config.get("traceback")
         with suppress_tb_frame():
             if isinstance(exc, GRPCError):
-                if self._expect_timeouts and exc.status in (Status.CANCELLED, Status.DEADLINE_EXCEEDED):
-                    raise exception.TimeoutError("Timeout expired")
-
                 modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
                 modal_exc._grpc_message = exc.message
                 modal_exc._grpc_status = exc.status

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/_utils/mount_utils.py

@@ -68,7 +68,7 @@ def validate_volumes(
     for path, volume in validated_volumes:
         if not isinstance(volume, (_Volume, _CloudBucketMount)):
             raise InvalidError(f"Object of type {type(volume)} mounted at '{path}' is not usable as a volume.")
-        elif isinstance(volume, (_Volume)):
+        elif isinstance(volume, _Volume):
             volume_to_paths.setdefault(volume, []).append(path)
     for paths in volume_to_paths.values():
         if len(paths) > 1:

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/_utils/task_command_router_client.py

@@ -74,7 +74,7 @@ async def call_with_retries_on_transient_errors(
     delay_factor: float = 2,
     max_retries: Optional[int] = 10,
     exclude_status_codes: Optional[list[Status]] = None,
-    expect_timeouts: bool = False,  # when True we convert TimeoutError to exception.TimeoutError and don't retry"""
+    timeout_deadline: Optional[float] = None,
 ):
     """Call func() with transient error retries and exponential backoff.
 
@@ -84,6 +84,13 @@ async def call_with_retries_on_transient_errors(
         exclude_status_codes: gRPC status codes to exclude from retry logic even if
             they are in RETRYABLE_GRPC_STATUS_CODES. Use this to let certain errors
             (e.g. DEADLINE_EXCEEDED) propagate immediately rather than being retried.
+        timeout_deadline: Optional monotonic deadline (`time.monotonic()` value).
+            When set, retries are not attempted once the deadline is reached and
+            the backoff sleep is clamped so we don't sleep past it. It's up to
+            the caller to decide whether to further translate the surfaced
+            exception (e.g., into a TimeoutError) based on the deadline check.
+            The caller is also responsible for propagating the remaining budget
+            into `func()` (typically as the per-call gRPC timeout).
     """
     delay_secs = base_delay_secs
     num_retries = 0
@@ -92,10 +99,22 @@ async def call_with_retries_on_transient_errors(
     def is_retryable_status(status: Status) -> bool:
         return status in RETRYABLE_GRPC_STATUS_CODES and status not in exclude_status_codes
 
-    async def sleep_and_update_delay_and_num_retries_remaining(e: Exception):
+    def can_retry() -> bool:
+        if max_retries is not None and num_retries >= max_retries:
+            return False
+        if timeout_deadline is not None and time.monotonic() >= timeout_deadline:
+            return False
+        return True
+
+    async def sleep_and_advance(e: Exception):
         nonlocal delay_secs, num_retries
-        logger.debug(f"Retrying RPC with delay {delay_secs}s due to error: {e}")
-        await asyncio.sleep(delay_secs)
+        # Clamp the backoff sleep to the remaining deadline so we don't sleep
+        # past it just to fail on the next iteration's deadline check.
+        sleep_for = delay_secs
+        if timeout_deadline is not None:
+            sleep_for = min(sleep_for, max(0.0, timeout_deadline - time.monotonic()))
+        logger.debug(f"Retrying RPC with delay {sleep_for}s due to error: {e}")
+        await asyncio.sleep(sleep_for)
         delay_secs *= delay_factor
         num_retries += 1
 
@@ -103,37 +122,28 @@ async def call_with_retries_on_transient_errors(
         try:
             return await func()
         except GRPCError as e:
-            if (max_retries is None or num_retries < max_retries) and is_retryable_status(e.status):
-                await sleep_and_update_delay_and_num_retries_remaining(e)
-            else:
-                raise e
+            if not is_retryable_status(e.status) or not can_retry():
+                raise
+            await sleep_and_advance(e)
         except AttributeError as e:
             # StreamTerminatedError are not properly raised in grpclib<=0.4.7
             # fixed in https://github.com/vmagamedov/grpclib/issues/185
             # TODO: update to newer version (>=0.4.8) once stable
-            if (max_retries is None or num_retries < max_retries) and "_write_appdata" in str(e):
-                await sleep_and_update_delay_and_num_retries_remaining(e)
-            else:
-                raise e
+            if "_write_appdata" not in str(e) or not can_retry():
+                raise
+            await sleep_and_advance(e)
         except StreamTerminatedError as e:
-            if max_retries is None or num_retries < max_retries:
-                await sleep_and_update_delay_and_num_retries_remaining(e)
-            else:
-                raise e
-        except asyncio.TimeoutError as e:
-            if expect_timeouts:
-                # grpclib raises TimeoutError for the client-side timeout/deadlines
-                raise ModalTimeoutError("Timeout expired")
-
-            if max_retries is None or num_retries < max_retries:
-                await sleep_and_update_delay_and_num_retries_remaining(e)
-            else:
-                raise ConnectionError(str(e))
-        except OSError as e:
-            if max_retries is None or num_retries < max_retries:
-                await sleep_and_update_delay_and_num_retries_remaining(e)
-            else:
+            if not can_retry():
+                raise
+            await sleep_and_advance(e)
+        except (asyncio.TimeoutError, OSError) as e:
+            if not can_retry():
+                # Client-side timeout / network OSError surfaces as a generic
+                # ConnectionError once we stop retrying. Callers that pass
+                # `timeout_deadline` can further translate this based on
+                # whether the deadline has elapsed.
                 raise ConnectionError(str(e))
+            await sleep_and_advance(e)
 
 
 async def fetch_command_router_access(server_client, task_id: str) -> api_pb2.TaskGetCommandRouterAccessResponse:
@@ -656,20 +666,34 @@ class TaskCommandRouterClient:
             )
 
     async def snapshot_filesystem(
-        self, request: sr_pb2.TaskSnapshotFilesystemRequest, *, timeout: Optional[int] = None, **kwargs
+        self, request: sr_pb2.TaskSnapshotFilesystemRequest, *, timeout: float, **kwargs
     ) -> sr_pb2.TaskSnapshotFilesystemResponse:
-        expect_timeouts = timeout is not None
-        with grpc_error_converter(expect_timeouts=expect_timeouts):
-            # note: TaskSnapshotFilesystem has a timeout concept with multiple variants:
-            # * Normally it would time out on the client side inside of grpclib - this causes an asyncio.TimeoutError
-            # * It also propagates the timeout to the server however, which could potentially trigger, in particular
-            #   if an in-progress requests is idempotently rejoined as a retry. These errors appear to be propagated
-            #   as Status.CANCELLED at the time of writing this, but we may change the backend to return
-            #   DEADLINE_EXCEEDED in the future, so we want to make the code compatible with both here:
-            return await call_with_retries_on_transient_errors(
-                lambda: self._call_with_auth_retry(
-                    self._stub.TaskSnapshotFilesystem, request, timeout=timeout, **kwargs
-                ),
-                exclude_status_codes=[Status.DEADLINE_EXCEEDED, Status.CANCELLED],
-                expect_timeouts=expect_timeouts,  # client wanted a timeout - raise as such immediately
+        # Compute the overall deadline once; each retry attempt passes the
+        # remaining budget as the per-call gRPC timeout so we honor the
+        # caller-specified `timeout` across retries instead of giving each
+        # attempt a fresh full window.
+        timeout_deadline = time.monotonic() + timeout
+
+        def call():
+            call_timeout = timeout_deadline - time.monotonic()
+            if call_timeout <= 0.0:
+                # doesn't matter which exception type this is
+                # as it will be caught by the catch all below
+                raise ModalTimeoutError("Timeout expired")
+
+            return self._call_with_auth_retry(
+                self._stub.TaskSnapshotFilesystem, request, timeout=call_timeout, **kwargs
             )
+
+        # Any failure observed at or after the deadline is treated as a timeout
+        try:
+            with grpc_error_converter():
+                return await call_with_retries_on_transient_errors(
+                    call,
+                    exclude_status_codes=[Status.DEADLINE_EXCEEDED, Status.CANCELLED],
+                    timeout_deadline=timeout_deadline,
+                )
+        except Exception:
+            if time.monotonic() >= timeout_deadline:
+                raise ModalTimeoutError("Timeout expired")
+            raise

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/app.py

@@ -743,6 +743,7 @@ class _App:
         ] = None,  # Set this to True if it's a non-generator function returning a [sync/async] generator object
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
+        routing_region: Optional[str] = None,  # Region to route inputs to the function through.
         nonpreemptible: bool = False,  # Whether to run the function on a nonpreemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
@@ -902,6 +903,7 @@ class _App:
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
                 region=region,
+                routing_region=routing_region,
                 nonpreemptible=nonpreemptible,
                 webhook_config=webhook_config,
                 enable_memory_snapshot=enable_memory_snapshot,
@@ -957,6 +959,7 @@ class _App:
         startup_timeout: Optional[int] = None,  # Maximum startup time in seconds with higher precedence than `timeout`.
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
+        routing_region: Optional[str] = None,  # Region to route inputs to the function through.
         nonpreemptible: bool = False,  # Whether to run the function on a non-preemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
@@ -1100,6 +1103,7 @@ class _App:
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
                 region=region,
+                routing_region=routing_region,
                 nonpreemptible=nonpreemptible,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/app.pyi

@@ -490,6 +490,7 @@ class _App:
         is_generator: typing.Optional[bool] = None,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
+        routing_region: typing.Optional[str] = None,
         nonpreemptible: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
@@ -537,6 +538,7 @@ class _App:
         startup_timeout: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
+        routing_region: typing.Optional[str] = None,
         nonpreemptible: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
@@ -1208,6 +1210,7 @@ class App:
         is_generator: typing.Optional[bool] = None,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
+        routing_region: typing.Optional[str] = None,
         nonpreemptible: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
@@ -1255,6 +1258,7 @@ class App:
         startup_timeout: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
+        routing_region: typing.Optional[str] = None,
         nonpreemptible: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/cli/shell.py

@@ -58,6 +58,23 @@ def _passed_forbidden_args(
     return passed_forbidden
 
 
+def _parse_experimental_options(options: Iterable[str]) -> dict[str, bool]:
+    parsed: dict[str, bool] = {}
+    for option in options:
+        key, sep, raw_value = option.partition("=")
+        if not key or not sep:
+            raise click.BadParameter("must use KEY=VALUE")
+
+        value = raw_value.lower()
+        if value in {"1", "true"}:
+            parsed[key] = True
+        elif value in {"0", "false"}:
+            parsed[key] = False
+        else:
+            raise click.BadParameter("BOOL must be one of true, false, 1, or 0")
+    return parsed
+
+
 def _is_valid_modal_id(ref: str, prefix: str) -> bool:
     assert prefix.endswith("-")
     return ref.startswith(prefix) and len(ref[len(prefix) :]) > 0 and ref[len(prefix) :].isalnum()
@@ -180,6 +197,7 @@ def _start_shell_from_function_spec(
     timeout: int,
     function_spec: _FunctionSpec,
     pty: bool,
+    experimental_options: dict[str, bool],
 ) -> None:
     interactive_shell(
         app,
@@ -198,6 +216,7 @@ def _start_shell_from_function_spec(
         region=function_spec.scheduler_placement.regions if function_spec.scheduler_placement else None,
         pty=pty,
         proxy=function_spec.proxy,
+        experimental_options=experimental_options,
     )
 
 
@@ -216,6 +235,7 @@ def _start_shell_from_image(
     cloud: Optional[str],
     region: Optional[str],
     pty: bool,
+    experimental_options: dict[str, bool],
 ) -> None:
     volumes = {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
     secrets = [Secret.from_name(s) for s in secret]
@@ -246,6 +266,7 @@ def _start_shell_from_image(
         secrets=secrets,
         region=region.split(",") if region else [],
         pty=pty,
+        experimental_options=experimental_options,
     )
 
 
@@ -298,6 +319,14 @@ def _start_shell_from_image(
     default=False,
     help="Interpret argument as a Python module path instead of a file/script path",
 )
+@click.option(
+    "--experimental-option",
+    "experimental_options",
+    multiple=True,
+    default=(),
+    hidden=True,
+    metavar="KEY=VALUE",
+)
 def shell(
     ref: Optional[str] = None,
     cmd: str = "/bin/bash",
@@ -314,6 +343,7 @@ def shell(
     region: Optional[str] = None,
     pty: Optional[bool] = None,
     use_module_mode: bool = False,
+    experimental_options: tuple[str, ...] = (),
 ):
     """Run a command or interactive shell inside a Modal container.
 
@@ -384,12 +414,16 @@ def shell(
     # NB: invoking under bash makes --cmd a lot more flexible.
     cmds = shlex.split(f'/bin/bash -c "{cmd}"')
     timeout = 3600
+    parsed_experimental_options = _parse_experimental_options(experimental_options)
 
     if ref is not None and not _is_valid_modal_id(ref, "im-"):
         # If ref it not a Modal Image ID, then it's a function reference, and we'll start a new container from its spec.
         ctx = click.get_current_context()
         if passed_forbidden := _passed_forbidden_args(
-            shell.params, ctx, locals(), allowed=lambda p: p in {"cmd", "env", "pty", "ref", "use_module_mode"}
+            shell.params,
+            ctx,
+            locals(),
+            allowed=lambda p: p in {"cmd", "env", "pty", "ref", "use_module_mode", "experimental_options"},
         ):
             raise ClickException(
                 f"Cannot specify container configuration arguments ({', '.join(passed_forbidden)}) "
@@ -397,7 +431,7 @@ def shell(
             )
 
         function_spec = _function_spec_from_ref(ref, use_module_mode)
-        _start_shell_from_function_spec(app, cmds, env, timeout, function_spec, pty)
+        _start_shell_from_function_spec(app, cmds, env, timeout, function_spec, pty, parsed_experimental_options)
         return
 
     if ref is not None and _is_valid_modal_id(ref, "im-"):
@@ -428,4 +462,5 @@ def shell(
         cloud,
         region,
         pty,
+        parsed_experimental_options,
     )

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.3.dev29",
+        version: str = "1.4.4.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -175,7 +175,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.3.dev29",
+        version: str = "1.4.4.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/functions.pyi

@@ -97,6 +97,7 @@ class Function(
         batch_wait_ms: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
+        routing_region: typing.Optional[str] = None,
         nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
@@ -420,7 +421,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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."""
             ...
@@ -429,7 +430,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -456,7 +457,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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.
 
@@ -479,7 +480,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -487,7 +488,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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.
 
@@ -508,7 +509,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/image.py

@@ -59,7 +59,7 @@ from .mount import _Mount, python_standalone_mount_name
 from .network_file_system import _NetworkFileSystem
 from .output import OutputManager
 from .secret import _Secret
-from .volume import _Volume
+from .volume import _Volume, _volume_to_mount_proto
 
 if typing.TYPE_CHECKING:
     import modal._functions
@@ -631,15 +631,7 @@ class _Image(_Object, type_prefix="im"):
             validate_volumes_by_object_id(validated_volumes)
 
             # 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
-            ]
+            volume_mounts = [_volume_to_mount_proto(path, volume) for path, volume in validated_volumes]
 
             image_definition = api_pb2.Image(
                 base_images=base_images_pb2s,

{modal-1.4.3.dev29 → modal-1.4.4.dev0}/modal/sandbox.py

@@ -21,7 +21,7 @@ from google.protobuf.message import Message
 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.volume import _Volume, _volume_to_mount_proto
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 
 from ._load_context import LoadContext
@@ -301,15 +301,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             validate_volumes_by_object_id(validated_volumes)
 
             # 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
-            ]
+            volume_mounts = [_volume_to_mount_proto(path, volume) for path, volume in validated_volumes]
 
             open_ports = [api_pb2.PortSpec(port=port, unencrypted=False) for port in encrypted_ports]
             open_ports.extend([api_pb2.PortSpec(port=port, unencrypted=True) for port in unencrypted_ports])