dstack 0.19.25rc1__py3-none-any.whl → 0.19.27__py3-none-any.whl

dstack/_internal/server/testing/common.py

@@ -28,6 +28,7 @@ from dstack._internal.core.models.configurations import (
 from dstack._internal.core.models.envs import Env
 from dstack._internal.core.models.fleets import (
     FleetConfiguration,
+    FleetNodesSpec,
     FleetSpec,
     FleetStatus,
     InstanceGroupPlacement,
@@ -60,7 +61,7 @@ from dstack._internal.core.models.profiles import (
 )
 from dstack._internal.core.models.repos.base import RepoType
 from dstack._internal.core.models.repos.local import LocalRunRepoData
-from dstack._internal.core.models.resources import CPUSpec, Memory, Range, ResourcesSpec
+from dstack._internal.core.models.resources import CPUSpec, Memory, ResourcesSpec
 from dstack._internal.core.models.runs import (
     JobProvisioningData,
     JobRuntimeData,
@@ -271,7 +272,7 @@ def get_run_spec(
         repo_id=repo_id,
         repo_data=LocalRunRepoData(repo_dir="/"),
         repo_code_hash=None,
-        working_dir=".",
+        working_dir=None,
         configuration_path=configuration_path,
         configuration=configuration or DevEnvironmentConfiguration(ide="vscode"),
         profile=profile,
@@ -284,6 +285,7 @@ async def create_run(
     project: ProjectModel,
     repo: RepoModel,
     user: UserModel,
+    fleet: Optional[FleetModel] = None,
     run_name: str = "test-run",
     status: RunStatus = RunStatus.SUBMITTED,
     termination_reason: Optional[RunTerminationReason] = None,
@@ -309,6 +311,7 @@ async def create_run(
         project_id=project.id,
         repo_id=repo.id,
         user_id=user.id,
+        fleet_id=fleet.id if fleet else None,
         submitted_at=submitted_at,
         run_name=run_name,
         status=status,
@@ -573,13 +576,13 @@ def get_fleet_spec(conf: Optional[FleetConfiguration] = None) -> FleetSpec:
     return FleetSpec(
         configuration=conf,
         configuration_path="fleet.dstack.yml",
-        profile=Profile(name=""),
+        profile=Profile(),
     )
 
 
 def get_fleet_configuration(
     name: str = "test-fleet",
-    nodes: Range[int] = Range(min=1, max=1),
+    nodes: FleetNodesSpec = FleetNodesSpec(min=1, target=1, max=1),
     placement: Optional[InstanceGroupPlacement] = None,
 ) -> FleetConfiguration:
     return FleetConfiguration(

dstack/_internal/server/utils/logging.py

@@ -31,15 +31,15 @@ def configure_logging():
             rename_fields={"name": "logger", "asctime": "timestamp", "levelname": "level"},
         ),
     }
-    handlers = {
+    handlers: dict[str, logging.Handler] = {
         "rich": DstackRichHandler(console=console),
         "standard": logging.StreamHandler(stream=sys.stdout),
         "json": logging.StreamHandler(stream=sys.stdout),
     }
     if settings.LOG_FORMAT not in formatters:
         raise ValueError(f"Invalid settings.LOG_FORMAT: {settings.LOG_FORMAT}")
-    formatter = formatters.get(settings.LOG_FORMAT)
-    handler = handlers.get(settings.LOG_FORMAT)
+    formatter = formatters[settings.LOG_FORMAT]
+    handler = handlers[settings.LOG_FORMAT]
     handler.setFormatter(formatter)
     handler.addFilter(AsyncioCancelledErrorFilter())
     root_logger = logging.getLogger(None)

dstack/_internal/server/utils/provisioning.py

@@ -312,10 +312,10 @@ def get_paramiko_connection(
     with proxy_ctx as proxy_client, paramiko.SSHClient() as client:
         proxy_channel: Optional[paramiko.Channel] = None
         if proxy_client is not None:
+            transport = proxy_client.get_transport()
+            assert transport is not None
             try:
-                proxy_channel = proxy_client.get_transport().open_channel(
-                    "direct-tcpip", (host, port), ("", 0)
-                )
+                proxy_channel = transport.open_channel("direct-tcpip", (host, port), ("", 0))
             except (paramiko.SSHException, OSError) as e:
                 raise ProvisioningError(f"Proxy channel failed: {e}") from e
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

dstack/_internal/utils/json_schema.py

@@ -3,7 +3,9 @@ def add_extra_schema_types(schema_property: dict, extra_types: list[dict]):
         refs = [schema_property.pop("allOf")[0]]
     elif "anyOf" in schema_property:
         refs = schema_property.pop("anyOf")
-    else:
+    elif "type" in schema_property:
         refs = [{"type": schema_property.pop("type")}]
+    else:
+        refs = [{"$ref": schema_property.pop("$ref")}]
     refs.extend(extra_types)
     schema_property["anyOf"] = refs

dstack/_internal/utils/path.py

@@ -1,6 +1,6 @@
 import os
 from dataclasses import dataclass
-from pathlib import Path, PurePath
+from pathlib import Path, PurePath, PurePosixPath
 from typing import Union
 
 PathLike = Union[str, os.PathLike]
@@ -48,3 +48,10 @@ def resolve_relative_path(path: PathLike) -> PurePath:
         return normalize_path(path)
     except ValueError:
         raise ValueError("Path is outside of the repo")
+
+
+def is_absolute_posix_path(path: PathLike) -> bool:
+    # Passing Windows path leads to undefined behavior
+    if str(path).startswith("~"):
+        return True
+    return PurePosixPath(path).is_absolute()

dstack/_internal/utils/ssh.py

@@ -50,6 +50,13 @@ def make_ssh_command_for_git(identity_file: PathLike) -> str:
     )
 
 
+def make_git_env(*, identity_file: Optional[PathLike] = None) -> dict[str, str]:
+    env: dict[str, str] = {"GIT_TERMINAL_PROMPT": "0"}
+    if identity_file is not None:
+        env["GIT_SSH_COMMAND"] = make_ssh_command_for_git(identity_file)
+    return env
+
+
 def try_ssh_key_passphrase(identity_file: PathLike, passphrase: str = "") -> bool:
     ssh_keygen = find_ssh_util("ssh-keygen")
     if ssh_keygen is None:

dstack/_internal/utils/typing.py

@@ -0,0 +1,14 @@
+from typing import Any, Protocol, TypeVar, Union
+
+_T_contra = TypeVar("_T_contra", contravariant=True)
+
+
+class SupportsDunderLT(Protocol[_T_contra]):
+    def __lt__(self, other: _T_contra, /) -> bool: ...
+
+
+class SupportsDunderGT(Protocol[_T_contra]):
+    def __gt__(self, other: _T_contra, /) -> bool: ...
+
+
+SupportsRichComparison = Union[SupportsDunderLT[Any], SupportsDunderGT[Any]]

dstack/api/_public/repos.py

@@ -1,15 +1,21 @@
 from pathlib import Path
-from typing import Optional, Union
+from typing import Literal, Optional, Union, overload
 
 from git import InvalidGitRepositoryError
 
 from dstack._internal.core.errors import ConfigurationError, ResourceNotExistsError
-from dstack._internal.core.models.repos import LocalRepo, RemoteRepo
+from dstack._internal.core.models.repos import (
+    LocalRepo,
+    RemoteRepo,
+    RemoteRepoCreds,
+    RepoHead,
+    RepoHeadWithCreds,
+)
 from dstack._internal.core.models.repos.base import Repo, RepoType
 from dstack._internal.core.services.configs import ConfigManager
 from dstack._internal.core.services.repos import (
     InvalidRepoCredentialsError,
-    get_local_repo_credentials,
+    get_repo_creds_and_default_branch,
     load_repo,
 )
 from dstack._internal.utils.crypto import generate_rsa_key_pair
@@ -34,6 +40,7 @@ class RepoCollection:
         repo: Repo,
         git_identity_file: Optional[PathLike] = None,
         oauth_token: Optional[str] = None,
+        creds: Optional[RemoteRepoCreds] = None,
     ):
         """
         Initializes the repo and configures its credentials in the project.
@@ -65,11 +72,13 @@ class RepoCollection:
             repo: The repo to initialize.
             git_identity_file: The private SSH key path for accessing the remote repo.
             oauth_token: The GitHub OAuth token to access the remote repo.
+            creds: Optional prepared repo credentials. If specified, both `git_identity_file`
+                and `oauth_token` are ignored.
         """
-        creds = None
-        if isinstance(repo, RemoteRepo):
+        if creds is None and isinstance(repo, RemoteRepo):
+            assert repo.repo_url is not None
             try:
-                creds = get_local_repo_credentials(
+                creds, _ = get_repo_creds_and_default_branch(
                     repo_url=repo.repo_url,
                     identity_file=git_identity_file,
                     oauth_token=oauth_token,
@@ -140,22 +149,67 @@ class RepoCollection:
     def is_initialized(
         self,
         repo: Repo,
+        by_user: bool = False,
     ) -> bool:
         """
-        Checks if the remote repo is initialized in the project
+        Checks if the repo is initialized in the project
 
         Args:
             repo: The repo to check.
+            by_user: Require the remote repo to be initialized by the user, that is, to have
+                the user's credentials. Ignored for other repo types.
 
         Returns:
             Whether the repo is initialized or not.
         """
+        if isinstance(repo, RemoteRepo) and by_user:
+            return self._is_initialized_by_user(repo)
         try:
-            self._api_client.repos.get(self._project, repo.repo_id, include_creds=False)
+            self._api_client.repos.get(self._project, repo.repo_id)
             return True
         except ResourceNotExistsError:
             return False
 
+    def _is_initialized_by_user(self, repo: RemoteRepo) -> bool:
+        try:
+            repo_head = self._api_client.repos.get_with_creds(self._project, repo.repo_id)
+        except ResourceNotExistsError:
+            return False
+        # This works because:
+        # - RepoCollection.init() always submits RemoteRepoCreds for remote repos, even if
+        #   the repo is public
+        # - Server returns creds only if there is RepoCredsModel for the user (or legacy
+        #   shared creds in RepoModel)
+        # TODO: add an API method with the same logic returning a bool value?
+        return repo_head.repo_creds is not None
+
+    @overload
+    def get(self, repo_id: str, *, with_creds: Literal[False] = False) -> Optional[RepoHead]: ...
+
+    @overload
+    def get(self, repo_id: str, *, with_creds: Literal[True]) -> Optional[RepoHeadWithCreds]: ...
+
+    def get(
+        self, repo_id: str, *, with_creds: bool = False
+    ) -> Optional[Union[RepoHead, RepoHeadWithCreds]]:
+        """
+        Returns the repo by `repo_id`
+
+        Args:
+            repo_id: The repo ID.
+            with_creds: include repo credentials in the response.
+
+        Returns:
+            The repo or `None` if the repo is not found.
+        """
+        method = self._api_client.repos.get
+        if with_creds:
+            method = self._api_client.repos.get_with_creds
+        try:
+            return method(self._project, repo_id)
+        except ResourceNotExistsError:
+            return None
+
 
 def get_ssh_keypair(key_path: Optional[PathLike], dstack_key_path: Path) -> str:
     """Returns a path to the private key"""

dstack/api/_public/runs.py

@@ -23,7 +23,7 @@ from dstack._internal.core.models.configurations import (
     PortMapping,
     ServiceConfiguration,
 )
-from dstack._internal.core.models.files import FileArchiveMapping, FilePathMapping
+from dstack._internal.core.models.files import FileArchiveMapping
 from dstack._internal.core.models.profiles import (
     CreationPolicy,
     Profile,
@@ -433,21 +433,28 @@ class RunCollection:
         repo: Optional[Repo] = None,
         profile: Optional[Profile] = None,
         configuration_path: Optional[str] = None,
+        repo_dir: Optional[str] = None,
     ) -> RunPlan:
         """
         Get a run plan.
-        Use this method to see the run plan before applying the cofiguration.
+        Use this method to see the run plan before applying the configuration.
 
         Args:
             configuration (Union[Task, Service, DevEnvironment]): The run configuration.
             repo (Union[LocalRepo, RemoteRepo, VirtualRepo, None]):
                 The repo to use for the run. Pass `None` if repo is not needed.
             profile: The profile to use for the run.
-            configuration_path: The path to the configuration file. Omit if the configuration is not loaded from a file.
+            configuration_path: The path to the configuration file. Omit if the configuration
+                is not loaded from a file.
+            repo_dir: The path of the cloned repo inside the run container. If not set,
+                defaults first to the `repos[0].path` property of the configuration (for remote
+                repos only), then to `/workflow`.
 
         Returns:
             Run plan.
         """
+        # XXX: not using the LEGACY_REPO_DIR const in the docstring above, as the docs generator,
+        # apparently, doesn't support f-strings (f"""...""").
         if repo is None:
             repo = VirtualRepo()
             repo_code_hash = None
@@ -455,11 +462,17 @@ class RunCollection:
             with _prepare_code_file(repo) as (_, repo_code_hash):
                 pass
 
+        if repo_dir is None and configuration.repos:
+            repo_dir = configuration.repos[0].path
+
         run_spec = RunSpec(
             run_name=configuration.name,
             repo_id=repo.repo_id,
             repo_data=repo.run_repo_data,
             repo_code_hash=repo_code_hash,
+            repo_dir=repo_dir,
+            # Server doesn't use this field since 0.19.27, but we still send it for compatibility
+            # with older servers
             working_dir=configuration.working_dir,
             configuration_path=configuration_path,
             configuration=configuration,
@@ -499,7 +512,6 @@ class RunCollection:
 
         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)
@@ -691,11 +703,11 @@ class RunCollection:
             spot_policy=spot_policy,
             retry=None,
             utilization_policy=utilization_policy,
-            max_duration=max_duration,
-            stop_duration=stop_duration,
+            max_duration=max_duration,  # type: ignore[assignment]
+            stop_duration=stop_duration,  # type: ignore[assignment]
             max_price=max_price,
             creation_policy=creation_policy,
-            idle_duration=idle_duration,
+            idle_duration=idle_duration,  # type: ignore[assignment]
         )
         run_spec = RunSpec(
             run_name=run_name,
@@ -812,7 +824,6 @@ class RunCollection:
         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:

dstack/api/server/__init__.py

@@ -27,9 +27,6 @@ from dstack.api.server._secrets import SecretsAPIClient
 from dstack.api.server._users import UsersAPIClient
 from dstack.api.server._volumes import VolumesAPIClient
 
-logger = get_logger(__name__)
-
-
 _MAX_RETRIES = 3
 _RETRY_INTERVAL = 1
 
@@ -66,6 +63,7 @@ class APIClient:
         client_api_version = os.getenv("DSTACK_CLIENT_API_VERSION", version.__version__)
         if client_api_version is not None:
             self._s.headers.update({"X-API-VERSION": client_api_version})
+        self._logger = get_logger(__name__)
 
     @property
     def base_url(self) -> str:
@@ -73,55 +71,55 @@ class APIClient:
 
     @property
     def users(self) -> UsersAPIClient:
-        return UsersAPIClient(self._request)
+        return UsersAPIClient(self._request, self._logger)
 
     @property
     def projects(self) -> ProjectsAPIClient:
-        return ProjectsAPIClient(self._request)
+        return ProjectsAPIClient(self._request, self._logger)
 
     @property
     def backends(self) -> BackendsAPIClient:
-        return BackendsAPIClient(self._request)
+        return BackendsAPIClient(self._request, self._logger)
 
     @property
     def fleets(self) -> FleetsAPIClient:
-        return FleetsAPIClient(self._request)
+        return FleetsAPIClient(self._request, self._logger)
 
     @property
     def repos(self) -> ReposAPIClient:
-        return ReposAPIClient(self._request)
+        return ReposAPIClient(self._request, self._logger)
 
     @property
     def runs(self) -> RunsAPIClient:
-        return RunsAPIClient(self._request)
+        return RunsAPIClient(self._request, self._logger)
 
     @property
     def gpus(self) -> GpusAPIClient:
-        return GpusAPIClient(self._request)
+        return GpusAPIClient(self._request, self._logger)
 
     @property
     def metrics(self) -> MetricsAPIClient:
-        return MetricsAPIClient(self._request)
+        return MetricsAPIClient(self._request, self._logger)
 
     @property
     def logs(self) -> LogsAPIClient:
-        return LogsAPIClient(self._request)
+        return LogsAPIClient(self._request, self._logger)
 
     @property
     def secrets(self) -> SecretsAPIClient:
-        return SecretsAPIClient(self._request)
+        return SecretsAPIClient(self._request, self._logger)
 
     @property
     def gateways(self) -> GatewaysAPIClient:
-        return GatewaysAPIClient(self._request)
+        return GatewaysAPIClient(self._request, self._logger)
 
     @property
     def volumes(self) -> VolumesAPIClient:
-        return VolumesAPIClient(self._request)
+        return VolumesAPIClient(self._request, self._logger)
 
     @property
     def files(self) -> FilesAPIClient:
-        return FilesAPIClient(self._request)
+        return FilesAPIClient(self._request, self._logger)
 
     def _request(
         self,
@@ -136,20 +134,20 @@ class APIClient:
             kwargs.setdefault("headers", {})["Content-Type"] = "application/json"
             kwargs["data"] = body
 
-        logger.debug("POST /%s", path)
+        self._logger.debug("POST /%s", path)
         for _ in range(_MAX_RETRIES):
             try:
                 # TODO: set adequate timeout here or everywhere the method is used
                 resp = self._s.request(method, f"{self._base_url}/{path}", **kwargs)
                 break
             except requests.exceptions.ConnectionError as e:
-                logger.debug("Could not connect to server: %s", e)
+                self._logger.debug("Could not connect to server: %s", e)
                 time.sleep(_RETRY_INTERVAL)
         else:
             raise ClientError(f"Failed to connect to dstack server {self._base_url}")
 
         if 400 <= resp.status_code < 600:
-            logger.debug(
+            self._logger.debug(
                 "Error requesting %s. Status: %s. Headers: %s. Body: %s",
                 resp.request.url,
                 resp.status_code,

dstack/api/server/_gpus.py

@@ -2,6 +2,7 @@ from typing import List, Optional
 
 from pydantic import parse_obj_as
 
+from dstack._internal.core.compatibility.gpus import get_list_gpus_excludes
 from dstack._internal.core.models.runs import RunSpec
 from dstack._internal.server.schemas.gpus import GpuGroup, ListGpusRequest, ListGpusResponse
 from dstack.api.server._group import APIClientGroup
@@ -17,6 +18,6 @@ class GpusAPIClient(APIClientGroup):
         body = ListGpusRequest(run_spec=run_spec, group_by=group_by)
         resp = self._request(
             f"/api/project/{project_name}/gpus/list",
-            body=body.json(),
+            body=body.json(exclude=get_list_gpus_excludes(body)),
         )
         return parse_obj_as(ListGpusResponse, resp.json()).gpus

dstack/api/server/_group.py

@@ -1,3 +1,4 @@
+from logging import Logger
 from typing import Optional
 
 import requests
@@ -12,10 +13,10 @@ class APIRequest(Protocol):
         raise_for_status: bool = True,
         method: str = "POST",
         **kwargs,
-    ) -> requests.Response:
-        pass
+    ) -> requests.Response: ...
 
 
 class APIClientGroup:
-    def __init__(self, _request: APIRequest):
+    def __init__(self, _request: APIRequest, _logger: Logger):
         self._request = _request
+        self._logger = _logger

dstack/api/server/_repos.py

@@ -2,7 +2,12 @@ from typing import BinaryIO, List, Optional
 
 from pydantic import parse_obj_as
 
-from dstack._internal.core.models.repos import AnyRepoInfo, RemoteRepoCreds, RepoHead
+from dstack._internal.core.models.repos import (
+    AnyRepoInfo,
+    RemoteRepoCreds,
+    RepoHead,
+    RepoHeadWithCreds,
+)
 from dstack._internal.server.schemas.repos import (
     DeleteReposRequest,
     GetRepoRequest,
@@ -16,11 +21,23 @@ class ReposAPIClient(APIClientGroup):
         resp = self._request(f"/api/project/{project_name}/repos/list")
         return parse_obj_as(List[RepoHead.__response__], resp.json())
 
-    def get(self, project_name: str, repo_id: str, include_creds: bool) -> RepoHead:
-        body = GetRepoRequest(repo_id=repo_id, include_creds=include_creds)
+    def get(
+        self, project_name: str, repo_id: str, include_creds: Optional[bool] = None
+    ) -> RepoHead:
+        if include_creds is not None:
+            self._logger.warning(
+                "`include_creds` argument is deprecated and has no effect, `get()` always returns"
+                " the repo without creds. Use `get_with_creds()` to get the repo with creds"
+            )
+        body = GetRepoRequest(repo_id=repo_id, include_creds=False)
         resp = self._request(f"/api/project/{project_name}/repos/get", body=body.json())
         return parse_obj_as(RepoHead.__response__, resp.json())
 
+    def get_with_creds(self, project_name: str, repo_id: str) -> RepoHeadWithCreds:
+        body = GetRepoRequest(repo_id=repo_id, include_creds=True)
+        resp = self._request(f"/api/project/{project_name}/repos/get", body=body.json())
+        return parse_obj_as(RepoHeadWithCreds.__response__, resp.json())
+
     def init(
         self,
         project_name: str,

dstack/plugins/builtin/rest_plugin/_plugin.py

@@ -86,6 +86,7 @@ class CustomApplyPolicy(ApplyPolicy):
         spec: ApplySpec,
         excludes: Optional[Dict] = None,
     ) -> ApplySpec:
+        spec_json = None
         try:
             spec_request = request_cls(user=user, project=project, spec=spec)
             spec_json = self._call_plugin_service(spec_request, endpoint, excludes)

dstack/version.py

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

{dstack-0.19.25rc1.dist-info → dstack-0.19.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.25rc1
+Version: 0.19.27
 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
@@ -22,7 +22,7 @@ Requires-Dist: cryptography
 Requires-Dist: cursor
 Requires-Dist: filelock
 Requires-Dist: gitpython
-Requires-Dist: gpuhunt==0.1.7
+Requires-Dist: gpuhunt==0.1.8
 Requires-Dist: ignore-python>=0.2.0
 Requires-Dist: jsonschema
 Requires-Dist: orjson