modal 1.2.5.dev27__tar.gz → 1.2.5.dev28__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev27
+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.dev27 → 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.dev27 → 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.dev27",
+        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.dev27",
+        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.dev27 → modal-1.2.5.dev28}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev27
+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.dev27 → 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.dev27"
+__version__ = "1.2.5.dev28"