modal 1.6.4.dev1__tar.gz → 1.6.4.dev3__tar.gz

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/PKG-INFO

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

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/_runtime/task_lifecycle_manager.py

@@ -25,9 +25,19 @@ from modal._utils.blob_utils import format_blob_data
 from modal._utils.grpc_utils import Retry
 from modal._utils.package_utils import parse_major_minor_version
 from modal.client import _Client
-from modal.config import config, logger
+from modal.config import _env_var_name, config, logger
 from modal_proto import api_pb2
 
+SPEC_ENVIRON_PATH: str = "/proc/gvisor/spec_environ"
+
+
+def _read_spec_environ() -> dict[str, str]:
+    path = Path(SPEC_ENVIRON_PATH)
+    if not path.exists():
+        return {}
+    entries = (entry.partition("=") for entry in path.read_text("utf8").split("\0"))
+    return {key: value for key, sep, value in entries if sep}
+
 
 class UserException(Exception):
     """Used to shut down the task gracefully."""
@@ -42,6 +52,7 @@ class _TaskLifecycleManager:
     checkpoint_id: str | None
     _client: _Client
     _cuda_checkpoint_session: gpu_memory_snapshot.CudaCheckpointSession | None
+    _snapshot_spec_environ: dict[str, str]
 
     def _init(
         self,
@@ -57,6 +68,7 @@ class _TaskLifecycleManager:
         self.checkpoint_id = checkpoint_id
         self._client = client
         self._cuda_checkpoint_session = None
+        self._snapshot_spec_environ = {}
 
     def __new__(
         cls,
@@ -171,10 +183,18 @@ class _TaskLifecycleManager:
                 setattr(self, key, restored_state[key])
 
         # Env vars and global state.
+        env_updates = {}
+        for key, value in _read_spec_environ().items():
+            if self._snapshot_spec_environ.get(key) != value:
+                env_updates[key] = value
+
+        # Values from the restore state take precedence.
         for key, value in restored_state.items():
             # Empty string indicates that value does not need to be updated.
             if value != "":
-                config.override_locally(key, value)
+                env_updates[_env_var_name(key)] = value
+
+        os.environ.update(env_updates)
 
         # Restore GPU memory.
         if self.function_def._experimental_enable_gpu_snapshot and self.function_def.resources.gpu_config.gpu_type:
@@ -205,6 +225,7 @@ class _TaskLifecycleManager:
             self._cuda_checkpoint_session = gpu_memory_snapshot.CudaCheckpointSession()
             self._cuda_checkpoint_session.checkpoint()
 
+        self._snapshot_spec_environ = _read_spec_environ()
         await self._client._stub.ContainerCheckpoint(
             api_pb2.ContainerCheckpointRequest(checkpoint_id=self.checkpoint_id)
         )

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/_runtime/task_lifecycle_manager.pyi

@@ -5,6 +5,8 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
+def _read_spec_environ() -> dict[str, str]: ...
+
 class UserException(Exception):
     """Used to shut down the task gracefully."""
 
@@ -18,6 +20,7 @@ class _TaskLifecycleManager:
     checkpoint_id: typing.Optional[str]
     _client: modal.client._Client
     _cuda_checkpoint_session: typing.Optional[modal._runtime.gpu_memory_snapshot.CudaCheckpointSession]
+    _snapshot_spec_environ: dict[str, str]
 
     def _init(
         self,
@@ -67,6 +70,7 @@ class TaskLifecycleManager:
     checkpoint_id: typing.Optional[str]
     _client: modal.client.Client
     _cuda_checkpoint_session: typing.Optional[modal._runtime.gpu_memory_snapshot.CudaCheckpointSession]
+    _snapshot_spec_environ: dict[str, str]
 
     def __init__(self, /, *args, **kwargs):
         """Initialize self.  See help(type(self)) for accurate signature."""
@@ -136,3 +140,5 @@ def check_fastapi_pydantic_compatibility(exc: ImportError) -> None:
     building an image that specifies a more recent version only for pydantic.
     """
     ...
+
+SPEC_ENVIRON_PATH: str

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/app.py

@@ -3,6 +3,7 @@ import inspect
 import typing
 from collections.abc import AsyncGenerator, Callable, Collection, Coroutine, Mapping, Sequence
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
@@ -56,7 +57,7 @@ from .retries import Retries
 from .running_app import RunningApp
 from .schedule import Schedule
 from .secret import _Secret
-from .types import AppInfo
+from .types import AppInfo, SandboxGroupStats
 from .volume import _Volume
 
 _default_image: _Image = _Image.debian_slim()
@@ -135,6 +136,82 @@ class _LocalAppState:
     volumes_default: dict[str | PurePosixPath, _Volume]
 
 
+class _AppSandboxesManager:
+    """mdmd:namespace"""
+
+    def __init__(self, app: "_App"):
+        """mdmd:hidden"""
+        self._app = app
+
+    async def stats(
+        self,
+        *,
+        since: datetime,
+        until: datetime | None = None,
+        group_by_tags: Sequence[str] | None = None,
+        tags: dict[str, str] | None = None,
+    ) -> AsyncGenerator[SandboxGroupStats, None]:
+        """Return statistics for this App's Sandboxes over a time range, optionally grouped by tag values.
+
+        The maximum time range is 7 days.
+
+        Args:
+            since: The beginning of the time range, inclusive, on a UTC hour boundary. Values without a
+                timezone are interpreted as local time.
+            until: The end of the time range, exclusive, on a UTC hour boundary. If omitted, this defaults to
+                the current time. Values without a timezone are interpreted as local time.
+            group_by_tags: Tag names to group by. Sandboxes with the same values for these names form one group;
+                a name not present on a Sandbox counts as `None`. If omitted, all matching Sandboxes are returned
+                as a single group.
+            tags: Only include Sandboxes that have at least these tags.
+
+        Yields:
+            `SandboxGroupStats` objects, one per combination of tag values, with the following fields:
+            - `tags`: the value of each name in `group_by_tags` for the group's Sandboxes, `None` where not present.
+            - `cost`: total cost in USD, the sum of `cost_by_resource`.
+            - `cost_by_resource`: cost in USD by billed resource: `CPU`, `Memory`, and GPU types such as
+              `H100`. The resource names are subject to change as Modal's billing model evolves.
+
+        Raises:
+            InvalidError: If the time range is invalid or there are more than 10,000 groups.
+
+        Examples:
+            ```python notest
+            app = modal.App.lookup("my-app")
+            since = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) - timedelta(days=1)
+            for group in app.sandboxes.stats(since=since, group_by_tags=["team"]):
+                print(group.tags, group.cost, group.cost_by_resource)
+            ```
+        """
+        if self._app._app_id is None:
+            raise InvalidError("`App.sandboxes.stats` requires a running, deployed or looked-up App.")
+        if until is not None:
+            if until.tzinfo is None:
+                until = until.astimezone()
+            until = until.astimezone(timezone.utc)
+        if since.tzinfo is None:
+            since = since.astimezone()
+        since = since.astimezone(timezone.utc)
+        if since >= datetime.now(timezone.utc):
+            raise InvalidError("`since` must be in the past.")
+        if until is not None and since >= until:
+            raise InvalidError("`since` must be before `until`.")
+        client = self._app._client or await _Client.from_env()
+        request = api_pb2.SandboxGetTimeRangeStatsRequest(
+            group_by_tags=list(group_by_tags or []), tags=tags or {}, app_id=self._app._app_id
+        )
+        request.since.FromDatetime(since)
+        if until is not None:
+            request.until.FromDatetime(until)
+        while True:
+            response = await client._stub.SandboxGetTimeRangeStats(request)
+            for group in response.groups:
+                yield SandboxGroupStats._from_proto(group)
+            if not response.next_page_token:
+                return
+            request.page_token = response.next_page_token
+
+
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -1679,6 +1756,11 @@ class _App:
 
         return _AppLogsManager(self)
 
+    @property
+    def sandboxes(self) -> _AppSandboxesManager:
+        """Namespace for the Sandboxes belonging to this App."""
+        return _AppSandboxesManager(self)
+
     async def info(self, refresh: bool = False) -> AppInfo:
         """Return information for a modal `App`.
 
@@ -1711,4 +1793,5 @@ class _App:
         return self._info
 
 
+AppSandboxesManager = synchronize_api(_AppSandboxesManager)
 App = synchronize_api(_App)

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/app.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import datetime
 import modal._functions
 import modal._image
 import modal._load_context
@@ -115,6 +116,54 @@ class _LocalAppState:
         """Return self==value."""
         ...
 
+class _AppSandboxesManager:
+    """mdmd:namespace"""
+    def __init__(self, app: _App):
+        """mdmd:hidden"""
+        ...
+
+    def stats(
+        self,
+        *,
+        since: datetime.datetime,
+        until: typing.Optional[datetime.datetime] = None,
+        group_by_tags: typing.Optional[collections.abc.Sequence[str]] = None,
+        tags: typing.Optional[dict[str, str]] = None,
+    ) -> collections.abc.AsyncGenerator[modal.types.SandboxGroupStats, None]:
+        """Return statistics for this App's Sandboxes over a time range, optionally grouped by tag values.
+
+        The maximum time range is 7 days.
+
+        Args:
+            since: The beginning of the time range, inclusive, on a UTC hour boundary. Values without a
+                timezone are interpreted as local time.
+            until: The end of the time range, exclusive, on a UTC hour boundary. If omitted, this defaults to
+                the current time. Values without a timezone are interpreted as local time.
+            group_by_tags: Tag names to group by. Sandboxes with the same values for these names form one group;
+                a name not present on a Sandbox counts as `None`. If omitted, all matching Sandboxes are returned
+                as a single group.
+            tags: Only include Sandboxes that have at least these tags.
+
+        Yields:
+            `SandboxGroupStats` objects, one per combination of tag values, with the following fields:
+            - `tags`: the value of each name in `group_by_tags` for the group's Sandboxes, `None` where not present.
+            - `cost`: total cost in USD, the sum of `cost_by_resource`.
+            - `cost_by_resource`: cost in USD by billed resource: `CPU`, `Memory`, and GPU types such as
+              `H100`. The resource names are subject to change as Modal's billing model evolves.
+
+        Raises:
+            InvalidError: If the time range is invalid or there are more than 10,000 groups.
+
+        Examples:
+            ```python notest
+            app = modal.App.lookup("my-app")
+            since = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) - timedelta(days=1)
+            for group in app.sandboxes.stats(since=since, group_by_tags=["team"]):
+                print(group.tags, group.cost, group.cost_by_resource)
+            ```
+        """
+        ...
+
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -953,6 +1002,11 @@ class _App:
         """
         ...
 
+    @property
+    def sandboxes(self) -> _AppSandboxesManager:
+        """Namespace for the Sandboxes belonging to this App."""
+        ...
+
     async def info(self, refresh: bool = False) -> modal.types.AppInfo:
         """Return information for a modal `App`.
 
@@ -971,6 +1025,101 @@ class _App:
         """
         ...
 
+class AppSandboxesManager:
+    """mdmd:namespace"""
+    def __init__(self, app: App):
+        """mdmd:hidden"""
+        ...
+
+    class __stats_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            *,
+            since: datetime.datetime,
+            until: typing.Optional[datetime.datetime] = None,
+            group_by_tags: typing.Optional[collections.abc.Sequence[str]] = None,
+            tags: typing.Optional[dict[str, str]] = None,
+        ) -> typing.Generator[modal.types.SandboxGroupStats, None, None]:
+            """Return statistics for this App's Sandboxes over a time range, optionally grouped by tag values.
+
+            The maximum time range is 7 days.
+
+            Args:
+                since: The beginning of the time range, inclusive, on a UTC hour boundary. Values without a
+                    timezone are interpreted as local time.
+                until: The end of the time range, exclusive, on a UTC hour boundary. If omitted, this defaults to
+                    the current time. Values without a timezone are interpreted as local time.
+                group_by_tags: Tag names to group by. Sandboxes with the same values for these names form one group;
+                    a name not present on a Sandbox counts as `None`. If omitted, all matching Sandboxes are returned
+                    as a single group.
+                tags: Only include Sandboxes that have at least these tags.
+
+            Yields:
+                `SandboxGroupStats` objects, one per combination of tag values, with the following fields:
+                - `tags`: the value of each name in `group_by_tags` for the group's Sandboxes, `None` where not present.
+                - `cost`: total cost in USD, the sum of `cost_by_resource`.
+                - `cost_by_resource`: cost in USD by billed resource: `CPU`, `Memory`, and GPU types such as
+                  `H100`. The resource names are subject to change as Modal's billing model evolves.
+
+            Raises:
+                InvalidError: If the time range is invalid or there are more than 10,000 groups.
+
+            Examples:
+                ```python notest
+                app = modal.App.lookup("my-app")
+                since = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) - timedelta(days=1)
+                for group in app.sandboxes.stats(since=since, group_by_tags=["team"]):
+                    print(group.tags, group.cost, group.cost_by_resource)
+                ```
+            """
+            ...
+
+        def aio(
+            self,
+            /,
+            *,
+            since: datetime.datetime,
+            until: typing.Optional[datetime.datetime] = None,
+            group_by_tags: typing.Optional[collections.abc.Sequence[str]] = None,
+            tags: typing.Optional[dict[str, str]] = None,
+        ) -> collections.abc.AsyncGenerator[modal.types.SandboxGroupStats, None]:
+            """Return statistics for this App's Sandboxes over a time range, optionally grouped by tag values.
+
+            The maximum time range is 7 days.
+
+            Args:
+                since: The beginning of the time range, inclusive, on a UTC hour boundary. Values without a
+                    timezone are interpreted as local time.
+                until: The end of the time range, exclusive, on a UTC hour boundary. If omitted, this defaults to
+                    the current time. Values without a timezone are interpreted as local time.
+                group_by_tags: Tag names to group by. Sandboxes with the same values for these names form one group;
+                    a name not present on a Sandbox counts as `None`. If omitted, all matching Sandboxes are returned
+                    as a single group.
+                tags: Only include Sandboxes that have at least these tags.
+
+            Yields:
+                `SandboxGroupStats` objects, one per combination of tag values, with the following fields:
+                - `tags`: the value of each name in `group_by_tags` for the group's Sandboxes, `None` where not present.
+                - `cost`: total cost in USD, the sum of `cost_by_resource`.
+                - `cost_by_resource`: cost in USD by billed resource: `CPU`, `Memory`, and GPU types such as
+                  `H100`. The resource names are subject to change as Modal's billing model evolves.
+
+            Raises:
+                InvalidError: If the time range is invalid or there are more than 10,000 groups.
+
+            Examples:
+                ```python notest
+                app = modal.App.lookup("my-app")
+                since = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0) - timedelta(days=1)
+                for group in app.sandboxes.stats(since=since, group_by_tags=["team"]):
+                    print(group.tags, group.cost, group.cost_by_resource)
+                ```
+            """
+            ...
+
+    stats: __stats_spec
+
 SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
 
 class App:
@@ -2073,6 +2222,11 @@ class App:
         """
         ...
 
+    @property
+    def sandboxes(self) -> AppSandboxesManager:
+        """Namespace for the Sandboxes belonging to this App."""
+        ...
+
     class __info_spec(typing_extensions.Protocol):
         def __call__(self, /, refresh: bool = False) -> modal.types.AppInfo:
             """Return information for a modal `App`.

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/cli/endpoint.py

@@ -5,6 +5,7 @@ from json import dumps
 from typing import Optional
 
 import click
+from rich.box import SIMPLE
 from rich.table import Column, Table
 from rich.text import Text
 
@@ -21,6 +22,7 @@ from modal_proto import api_pb2
 
 from ._help import ModalGroup
 from ._logs import _validate_logs_args
+from ._stats import STATS_METADATA_STYLE
 from .server import _run_server_logs, _run_server_stats, _server_stats_time_range
 
 _ENDPOINT_HELP = """
@@ -41,6 +43,11 @@ _SERVING_MODE_LABELS = {
     api_pb2.ENDPOINT_SERVING_MODE_DEDICATED: "dedicated",
     api_pb2.ENDPOINT_SERVING_MODE_SHARED: "shared",
 }
+_INPUT_MODALITY_LABELS = {
+    api_pb2.ENDPOINT_INPUT_MODALITY_TEXT: "text",
+    api_pb2.ENDPOINT_INPUT_MODALITY_IMAGE: "image",
+    api_pb2.ENDPOINT_INPUT_MODALITY_AUDIO: "audio",
+}
 _ENDPOINT_STATUS_LABELS = {
     api_pb2.EndpointGetInfoResponse.ENDPOINT_STATUS_PROVISIONING: "provisioning",
     api_pb2.EndpointGetInfoResponse.ENDPOINT_STATUS_LIVE: "live",
@@ -502,6 +509,108 @@ async def stop(
         output.print(f"[green]✓[/green] Stopped Endpoint {endpoint_id}.")
 
 
+@endpoint_cli.command("library", panel="Inspection")
+@click.option(
+    "--input-modality",
+    type=click.Choice(["text", "image", "audio"]),
+    multiple=True,
+    help="Only show models that accept any of these inputs. Can be repeated.",
+)
+@click.option("--json", "json_output", is_flag=True, help="Output models as JSON.")
+@synchronizer.create_blocking
+async def library(*, input_modality: tuple[str, ...] = (), json_output: bool = False) -> None:
+    """List models you can serve with Modal Endpoints.
+
+    Models are listed by their Hugging Face repo ID, with the input types they
+    accept and whether they're available as shared endpoints, dedicated
+    endpoints, or both.
+
+    This is Modal's catalog of supported models, not the Endpoints in your
+    workspace. To see those, run `modal endpoint list`.
+
+    Examples:
+
+    List models that support text input modality:
+
+    ```
+    modal endpoint library --input-modality text
+    ```
+
+    Pick a model ID and then create a shared endpoint:
+
+    ```
+    modal endpoint create --model Qwen/Qwen3.8-27B --shared
+    ```
+    """
+    client = await _Client.from_env()
+    response = await client._stub.EndpointGetLibrary(api_pb2.EndpointGetLibraryRequest())
+    modalities = {modality for modality, label in _INPUT_MODALITY_LABELS.items() if label in input_modality}
+
+    models = sorted(
+        (
+            model
+            for model in response.models
+            if (not modalities or modalities.intersection(model.supported_input_modalities))
+        ),
+        key=lambda model: model.base_model_repo_id,
+    )
+    output = OutputManager.get()
+    if json_output:
+        output.print_json(
+            dumps(
+                [
+                    {
+                        "base_model_repo_id": model.base_model_repo_id,
+                        "input_modalities": [
+                            _INPUT_MODALITY_LABELS.get(modality, "unknown")
+                            for modality in model.supported_input_modalities
+                        ],
+                        "shared": api_pb2.ENDPOINT_SERVING_MODE_SHARED in model.available_serving_modes,
+                        "dedicated": api_pb2.ENDPOINT_SERVING_MODE_DEDICATED in model.available_serving_modes,
+                    }
+                    for model in models
+                ]
+            )
+        )
+        return
+    output.print(
+        Text(
+            f"Displaying {len(models):,} {'model' if len(models) == 1 else 'models'}",
+            style=STATS_METADATA_STYLE,
+        )
+    )
+    if not models:
+        output.print(
+            "No endpoint-compatible models match the filters."
+            if input_modality
+            else "No endpoint-compatible models are available."
+        )
+        return
+    display_table(
+        [
+            Column("Model ID", overflow="fold"),
+            "Input Modalities",
+            Column("Shared", justify="center"),
+            Column("Dedicated", justify="center"),
+        ],
+        [
+            (
+                Text.assemble(
+                    (model.base_model_repo_id, f"link https://huggingface.co/{model.base_model_repo_id}"),
+                    (" ↗", "bright_blue not underline"),
+                ),
+                ", ".join(
+                    _INPUT_MODALITY_LABELS.get(modality, "unknown") for modality in model.supported_input_modalities
+                ),
+                "✓" if api_pb2.ENDPOINT_SERVING_MODE_SHARED in model.available_serving_modes else "—",
+                "✓" if api_pb2.ENDPOINT_SERVING_MODE_DEDICATED in model.available_serving_modes else "—",
+            )
+            for model in models
+        ],
+        table_box=SIMPLE,
+    )
+
+
 @endpoint_cli.command("info", panel="Inspection", no_args_is_help=True)
 @click.argument("endpoint_identifier")
 @env_option

{modal-1.6.4.dev1 → modal-1.6.4.dev3}/modal/cli/image.py

@@ -4,21 +4,27 @@ from __future__ import annotations
 
 import asyncio
 import json as json_module
+import os
 from collections.abc import AsyncIterator
 from typing import Optional
 
 import click
+from rich.syntax import Syntax
 
 from modal._environments import ensure_env
-from modal._image import _upgrade_image_name
+from modal._image import _Image, _infer_registry_auth_type, _upgrade_image_name
 from modal._logs_manager import _resolve_source
 from modal._utils.async_utils import synchronizer
 from modal._utils.time_utils import timestamp_to_localized_str
+from modal.app import _App
 from modal.cli.utils import display_table, env_option
 from modal.client import _Client
 from modal.config import config
+from modal.exception import InvalidError
 from modal.image import Image
 from modal.output import OutputManager
+from modal.runner import _run_app
+from modal.secret import _Secret
 from modal_proto import api_pb2
 
 from ._help import ModalGroup
@@ -36,6 +42,118 @@ def _print_result_summary(count: int) -> None:
     OutputManager.get().print(f"Showing {count} {result_label}")
 
 
+async def _registry_secret(
+    secret_name: Optional[str], secret_vars: Optional[str], env: str
+) -> tuple[Optional[_Secret], set[str]]:
+    if secret_name and secret_vars:
+        raise click.UsageError("--registry-secret and --registry-secret-from-env cannot be used together.")
+    if secret_name:
+        secret = _Secret.from_name(secret_name, environment_name=env)
+        return secret, await secret._get_keys()
+    keys = [key.strip() for key in (secret_vars or "").split(",") if key.strip()]
+    if not keys:
+        return None, set()
+    return _Secret.from_local_environ(keys), set(keys)
+
+
+@image_cli.command("build", no_args_is_help=True)
+@click.argument("context_dir", metavar="CONTEXT_DIR")
+@click.option(
+    "-t",
+    "--name",
+    "name",
+    metavar="[ENV/]NAME[:TAG]",
+    required=True,
+    help="Name to publish the Image as, e.g. `my-image`, `my-image:v2`, or `my-env/my-image`.",
+)
+@click.option(
+    "-f",
+    "--file",
+    "dockerfile",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Path to the Dockerfile. Defaults to `CONTEXT_DIR/Dockerfile`.",
+)
+@click.option(
+    "--registry-secret",
+    "registry_secret_name",
+    metavar="SECRET_NAME",
+    default=None,
+    help="Name of a Secret with credentials for pulling the base image from a private registry.",
+)
+@click.option(
+    "--registry-secret-from-env",
+    "registry_secret_vars",
+    default=None,
+    metavar="VAR[,VAR...]",
+    help=(
+        "Comma-separated local environment variable names holding registry credentials. "
+        "Cannot be combined with --registry-secret."
+    ),
+)
+@click.option("--force-build", is_flag=True, help="Rebuild every layer of the Image, ignoring cached builds.")
+@env_option
+@synchronizer.create_blocking
+async def build(
+    context_dir: str,
+    name: str,
+    dockerfile: Optional[str],
+    registry_secret_name: Optional[str],
+    registry_secret_vars: Optional[str],
+    force_build: bool,
+    env: Optional[str],
+) -> None:
+    """Build an Image from a Dockerfile and publish it as NAME.
+
+    CONTEXT_DIR is the build context used to resolve relative COPY paths. Use `.` for the current directory.
+
+    NAME defaults to the `latest` tag. `--env` sets the environment the build runs in and where
+    `--registry-secret` is looked up. The Image is published into that environment unless NAME has an
+    environment prefix, e.g. `my-env/my-image`.
+
+    Examples:
+
+    ```
+    modal image build -t my-image .
+    modal image build --name my-image:v2 -f docker/Dockerfile .
+    modal image build -t my-env/my-image .
+    modal image build -t my-image --registry-secret my-registry-creds .
+    modal image build -t my-image --registry-secret-from-env REGISTRY_USERNAME,REGISTRY_PASSWORD .
+    ```
+    """
+    if not os.path.isdir(context_dir):
+        raise click.UsageError(f"CONTEXT_DIR {context_dir!r} is not a directory.")
+    if dockerfile is None:
+        dockerfile = os.path.join(context_dir, "Dockerfile")
+        if not os.path.isfile(dockerfile):
+            raise click.UsageError(f"No Dockerfile found at {dockerfile}. Use --file to specify one.")
+    env = ensure_env(env)
+    try:
+        tag = _upgrade_image_name(name, fallback_environment_name=env)
+    except InvalidError as exc:
+        raise click.UsageError(str(exc))
+
+    secret, keys = await _registry_secret(registry_secret_name, registry_secret_vars, env)
+    if secret is not None:
+        # Fail before creating the app; from_dockerfile runs the same check during the build
+        try:
+            _infer_registry_auth_type(keys)
+        except InvalidError as exc:
+            raise click.UsageError(str(exc)) from exc
+    image = _Image.from_dockerfile(dockerfile, context_dir=context_dir, registry_secret=secret, force_build=force_build)
+    app = _App("modal-image-build")
+    # Only show the Image build output, which includes its logs
+    async with _run_app(app, environment_name=env, stream_output=False):
+        await image.build(app)
+        await image.publish(tag)
+
+    output_mgr = OutputManager.get()
+    output_mgr.step_completed(f"Image built: [bold]{image.object_id}[/bold]")
+    output_mgr.step_completed(f"Image published as [bold magenta]{tag}[/bold magenta]! 🎉")
+    output_mgr.print("\nUse it with:\n")
+    output_mgr.print(Syntax(f'modal.Image.from_name("{tag}")', "python"))
+
+
 @image_cli.command("logs", no_args_is_help=True)
 @click.argument("image_id")
 @click.option(