modal 1.5.3.dev3__tar.gz → 1.5.3.dev4__tar.gz

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/PKG-INFO

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

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/_container_entrypoint.py

@@ -145,7 +145,7 @@ def call_function(
                             item_count += 1
 
                 await container_io_manager._send_outputs.aio(
-                    started_at, io_context.output_items_generator_done(started_at, item_count)
+                    io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
                 value = await io_context.call_function_async()
@@ -182,9 +182,7 @@ def call_function(
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                container_io_manager._send_outputs(
-                    started_at, io_context.output_items_generator_done(started_at, item_count)
-                )
+                container_io_manager._send_outputs(io_context.output_items_generator_done(started_at, item_count))
             else:
                 values = io_context.call_function_sync()
                 container_io_manager.push_outputs(io_context, started_at, values)

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/_runtime/container_io_manager.py

@@ -1,7 +1,6 @@
 # Copyright Modal Labs 2024
 import asyncio
 import inspect
-import math
 import sys
 import time
 import traceback
@@ -48,8 +47,6 @@ DYNAMIC_CONCURRENCY_INTERVAL_SECS = 3
 DYNAMIC_CONCURRENCY_TIMEOUT_SECS = 10
 MAX_OUTPUT_BATCH_SIZE: int = 49
 
-RTT_S: float = 0.5  # conservative estimate of RTT in seconds.
-
 
 class Sentinel:
     """Used to get type-stubs to work with this object."""
@@ -474,8 +471,6 @@ class _ContainerIOManager:
     _task_lifecycle_manager: _TaskLifecycleManager
     input_plane_server_url: str | None
 
-    calls_completed: int
-    total_user_time: float
     current_input_id: str | None
     current_inputs: dict[str, IOContext]  # input_id -> IOContext
     current_input_started_at: float | None
@@ -510,8 +505,6 @@ class _ContainerIOManager:
 
         self.input_plane_server_url = container_args.input_plane_server_url
 
-        self.calls_completed = 0
-        self.total_user_time = 0.0
         self.current_input_id = None
         self.current_inputs = {}
         self.current_input_started_at = None
@@ -791,18 +784,6 @@ class _ContainerIOManager:
         """Put a value onto a queue, using the synchronicity event loop."""
         await queue.put(value)
 
-    def get_average_call_time(self) -> float:
-        if self.calls_completed == 0:
-            return 0
-
-        return self.total_user_time / self.calls_completed
-
-    def get_max_inputs_to_fetch(self):
-        if self.calls_completed == 0:
-            return 1
-
-        return math.ceil(RTT_S / max(self.get_average_call_time(), 1e-6))
-
     @synchronizer.no_io_translation
     async def _generate_inputs(
         self,
@@ -814,8 +795,6 @@ class _ContainerIOManager:
         while self._fetching_inputs:
             await self._input_slots.acquire()
 
-            request.average_call_time = self.get_average_call_time()
-            request.max_values = self.get_max_inputs_to_fetch()  # Deprecated; remove.
             request.input_concurrency = self.get_input_concurrency()
             request.batch_max_size, request.batch_linger_ms = batch_max_size, batch_wait_ms
 
@@ -888,7 +867,7 @@ class _ContainerIOManager:
             # collect all active input slots, meaning all inputs have wrapped up.
             await self._input_slots.close()
 
-    async def _send_outputs(self, started_at: float, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(self, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
         """Send pre-built output items with retry and chunking."""
         # There are multiple outputs for a single IOContext in the case of @modal.batched.
         # Limit the batch size to 20 to stay within message size limits and buffer size limits.
@@ -902,7 +881,7 @@ class _ContainerIOManager:
                 ),
             )
         input_ids = [output.input_id for output in outputs]
-        self.exit_context(started_at, input_ids)
+        self.exit_context(input_ids)
 
     @asynccontextmanager
     async def handle_input_exception(
@@ -922,7 +901,7 @@ class _ContainerIOManager:
             raise
         except (InputCancellation, asyncio.CancelledError):
             outputs = await io_context.output_items_cancellation(started_at)
-            await self._send_outputs(started_at, outputs)
+            await self._send_outputs(outputs)
             logger.warning(f"Successfully canceled input {io_context.input_ids}")
             return
         except BaseException as exc:
@@ -933,12 +912,9 @@ class _ContainerIOManager:
             # print exception so it's logged
             print_exception(*sys.exc_info())
             outputs = await io_context.output_items_exception(started_at, self.task_id, exc)
-            await self._send_outputs(started_at, outputs)
-
-    def exit_context(self, started_at, input_ids: list[str]):
-        self.total_user_time += time.time() - started_at
-        self.calls_completed += 1
+            await self._send_outputs(outputs)
 
+    def exit_context(self, input_ids: list[str]):
         for input_id in input_ids:
             self.current_inputs.pop(input_id)
 
@@ -954,7 +930,7 @@ class _ContainerIOManager:
     ) -> None:
         # The standard output encoding+sending method for successful function outputs
         outputs = await io_context.output_items(started_at, output_data)
-        await self._send_outputs(started_at, outputs)
+        await self._send_outputs(outputs)
 
     @asynccontextmanager
     async def snapshot_context_manager(self) -> AsyncGenerator[None, None]:

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/_runtime/container_io_manager.pyi

@@ -100,8 +100,6 @@ class _ContainerIOManager:
     app_id: str
     _task_lifecycle_manager: modal._runtime.task_lifecycle_manager._TaskLifecycleManager
     input_plane_server_url: typing.Optional[str]
-    calls_completed: int
-    total_user_time: float
     current_input_id: typing.Optional[str]
     current_inputs: dict[str, IOContext]
     current_input_started_at: typing.Optional[float]
@@ -185,8 +183,6 @@ class _ContainerIOManager:
         """Put a value onto a queue, using the synchronicity event loop."""
         ...
 
-    def get_average_call_time(self) -> float: ...
-    def get_max_inputs_to_fetch(self): ...
     def _generate_inputs(
         self, batch_max_size: int, batch_wait_ms: int
     ) -> collections.abc.AsyncIterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
@@ -196,7 +192,7 @@ class _ContainerIOManager:
         batch_max_size: int = 0,
         batch_wait_ms: int = 0,
     ) -> collections.abc.AsyncIterator[IOContext]: ...
-    async def _send_outputs(self, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(self, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
         """Send pre-built output items with retry and chunking."""
         ...
 
@@ -204,7 +200,7 @@ class _ContainerIOManager:
         """Handle an exception while processing a function input."""
         ...
 
-    def exit_context(self, started_at, input_ids: list[str]): ...
+    def exit_context(self, input_ids: list[str]): ...
     async def push_outputs(self, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
     def snapshot_context_manager(self) -> typing.AsyncContextManager[None]: ...
     async def interact(self, from_breakpoint: bool = False): ...
@@ -246,8 +242,6 @@ class ContainerIOManager:
     app_id: str
     _task_lifecycle_manager: modal._runtime.task_lifecycle_manager.TaskLifecycleManager
     input_plane_server_url: typing.Optional[str]
-    calls_completed: int
-    total_user_time: float
     current_input_id: typing.Optional[str]
     current_inputs: dict[str, IOContext]
     current_input_started_at: typing.Optional[float]
@@ -413,9 +407,6 @@ class ContainerIOManager:
 
     _queue_put: ___queue_put_spec
 
-    def get_average_call_time(self) -> float: ...
-    def get_max_inputs_to_fetch(self): ...
-
     class ___generate_inputs_spec(typing_extensions.Protocol):
         def __call__(
             self, /, batch_max_size: int, batch_wait_ms: int
@@ -445,11 +436,11 @@ class ContainerIOManager:
     run_inputs_outputs: __run_inputs_outputs_spec
 
     class ___send_outputs_spec(typing_extensions.Protocol):
-        def __call__(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        def __call__(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
-        async def aio(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        async def aio(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
@@ -468,7 +459,7 @@ class ContainerIOManager:
 
     handle_input_exception: __handle_input_exception_spec
 
-    def exit_context(self, started_at, input_ids: list[str]): ...
+    def exit_context(self, input_ids: list[str]): ...
 
     class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
@@ -517,5 +508,3 @@ class ContainerIOManager:
     def stop_fetching_inputs(cls): ...
 
 MAX_OUTPUT_BATCH_SIZE: int
-
-RTT_S: float

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/client.py

@@ -6,7 +6,7 @@ import sys
 import urllib.parse
 import warnings
 from collections.abc import AsyncGenerator, Collection, Mapping
-from typing import Any, ClassVar, TypeVar
+from typing import Any, ClassVar, Coroutine, TypeVar
 
 import grpclib.client
 from google.protobuf import empty_pb2
@@ -41,7 +41,7 @@ def _get_metadata(client_type: int, credentials: tuple[str, str] | None, version
     # sys.version_info is structured unlike sys.version or platform.python_version()
     python_version = "%d.%d.%d" % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
 
-    metadata = {
+    metadata: dict[str, str] = {
         "x-modal-client-version": version,
         "x-modal-client-type": str(client_type),
         "x-modal-python-version": python_version,
@@ -58,9 +58,15 @@ def _get_metadata(client_type: int, credentials: tuple[str, str] | None, version
         )
     if agent_env := _agent_environment():
         metadata["x-modal-agent-harness"] = urllib.parse.quote(agent_env)
+
+    override_headers = config.get("override_headers")
+    if override_headers:
+        metadata.update(override_headers)
+
     return metadata
 
 
+T = TypeVar("T")
 ReturnType = TypeVar("ReturnType")
 _Value = str | bytes
 _MetadataLike = Mapping[str, _Value] | Collection[tuple[str, _Value]]
@@ -308,7 +314,7 @@ class _Client:
             ("x-modal-auth-token", token),
         ]
 
-    async def _call_safely(self, coro, readable_method: str):
+    async def _call_safely(self, coro: Coroutine[Any, Any, T], readable_method: str) -> T:
         """Runs coroutine wrapped in a task that's part of the client's task context
 
         * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -364,11 +370,11 @@ class _Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: Any,
+        request: RequestType,
         *,
         timeout: float | None = None,
         metadata: _MetadataLike | None = None,
-    ) -> Any:
+    ) -> ResponseType:
         coro = grpclib_method(request, timeout=timeout, metadata=metadata)
         return await self._call_safely(coro, grpclib_method.name)
 
@@ -376,10 +382,10 @@ class _Client:
     async def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: Any,
+        request: RequestType,
         *,
         metadata: _MetadataLike | None,
-    ) -> AsyncGenerator[Any, None]:
+    ) -> AsyncGenerator[ResponseType, None]:
         stream_context = grpclib_method.open(metadata=metadata)
         stream = await self._call_safely(stream_context.__aenter__(), f"{grpclib_method.name}.open")
         try:

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/client.pyi

@@ -13,6 +13,8 @@ import typing_extensions
 
 def _get_metadata(client_type: int, credentials: typing.Optional[tuple[str, str]], version: str) -> dict[str, str]: ...
 
+T = typing.TypeVar("T")
+
 ReturnType = typing.TypeVar("ReturnType")
 
 RequestType = typing.TypeVar("RequestType", bound="google.protobuf.message.Message")
@@ -35,7 +37,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev3",
+        version: str = "1.5.3.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -154,7 +156,7 @@ class _Client:
         """
         ...
 
-    async def _call_safely(self, coro, readable_method: str):
+    async def _call_safely(self, coro: typing.Coroutine[typing.Any, typing.Any, T], readable_method: str) -> T:
         """Runs coroutine wrapped in a task that's part of the client's task context
 
         * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -168,7 +170,7 @@ class _Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         timeout: typing.Optional[float] = None,
         metadata: typing.Union[
@@ -176,18 +178,18 @@ class _Client:
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ] = None,
-    ) -> typing.Any: ...
+    ) -> ResponseType: ...
     def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         metadata: typing.Union[
             collections.abc.Mapping[str, typing.Union[str, bytes]],
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ],
-    ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
+    ) -> collections.abc.AsyncGenerator[ResponseType, None]: ...
 
 class Client:
     _client_from_env: typing.ClassVar[typing.Optional[Client]]
@@ -205,7 +207,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev3",
+        version: str = "1.5.3.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -429,7 +431,7 @@ class Client:
     get_input_plane_metadata: __get_input_plane_metadata_spec
 
     class ___call_safely_spec(typing_extensions.Protocol):
-        def __call__(self, /, coro, readable_method: str):
+        def __call__(self, /, coro: T, readable_method: str) -> T:
             """Runs coroutine wrapped in a task that's part of the client's task context
 
             * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -438,7 +440,7 @@ class Client:
             """
             ...
 
-        async def aio(self, /, coro, readable_method: str):
+        async def aio(self, /, coro: typing.Coroutine[typing.Any, typing.Any, T], readable_method: str) -> T:
             """Runs coroutine wrapped in a task that's part of the client's task context
 
             * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -464,7 +466,7 @@ class Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         timeout: typing.Optional[float] = None,
         metadata: typing.Union[
@@ -472,18 +474,18 @@ class Client:
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ] = None,
-    ) -> typing.Any: ...
+    ) -> ResponseType: ...
     def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         metadata: typing.Union[
             collections.abc.Mapping[str, typing.Union[str, bytes]],
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ],
-    ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
+    ) -> collections.abc.AsyncGenerator[ResponseType, None]: ...
 
 HEARTBEAT_INTERVAL: float
 

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/config.py

@@ -264,6 +264,33 @@ def _enforce_suffix_rules(x: str) -> str:
     return x
 
 
+def _transform_headers(s: str) -> dict[str, str]:
+    error_msg = (
+        "Must be a comma-separated list of `<header>:<value>` pairs (whitespace is ignored). "
+        "<header> and <value> must contain at least one non-whitespace character, and may "
+        "not contain commas."
+    )
+
+    if s == "":
+        return {}
+
+    pairs = s.split(",")
+
+    headers: dict[str, str] = {}
+    for pair in pairs:
+        res = pair.split(":", maxsplit=1)
+        if len(res) != 2:
+            raise ValueError(error_msg)
+
+        header, value = res[0].strip(), res[1].strip()
+        if len(header) == 0 or len(value) == 0:
+            raise ValueError(error_msg)
+
+        headers[header] = value
+
+    return headers
+
+
 class _Setting(typing.NamedTuple):
     default: typing.Any = None
     transform: typing.Callable[[str], typing.Any] = lambda x: x  # noqa: E731
@@ -306,6 +333,7 @@ _SETTINGS = {
     "max_throttle_wait": _Setting(None, transform=lambda x: int(x) if x else None),
     "async_warnings": _Setting(True, transform=_to_boolean),  # Activate synchronicity usage warnings
     "disable_api_proxy": _Setting(False, transform=_to_boolean),
+    "override_headers": _Setting(None, transform=_transform_headers),
 }
 
 

{modal-1.5.3.dev3 → modal-1.5.3.dev4}/modal/functions.pyi

@@ -493,7 +493,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.
 
@@ -518,7 +518,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]:
@@ -568,7 +568,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.
 
@@ -601,7 +601,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: ...
@@ -609,7 +609,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.
 
@@ -642,7 +642,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.3.dev3 → modal-1.5.3.dev4}/modal/sandbox.py

@@ -842,6 +842,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         experimental_options: dict[str, Any] | None = None,
         include_oidc_identity_token: bool = False,
         verbose: bool = False,
+        custom_domain: str | None = None,
         client: _Client | None = None,
     ) -> "_Sandbox":
         """Create a sandbox using the V2 backend.
@@ -849,15 +850,17 @@ class _Sandbox(_Object, type_prefix="sb"):
         Supported features include exec, encrypted tunnels, wait/poll/terminate,
         CPU and memory configuration, region placement, private IPv6 networking
         (i6pn), volumes, cloud bucket mounts (with static credentials via
-        `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies, and
-        filesystem snapshots.
+        `secret=...` or `oidc_auth_role_arn`), OIDC identity tokens, proxies,
+        filesystem snapshots, and custom domains (`custom_domain=...` allows
+        connections to the sandbox via a subdomain of that parent domain rather
+        than a default Modal domain; requires prior setup by Modal).
 
         `cpu` and `memory` accept either a scalar request or a `(request, limit)`
         tuple that additionally sets a hard limit (fractional CPU cores; memory
         in MiB), matching `Sandbox.create()`.
 
-        Features like memory snapshots, network file systems, GPUs, and custom
-        domains are not supported.
+        Features like memory snapshots, network file systems, and GPUs are not
+        supported.
 
         Set `i6pn=True` to enable private IPv6 networking so sandboxes in the same
         workspace can address each other directly at their `i6pn.modal.local`
@@ -996,6 +999,7 @@ class _Sandbox(_Object, type_prefix="sb"):
                 experimental_options_v2=(
                     {k: str(v) for k, v in experimental_options.items()} if experimental_options else None
                 ),
+                custom_domain=custom_domain,
             )
 
             tag_protos = [api_pb2.SandboxTag(tag_name=k, tag_value=v) for k, v in tags.items()] if tags else []
@@ -1317,6 +1321,31 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
             await stub.SandboxTagsSet(req)
 
+    async def _experimental_set_name(self, name: str) -> None:
+        """Assign a name to a running V2 Sandbox that was created without one.
+
+        This is only supported for V2 sandboxes, ie sandboxes created via
+        `modal.Sandbox._experimental_create`. A name may only be set once and
+        only on a Sandbox that has never had one; afterwards the Sandbox can
+        be looked up with `Sandbox._experimental_from_name(app_name, name)`.
+
+        Args:
+            name: Name to assign to the Sandbox. Must be unique within the App.
+
+        Raises:
+            AlreadyExistsError: If another running Sandbox in the App already holds the name.
+            ConflictError: If the Sandbox already has a name or is no longer running.
+        """
+        self._ensure_attached()
+        if not self._is_v2:
+            raise InvalidError("Sandbox._experimental_set_name() is only supported for V2 sandboxes")
+        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)])
+
     async def _experimental_set_outbound_network_policy(
         self,
         *,