modAL 1.0.3__tar.gz → 1.0.3.dev0__tar.gz

{modal-1.0.3 → modal-1.0.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.0.3
+Version: 1.0.3.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -22,7 +22,7 @@ Requires-Dist: click~=8.1.0
 Requires-Dist: grpclib==0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.9.13
+Requires-Dist: synchronicity~=0.9.12
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi

{modal-1.0.3 → modal-1.0.3.dev0}/modal/_functions.py

@@ -101,7 +101,6 @@ if TYPE_CHECKING:
 
 MAX_INTERNAL_FAILURE_COUNT = 8
 
-
 @dataclasses.dataclass
 class _RetryContext:
     function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType"
@@ -1662,8 +1661,8 @@ Use the `Function.get_web_url()` method instead.
     async def spawn(self, *args: P.args, **kwargs: P.kwargs) -> "_FunctionCall[ReturnType]":
         """Calls the function with the given arguments, without waiting for the results.
 
-        Returns a [`modal.FunctionCall`](/docs/reference/modal.FunctionCall) object, that can later be polled or
-        waited for using [`.get(timeout=...)`](/docs/reference/modal.FunctionCall#get).
+        Returns a `modal.FunctionCall` object, that can later be polled or
+        waited for using `.get(timeout=...)`.
         Conceptually similar to `multiprocessing.pool.apply_async`, or a Future/Promise in other contexts.
         """
         self._check_no_web_url("spawn")

{modal-1.0.3 → modal-1.0.3.dev0}/modal/_runtime/container_io_manager.py

@@ -323,7 +323,6 @@ class _ContainerIOManager:
         self._heartbeat_loop = None
         self._heartbeat_condition = None
         self._waiting_for_memory_snapshot = False
-        self._cuda_checkpoint_session = None
 
         self._is_interactivity_enabled = False
         self._fetching_inputs = True
@@ -882,11 +881,13 @@ class _ContainerIOManager:
         # Restore GPU memory.
         if self.function_def._experimental_enable_gpu_snapshot and self.function_def.resources.gpu_config.gpu_type:
             logger.debug("GPU memory snapshot enabled. Attempting to restore GPU memory.")
-
-            assert self._cuda_checkpoint_session, (
-                "CudaCheckpointSession not found when attempting to restore GPU memory"
-            )
-            self._cuda_checkpoint_session.restore()
+            gpu_process_state = gpu_memory_snapshot.get_state()
+            if gpu_process_state != gpu_memory_snapshot.CudaCheckpointState.CHECKPOINTED:
+                raise ValueError(
+                    "Cannot restore GPU state if GPU isn't in a 'checkpointed' state. "
+                    f"Current GPU state: {gpu_process_state}"
+                )
+            gpu_memory_snapshot.toggle()
 
         # Restore input to default state.
         self.current_input_id = None
@@ -906,9 +907,14 @@ class _ContainerIOManager:
             # Snapshot GPU memory.
             if self.function_def._experimental_enable_gpu_snapshot and self.function_def.resources.gpu_config.gpu_type:
                 logger.debug("GPU memory snapshot enabled. Attempting to snapshot GPU memory.")
+                gpu_process_state = gpu_memory_snapshot.get_state()
+                if gpu_process_state != gpu_memory_snapshot.CudaCheckpointState.RUNNING:
+                    raise ValueError(
+                        f"Cannot snapshot GPU state if it isn't running. Current GPU state: {gpu_process_state}"
+                    )
 
-                self._cuda_checkpoint_session = gpu_memory_snapshot.CudaCheckpointSession()
-                self._cuda_checkpoint_session.checkpoint()
+                gpu_memory_snapshot.toggle()
+                gpu_memory_snapshot.wait_for_state(gpu_memory_snapshot.CudaCheckpointState.CHECKPOINTED)
 
             # Notify the heartbeat loop that the snapshot phase has begun in order to
             # prevent it from sending heartbeat RPCs

modal-1.0.3.dev0/modal/_runtime/gpu_memory_snapshot.py

@@ -0,0 +1,101 @@
+# Copyright Modal Labs 2022
+#
+# This module provides a simple interface for creating GPU memory snapshots,
+# provising a convenient interface to `cuda-checkpoint` [1]. This is intended
+# to be used in conjunction with memory snapshots.
+#
+# [1] https://github.com/NVIDIA/cuda-checkpoint
+
+import os
+import subprocess
+import time
+from enum import Enum
+
+from modal.config import config, logger
+
+CUDA_CHECKPOINT_PATH: str = config.get("cuda_checkpoint_path")
+
+
+class CudaCheckpointState(Enum):
+    """State representation from the CUDA API: https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES_1gc96cdda177a2b8c296144567cbea4f23"""
+
+    RUNNING = "running"
+    LOCKED = "locked"
+    CHECKPOINTED = "checkpointed"
+    FAILED = "failed"
+
+
+class CudaCheckpointException(Exception):
+    pass
+
+
+def toggle():
+    """Toggle CUDA checkpoint state for current process, moving GPU memory to the
+    CPU and back depending on the current process state when called."""
+    pid = get_own_pid()
+    logger.debug(f"Toggling CUDA checkpoint state for PID {pid}")
+
+    try:
+        subprocess.run(
+            [
+                CUDA_CHECKPOINT_PATH,
+                "--toggle",
+                "--pid",
+                str(pid),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        logger.debug("Successfully toggled CUDA checkpoint state")
+
+    except subprocess.CalledProcessError as e:
+        logger.debug(f"Failed to toggle CUDA checkpoint state: {e.stderr}")
+        raise CudaCheckpointException(e.stderr)
+
+
+def get_state() -> CudaCheckpointState:
+    """Get current CUDA checkpoint state for this process."""
+    pid = get_own_pid()
+
+    try:
+        result = subprocess.run(
+            [CUDA_CHECKPOINT_PATH, "--get-state", "--pid", str(pid)], check=True, capture_output=True, text=True
+        )
+
+        # Parse output to get state
+        state_str = result.stdout.strip().lower()
+        return CudaCheckpointState(state_str)
+
+    except subprocess.CalledProcessError as e:
+        logger.debug(f"Failed to get CUDA checkpoint state: {e.stderr}")
+        raise CudaCheckpointException(e.stderr)
+
+
+def wait_for_state(target_state: CudaCheckpointState, timeout_secs: float = 5.0):
+    """Wait for CUDA checkpoint to reach a specific state."""
+    logger.debug(f"Waiting for CUDA checkpoint state {target_state.value}")
+    start_time = time.monotonic()
+
+    while True:
+        current_state = get_state()
+
+        if current_state == target_state:
+            logger.debug(f"Target state {target_state.value} reached")
+            break
+
+        if current_state == CudaCheckpointState.FAILED:
+            raise CudaCheckpointException(f"CUDA process state is {current_state}")
+
+        elapsed = time.monotonic() - start_time
+        if elapsed >= timeout_secs:
+            raise CudaCheckpointException(f"Timeout after {elapsed:.2f}s waiting for state {target_state.value}")
+
+        time.sleep(0.1)
+
+
+def get_own_pid():
+    """Returns the Process ID (PID) of the current Python process
+    using only the standard library.
+    """
+    return os.getpid()

{modal-1.0.3 → modal-1.0.3.dev0}/modal/cli/run.py

@@ -171,14 +171,6 @@ def _write_local_result(result_path: str, res: Any):
         fid.write(res)
 
 
-def _validate_interactive_quiet_params(ctx):
-    interactive = ctx.obj["interactive"]
-    show_progress = ctx.obj["show_progress"]
-
-    if not show_progress and interactive:
-        raise InvalidError("To use interactive mode, remove the --quiet flag")
-
-
 def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[tuple[str, ...], dict[str, Any]], Any]):
     @click.pass_context
     def f(ctx, **kwargs):
@@ -188,8 +180,6 @@ def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[
         else:
             args = ()
 
-        _validate_interactive_quiet_params(ctx)
-
         show_progress: bool = ctx.obj["show_progress"]
         with enable_output(show_progress):
             with run_app(
@@ -301,8 +291,6 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
             assert len(args) == 0 and len(kwargs) == 0
             args = ctx.args
 
-        _validate_interactive_quiet_params(ctx)
-
         show_progress: bool = ctx.obj["show_progress"]
         with enable_output(show_progress):
             with run_app(

{modal-1.0.3 → modal-1.0.3.dev0}/modal/cli/secret.py

@@ -1,9 +1,7 @@
 # Copyright Modal Labs 2022
-import json
 import os
 import platform
 import subprocess
-from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Optional
 
@@ -50,17 +48,14 @@ async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
 @secret_cli.command("create", help="Create a new secret.")
 @synchronizer.create_blocking
 async def create(
-    secret_name: str,
-    keyvalues: Optional[list[str]] = typer.Argument(default=None, help="Space-separated KEY=VALUE items."),
+    secret_name,
+    keyvalues: list[str] = typer.Argument(..., help="Space-separated KEY=VALUE items"),
     env: Optional[str] = ENV_OPTION,
-    from_dotenv: Optional[Path] = typer.Option(default=None, help="Path to a .env file to load secrets from."),
-    from_json: Optional[Path] = typer.Option(default=None, help="Path to a JSON file to load secrets from."),
     force: bool = typer.Option(False, "--force", help="Overwrite the secret if it already exists."),
 ):
     env = ensure_env(env)
     env_dict = {}
-
-    for arg in keyvalues or []:
+    for arg in keyvalues:
         if "=" in arg:
             key, value = arg.split("=", 1)
             if value == "-":
@@ -68,51 +63,17 @@ async def create(
             env_dict[key] = value
         else:
             raise click.UsageError(
-                """Each item should be of the form <KEY>=VALUE. To enter secrets using your $EDITOR, use `<KEY>=-`. To
-enter secrets from environment variables, use `<KEY>="$ENV_VAR"`.
+                """Each item should be of the form <KEY>=VALUE. To enter secrets using your $EDITOR, use `<KEY>=-`.
 
 E.g.
 
 modal secret create my-credentials username=john password=-
-modal secret create my-credentials username=john password="$PASSWORD"
 """
             )
 
-    if from_dotenv:
-        if not from_dotenv.is_file():
-            raise click.UsageError(f"Could not read .env file at {from_dotenv}")
-
-        try:
-            from dotenv import dotenv_values
-        except ImportError:
-            raise ImportError(
-                "Need the `python-dotenv` package installed. You can install it by running `pip install python-dotenv`."
-            )
-
-        try:
-            env_dict.update(dotenv_values(from_dotenv))
-        except Exception as e:
-            raise click.UsageError(f"Could not parse .env file at {from_dotenv}: {e}")
-
-    if from_json:
-        if not from_json.is_file():
-            raise click.UsageError(f"Could not read JSON file at {from_json}")
-
-        try:
-            with from_json.open("r") as f:
-                env_dict.update(json.load(f))
-        except Exception as e:
-            raise click.UsageError(f"Could not parse JSON file at {from_json}: {e}")
-
     if not env_dict:
         raise click.UsageError("You need to specify at least one key for your secret")
 
-    for k, v in env_dict.items():
-        if not isinstance(k, str) or not k:
-            raise click.UsageError(f"Invalid key: '{k}'")
-        if not isinstance(v, str):
-            raise click.UsageError(f"Non-string value for secret '{k}'")
-
     # Create secret
     await _Secret.create_deployed(secret_name, env_dict, overwrite=force)
 

{modal-1.0.3 → modal-1.0.3.dev0}/modal/cli/volume.py

@@ -154,10 +154,6 @@ async def ls(
                 filetype = "dir"
             elif entry.type == api_pb2.FileEntry.FileType.SYMLINK:
                 filetype = "link"
-            elif entry.type == api_pb2.FileEntry.FileType.FIFO:
-                filetype = "fifo"
-            elif entry.type == api_pb2.FileEntry.FileType.SOCKET:
-                filetype = "socket"
             else:
                 filetype = "file"
             rows.append(
@@ -265,13 +261,12 @@ async def rm(
 async def cp(
     volume_name: str,
     paths: list[str],  # accepts multiple paths, last path is treated as destination path
-    recursive: bool = Option(False, "-r", "--recursive", help="Copy directories recursively"),
     env: Optional[str] = ENV_OPTION,
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
     *src_paths, dst_path = paths
-    await volume.copy_files(src_paths, dst_path, recursive)
+    await volume.copy_files(src_paths, dst_path)
 
 
 @volume_cli.command(

{modal-1.0.3 → modal-1.0.3.dev0}/modal/client.pyi

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

{modal-1.0.3 → modal-1.0.3.dev0}/modal/experimental/__init__.py

@@ -94,9 +94,8 @@ async def raw_dockerfile_image(
 
     Unlike for `modal.Image.from_dockerfile`, the provided recipe will not be embellished with
     steps to install dependencies for the Modal client package. As a consequence, the resulting
-    Image cannot be used with a modal Function unless those dependencies are already included
-    as part of the base Dockerfile recipe or are added in a subsequent layer. The Image _can_ be
-    directly used with a modal Sandbox, which does not need the Modal client.
+    Image cannot be used with a modal Function unless those dependencies are added in a subsequent
+    layer. It _can_ be directly used with a modal Sandbox, which does not need the Modal client.
 
     We expect to support this experimental function until the `2025.04` Modal Image Builder is
     stable, at which point Modal Image recipes will no longer install the client dependencies
@@ -128,9 +127,8 @@ async def raw_registry_image(
 
     Unlike for `modal.Image.from_registry`, the provided recipe will not be embellished with
     steps to install dependencies for the Modal client package. As a consequence, the resulting
-    Image cannot be used with a modal Function unless those dependencies are already included
-    as part of the registry Image or are added in a subsequent layer. The Image _can_ be
-    directly used with a modal Sandbox, which does not need the Modal client.
+    Image cannot be used with a modal Function unless those dependencies are added in a subsequent
+    layer. It _can_ be directly used with a modal Sandbox, which does not need the Modal client.
 
     We expect to support this experimental function until the `2025.04` Modal Image Builder is
     stable, at which point Modal Image recipes will no longer install the client dependencies

{modal-1.0.3 → modal-1.0.3.dev0}/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-1.0.3 → modal-1.0.3.dev0}/modal/image.py

@@ -647,13 +647,7 @@ class _Image(_Object, type_prefix="im"):
                     metadata = resp.metadata
 
             if result.status == api_pb2.GenericResult.GENERIC_STATUS_FAILURE:
-                if result.exception:
-                    raise RemoteError(f"Image build for {image_id} failed with the exception:\n{result.exception}")
-                else:
-                    msg = f"Image build for {image_id} failed. See build logs for more details."
-                    if not _get_output_manager():
-                        msg += " (Hint: Use `modal.enable_output()` to see logs from the process building the Image.)"
-                    raise RemoteError(msg)
+                raise RemoteError(f"Image build for {image_id} failed with the exception:\n{result.exception}")
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_TERMINATED:
                 raise RemoteError(f"Image build for {image_id} terminated due to external shut-down. Please try again.")
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_TIMEOUT:
@@ -1528,14 +1522,12 @@ class _Image(_Object, type_prefix="im"):
         modal_requirements_commands = []
         if builder_version <= "2024.10":
             # past 2024.10, client dependencies are mounted at runtime
-            modal_requirements_commands.extend(
-                [
-                    f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
-                    f"RUN python -m pip install --upgrade {_base_image_config('package_tools', builder_version)}",
-                    f"RUN {requirements_prefix}{_get_modal_requirements_command(builder_version)}",
-                ]
-            )
-        if "2024.10" >= builder_version > "2023.12":
+            modal_requirements_commands.extend([
+                f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
+                f"RUN python -m pip install --upgrade {_base_image_config('package_tools', builder_version)}",
+                f"RUN {requirements_prefix}{_get_modal_requirements_command(builder_version)}",
+            ])
+        if  "2024.10" >= builder_version > "2023.12":
             modal_requirements_commands.append(f"RUN rm {CONTAINER_REQUIREMENTS_PATH}")
 
         return [
@@ -1838,31 +1830,23 @@ class _Image(_Object, type_prefix="im"):
                 f"FROM python:{full_python_version}-slim-{debian_codename}",
             ]
             if version <= "2024.10":
-                commands.extend(
-                    [
-                        f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
-                    ]
-                )
-            commands.extend(
-                [
-                    "RUN apt-get update",
-                    "RUN apt-get install -y gcc gfortran build-essential",
-                    f"RUN pip install --upgrade {_base_image_config('package_tools', version)}",
-                ]
-            )
+                commands.extend([
+                    f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
+                ])
+            commands.extend([
+                "RUN apt-get update",
+                "RUN apt-get install -y gcc gfortran build-essential",
+                f"RUN pip install --upgrade {_base_image_config('package_tools', version)}",
+            ])
             if version <= "2024.10":
                 # after 2024.10, modal requirements are mounted at runtime
-                commands.extend(
-                    [
-                        f"RUN {_get_modal_requirements_command(version)}",
-                    ]
-                )
-            commands.extend(
-                [
-                    # Set debian front-end to non-interactive to avoid users getting stuck with input prompts.
-                    "RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections",
-                ]
-            )
+                commands.extend([
+                    f"RUN {_get_modal_requirements_command(version)}",
+                ])
+            commands.extend([
+                # Set debian front-end to non-interactive to avoid users getting stuck with input prompts.
+                "RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections",
+            ])
             if "2024.10" >= version > "2023.12":
                 commands.append(f"RUN rm {CONTAINER_REQUIREMENTS_PATH}")
             if version > "2024.10":

{modal-1.0.3 → modal-1.0.3.dev0}/modal/mount.py

@@ -21,7 +21,7 @@ from modal_version import __version__
 
 from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
-from ._utils.async_utils import TaskContext, aclosing, async_map, synchronize_api
+from ._utils.async_utils import aclosing, async_map, synchronize_api
 from ._utils.blob_utils import FileUploadSpec, blob_upload_file, get_file_upload_spec_from_path
 from ._utils.deprecation import deprecation_warning
 from ._utils.grpc_utils import retry_transient_errors
@@ -115,8 +115,7 @@ class _MountFile(_MountEntry):
     def get_files_to_upload(self):
         local_file = self.local_file.resolve()
         if not local_file.exists():
-            msg = f"local file {local_file} does not exist"
-            raise FileNotFoundError(msg)
+            raise FileNotFoundError(local_file)
 
         rel_filename = self.remote_path
         yield local_file, rel_filename
@@ -145,12 +144,10 @@ class _MountDir(_MountEntry):
         local_dir = self.local_dir.expanduser().absolute()
 
         if not local_dir.exists():
-            msg = f"local dir {local_dir} does not exist"
-            raise FileNotFoundError(msg)
+            raise FileNotFoundError(local_dir)
 
         if not local_dir.is_dir():
-            msg = f"local dir {local_dir} is not a directory"
-            raise NotADirectoryError(msg)
+            raise NotADirectoryError(local_dir)
 
         if self.recursive:
             gen = (os.path.join(root, name) for root, dirs, files in os.walk(local_dir) for name in files)
@@ -813,124 +810,3 @@ def _is_modal_path(remote_path: PurePosixPath):
         if is_modal_path:
             return True
     return False
-
-
-REMOTE_PACKAGES_PATH = "/__modal/deps"
-REMOTE_SITECUSTOMIZE_PATH = "/pkg/sitecustomize.py"
-
-SITECUSTOMIZE_CONTENT = f"""
-# This file is automatically generated by Modal.
-# It ensures that Modal's python dependencies are available in the Python PATH,
-# while prioritizing user-installed packages.
-import sys; sys.path.append('{REMOTE_PACKAGES_PATH}')
-""".strip()
-
-
-async def _create_single_mount(
-    client: _Client,
-    builder_version: str,
-    python_version: str,
-    platform: str,
-    arch: str,
-    uv_python_platform: str = None,
-    check_if_exists: bool = True,
-):
-    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.")
-            return
-        except modal.exception.NotFoundError:
-            pass
-
-    with tempfile.TemporaryDirectory() as tmpd:
-        print(f"📦 Building {mount_name}.")
-        requirements = os.path.join(os.path.dirname(__file__), f"requirements/{builder_version}.txt")
-        subprocess.run(
-            [
-                "uv",
-                "pip",
-                "install",
-                "--strict",
-                "--no-deps",
-                "--no-cache",
-                "-r",
-                requirements,
-                "--compile-bytecode",
-                "--target",
-                tmpd,
-                "--python-platform",
-                uv_python_platform,
-                "--python-version",
-                python_version,
-            ],
-            check=True,
-            capture_output=True,
-        )
-
-        print(f"🌐 Downloaded and unpacked packages to {tmpd}.")
-
-        python_mount = Mount._from_local_dir(tmpd, remote_path=REMOTE_PACKAGES_PATH)
-
-        with tempfile.NamedTemporaryFile() as sitecustomize:
-            sitecustomize.write(
-                SITECUSTOMIZE_CONTENT.encode("utf-8"),
-            )
-            sitecustomize.flush()
-
-            python_mount = python_mount.add_local_file(
-                sitecustomize.name,
-                remote_path=REMOTE_SITECUSTOMIZE_PATH,
-            )
-
-            await python_mount._deploy.aio(
-                mount_name,
-                api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
-                environment_name=profile_environment,
-                client=client,
-            )
-            print(f"✅ Deployed mount {mount_name} to global namespace.")
-
-
-async def _create_client_dependency_mounts(
-    client=None,
-    check_if_exists=True,
-    python_versions: list[str] = list(PYTHON_STANDALONE_VERSIONS),
-):
-    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,
-            )
-        )
-    await TaskContext.gather(*coros)
-
-
-create_client_dependency_mounts = synchronize_api(_create_client_dependency_mounts)