dstack 0.19.15rc1__py3-none-any.whl → 0.19.17__py3-none-any.whl

dstack/_internal/server/statics/static/media/google.b194b06fafd0a52aeb566922160ea514.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="14" viewBox="0 0 24 24" width="14"><path d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z" fill="#4285F4"/><path d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z" fill="#34A853"/><path d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z" fill="#FBBC05"/><path d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z" fill="#EA4335"/><path d="M1 1h22v22H1z" fill="none"/></svg>

dstack/_internal/server/testing/common.py

@@ -1,5 +1,6 @@
 import json
 import uuid
+from collections.abc import Callable
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from typing import Dict, List, Literal, Optional, Union
@@ -77,6 +78,7 @@ from dstack._internal.core.models.volumes import (
 from dstack._internal.server.models import (
     BackendModel,
     DecryptedString,
+    FileArchiveModel,
     FleetModel,
     GatewayComputeModel,
     GatewayModel,
@@ -89,6 +91,7 @@ from dstack._internal.server.models import (
     RepoCredsModel,
     RepoModel,
     RunModel,
+    SecretModel,
     UserModel,
     VolumeAttachmentModel,
     VolumeModel,
@@ -232,21 +235,38 @@ async def create_repo_creds(
     return repo_creds
 
 
+async def create_file_archive(
+    session: AsyncSession,
+    user_id: UUID,
+    blob_hash: str = "blob_hash",
+    blob: bytes = b"blob_content",
+) -> FileArchiveModel:
+    archive = FileArchiveModel(
+        user_id=user_id,
+        blob_hash=blob_hash,
+        blob=blob,
+    )
+    session.add(archive)
+    await session.commit()
+    return archive
+
+
 def get_run_spec(
     run_name: str,
     repo_id: str,
-    profile: Optional[Profile] = None,
+    configuration_path: str = "dstack.yaml",
+    profile: Union[Profile, Callable[[], Profile], None] = lambda: Profile(name="default"),
     configuration: Optional[AnyRunConfiguration] = None,
 ) -> RunSpec:
-    if profile is None:
-        profile = Profile(name="default")
+    if callable(profile):
+        profile = profile()
     return RunSpec(
         run_name=run_name,
         repo_id=repo_id,
         repo_data=LocalRunRepoData(repo_dir="/"),
         repo_code_hash=None,
         working_dir=".",
-        configuration_path="dstack.yaml",
+        configuration_path=configuration_path,
         configuration=configuration or DevEnvironmentConfiguration(ide="vscode"),
         profile=profile,
         ssh_key_pub="user_ssh_key",
@@ -315,7 +335,9 @@ async def create_job(
     if deployment_num is None:
         deployment_num = run.deployment_num
     run_spec = RunSpec.parse_raw(run.run_spec)
-    job_spec = (await get_job_specs_from_run_spec(run_spec, replica_num=replica_num))[0]
+    job_spec = (
+        await get_job_specs_from_run_spec(run_spec=run_spec, secrets={}, replica_num=replica_num)
+    )[0]
     job_spec.job_num = job_num
     job = JobModel(
         project_id=run.project_id,
@@ -917,6 +939,22 @@ async def create_job_prometheus_metrics(
     return metrics
 
 
+async def create_secret(
+    session: AsyncSession,
+    project: ProjectModel,
+    name: str,
+    value: str,
+):
+    secret_model = SecretModel(
+        project=project,
+        name=name,
+        value=DecryptedString(plaintext=value),
+    )
+    session.add(secret_model)
+    await session.commit()
+    return secret_model
+
+
 def get_private_key_string() -> str:
     return """
 -----BEGIN RSA PRIVATE KEY-----

dstack/_internal/settings.py

@@ -17,6 +17,11 @@ DSTACK_BASE_IMAGE_VERSION = os.getenv("DSTACK_BASE_IMAGE_VERSION", version.base_
 DSTACK_BASE_IMAGE_UBUNTU_VERSION = os.getenv(
     "DSTACK_BASE_IMAGE_UBUNTU_VERSION", version.base_image_ubuntu_version
 )
+DSTACK_DIND_IMAGE = os.getenv("DSTACK_DIND_IMAGE", "dstackai/dind")
+
+# Development settings
+
+LOCAL_BACKEND_ENABLED = os.getenv("DSTACK_LOCAL_BACKEND_ENABLED") is not None
 
 
 class FeatureFlags:

dstack/_internal/utils/files.py

@@ -0,0 +1,69 @@
+import tarfile
+from pathlib import Path
+from typing import BinaryIO
+
+import ignore
+import ignore.overrides
+
+from dstack._internal.utils.hash import get_sha256
+from dstack._internal.utils.path import PathLike, normalize_path
+
+
+def create_file_archive(root: PathLike, fp: BinaryIO) -> str:
+    """
+    Packs the directory or file to a tar archive and writes it to the file-like object.
+
+    Archives can be used to transfer file(s) (e.g., over the network) preserving
+    file properties such as permissions, timestamps, etc.
+
+    NOTE: `.gitignore` and `.dstackignore` are respected.
+
+    Args:
+        root: The absolute path to the directory or file.
+        fp: The binary file-like object.
+
+    Returns:
+        The SHA-256 hash of the archive as a hex string.
+
+    Raises:
+        ValueError: If the path is not absolute.
+        OSError: Underlying errors from the tarfile module
+    """
+    root = Path(root)
+    if not root.is_absolute():
+        raise ValueError(f"path must be absolute: {root}")
+    walk = (
+        ignore.WalkBuilder(root)
+        .overrides(ignore.overrides.OverrideBuilder(root).add("!/.git/").build())
+        .hidden(False)  # do not ignore files that start with a dot
+        .require_git(False)  # respect git ignore rules even if not a git repo
+        .add_custom_ignore_filename(".dstackignore")
+        .build()
+    )
+    # sort paths to ensure archive reproducibility
+    paths = sorted(entry.path() for entry in walk)
+    with tarfile.TarFile(mode="w", fileobj=fp) as t:
+        for path in paths:
+            arcname = str(path.relative_to(root.parent))
+            info = t.gettarinfo(path, arcname)
+            if info.issym():
+                # Symlinks are handled as follows: each symlink in the chain is checked, and
+                # * if the target is inside the root: keep relative links as is, replace absolute
+                #   links with relative ones;
+                # * if the target is outside the root: replace the link with the actual file.
+                target = Path(info.linkname)
+                if not target.is_absolute():
+                    target = path.parent / target
+                target = normalize_path(target)
+                try:
+                    target.relative_to(root)
+                except ValueError:
+                    # Adding as a file
+                    t.add(path.resolve(), arcname, recursive=False)
+                else:
+                    # Adding as a relative symlink
+                    info.linkname = str(target.relative_to(path.parent, walk_up=True))
+                    t.addfile(info)
+            else:
+                t.add(path, arcname, recursive=False)
+    return get_sha256(fp)

dstack/_internal/utils/nested_list.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class NestedListItem:
+    label: str
+    children: list["NestedListItem"] = field(default_factory=list)
+
+    def render(self, indent: int = 0, visited: Optional[set[int]] = None) -> str:
+        if visited is None:
+            visited = set()
+
+        item_id = id(self)
+        if item_id in visited:
+            raise ValueError(f"Cycle detected at item: {self.label}")
+
+        visited.add(item_id)
+        prefix = "  " * indent + "- "
+        output = f"{prefix}{self.label}\n"
+        for child in self.children:
+            # `visited.copy()` so that we only detect cycles within each path,
+            # rather than duplicate items in unrelated paths
+            output += child.render(indent + 1, visited.copy())
+        return output
+
+
+@dataclass
+class NestedList:
+    """
+    A nested list that can be rendered in Markdown-like format:
+
+    - Item 1
+    - Item 2
+      - Item 2.1
+      - Item 2.2
+        - Item 2.2.1
+    - Item 3
+    """
+
+    children: list[NestedListItem] = field(default_factory=list)
+
+    def render(self) -> str:
+        output = ""
+        for child in self.children:
+            output += child.render()
+        return output

dstack/_internal/utils/path.py

@@ -27,16 +27,24 @@ def path_in_dir(path: PathLike, directory: PathLike) -> bool:
         return False
 
 
-def resolve_relative_path(path: str) -> PurePath:
+def normalize_path(path: PathLike) -> PurePath:
     path = PurePath(path)
-    if path.is_absolute():
-        raise ValueError("Path should be relative")
     stack = []
     for part in path.parts:
         if part == "..":
             if not stack:
-                raise ValueError("Path is outside of the repo")
+                raise ValueError("Path is outside of the top directory")
             stack.pop()
         else:
             stack.append(part)
     return PurePath(*stack)
+
+
+def resolve_relative_path(path: PathLike) -> PurePath:
+    path = PurePath(path)
+    if path.is_absolute():
+        raise ValueError("Path should be relative")
+    try:
+        return normalize_path(path)
+    except ValueError:
+        raise ValueError("Path is outside of the repo")

dstack/api/_public/runs.py

@@ -4,10 +4,12 @@ import tempfile
 import threading
 import time
 from abc import ABC
+from collections.abc import Iterator
+from contextlib import contextmanager
 from copy import copy
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Iterable, List, Optional, Union
+from typing import BinaryIO, Dict, Iterable, List, Optional, Union
 from urllib.parse import urlparse
 
 from websocket import WebSocketApp
@@ -17,6 +19,7 @@ from dstack._internal.core.consts import DSTACK_RUNNER_HTTP_PORT, DSTACK_RUNNER_
 from dstack._internal.core.errors import ClientError, ConfigurationError, ResourceNotExistsError
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.configurations import AnyRunConfiguration, PortMapping
+from dstack._internal.core.models.files import FileArchiveMapping, FilePathMapping
 from dstack._internal.core.models.profiles import (
     CreationPolicy,
     Profile,
@@ -42,6 +45,7 @@ from dstack._internal.core.services.ssh.attach import SSHAttach
 from dstack._internal.core.services.ssh.ports import PortsLock
 from dstack._internal.server.schemas.logs import PollLogsRequest
 from dstack._internal.utils.common import get_or_error, make_proxy_url
+from dstack._internal.utils.files import create_file_archive
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.path import PathLike, path_in_dir
 from dstack.api.server import APIClient
@@ -204,25 +208,26 @@ class Run(ABC):
             job = self._find_job(replica_num=replica_num, job_num=job_num)
             if job is None:
                 return []
-            next_start_time = start_time
+            next_token = None
             while True:
                 resp = self._api_client.logs.poll(
                     project_name=self._project,
                     body=PollLogsRequest(
                         run_name=self.name,
                         job_submission_id=job.job_submissions[-1].id,
-                        start_time=next_start_time,
+                        start_time=start_time,
                         end_time=None,
                         descending=False,
                         limit=1000,
                         diagnose=diagnose,
+                        next_token=next_token,
                     ),
                 )
-                if len(resp.logs) == 0:
-                    return []
                 for log in resp.logs:
                     yield base64.b64decode(log.message)
-                next_start_time = resp.logs[-1].timestamp
+                next_token = resp.next_token
+                if next_token is None:
+                    break
 
     def refresh(self):
         """
@@ -435,12 +440,16 @@ class RunCollection:
         """
         if repo is None:
             repo = VirtualRepo()
+            repo_code_hash = None
+        else:
+            with _prepare_code_file(repo) as (_, repo_code_hash):
+                pass
 
         run_spec = RunSpec(
             run_name=configuration.name,
             repo_id=repo.repo_id,
             repo_data=repo.run_repo_data,
-            repo_code_hash=None,  # `apply_plan` will fill it
+            repo_code_hash=repo_code_hash,
             working_dir=configuration.working_dir,
             configuration_path=configuration_path,
             configuration=configuration,
@@ -475,20 +484,36 @@ class RunCollection:
             # TODO handle multiple jobs
             ports_lock = _reserve_ports(run_plan.job_plans[0].job_spec)
 
+        run_spec = run_plan.run_spec
+        configuration = run_spec.configuration
+
+        self._validate_configuration_files(configuration, run_spec.configuration_path)
+        for file_mapping in configuration.files:
+            assert isinstance(file_mapping, FilePathMapping)
+            with tempfile.TemporaryFile("w+b") as fp:
+                try:
+                    archive_hash = create_file_archive(file_mapping.local_path, fp)
+                except OSError as e:
+                    raise ClientError(f"failed to archive '{file_mapping.local_path}': {e}") from e
+                fp.seek(0)
+                archive = self._api_client.files.upload_archive(hash=archive_hash, fp=fp)
+            run_spec.file_archives.append(
+                FileArchiveMapping(id=archive.id, path=file_mapping.path)
+            )
+
         if repo is None:
             repo = VirtualRepo()
         else:
             # Do not upload the diff without a repo (a default virtual repo)
             # since upload_code() requires a repo to be initialized.
-            with tempfile.TemporaryFile("w+b") as fp:
-                run_plan.run_spec.repo_code_hash = repo.write_code_file(fp)
-                fp.seek(0)
+            with _prepare_code_file(repo) as (fp, repo_code_hash):
                 self._api_client.repos.upload_code(
                     project_name=self._project,
                     repo_id=repo.repo_id,
-                    code_hash=run_plan.run_spec.repo_code_hash,
+                    code_hash=repo_code_hash,
                     fp=fp,
                 )
+
         run = self._api_client.runs.apply_plan(self._project, run_plan)
         return self._model_to_submitted_run(run, ports_lock)
 
@@ -626,6 +651,10 @@ class RunCollection:
         logger.warning("The get_plan() method is deprecated in favor of get_run_plan().")
         if repo is None:
             repo = VirtualRepo()
+            repo_code_hash = None
+        else:
+            with _prepare_code_file(repo) as (_, repo_code_hash):
+                pass
 
         if working_dir is None:
             working_dir = "."
@@ -662,7 +691,7 @@ class RunCollection:
             run_name=run_name,
             repo_id=repo.repo_id,
             repo_data=repo.run_repo_data,
-            repo_code_hash=None,  # `exec_plan` will fill it
+            repo_code_hash=repo_code_hash,
             working_dir=working_dir,
             configuration_path=configuration_path,
             configuration=configuration,
@@ -761,6 +790,30 @@ class RunCollection:
             ports_lock,
         )
 
+    def _validate_configuration_files(
+        self, configuration: AnyRunConfiguration, configuration_path: Optional[PathLike]
+    ) -> None:
+        """
+        Expands, normalizes and validates local paths specified in
+        the `files` configuration property.
+        """
+        base_dir: Optional[Path] = None
+        if configuration_path is not None:
+            base_dir = Path(configuration_path).expanduser().resolve().parent
+        for file_mapping in configuration.files:
+            assert isinstance(file_mapping, FilePathMapping)
+            path = Path(file_mapping.local_path).expanduser()
+            if not path.is_absolute():
+                if base_dir is None:
+                    raise ConfigurationError(
+                        f"Path '{path}' is relative but `configuration_path` is not provided"
+                    )
+                else:
+                    path = base_dir / path
+            if not path.exists():
+                raise ConfigurationError(f"Path '{path}' specified in `files` does not exist")
+            file_mapping.local_path = str(path)
+
 
 def _reserve_ports(
     job_spec: JobSpec,
@@ -780,3 +833,11 @@ def _reserve_ports(
         ports[port_override.container_port] = port_override.local_port or 0
     logger.debug("Reserving ports: %s", ports)
     return PortsLock(ports).acquire()
+
+
+@contextmanager
+def _prepare_code_file(repo: Repo) -> Iterator[tuple[BinaryIO, str]]:
+    with tempfile.TemporaryFile("w+b") as fp:
+        repo_code_hash = repo.write_code_file(fp)
+        fp.seek(0)
+        yield fp, repo_code_hash

dstack/api/server/__init__.py

@@ -14,6 +14,7 @@ from dstack._internal.core.errors import (
 )
 from dstack._internal.utils.logging import get_logger
 from dstack.api.server._backends import BackendsAPIClient
+from dstack.api.server._files import FilesAPIClient
 from dstack.api.server._fleets import FleetsAPIClient
 from dstack.api.server._gateways import GatewaysAPIClient
 from dstack.api.server._logs import LogsAPIClient
@@ -47,6 +48,7 @@ class APIClient:
         logs: operations with logs
         gateways: operations with gateways
         volumes: operations with volumes
+        files: operations with files
     """
 
     def __init__(self, base_url: str, token: str):
@@ -111,6 +113,10 @@ class APIClient:
     def volumes(self) -> VolumesAPIClient:
         return VolumesAPIClient(self._request)
 
+    @property
+    def files(self) -> FilesAPIClient:
+        return FilesAPIClient(self._request)
+
     def _request(
         self,
         path: str,

dstack/api/server/_files.py

@@ -0,0 +1,18 @@
+from typing import BinaryIO
+
+from pydantic import parse_obj_as
+
+from dstack._internal.core.models.files import FileArchive
+from dstack._internal.server.schemas.files import GetFileArchiveByHashRequest
+from dstack.api.server._group import APIClientGroup
+
+
+class FilesAPIClient(APIClientGroup):
+    def get_archive_by_hash(self, hash: str) -> FileArchive:
+        body = GetFileArchiveByHashRequest(hash=hash)
+        resp = self._request("/api/files/get_archive_by_hash", body=body.json())
+        return parse_obj_as(FileArchive.__response__, resp.json())
+
+    def upload_archive(self, hash: str, fp: BinaryIO) -> FileArchive:
+        resp = self._request("/api/files/upload_archive", files={"file": (hash, fp)})
+        return parse_obj_as(FileArchive.__response__, resp.json())

dstack/api/server/_logs.py

@@ -1,5 +1,6 @@
 from pydantic import parse_obj_as
 
+from dstack._internal.core.compatibility.logs import get_poll_logs_excludes
 from dstack._internal.core.models.logs import JobSubmissionLogs
 from dstack._internal.server.schemas.logs import PollLogsRequest
 from dstack.api.server._group import APIClientGroup
@@ -7,5 +8,8 @@ from dstack.api.server._group import APIClientGroup
 
 class LogsAPIClient(APIClientGroup):
     def poll(self, project_name: str, body: PollLogsRequest) -> JobSubmissionLogs:
-        resp = self._request(f"/api/project/{project_name}/logs/poll", body=body.json())
+        resp = self._request(
+            f"/api/project/{project_name}/logs/poll",
+            body=body.json(exclude=get_poll_logs_excludes(body)),
+        )
         return parse_obj_as(JobSubmissionLogs.__response__, resp.json())

dstack/api/server/_projects.py

@@ -3,10 +3,13 @@ from typing import List
 from pydantic import parse_obj_as
 
 from dstack._internal.core.models.projects import Project
+from dstack._internal.core.models.users import ProjectRole
 from dstack._internal.server.schemas.projects import (
+    AddProjectMemberRequest,
     CreateProjectRequest,
     DeleteProjectsRequest,
     MemberSetting,
+    RemoveProjectMemberRequest,
     SetProjectMembersRequest,
 )
 from dstack.api.server._group import APIClientGroup
@@ -34,3 +37,24 @@ class ProjectsAPIClient(APIClientGroup):
         body = SetProjectMembersRequest(members=members)
         resp = self._request(f"/api/projects/{project_name}/set_members", body=body.json())
         return parse_obj_as(Project.__response__, resp.json())
+
+    def add_member(self, project_name: str, username: str, project_role: ProjectRole) -> Project:
+        member_setting = MemberSetting(username=username, project_role=project_role)
+        body = AddProjectMemberRequest(members=[member_setting])
+        resp = self._request(f"/api/projects/{project_name}/add_members", body=body.json())
+        return parse_obj_as(Project.__response__, resp.json())
+
+    def add_members(self, project_name: str, members: List[MemberSetting]) -> Project:
+        body = AddProjectMemberRequest(members=members)
+        resp = self._request(f"/api/projects/{project_name}/add_members", body=body.json())
+        return parse_obj_as(Project.__response__, resp.json())
+
+    def remove_member(self, project_name: str, username: str) -> Project:
+        body = RemoveProjectMemberRequest(usernames=[username])
+        resp = self._request(f"/api/projects/{project_name}/remove_members", body=body.json())
+        return parse_obj_as(Project.__response__, resp.json())
+
+    def remove_members(self, project_name: str, usernames: List[str]) -> Project:
+        body = RemoveProjectMemberRequest(usernames=usernames)
+        resp = self._request(f"/api/projects/{project_name}/remove_members", body=body.json())
+        return parse_obj_as(Project.__response__, resp.json())

dstack/api/server/_secrets.py

@@ -4,33 +4,33 @@ from pydantic import parse_obj_as
 
 from dstack._internal.core.models.secrets import Secret
 from dstack._internal.server.schemas.secrets import (
-    AddSecretRequest,
+    CreateOrUpdateSecretRequest,
     DeleteSecretsRequest,
-    GetSecretsRequest,
-    ListSecretsRequest,
+    GetSecretRequest,
 )
 from dstack.api.server._group import APIClientGroup
 
 
 class SecretsAPIClient(APIClientGroup):
-    def list(self, project_name: str, repo_id: str) -> List[Secret]:
-        body = ListSecretsRequest(repo_id=repo_id)
-        resp = self._request(f"/api/project/{project_name}/secrets/list", body=body.json())
+    def list(self, project_name: str) -> List[Secret]:
+        resp = self._request(f"/api/project/{project_name}/secrets/list")
         return parse_obj_as(List[Secret.__response__], resp.json())
 
-    def get(self, project_name: str, repo_id: str, secret_name: str) -> Secret:
-        raise NotImplementedError()
-        body = GetSecretsRequest(repo_id=repo_id)
+    def get(self, project_name: str, name: str) -> Secret:
+        body = GetSecretRequest(name=name)
         resp = self._request(f"/api/project/{project_name}/secrets/get", body=body.json())
         return parse_obj_as(Secret, resp.json())
 
-    def add(self, project_name: str, repo_id: str, secret_name: str, secret_value: str) -> Secret:
-        body = AddSecretRequest(
-            repo_id=repo_id, secret=Secret(name=secret_name, value=secret_value)
+    def create_or_update(self, project_name: str, name: str, value: str) -> Secret:
+        body = CreateOrUpdateSecretRequest(
+            name=name,
+            value=value,
+        )
+        resp = self._request(
+            f"/api/project/{project_name}/secrets/create_or_update", body=body.json()
         )
-        resp = self._request(f"/api/project/{project_name}/secrets/add", body=body.json())
         return parse_obj_as(Secret.__response__, resp.json())
 
-    def delete(self, project_name: str, repo_id: str, secrets_names: List[str]):
-        body = DeleteSecretsRequest(repo_id=repo_id, secrets_names=secrets_names)
+    def delete(self, project_name: str, names: List[str]):
+        body = DeleteSecretsRequest(secrets_names=names)
         self._request(f"/api/project/{project_name}/secrets/delete", body=body.json())

dstack/version.py

@@ -1,4 +1,4 @@
-__version__ = "0.19.15rc1"
+__version__ = "0.19.17"
 __is_release__ = True
 base_image = "0.10"
 base_image_ubuntu_version = "22.04"

{dstack-0.19.15rc1.dist-info → dstack-0.19.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.15rc1
+Version: 0.19.17
 Summary: dstack is an open-source orchestration engine for running AI workloads on any cloud or on-premises.
 Project-URL: Homepage, https://dstack.ai
 Project-URL: Source, https://github.com/dstackai/dstack
@@ -338,8 +338,7 @@ Description-Content-Type: text/markdown
 
 </div>
 
-`dstack` is an open-source alternative to Kubernetes and Slurm, designed to simplify GPU allocation and AI workload
-orchestration for ML teams across top clouds and on-prem clusters.
+`dstack` is an open-source container orchestrator that simplifies workload orchestration and drives GPU utilization for ML teams. It works with any GPU cloud, on-prem cluster, or accelerated hardware.
 
 #### Accelerators
 
@@ -355,7 +354,7 @@ orchestration for ML teams across top clouds and on-prem clusters.
 
 ## How does it work?
 
-<img src="https://dstack.ai/static-assets/static-assets/images/dstack-architecture-diagram-v8.svg" width="750" />
+<img src="https://dstack.ai/static-assets/static-assets/images/dstack-architecture-diagram-v10.svg" width="750" />
 
 ### Installation