modAL 1.6.2.dev2__py3-none-any.whl → 1.6.2.dev4__py3-none-any.whl

modal/{sandbox.pyi → sandbox/sandbox.pyi}

@@ -1,10 +1,7 @@
 import asyncio.locks
 import collections.abc
-import enum
 import google.protobuf.message
-import modal._image
 import modal._logs_manager
-import modal._object
 import modal._outbound_policy
 import modal._supports_logs
 import modal._tunnel
@@ -19,6 +16,7 @@ import modal.mount
 import modal.network_file_system
 import modal.object
 import modal.proxy
+import modal.sandbox._sandbox
 import modal.sandbox_fs
 import modal.secret
 import modal.snapshot
@@ -32,1357 +30,6 @@ import pathlib
 import typing
 import typing_extensions
 
-SandboxRuntime = typing.Literal["gvisor", "vm"]
-
-async def _gather_load_with_timings(
-    load_coros: collections.abc.Sequence[collections.abc.Awaitable[typing.Any]],
-) -> list[tuple[str, float]]:
-    """Await all loader coroutines concurrently and return [(object_id, elapsed_seconds)] per load."""
-    ...
-
-def _format_sandbox_create_timing_log(
-    sandbox_id: str, total_seconds: float, rpc_seconds: float, dep_timings: collections.abc.Sequence[tuple[str, float]]
-) -> str:
-    """Format the Sandbox create debug log line, listing the slowest deps first."""
-    ...
-
-def _validate_sandbox_env(env: dict[str, str]) -> None: ...
-def _validate_sandbox_runtime(runtime: typing.Optional[typing.Literal["gvisor", "vm"]]) -> None: ...
-def _ttl_to_wire_ttl(ttl: typing.Optional[int]) -> int:
-    """Convert a TTL value to the wire format, validating the input."""
-    ...
-
-def _validate_experimental_encryption_key(key: typing.Optional[bytes]) -> typing.Optional[bytes]: ...
-def _image_id_for_mount(image: modal._image._Image, method_name: str) -> str: ...
-
-class SandboxVersion(enum.Enum):
-    V1 = 1
-    V2 = 2
-
-def _is_v1_sandbox_id(sandbox_id: str) -> bool: ...
-def _get_sandbox_version(sandbox_id: str) -> SandboxVersion: ...
-def _result_returncode(result: typing.Optional[modal_proto.api_pb2.GenericResult]) -> typing.Optional[int]: ...
-def _validate_exec_args(args: collections.abc.Sequence[str]) -> None: ...
-def _build_outbound_network_access(
-    block_network: bool,
-    outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]],
-    outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]],
-) -> modal_proto.api_pb2.NetworkAccess:
-    """Build the outbound `NetworkAccess` for the given params.
-
-    Shared by `Sandbox.create` and the sidecar create path. When nothing is
-    specified, defaults to open network access.
-    """
-    ...
-
-class DefaultSandboxNameOverride(str):
-    """A singleton class that represents the default sandbox name override.
-
-    It is used to indicate that the sandbox name should not be overridden.
-    """
-    def __repr__(self) -> str:
-        """Return repr(self)."""
-        ...
-
-_DEFAULT_SANDBOX_NAME_OVERRIDE: DefaultSandboxNameOverride
-
-class Probe:
-    """Probe configuration for the Sandbox Readiness Probe.
-
-    Examples:
-        ```python notest
-        # Wait until a file exists.
-        readiness_probe = modal.Probe.with_exec(
-            "sh", "-c", "test -f /tmp/ready",
-        )
-
-        # Wait until a TCP port is accepting connections.
-        readiness_probe = modal.Probe.with_tcp(8080)
-
-        app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
-        sandbox = modal.Sandbox.create(
-            "python3", "-m", "http.server", "8080",
-            readiness_probe=readiness_probe,
-            app=app,
-        )
-        sandbox.wait_until_ready()
-        ```
-    """
-
-    tcp_port: typing.Optional[int]
-    exec_argv: typing.Optional[tuple[str, ...]]
-    interval_ms: int
-
-    def __post_init__(self): ...
-    @classmethod
-    def with_tcp(cls, port: int, *, interval_ms: int = 100) -> Probe: ...
-    @classmethod
-    def with_exec(cls, *argv: str, interval_ms: int = 100) -> Probe: ...
-    def _to_proto(self) -> modal_proto.api_pb2.Probe: ...
-    def __init__(
-        self,
-        tcp_port: typing.Optional[int] = None,
-        exec_argv: typing.Optional[tuple[str, ...]] = None,
-        interval_ms: int = 100,
-    ) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
-
-    def __setattr__(self, name, value):
-        """Implement setattr(self, name, value)."""
-        ...
-
-    def __delattr__(self, name):
-        """Implement delattr(self, name)."""
-        ...
-
-    def __hash__(self):
-        """Return hash(self)."""
-        ...
-
-def _resolve_app_id_and_client(
-    app: typing.Optional[modal.app._App], client: typing.Optional[modal.client._Client]
-) -> tuple[typing.Optional[str], typing.Optional[modal.client._Client]]:
-    """Resolve the App id and client for Sandbox creation, validating that an App is available."""
-    ...
-
-class _Sandbox(modal._object._Object):
-    """A `Sandbox` object lets you interact with a running sandbox. This API is similar to Python's
-    [asyncio.subprocess.Process](https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.subprocess.Process).
-
-    Refer to the [guide](https://modal.com/docs/guide/sandbox) on how to spawn and use sandboxes.
-    """
-
-    _result: typing.Optional[modal_proto.api_pb2.GenericResult]
-    _stdout: modal.io_streams._StreamReader[str]
-    _stderr: modal.io_streams._StreamReader[str]
-    _stdin: modal.io_streams._StreamWriter
-    _task_id: typing.Optional[str]
-    _tunnels: typing.Optional[dict[int, modal._tunnel.Tunnel]]
-    _enable_snapshot: bool
-    _command_router_client: typing.Optional[modal._utils.task_command_router_client.TaskCommandRouterClient]
-    _command_router_lock: typing.Optional[asyncio.locks.Lock]
-    _init_command_router_access: typing.Optional[modal_proto.api_pb2.CommandRouterAccess]
-    _attached: bool
-    _filesystem: typing.Optional[modal.sandbox_fs._SandboxFilesystem]
-    _is_v2: bool
-    _app_id: typing.Optional[str]
-
-    @staticmethod
-    def _default_pty_info() -> modal_proto.api_pb2.PTYInfo: ...
-    @staticmethod
-    def _new(
-        args: collections.abc.Sequence[str],
-        image: modal._image._Image,
-        secrets: collections.abc.Collection[modal.secret._Secret],
-        name: typing.Optional[str] = None,
-        timeout: int = 300,
-        idle_timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        gpu: typing.Optional[str] = None,
-        cloud: typing.Optional[str] = None,
-        region: typing.Union[str, collections.abc.Sequence[str], None] = None,
-        cpu: typing.Union[float, tuple[float, float], None] = None,
-        memory: typing.Union[int, tuple[int, int], None] = None,
-        mounts: collections.abc.Sequence[modal.mount._Mount] = (),
-        network_file_systems: dict[typing.Union[str, os.PathLike], modal.network_file_system._NetworkFileSystem] = {},
-        block_network: bool = False,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_policy: typing.Optional[modal._outbound_policy._OutboundPolicy] = None,
-        inbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        volumes: dict[
-            typing.Union[str, os.PathLike],
-            typing.Union[modal.volume._Volume, modal.cloud_bucket_mount._CloudBucketMount],
-        ] = {},
-        pty: bool = False,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        encrypted_ports: collections.abc.Sequence[int] = [],
-        h2_ports: collections.abc.Sequence[int] = [],
-        unencrypted_ports: collections.abc.Sequence[int] = [],
-        proxy: typing.Optional[modal.proxy._Proxy] = None,
-        readiness_probe: typing.Optional[Probe] = None,
-        experimental_options: typing.Optional[dict[str, typing.Any]] = None,
-        tags: typing.Optional[dict[str, str]] = None,
-        enable_snapshot: bool = False,
-        verbose: bool = False,
-        custom_domain: typing.Optional[str] = None,
-        include_oidc_identity_token: bool = False,
-        runtime: typing.Optional[typing.Literal["gvisor", "vm"]] = None,
-    ) -> _Sandbox:
-        """mdmd:hidden"""
-        ...
-
-    @staticmethod
-    async def create(
-        *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,
-        network_file_systems: dict[typing.Union[str, os.PathLike], modal.network_file_system._NetworkFileSystem] = {},
-        timeout: int = 300,
-        idle_timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        gpu: typing.Optional[str] = None,
-        cloud: typing.Optional[str] = None,
-        region: typing.Union[str, collections.abc.Sequence[str], None] = None,
-        cpu: typing.Union[float, tuple[float, float], None] = None,
-        memory: typing.Union[int, tuple[int, int], None] = None,
-        runtime: typing.Optional[typing.Literal["gvisor", "vm"]] = None,
-        block_network: bool = False,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        _experimental_outbound_policy: typing.Optional[modal._outbound_policy._OutboundPolicy] = None,
-        inbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        volumes: dict[
-            typing.Union[str, os.PathLike],
-            typing.Union[modal.volume._Volume, modal.cloud_bucket_mount._CloudBucketMount],
-        ] = {},
-        pty: bool = False,
-        encrypted_ports: collections.abc.Sequence[int] = [],
-        h2_ports: collections.abc.Sequence[int] = [],
-        unencrypted_ports: collections.abc.Sequence[int] = [],
-        custom_domain: typing.Optional[str] = None,
-        proxy: typing.Optional[modal.proxy._Proxy] = None,
-        include_oidc_identity_token: bool = False,
-        readiness_probe: typing.Optional[Probe] = None,
-        verbose: bool = False,
-        experimental_options: typing.Optional[dict[str, typing.Any]] = None,
-        _experimental_enable_snapshot: bool = False,
-        client: typing.Optional[modal.client._Client] = None,
-        environment_name: typing.Optional[str] = None,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-    ) -> _Sandbox:
-        """Create a new Sandbox to run untrusted, arbitrary code.
-
-        The Sandbox's corresponding container will be created asynchronously.
-
-        Args:
-            *args: Set the CMD of the Sandbox, overriding any CMD of the container image.
-            app: Associate the sandbox with an app. Required unless creating from a container.
-            name: Optionally give the sandbox a name. Unique within an app.
-            tags: Tags to assign to the Sandbox.
-            image: The image to run as the container for the sandbox.
-            env: Environment variables to set in the Sandbox.
-            secrets: Secrets to inject into the Sandbox as environment variables.
-            network_file_systems: Network file systems to mount into the sandbox.
-            timeout: Maximum lifetime of the sandbox in seconds.
-            idle_timeout: The amount of time in seconds that a sandbox can be idle before being terminated.
-            workdir: Working directory of the sandbox.
-            gpu: GPU reservation for the sandbox.
-            cloud: Cloud provider for the sandbox.
-            region: Region or regions to run the sandbox on.
-            cpu:
-                Specify, in fractional CPU cores, how many CPU cores to request. Or, pass (request, limit) to
-                additionally specify a hard limit in fractional CPU cores. CPU throttling will prevent a container
-                from exceeding its specified limit.
-            memory:
-                Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to
-                additionally specify a hard limit in MiB.
-            runtime:
-                Runtime under which the Sandbox executes, or None to let Modal pick.
-            block_network: Whether to block network access.
-            outbound_cidr_allowlist: List of CIDRs the sandbox is allowed to access. If None, all CIDRs are allowed.
-            outbound_domain_allowlist: List of domain names the sandbox is allowed to access. Supports
-                wildcard prefixes (``*.``); a bare ``"*"`` allows all domains. The outbound policy
-                can be replaced later via `Sandbox._experimental_set_outbound_network_policy`.
-            inbound_cidr_allowlist:
-                List of CIDRs allowed to connect inbound to the sandbox (tunnels and connection tokens). If None,
-                all CIDRs are allowed.
-            _experimental_outbound_policy: Configuration for replacing headers in outbound HTTPS requests from
-                the Sandbox. Secrets referenced by the policy are resolved outside the Sandbox and are never
-                visible to the workload. See `modal.experimental.OutboundPolicy`. This API is experimental and
-                may change in the future.
-            volumes: Mount points for Modal Volumes and CloudBucketMounts.
-            pty:
-                Enable a PTY for the Sandbox entrypoint command. When enabled, all output (stdout and stderr from the
-                process) is multiplexed into stdout, and the stderr stream is effectively empty.
-            encrypted_ports: List of ports to tunnel into the sandbox. Encrypted ports are tunneled with TLS.
-            h2_ports: List of encrypted ports to tunnel into the sandbox, using HTTP/2.
-            unencrypted_ports: List of ports to tunnel into the sandbox without encryption.
-            custom_domain:
-                Allow connections to the Sandbox via a subdomain of this parent rather than a default Modal domain.
-            proxy: Reference to a Modal Proxy to use in front of this Sandbox.
-            include_oidc_identity_token:
-                If True, the sandbox will receive a MODAL_IDENTITY_TOKEN env var for OIDC-based auth.
-            readiness_probe: Probe used to determine when the sandbox has become ready.
-            verbose: Enable verbose logging for sandbox operations.
-            experimental_options: Experimental options to pass to the sandbox.
-            _experimental_enable_snapshot: Enable memory snapshots.
-            client: Modal Client to use for the sandbox.
-            environment_name: *DEPRECATED* Optionally override the default environment
-            pty_info: *DEPRECATED* Use `pty` instead. `pty` will override `pty_info`.
-            cidr_allowlist: *DEPRECATED* Use outbound_cidr_allowlist instead.
-
-        Returns:
-            A `Sandbox` object representing the created sandbox which can be used to interact with the sandbox.
-
-        Raises:
-            AlreadyExistsError: If a sandbox with the same name already exists.
-
-        Examples:
-            ```python
-            app = modal.App.lookup('sandbox-hello-world', create_if_missing=True)
-            sandbox = modal.Sandbox.create("echo", "hello world", app=app)
-            print(sandbox.stdout.read())
-            sandbox.wait()
-            ```
-        """
-        ...
-
-    @staticmethod
-    async def _create(
-        *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,
-        mounts: collections.abc.Sequence[modal.mount._Mount] = (),
-        network_file_systems: dict[typing.Union[str, os.PathLike], modal.network_file_system._NetworkFileSystem] = {},
-        timeout: int = 300,
-        idle_timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        gpu: typing.Optional[str] = None,
-        cloud: typing.Optional[str] = None,
-        region: typing.Union[str, collections.abc.Sequence[str], None] = None,
-        cpu: typing.Union[float, tuple[float, float], None] = None,
-        memory: typing.Union[int, tuple[int, int], None] = None,
-        runtime: typing.Optional[typing.Literal["gvisor", "vm"]] = None,
-        block_network: bool = False,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        _experimental_outbound_policy: typing.Optional[modal._outbound_policy._OutboundPolicy] = None,
-        inbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        volumes: dict[
-            typing.Union[str, os.PathLike],
-            typing.Union[modal.volume._Volume, modal.cloud_bucket_mount._CloudBucketMount],
-        ] = {},
-        pty: bool = False,
-        encrypted_ports: collections.abc.Sequence[int] = [],
-        h2_ports: collections.abc.Sequence[int] = [],
-        unencrypted_ports: collections.abc.Sequence[int] = [],
-        proxy: typing.Optional[modal.proxy._Proxy] = None,
-        include_oidc_identity_token: bool = False,
-        readiness_probe: typing.Optional[Probe] = None,
-        experimental_options: typing.Optional[dict[str, typing.Any]] = None,
-        _experimental_enable_snapshot: bool = False,
-        client: typing.Optional[modal.client._Client] = None,
-        verbose: bool = False,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        custom_domain: typing.Optional[str] = None,
-    ):
-        """Private method used internally.
-
-        This method exposes some internal arguments (currently `mounts`) which are not in the public API.
-        `mounts` is currently only used by modal shell (cli) to provide a function's mounts to the
-        sandbox that runs the shell session.
-        """
-        ...
-
-    @staticmethod
-    async def _experimental_create(
-        *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,
-        mounts: collections.abc.Sequence[modal.mount._Mount] = (),
-        timeout: int = 300,
-        idle_timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        cpu: typing.Union[float, tuple[float, float], None] = None,
-        memory: typing.Union[int, tuple[int, int], None] = None,
-        runtime: typing.Optional[typing.Literal["gvisor", "vm"]] = None,
-        cloud: typing.Optional[str] = None,
-        region: typing.Union[str, collections.abc.Sequence[str], None] = None,
-        block_network: bool = False,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        _experimental_outbound_policy: typing.Optional[modal._outbound_policy._OutboundPolicy] = None,
-        inbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        i6pn: bool = False,
-        volumes: dict[
-            typing.Union[str, os.PathLike],
-            typing.Union[modal.volume._Volume, modal.cloud_bucket_mount._CloudBucketMount],
-        ] = {},
-        pty: bool = False,
-        encrypted_ports: collections.abc.Sequence[int] = [],
-        h2_ports: collections.abc.Sequence[int] = [],
-        unencrypted_ports: collections.abc.Sequence[int] = [],
-        proxy: typing.Optional[modal.proxy._Proxy] = None,
-        readiness_probe: typing.Optional[Probe] = None,
-        experimental_options: typing.Optional[dict[str, typing.Any]] = None,
-        include_oidc_identity_token: bool = False,
-        verbose: bool = False,
-        custom_domain: typing.Optional[str] = None,
-        client: typing.Optional[modal.client._Client] = None,
-        _experimental_enable_snapshot: bool = False,
-    ) -> _Sandbox:
-        """Create a sandbox using the V2 backend.
-
-        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,
-        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()`.
-
-        Pass `_experimental_enable_snapshot=True` to create a sandbox that can be
-        snapshotted with `._experimental_snapshot()`. Features like 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`
-        address. i6pn only connects sandboxes co-located on the same routable
-        network, so pin every sandbox in the group to the same specific region
-        (e.g. `region="us-east-1"`).
-
-        V2 sandboxes created with this method are not currently returned by
-        `Sandbox.list()`. A named sandbox can be looked up with
-        `Sandbox._experimental_from_name(app_name, name)`; otherwise store
-        `sandbox.object_id` and use `Sandbox.from_id(sandbox.object_id)` to
-        reattach.
-        """
-        ...
-
-    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:
-        """Wire up V2 stdio readers that read directly from the worker. Cheap
-        to call eagerly: the router connection is opened lazily on first read.
-        """
-        ...
-
-    def _initialize_from_other(self, other): ...
-    def _initialize_from_empty(self): ...
-    async def detach(self):
-        """Disconnects your client from the sandbox and cleans up resources associated with the connection.
-
-        Be sure to only call `detach` when you are done interacting with the sandbox. After calling `detach`,
-        any operation using the Sandbox object is not guaranteed to work anymore. If you want to continue interacting
-        with a running sandbox, use `Sandbox.from_id` to get a new Sandbox object.
-
-        This method does not interrupt or wait for running concurrent operations on the sandbox. Resources are
-        promptly closed once those operations complete.
-        """
-        ...
-
-    @property
-    def _client(self) -> modal.client._Client: ...
-    @_client.setter
-    def _client(self, value): ...
-    def _ensure_attached(self): ...
-    def _ensure_v1(self, method_name: str): ...
-    @staticmethod
-    async def from_name(
-        app_name: str,
-        name: str,
-        *,
-        environment_name: typing.Optional[str] = None,
-        client: typing.Optional[modal.client._Client] = None,
-    ) -> _Sandbox:
-        """Get a running Sandbox by name from a deployed App.
-
-        A Sandbox's name is the `name` argument passed to `Sandbox.create`.
-
-        Args:
-            app_name: Name of the deployed app to look up the sandbox under.
-            name: Sandbox name to resolve.
-            environment_name: Optional environment name for the lookup; defaults to the configured environment.
-            client: Modal client to use for the RPC; defaults to `Client.from_env()` when omitted.
-
-        Returns:
-            A `Sandbox` handle for the running sandbox.
-
-        Raises:
-            NotFoundError: If no running sandbox exists with the given name.
-        """
-        ...
-
-    @staticmethod
-    async def _experimental_from_name(
-        app_name: str,
-        name: str,
-        *,
-        environment_name: typing.Optional[str] = None,
-        client: typing.Optional[modal.client._Client] = None,
-    ) -> _Sandbox:
-        """Get a running V2 Sandbox by name from a deployed App.
-
-        This looks up V2 sandboxes, ie sandboxes created via `modal.Sandbox._experimental_create`.
-
-        Args:
-            app_name: Name of the deployed app to look up the sandbox under.
-            name: Sandbox name to resolve.
-            environment_name: Optional environment name for the lookup; defaults to the configured environment.
-            client: Modal client to use for the RPC; defaults to `Client.from_env()` when omitted.
-
-        Returns:
-            A `Sandbox` handle for the running sandbox.
-
-        Raises:
-            NotFoundError: If no running sandbox exists with the given name.
-        """
-        ...
-
-    @staticmethod
-    async def from_id(sandbox_id: str, client: typing.Optional[modal.client._Client] = None) -> _Sandbox:
-        """Construct a Sandbox from an id and look up the Sandbox result.
-
-        The ID of a Sandbox object can be accessed using `.object_id`.
-
-        Args:
-            sandbox_id: Sandbox object ID to attach to.
-            client: Modal client to use for the lookup; defaults to the environment client when omitted.
-
-        Returns:
-            A `Sandbox` handle with any available result metadata populated from the server.
-        """
-        ...
-
-    async def get_tags(self) -> dict[str, str]:
-        """Fetches any tags (key-value pairs) currently attached to this Sandbox from the server.
-
-        Returns:
-            Tags as a map from tag name to tag value.
-        """
-        ...
-
-    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.
-        """
-        ...
-
-    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)`.
-        Repeating the Sandbox's current name is idempotent and succeeds, so
-        the call is safe to retry.
-
-        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 different name or is no longer running.
-        """
-        ...
-
-    async def _experimental_set_outbound_network_policy(
-        self,
-        *,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-    ) -> None:
-        """Replace the outbound network policy of a running Sandbox.
-
-        Established connections that the new policy no longer permits are
-        terminated.
-
-        Args:
-            outbound_cidr_allowlist: List of CIDRs the Sandbox is allowed to access. If None, all CIDRs are allowed.
-            outbound_domain_allowlist: List of domain names the Sandbox is allowed to access. Supports
-                wildcard prefixes (``*.``); a bare ``"*"`` allows all domains.
-        """
-        ...
-
-    async def _experimental_update_outbound_policy(
-        self, outbound_policy: modal._outbound_policy._OutboundPolicy
-    ) -> None:
-        """Replace the outbound policy of a running Sandbox.
-
-        This API is experimental and may change in the future.
-
-        The new policy replaces all existing policy configuration on the
-        Sandbox; build a policy including any existing rules you want to keep.
-
-        Only Sandboxes created with an `_experimental_outbound_policy` can be
-        updated this way; for Sandboxes created without one this fails, since
-        header replacement is only set up at creation time.
-
-        Args:
-            outbound_policy: The new policy to apply.
-        """
-        ...
-
-    async def _experimental_get_exit_snapshot(self, timeout: typing.Optional[float] = None) -> modal._image._Image:
-        """Get the exit filesystem snapshot image.
-
-        An exit snapshot captures the Sandbox filesystem when the Sandbox exits,
-        whether its entrypoint finishes gracefully, abruptly, or it is stopped with
-        `terminate()`. Exit snapshots are opt-in: the Sandbox must have been
-        created with `experimental_options={"enable_exit_snapshot": True}`.
-
-        Args:
-            timeout: Total time to wait in seconds, spread across repeated long
-                polls of at most `_EXIT_SNAPSHOT_LONG_POLL_TIMEOUT` seconds each.
-                `None` (the default) waits until the snapshot reaches a terminal
-                state; `0` performs an immediate check without waiting.
-
-        Returns:
-            The exit snapshot Image.
-
-        Raises:
-            InvalidError: If `timeout` is negative, or if exit snapshot is not
-                enabled for the sandbox.
-            TimeoutError: If `timeout` elapses before the snapshot reaches a
-                terminal state. This includes `timeout=0` when the snapshot is
-                still pending.
-            SnapshotCreationError: Snapshot operation is done and failed.
-                Polling again will not produce an Image; filesystem state is gone.
-            NotFoundError: If the sandbox does not exist.
-            PermissionDeniedError: If the caller cannot access the sandbox.
-        """
-        ...
-
-    async def snapshot_filesystem(
-        self, timeout: int = 55, *, ttl: typing.Optional[int] = 2592000
-    ) -> modal._image._Image:
-        """Snapshot the filesystem of the Sandbox.
-
-        Args:
-            timeout:
-                Maximum time in seconds to wait for the snapshot operation. If the snapshot does not return within
-                that window, the call is cancelled and `modal.exception.TimeoutError` is raised.
-            ttl:
-                The resulting Image is retained for `ttl` seconds (default: 30 days). Pass `ttl=None` to retain
-                the image indefinitely.
-
-        Returns:
-            An [`Image`](https://modal.com/docs/sdk/py/latest/Image) object which can be used to spawn a new
-            Sandbox with the same filesystem.
-        """
-        ...
-
-    async def _snapshot_filesystem(
-        self, timeout: int, *, ttl: typing.Optional[int], container_id: str = ""
-    ) -> modal._image._Image: ...
-    async def _legacy_snapshot_filesystem(self, timeout: int = 55) -> modal._image._Image: ...
-    async def mount_image(
-        self,
-        path: typing.Union[pathlib.PurePosixPath, str],
-        image: modal._image._Image,
-        *,
-        _experimental_encryption_key: typing.Optional[bytes] = None,
-    ):
-        """Mount an Image at a specified path in a running Sandbox.
-
-        `path` should be a directory that is **not** the root path (`/`). If the path doesn't exist
-        it will be created. If it exists and contains data, the previous directory will be replaced
-        by the mount.
-
-        The `image` argument supports any Image that has an object ID, including:
-        - Images built using `image.build()`
-        - Images referenced by ID, e.g. `Image.from_id(...)`
-        - Filesystem/directory snapshots, e.g. created by `.snapshot_directory()` or `.snapshot_filesystem()`
-        - Empty images created with `Image.from_scratch()`
-
-        Args:
-            path: Absolute mount point directory inside the sandbox (not `/`).
-            image: Image to mount at `path` (must be built, referenced by ID, or snapshot-based as described above).
-
-
-        Examples:
-            ```py notest
-            user_project_snapshot: Image = sandbox_session_1.snapshot_directory("/user_project")
-
-            # You can later mount this snapshot to another Sandbox:
-            sandbox_session_2 = modal.Sandbox.create(...)
-            sandbox_session_2.mount_image("/user_project", user_project_snapshot)
-            sandbox_session_2.filesystem.list_files("/user_project")
-            ```
-        """
-        ...
-
-    async def unmount_image(self, path: typing.Union[pathlib.PurePosixPath, str]):
-        """Unmount a previously mounted Image from a running Sandbox.
-
-        `path` must be the exact mount point that was passed to `.mount_image()`.
-        After unmounting, the underlying Sandbox filesystem at that path becomes
-        visible again.
-
-        Args:
-            path: Absolute mount point directory to unmount.
-        """
-        ...
-
-    async def snapshot_directory(
-        self,
-        path: typing.Union[pathlib.PurePosixPath, str],
-        *,
-        timeout: int = 55,
-        ttl: typing.Optional[int] = 2592000,
-        _experimental_encryption_key: typing.Optional[bytes] = None,
-    ) -> modal._image._Image:
-        """Snapshot a directory in a running Sandbox, creating a new Image with its content.
-
-        `timeout` If the snapshot does not return within that window, the call is cancelled
-        and `modal.exception.TimeoutError` is raised.
-
-        `ttl` The resulting Image is retained for `ttl` seconds (default: 30 days)
-        Pass `ttl=None` to retain the image indefinitely.
-
-        Args:
-            path: Absolute path of the directory inside the sandbox to snapshot.
-
-        Returns:
-            An `Image` containing the directory contents.
-
-        Examples:
-            ```py notest
-            user_project_snapshot: Image = sandbox_session_1.snapshot_directory("/user_project")
-
-            # You can later mount this snapshot to another Sandbox:
-            sandbox_session_2 = modal.Sandbox.create(...)
-            sandbox_session_2.mount_image("/user_project", user_project_snapshot)
-            sandbox_session_2.filesystem.list_files("/user_project")
-            ```
-        """
-        ...
-
-    async def wait(self, raise_on_termination: bool = True):
-        """Wait for the Sandbox to finish running.
-
-        Args:
-            raise_on_termination: If True, raise when the sandbox is terminated externally.
-        """
-        ...
-
-    async def wait_until_ready(self, *, timeout: int = 300) -> None:
-        """Wait for the Sandbox readiness probe to report that the Sandbox is ready.
-
-        The Sandbox must be configured with a `readiness_probe` in order to use this method.
-
-        Args:
-            timeout: Maximum time in seconds to wait for readiness.
-
-
-        Examples:
-            ```py notest
-            app = modal.App.lookup('sandbox-wait-until-ready', create_if_missing=True)
-            sandbox = modal.Sandbox.create(
-                "python3", "-m", "http.server", "8080",
-                readiness_probe=modal.Probe.with_tcp(8080),
-                app=app,
-            )
-            sandbox.wait_until_ready()
-            ```
-        """
-        ...
-
-    async def tunnels(self, timeout: int = 50) -> dict[int, modal._tunnel.Tunnel]:
-        """Get Tunnel metadata for the sandbox.
-
-        NOTE: Previous to client [v0.64.153](https://modal.com/docs/sdk/py/changelog#064153-2024-09-30), this
-        returned a list of `TunnelData` objects.
-
-        Args:
-            timeout: Maximum time in seconds to wait for tunnel metadata when not already cached.
-
-        Returns:
-            A dictionary mapping container port to `Tunnel` metadata.
-
-        Raises:
-            SandboxTimeoutError: If the tunnels are not available after the timeout.
-        """
-        ...
-
-    async def create_connect_token(
-        self, user_metadata: typing.Union[str, dict[str, typing.Any], None] = None, port: int = 8080
-    ) -> modal.types.SandboxConnectCredentials:
-        """Create a token for making HTTP connections to the Sandbox.
-
-        Accepts an optional user_metadata string or dict to associate with the token. This metadata
-        will be added to the headers by the proxy when forwarding requests to the Sandbox.
-        Also accepts a port that requests will be routed to.
-
-        Args:
-            user_metadata: Optional JSON-serializable metadata or string stored with the connect token.
-            port: Optional container port that requests are routed to when using this token.
-
-        Returns:
-            URL and token credentials for connecting to the sandbox over HTTP.
-        """
-        ...
-
-    async def reload_volumes(self, *, timeout: int = 55) -> None:
-        """Reload all Volumes mounted in the Sandbox.
-
-        Added in v1.1.0.
-
-        Blocks until the reload completes, or raises `modal.exception.TimeoutError` on timeout (the reload
-        may still complete in the background).
-
-        Args:
-            timeout: Defaults to 55 seconds.
-        """
-        ...
-
-    async def _reload_volumes(self, *, timeout: int, container_id: str = "") -> None: ...
-    @typing.overload
-    async def terminate(self, *, wait: typing.Literal[True]) -> int: ...
-    @typing.overload
-    async def terminate(self, *, wait: typing.Literal[False] = False) -> None: ...
-    async def poll(self) -> typing.Optional[int]:
-        """Check if the Sandbox has finished running.
-
-        Returns:
-            `None` if the Sandbox is still running, otherwise the exit code.
-        """
-        ...
-
-    async def _get_task_id(
-        self, raise_if_task_complete=False, timeout: typing.Optional[float] = None, retry_transient: bool = False
-    ) -> str: ...
-    async def _resolve_task_id_for_logs(self) -> str:
-        """Try to resolve the task ID in one shot for historical log fetches.
-
-        For a historical log api, we should not wait for the task to be created.
-        If the Sandbox created logs worth fetching, the task ID should be available.
-        """
-        ...
-
-    async def _get_command_router_client(
-        self, task_id: str
-    ) -> modal._utils.task_command_router_client.TaskCommandRouterClient: ...
-    @property
-    def _experimental_sidecars(self) -> _SidecarManager:
-        """Manage sidecar containers running in this Sandbox."""
-        ...
-
-    @typing.overload
-    async def exec(
-        self,
-        *args: str,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        text: typing.Literal[True] = True,
-        bufsize: typing.Literal[-1, 1] = -1,
-        pty: bool = False,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        _pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-    ) -> modal.container_process._ContainerProcess[str]: ...
-    @typing.overload
-    async def exec(
-        self,
-        *args: str,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        text: typing.Literal[False] = False,
-        bufsize: typing.Literal[-1, 1] = -1,
-        pty: bool = False,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        _pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-    ) -> modal.container_process._ContainerProcess[bytes]: ...
-    async def _exec(
-        self,
-        *args: str,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        text: bool = True,
-        bufsize: typing.Literal[-1, 1] = -1,
-        container_id: typing.Optional[str] = None,
-    ) -> typing.Union[modal.container_process._ContainerProcess[bytes], modal.container_process._ContainerProcess[str]]:
-        """Private method used internally.
-
-        This method exposes some internal arguments (currently `pty_info`) which are not in the public API.
-        """
-        ...
-
-    async def _exec_through_command_router(
-        self,
-        *args: str,
-        task_id: str,
-        command_router_client: modal._utils.task_command_router_client.TaskCommandRouterClient,
-        pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
-        env: typing.Optional[dict[str, str]] = None,
-        text: bool = True,
-        bufsize: typing.Literal[-1, 1] = -1,
-        runtime_debug: bool = False,
-        container_id: typing.Optional[str] = None,
-    ) -> typing.Union[modal.container_process._ContainerProcess[bytes], modal.container_process._ContainerProcess[str]]:
-        """Execute a command through a task command router running on the Modal worker."""
-        ...
-
-    async def _experimental_snapshot(self) -> modal.snapshot._SandboxSnapshot: ...
-    @staticmethod
-    async def _experimental_from_snapshot(
-        snapshot: modal.snapshot._SandboxSnapshot,
-        client: typing.Optional[modal.client._Client] = None,
-        *,
-        name: typing.Optional[str] = _DEFAULT_SANDBOX_NAME_OVERRIDE,
-    ):
-        """Restore a Sandbox from a memory snapshot.
-
-        The restore targets the same backend the snapshot was taken from. A V1
-        snapshot restores as a V1 sandbox, a V2 snapshot as a V2 sandbox.
-        """
-        ...
-
-    @staticmethod
-    async def _experimental_from_snapshot_v2(
-        snapshot: modal.snapshot._SandboxSnapshot,
-        client: modal.client._Client,
-        *,
-        override_type: int,
-        name_override: typing.Optional[str],
-    ) -> _Sandbox: ...
-    @property
-    def filesystem(self) -> modal.sandbox_fs._SandboxFilesystem:
-        """Namespace for Sandbox filesystem APIs."""
-        ...
-
-    @property
-    def stdout(self) -> modal.io_streams._StreamReader[str]:
-        """[`StreamReader`](https://modal.com/docs/sdk/py/latest/io_streams#streamreader)
-        for the sandbox's stdout stream.
-
-        Returns:
-            Stream reader for sandbox stdout.
-        """
-        ...
-
-    @property
-    def stderr(self) -> modal.io_streams._StreamReader[str]:
-        """[`StreamReader`](https://modal.com/docs/sdk/py/latest/io_streams#streamreader)
-        for the Sandbox's stderr stream.
-
-        Returns:
-            Stream reader for sandbox stderr.
-        """
-        ...
-
-    @property
-    def stdin(self) -> modal.io_streams._StreamWriter:
-        """[`StreamWriter`](https://modal.com/docs/sdk/py/latest/io_streams#streamwriter)
-        for the Sandbox's stdin stream.
-
-        Returns:
-            Stream writer for sandbox stdin.
-        """
-        ...
-
-    @property
-    def returncode(self) -> typing.Optional[int]:
-        """Return code of the Sandbox process if it has finished running, else `None`.
-
-        Returns:
-            Exit code when the sandbox process has completed, otherwise None.
-        """
-        ...
-
-    @staticmethod
-    def list(
-        *,
-        app_id: typing.Optional[str] = None,
-        tags: typing.Optional[dict[str, str]] = None,
-        client: typing.Optional[modal.client._Client] = None,
-    ) -> collections.abc.AsyncGenerator[_Sandbox, None]:
-        """List all Sandboxes for the current Environment or App ID (if specified). If tags are specified, only
-        Sandboxes that have at least those tags are returned.
-
-        Args:
-            app_id: If set, restrict results to sandboxes under this app ID.
-            tags: If set, only sandboxes containing at least these tags are returned.
-            client: Modal client to use for listing; defaults to `Client.from_env()` when omitted.
-
-        Returns:
-            An async generator yielding `Sandbox` objects.
-        """
-        ...
-
-    @staticmethod
-    def _experimental_list(
-        *,
-        app_id: typing.Optional[str] = None,
-        tags: typing.Optional[dict[str, str]] = None,
-        client: typing.Optional[modal.client._Client] = None,
-    ) -> collections.abc.AsyncGenerator[_Sandbox, None]:
-        """List all sandboxes (both v1 and v2).
-
-        Pass `app_id` to scope to an App; without it, Sandboxes across the current
-        Environment are listed (deprecated — prefer scoping by `app_id`).
-
-        Args:
-            app_id: If set, restrict results to Sandboxes under this App.
-            tags: If set, only sandboxes containing at least these tags are returned.
-            client: Optional client to use for the session.
-
-        Yields:
-            `Sandbox` objects that are currently running.
-        """
-        ...
-
-    async def _get_log_query_data(self) -> modal._supports_logs._LogQueryData: ...
-    @property
-    def logs(self) -> modal._logs_manager._SandboxLogsManager:
-        """Access logs for a `Sandbox` entrypoint.
-
-        Useful for inspecting logs after a Sandbox terminates.
-        Use [`fetch()`](#logsfetch)
-        to read logs from a UTC time range, [`tail()`](#logstail)
-        to read the most recent logs.
-
-        Note that the logs from executed commands in the sandbox (via `exec()`) are not included in the
-        entrypoint logs.
-
-        See also:
-            - [`modal app logs`](https://modal.com/docs/cli/latest/app#modal-app-logs):
-              CLI access to logs for an App.
-        """
-        ...
-
-class _SidecarContainer:
-    """Handle to an additional container running in a Sandbox."""
-
-    _result: typing.Optional[modal_proto.api_pb2.GenericResult]
-    _filesystem: typing.Optional[modal.sandbox_fs._SandboxFilesystem]
-
-    def __init__(
-        self,
-        sandbox: _Sandbox,
-        container_id: str,
-        container_name: str,
-        result: typing.Optional[modal_proto.api_pb2.GenericResult] = None,
-    ) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def object_id(self) -> str: ...
-    @property
-    def name(self) -> str: ...
-    @staticmethod
-    def _from_container_info(
-        sandbox: _Sandbox, container_info: modal_proto.task_command_router_pb2.TaskContainerInfo
-    ) -> _SidecarContainer: ...
-    async def _get_command_router(self) -> tuple[str, modal._utils.task_command_router_client.TaskCommandRouterClient]:
-        """Get task ID and command router client."""
-        ...
-
-    async def snapshot_filesystem(
-        self, timeout: int = 55, *, ttl: typing.Optional[int] = 2592000
-    ) -> modal._image._Image:
-        """Snapshot this Sidecar container's filesystem.
-
-        Args:
-            timeout:
-                Maximum time in seconds to wait for the snapshot operation.
-            ttl:
-                The resulting Image is retained for `ttl` seconds (default: 30 days). Pass `ttl=None` to retain
-                the image indefinitely.
-
-        Returns:
-            An [`Image`](https://modal.com/docs/sdk/py/latest/Image) containing a snapshot of this Sidecar's
-            filesystem.
-        """
-        ...
-
-    @typing.overload
-    async def exec(
-        self,
-        *args: str,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        text: typing.Literal[True] = True,
-        bufsize: typing.Literal[-1, 1] = -1,
-        pty: bool = False,
-    ) -> modal.container_process._ContainerProcess[str]: ...
-    @typing.overload
-    async def exec(
-        self,
-        *args: str,
-        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
-        timeout: typing.Optional[int] = None,
-        workdir: typing.Optional[str] = None,
-        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        text: typing.Literal[False],
-        bufsize: typing.Literal[-1, 1] = -1,
-        pty: bool = False,
-    ) -> modal.container_process._ContainerProcess[bytes]: ...
-    @property
-    def filesystem(self) -> modal.sandbox_fs._SandboxFilesystem:
-        """Namespace for Sandbox filesystem APIs."""
-        ...
-
-    async def mount_image(
-        self,
-        path: typing.Union[pathlib.PurePosixPath, str],
-        image: modal._image._Image,
-        *,
-        _experimental_encryption_key: typing.Optional[bytes] = None,
-    ) -> None:
-        """Mount an Image at a specified path in this Sidecar container.
-
-        `path` should be a directory that is **not** the root path (`/`). If the path doesn't exist,
-        it will be created. If it exists and contains data, the previous directory will be replaced
-        by the mount.
-
-        The `image` argument supports any Image that has an object ID, including:
-        - Images built using `image.build()`
-        - Images referenced by ID, e.g. `Image.from_id(...)`
-        - Filesystem/directory snapshots, e.g. created by `.snapshot_directory()` or `.snapshot_filesystem()`
-        - Empty images created with `Image.from_scratch()`
-
-        Args:
-            path: Absolute mount point directory inside the Sidecar container (not `/`).
-            image: Image to mount at `path` (must be built, referenced by ID, or snapshot-based as described above).
-
-        Examples:
-            ```py notest
-            sidecar_1.mount_image("/workspace", modal.Image.from_scratch())
-            workspace_snapshot = sidecar_1.snapshot_directory("/workspace")
-
-            # You can later mount this snapshot in another Sidecar:
-            sidecar_2.mount_image("/workspace", workspace_snapshot)
-            sidecar_2.filesystem.list_files("/workspace")
-            ```
-        """
-        ...
-
-    async def unmount_image(self, path: typing.Union[pathlib.PurePosixPath, str]) -> None:
-        """Unmount a previously mounted Image from this Sidecar container.
-
-        `path` must be the exact mount point that was passed to `.mount_image()`.
-        After unmounting, the underlying Sidecar filesystem at that path becomes
-        visible again.
-
-        Args:
-            path: Absolute mount point directory to unmount.
-        """
-        ...
-
-    async def snapshot_directory(
-        self,
-        path: typing.Union[pathlib.PurePosixPath, str],
-        *,
-        timeout: int = 55,
-        ttl: typing.Optional[int] = 2592000,
-        _experimental_encryption_key: typing.Optional[bytes] = None,
-    ) -> modal._image._Image:
-        """Snapshot a directory in this Sidecar container, creating a new Image with its content.
-
-        `timeout` If the snapshot does not return within that window, the call is cancelled
-        and `modal.exception.TimeoutError` is raised.
-
-        `ttl` The resulting Image is retained for `ttl` seconds (default: 30 days).
-        Pass `ttl=None` to retain the Image indefinitely.
-
-        The returned Image can be used anywhere an Image is accepted, including
-        as a mount or as the base filesystem for another container.
-
-        Args:
-            path: Absolute path of the directory inside the Sidecar container to snapshot.
-
-        Returns:
-            An `Image` containing the directory contents.
-
-        Examples:
-            ```py notest
-            workspace_snapshot = sidecar_1.snapshot_directory("/workspace")
-
-            # You can later mount this snapshot in another Sidecar:
-            sidecar_2.mount_image("/workspace", workspace_snapshot)
-            sidecar_2.filesystem.list_files("/workspace")
-            ```
-        """
-        ...
-
-    async def wait(self, raise_on_termination: bool = True) -> None: ...
-    async def poll(self) -> typing.Optional[int]: ...
-    @typing.overload
-    async def terminate(self, *, wait: typing.Literal[True]) -> int: ...
-    @typing.overload
-    async def terminate(self, *, wait: typing.Literal[False] = False) -> None: ...
-    async def reload_volumes(self, *, timeout: int = 55) -> None:
-        """Reload all Volumes mounted in this sidecar container.
-
-        EXPERIMENTAL: the API is subject to change.
-
-        Blocks until the reload completes, or raises `modal.exception.TimeoutError` on timeout (the reload
-        may still complete in the background).
-
-        Args:
-            timeout: Defaults to 55 seconds.
-        """
-        ...
-
-def _use_control_plane_sidecar_create(is_v2: bool) -> bool:
-    """Whether a sidecar create request goes to the Modal server rather than over the Sandbox connection.
-
-    V2 Sandboxes do unless opted out via the `use_control_plane_sidecar_create` config
-    setting (`MODAL_USE_CONTROL_PLANE_SIDECAR_CREATE=0`). V1 Sandboxes always create
-    sidecars over the Sandbox connection.
-    """
-    ...
-
-class _SidecarManager:
-    """Creates and manages sidecar containers in a Sandbox."""
-    def __init__(self, sandbox: _Sandbox) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    async def _get_command_router(self) -> tuple[str, modal._utils.task_command_router_client.TaskCommandRouterClient]:
-        """Get task ID and command router client."""
-        ...
-
-    async def create(
-        self,
-        *args: str,
-        name: str,
-        image: modal._image._Image,
-        env: typing.Optional[dict[str, str]] = None,
-        secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
-        workdir: typing.Optional[str] = None,
-        volumes: typing.Optional[
-            dict[
-                typing.Union[str, os.PathLike],
-                typing.Union[modal.volume._Volume, modal.cloud_bucket_mount._CloudBucketMount],
-            ]
-        ] = None,
-        outbound_cidr_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        outbound_domain_allowlist: typing.Optional[collections.abc.Sequence[str]] = None,
-        include_oidc_identity_token: bool = False,
-        proxy: typing.Optional[modal.proxy._Proxy] = None,
-        pty: bool = False,
-        experimental_memory_reserve_consume_mib: typing.Optional[int] = None,
-    ) -> _SidecarContainer:
-        """Create a sidecar container running alongside the Sandbox's main container.
-
-        Sidecar containers share the Sandbox's lifecycle but run their own Image and command. They
-        can be used to run auxiliary processes, such as a database or a service the main container
-        depends on.
-
-        The sidecar's outbound network policy is independent of the main container's and defaults to
-        open network access. To restrict it, pass `outbound_cidr_allowlist` and/or
-        `outbound_domain_allowlist`. To block all external egress while keeping connectivity to the
-        main container, pass an empty allowlist (`outbound_cidr_allowlist=[]`); a fully network-blocked
-        sidecar is not supported because it would have no IP and could not reach the main container.
-
-        Args:
-            *args: Command and arguments to run inside the sidecar container.
-            name: Unique name for the sidecar container. The name ``"main"`` is reserved.
-            image: Image to run the sidecar container with. Must be a pre-built or referenced Image.
-            env: Environment variables to set in the sidecar container.
-            secrets: Secrets to inject as environment variables in the sidecar container.
-            workdir: Working directory for the command; must be absolute if set.
-            volumes: Mapping of mount paths to `Volume` or `CloudBucketMount` objects to mount in the
-                sidecar container. Cloud bucket mounts are not supported for GPU Sandboxes.
-            outbound_cidr_allowlist: If set, restrict the sidecar's outbound traffic to these CIDR
-                blocks. An empty list blocks all external egress while preserving connectivity to the
-                main container.
-            outbound_domain_allowlist: If set, restrict the sidecar's outbound TLS connections (port
-                443) to these SNI domains. Supports wildcards like ``*.example.com``.
-            include_oidc_identity_token: If True, the sidecar receives a MODAL_IDENTITY_TOKEN env var for
-                OIDC-based auth (e.g. to AWS, GCP). The token identifies the sidecar container itself,
-                not the main container. Not supported for GPU Sandboxes.
-            proxy: Reference to a Modal Proxy to use in front of this sidecar. Not supported for GPU
-                Sandboxes.
-            pty: Whether to enable PTY for the sidecar container.
-            experimental_memory_reserve_consume_mib: Memory, in MiB, this sidecar consumes from the Sandbox's
-                sidecar memory reserve (the experimental `vm_sidecar_memory_reserve_mib` option).
-                Unset consumes whatever is left of the reserve; creation fails if the request exceeds
-                what is left. Ignored by Sandboxes without a reserve.
-
-        Returns:
-            A `SidecarContainer` handle for the running container.
-        """
-        ...
-
-    async def get(self, *, name: str, include_terminated: bool = False) -> _SidecarContainer: ...
-    async def list(self, include_terminated: bool = False) -> list[_SidecarContainer]: ...
-
-class ___container_exec_spec(typing_extensions.Protocol):
-    def __call__(
-        self,
-        /,
-        pty: bool,
-        container_id: str = "",
-        command: tuple[str, ...] = (),
-        sandbox_id_v2: typing.Optional[str] = None,
-    ):
-        """Execute a command in a container.
-
-        For tasks belonging to V2 sandboxes, `sandbox_id_v2` may be set to the
-        sandbox ID; otherwise the V2 backend is used whenever the task ID itself
-        marks a V2 sandbox task.
-        """
-        ...
-
-    async def aio(
-        self,
-        /,
-        pty: bool,
-        container_id: str = "",
-        command: tuple[str, ...] = (),
-        sandbox_id_v2: typing.Optional[str] = None,
-    ):
-        """Execute a command in a container.
-
-        For tasks belonging to V2 sandboxes, `sandbox_id_v2` may be set to the
-        sandbox ID; otherwise the V2 backend is used whenever the task ID itself
-        marks a V2 sandbox task.
-        """
-        ...
-
-_container_exec: ___container_exec_spec
-
 class SidecarContainer:
     """Handle to an additional container running in a Sandbox."""
 
@@ -1968,7 +615,7 @@ class Sandbox(modal.object.Object):
         h2_ports: collections.abc.Sequence[int] = [],
         unencrypted_ports: collections.abc.Sequence[int] = [],
         proxy: typing.Optional[modal.proxy.Proxy] = None,
-        readiness_probe: typing.Optional[Probe] = None,
+        readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
         tags: typing.Optional[dict[str, str]] = None,
         enable_snapshot: bool = False,
@@ -2019,7 +666,7 @@ class Sandbox(modal.object.Object):
             custom_domain: typing.Optional[str] = None,
             proxy: typing.Optional[modal.proxy.Proxy] = None,
             include_oidc_identity_token: bool = False,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             verbose: bool = False,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             _experimental_enable_snapshot: bool = False,
@@ -2143,7 +790,7 @@ class Sandbox(modal.object.Object):
             custom_domain: typing.Optional[str] = None,
             proxy: typing.Optional[modal.proxy.Proxy] = None,
             include_oidc_identity_token: bool = False,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             verbose: bool = False,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             _experimental_enable_snapshot: bool = False,
@@ -2270,7 +917,7 @@ class Sandbox(modal.object.Object):
             unencrypted_ports: collections.abc.Sequence[int] = [],
             proxy: typing.Optional[modal.proxy.Proxy] = None,
             include_oidc_identity_token: bool = False,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             _experimental_enable_snapshot: bool = False,
             client: typing.Optional[modal.client.Client] = None,
@@ -2324,7 +971,7 @@ class Sandbox(modal.object.Object):
             unencrypted_ports: collections.abc.Sequence[int] = [],
             proxy: typing.Optional[modal.proxy.Proxy] = None,
             include_oidc_identity_token: bool = False,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             _experimental_enable_snapshot: bool = False,
             client: typing.Optional[modal.client.Client] = None,
@@ -2377,7 +1024,7 @@ class Sandbox(modal.object.Object):
             h2_ports: collections.abc.Sequence[int] = [],
             unencrypted_ports: collections.abc.Sequence[int] = [],
             proxy: typing.Optional[modal.proxy.Proxy] = None,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             include_oidc_identity_token: bool = False,
             verbose: bool = False,
@@ -2451,7 +1098,7 @@ class Sandbox(modal.object.Object):
             h2_ports: collections.abc.Sequence[int] = [],
             unencrypted_ports: collections.abc.Sequence[int] = [],
             proxy: typing.Optional[modal.proxy.Proxy] = None,
-            readiness_probe: typing.Optional[Probe] = None,
+            readiness_probe: typing.Optional[modal.sandbox._sandbox.Probe] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             include_oidc_identity_token: bool = False,
             verbose: bool = False,
@@ -3526,8 +2173,7 @@ class Sandbox(modal.object.Object):
             stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
             timeout: typing.Optional[int] = None,
             workdir: typing.Optional[str] = None,
-            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
-            env: typing.Optional[dict[str, str]] = None,
+            secret_sources: typing.Optional[collections.abc.Collection[modal_proto.api_pb2.SecretSource]] = None,
             text: bool = True,
             bufsize: typing.Literal[-1, 1] = -1,
             runtime_debug: bool = False,
@@ -3549,8 +2195,7 @@ class Sandbox(modal.object.Object):
             stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
             timeout: typing.Optional[int] = None,
             workdir: typing.Optional[str] = None,
-            secret_ids: typing.Optional[collections.abc.Collection[str]] = None,
-            env: typing.Optional[dict[str, str]] = None,
+            secret_sources: typing.Optional[collections.abc.Collection[modal_proto.api_pb2.SecretSource]] = None,
             text: bool = True,
             bufsize: typing.Literal[-1, 1] = -1,
             runtime_debug: bool = False,
@@ -3576,7 +2221,7 @@ class Sandbox(modal.object.Object):
             snapshot: modal.snapshot.SandboxSnapshot,
             client: typing.Optional[modal.client.Client] = None,
             *,
-            name: typing.Optional[str] = _DEFAULT_SANDBOX_NAME_OVERRIDE,
+            name: typing.Optional[str] = modal.sandbox._sandbox._DEFAULT_SANDBOX_NAME_OVERRIDE,
         ):
             """Restore a Sandbox from a memory snapshot.
 
@@ -3591,7 +2236,7 @@ class Sandbox(modal.object.Object):
             snapshot: modal.snapshot.SandboxSnapshot,
             client: typing.Optional[modal.client.Client] = None,
             *,
-            name: typing.Optional[str] = _DEFAULT_SANDBOX_NAME_OVERRIDE,
+            name: typing.Optional[str] = modal.sandbox._sandbox._DEFAULT_SANDBOX_NAME_OVERRIDE,
         ):
             """Restore a Sandbox from a memory snapshot.
 
@@ -3786,10 +2431,37 @@ class Sandbox(modal.object.Object):
         """
         ...
 
-_default_image: modal._image._Image
+class ___container_exec_spec(typing_extensions.Protocol):
+    def __call__(
+        self,
+        /,
+        pty: bool,
+        container_id: str = "",
+        command: tuple[str, ...] = (),
+        sandbox_id_v2: typing.Optional[str] = None,
+    ):
+        """Execute a command in a container.
+
+        For tasks belonging to V2 sandboxes, `sandbox_id_v2` may be set to the
+        sandbox ID; otherwise the V2 backend is used whenever the task ID itself
+        marks a V2 sandbox task.
+        """
+        ...
 
-_SANDBOX_SCHEDULING_TIMEOUT: float
+    async def aio(
+        self,
+        /,
+        pty: bool,
+        container_id: str = "",
+        command: tuple[str, ...] = (),
+        sandbox_id_v2: typing.Optional[str] = None,
+    ):
+        """Execute a command in a container.
 
-_TASK_ID_POLL_INTERVAL: float
+        For tasks belonging to V2 sandboxes, `sandbox_id_v2` may be set to the
+        sandbox ID; otherwise the V2 backend is used whenever the task ID itself
+        marks a V2 sandbox task.
+        """
+        ...
 
-_MAIN_CONTAINER_NAME: str
+_container_exec: ___container_exec_spec