modal 1.5.2.dev21__tar.gz → 1.5.3.dev0__tar.gz

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.2.dev21
+Version: 1.5.3.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/_utils/grpc_utils.py

@@ -164,6 +164,9 @@ RETRYABLE_GRPC_STATUS_CODES = [
 ]
 SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
 DEFAULT_MAX_RETRIES = 3
+GRPC_KEEPALIVE_TIME_SECS = 30.0
+GRPC_KEEPALIVE_TIMEOUT_SECS = 10.0
+GRPC_WINDOW_SIZE = 64 * 1024 * 1024  # 64 MiB
 
 
 @dataclass
@@ -251,6 +254,21 @@ class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
 custom_detail_codec = CustomProtoStatusDetailsCodec()
 
 
+def create_channel_config() -> grpclib.config.Configuration:
+    """Shared grpclib channel settings for Modal client connections.
+
+    HTTP/2 keepalive probes keep idle transports warm through stateful
+    middleboxes and surface dead connections before retries reuse them.
+    """
+    return grpclib.config.Configuration(
+        _keepalive_time=GRPC_KEEPALIVE_TIME_SECS,
+        _keepalive_timeout=GRPC_KEEPALIVE_TIMEOUT_SECS,
+        _keepalive_permit_without_calls=True,
+        http2_connection_window_size=GRPC_WINDOW_SIZE,
+        http2_stream_window_size=GRPC_WINDOW_SIZE,
+    )
+
+
 def create_channel(
     server_url: str,
     metadata: dict[str, str] = {},
@@ -262,10 +280,7 @@ def create_channel(
     o = urllib.parse.urlparse(server_url)
 
     channel: grpclib.client.Channel
-    config = grpclib.config.Configuration(
-        http2_connection_window_size=64 * 1024 * 1024,  # 64 MiB
-        http2_stream_window_size=64 * 1024 * 1024,  # 64 MiB
-    )
+    config = create_channel_config()
 
     if o.scheme == "unix":
         channel = grpclib.client.Channel(path=o.path, config=config, status_details_codec=custom_detail_codec)

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/_utils/task_command_router_client.py

@@ -13,7 +13,6 @@ from contextlib import suppress
 from typing import TypeVar
 
 import grpclib.client
-import grpclib.config
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
@@ -23,7 +22,7 @@ from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
 from .._grpc_client import grpc_error_converter
-from .._utils.grpc_utils import ModalChannel
+from .._utils.grpc_utils import ModalChannel, create_channel_config
 from .async_utils import aclosing, retry
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
@@ -222,10 +221,7 @@ class TaskCommandRouterClient:
             host,
             port,
             ssl=ssl_context,
-            config=grpclib.config.Configuration(
-                http2_connection_window_size=64 * 1024 * 1024,  # 64 MiB
-                http2_stream_window_size=64 * 1024 * 1024,  # 64 MiB
-            ),
+            config=create_channel_config(),
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 
@@ -501,16 +497,7 @@ class TaskCommandRouterClient:
             TimeoutError: If the sandbox does not become ready within `timeout`.
         """
         request = sr_pb2.SandboxWaitUntilReadyTcrRequest(task_id=task_id, timeout=timeout)
-        with grpc_error_converter():
-            try:
-                return await asyncio.wait_for(
-                    call_with_retries_on_transient_errors(
-                        lambda: self._call_with_auth_retry(self._stub.SandboxWaitUntilReady, request, timeout=timeout),
-                    ),
-                    timeout=timeout,
-                )
-            except asyncio.TimeoutError:
-                raise ModalTimeoutError("Timeout expired")
+        return await self._unary_call_with_deadline(self._stub.SandboxWaitUntilReady, request, timeout=timeout)
 
     async def exec_poll(self, task_id: str, exec_id: str, deadline: float | None = None) -> sr_pb2.TaskExecPollResponse:
         """Poll for the exit status of an exec'd command, properly retrying on transient errors.
@@ -820,21 +807,14 @@ class TaskCommandRouterClient:
                 window, the call is cancelled and a `modal.exception.TimeoutError` is raised.
         """
         request = sr_pb2.TaskReloadVolumesRequest(task_id=task_id)
-        with grpc_error_converter():
-            try:
-                return await asyncio.wait_for(
-                    call_with_retries_on_transient_errors(
-                        lambda: self._call_with_auth_retry(self._stub.TaskReloadVolumes, request, timeout=timeout),
-                    ),
-                    timeout=timeout,
-                )
-            except asyncio.TimeoutError:
-                raise ModalTimeoutError("Timeout expired")
+        return await self._unary_call_with_deadline(self._stub.TaskReloadVolumes, request, timeout=timeout)
+
+    async def _unary_call_with_deadline(self, rpc, request, *, timeout: float, **kwargs):
+        """Call a unary RPC with transient-error retries bounded by a total deadline.
 
-    async def _snapshot_with_deadline(self, rpc, request, *, timeout: float, **kwargs):
-        # helper method for snapshot_directory and snapshot_filesystem to handle grpc
-        # deadlines in a consistent way, converting any error to TimeoutError after passing
-        # the total deadline budget
+        Raises `modal.exception.TimeoutError` once the deadline has elapsed, or when
+        the server responds with `DEADLINE_EXCEEDED`.
+        """
         timeout_deadline = time.monotonic() + timeout
 
         def call():
@@ -852,17 +832,21 @@ class TaskCommandRouterClient:
                     exclude_status_codes=[Status.DEADLINE_EXCEEDED, Status.CANCELLED],
                     timeout_deadline=timeout_deadline,
                 )
-        except Exception:
-            if time.monotonic() >= timeout_deadline:
+        except Exception as exc:
+            if time.monotonic() >= timeout_deadline or getattr(exc, "_grpc_status", None) == Status.DEADLINE_EXCEEDED:
                 raise ModalTimeoutError("Timeout expired")
             raise
 
     async def snapshot_directory(
         self, request: sr_pb2.TaskSnapshotDirectoryRequest, *, timeout: float, **kwargs
     ) -> sr_pb2.TaskSnapshotDirectoryResponse:
-        return await self._snapshot_with_deadline(self._stub.TaskSnapshotDirectory, request, timeout=timeout, **kwargs)
+        return await self._unary_call_with_deadline(
+            self._stub.TaskSnapshotDirectory, request, timeout=timeout, **kwargs
+        )
 
     async def snapshot_filesystem(
         self, request: sr_pb2.TaskSnapshotFilesystemRequest, *, timeout: float, **kwargs
     ) -> sr_pb2.TaskSnapshotFilesystemResponse:
-        return await self._snapshot_with_deadline(self._stub.TaskSnapshotFilesystem, request, timeout=timeout, **kwargs)
+        return await self._unary_call_with_deadline(
+            self._stub.TaskSnapshotFilesystem, request, timeout=timeout, **kwargs
+        )

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/cli/_help.py

@@ -70,7 +70,13 @@ def _option_label(param: click.Parameter, ctx: click.Context) -> Text:
             text.append(opt, style=_OPTION_FLAG_STYLE)
     if not getattr(param, "is_flag", False) and not getattr(param, "count", False):
         text.append(" ")
-        text.append(param.make_metavar(ctx), style=_OPTION_METAVAR_STYLE)
+        if "ctx" in inspect.signature(click.Parameter.make_metavar).parameters:
+            # click >= 8.2.0
+            metavar = param.make_metavar(ctx)
+        else:
+            # backwards compatibility
+            metavar = param.make_metavar()  # type: ignore[call-arg]
+        text.append(metavar, style=_OPTION_METAVAR_STYLE)
     return text
 
 

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/cli/changelog.py

@@ -120,17 +120,17 @@ def changelog(
 
     Examples:
 
-        ```bash
-        modal changelog --since 1.2.0  # Show updates added after a specific version
+    ```bash
+    modal changelog --since 1.2.0  # Show updates added after a specific version
 
-        modal changelog --since 2026-01-01  # Show updates added after a specific date
+    modal changelog --since 2026-01-01  # Show updates added after a specific date
 
-        modal changelog --newer  # Show updates released after the currently installed version
+    modal changelog --newer  # Show updates released after the currently installed version
 
-        modal changelog --last 3  # Show updates included in the 3 most recent releases
+    modal changelog --last 3  # Show updates included in the 3 most recent releases
 
-        modal changelog --for 1.3.1  # Show the changelog for a specific release
-        ```
+    modal changelog --for 1.3.1  # Show the changelog for a specific release
+    ```
 
     Note: when using `--since` or `--last`, only changes up to the currently installed version are shown.
 

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/cli/environment.py

@@ -242,21 +242,21 @@ async def environment_billing(
 
     Examples:
 
-        ```bash
-        modal environment billing report --start 2025-12-01 --end 2026-01-01
+    ```bash
+    modal environment billing report --start 2025-12-01 --end 2026-01-01
 
-        modal environment billing report --for "last month" --tag-names team,project
+    modal environment billing report --for "last month" --tag-names team,project
 
-        modal environment billing report test_env --for today --resolution h
+    modal environment billing report test_env --for today --resolution h
 
-        modal environment billing report test_env --for "this month" --show-resources
+    modal environment billing report test_env --for "this month" --show-resources
 
-        modal environment billing report prod_env --for yesterday -r h --tz local
+    modal environment billing report prod_env --for yesterday -r h --tz local
 
-        modal environment billing report main_env --for "last month" --csv > report.csv
+    modal environment billing report main_env --for "last month" --csv > report.csv
 
-        modal environment billing report main_env --start 2025-12-01 --json > report.json
-        ```
+    modal environment billing report main_env --start 2025-12-01 --json > report.json
+    ```
 
     """
     if json and csv:

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev21",
+        version: str = "1.5.3.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev21",
+        version: str = "1.5.3.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/functions.pyi

@@ -491,7 +491,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -516,7 +516,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -566,7 +566,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -599,7 +599,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -607,7 +607,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -640,7 +640,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/parallel_map.py

@@ -654,16 +654,14 @@ async def _map_invocation_inputplane(
     stale_retry_duplicates = 0
     already_complete_duplicates = 0
     retried_outputs = 0
-    input_queue_size = 0
     last_entry_id = ""
 
     # The input-plane server returns this after the first request.
     map_token = None
     map_token_received = asyncio.Event()
 
-    # Single priority queue that holds *both* fresh inputs (timestamp == now)
-    # and future retries (timestamp > now).
-    queue: TimestampPriorityQueue[api_pb2.MapStartOrContinueItem] = TimestampPriorityQueue()
+    input_queue: asyncio.Queue[api_pb2.MapStartOrContinueItem | None] = asyncio.Queue()
+    retry_queue: TimestampPriorityQueue[api_pb2.MapStartOrContinueItem] = TimestampPriorityQueue()
 
     # Maximum number of inputs that may be in-flight (the server sends this in
     # the first response – fall back to the default if we never receive it for
@@ -682,7 +680,7 @@ async def _map_invocation_inputplane(
     map_items_manager = _MapItemsManager(
         retry_policy=retry_policy,
         function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
-        retry_queue=queue,
+        retry_queue=retry_queue,
         sync_client_retries_enabled=True,
         max_inputs_outstanding=MAX_INPUTS_OUTSTANDING_DEFAULT,
         is_input_plane_instance=True,
@@ -729,61 +727,67 @@ async def _map_invocation_inputplane(
             async_map_ordered(input_iter(), create_input, concurrency=BLOB_MAX_PARALLELISM)
         ) as streamer:
             async for q_item in streamer:
-                await queue.put(time.time(), q_item)
+                await input_queue.put(q_item)
 
         # All inputs have been read.
+        await input_queue.put(None)
         update_counters(set_have_all_inputs=True)
         yield
 
-    async def pump_inputs():
+    async def send_map_start_or_continue(request_items: list[api_pb2.MapStartOrContinueItem]):
         nonlocal map_token, max_inputs_outstanding
-        async for batch in queue_batch_iterator(queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
-            # Convert the queued items into the proto format expected by the RPC.
-            request_items: list[api_pb2.MapStartOrContinueItem] = [
-                api_pb2.MapStartOrContinueItem(input=qi.input, attempt_token=qi.attempt_token) for qi in batch
-            ]
+        request = api_pb2.MapStartOrContinueRequest(
+            function_id=function.object_id,
+            map_token=map_token or "",
+            parent_input_id=current_input_id() or "",
+            items=request_items,
+        )
 
-            await map_items_manager.add_items_inputplane(request_items)
+        metadata = await client.get_input_plane_metadata(function._input_plane_region)
 
-            # Build request
-            request = api_pb2.MapStartOrContinueRequest(
-                function_id=function.object_id,
-                map_token=map_token,
-                parent_input_id=current_input_id() or "",
-                items=request_items,
-            )
+        response: api_pb2.MapStartOrContinueResponse = await input_plane_stub.MapStartOrContinue(
+            request,
+            retry=Retry(
+                additional_status_codes=[Status.RESOURCE_EXHAUSTED],
+                max_delay=PUMP_INPUTS_MAX_RETRY_DELAY,
+                max_retries=None,
+            ),
+            metadata=metadata,
+        )
 
-            metadata = await client.get_input_plane_metadata(function._input_plane_region)
+        # match response items to the corresponding request item index
+        response_items_idx_tuple = [
+            (request_items[idx].input.idx, attempt_token) for idx, attempt_token in enumerate(response.attempt_tokens)
+        ]
 
-            response: api_pb2.MapStartOrContinueResponse = await input_plane_stub.MapStartOrContinue(
-                request,
-                retry=Retry(
-                    additional_status_codes=[Status.RESOURCE_EXHAUSTED],
-                    max_delay=PUMP_INPUTS_MAX_RETRY_DELAY,
-                    max_retries=None,
-                ),
-                metadata=metadata,
-            )
+        map_items_manager.handle_put_continue_response(response_items_idx_tuple)
 
-            # match response items to the corresponding request item index
-            response_items_idx_tuple = [
-                (request_items[idx].input.idx, attempt_token)
-                for idx, attempt_token in enumerate(response.attempt_tokens)
-            ]
+        # Set the function call id and actual retry policy with the data from the first response.
+        if map_token is None:
+            map_token = response.map_token
+            map_token_received.set()
+            max_inputs_outstanding = response.max_inputs_outstanding or MAX_INPUTS_OUTSTANDING_DEFAULT
+            map_items_manager.set_retry_policy(response.retry_policy)
+            # Update the retry policy for the first batch of inputs.
+            # Subsequent batches will have the correct user-specified retry policy
+            # set by the updated _MapItemsManager.
+            map_items_manager.update_items_retry_policy(response.retry_policy)
 
-            map_items_manager.handle_put_continue_response(response_items_idx_tuple)
+    async def pump_inputs():
+        async for batch in queue_batch_iterator(input_queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
+            request_items: list[api_pb2.MapStartOrContinueItem] = list(batch)
+            await map_items_manager.add_items_inputplane(request_items)
+            await send_map_start_or_continue(request_items)
+        yield
 
-            # Set the function call id and actual retry policy with the data from the first response.
-            # This conditional is skipped for subsequent iterations of this for-loop.
-            if map_token is None:
-                map_token = response.map_token
-                map_token_received.set()
-                max_inputs_outstanding = response.max_inputs_outstanding or MAX_INPUTS_OUTSTANDING_DEFAULT
-                map_items_manager.set_retry_policy(response.retry_policy)
-                # Update the retry policy for the first batch of inputs.
-                # Subsequent batches will have the correct user-specified retry policy
-                # set by the updated _MapItemsManager.
-                map_items_manager.update_items_retry_policy(response.retry_policy)
+    async def retry_inputs():
+        while True:
+            retry_item = await retry_queue.get()
+            if retry_item is None:
+                break
+            request_items = [retry_item]
+            await map_items_manager.add_items_inputplane(request_items)
+            await send_map_start_or_continue(request_items)
         yield
 
     async def check_lost_inputs():
@@ -897,8 +901,8 @@ async def _map_invocation_inputplane(
                 async for item in stream:
                     yield item
         finally:
-            await queue.close()
-            pass
+            await input_queue.put(None)
+            await retry_queue.close()
 
     async def fetch_output(item: api_pb2.FunctionGetOutputsItem) -> tuple[int, Any]:
         try:
@@ -945,7 +949,8 @@ async def _map_invocation_inputplane(
                 f"no_context_duplicates={no_context_duplicates} stale_retry_duplicates={stale_retry_duplicates} "
                 f"already_complete_duplicates={already_complete_duplicates} retried_outputs={retried_outputs} "
                 f"map_token={map_token} max_inputs_outstanding={max_inputs_outstanding} "
-                f"map_items_manager_size={len(map_items_manager)} input_queue_size={input_queue_size}"
+                f"map_items_manager_size={len(map_items_manager)} input_queue_size={input_queue.qsize()} "
+                f"retry_queue_size={retry_queue.qsize()}"
             )
 
         while True:
@@ -960,7 +965,7 @@ async def _map_invocation_inputplane(
     log_task = asyncio.create_task(log_debug_stats())
 
     async with aclosing(
-        async_merge(drain_input_generator(), pump_inputs(), poll_outputs(), check_lost_inputs())
+        async_merge(drain_input_generator(), pump_inputs(), retry_inputs(), poll_outputs(), check_lost_inputs())
     ) as merged:
         async for maybe_output in merged:
             if maybe_output is not None:  # ignore None sentinels

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/sandbox.py

@@ -816,6 +816,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         *args: str,
         app: "modal.app._App | None" = None,
         name: str | None = None,
+        tags: dict[str, str] | None = None,
         image: _Image | None = None,
         env: dict[str, str | None] | None = None,
         secrets: Collection[_Secret] | None = None,
@@ -851,7 +852,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
         filesystem snapshots.
 
-        Features like tags, memory snapshots, network file systems, GPUs, and custom
+        Features like memory snapshots, network file systems, GPUs, and custom
         domains are not supported.
 
         Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -993,10 +994,12 @@ class _Sandbox(_Object, type_prefix="sb"):
                 ),
             )
 
+            tag_protos = [api_pb2.SandboxTag(tag_name=k, tag_value=v) for k, v in tags.items()] if tags else []
             create_req = api_pb2.SandboxCreateV2Request(
                 app_id=load_context.app_id,
                 definition=definition,
                 ephemeral_secrets=api_pb2.StringMap(contents=env_dict) if env_dict else None,
+                tags=tag_protos,
             )
             assert load_context.client._auth_token_manager
             auth_token = await load_context.client._auth_token_manager.get_token()
@@ -1267,22 +1270,27 @@ class _Sandbox(_Object, type_prefix="sb"):
         Returns:
             Tags as a map from tag name to tag value.
         """
-        self._ensure_v1("get_tags")
         req = api_pb2.SandboxTagsGetRequest(sandbox_id=self.object_id)
-        resp = await self._client.stub.SandboxTagsGet(req)
+        stub = self._client.stub
+        if self._is_v2:
+            assert self._client._auth_token_manager
+            auth_token = await self._client._auth_token_manager.get_token()
+            resp = await stub.SandboxTagsGetV2(req, metadata=[("x-modal-auth-token", auth_token)])
+        else:
+            resp = await stub.SandboxTagsGet(req)
 
         return {tag.tag_name: tag.tag_value for tag in resp.tags}
 
     async def set_tags(self, tags: dict[str, str], *, client: _Client | None = None) -> None:
         """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+        Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
         Args:
             tags: Tag names and values to set on this sandbox.
             client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
 
         """
-        self._ensure_v1("set_tags")
-        environment_name = _get_environment_name()
         if client is not None:
             deprecation_warning(
                 (2025, 9, 18),
@@ -1291,13 +1299,19 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
 
         tags_list = [api_pb2.SandboxTag(tag_name=name, tag_value=value) for name, value in tags.items()]
-
-        req = api_pb2.SandboxTagsSetRequest(
-            environment_name=environment_name,
-            sandbox_id=self.object_id,
-            tags=tags_list,
-        )
-        await self._client.stub.SandboxTagsSet(req)
+        stub = self._client.stub
+        if self._is_v2:
+            assert self._client._auth_token_manager
+            auth_token = await self._client._auth_token_manager.get_token()
+            req = api_pb2.SandboxTagsSetRequest(sandbox_id=self.object_id, tags=tags_list)
+            await stub.SandboxTagsSetV2(req, metadata=[("x-modal-auth-token", auth_token)])
+        else:
+            req = api_pb2.SandboxTagsSetRequest(
+                environment_name=_get_environment_name(),
+                sandbox_id=self.object_id,
+                tags=tags_list,
+            )
+            await stub.SandboxTagsSet(req)
 
     async def _experimental_set_outbound_network_policy(
         self,

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal/sandbox.pyi

@@ -361,6 +361,7 @@ class _Sandbox(modal._object._Object):
         *args: str,
         app: typing.Optional[modal.app._App] = None,
         name: typing.Optional[str] = None,
+        tags: typing.Optional[dict[str, str]] = None,
         image: typing.Optional[modal._image._Image] = None,
         env: typing.Optional[dict[str, typing.Optional[str]]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
@@ -399,7 +400,7 @@ class _Sandbox(modal._object._Object):
         `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
         filesystem snapshots.
 
-        Features like tags, memory snapshots, network file systems, GPUs, and custom
+        Features like memory snapshots, network file systems, GPUs, and custom
         domains are not supported.
 
         Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -518,6 +519,8 @@ class _Sandbox(modal._object._Object):
     async def set_tags(self, tags: dict[str, str], *, client: typing.Optional[modal.client._Client] = None) -> None:
         """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+        Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
         Args:
             tags: Tag names and values to set on this sandbox.
             client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
@@ -1711,6 +1714,7 @@ class Sandbox(modal.object.Object):
             *args: str,
             app: typing.Optional[modal.app.App] = None,
             name: typing.Optional[str] = None,
+            tags: typing.Optional[dict[str, str]] = None,
             image: typing.Optional[modal.image.Image] = None,
             env: typing.Optional[dict[str, typing.Optional[str]]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
@@ -1749,7 +1753,7 @@ class Sandbox(modal.object.Object):
             `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
             filesystem snapshots.
 
-            Features like tags, memory snapshots, network file systems, GPUs, and custom
+            Features like memory snapshots, network file systems, GPUs, and custom
             domains are not supported.
 
             Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -1772,6 +1776,7 @@ class Sandbox(modal.object.Object):
             *args: str,
             app: typing.Optional[modal.app.App] = None,
             name: typing.Optional[str] = None,
+            tags: typing.Optional[dict[str, str]] = None,
             image: typing.Optional[modal.image.Image] = None,
             env: typing.Optional[dict[str, typing.Optional[str]]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
@@ -1810,7 +1815,7 @@ class Sandbox(modal.object.Object):
             `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
             filesystem snapshots.
 
-            Features like tags, memory snapshots, network file systems, GPUs, and custom
+            Features like memory snapshots, network file systems, GPUs, and custom
             domains are not supported.
 
             Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
@@ -2035,6 +2040,8 @@ class Sandbox(modal.object.Object):
         def __call__(self, /, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None) -> None:
             """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+            Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
             Args:
                 tags: Tag names and values to set on this sandbox.
                 client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.
@@ -2044,6 +2051,8 @@ class Sandbox(modal.object.Object):
         async def aio(self, /, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None) -> None:
             """Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
 
+            Setting tags replaces the Sandbox's entire tag set; passing an empty dict clears all tags.
+
             Args:
                 tags: Tag names and values to set on this sandbox.
                 client: Deprecated. Prefer setting the client when creating or re-attaching to the sandbox.

{modal-1.5.2.dev21 → modal-1.5.3.dev0}/modal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.2.dev21
+Version: 1.5.3.dev0
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0