dstack 0.19.18__py3-none-any.whl → 0.19.19__py3-none-any.whl

dstack/_internal/server/testing/common.py

@@ -31,6 +31,8 @@ from dstack._internal.core.models.fleets import (
     FleetSpec,
     FleetStatus,
     InstanceGroupPlacement,
+    SSHHostParams,
+    SSHParams,
 )
 from dstack._internal.core.models.gateways import GatewayComputeConfiguration, GatewayStatus
 from dstack._internal.core.models.instances import (
@@ -378,6 +380,7 @@ def get_job_provisioning_data(
     hostname: str = "127.0.0.4",
     internal_ip: Optional[str] = "127.0.0.4",
     price: float = 10.5,
+    instance_type: Optional[InstanceType] = None,
 ) -> JobProvisioningData:
     gpus = [
         Gpu(
@@ -386,14 +389,16 @@ def get_job_provisioning_data(
             vendor=gpuhunt.AcceleratorVendor.NVIDIA,
         )
     ] * gpu_count
-    return JobProvisioningData(
-        backend=backend,
-        instance_type=InstanceType(
+    if instance_type is None:
+        instance_type = InstanceType(
             name="instance",
             resources=Resources(
                 cpus=cpu_count, memory_mib=int(memory_gib * 1024), spot=spot, gpus=gpus
             ),
-        ),
+        )
+    return JobProvisioningData(
+        backend=backend,
+        instance_type=instance_type,
         instance_id="instance_id",
         hostname=hostname,
         internal_ip=internal_ip,
@@ -549,6 +554,31 @@ def get_fleet_configuration(
     )
 
 
+def get_ssh_fleet_configuration(
+    name: str = "test-fleet",
+    user: str = "ubuntu",
+    ssh_key: Optional[SSHKey] = None,
+    hosts: Optional[list[Union[SSHHostParams, str]]] = None,
+    network: Optional[str] = None,
+    placement: Optional[InstanceGroupPlacement] = None,
+) -> FleetConfiguration:
+    if ssh_key is None:
+        ssh_key = SSHKey(public="", private=get_private_key_string())
+    if hosts is None:
+        hosts = ["10.0.0.100"]
+    ssh_config = SSHParams(
+        user=user,
+        ssh_key=ssh_key,
+        hosts=hosts,
+        network=network,
+    )
+    return FleetConfiguration(
+        name=name,
+        ssh_config=ssh_config,
+        placement=placement,
+    )
+
+
 async def create_instance(
     session: AsyncSession,
     project: ProjectModel,
@@ -590,7 +620,9 @@ async def create_instance(
             internal_ip=None,
         )
     if offer == "auto":
-        offer = get_instance_offer_with_availability(backend=backend, region=region, spot=spot)
+        offer = get_instance_offer_with_availability(
+            backend=backend, region=region, spot=spot, price=price
+        )
     if profile is None:
         profile = Profile(name="test_name")
 
@@ -742,6 +774,7 @@ async def create_volume(
     status: VolumeStatus = VolumeStatus.SUBMITTED,
     created_at: datetime = datetime(2023, 1, 2, 3, 4, tzinfo=timezone.utc),
     last_processed_at: Optional[datetime] = None,
+    last_job_processed_at: Optional[datetime] = None,
     configuration: Optional[VolumeConfiguration] = None,
     volume_provisioning_data: Optional[VolumeProvisioningData] = None,
     deleted_at: Optional[datetime] = None,
@@ -759,6 +792,7 @@ async def create_volume(
         status=status,
         created_at=created_at,
         last_processed_at=last_processed_at,
+        last_job_processed_at=last_job_processed_at,
         configuration=configuration.json(),
         volume_provisioning_data=volume_provisioning_data.json()
         if volume_provisioning_data
@@ -820,6 +854,7 @@ def get_volume_configuration(
     region: str = "eu-west-1",
     size: Optional[Memory] = Memory(100),
     volume_id: Optional[str] = None,
+    auto_cleanup_duration: Optional[Union[str, int]] = None,
 ) -> VolumeConfiguration:
     return VolumeConfiguration(
         name=name,
@@ -827,6 +862,7 @@ def get_volume_configuration(
         region=region,
         size=size,
         volume_id=volume_id,
+        auto_cleanup_duration=auto_cleanup_duration,
     )
 
 

dstack/_internal/server/utils/routers.py

@@ -1,11 +1,34 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
-from fastapi import HTTPException, Request, status
-from fastapi.responses import JSONResponse
+import orjson
+from fastapi import HTTPException, Request, Response, status
 from packaging import version
 
 from dstack._internal.core.errors import ServerClientError, ServerClientErrorCode
 from dstack._internal.core.models.common import CoreModel
+from dstack._internal.utils.json_utils import get_orjson_default_options, orjson_default
+
+
+class CustomORJSONResponse(Response):
+    """
+    Custom JSONResponse that uses orjson for serialization.
+
+    It's recommended to return this class from routers directly instead of
+    returning pydantic models to avoid the FastAPI's jsonable_encoder overhead.
+    See https://fastapi.tiangolo.com/advanced/custom-response/#use-orjsonresponse.
+
+    Beware that FastAPI skips model validation when responses are returned directly.
+    If serialization needs to be modified, override `dict()` instead of adding validators.
+    """
+
+    media_type = "application/json"
+
+    def render(self, content: Any) -> bytes:
+        return orjson.dumps(
+            content,
+            option=get_orjson_default_options(),
+            default=orjson_default,
+        )
 
 
 class BadRequestDetailsModel(CoreModel):
@@ -30,7 +53,7 @@ def get_base_api_additional_responses() -> Dict:
     """
     Returns additional responses for the OpenAPI docs relevant to all API endpoints.
     The endpoints may override responses to make them as specific as possible.
-    E.g. an enpoint may specify which error codes it may return in `code`.
+    E.g. an endpoint may specify which error codes it may return in `code`.
     """
     return {
         400: get_bad_request_additional_response(),
@@ -102,7 +125,7 @@ def get_request_size(request: Request) -> int:
 def check_client_server_compatibility(
     client_version: Optional[str],
     server_version: Optional[str],
-) -> Optional[JSONResponse]:
+) -> Optional[CustomORJSONResponse]:
     """
     Returns `JSONResponse` with error if client/server versions are incompatible.
     Returns `None` otherwise.
@@ -116,7 +139,7 @@ def check_client_server_compatibility(
     try:
         parsed_client_version = version.parse(client_version)
     except version.InvalidVersion:
-        return JSONResponse(
+        return CustomORJSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
             content={
                 "detail": get_server_client_error_details(
@@ -138,11 +161,11 @@ def error_incompatible_versions(
     client_version: Optional[str],
     server_version: str,
     ask_cli_update: bool,
-) -> JSONResponse:
+) -> CustomORJSONResponse:
     msg = f"The client/CLI version ({client_version}) is incompatible with the server version ({server_version})."
     if ask_cli_update:
         msg += f" Update the dstack CLI: `pip install dstack=={server_version}`."
-    return JSONResponse(
+    return CustomORJSONResponse(
         status_code=status.HTTP_400_BAD_REQUEST,
         content={"detail": get_server_client_error_details(ServerClientError(msg=msg))},
     )

dstack/_internal/utils/json_utils.py

@@ -0,0 +1,54 @@
+from typing import Any
+
+import orjson
+from pydantic import BaseModel
+
+FREEZEGUN = True
+try:
+    from freezegun.api import FakeDatetime
+except ImportError:
+    FREEZEGUN = False
+
+
+ASYNCPG = True
+try:
+    import asyncpg.pgproto.pgproto
+except ImportError:
+    ASYNCPG = False
+
+
+def pydantic_orjson_dumps(v: Any, *, default: Any) -> str:
+    return orjson.dumps(
+        v,
+        option=get_orjson_default_options(),
+        default=orjson_default,
+    ).decode()
+
+
+def pydantic_orjson_dumps_with_indent(v: Any, *, default: Any) -> str:
+    return orjson.dumps(
+        v,
+        option=get_orjson_default_options() | orjson.OPT_INDENT_2,
+        default=orjson_default,
+    ).decode()
+
+
+def orjson_default(obj):
+    if isinstance(obj, float):
+        # orjson does not convert float subclasses be default
+        return float(obj)
+    if isinstance(obj, BaseModel):
+        # Allows calling orjson.dumps() on pydantic models
+        # (e.g. to return from the API)
+        return obj.dict()
+    if ASYNCPG:
+        if isinstance(obj, asyncpg.pgproto.pgproto.UUID):
+            return str(obj)
+    if FREEZEGUN:
+        if isinstance(obj, FakeDatetime):
+            return obj.isoformat()
+    raise TypeError
+
+
+def get_orjson_default_options() -> int:
+    return orjson.OPT_NON_STR_KEYS

dstack/api/_public/runs.py

@@ -18,7 +18,11 @@ import dstack.api as api
 from dstack._internal.core.consts import DSTACK_RUNNER_HTTP_PORT, DSTACK_RUNNER_SSH_PORT
 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.configurations import (
+    AnyRunConfiguration,
+    PortMapping,
+    ServiceConfiguration,
+)
 from dstack._internal.core.models.files import FileArchiveMapping, FilePathMapping
 from dstack._internal.core.models.profiles import (
     CreationPolicy,
@@ -38,6 +42,7 @@ from dstack._internal.core.models.runs import (
     RunPlan,
     RunSpec,
     RunStatus,
+    get_service_port,
 )
 from dstack._internal.core.models.runs import Run as RunModel
 from dstack._internal.core.services.logs import URLReplacer
@@ -163,7 +168,7 @@ class Run(ABC):
                 service_port = 443 if secure else 80
             ports = {
                 **ports,
-                self._run.run_spec.configuration.port.container_port: service_port,
+                get_or_error(get_or_error(self._ssh_attach).service_port): service_port,
             }
             path_prefix = url.path
         replace_urls = URLReplacer(
@@ -338,6 +343,10 @@ class Run(ABC):
             else:
                 container_user = "root"
 
+            service_port = None
+            if isinstance(self._run.run_spec.configuration, ServiceConfiguration):
+                service_port = get_service_port(job.job_spec, self._run.run_spec.configuration)
+
             self._ssh_attach = SSHAttach(
                 hostname=provisioning_data.hostname,
                 ssh_port=provisioning_data.ssh_port,
@@ -349,6 +358,7 @@ class Run(ABC):
                 run_name=name,
                 dockerized=provisioning_data.dockerized,
                 ssh_proxy=provisioning_data.ssh_proxy,
+                service_port=service_port,
                 local_backend=provisioning_data.backend == BackendType.LOCAL,
                 bind_address=bind_address,
             )
@@ -748,6 +758,7 @@ class RunCollection:
             repo_id=None,
             only_active=only_active,
             limit=limit or 100,
+            # TODO: Pass job_submissions_limit=1 in 0.20
         )
         if only_active and len(runs) == 0:
             runs = self._api_client.runs.list(

dstack/api/server/_runs.py

@@ -4,7 +4,11 @@ from uuid import UUID
 
 from pydantic import parse_obj_as
 
-from dstack._internal.core.compatibility.runs import get_apply_plan_excludes, get_get_plan_excludes
+from dstack._internal.core.compatibility.runs import (
+    get_apply_plan_excludes,
+    get_get_plan_excludes,
+    get_list_runs_excludes,
+)
 from dstack._internal.core.models.runs import (
     ApplyRunPlanInput,
     Run,
@@ -33,18 +37,24 @@ class RunsAPIClient(APIClientGroup):
         prev_run_id: Optional[UUID] = None,
         limit: int = 100,
         ascending: bool = False,
+        include_jobs: bool = True,
+        job_submissions_limit: Optional[int] = None,
     ) -> List[Run]:
         body = ListRunsRequest(
             project_name=project_name,
             repo_id=repo_id,
             username=username,
             only_active=only_active,
+            include_jobs=include_jobs,
+            job_submissions_limit=job_submissions_limit,
             prev_submitted_at=prev_submitted_at,
             prev_run_id=prev_run_id,
             limit=limit,
             ascending=ascending,
         )
-        resp = self._request("/api/runs/list", body=body.json())
+        resp = self._request(
+            "/api/runs/list", body=body.json(exclude=get_list_runs_excludes(body))
+        )
         return parse_obj_as(List[Run.__response__], resp.json())
 
     def get(self, project_name: str, run_name: str) -> Run:

dstack/version.py

@@ -1,4 +1,4 @@
-__version__ = "0.19.18"
+__version__ = "0.19.19"
 __is_release__ = True
 base_image = "0.10"
 base_image_ubuntu_version = "22.04"

{dstack-0.19.18.dist-info → dstack-0.19.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.18
+Version: 0.19.19
 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
@@ -24,6 +24,7 @@ Requires-Dist: gitpython
 Requires-Dist: gpuhunt==0.1.6
 Requires-Dist: ignore-python>=0.2.0
 Requires-Dist: jsonschema
+Requires-Dist: orjson
 Requires-Dist: packaging
 Requires-Dist: paramiko>=3.2.0
 Requires-Dist: psutil
@@ -346,12 +347,13 @@ Description-Content-Type: text/markdown
 `dstack` supports `NVIDIA`, `AMD`, `Google TPU`, `Intel Gaudi`, and `Tenstorrent` accelerators out of the box.
 
 ## Latest news ✨
-
+- [2025/07] [dstack 0.19.17: Secrets, Files, Rolling deployment](https://github.com/dstackai/dstack/releases/tag/0.19.17)
+- [2025/06] [dstack 0.19.16: Docker in Docker, CloudRift](https://github.com/dstackai/dstack/releases/tag/0.19.16)
+- [2025/06] [dstack 0.19.13: InfiniBand support in default images](https://github.com/dstackai/dstack/releases/tag/0.19.13)
+- [2025/06] [dstack 0.19.12: Simplified use of MPI](https://github.com/dstackai/dstack/releases/tag/0.19.12)
+- [2025/05] [dstack 0.19.10: Priorities](https://github.com/dstackai/dstack/releases/tag/0.19.10)
 - [2025/05] [dstack 0.19.8: Nebius clusters, GH200 on Lambda](https://github.com/dstackai/dstack/releases/tag/0.19.8)
 - [2025/04] [dstack 0.19.6: Tenstorrent, Plugins](https://github.com/dstackai/dstack/releases/tag/0.19.6)
-- [2025/04] [dstack 0.19.5: GCP A3 High clusters](https://github.com/dstackai/dstack/releases/tag/0.19.5)
-- [2025/04] [dstack 0.19.3: GCP A3 Mega clusters](https://github.com/dstackai/dstack/releases/tag/0.19.3)
-- [2025/03] [dstack 0.19.0: Prometheus](https://github.com/dstackai/dstack/releases/tag/0.19.0)
 
 ## How does it work?