modal 1.3.6.dev12__tar.gz → 1.3.6.dev13__tar.gz

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/PKG-INFO

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

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/_functions.py

@@ -56,7 +56,7 @@ from ._utils.function_utils import (
     is_async,
 )
 from ._utils.grpc_utils import Retry, RetryWarningMessage
-from ._utils.mount_utils import validate_network_file_systems, validate_volumes
+from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
 from .call_graph import InputInfo, _reconstruct_call_graph
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
@@ -966,6 +966,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 if image._metadata is not None:
                     mount_client_dependencies = image._metadata.image_builder_version > "2024.10"
 
+                # Validate that the same volume (by object_id) isn't mounted at multiple paths
+                # This validation happens here (at load time) because volumes need to be hydrated
+                # to have their object_id set.
+                validate_volumes_by_object_id(validated_volumes_no_cloud_buckets)
+
                 # Relies on dicts being ordered (true as of Python 3.6).
                 volume_mounts = [
                     api_pb2.VolumeMount(
@@ -1235,6 +1240,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             assert parent is not None and parent.is_hydrated
 
             if options:
+                # Validate that the same volume (by object_id) isn't mounted at multiple paths
+                validate_volumes_by_object_id(options.validated_volumes)
+
                 volume_mounts = [
                     api_pb2.VolumeMount(
                         mount_path=path,

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/_utils/mount_utils.py

@@ -101,3 +101,23 @@ def validate_only_modal_volumes(
         raise InvalidError(f"{caller_name} only supports volumes that are modal.Volume")
 
     return validated_volumes
+
+
+def validate_volumes_by_object_id(validated_volumes: Sequence[tuple[str, _Volume]]) -> None:
+    """Validate that the same volume (by object_id) is not mounted at multiple paths.
+
+    This validation happens at load time after volumes are hydrated and have object_ids.
+    """
+    object_id_to_paths: dict[str, list[str]] = {}
+    for path, volume in validated_volumes:
+        if not volume.is_hydrated:
+            # This should never happen since this function is only called at load time
+            raise RuntimeError(f"Internal error: Volume at '{path}' is not hydrated when validating mounts")
+        object_id_to_paths.setdefault(volume.object_id, []).append(path)
+
+    for object_id, paths in object_id_to_paths.items():
+        if len(paths) > 1:
+            conflicting = ", ".join(sorted(paths))
+            raise InvalidError(
+                f"The same Volume cannot be mounted in multiple locations for the same function: {conflicting}"
+            )

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/cli/app.py

@@ -137,13 +137,14 @@ def logs(
         "--until",
         help="End of time range; accepts same argument types as --since",
     ),
+    tail: Optional[int] = typer.Option(None, "--tail", "-n", help="Show only the last N log entries"),
     search: Optional[str] = typer.Option(None, "--search", help="Filter by search text"),
     function_id: Optional[str] = typer.Option("", "--function", help="Filter by Function ID (fu-*)"),
     function_call_id: Optional[str] = typer.Option("", "--function-call", help="Filter by FunctionCall ID (fc-*)"),
+    container_id: Optional[str] = typer.Option("", "--container", help="Filter by Container ID (ta-*)"),
     source: Optional[str] = typer.Option(
         None, "--source", "-s", help="Filter by source: 'stdout', 'stderr', or 'system'"
     ),
-    tail: Optional[int] = typer.Option(None, "--tail", "-n", help="Show only the last N log entries"),
     timestamps: bool = typer.Option(False, "--timestamps", help="Prefix each line with its timestamp"),
     show_function_id: bool = typer.Option(False, "--show-function-id", help="Prefix each line with its Function ID"),
     show_function_call_id: bool = typer.Option(
@@ -236,12 +237,14 @@ def logs(
         source=source_fd,
         function_id=function_id or "",
         function_call_id=function_call_id or "",
+        task_id=container_id or "",
         search_text=search or "",
     )
 
     if follow:
         stream_app_logs(
             app_id,
+            task_id=container_id or "",
             show_timestamps=timestamps,
             follow=True,
             prefix_fields=prefix_fields,

modal-1.3.6.dev13/modal/cli/container.py

@@ -0,0 +1,264 @@
+# Copyright Modal Labs 2022
+from datetime import datetime, timezone
+from typing import Optional, Union
+
+import typer
+from click import UsageError
+from rich.table import Column
+from rich.text import Text
+
+from modal._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
+from modal._object import _get_environment_name
+from modal._output.pty import get_pty_info
+from modal._utils.async_utils import synchronizer
+from modal._utils.time_utils import timestamp_to_localized_str
+from modal.cli.app import _DEFAULT_LOGS_TAIL, _SOURCE_OPTIONS, _parse_time_arg
+from modal.cli.utils import ENV_OPTION, display_table, fetch_app_logs, is_tty, stream_app_logs, tail_app_logs
+from modal.client import _Client
+from modal.config import config
+from modal.container_process import _ContainerProcess
+from modal.environments import ensure_env
+from modal.exception import InvalidError
+from modal.stream_type import StreamType
+from modal_proto import api_pb2
+
+container_cli = typer.Typer(name="container", help="Manage and connect to running containers.", no_args_is_help=True)
+
+
+@container_cli.command("list")
+@synchronizer.create_blocking
+async def list_(env: Optional[str] = ENV_OPTION, json: bool = False, app_id: str = ""):
+    """List all containers that are currently running."""
+    env = ensure_env(env)
+    client = await _Client.from_env()
+    environment_name = _get_environment_name(env)
+    res: api_pb2.TaskListResponse = await client.stub.TaskList(
+        api_pb2.TaskListRequest(environment_name=environment_name, app_id=app_id)
+    )
+
+    column_names: list[Union[Column, str]] = [
+        Column("Container ID", min_width=29),
+        Column("App ID", min_width=25),
+        "App Name",
+        "Start Time",
+    ]
+    rows: list[list[Union[Text, str]]] = []
+    res.tasks.sort(key=lambda task: task.started_at, reverse=True)
+    for task_stats in res.tasks:
+        rows.append(
+            [
+                task_stats.task_id,
+                task_stats.app_id,
+                task_stats.app_description,
+                timestamp_to_localized_str(task_stats.started_at, json) if task_stats.started_at else "Pending",
+            ]
+        )
+
+    display_table(column_names, rows, json=json, title=f"Active Containers in environment: {environment_name}")
+
+
+@container_cli.command("logs", no_args_is_help=True)
+@synchronizer.create_blocking
+async def logs(
+    container_id: str = typer.Argument(help="Container ID"),
+    follow: bool = typer.Option(False, "-f", "--follow", help="Stream log output until Container stops"),
+    all_logs: bool = typer.Option(False, "--all", help="Show all logs for the container"),
+    since: Optional[str] = typer.Option(
+        None,
+        "--since",
+        help=(
+            "Start of time range. Accepts ISO 8601 datetime or relative time, e.g. '1d' (1 day ago), '2h', '30m', etc."
+        ),
+    ),
+    until: Optional[str] = typer.Option(
+        None,
+        "--until",
+        help="End of time range; accepts same argument types as --since",
+    ),
+    tail: Optional[int] = typer.Option(None, "--tail", "-n", help="Show only the last N log entries"),
+    search: Optional[str] = typer.Option(None, "--search", help="Filter by search text"),
+    source: Optional[str] = typer.Option(
+        None, "--source", "-s", help="Filter by source: 'stdout', 'stderr', or 'system'"
+    ),
+    timestamps: bool = typer.Option(False, "--timestamps", help="Prefix each line with its timestamp"),
+):
+    """Fetch or stream logs for a specific container.
+
+    By default, this command fetches the last 100 log entries and exits. Use ``-f`` to
+    live-stream logs from a running container instead. Fetch and follow are mutually exclusive.
+
+    **Examples:**
+
+    Get recent logs for a container:
+
+    ```
+    modal container logs ta-123456
+    ```
+
+    Follow (stream) logs from a running container:
+
+    ```
+    modal container logs ta-123456 -f
+    ```
+
+    Fetch logs from the last 2 hours:
+
+    ```
+    modal container logs ta-123456 --since 2h
+    ```
+
+    Fetch logs in a specific time range:
+
+    ```
+    modal container logs ta-123456 --since 2026-03-01T05:00:00 --until 2026-03-01T08:00:00
+    ```
+
+    Fetch all container logs:
+
+    ```
+    modal container logs ta-123456 --all
+    ```
+    """
+    task_id, sandbox_id = None, None
+    if container_id.startswith("sb-"):
+        sandbox_id = container_id
+    elif container_id.startswith("ta-"):
+        task_id = container_id
+    else:
+        raise InvalidError(f"Invalid container ID: {container_id}")
+
+    if follow and (since or until or tail):
+        raise UsageError("--follow cannot be combined with --since, --until, or --tail.")
+
+    if tail is not None and tail <= 0:
+        raise UsageError("--tail value must be positive.")
+
+    if tail is not None and tail > _FETCH_LIMIT:
+        raise UsageError(f"--tail value must not exceed {_FETCH_LIMIT}.")
+
+    if all_logs and (since or until or tail):
+        raise UsageError("--all cannot be combined with --since, --until, or --tail.")
+
+    if all_logs and follow:
+        raise UsageError("--all cannot be combined with --follow.")
+
+    if source is not None:
+        if source not in _SOURCE_OPTIONS:
+            raise UsageError(f"Invalid source: '{source}'. Must be 'stdout', 'stderr', or 'system'.")
+        source_fd = _SOURCE_OPTIONS[source]
+    else:
+        source_fd = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED
+
+    log_filters = LogsFilters(
+        source=source_fd,
+        task_id=task_id or "",
+        sandbox_id=sandbox_id or "",
+        search_text=search or "",
+    )
+
+    if follow:
+        await stream_app_logs.aio(
+            task_id=task_id,
+            sandbox_id=sandbox_id,
+            show_timestamps=timestamps,
+            follow=True,
+            filters=log_filters,
+        )
+    else:
+        # Resolve the app_id for the container.
+        client = await _Client.from_env()
+
+        if sandbox_id:
+            sb_resp = await client.stub.SandboxGetTaskId(api_pb2.SandboxGetTaskIdRequest(sandbox_id=sandbox_id))
+            task_id = sb_resp.task_id
+
+        task_info_resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=task_id))
+        app_id = task_info_resp.app_id
+
+        now = datetime.now(timezone.utc)
+        if all_logs:
+            since_dt = datetime.fromtimestamp(task_info_resp.info.started_at, timezone.utc)
+            if task_info_resp.info.finished_at:
+                until_dt = datetime.fromtimestamp(task_info_resp.info.finished_at, timezone.utc)
+            else:
+                until_dt = now
+        else:
+            since_dt = _parse_time_arg(since, default=now) if since else None
+            until_dt = _parse_time_arg(until, default=now) if until else None
+
+        if since_dt is not None and until_dt is not None and since_dt >= until_dt:
+            raise UsageError("--since must be before --until.")
+
+        if since_dt is not None:
+            effective_until = until_dt or now
+            if effective_until - since_dt > _MAX_FETCH_RANGE:
+                raise UsageError(f"Log fetch time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+
+        if all_logs or (since and tail is None):
+            # Range mode: --since without --tail fetches everything in the range.
+            await fetch_app_logs.aio(
+                app_id,
+                since_dt,
+                until_dt or now,
+                show_timestamps=timestamps,
+                filters=log_filters,
+            )
+        else:
+            # Tail mode: single fetch with limit.
+            # --since is a hard floor, --until shifts the anchor.
+            effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
+            await tail_app_logs.aio(
+                app_id,
+                effective_tail,
+                show_timestamps=timestamps,
+                since=since_dt,
+                until=until_dt,
+                filters=log_filters,
+            )
+
+
+@container_cli.command("exec")
+@synchronizer.create_blocking
+async def exec(
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
+    container_id: str = typer.Argument(help="Container ID"),
+    command: list[str] = typer.Argument(
+        help="A command to run inside the container.\n\n"
+        "To pass command-line flags or options, add `--` before the start of your commands. "
+        "For example: `modal container exec <id> -- /bin/bash -c 'echo hi'`"
+    ),
+):
+    """Execute a command in a container."""
+
+    if pty is None:
+        pty = is_tty()
+
+    client = await _Client.from_env()
+
+    req = api_pb2.ContainerExecRequest(
+        task_id=container_id,
+        command=command,
+        pty_info=get_pty_info(shell=True) if pty else None,
+        runtime_debug=config.get("function_runtime_debug"),
+    )
+    res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
+
+    if pty:
+        await _ContainerProcess(res.exec_id, container_id, client).attach()
+    else:
+        # TODO: redirect stderr to its own stream?
+        await _ContainerProcess(
+            res.exec_id, container_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+        ).wait()
+
+
+@container_cli.command("stop")
+@synchronizer.create_blocking
+async def stop(container_id: str = typer.Argument(help="Container ID")):
+    """Stop a currently-running container and reassign its in-progress inputs.
+
+    This will send the container a SIGINT signal that Modal will handle.
+    """
+    client = await _Client.from_env()
+    request = api_pb2.ContainerStopRequest(task_id=container_id)
+    await client.stub.ContainerStop(request)

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/client.pyi

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

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/functions.pyi

@@ -408,7 +408,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -417,7 +417,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -444,7 +444,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -467,7 +467,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -475,7 +475,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -496,7 +496,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/image.py

@@ -40,7 +40,7 @@ from ._utils.docker_utils import (
     find_dockerignore_file,
 )
 from ._utils.function_utils import FunctionInfo
-from ._utils.mount_utils import validate_only_modal_volumes
+from ._utils.mount_utils import validate_only_modal_volumes, validate_volumes_by_object_id
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
@@ -434,7 +434,7 @@ class _Image(_Object, type_prefix="im"):
         self._serve_mounts = other._serve_mounts
         self._deferred_mounts = other._deferred_mounts
         self._added_python_source_set = other._added_python_source_set
-        self._is_empty = other._is_empty
+        self._is_empty = False
 
     def _get_metadata(self) -> Optional[Message]:
         return self._metadata
@@ -626,6 +626,9 @@ class _Image(_Object, type_prefix="im"):
                 build_function_id = ""
                 _build_function = None
 
+            # Validate that the same volume (by object_id) isn't mounted at multiple paths
+            validate_volumes_by_object_id(validated_volumes)
+
             # Relies on dicts being ordered (true as of Python 3.6).
             volume_mounts = [
                 api_pb2.VolumeMount(
@@ -724,12 +727,6 @@ class _Image(_Object, type_prefix="im"):
         )
         return obj
 
-    @staticmethod
-    def _from_scratch() -> "_Image":
-        image = _Image.from_registry("scratch")
-        image._is_empty = True
-        return image
-
     def _copy_mount(self, mount: _Mount, remote_path: Union[str, Path] = ".") -> "_Image":
         """mdmd:hidden
         Internal
@@ -2179,6 +2176,36 @@ class _Image(_Object, type_prefix="im"):
             force_build=force_build,
         )
 
+    @staticmethod
+    def from_scratch(force_build: bool = False) -> "_Image":
+        """Create an empty Image, equivalent to `FROM scratch` in Docker.
+
+        The resulting Image has no operating system, shell, or package manager. It is
+        primarily useful as a lightweight filesystem to mount into a Sandbox via
+        `Sandbox.mount_image`.
+
+        Note that since this Image doesn't contain Python or other standard OS utilities,
+        higher-level Image build steps like `pip_install` cannot be chained onto it. It also
+        cannot be used for `modal.Function` execution, which requires a Python interpreter.
+
+        **Example**
+
+        ```python notest
+        image = modal.Image.from_scratch().add_local_file(local_path, "/bin/my_binary", copy=True)
+        ```
+        """
+
+        def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
+            return DockerfileSpec(commands=["FROM scratch"], context_files={})
+
+        image = _Image._from_args(
+            dockerfile_function=build_dockerfile,
+            force_build=force_build,
+            _namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+        )
+        image._is_empty = True
+        return image
+
     @staticmethod
     def debian_slim(python_version: Optional[str] = None, force_build: bool = False) -> "_Image":
         """Default image, based on the official `python` Docker images."""

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/image.pyi

@@ -187,8 +187,6 @@ class _Image(modal._object._Object):
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
-    @staticmethod
-    def _from_scratch() -> _Image: ...
     def _copy_mount(self, mount: modal.mount._Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> _Image:
         """mdmd:hidden
         Internal
@@ -901,6 +899,26 @@ class _Image(modal._object._Object):
         """
         ...
 
+    @staticmethod
+    def from_scratch(force_build: bool = False) -> _Image:
+        """Create an empty Image, equivalent to `FROM scratch` in Docker.
+
+        The resulting Image has no operating system, shell, or package manager. It is
+        primarily useful as a lightweight filesystem to mount into a Sandbox via
+        `Sandbox.mount_image`.
+
+        Note that since this Image doesn't contain Python or other standard OS utilities,
+        higher-level Image build steps like `pip_install` cannot be chained onto it. It also
+        cannot be used for `modal.Function` execution, which requires a Python interpreter.
+
+        **Example**
+
+        ```python notest
+        image = modal.Image.from_scratch().add_local_file(local_path, "/bin/my_binary", copy=True)
+        ```
+        """
+        ...
+
     @staticmethod
     def debian_slim(python_version: typing.Optional[str] = None, force_build: bool = False) -> _Image:
         """Default image, based on the official `python` Docker images."""
@@ -1109,8 +1127,6 @@ class Image(modal.object.Object):
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
-    @staticmethod
-    def _from_scratch() -> Image: ...
     def _copy_mount(self, mount: modal.mount.Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> Image:
         """mdmd:hidden
         Internal
@@ -1879,6 +1895,26 @@ class Image(modal.object.Object):
         """
         ...
 
+    @staticmethod
+    def from_scratch(force_build: bool = False) -> Image:
+        """Create an empty Image, equivalent to `FROM scratch` in Docker.
+
+        The resulting Image has no operating system, shell, or package manager. It is
+        primarily useful as a lightweight filesystem to mount into a Sandbox via
+        `Sandbox.mount_image`.
+
+        Note that since this Image doesn't contain Python or other standard OS utilities,
+        higher-level Image build steps like `pip_install` cannot be chained onto it. It also
+        cannot be used for `modal.Function` execution, which requires a Python interpreter.
+
+        **Example**
+
+        ```python notest
+        image = modal.Image.from_scratch().add_local_file(local_path, "/bin/my_binary", copy=True)
+        ```
+        """
+        ...
+
     @staticmethod
     def debian_slim(python_version: typing.Optional[str] = None, force_build: bool = False) -> Image:
         """Default image, based on the official `python` Docker images."""

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/runner.py

@@ -214,23 +214,32 @@ async def _stop_and_wait_for_containers(
             if container.enqueued_at and container.enqueued_at < deployed_at
         ]
 
+    stopped_ids = set()
+
     async def stop_containers(container_ids: list[str]):
         sem = asyncio.Semaphore(32)
 
         async def stop_one_container(tid: str):
+            if tid in stopped_ids:
+                return
+
             async with sem:
                 await client.stub.ContainerStop(api_pb2.ContainerStopRequest(task_id=tid))
+                stopped_ids.add(tid)
 
-        results = await asyncio.gather(*[stop_one_container(tid) for tid in container_ids], return_exceptions=True)
+        stop_tasks = [stop_one_container(tid) for tid in container_ids if tid not in stopped_ids]
+        if not stop_tasks:
+            return
+
+        results = await asyncio.gather(*stop_tasks, return_exceptions=True)
         exceptions = [r for r in results if isinstance(r, BaseException)]
         if exceptions:
             raise exceptions[0]
 
-    async def poll_until_stopped(initial_ids: list[str]):
-        await stop_containers(initial_ids)
-        await asyncio.sleep(WAIT_FOR_CONTAINER_STOP_SLEEP_INTERVAL)
-
+    async def poll_until_stopped():
         while ids := await get_old_container_ids():
+            # Just in case there are new ids from `get_old_container_ids`, we call `stop_containers` again,
+            # which will no-op for containers that was already stopped.
             await stop_containers(ids)
             await asyncio.sleep(WAIT_FOR_CONTAINER_STOP_SLEEP_INTERVAL)
 
@@ -239,12 +248,13 @@ async def _stop_and_wait_for_containers(
         return
 
     output = OutputManager.get()
-    output.print("♻️ Restarting containers...")
+    output.print("🧹 Terminating running containers")
+    await stop_containers(ids)
 
     try:
-        await asyncio.wait_for(poll_until_stopped(ids), timeout=WAIT_FOR_CONTAINER_STOP_TIMEOUT)
+        await asyncio.wait_for(poll_until_stopped(), timeout=WAIT_FOR_CONTAINER_STOP_TIMEOUT)
     except asyncio.TimeoutError:
-        raise asyncio.TimeoutError(f"Containers did not restart in under {WAIT_FOR_CONTAINER_STOP_TIMEOUT} seconds.")
+        raise asyncio.TimeoutError(f"Containers did not terminate in under {WAIT_FOR_CONTAINER_STOP_TIMEOUT} seconds.")
 
 
 def _validate_deployment_strategy(strategy: str) -> DEPLOYMENT_STRATEGY_TYPE:
@@ -294,7 +304,7 @@ async def _publish_app(
             )
         except Exception as exc:
             warnings.warn(
-                f"App updated successfully, but containers did not all restart. {exc}",
+                f"App updated successfully, but containers did not all terminate. {exc}",
                 UserWarning,
             )
 

{modal-1.3.6.dev12 → modal-1.3.6.dev13}/modal/sandbox.py

@@ -30,7 +30,7 @@ from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.deprecation import deprecation_warning
-from ._utils.mount_utils import validate_network_file_systems, validate_volumes
+from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
 from ._utils.name_utils import check_object_name
 from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
@@ -214,6 +214,9 @@ class _Sandbox(_Object, type_prefix="sb"):
         async def _load(
             self: _Sandbox, resolver: Resolver, load_context: LoadContext, _existing_object_id: Optional[str]
         ):
+            # Validate that the same volume (by object_id) isn't mounted at multiple paths
+            validate_volumes_by_object_id(validated_volumes)
+
             # Relies on dicts being ordered (true as of Python 3.6).
             volume_mounts = [
                 api_pb2.VolumeMount(
@@ -739,7 +742,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             "The `Sandbox._experimental_mount_image()` method is deprecated. Use `Sandbox.mount_image()` instead.",
         )
         if image is None:
-            image = _Image._from_scratch()
+            image = _Image.from_scratch()
         await self.mount_image(path, image)
 
     async def snapshot_directory(self, path: Union[PurePosixPath, str]) -> _Image: