modal 1.1.1.dev41__py3-none-any.whl → 1.1.2__py3-none-any.whl

modal/experimental/__init__.py

@@ -1,5 +1,6 @@
 # Copyright Modal Labs 2025
 import os
+import shlex
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, Optional, Union
@@ -212,6 +213,135 @@ async def raw_registry_image(
     )
 
 
+def _install_cuda_command() -> str:
+    """Command to install CUDA Toolkit (nvcc) inside a container."""
+    arch = "x86_64"  # instruction set architecture for the CPU, all Modal machines are x86_64
+    distro = "debian12"  # the distribution and version number of our OS (GNU/Linux)
+    filename = "cuda-keyring_1.1-1_all.deb"  # NVIDIA signing key file
+    cuda_keyring_url = f"https://developer.download.nvidia.com/compute/cuda/repos/{distro}/{arch}/{filename}"
+
+    major, minor = 12, 8
+    max_cuda_version = f"{major}-{minor}"
+
+    return (
+        f"wget {cuda_keyring_url} && "
+        + f"dpkg -i {filename} && "
+        + f"rm -f {filename} && "
+        + f"apt-get update && apt-get install -y cuda-nvcc-{max_cuda_version}"
+    )
+
+
+@synchronizer.create_blocking
+async def notebook_base_image(*, python_version: Optional[str] = None, force_build: bool = False) -> _Image:
+    """Default image used for Modal notebook kernels, with common libraries.
+
+    This can be used to bootstrap development workflows quickly. We don't
+    recommend using this image for production Modal Functions though, as it may
+    change at any time in the future.
+    """
+    # Include several common packages, as well as kernelshim dependencies (except 'modal').
+    # These packages aren't pinned, so they may change over time with builds.
+    #
+    # We plan to use `--exclude-newer` in the future, with date-specific image builds.
+    base_image = _Image.debian_slim(python_version=python_version)
+
+    environment_packages: list[str] = [
+        "accelerate",
+        "aiohttp",
+        "altair",
+        "anthropic",
+        "asyncpg",
+        "beautifulsoup4",
+        "bokeh",
+        "boto3[crt]",
+        "click",
+        "diffusers[torch,flax]",
+        "dm-sonnet",
+        "flax",
+        "ftfy",
+        "h5py",
+        "urllib3",
+        "httpx",
+        "huggingface-hub",
+        "ipywidgets",
+        "jax[cuda12]",
+        "keras",
+        "matplotlib",
+        "nbformat",
+        "numba",
+        "numpy",
+        "openai",
+        "optax",
+        "pandas",
+        "plotly[express]",
+        "polars",
+        "psycopg2",
+        "requests",
+        "safetensors",
+        "scikit-image",
+        "scikit-learn",
+        "scipy",
+        "seaborn",
+        "sentencepiece",
+        "sqlalchemy",
+        "statsmodels",
+        "sympy",
+        "tabulate",
+        "tensorboard",
+        "toml",
+        "transformers",
+        "triton",
+        "typer",
+        "vega-datasets",
+        "watchfiles",
+        "websockets",
+    ]
+
+    # Kernelshim dependencies. (see NOTEBOOK_KERNELSHIM_DEPENDENCIES)
+    kernelshim_packages: list[str] = [
+        "authlib>=1.3",
+        "basedpyright>=1.28",
+        "fastapi>=0.100",
+        "ipykernel>=6",
+        "pydantic>=2",
+        "pyzmq>=26",
+        "ruff>=0.11",
+        "uvicorn>=0.32",
+    ]
+
+    commands: list[str] = [
+        "apt-get update",
+        "apt-get install -y libpq-dev pkg-config cmake git curl wget unzip zip libsqlite3-dev openssh-server vim",
+        _install_cuda_command(),
+        # Install uv since it's faster than pip for installing packages.
+        "pip install uv",
+        # https://github.com/astral-sh/uv/issues/11480
+        "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126",
+        f"uv pip install --system {shlex.join(sorted(environment_packages))}",
+        f"uv pip install --system {shlex.join(sorted(kernelshim_packages))}",
+    ]
+
+    # TODO: Also install the CUDA Toolkit, so `nvcc` is available.
+    # https://github.com/charlesfrye/cuda-modal/blob/7fef8db12402986cf42d9c8cca8c63d1da6d7700/cuda/use_cuda.py#L158-L188
+
+    def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
+        return DockerfileSpec(
+            commands=[
+                "FROM base",
+                *(f"RUN {cmd}" for cmd in commands),
+                "ENV PATH=/usr/local/cuda/bin:$PATH",
+            ],
+            context_files={},
+        )
+
+    return _Image._from_args(
+        base_images={"base": base_image},
+        dockerfile_function=build_dockerfile,
+        force_build=force_build,
+        _namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+    )
+
+
 @synchronizer.create_blocking
 async def update_autoscaler(
     obj: Union[_Function, _Obj],

modal/file_io.py

@@ -128,7 +128,7 @@ class _FileIO(Generic[T]):
 
     **Usage**
 
-    ```python
+    ```python notest
     import modal
 
     app = modal.App.lookup("my-app", create_if_missing=True)

modal/file_io.pyi

@@ -62,7 +62,7 @@ class _FileIO(typing.Generic[T]):
 
     **Usage**
 
-    ```python
+    ```python notest
     import modal
 
     app = modal.App.lookup("my-app", create_if_missing=True)
@@ -232,7 +232,7 @@ class FileIO(typing.Generic[T]):
 
     **Usage**
 
-    ```python
+    ```python notest
     import modal
 
     app = modal.App.lookup("my-app", create_if_missing=True)

modal/file_pattern_matcher.py

@@ -11,6 +11,7 @@ then asking it whether file paths match any of its patterns.
 
 import os
 from abc import abstractmethod
+from functools import cached_property
 from pathlib import Path
 from typing import Callable, Optional, Sequence, Union
 
@@ -99,11 +100,11 @@ class FilePatternMatcher(_AbstractPatternMatcher):
     ```
     """
 
-    patterns: list[Pattern]
-    _delayed_init: Callable[[], None] = None
+    _file_path: Optional[Union[str, Path]]
+    _pattern_strings: Optional[Sequence[str]]
 
-    def _set_patterns(self, patterns: Sequence[str]) -> None:
-        self.patterns = []
+    def _parse_patterns(self, patterns: Sequence[str]) -> list[Pattern]:
+        parsed_patterns = []
         for pattern in list(patterns):
             pattern = pattern.strip().strip(os.path.sep)
             if not pattern:
@@ -118,7 +119,8 @@ class FilePatternMatcher(_AbstractPatternMatcher):
             # In Python, we can proceed without explicit syntax checking
             new_pattern.cleaned_pattern = pattern
             new_pattern.dirs = pattern.split(os.path.sep)
-            self.patterns.append(new_pattern)
+            parsed_patterns.append(new_pattern)
+        return parsed_patterns
 
     def __init__(self, *pattern: str) -> None:
         """Initialize a new FilePatternMatcher instance.
@@ -129,7 +131,8 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         Raises:
             ValueError: If an illegal exclusion pattern is provided.
         """
-        self._set_patterns(pattern)
+        self._pattern_strings = pattern
+        self._file_path = None
 
     @classmethod
     def from_file(cls, file_path: Union[str, Path]) -> "FilePatternMatcher":
@@ -148,14 +151,10 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         ```
 
         """
-        uninitialized = cls.__new__(cls)
-
-        def _delayed_init():
-            uninitialized._set_patterns(Path(file_path).read_text("utf8").splitlines())
-            uninitialized._delayed_init = None
-
-        uninitialized._delayed_init = _delayed_init
-        return uninitialized
+        instance = cls.__new__(cls)
+        instance._file_path = file_path
+        instance._pattern_strings = None
+        return instance
 
     def _matches(self, file_path: str) -> bool:
         """Check if the file path or any of its parent directories match the patterns.
@@ -194,6 +193,18 @@ class FilePatternMatcher(_AbstractPatternMatcher):
 
         return matched
 
+    @cached_property
+    def patterns(self) -> list[Pattern]:
+        """Get the patterns, loading from file if necessary."""
+        if self._file_path is not None:
+            # Lazy load from file
+            pattern_strings = Path(self._file_path).read_text("utf8").splitlines()
+        else:
+            # Use patterns provided in __init__
+            pattern_strings = list(self._pattern_strings)
+
+        return self._parse_patterns(pattern_strings)
+
     def can_prune_directories(self) -> bool:
         """
         Returns True if this pattern matcher allows safe early directory pruning.
@@ -205,8 +216,6 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         return not any(pattern.exclusion for pattern in self.patterns)
 
     def __call__(self, file_path: Path) -> bool:
-        if self._delayed_init:
-            self._delayed_init()
         return self._matches(str(file_path))
 
 

modal/functions.pyi

@@ -84,7 +84,7 @@ class Function(
         memory: typing.Union[int, tuple[int, int], None] = None,
         proxy: typing.Optional[modal.proxy.Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -405,6 +405,12 @@ class Function(
 
     _map: ___map_spec[typing_extensions.Self]
 
+    class ___spawn_map_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
+        def __call__(self, /, input_queue: modal.parallel_map.SynchronizedQueue) -> FunctionCall[ReturnType_INNER]: ...
+        async def aio(self, /, input_queue: modal.parallel_map.SynchronizedQueue) -> FunctionCall[ReturnType_INNER]: ...
+
+    _spawn_map: ___spawn_map_spec[modal._functions.ReturnType, typing_extensions.Self]
+
     class ___call_function_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, args, kwargs) -> ReturnType_INNER: ...
         async def aio(self, /, args, kwargs) -> ReturnType_INNER: ...
@@ -427,7 +433,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."""
             ...
@@ -436,7 +442,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]:
@@ -463,7 +469,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.
 
@@ -487,7 +493,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]):
@@ -496,7 +502,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.
 
@@ -517,7 +523,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."""
@@ -693,6 +699,34 @@ class Function(
 
     spawn_map: __spawn_map_spec[typing_extensions.Self]
 
+    class __experimental_spawn_map_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, *input_iterators, kwargs={}) -> modal._functions._FunctionCall:
+            """mdmd:hidden
+            Spawn parallel execution over a set of inputs, returning as soon as the inputs are created.
+
+            Unlike `modal.Function.map`, this method does not block on completion of the remote execution but
+            returns a `modal.FunctionCall` object that can be used to poll status and retrieve results later.
+
+            Takes one iterator argument per argument in the function being mapped over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a, b):
+                return a ** b
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2], [3, 4])
+            ```
+            """
+            ...
+
+        async def aio(self, /, *input_iterators, kwargs={}) -> modal._functions._FunctionCall: ...
+
+    experimental_spawn_map: __experimental_spawn_map_spec[typing_extensions.Self]
+
 class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Object):
     """A reference to an executed function call.
 
@@ -705,16 +739,31 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
     """
 
     _is_generator: bool
+    _num_inputs: typing.Optional[int]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
         ...
 
     def _invocation(self): ...
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
+
+    class __num_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /) -> int:
+            """Get the number of inputs in the function call."""
+            ...
+
+        async def aio(self, /) -> int:
+            """Get the number of inputs in the function call."""
+            ...
+
+    num_inputs: __num_inputs_spec[typing_extensions.Self]
 
     class __get_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
-        def __call__(self, /, timeout: typing.Optional[float] = None) -> ReturnType_INNER:
-            """Get the result of the function call.
+        def __call__(self, /, timeout: typing.Optional[float] = None, *, index: int = 0) -> ReturnType_INNER:
+            """Get the result of the index-th input of the function call.
+            `.spawn()` calls have a single output, so only specifying `index=0` is valid.
+            A non-zero index is useful when your function has multiple outputs, like via `.spawn_map()`.
 
             This function waits indefinitely by default. It takes an optional
             `timeout` argument that specifies the maximum number of seconds to wait,
@@ -724,8 +773,10 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             """
             ...
 
-        async def aio(self, /, timeout: typing.Optional[float] = None) -> ReturnType_INNER:
-            """Get the result of the function call.
+        async def aio(self, /, timeout: typing.Optional[float] = None, *, index: int = 0) -> ReturnType_INNER:
+            """Get the result of the index-th input of the function call.
+            `.spawn()` calls have a single output, so only specifying `index=0` is valid.
+            A non-zero index is useful when your function has multiple outputs, like via `.spawn_map()`.
 
             This function waits indefinitely by default. It takes an optional
             `timeout` argument that specifies the maximum number of seconds to wait,
@@ -737,6 +788,55 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     get: __get_spec[modal._functions.ReturnType, typing_extensions.Self]
 
+    class __iter_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
+        def __call__(self, /, *, start: int = 0, end: typing.Optional[int] = None) -> typing.Iterator[ReturnType_INNER]:
+            """Iterate in-order over the results of the function call.
+
+            Optionally, specify a range [start, end) to iterate over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a):
+                return a ** 2
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2, 3, 4])
+                assert list(fc.iter()) == [1, 4, 9, 16]
+                assert list(fc.iter(start=1, end=3)) == [4, 9]
+            ```
+
+            If `end` is not provided, it will iterate over all results.
+            """
+            ...
+
+        def aio(self, /, *, start: int = 0, end: typing.Optional[int] = None) -> typing.AsyncIterator[ReturnType_INNER]:
+            """Iterate in-order over the results of the function call.
+
+            Optionally, specify a range [start, end) to iterate over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a):
+                return a ** 2
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2, 3, 4])
+                assert list(fc.iter()) == [1, 4, 9, 16]
+                assert list(fc.iter(start=1, end=3)) == [4, 9]
+            ```
+
+            If `end` is not provided, it will iterate over all results.
+            """
+            ...
+
+    iter: __iter_spec[modal._functions.ReturnType, typing_extensions.Self]
+
     class __get_call_graph_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /) -> list[modal.call_graph.InputInfo]:
             """Returns a structure representing the call graph from a given root

modal/image.py

@@ -1393,7 +1393,13 @@ class _Image(_Object, type_prefix="im"):
                 # a requirement in `uv.lock`
                 return
 
-            dependencies = pyproject_toml_content["project"]["dependencies"]
+            try:
+                dependencies = pyproject_toml_content["project"]["dependencies"]
+            except KeyError as e:
+                raise InvalidError(
+                    f"Invalid pyproject.toml file: missing key {e} in {pyproject_toml}. "
+                    "See https://packaging.python.org/en/latest/guides/writing-pyproject-toml for guidelines."
+                )
 
             for group in groups:
                 if (
@@ -1459,7 +1465,7 @@ class _Image(_Object, type_prefix="im"):
                 commands.append(f"COPY /.uv.lock {UV_ROOT}/uv.lock")
 
                 if frozen:
-                    # Do not update `uv.lock` when we have one when `frozen=True`. This it ehd efault because this
+                    # Do not update `uv.lock` when we have one when `frozen=True`. This is the default because this
                     # ensures that the runtime environment matches the local `uv.lock`.
                     #
                     # If `frozen=False`, then `uv sync` will update the the dependencies in the `uv.lock` file
@@ -2108,7 +2114,7 @@ class _Image(_Object, type_prefix="im"):
         gpu: Union[GPU_T, list[GPU_T]] = None,  # Requested GPU or or list of acceptable GPUs( e.g. ["A10", "A100"])
         cpu: Optional[float] = None,  # How many CPU cores to request. This is a soft limit.
         memory: Optional[int] = None,  # How much memory to request, in MiB. This is a soft limit.
-        timeout: Optional[int] = 60 * 60,  # Maximum execution time of the function in seconds.
+        timeout: int = 60 * 60,  # Maximum execution time of the function in seconds.
         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.
         force_build: bool = False,  # Ignore cached builds, similar to 'docker build --no-cache'

modal/image.pyi

@@ -91,7 +91,7 @@ def _create_context_mount_function(
     dockerfile_cmds: list[str] = [],
     dockerfile_path: typing.Optional[pathlib.Path] = None,
     context_mount: typing.Optional[modal.mount._Mount] = None,
-    context_dir: typing.Union[pathlib.Path, str, None] = None,
+    context_dir: typing.Union[str, pathlib.Path, None] = None,
 ): ...
 
 class _ImageRegistryConfig:
@@ -537,7 +537,7 @@ class _Image(modal._object._Object):
         secrets: collections.abc.Sequence[modal.secret._Secret] = [],
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         context_mount: typing.Optional[modal.mount._Mount] = None,
-        context_dir: typing.Union[pathlib.Path, str, None] = None,
+        context_dir: typing.Union[str, pathlib.Path, None] = None,
         force_build: bool = False,
         ignore: typing.Union[
             collections.abc.Sequence[str], collections.abc.Callable[[pathlib.Path], bool]
@@ -748,7 +748,7 @@ class _Image(modal._object._Object):
         *,
         context_mount: typing.Optional[modal.mount._Mount] = None,
         force_build: bool = False,
-        context_dir: typing.Union[pathlib.Path, str, None] = None,
+        context_dir: typing.Union[str, pathlib.Path, None] = None,
         secrets: collections.abc.Sequence[modal.secret._Secret] = [],
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         add_python: typing.Optional[str] = None,
@@ -845,7 +845,7 @@ class _Image(modal._object._Object):
         gpu: typing.Union[None, str, modal.gpu._GPUConfig, list[typing.Union[None, str, modal.gpu._GPUConfig]]] = None,
         cpu: typing.Optional[float] = None,
         memory: typing.Optional[int] = None,
-        timeout: typing.Optional[int] = 3600,
+        timeout: int = 3600,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
         force_build: bool = False,
@@ -1381,7 +1381,7 @@ class Image(modal.object.Object):
         secrets: collections.abc.Sequence[modal.secret.Secret] = [],
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         context_mount: typing.Optional[modal.mount.Mount] = None,
-        context_dir: typing.Union[pathlib.Path, str, None] = None,
+        context_dir: typing.Union[str, pathlib.Path, None] = None,
         force_build: bool = False,
         ignore: typing.Union[
             collections.abc.Sequence[str], collections.abc.Callable[[pathlib.Path], bool]
@@ -1592,7 +1592,7 @@ class Image(modal.object.Object):
         *,
         context_mount: typing.Optional[modal.mount.Mount] = None,
         force_build: bool = False,
-        context_dir: typing.Union[pathlib.Path, str, None] = None,
+        context_dir: typing.Union[str, pathlib.Path, None] = None,
         secrets: collections.abc.Sequence[modal.secret.Secret] = [],
         gpu: typing.Union[None, str, modal.gpu._GPUConfig] = None,
         add_python: typing.Optional[str] = None,
@@ -1689,7 +1689,7 @@ class Image(modal.object.Object):
         gpu: typing.Union[None, str, modal.gpu._GPUConfig, list[typing.Union[None, str, modal.gpu._GPUConfig]]] = None,
         cpu: typing.Optional[float] = None,
         memory: typing.Optional[int] = None,
-        timeout: typing.Optional[int] = 3600,
+        timeout: int = 3600,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
         force_build: bool = False,

modal/mount.py

@@ -13,6 +13,7 @@ from pathlib import Path, PurePosixPath
 from typing import Callable, Optional, Sequence, Union
 
 from google.protobuf.message import Message
+from grpclib import GRPCError
 
 import modal.exception
 import modal.file_pattern_matcher
@@ -929,19 +930,23 @@ async def _create_single_client_dependency_mount(
                 remote_path=REMOTE_SITECUSTOMIZE_PATH,
             )
 
-            await python_mount._deploy.aio(
-                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.")
+            try:
+                await python_mount._deploy.aio(
+                    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.")
+            except GRPCError as e:
+                print(f"⚠️ Mount creation failed with {e.status}: {e.message}")
 
 
 async def _create_client_dependency_mounts(
     client=None,
     python_versions: list[str] = list(PYTHON_STANDALONE_VERSIONS),
+    builder_versions: list[str] = ["2025.06"],  # Reenable "PREVIEW" during testing
     check_if_exists=True,
 ):
     arch = "x86_64"
@@ -950,8 +955,8 @@ async def _create_client_dependency_mounts(
         ("musllinux_1_2", f"{arch}-unknown-linux-musl"),  # musl >= 1.2
     ]
     coros = []
-    for builder_version in ["2025.06", "PREVIEW"]:
-        for python_version in python_versions:
+    for python_version in python_versions:
+        for builder_version in builder_versions:
             for platform, uv_python_platform in platform_tags:
                 coros.append(
                     _create_single_client_dependency_mount(
@@ -961,9 +966,11 @@ async def _create_client_dependency_mounts(
                         arch,
                         platform,
                         uv_python_platform,
-                        # Re-enable mount overwriting for PREVIEW version while under development
-                        # check_if_exists=builder_version != "PREVIEW",
-                        # allow_overwrite=builder_version == "PREVIEW",
+                        # This check_if_exists / allow_overwrite parameterization is very awkward
+                        # Also it doesn't provide a hook for overwriting a non-preview version, which
+                        # in theory we may need to do at some point (hopefully not, but...)
+                        check_if_exists=check_if_exists and builder_version != "PREVIEW",
+                        allow_overwrite=builder_version == "PREVIEW",
                     )
                 )
     await TaskContext.gather(*coros)

modal/mount.pyi

@@ -570,15 +570,28 @@ async def _create_single_client_dependency_mount(
     allow_overwrite: bool = False,
 ): ...
 async def _create_client_dependency_mounts(
-    client=None, python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"], check_if_exists=True
+    client=None,
+    python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+    builder_versions: list[str] = ["2025.06"],
+    check_if_exists=True,
 ): ...
 
 class __create_client_dependency_mounts_spec(typing_extensions.Protocol):
     def __call__(
-        self, /, client=None, python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"], check_if_exists=True
+        self,
+        /,
+        client=None,
+        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        builder_versions: list[str] = ["2025.06"],
+        check_if_exists=True,
     ): ...
     async def aio(
-        self, /, client=None, python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"], check_if_exists=True
+        self,
+        /,
+        client=None,
+        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        builder_versions: list[str] = ["2025.06"],
+        check_if_exists=True,
     ): ...
 
 create_client_dependency_mounts: __create_client_dependency_mounts_spec