modAL 1.2.5.dev27__tar.gz → 1.2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev27
+Version: 1.2.6
 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.6}/modal/_output.py

@@ -556,7 +556,7 @@ async def get_app_logs_loop(
     async def stop_pty_shell():
         nonlocal pty_shell_finish_event, pty_shell_input_task
         if pty_shell_finish_event:
-            print("\r", end="")  # move cursor to beginning of line
+            print("\r", end="")  # move cursor to beginning of line # noqa: T201
             pty_shell_finish_event.set()
             pty_shell_finish_event = None
 
@@ -623,7 +623,7 @@ async def get_app_logs_loop(
                 # This corresponds to the `modal run -i` use case where a breakpoint
                 # triggers and the task drops into an interactive PTY mode
                 if pty_shell_finish_event:
-                    print("ERROR: concurrent PTY shells are not supported.")
+                    print("ERROR: concurrent PTY shells are not supported.")  # noqa: T201
                 else:
                     pty_shell_stdout = output_mgr._stdout
                     pty_shell_finish_event = asyncio.Event()

{modal-1.2.5.dev27 → modal-1.2.6}/modal/_runtime/container_io_manager.py

@@ -1007,7 +1007,7 @@ class _ContainerIOManager:
         # Start a debugger if the worker tells us to
         if int(restored_state.get("snapshot_debug", 0)):
             logger.debug("Entering snapshot debugger")
-            breakpoint()
+            breakpoint()  # noqa: T100
 
         # Local ContainerIOManager state.
         for key in ["task_id", "function_id"]:

{modal-1.2.5.dev27 → modal-1.2.6}/modal/_runtime/user_code_imports.py

@@ -243,7 +243,7 @@ def create_breakpoint_wrapper(container_io_manager: "modal._runtime.container_io
     def breakpoint_wrapper():
         # note: it would be nice to not have breakpoint_wrapper() included in the backtrace
         container_io_manager.interact(from_breakpoint=True)
-        import pdb
+        import pdb  # noqa: T100
 
         current_frame = inspect.currentframe()
         if current_frame is not None:

{modal-1.2.5.dev27 → modal-1.2.6}/modal/_traceback.py

@@ -119,7 +119,7 @@ def print_exception(exc: Optional[type[BaseException]], value: Optional[BaseExce
     traceback.print_exception(exc, value, tb)
     if sys.version_info < (3, 11) and value is not None:  # type: ignore
         notes = getattr(value, "__notes__", [])
-        print(*notes, sep="\n", file=sys.stderr)
+        print(*notes, sep="\n", file=sys.stderr)  # noqa: T201
 
 
 def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):

{modal-1.2.5.dev27 → modal-1.2.6}/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
 
-        self._jwt_refresh_task.cancel()
+        channel = getattr(self, "_channel", None)
+        if channel is None:
+            return
 
-        try:
-            self._channel.close()
-        except Exception:
-            pass
+        loop = getattr(self, "_loop", None)
+
+        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
@@ -389,13 +403,14 @@ class TaskCommandRouterClient:
                 )
                 return
 
+            logger.debug(f"Refreshing JWT for exec with task ID {self._task_id}")
             resp = await fetch_command_router_access(self._server_client, self._task_id)
+            logger.debug(f"Finished refreshing JWT for exec with task ID {self._task_id}")
+
             # Ensure the server URL remains stable for the lifetime of this client.
             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 +422,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,
@@ -463,7 +437,9 @@ class TaskCommandRouterClient:
         delay_secs = self.stream_stdio_retry_delay_secs
         delay_factor = self.stream_stdio_retry_delay_factor
         num_retries_remaining = self.stream_stdio_max_retries
-        num_auth_retries = 0
+        # Flag to prevent infinite auth retries in the event that the JWT
+        # refresh yields an invalid JWT somehow or that the JWT is otherwise invalid.
+        did_auth_retry = False
 
         async def sleep_and_update_delay_and_num_retries_remaining(e: Exception):
             nonlocal delay_secs, num_retries_remaining
@@ -487,25 +463,28 @@ class TaskCommandRouterClient:
                         file_descriptor=file_descriptor,
                     )
 
-                    # Scope auth retry strictly to the initial send (where headers/auth are sent).
+                    # Auth retry is scoped to a single refresh per streaming attempt. While auth metadata is
+                    # sent on request start, UNAUTHENTICATED may sometimes surface during iteration,
+                    # so we handle it at both send and receive boundaries.
                     try:
                         await s.send_message(req, end=True)
+                        async for item in s:
+                            # We successfully authenticated after a JWT refresh, reset the auth retry flag.
+                            if did_auth_retry:
+                                did_auth_retry = False
+                            # Reset retry backoff after any successful chunk.
+                            delay_secs = self.stream_stdio_retry_delay_secs
+                            offset += len(item.data)
+                            yield item
                     except GRPCError as exc:
-                        if exc.status == Status.UNAUTHENTICATED and num_auth_retries < 1:
+                        if exc.status == Status.UNAUTHENTICATED and not did_auth_retry:
                             await self._refresh_jwt()
-                            num_auth_retries += 1
+                            # Mark that we've retried authentication for this streaming attempt, to
+                            # prevent subsequent retries.
+                            did_auth_retry = True
                             continue
                         raise
 
-                    # We successfully authenticated, reset the auth retry count.
-                    num_auth_retries = 0
-
-                    async for item in s:
-                        # Reset retry backoff after any successful chunk.
-                        delay_secs = self.stream_stdio_retry_delay_secs
-                        offset += len(item.data)
-                        yield item
-
                 # We successfully streamed all output.
                 return
             except GRPCError as e:

{modal-1.2.5.dev27 → modal-1.2.6}/modal/cli/network_file_system.py

@@ -102,7 +102,7 @@ async def ls(
         console.print(table)
     else:
         for entry in entries:
-            print(entry.path)
+            print(entry.path)  # noqa: T201
 
 
 @nfs_cli.command(

{modal-1.2.5.dev27 → modal-1.2.6}/modal/cli/run.py

@@ -292,7 +292,7 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
     @click.pass_context
     def f(ctx, *args, **kwargs):
         if ctx.obj["detach"]:
-            print(
+            print(  # noqa: T201
                 "Note that running a local entrypoint in detached mode only keeps the last "
                 "triggered Modal function alive after the parent process has been killed or disconnected."
             )

{modal-1.2.5.dev27 → modal-1.2.6}/modal/cli/volume.py

@@ -148,7 +148,7 @@ async def ls(
     if not json and not sys.stdout.isatty():
         # Legacy behavior -- I am not sure why exactly we did this originally but I don't want to break it
         for entry in entries:
-            print(entry.path)
+            print(entry.path)  # noqa: T201
     else:
         rows = []
         for entry in entries:

{modal-1.2.5.dev27 → modal-1.2.6}/modal/client.pyi

@@ -28,11 +28,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev27",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.2.6"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -159,11 +155,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev27",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.2.6"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.5.dev27 → modal-1.2.6}/modal/container_process.py

@@ -146,7 +146,7 @@ class _ContainerProcessThroughServer(Generic[T]):
     async def attach(self):
         """mdmd:hidden"""
         if platform.system() == "Windows":
-            print("interactive exec is not currently supported on Windows.")
+            print("interactive exec is not currently supported on Windows.")  # noqa: T201
             return
 
         from ._output import make_console
@@ -347,7 +347,7 @@ class _ContainerProcessThroughCommandRouter(Generic[T]):
 
     async def attach(self):
         if platform.system() == "Windows":
-            print("interactive exec is not currently supported on Windows.")
+            print("interactive exec is not currently supported on Windows.")  # noqa: T201
             return
 
         from ._output import make_console

{modal-1.2.5.dev27 → modal-1.2.6}/modal/io_streams.py

@@ -183,7 +183,7 @@ class _StreamReaderThroughServer(Generic[T]):
                 async for message, batch_index in iterator:
                     if self._stream_type == StreamType.STDOUT and message:
                         # TODO: rearchitect this, since these bytes aren't necessarily decodable
-                        print(message.decode("utf-8"), end="")
+                        print(message.decode("utf-8"), end="")  # noqa: T201
                     elif self._stream_type == StreamType.PIPE:
                         self._container_process_buffer.append(message)
 

{modal-1.2.5.dev27 → modal-1.2.6}/modal/mount.py

@@ -775,13 +775,13 @@ async def _create_single_client_dependency_mount(
     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.")
+            print(f"➖ Found existing mount {mount_name} in global namespace.")  # noqa: T201
             return
         except modal.exception.NotFoundError:
             pass
 
     with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmpd:
-        print(f"📦 Building {mount_name}.")
+        print(f"📦 Building {mount_name}.")  # noqa: T201
         requirements = os.path.join(os.path.dirname(__file__), f"builder/{builder_version}.txt")
         cmd = " ".join(
             [
@@ -810,11 +810,11 @@ async def _create_single_client_dependency_mount(
         await proc.wait()
         if proc.returncode:
             stdout, stderr = await proc.communicate()
-            print(stdout.decode("utf-8"))
-            print(stderr.decode("utf-8"))
+            print(stdout.decode("utf-8"))  # noqa: T201
+            print(stderr.decode("utf-8"))  # noqa: T201
             raise RuntimeError(f"Subprocess failed with {proc.returncode}")
 
-        print(f"🌐 Downloaded and unpacked {mount_name} packages to {tmpd}.")
+        print(f"🌐 Downloaded and unpacked {mount_name} packages to {tmpd}.")  # noqa: T201
 
         python_mount = Mount._from_local_dir(tmpd, remote_path=REMOTE_PACKAGES_PATH)
 
@@ -838,11 +838,11 @@ async def _create_single_client_dependency_mount(
                         allow_overwrite=allow_overwrite,
                         client=client,
                     )
-                    print(f"✅ Deployed mount {mount_name} to global namespace.")
+                    print(f"✅ Deployed mount {mount_name} to global namespace.")  # noqa: T201
                 except GRPCError as e:
-                    print(f"⚠️ Mount creation failed with {e.status}: {e.message}")
+                    print(f"⚠️ Mount creation failed with {e.status}: {e.message}")  # noqa: T201
             else:
-                print(f"Dry run - skipping deployment of mount {mount_name}")
+                print(f"Dry run - skipping deployment of mount {mount_name}")  # noqa: T201
 
 
 async def _create_client_dependency_mounts(

{modal-1.2.5.dev27 → modal-1.2.6}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev27
+Version: 1.2.6
 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.6}/modal_proto/task_command_router.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 
 option go_package = "github.com/modal-labs/modal/go/proto";
 
+import "google/protobuf/empty.proto";
 import "modal_proto/api.proto";
 
 package modal.task_command_router;
@@ -130,6 +131,21 @@ message TaskExecWaitResponse {
   // and termination by Modal (due to task timeout, exec exceeded deadline, etc.)
 }
 
+message TaskMountDirectoryRequest {
+  string task_id = 1;
+  bytes path = 2;
+  string image_id = 3;
+}
+
+message TaskSnapshotDirectoryRequest {
+  string task_id = 1;
+  bytes path = 2;
+}
+
+message TaskSnapshotDirectoryResponse {
+  string image_id = 1;
+}
+
 service TaskCommandRouter {
   // Poll for the exit status of an exec'd command.
   rpc TaskExecPoll(TaskExecPollRequest) returns (TaskExecPollResponse);
@@ -141,4 +157,8 @@ service TaskCommandRouter {
   rpc TaskExecStdioRead(TaskExecStdioReadRequest) returns (stream TaskExecStdioReadResponse);
   // Wait for an exec'd command to exit and return the exit code.
   rpc TaskExecWait(TaskExecWaitRequest) returns (TaskExecWaitResponse);
+  // Mount an image at a directory in the container.
+  rpc TaskMountDirectory(TaskMountDirectoryRequest) returns (google.protobuf.Empty);
+  // Snapshot a directory with a mounted image, including any local changes, into a new image.
+  rpc TaskSnapshotDirectory(TaskSnapshotDirectoryRequest) returns (TaskSnapshotDirectoryResponse);
 }

{modal-1.2.5.dev27 → modal-1.2.6}/modal_proto/task_command_router_grpc.py

@@ -9,6 +9,7 @@ import grpclib.client
 if typing.TYPE_CHECKING:
     import grpclib.server
 
+import google.protobuf.empty_pb2
 import modal_proto.api_pb2
 import modal_proto.task_command_router_pb2
 
@@ -35,6 +36,14 @@ class TaskCommandRouterBase(abc.ABC):
     async def TaskExecWait(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskExecWaitRequest, modal_proto.task_command_router_pb2.TaskExecWaitResponse]') -> None:
         pass
 
+    @abc.abstractmethod
+    async def TaskMountDirectory(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskMountDirectoryRequest, google.protobuf.empty_pb2.Empty]') -> None:
+        pass
+
+    @abc.abstractmethod
+    async def TaskSnapshotDirectory(self, stream: 'grpclib.server.Stream[modal_proto.task_command_router_pb2.TaskSnapshotDirectoryRequest, modal_proto.task_command_router_pb2.TaskSnapshotDirectoryResponse]') -> None:
+        pass
+
     def __mapping__(self) -> typing.Dict[str, grpclib.const.Handler]:
         return {
             '/modal.task_command_router.TaskCommandRouter/TaskExecPoll': grpclib.const.Handler(
@@ -67,6 +76,18 @@ class TaskCommandRouterBase(abc.ABC):
                 modal_proto.task_command_router_pb2.TaskExecWaitRequest,
                 modal_proto.task_command_router_pb2.TaskExecWaitResponse,
             ),
+            '/modal.task_command_router.TaskCommandRouter/TaskMountDirectory': grpclib.const.Handler(
+                self.TaskMountDirectory,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskMountDirectoryRequest,
+                google.protobuf.empty_pb2.Empty,
+            ),
+            '/modal.task_command_router.TaskCommandRouter/TaskSnapshotDirectory': grpclib.const.Handler(
+                self.TaskSnapshotDirectory,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.task_command_router_pb2.TaskSnapshotDirectoryRequest,
+                modal_proto.task_command_router_pb2.TaskSnapshotDirectoryResponse,
+            ),
         }
 
 
@@ -103,3 +124,15 @@ class TaskCommandRouterStub:
             modal_proto.task_command_router_pb2.TaskExecWaitRequest,
             modal_proto.task_command_router_pb2.TaskExecWaitResponse,
         )
+        self.TaskMountDirectory = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskMountDirectory',
+            modal_proto.task_command_router_pb2.TaskMountDirectoryRequest,
+            google.protobuf.empty_pb2.Empty,
+        )
+        self.TaskSnapshotDirectory = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.task_command_router.TaskCommandRouter/TaskSnapshotDirectory',
+            modal_proto.task_command_router_pb2.TaskSnapshotDirectoryRequest,
+            modal_proto.task_command_router_pb2.TaskSnapshotDirectoryResponse,
+        )