dstack 0.19.16__py3-none-any.whl → 0.19.17__py3-none-any.whl

dstack/_internal/cli/commands/secrets.py

@@ -0,0 +1,92 @@
+import argparse
+
+from dstack._internal.cli.commands import APIBaseCommand
+from dstack._internal.cli.services.completion import SecretNameCompleter
+from dstack._internal.cli.utils.common import (
+    confirm_ask,
+    console,
+)
+from dstack._internal.cli.utils.secrets import print_secrets_table
+
+
+class SecretCommand(APIBaseCommand):
+    NAME = "secret"
+    DESCRIPTION = "Manage secrets"
+
+    def _register(self):
+        super()._register()
+        self._parser.set_defaults(subfunc=self._list)
+        subparsers = self._parser.add_subparsers(dest="action")
+
+        list_parser = subparsers.add_parser(
+            "list", help="List secrets", formatter_class=self._parser.formatter_class
+        )
+        list_parser.set_defaults(subfunc=self._list)
+
+        get_parser = subparsers.add_parser(
+            "get", help="Get secret value", formatter_class=self._parser.formatter_class
+        )
+        get_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        ).completer = SecretNameCompleter()
+        get_parser.set_defaults(subfunc=self._get)
+
+        set_parser = subparsers.add_parser(
+            "set", help="Set secret", formatter_class=self._parser.formatter_class
+        )
+        set_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        )
+        set_parser.add_argument(
+            "value",
+            help="The value of the secret",
+        )
+        set_parser.set_defaults(subfunc=self._set)
+
+        delete_parser = subparsers.add_parser(
+            "delete",
+            help="Delete secrets",
+            formatter_class=self._parser.formatter_class,
+        )
+        delete_parser.add_argument(
+            "name",
+            help="The name of the secret",
+        ).completer = SecretNameCompleter()
+        delete_parser.add_argument(
+            "-y", "--yes", help="Don't ask for confirmation", action="store_true"
+        )
+        delete_parser.set_defaults(subfunc=self._delete)
+
+    def _command(self, args: argparse.Namespace):
+        super()._command(args)
+        args.subfunc(args)
+
+    def _list(self, args: argparse.Namespace):
+        secrets = self.api.client.secrets.list(self.api.project)
+        print_secrets_table(secrets)
+
+    def _get(self, args: argparse.Namespace):
+        secret = self.api.client.secrets.get(self.api.project, name=args.name)
+        print_secrets_table([secret])
+
+    def _set(self, args: argparse.Namespace):
+        self.api.client.secrets.create_or_update(
+            self.api.project,
+            name=args.name,
+            value=args.value,
+        )
+        console.print("[grey58]OK[/]")
+
+    def _delete(self, args: argparse.Namespace):
+        if not args.yes and not confirm_ask(f"Delete the secret [code]{args.name}[/]?"):
+            console.print("\nExiting...")
+            return
+
+        with console.status("Deleting secret..."):
+            self.api.client.secrets.delete(
+                project_name=self.api.project,
+                names=[args.name],
+            )
+        console.print("[grey58]OK[/]")

dstack/_internal/cli/main.py

@@ -17,6 +17,7 @@ from dstack._internal.cli.commands.metrics import MetricsCommand
 from dstack._internal.cli.commands.offer import OfferCommand
 from dstack._internal.cli.commands.project import ProjectCommand
 from dstack._internal.cli.commands.ps import PsCommand
+from dstack._internal.cli.commands.secrets import SecretCommand
 from dstack._internal.cli.commands.server import ServerCommand
 from dstack._internal.cli.commands.stats import StatsCommand
 from dstack._internal.cli.commands.stop import StopCommand
@@ -72,6 +73,7 @@ def main():
     MetricsCommand.register(subparsers)
     ProjectCommand.register(subparsers)
     PsCommand.register(subparsers)
+    SecretCommand.register(subparsers)
     ServerCommand.register(subparsers)
     StatsCommand.register(subparsers)
     StopCommand.register(subparsers)

dstack/_internal/cli/services/completion.py

@@ -75,6 +75,11 @@ class GatewayNameCompleter(BaseAPINameCompleter):
         return [r.name for r in api.client.gateways.list(api.project)]
 
 
+class SecretNameCompleter(BaseAPINameCompleter):
+    def fetch_resource_names(self, api: Client) -> Iterable[str]:
+        return [r.name for r in api.client.secrets.list(api.project)]
+
+
 class ProjectNameCompleter(BaseCompleter):
     """
     Completer for local project names.

dstack/_internal/cli/services/configurators/run.py

@@ -41,12 +41,13 @@ from dstack._internal.core.models.configurations import (
 )
 from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.core.models.resources import CPUSpec
-from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunStatus
+from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunSpec, RunStatus
 from dstack._internal.core.services.configs import ConfigManager
 from dstack._internal.core.services.diff import diff_models
 from dstack._internal.utils.common import local_time
 from dstack._internal.utils.interpolator import InterpolatorError, VariablesInterpolator
 from dstack._internal.utils.logging import get_logger
+from dstack._internal.utils.nested_list import NestedList, NestedListItem
 from dstack.api._public.repos import get_ssh_keypair
 from dstack.api._public.runs import Run
 from dstack.api.utils import load_profile
@@ -102,25 +103,20 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             confirm_message = f"Submit the run [code]{conf.name}[/]?"
         stop_run_name = None
         if run_plan.current_resource is not None:
-            changed_fields = []
-            if run_plan.action == ApplyAction.UPDATE:
-                diff = diff_models(
-                    run_plan.get_effective_run_spec().configuration,
-                    run_plan.current_resource.run_spec.configuration,
-                )
-                changed_fields = list(diff.keys())
-            if run_plan.action == ApplyAction.UPDATE and len(changed_fields) > 0:
+            diff = render_run_spec_diff(
+                run_plan.get_effective_run_spec(),
+                run_plan.current_resource.run_spec,
+            )
+            if run_plan.action == ApplyAction.UPDATE and diff is not None:
                 console.print(
                     f"Active run [code]{conf.name}[/] already exists."
-                    " Detected configuration changes that can be updated in-place:"
-                    f" {changed_fields}"
+                    f" Detected changes that [code]can[/] be updated in-place:\n{diff}"
                 )
                 confirm_message = "Update the run?"
-            elif run_plan.action == ApplyAction.UPDATE and len(changed_fields) == 0:
+            elif run_plan.action == ApplyAction.UPDATE and diff is None:
                 stop_run_name = run_plan.current_resource.run_spec.run_name
                 console.print(
-                    f"Active run [code]{conf.name}[/] already exists."
-                    " Detected no configuration changes."
+                    f"Active run [code]{conf.name}[/] already exists. Detected no changes."
                 )
                 if command_args.yes and not command_args.force:
                     console.print("Use --force to apply anyway.")
@@ -129,7 +125,8 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             elif not run_plan.current_resource.status.is_finished():
                 stop_run_name = run_plan.current_resource.run_spec.run_name
                 console.print(
-                    f"Active run [code]{conf.name}[/] already exists and cannot be updated in-place."
+                    f"Active run [code]{conf.name}[/] already exists."
+                    f" Detected changes that [error]cannot[/] be updated in-place:\n{diff}"
                 )
                 confirm_message = "Stop and override the run?"
 
@@ -398,9 +395,10 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         else:
             has_amd_gpu = vendor == gpuhunt.AcceleratorVendor.AMD
             has_tt_gpu = vendor == gpuhunt.AcceleratorVendor.TENSTORRENT
-        if has_amd_gpu and conf.image is None:
+        # When docker=True, the system uses Docker-in-Docker image, so no custom image is required
+        if has_amd_gpu and conf.image is None and conf.docker is not True:
             raise ConfigurationError("`image` is required if `resources.gpu.vendor` is `amd`")
-        if has_tt_gpu and conf.image is None:
+        if has_tt_gpu and conf.image is None and conf.docker is not True:
             raise ConfigurationError(
                 "`image` is required if `resources.gpu.vendor` is `tenstorrent`"
             )
@@ -610,3 +608,47 @@ def _run_resubmitted(run: Run, current_job_submission: Optional[JobSubmission])
         not run.status.is_finished()
         and run._run.latest_job_submission.submitted_at > current_job_submission.submitted_at
     )
+
+
+def render_run_spec_diff(old_spec: RunSpec, new_spec: RunSpec) -> Optional[str]:
+    changed_spec_fields = list(diff_models(old_spec, new_spec))
+    if not changed_spec_fields:
+        return None
+    friendly_spec_field_names = {
+        "repo_id": "Repo ID",
+        "repo_code_hash": "Repo files",
+        "repo_data": "Repo state (branch, commit, or other)",
+        "ssh_key_pub": "Public SSH key",
+    }
+    nested_list = NestedList()
+    for spec_field in changed_spec_fields:
+        if spec_field == "merged_profile":
+            continue
+        elif spec_field == "configuration":
+            if type(old_spec.configuration) is not type(new_spec.configuration):
+                item = NestedListItem("Configuration type")
+            else:
+                item = NestedListItem(
+                    "Configuration properties:",
+                    children=[
+                        NestedListItem(field)
+                        for field in diff_models(old_spec.configuration, new_spec.configuration)
+                    ],
+                )
+        elif spec_field == "profile":
+            if type(old_spec.profile) is not type(new_spec.profile):
+                item = NestedListItem("Profile")
+            else:
+                item = NestedListItem(
+                    "Profile properties:",
+                    children=[
+                        NestedListItem(field)
+                        for field in diff_models(old_spec.profile, new_spec.profile)
+                    ],
+                )
+        elif spec_field in friendly_spec_field_names:
+            item = NestedListItem(friendly_spec_field_names[spec_field])
+        else:
+            item = NestedListItem(spec_field.replace("_", " ").capitalize())
+        nested_list.children.append(item)
+    return nested_list.render()

dstack/_internal/cli/utils/secrets.py

@@ -0,0 +1,25 @@
+from typing import List
+
+from rich.table import Table
+
+from dstack._internal.cli.utils.common import add_row_from_dict, console
+from dstack._internal.core.models.secrets import Secret
+
+
+def print_secrets_table(secrets: List[Secret]) -> None:
+    console.print(get_secrets_table(secrets))
+    console.print()
+
+
+def get_secrets_table(secrets: List[Secret]) -> Table:
+    table = Table(box=None)
+    table.add_column("NAME", no_wrap=True)
+    table.add_column("VALUE")
+
+    for secret in secrets:
+        row = {
+            "NAME": secret.name,
+            "VALUE": secret.value or "*" * 6,
+        }
+        add_row_from_dict(table, row)
+    return table

dstack/_internal/core/backends/__init__.py

@@ -9,18 +9,25 @@ from dstack._internal.core.backends.base.compute import (
 )
 from dstack._internal.core.backends.base.configurator import Configurator
 from dstack._internal.core.backends.configurators import list_available_configurator_classes
+from dstack._internal.core.backends.local.compute import LocalCompute
 from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.settings import LOCAL_BACKEND_ENABLED
 
 
 def _get_backends_with_compute_feature(
     configurator_classes: list[type[Configurator]],
     compute_feature_class: type,
 ) -> list[BackendType]:
+    backend_types_and_computes = [
+        (configurator_class.TYPE, configurator_class.BACKEND_CLASS.COMPUTE_CLASS)
+        for configurator_class in configurator_classes
+    ]
+    if LOCAL_BACKEND_ENABLED:
+        backend_types_and_computes.append((BackendType.LOCAL, LocalCompute))
     backend_types = []
-    for configurator_class in configurator_classes:
-        compute_class = configurator_class.BACKEND_CLASS.COMPUTE_CLASS
+    for backend_type, compute_class in backend_types_and_computes:
         if issubclass(compute_class, compute_feature_class):
-            backend_types.append(configurator_class.TYPE)
+            backend_types.append(backend_type)
     return backend_types
 
 
@@ -28,7 +35,6 @@ _configurator_classes = list_available_configurator_classes()
 
 
 # The following backend lists do not include unavailable backends (i.e. backends missing deps).
-# TODO: Add LocalBackend to lists if it's enabled
 BACKENDS_WITH_CREATE_INSTANCE_SUPPORT = _get_backends_with_compute_feature(
     configurator_classes=_configurator_classes,
     compute_feature_class=ComputeWithCreateInstanceSupport,

dstack/_internal/core/compatibility/runs.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, Optional
 
 from dstack._internal.core.models.configurations import ServiceConfiguration
-from dstack._internal.core.models.runs import ApplyRunPlanInput, JobSubmission, RunSpec
+from dstack._internal.core.models.runs import ApplyRunPlanInput, JobSpec, JobSubmission, RunSpec
 from dstack._internal.server.schemas.runs import GetRunPlanRequest
 
 
@@ -25,7 +25,10 @@ def get_apply_plan_excludes(plan: ApplyRunPlanInput) -> Optional[Dict]:
         current_resource_excludes["run_spec"] = get_run_spec_excludes(current_resource.run_spec)
         job_submissions_excludes = {}
         current_resource_excludes["jobs"] = {
-            "__all__": {"job_submissions": {"__all__": job_submissions_excludes}}
+            "__all__": {
+                "job_spec": get_job_spec_excludes([job.job_spec for job in current_resource.jobs]),
+                "job_submissions": {"__all__": job_submissions_excludes},
+            }
         }
         job_submissions = [js for j in current_resource.jobs for js in j.job_submissions]
         if all(map(_should_exclude_job_submission_jpd_cpu_arch, job_submissions)):
@@ -109,6 +112,10 @@ def get_run_spec_excludes(run_spec: RunSpec) -> Optional[Dict]:
         configuration_excludes["stop_criteria"] = True
     if profile is not None and profile.stop_criteria is None:
         profile_excludes.add("stop_criteria")
+    if not configuration.files:
+        configuration_excludes["files"] = True
+    if not run_spec.file_archives:
+        spec_excludes["file_archives"] = True
 
     if configuration_excludes:
         spec_excludes["configuration"] = configuration_excludes
@@ -119,6 +126,26 @@ def get_run_spec_excludes(run_spec: RunSpec) -> Optional[Dict]:
     return None
 
 
+def get_job_spec_excludes(job_specs: list[JobSpec]) -> Optional[dict]:
+    """
+    Returns `job_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: dict[str, Any] = {}
+
+    if all(s.repo_code_hash is None for s in job_specs):
+        spec_excludes["repo_code_hash"] = True
+    if all(s.repo_data is None for s in job_specs):
+        spec_excludes["repo_data"] = True
+    if all(not s.file_archives for s in job_specs):
+        spec_excludes["file_archives"] = True
+
+    if spec_excludes:
+        return spec_excludes
+    return None
+
+
 def _should_exclude_job_submission_jpd_cpu_arch(job_submission: JobSubmission) -> bool:
     try:
         return job_submission.job_provisioning_data.instance_type.resources.cpu_arch is None

dstack/_internal/core/models/configurations.py

@@ -10,6 +10,7 @@ from typing_extensions import Annotated, Literal
 from dstack._internal.core.errors import ConfigurationError
 from dstack._internal.core.models.common import CoreModel, Duration, RegistryAuth
 from dstack._internal.core.models.envs import Env
+from dstack._internal.core.models.files import FilePathMapping
 from dstack._internal.core.models.fleets import FleetConfiguration
 from dstack._internal.core.models.gateways import GatewayConfiguration
 from dstack._internal.core.models.profiles import ProfileParams, parse_off_duration
@@ -252,6 +253,10 @@ class BaseRunConfiguration(CoreModel):
             description="Use Docker inside the container. Mutually exclusive with `image`, `python`, and `nvcc`. Overrides `privileged`"
         ),
     ] = None
+    files: Annotated[
+        list[Union[FilePathMapping, str]],
+        Field(description="The local to container file path mappings"),
+    ] = []
     # deprecated since 0.18.31; task, service -- no effect; dev-environment -- executed right before `init`
     setup: CommandsList = []
 
@@ -285,6 +290,12 @@ class BaseRunConfiguration(CoreModel):
             return parse_mount_point(v)
         return v
 
+    @validator("files", each_item=True)
+    def convert_files(cls, v) -> FilePathMapping:
+        if isinstance(v, str):
+            return FilePathMapping.parse(v)
+        return v
+
     @validator("user")
     def validate_user(cls, v) -> Optional[str]:
         if v is None:

dstack/_internal/core/models/files.py

@@ -0,0 +1,67 @@
+import pathlib
+import string
+from uuid import UUID
+
+from pydantic import Field, validator
+from typing_extensions import Annotated, Self
+
+from dstack._internal.core.models.common import CoreModel
+
+
+class FileArchive(CoreModel):
+    id: UUID
+    hash: str
+
+
+class FilePathMapping(CoreModel):
+    local_path: Annotated[
+        str,
+        Field(
+            description=(
+                "The path on the user's machine. Relative paths are resolved relative to"
+                " the parent directory of the the configuration file"
+            )
+        ),
+    ]
+    path: Annotated[
+        str,
+        Field(
+            description=(
+                "The path in the container. Relative paths are resolved relative to"
+                " the repo directory (`/workflow`)"
+            )
+        ),
+    ]
+
+    @classmethod
+    def parse(cls, v: str) -> Self:
+        local_path: str
+        path: str
+        parts = v.split(":")
+        # A special case for Windows paths, e.g., `C:\path\to`, 'c:/path/to'
+        if (
+            len(parts) > 1
+            and len(parts[0]) == 1
+            and parts[0] in string.ascii_letters
+            and parts[1][:1] in ["\\", "/"]
+        ):
+            parts = [f"{parts[0]}:{parts[1]}", *parts[2:]]
+        if len(parts) == 1:
+            local_path = path = parts[0]
+        elif len(parts) == 2:
+            local_path, path = parts
+        else:
+            raise ValueError(f"invalid file path mapping: {v}")
+        return cls(local_path=local_path, path=path)
+
+    @validator("path")
+    def validate_path(cls, v) -> str:
+        # True for `C:/.*`, False otherwise, including `/abs/unix/path`, `rel\windows\path`, etc.
+        if pathlib.PureWindowsPath(v).is_absolute():
+            raise ValueError(f"path must be a Unix file path: {v}")
+        return v
+
+
+class FileArchiveMapping(CoreModel):
+    id: Annotated[UUID, Field(description="The File archive ID")]
+    path: Annotated[str, Field(description="The path in the container")]

dstack/_internal/core/models/runs.py

@@ -12,6 +12,7 @@ from dstack._internal.core.models.configurations import (
     AnyRunConfiguration,
     RunConfiguration,
 )
+from dstack._internal.core.models.files import FileArchiveMapping
 from dstack._internal.core.models.instances import (
     InstanceOfferWithAvailability,
     InstanceType,
@@ -217,6 +218,15 @@ class JobSpec(CoreModel):
     volumes: Optional[List[MountPoint]] = None
     ssh_key: Optional[JobSSHKey] = None
     working_dir: Optional[str]
+    # `repo_data` is optional for client compatibility with pre-0.19.17 servers and for compatibility
+    # with jobs submitted before 0.19.17. All new jobs are expected to have non-None `repo_data`.
+    # For --no-repo runs, `repo_data` is `VirtualRunRepoData()`.
+    repo_data: Annotated[Optional[AnyRunRepoData], Field(discriminator="repo_type")] = None
+    # `repo_code_hash` can be None because it is not used for the repo or because the job was
+    # submitted before 0.19.17. See `_get_repo_code_hash` on how to get the correct `repo_code_hash`
+    # TODO: drop this comment when supporting jobs submitted before 0.19.17 is no longer relevant.
+    repo_code_hash: Optional[str] = None
+    file_archives: list[FileArchiveMapping] = []
 
 
 class JobProvisioningData(CoreModel):
@@ -413,6 +423,10 @@ class RunSpec(CoreModel):
         Optional[str],
         Field(description="The hash of the repo diff. Can be omitted if there is no repo diff."),
     ] = None
+    file_archives: Annotated[
+        list[FileArchiveMapping],
+        Field(description="The list of file archive ID to container path mappings"),
+    ] = []
     working_dir: Annotated[
         Optional[str],
         Field(

dstack/_internal/core/models/secrets.py

@@ -1,9 +1,16 @@
+from typing import Optional
+from uuid import UUID
+
 from dstack._internal.core.models.common import CoreModel
 
 
 class Secret(CoreModel):
+    id: UUID
     name: str
-    value: str
+    value: Optional[str] = None
 
     def __str__(self) -> str:
-        return f'Secret(name="{self.name}", value={"*" * len(self.value)})'
+        displayed_value = "*"
+        if self.value is not None:
+            displayed_value = "*" * len(self.value)
+        return f'Secret(name="{self.name}", value={displayed_value})'

dstack/_internal/server/app.py

@@ -23,6 +23,7 @@ from dstack._internal.server.background import start_background_tasks
 from dstack._internal.server.db import get_db, get_session_ctx, migrate
 from dstack._internal.server.routers import (
     backends,
+    files,
     fleets,
     gateways,
     instances,
@@ -197,6 +198,7 @@ def register_routes(app: FastAPI, ui: bool = True):
     app.include_router(service_proxy.router, prefix="/proxy/services", tags=["service-proxy"])
     app.include_router(model_proxy.router, prefix="/proxy/models", tags=["model-proxy"])
     app.include_router(prometheus.router)
+    app.include_router(files.router)
 
     @app.exception_handler(ForbiddenError)
     async def forbidden_error_handler(request: Request, exc: ForbiddenError):