modal 1.6.1.dev3__tar.gz → 1.6.2.dev0__tar.gz

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/PKG-INFO

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

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal/_utils/task_command_router_client.py

@@ -226,6 +226,7 @@ async def fetch_command_router_access_v2(
     *,
     sandbox_id: str | None = None,
     task_id: str | None = None,
+    sandbox_token: str | None = None,
 ) -> api_pb2.SandboxGetCommandRouterAccessResponse:
     """Fetch direct command router access info from Modal server for a V2 sandbox."""
     if sandbox_id is not None:
@@ -236,10 +237,10 @@ async def fetch_command_router_access_v2(
         raise ValueError("Either sandbox_id or task_id must be provided")
     assert server_client._auth_token_manager
     auth_token = await server_client._auth_token_manager.get_token()
-    return await server_client._stub.SandboxGetCommandRouterAccess(
-        request,
-        metadata=[("x-modal-auth-token", auth_token)],
-    )
+    metadata = [("x-modal-auth-token", auth_token)]
+    if sandbox_token:
+        metadata.append(("x-modal-sandbox-token", sandbox_token))
+    return await server_client._stub.SandboxGetCommandRouterAccess(request, metadata=metadata)
 
 
 def _finalize_channel(loop, channel):
@@ -267,6 +268,7 @@ class TaskCommandRouterClient:
         jwt: str,
         *,
         sandbox_id: str | None = None,
+        sandbox_token: str | None = None,
     ) -> "TaskCommandRouterClient":
         """Build a connected client from a jwt and url."""
         o = urllib.parse.urlparse(url)
@@ -315,7 +317,17 @@ class TaskCommandRouterClient:
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 
-        client = cls(server_client, task_id, url, jwt, channel, loop, jwt_refresh_lock, sandbox_id=sandbox_id)
+        client = cls(
+            server_client,
+            task_id,
+            url,
+            jwt,
+            channel,
+            loop,
+            jwt_refresh_lock,
+            sandbox_id=sandbox_id,
+            sandbox_token=sandbox_token,
+        )
         # An unused client releases its connection too.
         client._arm_idle_release()
         return client
@@ -337,6 +349,8 @@ class TaskCommandRouterClient:
         sandbox_id: str,
         task_id: str,
         access: api_pb2.CommandRouterAccess | None = None,
+        *,
+        sandbox_token: str | None = None,
     ) -> "TaskCommandRouterClient":
         """Initialize a TaskCommandRouterClient for a V2 sandbox.
 
@@ -348,10 +362,12 @@ class TaskCommandRouterClient:
         if access is not None:
             url, jwt = access.url, access.jwt
         else:
-            resp = await fetch_command_router_access_v2(server_client, sandbox_id=sandbox_id)
+            resp = await fetch_command_router_access_v2(
+                server_client, sandbox_id=sandbox_id, sandbox_token=sandbox_token
+            )
             url, jwt = resp.url, resp.jwt
         logger.debug(f"Using command router access for sandbox {sandbox_id}")
-        return await cls._connect(server_client, task_id, url, jwt, sandbox_id=sandbox_id)
+        return await cls._connect(server_client, task_id, url, jwt, sandbox_id=sandbox_id, sandbox_token=sandbox_token)
 
     @classmethod
     async def init_v2_by_task_id(
@@ -375,6 +391,7 @@ class TaskCommandRouterClient:
         jwt_refresh_lock: asyncio.Lock,
         *,
         sandbox_id: str | None = None,
+        sandbox_token: str | None = None,
         stream_stdio_retry_delay_secs: float = 0.01,
         stream_stdio_retry_delay_factor: float = 2,
         stream_stdio_max_retries: int = 10,
@@ -388,6 +405,7 @@ class TaskCommandRouterClient:
         self._server_client = server_client
         self._task_id = task_id
         self._sandbox_id = sandbox_id
+        self._sandbox_token = sandbox_token
         self._server_url = server_url
         self._jwt = jwt
         self._channel = channel
@@ -902,7 +920,10 @@ class TaskCommandRouterClient:
             if self._is_v2_sandbox:
                 logger.debug(f"Refreshing JWT for V2 exec with task ID {self._task_id}")
                 v2_resp = await fetch_command_router_access_v2(
-                    self._server_client, sandbox_id=self._sandbox_id, task_id=self._task_id
+                    self._server_client,
+                    sandbox_id=self._sandbox_id,
+                    task_id=self._task_id,
+                    sandbox_token=self._sandbox_token,
                 )
                 logger.debug(f"Finished refreshing JWT for V2 exec with task ID {self._task_id}")
                 jwt, url = v2_resp.jwt, v2_resp.url

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal/client.pyi

@@ -80,7 +80,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.1.dev3",
+        version: str = "1.6.2.dev0",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -290,7 +290,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.1.dev3",
+        version: str = "1.6.2.dev0",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal/functions.pyi

@@ -613,7 +613,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.
 
@@ -638,7 +638,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]:
@@ -688,7 +688,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.
 
@@ -721,7 +721,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: ...
@@ -729,7 +729,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.
 
@@ -762,7 +762,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     @property
     def _raw_f_(self) -> collections.abc.Callable[..., typing.Any]: ...

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal/sandbox.py

@@ -1180,6 +1180,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             self._hydrate(sandbox_id, load_context.client, create_resp.metadata)
             self._is_v2 = True
             self._task_id = create_resp.task_id
+            self._sandbox_token = create_resp.sandbox_token or None
             # An unset proto message reads as an empty one rather than None, so the
             # presence check is what distinguishes "no access" from "empty access".
             if create_resp.HasField("command_router_access"):
@@ -1208,6 +1209,15 @@ class _Sandbox(_Object, type_prefix="sb"):
             await resolver.load(obj, load_context)
         return obj
 
+    async def _v2_metadata(self, client: _Client | None = None) -> list[tuple[str, str]]:
+        client = client if client is not None else self._client
+        assert client._auth_token_manager
+        auth_token = await client._auth_token_manager.get_token()
+        metadata = [("x-modal-auth-token", auth_token)]
+        if self._sandbox_token:
+            metadata.append(("x-modal-sandbox-token", self._sandbox_token))
+        return metadata
+
     def _get_metadata(self) -> api_pb2.SandboxHandleMetadata:
         metadata = api_pb2.SandboxHandleMetadata(app_id=self._app_id or "")
         if hasattr(self, "_result") and self._result is not None:
@@ -1242,6 +1252,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         )
         self._stdin = StreamWriter(_StreamWriterThroughServerParams(object_id=self.object_id, client=self._client))
         self._task_id = None
+        self._sandbox_token = None
         self._tunnels = None
         self._enable_snapshot = False
         self._command_router_client = None
@@ -1463,9 +1474,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         req = api_pb2.SandboxTagsGetRequest(sandbox_id=self.object_id)
         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)])
+            resp = await stub.SandboxTagsGetV2(req, metadata=await self._v2_metadata())
         else:
             resp = await stub.SandboxTagsGet(req)
 
@@ -1491,10 +1500,8 @@ class _Sandbox(_Object, type_prefix="sb"):
         tags_list = [api_pb2.SandboxTag(tag_name=name, tag_value=value) for name, value in tags.items()]
         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)])
+            await stub.SandboxTagsSetV2(req, metadata=await self._v2_metadata())
         else:
             req = api_pb2.SandboxTagsSetRequest(
                 environment_name=_get_environment_name(),
@@ -1526,9 +1533,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         check_object_name(name, "Sandbox")
 
         req = api_pb2.SandboxSetNameRequest(sandbox_id=self.object_id, name=name)
-        assert self._client._auth_token_manager
-        auth_token = await self._client._auth_token_manager.get_token()
-        await self._client._stub.SandboxSetName(req, metadata=[("x-modal-auth-token", auth_token)])
+        await self._client._stub.SandboxSetName(req, metadata=await self._v2_metadata())
 
     async def _experimental_set_outbound_network_policy(
         self,
@@ -1643,13 +1648,10 @@ class _Sandbox(_Object, type_prefix="sb"):
                 total_timeout=remaining,
             )
             resp: api_pb2.SandboxGetExitSnapshotResponse
-            if self._is_v2:
-                assert client._auth_token_manager
-                auth_token = await client._auth_token_manager.get_token()
             try:
                 if self._is_v2:
                     resp = await client._stub.SandboxGetExitSnapshotV2(
-                        req, retry=poll_retry, metadata=[("x-modal-auth-token", auth_token)]
+                        req, retry=poll_retry, metadata=await self._v2_metadata(client)
                     )
                 else:
                     resp = await client._stub.SandboxGetExitSnapshot(req, retry=poll_retry)
@@ -1876,9 +1878,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             # Use the private __client to allow `wait` to work with a detached sandbox
             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.SandboxWaitV2(req, metadata=[("x-modal-auth-token", auth_token)])
+                resp = await stub.SandboxWaitV2(req, metadata=await self._v2_metadata(self.__client))
             else:
                 resp = await stub.SandboxWait(req)
             if resp.result.status:
@@ -1947,9 +1947,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         req = api_pb2.SandboxGetTunnelsRequest(sandbox_id=self.object_id, timeout=timeout)
         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.SandboxGetTunnelsV2(req, metadata=[("x-modal-auth-token", auth_token)])
+            resp = await stub.SandboxGetTunnelsV2(req, metadata=await self._v2_metadata())
         else:
             resp = await stub.SandboxGetTunnels(req)
 
@@ -1993,11 +1991,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             sandbox_id=self.object_id, user_metadata=user_metadata, port=port
         )
         if self._is_v2:
-            assert self._client._auth_token_manager
-            auth_token = await self._client._auth_token_manager.get_token()
-            resp = await self._client._stub.SandboxCreateConnectTokenV2(
-                req, metadata=[("x-modal-auth-token", auth_token)]
-            )
+            resp = await self._client._stub.SandboxCreateConnectTokenV2(req, metadata=await self._v2_metadata())
         else:
             resp = await self._client._stub.SandboxCreateConnectToken(req)
         return SandboxConnectCredentials(resp.url, resp.token)
@@ -2055,9 +2049,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         req = api_pb2.SandboxTerminateRequest(sandbox_id=self.object_id)
         stub = self._client._stub
         if self._is_v2:
-            assert self._client._auth_token_manager
-            auth_token = await self._client._auth_token_manager.get_token()
-            await stub.SandboxTerminateV2(req, metadata=[("x-modal-auth-token", auth_token)])
+            await stub.SandboxTerminateV2(req, metadata=await self._v2_metadata())
         else:
             await stub.SandboxTerminate(req)
         if wait:
@@ -2074,9 +2066,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         req = api_pb2.SandboxWaitRequest(sandbox_id=self.object_id, timeout=0)
         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.SandboxWaitV2(req, metadata=[("x-modal-auth-token", auth_token)])
+            resp = await stub.SandboxWaitV2(req, metadata=await self._v2_metadata())
         else:
             resp = await stub.SandboxWait(req)
 
@@ -2094,9 +2084,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             stub = self._client._stub
             try:
                 if self._is_v2:
-                    assert self._client._auth_token_manager
-                    auth_token = await self._client._auth_token_manager.get_token()
-                    resp = await stub.SandboxGetTaskIdV2(req, metadata=[("x-modal-auth-token", auth_token)])
+                    resp = await stub.SandboxGetTaskIdV2(req, metadata=await self._v2_metadata())
                 else:
                     resp = await stub.SandboxGetTaskId(req)
             except (ServiceError, InternalError, ConnectionError) as exc:
@@ -2136,9 +2124,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         req = api_pb2.SandboxGetTaskIdRequest(sandbox_id=self.object_id)
         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.SandboxGetTaskIdV2(req, metadata=[("x-modal-auth-token", auth_token)])
+            resp = await stub.SandboxGetTaskIdV2(req, metadata=await self._v2_metadata(self.__client))
         else:
             resp = await stub.SandboxGetTaskId(req)
         if not resp.task_id:
@@ -2165,7 +2151,7 @@ class _Sandbox(_Object, type_prefix="sb"):
                     # re-trying the same credentials forever.
                     access, self._init_command_router_access = self._init_command_router_access, None
                     command_router_client = await TaskCommandRouterClient.init_v2_by_sandbox_id(
-                        self._client, self.object_id, task_id, access
+                        self._client, self.object_id, task_id, access, sandbox_token=self._sandbox_token
                     )
                 else:
                     command_router_client = await TaskCommandRouterClient.init(self._client, task_id)
@@ -3289,10 +3275,8 @@ class _SidecarManager:
                 cloud_bucket_mount_credentials=cloud_bucket_credentials,
             )
             client = self._sandbox._client
-            assert client._auth_token_manager
-            auth_token = await client._auth_token_manager.get_token()
             create_resp = await client._stub.SandboxContainerCreateV2(
-                create_req, metadata=[("x-modal-auth-token", auth_token)]
+                create_req, metadata=await self._sandbox._v2_metadata(client)
             )
         else:
             task_id, command_router_client = await self._get_command_router()

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal/sandbox.pyi

@@ -466,6 +466,7 @@ class _Sandbox(modal._object._Object):
         """
         ...
 
+    async def _v2_metadata(self, client: typing.Optional[modal.client._Client] = None) -> list[tuple[str, str]]: ...
     def _get_metadata(self) -> modal_proto.api_pb2.SandboxHandleMetadata: ...
     def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]) -> None: ...
     def _hydrate_metadata_v2(self) -> None:
@@ -2492,6 +2493,12 @@ class Sandbox(modal.object.Object):
 
     _experimental_create: typing.ClassVar[___experimental_create_spec]
 
+    class ___v2_metadata_spec(typing_extensions.Protocol):
+        def __call__(self, /, client: typing.Optional[modal.client.Client] = None) -> list[tuple[str, str]]: ...
+        async def aio(self, /, client: typing.Optional[modal.client.Client] = None) -> list[tuple[str, str]]: ...
+
+    _v2_metadata: ___v2_metadata_spec
+
     def _get_metadata(self) -> modal_proto.api_pb2.SandboxHandleMetadata: ...
     def _hydrate_metadata(self, handle_metadata: typing.Optional[google.protobuf.message.Message]) -> None: ...
     def _hydrate_metadata_v2(self) -> None:

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal.egg-info/PKG-INFO

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

{modal-1.6.1.dev3 → modal-1.6.2.dev0}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2026
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.6.1.dev3"
+__version__ = "1.6.2.dev0"