modal 1.0.3.dev28__py3-none-any.whl → 1.0.4__py3-none-any.whl

modal/_partial_function.py

@@ -789,12 +789,12 @@ def _batched(
         )
     if max_batch_size < 1:
         raise InvalidError("max_batch_size must be a positive integer.")
-    if max_batch_size >= MAX_MAX_BATCH_SIZE:
-        raise InvalidError(f"max_batch_size must be less than {MAX_MAX_BATCH_SIZE}.")
+    if max_batch_size > MAX_MAX_BATCH_SIZE:
+        raise InvalidError(f"max_batch_size cannot be greater than {MAX_MAX_BATCH_SIZE}.")
     if wait_ms < 0:
         raise InvalidError("wait_ms must be a non-negative integer.")
-    if wait_ms >= MAX_BATCH_WAIT_MS:
-        raise InvalidError(f"wait_ms must be less than {MAX_BATCH_WAIT_MS}.")
+    if wait_ms > MAX_BATCH_WAIT_MS:
+        raise InvalidError(f"wait_ms cannot be greater than {MAX_BATCH_WAIT_MS}.")
 
     flags = _PartialFunctionFlags.CALLABLE_INTERFACE | _PartialFunctionFlags.BATCHED
     params = _PartialFunctionParams(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)

modal/_utils/async_utils.py

@@ -647,7 +647,9 @@ class StopSentinelType: ...
 STOP_SENTINEL = StopSentinelType()
 
 
-async def async_merge(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T, None]:
+async def async_merge(
+    *generators: AsyncGenerator[T, None], cancellation_timeout: float = 10.0
+) -> AsyncGenerator[T, None]:
     """
     Asynchronously merges multiple async generators into a single async generator.
 
@@ -692,8 +694,9 @@ async def async_merge(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T,
 
     async def producer(generator: AsyncGenerator[T, None]):
         try:
-            async for item in generator:
-                await queue.put(ValueWrapper(item))
+            async with aclosing(generator) as stream:
+                async for item in stream:
+                    await queue.put(ValueWrapper(item))
         except Exception as e:
             await queue.put(ExceptionWrapper(e))
 
@@ -735,15 +738,20 @@ async def async_merge(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T,
             new_output_task = asyncio.create_task(queue.get())
 
     finally:
-        if not new_output_task.done():
-            new_output_task.cancel()
-        for task in tasks:
-            if not task.done():
-                try:
-                    task.cancel()
-                    await task
-                except asyncio.CancelledError:
-                    pass
+        unfinished_tasks = [t for t in tasks | {new_output_task} if not t.done()]
+        for t in unfinished_tasks:
+            t.cancel()
+        try:
+            await asyncio.wait_for(
+                asyncio.shield(
+                    # we need to `shield` the `gather` to ensure cooperation with the timeout
+                    # all underlying tasks have been marked as cancelled at this point anyway
+                    asyncio.gather(*unfinished_tasks, return_exceptions=True)
+                ),
+                timeout=cancellation_timeout,
+            )
+        except asyncio.TimeoutError:
+            logger.debug("Timed out while cleaning up async_merge")
 
 
 async def callable_to_agen(awaitable: Callable[[], Awaitable[T]]) -> AsyncGenerator[T, None]:
@@ -761,16 +769,34 @@ async def gather_cancel_on_exc(*coros_or_futures):
         raise
 
 
+async def prevent_cancellation_abortion(coro):
+    # if this is cancelled, it will wait for coro cancellation handling
+    # and then unconditionally re-raises a CancelledError, even if the underlying coro
+    # doesn't re-raise the cancellation itself
+    t = asyncio.create_task(coro)
+    try:
+        return await asyncio.shield(t)
+    except asyncio.CancelledError:
+        if t.cancelled():
+            # coro cancelled itself - reraise
+            raise
+        t.cancel()  # cancel task
+        await t  # this *normally* reraises
+        raise  # if the above somehow resolved, by swallowing cancellation - we still raise
+
+
 async def async_map(
     input_generator: AsyncGenerator[T, None],
     async_mapper_func: Callable[[T], Awaitable[V]],
     concurrency: int,
+    cancellation_timeout: float = 10.0,
 ) -> AsyncGenerator[V, None]:
     queue: asyncio.Queue[Union[ValueWrapper[T], StopSentinelType]] = asyncio.Queue(maxsize=concurrency * 2)
 
     async def producer() -> AsyncGenerator[V, None]:
-        async for item in input_generator:
-            await queue.put(ValueWrapper(item))
+        async with aclosing(input_generator) as stream:
+            async for item in stream:
+                await queue.put(ValueWrapper(item))
 
         for _ in range(concurrency):
             await queue.put(STOP_SENTINEL)
@@ -784,14 +810,17 @@ async def async_map(
         while True:
             item = await queue.get()
             if isinstance(item, ValueWrapper):
-                yield await async_mapper_func(item.value)
+                res = await prevent_cancellation_abortion(async_mapper_func(item.value))
+                yield res
             elif isinstance(item, ExceptionWrapper):
                 raise item.value
             else:
                 assert_type(item, StopSentinelType)
                 break
 
-    async with aclosing(async_merge(*[worker() for _ in range(concurrency)], producer())) as stream:
+    async with aclosing(
+        async_merge(*[worker() for i in range(concurrency)], producer(), cancellation_timeout=cancellation_timeout)
+    ) as stream:
         async for item in stream:
             yield item
 

modal/cli/network_file_system.py

@@ -203,8 +203,11 @@ async def rm(
 ):
     ensure_env(env)
     volume = _NetworkFileSystem.from_name(volume_name)
+    console = Console()
     try:
         await volume.remove_file(remote_path, recursive=recursive)
+        console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
+
     except GRPCError as exc:
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)

modal/cli/run.py

@@ -27,6 +27,7 @@ from ..functions import Function
 from ..image import Image
 from ..output import enable_output
 from ..runner import deploy_app, interactive_shell, run_app
+from ..secret import Secret
 from ..serving import serve_app
 from ..volume import Volume
 from .import_refs import (
@@ -531,6 +532,10 @@ def shell(
             " Can be used multiple times."
         ),
     ),
+    secret: Optional[list[str]] = typer.Option(
+        default=None,
+        help=("Name of a `modal.Secret` to mount inside the shell (if not using REF). Can be used multiple times."),
+    ),
     cpu: Optional[int] = typer.Option(default=None, help="Number of CPUs to allocate to the shell (if not using REF)."),
     memory: Optional[int] = typer.Option(
         default=None, help="Memory to allocate for the shell, in MiB (if not using REF)."
@@ -660,6 +665,7 @@ def shell(
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
         volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
+        secrets = [] if secret is None else [Secret.from_name(s) for s in secret]
         start_shell = partial(
             interactive_shell,
             image=modal_image,
@@ -668,6 +674,7 @@ def shell(
             gpu=gpu,
             cloud=cloud,
             volumes=volumes,
+            secrets=secrets,
             region=region.split(",") if region else [],
             pty=pty,
         )

modal/cli/volume.py

@@ -245,8 +245,10 @@ async def rm(
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
+    console = Console()
     try:
         await volume.remove_file(remote_path, recursive=recursive)
+        console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
     except GRPCError as exc:
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)

modal/client.pyi

@@ -27,11 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.3.dev28",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.0.4"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -90,11 +86,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.3.dev28",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.0.4"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -75,6 +75,7 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
 
 @dataclasses.dataclass()
 class _ServiceOptions:
+    # Note that default values should always be "untruthy" so we can detect when they are not set
     secrets: typing.Collection[_Secret] = ()
     validated_volumes: typing.Sequence[tuple[str, _Volume]] = ()
     resources: Optional[api_pb2.Resources] = None
@@ -88,6 +89,25 @@ class _ServiceOptions:
     batch_max_size: Optional[int] = None
     batch_wait_ms: Optional[int] = None
 
+    def merge_options(self, new_options: "_ServiceOptions") -> "_ServiceOptions":
+        """Implement protobuf-like MergeFrom semantics for this dataclass.
+
+        This mostly exists to support "stacking" of `.with_options()` calls.
+        """
+        new_options_dict = dataclasses.asdict(new_options)
+
+        # Resources needs special merge handling because individual fields are parameters in the public API
+        merged_resources = api_pb2.Resources()
+        if self.resources:
+            merged_resources.MergeFrom(self.resources)
+        if new_resources := new_options_dict.pop("resources"):
+            merged_resources.MergeFrom(new_resources)
+        self.resources = merged_resources
+
+        for key, value in new_options_dict.items():
+            if value:  # Only overwrite data when the value was set in the new options
+                setattr(self, key, value)
+
 
 def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name: str):
     """Binds an "instance service function" to a specific method using metadata for that method
@@ -664,15 +684,32 @@ More information on class parameterization can be found here: https://modal.com/
         container_idle_timeout: Optional[int] = None,  # Now called `scaledown_window`
         allow_concurrent_inputs: Optional[int] = None,  # See `.with_concurrency`
     ) -> "_Cls":
-        """Create an instance of the Cls with configuration options overridden with new values.
+        """Override the static Function configuration at runtime.
+
+        This method will return a new instance of the cls that will autoscale independently of the
+        original instance. Note that options cannot be "unset" with this method (i.e., if a GPU
+        is configured in the `@app.cls()` decorator, passing `gpu=None` here will not create a
+        CPU-only instance).
 
         **Usage:**
 
+        You can use this method after looking up the Cls from a deployed App or if you have a
+        direct reference to a Cls from another Function or local entrypoint on its App:
+
         ```python notest
         Model = modal.Cls.from_name("my_app", "Model")
         ModelUsingGPU = Model.with_options(gpu="A100")
-        ModelUsingGPU().generate.remote(42)  # will run with an A100 GPU
+        ModelUsingGPU().generate.remote(input_prompt)  # Run with an A100 GPU
         ```
+
+        The method can be called multiple times to "stack" updates:
+
+        ```python notest
+        Model.with_options(gpu="A100").with_options(scaledown_window=300)  # Use an A100 with slow scaledown
+        ```
+
+        Note that container arguments (i.e. `volumes` and `secrets`) passed in subsequent calls
+        will not be merged.
         """
         retry_policy = _parse_retries(retries, f"Class {self.__name__}" if self._user_cls else "")
         if gpu or cpu or memory:
@@ -705,21 +742,23 @@ More information on class parameterization can be found here: https://modal.com/
 
         cls = _Cls._from_loader(_load_from_base, rep=f"{self._name}.with_options(...)", is_another_app=True, deps=_deps)
         cls._initialize_from_other(self)
-        cls._options = dataclasses.replace(
-            cls._options,
+
+        new_options = _ServiceOptions(
             secrets=secrets,
+            validated_volumes=validate_volumes(volumes),
             resources=resources,
             retry_policy=retry_policy,
             max_containers=max_containers,
             buffer_containers=buffer_containers,
             scaledown_window=scaledown_window,
             timeout_secs=timeout,
-            validated_volumes=validate_volumes(volumes),
             # Note: set both for backwards / forwards compatibility
             # But going forward `.with_concurrency` is the preferred method with distinct parameterization
             max_concurrent_inputs=allow_concurrent_inputs,
             target_concurrent_inputs=allow_concurrent_inputs,
         )
+
+        cls._options.merge_options(new_options)
         return cls
 
     def with_concurrency(self: "_Cls", *, max_inputs: int, target_inputs: Optional[int] = None) -> "_Cls":
@@ -746,9 +785,9 @@ More information on class parameterization can be found here: https://modal.com/
             _load_from_base, rep=f"{self._name}.with_concurrency(...)", is_another_app=True, deps=_deps
         )
         cls._initialize_from_other(self)
-        cls._options = dataclasses.replace(
-            cls._options, max_concurrent_inputs=max_inputs, target_concurrent_inputs=target_inputs
-        )
+
+        concurrency_options = _ServiceOptions(max_concurrent_inputs=max_inputs, target_concurrent_inputs=target_inputs)
+        cls._options.merge_options(concurrency_options)
         return cls
 
     def with_batching(self: "_Cls", *, max_batch_size: int, wait_ms: int) -> "_Cls":
@@ -775,7 +814,9 @@ More information on class parameterization can be found here: https://modal.com/
             _load_from_base, rep=f"{self._name}.with_concurrency(...)", is_another_app=True, deps=_deps
         )
         cls._initialize_from_other(self)
-        cls._options = dataclasses.replace(cls._options, batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
+
+        batching_options = _ServiceOptions(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
+        cls._options.merge_options(batching_options)
         return cls
 
     @staticmethod

modal/cls.pyi

@@ -37,6 +37,7 @@ class _ServiceOptions:
     batch_max_size: typing.Optional[int]
     batch_wait_ms: typing.Optional[int]
 
+    def merge_options(self, new_options: _ServiceOptions) -> _ServiceOptions: ...
     def __init__(
         self,
         secrets: typing.Collection[modal.secret._Secret] = (),

modal/file_io.py

@@ -144,11 +144,12 @@ class _FileIO(Generic[T]):
     _task_id: str = ""
     _file_descriptor: str = ""
     _client: _Client
-    _watch_output_buffer: list[Optional[bytes]] = []
+    _watch_output_buffer: list[Union[Optional[bytes],Exception]] = []
 
     def __init__(self, client: _Client, task_id: str) -> None:
         self._client = client
         self._task_id = task_id
+        self._watch_output_buffer = []
 
     def _validate_mode(self, mode: str) -> None:
         if not any(char in mode for char in "rwax"):
@@ -173,11 +174,7 @@ class _FileIO(Generic[T]):
                 raise ValueError(f"Invalid file mode: {mode}")
             seen_chars.add(char)
 
-    def _handle_error(self, error: api_pb2.SystemErrorMessage) -> None:
-        error_class = ERROR_MAPPING.get(error.error_code, FilesystemExecutionError)
-        raise error_class(error.error_message)
-
-    async def _consume_output(self, exec_id: str) -> AsyncIterator[Optional[bytes]]:
+    async def _consume_output(self, exec_id: str) -> AsyncIterator[Union[Optional[bytes], Exception]]:
         req = api_pb2.ContainerFilesystemExecGetOutputRequest(
             exec_id=exec_id,
             timeout=55,
@@ -187,7 +184,8 @@ class _FileIO(Generic[T]):
                 yield None
                 break
             if batch.HasField("error"):
-                self._handle_error(batch.error)
+                error_class = ERROR_MAPPING.get(batch.error.error_code, FilesystemExecutionError)
+                yield error_class(batch.error.error_message)
             for message in batch.output:
                 yield message
 
@@ -236,6 +234,8 @@ class _FileIO(Generic[T]):
                     if data is None:
                         completed = True
                         break
+                    if isinstance(data, Exception):
+                        raise data
                     output += data
             except (GRPCError, StreamTerminatedError) as exc:
                 if retries_remaining > 0:
@@ -475,6 +475,8 @@ class _FileIO(Generic[T]):
                     item = self._watch_output_buffer.pop(0)
                     if item is None:
                         break
+                    if isinstance(item, Exception):
+                        raise item
                     buffer += item
                     # a single event may be split across multiple messages
                     # the end of an event is marked by two newlines

modal/file_io.pyi

@@ -1,7 +1,6 @@
 import _typeshed
 import enum
 import modal.client
-import modal_proto.api_pb2
 import typing
 import typing_extensions
 
@@ -33,12 +32,11 @@ class _FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
     _client: modal.client._Client
-    _watch_output_buffer: list[typing.Optional[bytes]]
+    _watch_output_buffer: list[typing.Union[bytes, None, Exception]]
 
     def __init__(self, client: modal.client._Client, task_id: str) -> None: ...
     def _validate_mode(self, mode: str) -> None: ...
-    def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
-    def _consume_output(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
+    def _consume_output(self, exec_id: str) -> typing.AsyncIterator[typing.Union[bytes, None, Exception]]: ...
     async def _consume_watch_output(self, exec_id: str) -> None: ...
     async def _parse_watch_output(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
     async def _wait(self, exec_id: str) -> bytes: ...
@@ -112,15 +110,14 @@ class FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
     _client: modal.client.Client
-    _watch_output_buffer: list[typing.Optional[bytes]]
+    _watch_output_buffer: list[typing.Union[bytes, None, Exception]]
 
     def __init__(self, client: modal.client.Client, task_id: str) -> None: ...
     def _validate_mode(self, mode: str) -> None: ...
-    def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
 
     class ___consume_output_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, exec_id: str) -> typing.Iterator[typing.Optional[bytes]]: ...
-        def aio(self, /, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
+        def __call__(self, /, exec_id: str) -> typing.Iterator[typing.Union[bytes, None, Exception]]: ...
+        def aio(self, /, exec_id: str) -> typing.AsyncIterator[typing.Union[bytes, None, Exception]]: ...
 
     _consume_output: ___consume_output_spec[typing_extensions.Self]
 

modal/functions.pyi

@@ -227,11 +227,11 @@ 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: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    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]: ...
@@ -246,12 +246,12 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    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]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _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]):
@@ -260,11 +260,11 @@ 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]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    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]: ...
 

modal/mount.py

@@ -290,6 +290,7 @@ class _Mount(_Object, type_prefix="mo"):
     _deployment_name: Optional[str] = None
     _namespace: Optional[int] = None
     _environment_name: Optional[str] = None
+    _allow_overwrite: bool = False
     _content_checksum_sha256_hex: Optional[str] = None
 
     @staticmethod
@@ -600,11 +601,16 @@ class _Mount(_Object, type_prefix="mo"):
         # Build the mount.
         status_row.message(f"Creating mount {message_label}: Finalizing index of {len(files)} files")
         if self._deployment_name:
+            creation_type = (
+                api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING
+                if self._allow_overwrite
+                else api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS
+            )
             req = api_pb2.MountGetOrCreateRequest(
                 deployment_name=self._deployment_name,
                 namespace=self._namespace,
                 environment_name=self._environment_name,
-                object_creation_type=api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS,
+                object_creation_type=creation_type,
                 files=files,
             )
         elif resolver.app_id is not None:
@@ -736,7 +742,9 @@ class _Mount(_Object, type_prefix="mo"):
         self: "_Mount",
         deployment_name: Optional[str] = None,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
+        *,
         environment_name: Optional[str] = None,
+        allow_overwrite: bool = False,
         client: Optional[_Client] = None,
     ) -> None:
         check_object_name(deployment_name, "Mount")
@@ -744,6 +752,7 @@ class _Mount(_Object, type_prefix="mo"):
         self._deployment_name = deployment_name
         self._namespace = namespace
         self._environment_name = environment_name
+        self._allow_overwrite = allow_overwrite
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client, environment_name=environment_name)
@@ -826,35 +835,34 @@ import sys; sys.path.append('{REMOTE_PACKAGES_PATH}')
 """.strip()
 
 
-async def _create_single_mount(
+async def _create_single_client_dependency_mount(
     client: _Client,
     builder_version: str,
     python_version: str,
-    platform: str,
     arch: str,
-    uv_python_platform: str = None,
+    platform: str,
+    uv_python_platform: str,
     check_if_exists: bool = True,
+    allow_overwrite: bool = False,
 ):
-    import subprocess
     import tempfile
 
     profile_environment = config.get("environment")
     abi_tag = "cp" + python_version.replace(".", "")
     mount_name = f"{builder_version}-{abi_tag}-{platform}-{arch}"
-    uv_python_platform = uv_python_platform or f"{arch}-{platform}"
 
     if check_if_exists:
         try:
             await Mount.from_name(mount_name, namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL).hydrate.aio(client)
-            print(f"✅ Found existing mount {mount_name} in global namespace.")
+            print(f"➖ Found existing mount {mount_name} in global namespace.")
             return
         except modal.exception.NotFoundError:
             pass
 
-    with tempfile.TemporaryDirectory() as tmpd:
+    with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmpd:
         print(f"📦 Building {mount_name}.")
         requirements = os.path.join(os.path.dirname(__file__), f"requirements/{builder_version}.txt")
-        subprocess.run(
+        cmd = " ".join(
             [
                 "uv",
                 "pip",
@@ -871,12 +879,21 @@ async def _create_single_mount(
                 uv_python_platform,
                 "--python-version",
                 python_version,
-            ],
-            check=True,
-            capture_output=True,
+            ]
         )
+        proc = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.wait()
+        if proc.returncode:
+            stdout, stderr = await proc.communicate()
+            print(stdout.decode("utf-8"))
+            print(stderr.decode("utf-8"))
+            raise RuntimeError(f"Subprocess failed with {proc.returncode}", proc.args)
 
-        print(f"🌐 Downloaded and unpacked packages to {tmpd}.")
+        print(f"🌐 Downloaded and unpacked {mount_name} packages to {tmpd}.")
 
         python_mount = Mount._from_local_dir(tmpd, remote_path=REMOTE_PACKAGES_PATH)
 
@@ -895,6 +912,7 @@ async def _create_single_mount(
                 mount_name,
                 api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
                 environment_name=profile_environment,
+                allow_overwrite=allow_overwrite,
                 client=client,
             )
             print(f"✅ Deployed mount {mount_name} to global namespace.")
@@ -902,34 +920,30 @@ async def _create_single_mount(
 
 async def _create_client_dependency_mounts(
     client=None,
-    check_if_exists=True,
     python_versions: list[str] = list(PYTHON_STANDALONE_VERSIONS),
+    check_if_exists=True,
 ):
+    arch = "x86_64"
+    platform_tags = [
+        ("manylinux_2_17", f"{arch}-manylinux_2_17"),  # glibc >= 2.17
+        ("musllinux_1_2", f"{arch}-unknown-linux-musl"),  # musl >= 1.2
+    ]
     coros = []
-    for python_version in python_versions:
-        # glibc >= 2.17
-        coros.append(
-            _create_single_mount(
-                client,
-                "PREVIEW",
-                python_version,
-                "manylinux_2_17",
-                "x86_64",
-                check_if_exists=check_if_exists,
-            )
-        )
-        # musl >= 1.2
-        coros.append(
-            _create_single_mount(
-                client,
-                "PREVIEW",
-                python_version,
-                "musllinux_1_2",
-                "x86_64",
-                uv_python_platform="x86_64-unknown-linux-musl",
-                check_if_exists=check_if_exists,
-            )
-        )
+    for builder_version in ["PREVIEW"]:
+        for python_version in python_versions:
+            for platform, uv_python_platform in platform_tags:
+                coros.append(
+                    _create_single_client_dependency_mount(
+                        client,
+                        builder_version,
+                        python_version,
+                        arch,
+                        platform,
+                        uv_python_platform,
+                        check_if_exists=builder_version != "PREVIEW",
+                        allow_overwrite=builder_version == "PREVIEW",
+                    )
+                )
     await TaskContext.gather(*coros)