modal 1.2.5.dev26__tar.gz → 1.2.5.dev28__tar.gz

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/PKG-INFO

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

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal/_utils/blob_utils.py

@@ -371,11 +371,17 @@ class FileUploadSpec:
     mount_filename: str
 
     use_blob: bool
-    content: Optional[bytes]  # typically None if using blob, required otherwise
     sha256_hex: str
     md5_hex: str
     mode: int  # file permission bits (last 12 bits of st_mode)
     size: int
+    content: Optional[bytes] = None  # Set for very small files to avoid double-read
+
+    def read_content(self) -> bytes:
+        """Read content from source."""
+        with self.source() as fp:
+            fp.seek(0)
+            return fp.read()
 
 
 def _get_file_upload_spec(
@@ -384,6 +390,7 @@ def _get_file_upload_spec(
     mount_filename: PurePosixPath,
     mode: int,
 ) -> FileUploadSpec:
+    content = None
     with source() as fp:
         # Current position is ignored - we always upload from position 0
         fp.seek(0, os.SEEK_END)
@@ -394,12 +401,18 @@ def _get_file_upload_spec(
             # TODO(dano): remove the placeholder md5 once we stop requiring md5 for blobs
             md5_hex = "baadbaadbaadbaadbaadbaadbaadbaad" if size > MULTIPART_UPLOAD_THRESHOLD else None
             use_blob = True
-            content = None
             hashes = get_upload_hashes(fp, md5_hex=md5_hex)
         else:
             use_blob = False
-            content = fp.read()
-            hashes = get_upload_hashes(content)
+            # For very small files (< 256 KiB), read content once and cache it
+            # This avoids double-read penalty while limiting memory usage
+            if size < 256 * 1024:  # 256 KiB threshold
+                fp.seek(0)
+                content = fp.read()
+                hashes = get_upload_hashes(content)
+            else:
+                # For medium files (256 KiB - 4 MiB), compute hashes without caching content
+                hashes = get_upload_hashes(fp)
 
     return FileUploadSpec(
         source=source,
@@ -407,11 +420,11 @@ def _get_file_upload_spec(
         source_is_path=isinstance(source_description, Path),
         mount_filename=mount_filename.as_posix(),
         use_blob=use_blob,
-        content=content,
         sha256_hex=hashes.sha256_hex(),
         md5_hex=hashes.md5_hex(),
         mode=mode & 0o7777,
         size=size,
+        content=content,
     )
 
 

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal/_utils/task_command_router_client.py

@@ -158,8 +158,10 @@ class TaskCommandRouterClient:
         )
 
         await connect_channel(channel)
+        loop = asyncio.get_running_loop()
+        jwt_refresh_lock = asyncio.Lock()
 
-        return cls(server_client, task_id, resp.url, resp.jwt, channel)
+        return cls(server_client, task_id, resp.url, resp.jwt, channel, loop, jwt_refresh_lock)
 
     def __init__(
         self,
@@ -168,12 +170,18 @@ class TaskCommandRouterClient:
         server_url: str,
         jwt: str,
         channel: grpclib.client.Channel,
+        loop: asyncio.AbstractEventLoop,
+        jwt_refresh_lock: asyncio.Lock,
         *,
         stream_stdio_retry_delay_secs: float = 0.01,
         stream_stdio_retry_delay_factor: float = 2,
         stream_stdio_max_retries: int = 10,
     ) -> None:
         """Callers should not use this directly. Use TaskCommandRouterClient.try_init() instead."""
+        # Record the loop this instance is bound to so __del__ can safely schedule cleanup
+        # even if finalization happens from a different thread (e.g. via synchronicity).
+        self._loop = loop
+
         # Attach bearer token on all requests to the worker-side router service.
         self._server_client = server_client
         self._task_id = task_id
@@ -187,12 +195,10 @@ class TaskCommandRouterClient:
 
         # JWT refresh coordination
         self._jwt_exp: Optional[float] = _parse_jwt_expiration(jwt)
-        self._jwt_refresh_lock = asyncio.Lock()
-        self._jwt_refresh_event = asyncio.Event()
-        self._closed = False
+        # This is passed in as an argument to ensure it's created from within the correct event loop.
+        self._jwt_refresh_lock = jwt_refresh_lock
 
-        # Start background task to eagerly refresh JWT 30s before expiration.
-        self._jwt_refresh_task = asyncio.create_task(self._jwt_refresh_loop())
+        self._closed = False
 
         async def send_request(event: grpclib.events.SendRequest) -> None:
             # This will get the most recent JWT for every request. No need to
@@ -205,29 +211,40 @@ class TaskCommandRouterClient:
         self._stub = TaskCommandRouterStub(self._channel)
 
     def __del__(self) -> None:
-        """Clean up the client when it's garbage collected."""
-        if self._closed:
+        """Best-effort cleanup if the caller forgot to close().
+
+        This object is typically used through synchronicity wrappers, which means this finalizer
+        may run on a different thread than the event loop that owns the channel. Closing the
+        channel is therefore scheduled onto the owning loop using call_soon_threadsafe.
+
+        Use getattr in the event that attributes are not yet initialized or the
+        object is in a half-torn-down state.
+        """
+        if getattr(self, "_closed", False):
+            return
+        self._closed = True
+
+        channel = getattr(self, "_channel", None)
+        if channel is None:
             return
 
-        self._jwt_refresh_task.cancel()
+        loop = getattr(self, "_loop", None)
 
-        try:
-            self._channel.close()
-        except Exception:
-            pass
+        if loop is not None and not loop.is_closed():
+            try:
+                loop.call_soon_threadsafe(channel.close)
+            except Exception:
+                # call_soon_threadsafe could throw if the loop is torn down
+                # after calling is_closed. This is safe to ignore, and we don't
+                # want to raise an exception from a destructor.
+                pass
 
     async def close(self) -> None:
-        """Close the client and stop the background JWT refresh task."""
+        """Close the client."""
         if self._closed:
             return
 
         self._closed = True
-        self._jwt_refresh_task.cancel()
-        try:
-            logger.debug(f"Waiting for JWT refresh task to complete for exec with task ID {self._task_id}")
-            await self._jwt_refresh_task
-        except asyncio.CancelledError:
-            pass
         self._channel.close()
 
     async def exec_start(self, request: sr_pb2.TaskExecStartRequest) -> sr_pb2.TaskExecStartResponse:
@@ -370,10 +387,7 @@ class TaskCommandRouterClient:
             raise ExecTimeoutError(f"Deadline exceeded while waiting for exec {exec_id}")
 
     async def _refresh_jwt(self) -> None:
-        """Refresh JWT from the server and update internal state.
-
-        Concurrency-safe: only one refresh runs at a time.
-        """
+        """Refresh JWT from the server and update internal state."""
         async with self._jwt_refresh_lock:
             if self._closed:
                 return
@@ -394,8 +408,6 @@ class TaskCommandRouterClient:
             assert resp.url == self._server_url, "Task router URL changed during session"
             self._jwt = resp.jwt
             self._jwt_exp = _parse_jwt_expiration(resp.jwt)
-            # Wake up the background loop to recompute its next sleep.
-            self._jwt_refresh_event.set()
 
     async def _call_with_auth_retry(self, func, *args, **kwargs):
         try:
@@ -407,47 +419,6 @@ class TaskCommandRouterClient:
                 return await func(*args, **kwargs)
             raise
 
-    async def _jwt_refresh_loop(self) -> None:
-        """Background task that refreshes JWT 30 seconds before expiration.
-
-        Uses an event to wake early when a manual refresh happens or token changes.
-        """
-        while not self._closed:
-            try:
-                exp = self._jwt_exp
-                now = time.time()
-                if exp is None:
-                    # Unknown expiration: re-check periodically or until event wakes us.
-                    sleep_s = 60.0
-                else:
-                    refresh_at = exp - 30.0
-                    sleep_s = max(refresh_at - now, 0.0)
-
-                self._jwt_refresh_event.clear()
-                if sleep_s > 0:
-                    try:
-                        logger.debug(f"Waiting for JWT refresh for {sleep_s}s for exec with task ID {self._task_id}")
-                        # Wait until it's time to refresh, unless woken early.
-                        await asyncio.wait_for(self._jwt_refresh_event.wait(), timeout=sleep_s)
-                        logger.debug(f"Stopped waiting for JWT refresh for exec with task ID {self._task_id}")
-                        # Event fired (e.g., token changed) -> recompute timings.
-                        continue
-                    except asyncio.TimeoutError:
-                        logger.debug(f"Done waiting for JWT refresh for exec with task ID {self._task_id}")
-                        pass
-
-                # Time to refresh.
-                logger.debug(f"Refreshing JWT for exec with task ID {self._task_id}")
-                await self._refresh_jwt()
-            except asyncio.CancelledError:
-                logger.debug(f"Cancelled JWT refresh loop for exec with task ID {self._task_id}")
-                break
-            except Exception as e:
-                # Exceptions here can stem from non-transient errors against the server sending
-                # the TaskGetCommandRouterAccess RPC, for instance, if the task has finished.
-                logger.debug(f"Background JWT refresh failed for exec with task ID {self._task_id}: {e}")
-                break
-
     async def _stream_stdio(
         self,
         task_id: str,

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev26",
+        version: str = "1.2.5.dev28",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev26",
+        version: str = "1.2.5.dev28",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal/mount.py

@@ -466,16 +466,18 @@ class _Mount(_Object, type_prefix="mo"):
         loop = asyncio.get_event_loop()
         with concurrent.futures.ThreadPoolExecutor() as exe:
             all_files = await loop.run_in_executor(exe, _select_files, entries)
+            logger.debug(f"Computing checksums for {len(all_files)} files using {exe._max_workers} worker threads")
 
-            futs = []
+            # Yield FileUploadSpec objects lazily as they're consumed by async_map downstream.
+            # async_map's concurrency limit provides natural backpressure, so we don't need
+            # a separate semaphore here. This keeps memory bounded without creating all tasks upfront.
             for local_filename, remote_filename in all_files:
-                logger.debug(f"Mounting {local_filename} as {remote_filename}")
-                futs.append(loop.run_in_executor(exe, get_file_upload_spec_from_path, local_filename, remote_filename))
-
-            logger.debug(f"Computing checksums for {len(futs)} files using {exe._max_workers} worker threads")
-            for fut in asyncio.as_completed(futs):
                 try:
-                    yield await fut
+                    logger.debug(f"Mounting {local_filename} as {remote_filename}")
+                    file_spec = await loop.run_in_executor(
+                        exe, get_file_upload_spec_from_path, local_filename, remote_filename
+                    )
+                    yield file_spec
                 except FileNotFoundError as exc:
                     # Can happen with temporary files (e.g. emacs will write temp files and delete them quickly)
                     logger.info(f"Ignoring file not found: {exc}")
@@ -547,7 +549,11 @@ class _Mount(_Object, type_prefix="mo"):
                 logger.debug(
                     f"Uploading file {file_spec.source_description} to {remote_filename} ({file_spec.size} bytes)"
                 )
-                request2 = api_pb2.MountPutFileRequest(data=file_spec.content, sha256_hex=file_spec.sha256_hex)
+                if file_spec.content is None:
+                    content = await asyncio.to_thread(file_spec.read_content)
+                else:
+                    content = file_spec.content
+                request2 = api_pb2.MountPutFileRequest(data=content, sha256_hex=file_spec.sha256_hex)
 
             start_time = time.monotonic()
             while time.monotonic() - start_time < MOUNT_PUT_FILE_CLIENT_TIMEOUT:

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal/volume.py

@@ -1056,7 +1056,11 @@ class _VolumeUploadContextManager(_AbstractVolumeUploadContextManager):
                 logger.debug(
                     f"Uploading file {file_spec.source_description} to {remote_filename} ({file_spec.size} bytes)"
                 )
-                request2 = api_pb2.MountPutFileRequest(data=file_spec.content, sha256_hex=file_spec.sha256_hex)
+                if file_spec.content is None:
+                    content = await asyncio.to_thread(file_spec.read_content)
+                else:
+                    content = file_spec.content
+                request2 = api_pb2.MountPutFileRequest(data=content, sha256_hex=file_spec.sha256_hex)
                 self._progress_cb(task_id=progress_task_id, complete=True)
 
             while (time.monotonic() - start_time) < VOLUME_PUT_FILE_CLIENT_TIMEOUT:

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal.egg-info/PKG-INFO

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

{modal-1.2.5.dev26 → modal-1.2.5.dev28}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.2.5.dev26"
+__version__ = "1.2.5.dev28"