modal 1.4.4.dev6__tar.gz → 1.4.4.dev8__tar.gz

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/PKG-INFO

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

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/_runtime/asgi.py

@@ -285,7 +285,7 @@ def wait_for_web_server(host: str, port: int, *, timeout: float) -> None:
     start_time = time.monotonic()
     while True:
         try:
-            with socket.create_connection((host, port), timeout=timeout):
+            with socket.create_connection((host, port), timeout=min(timeout, 1.0)):
                 break
         except OSError as ex:
             time.sleep(0.01)

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/cli/shell.py

@@ -2,7 +2,7 @@
 import platform
 import shlex
 from pathlib import Path, PurePosixPath
-from typing import Any, Callable, Iterable, Optional
+from typing import Any, Callable, Iterable, Optional, Union
 
 import click
 from click import ClickException
@@ -10,12 +10,13 @@ from click import ClickException
 from .._environments import ensure_env
 from .._functions import _FunctionSpec
 from ..app import App
+from ..container_process import ContainerProcess
 from ..exception import InvalidError, NotFoundError
 from ..functions import Function
 from ..image import Image
 from ..mount import _Mount
 from ..runner import interactive_shell
-from ..sandbox import Sandbox
+from ..sandbox import _MAIN_CONTAINER_NAME, Sandbox
 from ..secret import Secret
 from ..stream_type import StreamType
 from ..volume import Volume
@@ -105,8 +106,8 @@ def _is_running_container_ref(ref: Optional[str]) -> bool:
     return _is_valid_modal_id(sandbox_id, "sb-") or _is_valid_modal_id(ref, "ta-")
 
 
-def _start_shell_in_sandbox_container(sandbox_id: str, container_name: str, cmd: str, pty: bool) -> None:
-    """Shell into a named container within a sandbox."""
+def _start_shell_in_sidecar_container(sandbox_id: str, container_name: str, cmd: str, pty: bool) -> None:
+    """Shell into a sidecar container within a sandbox."""
     try:
         sandbox = Sandbox.from_id(sandbox_id)
     except NotFoundError:
@@ -115,18 +116,19 @@ def _start_shell_in_sandbox_container(sandbox_id: str, container_name: str, cmd:
         raise ClickException(f"Error connecting to Sandbox '{sandbox_id}': {str(e)}")
 
     try:
-        sandbox_container = sandbox._experimental_containers.get(name=container_name)
+        sandbox_container = sandbox._experimental_sidecars.get(name=container_name)
+        process: Union[ContainerProcess[bytes], ContainerProcess[str]]
         if pty:
             # PTY output is raw terminal bytes, not text; strict UTF-8 decode
             # crashes on the first non-UTF-8 byte (e.g. vim drawing a Latin-1
             # file under LC_CTYPE=C). See the matching call in `_exec_impl`.
-            process = sandbox_container.exec(*shlex.split(cmd), pty=pty, text=False)
+            process = sandbox_container.exec(*shlex.split(cmd), pty=True, text=False)
             process.attach()
         else:
             process = sandbox_container.exec(
-                *shlex.split(cmd), pty=pty, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+                *shlex.split(cmd), pty=False, text=False, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
             )
-            process.wait()
+            _ = process.wait()
     except NotFoundError:
         raise ClickException(f"Container '{container_name}' not found in Sandbox '{sandbox_id}'.")
     except Exception as e:
@@ -136,8 +138,8 @@ def _start_shell_in_sandbox_container(sandbox_id: str, container_name: str, cmd:
 def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
     sandbox_id, container_name = _parse_sandbox_container_ref(ref)
 
-    if container_name is not None:
-        return _start_shell_in_sandbox_container(sandbox_id, container_name, cmd, pty)
+    if container_name is not None and container_name != _MAIN_CONTAINER_NAME:
+        return _start_shell_in_sidecar_container(sandbox_id, container_name, cmd, pty)
 
     if _is_valid_modal_id(sandbox_id, "sb-"):
         try:

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/client.pyi

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

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/io_streams.py

@@ -501,7 +501,7 @@ class _StreamReader(Generic[T]):
 MAX_BUFFER_SIZE = 2 * 1024 * 1024
 # Larger buffer limit for the exec path via the task command router.
 # This applies only to task_exec_stdin_write; sandbox stdin via the server keeps MAX_BUFFER_SIZE.
-TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE = 16 * 1024 * 1024
+TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE: int = 16 * 1024 * 1024
 
 
 @dataclass(frozen=True)

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/io_streams.pyi

@@ -589,3 +589,5 @@ class StreamWriter:
             ...
 
     drain: __drain_spec
+
+TASK_COMMAND_ROUTER_MAX_BUFFER_SIZE: int

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/sandbox.py

@@ -5,6 +5,7 @@ import enum
 import json
 import os
 import time
+import typing
 import uuid
 from collections.abc import AsyncGenerator, Collection, Sequence
 from dataclasses import dataclass
@@ -1385,10 +1386,10 @@ class _Sandbox(_Object, type_prefix="sb"):
         return self._command_router_client
 
     @property
-    def _experimental_containers(self) -> "_SandboxContainerManager":
-        """Manage additional containers running in this Sandbox."""
+    def _experimental_sidecars(self) -> "_SidecarManager":
+        """Manage sidecar containers running in this Sandbox."""
         self._ensure_attached()
-        return _SandboxContainerManager(self)
+        return _SidecarManager(self)
 
     @overload
     async def exec(
@@ -1853,10 +1854,11 @@ class _Sandbox(_Object, type_prefix="sb"):
             before_timestamp = resp.sandboxes[-1].created_at
 
 
-class _SandboxContainer:
+class _SidecarContainer:
     """Handle to an additional container running in a Sandbox."""
 
     _result: Optional[api_pb2.GenericResult]
+    _filesystem: Optional[_SandboxFilesystem]
 
     def __init__(
         self,
@@ -1869,6 +1871,7 @@ class _SandboxContainer:
         self._container_id = container_id
         self._container_name = container_name
         self._result = result
+        self._filesystem = None
 
     @property
     def object_id(self) -> str:
@@ -1879,9 +1882,9 @@ class _SandboxContainer:
         return self._container_name
 
     @staticmethod
-    def _from_container_info(sandbox: "_Sandbox", container_info: sr_pb2.TaskContainerInfo) -> "_SandboxContainer":
+    def _from_container_info(sandbox: "_Sandbox", container_info: sr_pb2.TaskContainerInfo) -> "_SidecarContainer":
         result = container_info.result if container_info.HasField("result") else None
-        return _SandboxContainer(sandbox, container_info.container_id, container_info.container_name, result)
+        return _SidecarContainer(sandbox, container_info.container_id, container_info.container_name, result)
 
     async def _get_command_router(self) -> tuple[str, "TaskCommandRouterClient"]:
         """Get task ID and command router client."""
@@ -1889,6 +1892,40 @@ class _SandboxContainer:
         command_router_client = await self._sandbox._get_command_router_client(task_id)
         return task_id, command_router_client
 
+    @typing.overload
+    async def exec(
+        self,
+        *args: str,
+        stdout: StreamType = StreamType.PIPE,
+        stderr: StreamType = StreamType.PIPE,
+        timeout: Optional[int] = None,
+        workdir: Optional[str] = None,
+        env: Optional[dict[str, Optional[str]]] = None,
+        secrets: Optional[Collection[_Secret]] = None,
+        text: Literal[True] = True,
+        bufsize: Literal[-1, 1] = -1,
+        # Enable a PTY for the command. When enabled, all output (stdout and stderr from the
+        # process) is multiplexed into stdout, and the stderr stream is effectively empty.
+        pty: bool = False,
+    ) -> _ContainerProcess[str]: ...
+
+    @typing.overload
+    async def exec(
+        self,
+        *args: str,
+        stdout: StreamType = StreamType.PIPE,
+        stderr: StreamType = StreamType.PIPE,
+        timeout: Optional[int] = None,
+        workdir: Optional[str] = None,
+        env: Optional[dict[str, Optional[str]]] = None,
+        secrets: Optional[Collection[_Secret]] = None,
+        text: Literal[False],
+        bufsize: Literal[-1, 1] = -1,
+        # Enable a PTY for the command. When enabled, all output (stdout and stderr from the
+        # process) is multiplexed into stdout, and the stderr stream is effectively empty.
+        pty: bool = False,
+    ) -> _ContainerProcess[bytes]: ...
+
     async def exec(
         self,
         *args: str,
@@ -1919,6 +1956,13 @@ class _SandboxContainer:
             container_id=self._container_id,
         )
 
+    @property
+    def filesystem(self) -> _SandboxFilesystem:
+        """Namespace for filesystem APIs."""
+        if self._filesystem is None:
+            self._filesystem = _SandboxFilesystem(self)
+        return self._filesystem
+
     async def wait(self, raise_on_termination: bool = True) -> None:
         if self._result is not None and self._result.status != api_pb2.GenericResult.GENERIC_STATUS_UNSPECIFIED:
             if self._result.status == api_pb2.GenericResult.GENERIC_STATUS_TERMINATED and raise_on_termination:
@@ -1987,8 +2031,11 @@ class _SandboxContainer:
             return _result_returncode(self._result)
 
 
-class _SandboxContainerManager:
-    """Creates and manages additional containers in a Sandbox."""
+_MAIN_CONTAINER_NAME: str = "main"
+
+
+class _SidecarManager:
+    """Creates and manages sidecar containers in a Sandbox."""
 
     def __init__(self, sandbox: _Sandbox) -> None:
         self._sandbox = sandbox
@@ -2007,22 +2054,24 @@ class _SandboxContainerManager:
         env: Optional[dict[str, str]] = None,
         secrets: Optional[Collection[_Secret]] = None,
         workdir: Optional[str] = None,
-    ) -> _SandboxContainer:
+    ) -> _SidecarContainer:
+        if name == _MAIN_CONTAINER_NAME:
+            raise InvalidError(f"The name {_MAIN_CONTAINER_NAME!r} is reserved for the sandbox's main container.")
         if workdir is not None and not workdir.startswith("/"):
             raise InvalidError(f"workdir must be an absolute path, got: {workdir}")
         _validate_exec_args(args)
 
         if image._mount_layers:
             raise InvalidError(
-                "Sandbox._experimental_containers.create(image=...) only supports pre-built images. "
+                "Sandbox._experimental_sidecars.create(image=...) only supports pre-built images. "
                 "When using `add_local*` methods, specify `copy=True` and call `.build()` before passing "
-                "the image to `._experimental_containers.create()`:\n\nE.g.\n"
+                "the image to `._experimental_sidecars.create()`:\n\nE.g.\n"
                 'img = modal.Image.debian_slim().add_local_file("foo", "/foo", copy=True).build(app)\n'
-                'sandbox._experimental_containers.create(name="worker", image=img)'
+                'sandbox._experimental_sidecars.create(name="worker", image=img)'
             )
         if not image._object_id:
             raise InvalidError(
-                "Sandbox._experimental_containers.create(image=...) currently only supports Images that are "
+                "Sandbox._experimental_sidecars.create(image=...) currently only supports Images that are "
                 "either:\n"
                 "- prebuilt using `image.build()`\n"
                 "- referenced by id, e.g. `Image.from_id()`\n"
@@ -2048,9 +2097,14 @@ class _SandboxContainerManager:
         create_resp = await command_router_client.container_create(create_req)
         container_id = create_resp.container_id
         container_name = create_resp.container_name or name
-        return _SandboxContainer(self._sandbox, container_id, container_name)
+        return _SidecarContainer(self._sandbox, container_id, container_name)
 
-    async def get(self, *, name: str, include_terminated: bool = False) -> "_SandboxContainer":
+    async def get(self, *, name: str, include_terminated: bool = False) -> "_SidecarContainer":
+        if name == _MAIN_CONTAINER_NAME:
+            raise InvalidError(
+                "Cannot get the main sandbox container through the sidecars API. "
+                "Use Sandbox methods directly to interact with the main container."
+            )
         task_id, command_router_client = await self._get_command_router()
         resp = await command_router_client.container_get(
             sr_pb2.TaskContainerGetRequest(
@@ -2059,16 +2113,20 @@ class _SandboxContainerManager:
                 include_terminated=include_terminated,
             )
         )
-        return _SandboxContainer._from_container_info(self._sandbox, resp.container)
+        return _SidecarContainer._from_container_info(self._sandbox, resp.container)
 
-    async def list(self, include_terminated: bool = False) -> builtins.list[_SandboxContainer]:
+    async def list(self, include_terminated: bool = False) -> builtins.list[_SidecarContainer]:
         task_id, command_router_client = await self._get_command_router()
         resp = await command_router_client.container_list(
             sr_pb2.TaskContainerListRequest(task_id=task_id, include_terminated=include_terminated)
         )
-        return [_SandboxContainer._from_container_info(self._sandbox, container) for container in resp.containers]
+        return [
+            _SidecarContainer._from_container_info(self._sandbox, container)
+            for container in resp.containers
+            if container.container_name != _MAIN_CONTAINER_NAME
+        ]
 
 
-SandboxContainer = synchronize_api(_SandboxContainer)
-SandboxContainerManager = synchronize_api(_SandboxContainerManager)
+SidecarContainer = synchronize_api(_SidecarContainer)
+SidecarManager = synchronize_api(_SidecarManager)
 Sandbox = synchronize_api(_Sandbox)

{modal-1.4.4.dev6 → modal-1.4.4.dev8}/modal/sandbox.pyi

@@ -533,8 +533,8 @@ class _Sandbox(modal._object._Object):
         self, task_id: str
     ) -> modal._utils.task_command_router_client.TaskCommandRouterClient: ...
     @property
-    def _experimental_containers(self) -> _SandboxContainerManager:
-        """Manage additional containers running in this Sandbox."""
+    def _experimental_sidecars(self) -> _SidecarManager:
+        """Manage sidecar containers running in this Sandbox."""
         ...
 
     @typing.overload
@@ -697,10 +697,11 @@ class _Sandbox(modal._object._Object):
         """
         ...
 
-class _SandboxContainer:
+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,
@@ -719,11 +720,12 @@ class _SandboxContainer:
     @staticmethod
     def _from_container_info(
         sandbox: _Sandbox, container_info: modal_proto.task_command_router_pb2.TaskContainerInfo
-    ) -> _SandboxContainer: ...
+    ) -> _SidecarContainer: ...
     async def _get_command_router(self) -> tuple[str, modal._utils.task_command_router_client.TaskCommandRouterClient]:
         """Get task ID and command router client."""
         ...
 
+    @typing.overload
     async def exec(
         self,
         *args: str,
@@ -733,12 +735,29 @@ class _SandboxContainer:
         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,
+        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,
-    ) -> typing.Union[
-        modal.container_process._ContainerProcess[bytes], modal.container_process._ContainerProcess[str]
-    ]: ...
+    ) -> modal.container_process._ContainerProcess[bytes]: ...
+    @property
+    def filesystem(self) -> modal.sandbox_fs._SandboxFilesystem:
+        """Namespace for filesystem APIs."""
+        ...
+
     async def wait(self, raise_on_termination: bool = True) -> None: ...
     async def poll(self) -> typing.Optional[int]: ...
     @typing.overload
@@ -746,8 +765,8 @@ class _SandboxContainer:
     @typing.overload
     async def terminate(self, *, wait: typing.Literal[False] = False) -> None: ...
 
-class _SandboxContainerManager:
-    """Creates and manages additional containers in a Sandbox."""
+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."""
         ...
@@ -764,14 +783,15 @@ class _SandboxContainerManager:
         env: typing.Optional[dict[str, str]] = None,
         secrets: typing.Optional[collections.abc.Collection[modal.secret._Secret]] = None,
         workdir: typing.Optional[str] = None,
-    ) -> _SandboxContainer: ...
-    async def get(self, *, name: str, include_terminated: bool = False) -> _SandboxContainer: ...
-    async def list(self, include_terminated: bool = False) -> list[_SandboxContainer]: ...
+    ) -> _SidecarContainer: ...
+    async def get(self, *, name: str, include_terminated: bool = False) -> _SidecarContainer: ...
+    async def list(self, include_terminated: bool = False) -> list[_SidecarContainer]: ...
 
-class SandboxContainer:
+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,
@@ -787,7 +807,7 @@ class SandboxContainer:
     @staticmethod
     def _from_container_info(
         sandbox: Sandbox, container_info: modal_proto.task_command_router_pb2.TaskContainerInfo
-    ) -> SandboxContainer: ...
+    ) -> SidecarContainer: ...
 
     class ___get_command_router_spec(typing_extensions.Protocol):
         def __call__(self, /) -> tuple[str, modal._utils.task_command_router_client.TaskCommandRouterClient]:
@@ -801,6 +821,7 @@ class SandboxContainer:
     _get_command_router: ___get_command_router_spec
 
     class __exec_spec(typing_extensions.Protocol):
+        @typing.overload
         def __call__(
             self,
             /,
@@ -811,12 +832,26 @@ class SandboxContainer:
             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,
+            text: typing.Literal[True] = True,
             bufsize: typing.Literal[-1, 1] = -1,
             pty: bool = False,
-        ) -> typing.Union[
-            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
-        ]: ...
+        ) -> modal.container_process.ContainerProcess[str]: ...
+        @typing.overload
+        def __call__(
+            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]: ...
+        @typing.overload
         async def aio(
             self,
             /,
@@ -827,15 +862,33 @@ class SandboxContainer:
             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,
+            text: typing.Literal[True] = True,
             bufsize: typing.Literal[-1, 1] = -1,
             pty: bool = False,
-        ) -> typing.Union[
-            modal.container_process.ContainerProcess[bytes], modal.container_process.ContainerProcess[str]
-        ]: ...
+        ) -> modal.container_process.ContainerProcess[str]: ...
+        @typing.overload
+        async def aio(
+            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]: ...
 
     exec: __exec_spec
 
+    @property
+    def filesystem(self) -> modal.sandbox_fs.SandboxFilesystem:
+        """Namespace for filesystem APIs."""
+        ...
+
     class __wait_spec(typing_extensions.Protocol):
         def __call__(self, /, raise_on_termination: bool = True) -> None: ...
         async def aio(self, /, raise_on_termination: bool = True) -> None: ...
@@ -860,8 +913,8 @@ class SandboxContainer:
 
     terminate: __terminate_spec
 
-class SandboxContainerManager:
-    """Creates and manages additional containers in a Sandbox."""
+class SidecarManager:
+    """Creates and manages sidecar containers in a Sandbox."""
     def __init__(self, sandbox: Sandbox) -> None: ...
 
     class ___get_command_router_spec(typing_extensions.Protocol):
@@ -885,7 +938,7 @@ class SandboxContainerManager:
             env: typing.Optional[dict[str, str]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
             workdir: typing.Optional[str] = None,
-        ) -> SandboxContainer: ...
+        ) -> SidecarContainer: ...
         async def aio(
             self,
             /,
@@ -895,19 +948,19 @@ class SandboxContainerManager:
             env: typing.Optional[dict[str, str]] = None,
             secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
             workdir: typing.Optional[str] = None,
-        ) -> SandboxContainer: ...
+        ) -> SidecarContainer: ...
 
     create: __create_spec
 
     class __get_spec(typing_extensions.Protocol):
-        def __call__(self, /, *, name: str, include_terminated: bool = False) -> SandboxContainer: ...
-        async def aio(self, /, *, name: str, include_terminated: bool = False) -> SandboxContainer: ...
+        def __call__(self, /, *, name: str, include_terminated: bool = False) -> SidecarContainer: ...
+        async def aio(self, /, *, name: str, include_terminated: bool = False) -> SidecarContainer: ...
 
     get: __get_spec
 
     class __list_spec(typing_extensions.Protocol):
-        def __call__(self, /, include_terminated: bool = False) -> list[SandboxContainer]: ...
-        async def aio(self, /, include_terminated: bool = False) -> list[SandboxContainer]: ...
+        def __call__(self, /, include_terminated: bool = False) -> list[SidecarContainer]: ...
+        async def aio(self, /, include_terminated: bool = False) -> list[SidecarContainer]: ...
 
     list: __list_spec
 
@@ -1707,8 +1760,8 @@ class Sandbox(modal.object.Object):
     _get_command_router_client: ___get_command_router_client_spec
 
     @property
-    def _experimental_containers(self) -> SandboxContainerManager:
-        """Manage additional containers running in this Sandbox."""
+    def _experimental_sidecars(self) -> SidecarManager:
+        """Manage sidecar containers running in this Sandbox."""
         ...
 
     class __exec_spec(typing_extensions.Protocol):
@@ -2060,3 +2113,5 @@ class Sandbox(modal.object.Object):
     list: typing.ClassVar[__list_spec]
 
 _default_image: modal.image._Image
+
+_MAIN_CONTAINER_NAME: str