modAL 1.6.3.dev5__tar.gz → 1.6.3.dev6__tar.gz

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/PKG-INFO

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

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/modal/_utils/grpc_testing.py

@@ -116,7 +116,7 @@ class InterceptionContext:
         """Adds one response payload to an expected queue of responses for a method.
 
         These responses will be used once each instead of calling the MockServicer's
-        implementation of the method.
+        implementation of the method. An exception payload is raised instead of being sent.
 
         The interception context will throw an exception on exit if not all of the added
         responses have been consumed.
@@ -184,6 +184,8 @@ class InterceptionContext:
         async def responder(servicer_self, stream):
             await stream.recv_message()  # get the input message so we can track that
             for msg in next_response_messages:
+                if isinstance(msg, Exception):
+                    raise msg
                 await stream.send_message(msg)
 
         return responder

modal-1.6.3.dev6/modal/builder/PREVIEW.txt

@@ -0,0 +1,18 @@
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.5
+aiosignal==1.4.0
+async-timeout==5.0.1 ; python_version < "3.11"
+attrs==26.1.0
+cbor2==5.9.0
+certifi==2026.10.19
+frozenlist==1.8.0
+grpclib==0.4.9
+h2==4.4.1
+hpack==4.2.0
+hyperframe==6.1.0
+idna==3.20
+multidict==7.1.0
+propcache==0.5.4
+protobuf==7.36.2
+typing_extensions==4.16.0
+yarl==1.25.1

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/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.3.dev5",
+        version: str = "1.6.3.dev6",
         *,
         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.3.dev5",
+        version: str = "1.6.3.dev6",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/modal/sandbox/_common.py

@@ -386,7 +386,7 @@ class SandboxCreateArgs:
     secrets: Collection[_Secret] | None = None
     env: dict[str, str | None] | None = None
     name: str | None = None
-    timeout: int = 300
+    timeout: int | None = 300
     idle_timeout: int | None = None
     workdir: str | None = None
     gpu: str | None = None
@@ -417,6 +417,7 @@ class SandboxCreateArgs:
     custom_domain: str | None = None
     include_oidc_identity_token: bool = False
     runtime: SandboxRuntime | None = None
+    persistent: bool = False
 
 
 class SandboxCreateCommon:
@@ -428,6 +429,8 @@ class SandboxCreateCommon:
 
     def __init__(self, create_args: SandboxCreateArgs, *, secrets: Sequence[_Secret]) -> None:
         a = create_args
+        if a.timeout is None:
+            raise InvalidError("`timeout=None` is only supported for experimental persistent Sandboxes.")
         _validate_exec_args(a.args)
         if a.name is not None:
             check_object_name(a.name, "Sandbox")
@@ -452,6 +455,7 @@ class SandboxCreateCommon:
             raise InvalidError("`inbound_cidr_allowlist` cannot be used when `block_network` is enabled")
 
         self.create_args = a
+        self.timeout = a.timeout
         self.secrets = secrets
         self.image = a.image or _default_image
         self.network_file_systems = validate_network_file_systems(a.network_file_systems)
@@ -503,7 +507,7 @@ class SandboxCreateCommon:
             secret_ids=[secret.object_id for secret in self.secrets],
             # Ephemeral disk requests are not supported on Sandboxes.
             resources=convert_fn_config_to_resources_config(cpu=a.cpu, memory=a.memory, gpu=a.gpu, ephemeral_disk=None),
-            timeout_secs=a.timeout,
+            timeout_secs=self.timeout,
             idle_timeout_secs=a.idle_timeout,
             workdir=a.workdir,
             cloud_provider_str=a.cloud if a.cloud else None,  # pyright: ignore[reportArgumentType]
@@ -637,6 +641,10 @@ class SandboxImpl(Protocol):
         """
         ...
 
+    def clone(self) -> "SandboxImpl":
+        """Create an implementation of the same type for another handle to the same Sandbox."""
+        ...
+
     @classmethod
     async def lookup_by_name(
         cls, client: _Client, req: api_pb2.SandboxGetFromNameRequest
@@ -674,6 +682,10 @@ class SandboxImpl(Protocol):
 
     async def terminate(self) -> None: ...
 
+    async def pause(self) -> None: ...
+
+    async def resume(self) -> None: ...
+
     async def close(self) -> None:
         """Release connections held for the Sandbox once in-flight operations complete."""
         ...
@@ -907,6 +919,9 @@ async def snapshot_filesystem_via_tcr(
     return _Image._new_hydrated(res.image_id, client, None)
 
 
+_PERSISTENT_ONLY_MESSAGE = "`{}` requires a persistent Sandbox, created with `_experimental_persistent=True`."
+
+
 async def mount_image_via_tcr(
     impl: SandboxImpl,
     path: PurePosixPath | str,

modal-1.6.3.dev6/modal/sandbox/_impl_persistent.py

@@ -0,0 +1,470 @@
+# Copyright Modal Labs 2026
+"""Persistent Sandboxes, managed by the `PersistentSandbox*` control-plane RPCs.
+
+A persistent Sandbox runs as a sequence of regular V2 Sandboxes, its sessions. The control plane starts each
+session from the exit snapshot of the previous one.
+"""
+
+import asyncio
+import copy
+import dataclasses
+import time
+import weakref
+from collections.abc import Awaitable, Callable, Collection, Sequence
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, Any, Literal, TypeVar
+
+from grpclib import GRPCError, Status
+
+from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
+
+from .._image import _Image
+from .._outbound_policy import _OutboundPolicy
+from .._resolver import Resolver
+from .._tunnel import Tunnel
+from ..client import _Client
+from ..cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
+from ..config import logger
+from ..container_process import _ContainerProcess
+from ..exception import ClientClosed, InvalidError, SandboxTerminatedError
+from ..io_streams import (
+    StreamReader,
+    StreamWriter,
+    _StreamReaderThroughSandboxCommandRouterParams,
+    _StreamWriterThroughCommandRouterSandboxParams,
+)
+from ..secret import _resolvable_secrets, _Secret, _secret_sources
+from ..stream_type import StreamType
+from ._common import SandboxCreateArgs, SandboxCreateCommon, SandboxImpl, command_router, sandbox_create_context
+from ._impl_v2 import SandboxImplV2, auth_metadata
+from ._snapshot import _SandboxSnapshot
+from ._task_command_router_client import TaskCommandRouterClient
+
+if TYPE_CHECKING:
+    import modal.app
+
+_T = TypeVar("_T")
+
+# Errors caused by the caller rather than by the session, which a new session can't fix.
+_NON_RECOVERABLE_ERRORS = (InvalidError, ClientClosed)
+
+# Lifetime limits of each session. A session that hits one is paused, and resumed on next use.
+PERSISTENT_SANDBOX_SESSION_TIMEOUT = 60 * 60
+PERSISTENT_SANDBOX_SESSION_IDLE_TIMEOUT = 5 * 60
+
+# How long to retry resuming while the previous session is still saving its exit snapshot.
+_RESUME_RETRY_TIMEOUT = 120.0
+_RESUME_RETRY_INTERVAL = 1.0
+
+# How often `wait()` checks whether the persistent Sandbox has been terminated.
+_WAIT_POLL_INTERVAL = 1.0
+
+_TERMINATED_RESULT = api_pb2.GenericResult(status=api_pb2.GenericResult.GENERIC_STATUS_TERMINATED)
+
+
+class SandboxImplPersistent:
+    """Backs a persistent Sandbox, whose object ID is the ID of its first session.
+
+    Operations are forwarded to the current session. When one fails and the Sandbox hasn't been terminated
+    through this handle, the control plane is asked for the running session, resuming the Sandbox from its
+    latest exit snapshot if there is none. The operation is then retried once on the new session.
+    """
+
+    def __init__(
+        self,
+        client: _Client,
+        sandbox_id: str,
+        *,
+        result: api_pb2.GenericResult | None = None,
+        persistent_sandbox_id: str = "",
+        session: SandboxImplV2 | None = None,
+    ) -> None:
+        self.client = client
+        self.sandbox_id = sandbox_id
+        self.result = result
+        self._persistent_sandbox_id = persistent_sandbox_id
+        self._session = session if session is not None else SandboxImplV2(client, sandbox_id)
+        self._replace_lock: asyncio.Lock | None = None
+        self._terminated = result is not None
+
+    @property
+    def _delegate(self) -> SandboxImplV2:
+        return self._session
+
+    @property
+    def _client(self) -> _Client:
+        return self.client
+
+    @classmethod
+    async def create(
+        cls, create_args: SandboxCreateArgs, *, app: "modal.app._App | None", client: _Client | None
+    ) -> "tuple[SandboxImpl, api_pb2.SandboxHandleMetadata]":
+        if create_args.timeout is not None or create_args.idle_timeout is not None:
+            raise InvalidError("Persistent Sandboxes require `timeout=None` and don't support `idle_timeout`.")
+        create_args = dataclasses.replace(
+            create_args,
+            timeout=PERSISTENT_SANDBOX_SESSION_TIMEOUT,
+            idle_timeout=PERSISTENT_SANDBOX_SESSION_IDLE_TIMEOUT,
+        )
+        if create_args.name is not None:
+            raise InvalidError("Named persistent Sandboxes are not supported yet.")
+        if create_args.gpu is not None or create_args.network_file_systems or create_args.pty_info is not None:
+            raise InvalidError("GPUs, network file systems and PTYs are not supported by persistent Sandboxes yet.")
+        if create_args.enable_snapshot:
+            raise InvalidError("Memory snapshots are not supported by persistent Sandboxes.")
+        if create_args.env or create_args.tags:
+            raise InvalidError("`env` and `tags` are not supported by persistent Sandboxes yet.")
+
+        secrets = create_args.secrets or []
+        common = SandboxCreateCommon(create_args, secrets=_resolvable_secrets(secrets))
+        async with sandbox_create_context(app, client) as (client, load_context):
+            await common.load_dependencies(Resolver(), load_context, load_ephemeral_bucket_secrets=False)
+            cloud_bucket_mount_protos, cloud_bucket_credentials = cloud_bucket_mounts_to_proto(
+                common.cloud_bucket_mounts, split_ephemeral_credentials=True
+            )
+            if cloud_bucket_credentials or any(source.HasField("env") for source in _secret_sources(secrets)):
+                raise InvalidError("Ephemeral credentials are not supported by persistent Sandboxes yet.")
+            req = api_pb2.PersistentSandboxCreateRequest(
+                app_id=load_context.app_id or "",
+                definition=common.definition(cloud_bucket_mounts=cloud_bucket_mount_protos),
+            )
+            resp = await client._stub.PersistentSandboxCreate(req, metadata=await auth_metadata(client))
+            app_id = load_context.app_id or ""
+        impl = cls(client, resp.sandbox_id, persistent_sandbox_id=resp.persistent_sandbox_id)
+        return impl, api_pb2.SandboxHandleMetadata(app_id=app_id)
+
+    # Persistent Sandboxes are only created through `create`, and can't be looked up yet.
+
+    @classmethod
+    async def lookup_by_name(cls, *args: Any, **kwargs: Any) -> api_pb2.SandboxGetFromNameResponse:
+        raise NotImplementedError
+
+    @classmethod
+    async def lookup_by_id(cls, *args: Any, **kwargs: Any) -> api_pb2.SandboxWaitResponse:
+        raise NotImplementedError
+
+    @classmethod
+    async def list_page(cls, *args: Any, **kwargs: Any) -> api_pb2.SandboxListResponse:
+        raise NotImplementedError
+
+    @classmethod
+    async def restore_from_memory_snapshot(
+        cls, *args: Any, **kwargs: Any
+    ) -> "tuple[SandboxImpl, api_pb2.SandboxHandleMetadata]":
+        raise NotImplementedError
+
+    def clone(self) -> "SandboxImplPersistent":
+        return copy.copy(self)
+
+    def make_stdio(self, check_open: Callable[[], None]) -> tuple[StreamReader[str], StreamReader[str], StreamWriter]:
+        """Create stdio streams of the entrypoint of whichever session is current when they connect."""
+        weak_self = weakref.ref(self)
+
+        async def resolve_router() -> tuple[str, TaskCommandRouterClient]:
+            this = weak_self()
+            if this is None:
+                raise RuntimeError("Sandbox was garbage collected before its stdio reader connected")
+            return await command_router(this)
+
+        def reader(file_descriptor: "api_pb2.FileDescriptor.ValueType") -> StreamReader[str]:
+            return StreamReader(
+                _StreamReaderThroughSandboxCommandRouterParams(
+                    file_descriptor=file_descriptor, sandbox_id=self.sandbox_id, resolve_router=resolve_router
+                ),
+                by_line=True,
+            )
+
+        stdin = StreamWriter(
+            _StreamWriterThroughCommandRouterSandboxParams(resolve_router=resolve_router, check_open=check_open)
+        )
+        return reader(api_pb2.FILE_DESCRIPTOR_STDOUT), reader(api_pb2.FILE_DESCRIPTOR_STDERR), stdin
+
+    # Session replacement
+
+    async def _run(self, op: Callable[[SandboxImplV2], Awaitable[_T]]) -> _T:
+        """Run `op` on the session, switching to the running session and retrying once if it fails."""
+        session = self._delegate
+        try:
+            return await op(session)
+        except _NON_RECOVERABLE_ERRORS:
+            raise
+        except Exception as exc:
+            if self._terminated:
+                # A terminated persistent Sandbox is stopped for good, so it isn't resumed on use.
+                raise
+            replacement = await self._replace_session(session)
+            if replacement is None:
+                raise
+            logger.debug(f"Retrying operation on persistent Sandbox {self._persistent_sandbox_id} after: {exc!r}")
+            return await op(replacement)
+
+    async def _get_running_session_id(self) -> str:
+        req = api_pb2.PersistentSandboxGetRequest(persistent_sandbox_id=self._persistent_sandbox_id)
+        resp = await self._client._stub.PersistentSandboxGet(req, metadata=await auth_metadata(self._client))
+        return resp.sandbox_id
+
+    async def _resume_session(self) -> str:
+        """Resume the persistent Sandbox, returning the ID of its running session."""
+        req = api_pb2.PersistentSandboxResumeRequest(persistent_sandbox_id=self._persistent_sandbox_id)
+        deadline = time.monotonic() + _RESUME_RETRY_TIMEOUT
+        while True:
+            try:
+                resp = await self._client._stub.PersistentSandboxResume(req, metadata=await auth_metadata(self._client))
+                return resp.sandbox_id
+            except GRPCError as exc:
+                # UNAVAILABLE means the previous session is still pausing or another resume is in progress.
+                if exc.status != Status.UNAVAILABLE or time.monotonic() > deadline:
+                    raise
+            await asyncio.sleep(_RESUME_RETRY_INTERVAL)
+
+    async def _replace_session(self, failed: SandboxImplV2 | None, *, resume: bool = True) -> SandboxImplV2 | None:
+        """Switch from the `failed` session, or return None if it is still the running session."""
+        # Lazily create the lock on the event loop that first uses the Sandbox.
+        if self._replace_lock is None:
+            self._replace_lock = asyncio.Lock()
+        async with self._replace_lock:
+            if self._session is not failed:
+                # A concurrent operation has already replaced the session.
+                return self._session
+
+            session_id = await self._get_running_session_id()
+            if failed is not None and session_id == failed.sandbox_id:
+                return None
+            if not session_id:
+                if not resume:
+                    return None
+                session_id = await self._resume_session()
+            logger.debug(f"Switching persistent Sandbox {self._persistent_sandbox_id} to session {session_id}")
+            replacement = SandboxImplV2(self.client, session_id)
+            self._session = replacement
+            if failed is not None:
+                await failed.close()
+            return replacement
+
+    # Operations
+
+    async def close(self) -> None:
+        await self._session.close()
+
+    def _set_terminated_result(self) -> None:
+        self.result = _TERMINATED_RESULT
+
+    async def wait(self, raise_on_termination: bool) -> None:
+        # A persistent Sandbox keeps running across sessions, until it is terminated.
+        while not self._terminated:
+            await asyncio.sleep(_WAIT_POLL_INTERVAL)
+        self._set_terminated_result()
+        if raise_on_termination:
+            raise SandboxTerminatedError()
+
+    async def poll(self) -> None:
+        if self._terminated:
+            self._set_terminated_result()
+        else:
+            self.result = None
+
+    async def terminate(self) -> None:
+        req = api_pb2.PersistentSandboxTerminateRequest(persistent_sandbox_id=self._persistent_sandbox_id)
+        await self._client._stub.PersistentSandboxTerminate(req, metadata=await auth_metadata(self._client))
+        self._terminated = True
+        self._set_terminated_result()
+
+    async def pause(self) -> None:
+        """Stop the current session, which saves its exit snapshot for the next `resume`."""
+        self._check_not_terminated()
+        session = self._delegate
+        await session.terminate()
+        await session.wait(raise_on_termination=False)
+
+    async def resume(self) -> None:
+        """Start a session from the latest exit snapshot, unless one is already running."""
+        self._check_not_terminated()
+        session = self._delegate
+        session_id = await self._resume_session()
+        if session_id != session.sandbox_id:
+            self._session = SandboxImplV2(self.client, session_id)
+            await session.close()
+
+    def _check_not_terminated(self) -> None:
+        if self._terminated:
+            raise InvalidError(f"Persistent Sandbox {self._persistent_sandbox_id} has been terminated.")
+
+    async def tunnels(self, timeout: int) -> dict[int, Tunnel]:
+        return await self._run(lambda d: d.tunnels(timeout))
+
+    async def get_task_id(
+        self, raise_if_task_complete: bool = False, timeout: float | None = None, retry_transient: bool = False
+    ) -> str:
+        return await self._run(
+            lambda d: d.get_task_id(
+                raise_if_task_complete=raise_if_task_complete, timeout=timeout, retry_transient=retry_transient
+            )
+        )
+
+    async def resolve_task_id_for_logs(self) -> str:
+        return await self._delegate.resolve_task_id_for_logs()
+
+    async def get_exit_snapshot(self, timeout: float | None) -> _Image:
+        return await self._delegate.get_exit_snapshot(timeout)
+
+    async def snapshot_memory(self) -> _SandboxSnapshot:
+        raise NotImplementedError("Memory snapshots aren't supported for persistent Sandboxes.")
+
+    async def get_command_router_client(self, task_id: str) -> TaskCommandRouterClient:
+        # The task ID belongs to the current delegate, so this can't be retried on a replacement.
+        return await self._delegate.get_command_router_client(task_id)
+
+    async def get_tags(self) -> dict[str, str]:
+        raise NotImplementedError("Tags aren't supported for persistent Sandboxes yet.")
+
+    async def set_tags(self, tags: dict[str, str]) -> None:
+        raise NotImplementedError("Tags aren't supported for persistent Sandboxes yet.")
+
+    async def set_name(self, name: str) -> None:
+        raise InvalidError("The name of a persistent Sandbox can't be changed.")
+
+    async def create_connect_token(
+        self, req: api_pb2.SandboxCreateConnectTokenRequest
+    ) -> api_pb2.SandboxCreateConnectTokenResponse:
+        def create(d: SandboxImplV2) -> Awaitable[api_pb2.SandboxCreateConnectTokenResponse]:
+            delegate_req = api_pb2.SandboxCreateConnectTokenRequest()
+            delegate_req.CopyFrom(req)
+            delegate_req.sandbox_id = d.sandbox_id
+            return d.create_connect_token(delegate_req)
+
+        return await self._run(create)
+
+    async def wait_until_ready(self, timeout: int) -> None:
+        await self._run(lambda d: d.wait_until_ready(timeout))
+
+    async def set_network_access(self, network_access: api_pb2.NetworkAccess) -> None:
+        raise NotImplementedError("Updating network access isn't supported for persistent Sandboxes yet.")
+
+    async def update_outbound_policy(self, outbound_policy: _OutboundPolicy) -> None:
+        raise NotImplementedError("Updating the outbound policy isn't supported for persistent Sandboxes yet.")
+
+    async def snapshot_filesystem(self, timeout: int, *, ttl: int | None, container_id: str = "") -> _Image:
+        return await self._run(lambda d: d.snapshot_filesystem(timeout, ttl=ttl, container_id=container_id))
+
+    async def mount_image(
+        self,
+        path: PurePosixPath | str,
+        image_id: str,
+        *,
+        encryption_key: bytes | None,
+        container_id: str = "",
+    ) -> None:
+        raise NotImplementedError("Mounting images isn't supported for persistent Sandboxes yet.")
+
+    async def unmount_image(self, path: PurePosixPath | str, *, container_id: str = "") -> None:
+        raise NotImplementedError("Mounting images isn't supported for persistent Sandboxes yet.")
+
+    async def snapshot_directory(
+        self,
+        path: PurePosixPath | str,
+        *,
+        timeout: int,
+        ttl: int | None,
+        encryption_key: bytes | None,
+        container_id: str = "",
+    ) -> _Image:
+        return await self._run(
+            lambda d: d.snapshot_directory(
+                path, timeout=timeout, ttl=ttl, encryption_key=encryption_key, container_id=container_id
+            )
+        )
+
+    async def reload_volumes(self, *, timeout: int, container_id: str = "") -> None:
+        await self._run(lambda d: d.reload_volumes(timeout=timeout, container_id=container_id))
+
+    async def exec(
+        self,
+        *args: str,
+        pty_info: api_pb2.PTYInfo | None,
+        stdout: StreamType,
+        stderr: StreamType,
+        timeout: int | None,
+        workdir: str | None,
+        env: dict[str, str | None] | None,
+        secrets: Collection[_Secret] | None,
+        text: bool,
+        bufsize: Literal[-1, 1],
+        container_id: str | None,
+    ) -> _ContainerProcess[bytes] | _ContainerProcess[str]:
+        return await self._run(
+            lambda d: d.exec(
+                *args,
+                pty_info=pty_info,
+                stdout=stdout,
+                stderr=stderr,
+                timeout=timeout,
+                workdir=workdir,
+                env=env,
+                secrets=secrets,
+                text=text,
+                bufsize=bufsize,
+                container_id=container_id,
+            )
+        )
+
+    # Sidecar containers
+
+    def validate_sidecar_create(
+        self,
+        *,
+        cloud_bucket_mounts: Sequence[tuple[str, _CloudBucketMount]],
+        has_proxy: bool,
+        include_oidc_identity_token: bool,
+    ) -> None:
+        self._delegate.validate_sidecar_create(
+            cloud_bucket_mounts=cloud_bucket_mounts,
+            has_proxy=has_proxy,
+            include_oidc_identity_token=include_oidc_identity_token,
+        )
+
+    async def create_sidecar(
+        self,
+        *args: str,
+        name: str,
+        image_id: str,
+        secret_ids: Sequence[str],
+        secret_sources: Sequence[api_pb2.SecretSource],
+        workdir: str | None,
+        volume_mounts: Sequence[api_pb2.VolumeMount],
+        cloud_bucket_mounts: Sequence[tuple[str, _CloudBucketMount]],
+        network_access: api_pb2.NetworkAccess,
+        include_oidc_identity_token: bool,
+        proxy_id: str | None,
+        pty_info: api_pb2.PTYInfo | None,
+        memory_reserve_consume_mib: int | None,
+    ) -> tuple[str, str]:
+        return await self._run(
+            lambda d: d.create_sidecar(
+                *args,
+                name=name,
+                image_id=image_id,
+                secret_ids=secret_ids,
+                secret_sources=secret_sources,
+                workdir=workdir,
+                volume_mounts=volume_mounts,
+                cloud_bucket_mounts=cloud_bucket_mounts,
+                network_access=network_access,
+                include_oidc_identity_token=include_oidc_identity_token,
+                proxy_id=proxy_id,
+                pty_info=pty_info,
+                memory_reserve_consume_mib=memory_reserve_consume_mib,
+            )
+        )
+
+    async def get_sidecar(self, name: str, include_terminated: bool) -> sr_pb2.TaskContainerInfo:
+        return await self._run(lambda d: d.get_sidecar(name, include_terminated))
+
+    async def list_sidecars(self, include_terminated: bool) -> list[sr_pb2.TaskContainerInfo]:
+        return await self._run(lambda d: d.list_sidecars(include_terminated))
+
+    async def wait_sidecar(self, container_id: str, timeout: float) -> api_pb2.GenericResult | None:
+        # Sidecar containers don't carry over to a replacement delegate.
+        return await self._delegate.wait_sidecar(container_id, timeout)
+
+    async def terminate_sidecar(self, container_id: str) -> None:
+        await self._delegate.terminate_sidecar(container_id)

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/modal/sandbox/_impl_v1.py

@@ -40,6 +40,7 @@ from ..io_streams import (
 from ..secret import _Secret
 from ..stream_type import StreamType
 from ._common import (
+    _PERSISTENT_ONLY_MESSAGE,
     _TASK_ID_POLL_INTERVAL,
     ExitSnapshotPoll,
     SandboxCreateArgs,
@@ -124,6 +125,9 @@ class SandboxImplV1:
     def _client(self) -> _Client:
         return self.client
 
+    def clone(self) -> "SandboxImplV1":
+        return type(self)(self.client, self.sandbox_id, result=self.result)
+
     @classmethod
     async def create(
         cls, create_args: SandboxCreateArgs, *, app: "modal.app._App | None", client: _Client | None
@@ -289,6 +293,12 @@ class SandboxImplV1:
         req = api_pb2.SandboxTerminateRequest(sandbox_id=self.sandbox_id)
         await self.client._stub.SandboxTerminate(req)
 
+    async def pause(self) -> None:
+        raise NotImplementedError(_PERSISTENT_ONLY_MESSAGE.format("_experimental_pause()"))
+
+    async def resume(self) -> None:
+        raise NotImplementedError(_PERSISTENT_ONLY_MESSAGE.format("_experimental_resume()"))
+
     async def snapshot_filesystem(self, timeout: int, *, ttl: int | None, container_id: str = "") -> _Image:
         if not container_id and os.environ.get("MODAL_USE_LEGACY_FILESYSTEM_SNAPSHOT") == "1":
             if ttl != DEFAULT_SNAPSHOT_TTL:

{modal-1.6.3.dev5 → modal-1.6.3.dev6}/modal/sandbox/_impl_v2.py

@@ -32,6 +32,7 @@ from ..io_streams import (
 from ..secret import _resolvable_secrets, _Secret, _secret_sources
 from ..stream_type import StreamType
 from ._common import (
+    _PERSISTENT_ONLY_MESSAGE,
     _TASK_ID_POLL_INTERVAL,
     ExitSnapshotPoll,
     SandboxCreateArgs,
@@ -147,6 +148,9 @@ class SandboxImplV2:
     def _client(self) -> _Client:
         return self.client
 
+    def clone(self) -> "SandboxImplV2":
+        return type(self)(self.client, self.sandbox_id, result=self.result)
+
     @classmethod
     async def create(
         cls, create_args: SandboxCreateArgs, *, app: "modal.app._App | None", client: _Client | None
@@ -351,6 +355,12 @@ class SandboxImplV2:
         req = api_pb2.SandboxTerminateRequest(sandbox_id=self.sandbox_id)
         await self.client._stub.SandboxTerminateV2(req, metadata=await self._metadata())
 
+    async def pause(self) -> None:
+        raise NotImplementedError(_PERSISTENT_ONLY_MESSAGE.format("_experimental_pause()"))
+
+    async def resume(self) -> None:
+        raise NotImplementedError(_PERSISTENT_ONLY_MESSAGE.format("_experimental_resume()"))
+
     def _create_sidecar_via_control_plane(self) -> bool:
         # Opt out via the `use_control_plane_sidecar_create` config setting to create
         # sidecars over the task command router instead.