modal 1.0.3.dev8__py3-none-any.whl → 1.0.3.dev11__py3-none-any.whl

modal/_runtime/container_io_manager.py

@@ -323,6 +323,7 @@ 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
@@ -881,13 +882,11 @@ 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.")
-            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()
+
+            assert self._cuda_checkpoint_session, (
+                "CudaCheckpointSession not found when attempting to restore GPU memory"
+            )
+            self._cuda_checkpoint_session.restore()
 
         # Restore input to default state.
         self.current_input_id = None
@@ -907,14 +906,9 @@ 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}"
-                    )
 
-                gpu_memory_snapshot.toggle()
-                gpu_memory_snapshot.wait_for_state(gpu_memory_snapshot.CudaCheckpointState.CHECKPOINTED)
+                self._cuda_checkpoint_session = gpu_memory_snapshot.CudaCheckpointSession()
+                self._cuda_checkpoint_session.checkpoint()
 
             # Notify the heartbeat loop that the snapshot phase has begun in order to
             # prevent it from sending heartbeat RPCs

modal/_runtime/gpu_memory_snapshot.py

@@ -6,10 +6,12 @@
 #
 # [1] https://github.com/NVIDIA/cuda-checkpoint
 
-import os
 import subprocess
 import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
 
 from modal.config import config, logger
 
@@ -29,73 +31,169 @@ 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}")
+@dataclass
+class CudaCheckpointProcess:
+    """Contains a reference to a PID with active CUDA session. This also provides
+    methods for checkpointing and restoring GPU memory."""
 
-    try:
-        subprocess.run(
-            [
-                CUDA_CHECKPOINT_PATH,
-                "--toggle",
-                "--pid",
-                str(pid),
-            ],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
-        logger.debug("Successfully toggled CUDA checkpoint state")
+    pid: int
+    state: CudaCheckpointState
 
-    except subprocess.CalledProcessError as e:
-        logger.debug(f"Failed to toggle CUDA checkpoint state: {e.stderr}")
-        raise CudaCheckpointException(e.stderr)
+    def toggle(self, target_state: CudaCheckpointState, timeout_secs: float = 5 * 60.0):
+        """Toggle CUDA checkpoint state for current process, moving GPU memory to the
+        CPU and back depending on the current process state when called."""
+        logger.debug(f"PID: {self.pid} Toggling CUDA checkpoint state to {target_state.value}")
 
+        start_time = time.monotonic()
 
-def get_state() -> CudaCheckpointState:
-    """Get current CUDA checkpoint state for this process."""
-    pid = get_own_pid()
+        while self._should_continue_toggle(target_state, start_time, timeout_secs):
+            self._execute_toggle_command()
+            time.sleep(0.1)
 
-    try:
-        result = subprocess.run(
-            [CUDA_CHECKPOINT_PATH, "--get-state", "--pid", str(pid)], check=True, capture_output=True, text=True
-        )
+        logger.debug(f"PID: {self.pid} Target state {target_state.value} reached")
 
-        # Parse output to get state
-        state_str = result.stdout.strip().lower()
-        return CudaCheckpointState(state_str)
+    def _should_continue_toggle(
+        self, target_state: CudaCheckpointState, start_time: float, timeout_secs: float
+    ) -> bool:
+        """Check if toggle operation should continue based on current state and timeout."""
+        self.refresh_state()
 
-    except subprocess.CalledProcessError as e:
-        logger.debug(f"Failed to get CUDA checkpoint state: {e.stderr}")
-        raise CudaCheckpointException(e.stderr)
+        if self.state == target_state:
+            return False
 
-
-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}")
+        if self.state == CudaCheckpointState.FAILED:
+            raise CudaCheckpointException(f"PID: {self.pid} CUDA process state is {self.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()
+            raise CudaCheckpointException(
+                f"PID: {self.pid} Timeout after {elapsed:.2f}s waiting for state {target_state.value}. "
+                f"Current state: {self.state}"
+            )
+
+        return True
+
+    def _execute_toggle_command(self):
+        """Execute the cuda-checkpoint toggle command."""
+        try:
+            subprocess.run(
+                [CUDA_CHECKPOINT_PATH, "--toggle", "--pid", str(self.pid)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            logger.debug(f"PID: {self.pid} Successfully toggled CUDA checkpoint state")
+        except subprocess.CalledProcessError as e:
+            logger.debug(f"PID: {self.pid} Failed to toggle CUDA checkpoint state: {e.stderr}")
+            raise CudaCheckpointException(e.stderr)
+
+    def refresh_state(self) -> None:
+        """Refreshes the current CUDA checkpoint state for this process."""
+        try:
+            result = subprocess.run(
+                [CUDA_CHECKPOINT_PATH, "--get-state", "--pid", str(self.pid)],
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+
+            state_str = result.stdout.strip().lower()
+            self.state = CudaCheckpointState(state_str)
+
+        except subprocess.CalledProcessError as e:
+            logger.debug(f"PID: {self.pid} Failed to get CUDA checkpoint state: {e.stderr}")
+            raise CudaCheckpointException(e.stderr)
+
+
+class CudaCheckpointSession:
+    """Manages the checkpointing state of processes with active CUDA sessions."""
+
+    def __init__(self):
+        self.cuda_processes = self._get_cuda_pids()
+        logger.debug(f"PIDs with CUDA sessions: {[c.pid for c in self.cuda_processes]}")
+
+    def _get_cuda_pids(self) -> list[CudaCheckpointProcess]:
+        """Iterates over all PIDs and identifies the ones that have running
+        CUDA sessions."""
+        cuda_pids: list[CudaCheckpointProcess] = []
+
+        # Get all active process IDs from /proc directory
+        proc_dir = Path("/proc")
+        if not proc_dir.exists():
+            raise CudaCheckpointException(
+                "OS does not have /proc path rendering it incompatible with GPU memory snapshots."
+            )
+
+        for entry in proc_dir.iterdir():
+            if not entry.name.isdigit():
+                continue
+
+            pid = int(entry.name)
+            try:
+                # Call cuda-checkpoint to check if this PID has a CUDA session
+                result = subprocess.run(
+                    [CUDA_CHECKPOINT_PATH, "--get-state", "--pid", str(pid)],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+
+                # If the command succeeds (return code 0), this PID has a CUDA session
+                if result.returncode == 0:
+                    state_str = result.stdout.strip().lower()
+                    state = CudaCheckpointState(state_str)
+
+                    cuda_checkpoint_process = CudaCheckpointProcess(pid=pid, state=state)
+                    cuda_pids.append(cuda_checkpoint_process)
+
+            # Command failed, which is expected for PIDs without CUDA sessions
+            except subprocess.CalledProcessError:
+                continue
+
+            # Raise other exceptions
+            except subprocess.TimeoutExpired:
+                raise CudaCheckpointException(f"Failed to get CUDA state for PID {pid}")
+            except Exception as e:
+                raise CudaCheckpointException(e)
+
+        # Sort PIDs for ordered checkpointing
+        cuda_pids.sort(key=lambda x: x.pid)
+        return cuda_pids
+
+    def checkpoint(self) -> None:
+        # Validate all states first
+        for proc in self.cuda_processes:
+            if proc.state != CudaCheckpointState.RUNNING:
+                raise CudaCheckpointException(f"CUDA session not in {CudaCheckpointState.RUNNING} state.")
+
+        # Moving state from GPU to CPU can take several seconds per CUDA session.
+        # Make a parallel call per CUDA session.
+        start = time.perf_counter()
+
+        def checkpoint_impl(proc: CudaCheckpointProcess):
+            proc.toggle(CudaCheckpointState.CHECKPOINTED)
+
+        with ThreadPoolExecutor() as executor:
+            list(executor.map(checkpoint_impl, self.cuda_processes))
+
+        elapsed = time.perf_counter() - start
+        logger.debug(f"Checkpointing CUDA sessions took => {elapsed:.3f}s")
+
+    def restore(self) -> None:
+        # Validate all states first
+        for proc in self.cuda_processes:
+            if proc.state != CudaCheckpointState.CHECKPOINTED:
+                raise CudaCheckpointException(f"CUDA session not in {CudaCheckpointState.CHECKPOINTED} state.")
+
+        # See checkpoint() for rationale about parallelism.
+        start = time.perf_counter()
+
+        def restore_process(proc: CudaCheckpointProcess):
+            proc.toggle(CudaCheckpointState.RUNNING)
+
+        with ThreadPoolExecutor() as executor:
+            list(executor.map(restore_process, self.cuda_processes))
+
+        elapsed = time.perf_counter() - start
+        logger.debug(f"Restoring CUDA sessions took => {elapsed:.3f}s")

modal/cli/secret.py

@@ -1,7 +1,9 @@
 # Copyright Modal Labs 2022
+import json
 import os
 import platform
 import subprocess
+from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Optional
 
@@ -48,14 +50,17 @@ 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,
-    keyvalues: list[str] = typer.Argument(..., help="Space-separated KEY=VALUE items"),
+    secret_name: str,
+    keyvalues: Optional[list[str]] = typer.Argument(default=None, 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:
+
+    for arg in keyvalues or []:
         if "=" in arg:
             key, value = arg.split("=", 1)
             if value == "-":
@@ -63,17 +68,51 @@ 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>=-`.
+                """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"`.
 
 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/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.3.dev8",
+        version: str = "1.0.3.dev11",
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -94,7 +94,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.3.dev8",
+        version: str = "1.0.3.dev11",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/functions.pyi

@@ -227,11 +227,11 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, 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[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, 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[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...
 

{modal-1.0.3.dev8.dist-info → modal-1.0.3.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.0.3.dev8
+Version: 1.0.3.dev11
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.0.3.dev8.dist-info → modal-1.0.3.dev11.dist-info}/RECORD

@@ -22,7 +22,7 @@ modal/app.py,sha256=NZ_rJ9TuMfiNiLg8-gOFgufD5flGtXWPHOZI0gdD3hE,46585
 modal/app.pyi,sha256=4-b_vbe3lNAqQPcMRpQCEDsE1zsVkQRJGUql9B7HvbM,22659
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=OwISJvkgMb-rHm9Gc4i-7YcDgGiZgwJ7F_PzwZH7a6Q,16847
-modal/client.pyi,sha256=9Na2pTVt0dajHjqeQIslZ9l1qZV1oTEX0ZfxR2X9w4s,8457
+modal/client.pyi,sha256=No4MWgan--Ny6RM3uhTaKX9FK5QZHMOvhmgkUk3rZL8,8459
 modal/cloud_bucket_mount.py,sha256=YOe9nnvSr4ZbeCn587d7_VhE9IioZYRvF9VYQTQux08,5914
 modal/cloud_bucket_mount.pyi,sha256=30T3K1a89l6wzmEJ_J9iWv9SknoGqaZDx59Xs-ZQcmk,1607
 modal/cls.py,sha256=dBbeARwOWftlKd1cwtM0cHFtQWSWkwVXwVmOV4w0SyI,37907
@@ -39,7 +39,7 @@ modal/file_io.py,sha256=lcMs_E9Xfm0YX1t9U2wNIBPnqHRxmImqjLW1GHqVmyg,20945
 modal/file_io.pyi,sha256=oB7x-rKq7bmm8cA7Z7W9C9yeko7KK9m9i5GidFnkGK4,9569
 modal/file_pattern_matcher.py,sha256=wov-otB5M1oTdrYDtR2_VgacYin2srdtAP4McA1Cqzw,6516
 modal/functions.py,sha256=kcNHvqeGBxPI7Cgd57NIBBghkfbeFJzXO44WW0jSmao,325
-modal/functions.pyi,sha256=5T58OucdNU4I-LqhBdwsWSAGka-Wa8nP2GcZ5K1bOL0,16236
+modal/functions.pyi,sha256=iqdp5ixtOOlm8bF-QYbD_G8VKqSRt_AVLT7AWjpn6pQ,16236
 modal/gpu.py,sha256=Kbhs_u49FaC2Zi0TjCdrpstpRtT5eZgecynmQi5IZVE,6752
 modal/image.py,sha256=yrI9DCw7GAck3d788GCHJom-_yU55zNu7reNapBhlgE,93284
 modal/image.pyi,sha256=2xjB6XOZDtm_chDdd90UoIj8pnDt5hCg6bOmu5fNaA4,25625
@@ -82,11 +82,11 @@ modal/volume.py,sha256=XtOxzvdTJ3H7BEldl5Puj6vvXucev0i6KWI5tgkXe7I,44120
 modal/volume.pyi,sha256=YZqC3-z4bfiTgb1-uO7XylrONvIsHQUZd9pqW_Wxd48,21145
 modal/_runtime/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_runtime/asgi.py,sha256=_2xSTsDD27Cit7xnMs4lzkJA2wzer2_N4Oa3BkXFzVA,22521
-modal/_runtime/container_io_manager.py,sha256=6j0jO2-s9ShckM4SK45OapoQxWW9HQwQjFaBkXPJPwU,44763
+modal/_runtime/container_io_manager.py,sha256=qKYtd52I0JAmiw1Wfy_EQXHuHsbmt-XwLqKDLBhWrZc,44289
 modal/_runtime/container_io_manager.pyi,sha256=OKvrccBxawjF0PHZuN5eXeh266fS7qZH8yAIG0P02cY,16349
 modal/_runtime/execution_context.py,sha256=73Y5zH_o-MhVCrkJXakYVlFkKqCa2CWvqoHjOfJrJGg,3034
 modal/_runtime/execution_context.pyi,sha256=AlRGyocfQlb4UpEuI_VmRRtvaBTbhjgyKSRFUePi8J0,667
-modal/_runtime/gpu_memory_snapshot.py,sha256=tA3m1d1cwnmHpvpCeN_WijDd6n8byn7LWlpicbIxiOI,3144
+modal/_runtime/gpu_memory_snapshot.py,sha256=HXgqPHQj0LARhmie_h62V95L-M2R1Kg21INUm_IStn8,7574
 modal/_runtime/telemetry.py,sha256=T1RoAGyjBDr1swiM6pPsGRSITm7LI5FDK18oNXxY08U,5163
 modal/_runtime/user_code_imports.py,sha256=78wJyleqY2RVibqcpbDQyfWVBVT9BjyHPeoV9WdwV5Y,17720
 modal/_utils/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
@@ -131,7 +131,7 @@ modal/cli/network_file_system.py,sha256=DoIdY8I42DjFdTtaYuRKNm7GC6vY0QtA4mk6694f
 modal/cli/profile.py,sha256=0TYhgRSGUvQZ5LH9nkl6iZllEvAjDniES264dE57wOM,3201
 modal/cli/queues.py,sha256=1OzC9HdCkbNz6twF3US4FZmIhuVRQ01GOfBY42ux61A,4533
 modal/cli/run.py,sha256=DPa-yQ9o7vjqwvs_TAOvVJxS51yVn__ZGCnbkORL37g,23972
-modal/cli/secret.py,sha256=oLFEPZoyyeMUKPaJZ9JKKl5mfkQU80DGF9p0atotqig,5002
+modal/cli/secret.py,sha256=2bngl3Gb6THXkQ2eWZIN9pOHeOFJqiSNo_waUCVYgns,6611
 modal/cli/token.py,sha256=mxSgOWakXG6N71hQb1ko61XAR9ZGkTMZD-Txn7gmTac,1924
 modal/cli/utils.py,sha256=9Q7DIUX78-c19zBQNA7EtkgqIFatvHWUVGHwUIeBX_0,3366
 modal/cli/volume.py,sha256=h0Lk4CWe37L8X1kOpCj_KXfGGCEZf799fkX6Tbd6BPg,10734
@@ -147,7 +147,7 @@ modal/requirements/2024.10.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddR
 modal/requirements/PREVIEW.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddRo,296
 modal/requirements/README.md,sha256=9tK76KP0Uph7O0M5oUgsSwEZDj5y-dcUPsnpR0Sc-Ik,854
 modal/requirements/base-images.json,sha256=57vMSqzMbLBxw5tFWSaMiIkkVEps4JfX5PAtXGnkS4U,740
-modal-1.0.3.dev8.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-1.0.3.dev11.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=c1yfBS_x--gL5bs0N4ihMwqwX8l3IBWSkBAKNNIi6bQ,3801
 modal_docs/gen_reference_docs.py,sha256=d_CQUGQ0rfw28u75I2mov9AlS773z9rG40-yq5o7g2U,6359
@@ -170,10 +170,10 @@ modal_proto/options_pb2.pyi,sha256=l7DBrbLO7q3Ir-XDkWsajm0d0TQqqrfuX54i4BMpdQg,1
 modal_proto/options_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
 modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0yJSI,247
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modal_version/__init__.py,sha256=ILpE8xfs22gw9WWQLpPlTAtz4i-b9kO12KIIRnKTj9s,120
+modal_version/__init__.py,sha256=KxbRFCmx8jMBlr6spsirRW-qm9_wykDtXonmu1ok9wY,121
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal-1.0.3.dev8.dist-info/METADATA,sha256=koyzYQIvvwuxQ47sZW7NzzKQ5XBE7YaWmhejysY_3xg,2454
-modal-1.0.3.dev8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-1.0.3.dev8.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-1.0.3.dev8.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-1.0.3.dev8.dist-info/RECORD,,
+modal-1.0.3.dev11.dist-info/METADATA,sha256=7T4TyX6KkAkprzHb-YYziHh4WHb_6kQXZa0bNpgvEGM,2455
+modal-1.0.3.dev11.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-1.0.3.dev11.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-1.0.3.dev11.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-1.0.3.dev11.dist-info/RECORD,,

modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.0.3.dev8"
+__version__ = "1.0.3.dev11"