dstack 0.19.26__py3-none-any.whl → 0.19.28__py3-none-any.whl

dstack/_internal/core/models/configurations.py

@@ -10,12 +10,23 @@ from pydantic import Field, ValidationError, conint, constr, root_validator, val
 from typing_extensions import Self
 
 from dstack._internal.core.errors import ConfigurationError
-from dstack._internal.core.models.common import CoreModel, Duration, RegistryAuth
+from dstack._internal.core.models.common import (
+    CoreConfig,
+    CoreModel,
+    Duration,
+    RegistryAuth,
+    generate_dual_core_model,
+)
 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_duration, parse_off_duration
+from dstack._internal.core.models.profiles import (
+    ProfileParams,
+    ProfileParamsConfig,
+    parse_duration,
+    parse_off_duration,
+)
 from dstack._internal.core.models.resources import Range, ResourcesSpec
 from dstack._internal.core.models.services import AnyModel, OpenAIChatModel
 from dstack._internal.core.models.unix import UnixUser
@@ -34,7 +45,7 @@ STRIP_PREFIX_DEFAULT = True
 RUN_PRIOTIRY_MIN = 0
 RUN_PRIOTIRY_MAX = 100
 RUN_PRIORITY_DEFAULT = 0
-DEFAULT_REPO_DIR = "/workflow"
+LEGACY_REPO_DIR = "/workflow"
 MIN_PROBE_TIMEOUT = 1
 MIN_PROBE_INTERVAL = 1
 DEFAULT_PROBE_URL = "/"
@@ -112,8 +123,15 @@ class RepoSpec(CoreModel):
         Optional[str],
         Field(description="The commit hash"),
     ] = None
-    # Not implemented, has no effect, hidden in the docs
-    path: str = DEFAULT_REPO_DIR
+    path: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The repo path inside the run container. Relative paths are resolved"
+                f" relative to the working directory. Defaults to `{LEGACY_REPO_DIR}`"
+            )
+        ),
+    ] = None
 
     @classmethod
     def parse(cls, v: str) -> Self:
@@ -149,6 +167,14 @@ class RepoSpec(CoreModel):
             raise ValueError("Either `local_path` or `url` must be specified")
         return values
 
+    @validator("path")
+    def validate_path(cls, v: Optional[str]) -> Optional[str]:
+        if v is None:
+            return v
+        if v.startswith("~") and PurePosixPath(v).parts[0] != "~":
+            raise ValueError("`~username` syntax is not supported")
+        return v
+
 
 class ScalingSpec(CoreModel):
     metric: Annotated[
@@ -261,7 +287,20 @@ class HTTPHeaderSpec(CoreModel):
     ]
 
 
-class ProbeConfig(CoreModel):
+class ProbeConfigConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        add_extra_schema_types(
+            schema["properties"]["timeout"],
+            extra_types=[{"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["interval"],
+            extra_types=[{"type": "string"}],
+        )
+
+
+class ProbeConfig(generate_dual_core_model(ProbeConfigConfig)):
     type: Literal["http"]  # expect other probe types in the future, namely `exec`
     url: Annotated[
         Optional[str], Field(description=f"The URL to request. Defaults to `{DEFAULT_PROBE_URL}`")
@@ -316,18 +355,6 @@ class ProbeConfig(CoreModel):
         ),
     ] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["timeout"],
-                extra_types=[{"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["interval"],
-                extra_types=[{"type": "string"}],
-            )
-
     @validator("timeout", pre=True)
     def parse_timeout(cls, v: Optional[Union[int, str]]) -> Optional[int]:
         if v is None:
@@ -366,6 +393,19 @@ class ProbeConfig(CoreModel):
         return values
 
 
+class BaseRunConfigurationConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        add_extra_schema_types(
+            schema["properties"]["volumes"]["items"],
+            extra_types=[{"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["files"]["items"],
+            extra_types=[{"type": "string"}],
+        )
+
+
 class BaseRunConfiguration(CoreModel):
     type: Literal["none"]
     name: Annotated[
@@ -380,7 +420,7 @@ class BaseRunConfiguration(CoreModel):
         Field(
             description=(
                 "The user inside the container, `user_name_or_id[:group_name_or_id]`"
-                " (e.g., `ubuntu`, `1000:1000`). Defaults to the default `image` user"
+                " (e.g., `ubuntu`, `1000:1000`). Defaults to the default user from the `image`"
             )
         ),
     ] = None
@@ -390,9 +430,8 @@ class BaseRunConfiguration(CoreModel):
         Optional[str],
         Field(
             description=(
-                "The path to the working directory inside the container."
-                f" It's specified relative to the repository directory (`{DEFAULT_REPO_DIR}`) and should be inside it."
-                ' Defaults to `"."` '
+                "The absolute path to the working directory inside the container."
+                f" Defaults to `{LEGACY_REPO_DIR}`"
             )
         ),
     ] = None
@@ -470,18 +509,6 @@ class BaseRunConfiguration(CoreModel):
     # deprecated since 0.18.31; task, service -- no effect; dev-environment -- executed right before `init`
     setup: CommandsList = []
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["volumes"]["items"],
-                extra_types=[{"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["files"]["items"],
-                extra_types=[{"type": "string"}],
-            )
-
     @validator("python", pre=True, always=True)
     def convert_python(cls, v, values) -> Optional[PythonVersion]:
         if v is not None and values.get("image"):
@@ -607,20 +634,25 @@ class DevEnvironmentConfigurationParams(CoreModel):
         return None
 
 
+class DevEnvironmentConfigurationConfig(
+    ProfileParamsConfig,
+    BaseRunConfigurationConfig,
+):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        ProfileParamsConfig.schema_extra(schema)
+        BaseRunConfigurationConfig.schema_extra(schema)
+
+
 class DevEnvironmentConfiguration(
     ProfileParams,
     BaseRunConfiguration,
     ConfigurationWithPortsParams,
     DevEnvironmentConfigurationParams,
+    generate_dual_core_model(DevEnvironmentConfigurationConfig),
 ):
     type: Literal["dev-environment"] = "dev-environment"
 
-    class Config(ProfileParams.Config, BaseRunConfiguration.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            ProfileParams.Config.schema_extra(schema)
-            BaseRunConfiguration.Config.schema_extra(schema)
-
     @validator("entrypoint")
     def validate_entrypoint(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
@@ -632,20 +664,38 @@ class TaskConfigurationParams(CoreModel):
     nodes: Annotated[int, Field(description="Number of nodes", ge=1)] = 1
 
 
+class TaskConfigurationConfig(
+    ProfileParamsConfig,
+    BaseRunConfigurationConfig,
+):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        ProfileParamsConfig.schema_extra(schema)
+        BaseRunConfigurationConfig.schema_extra(schema)
+
+
 class TaskConfiguration(
     ProfileParams,
     BaseRunConfiguration,
     ConfigurationWithCommandsParams,
     ConfigurationWithPortsParams,
     TaskConfigurationParams,
+    generate_dual_core_model(TaskConfigurationConfig),
 ):
     type: Literal["task"] = "task"
 
-    class Config(ProfileParams.Config, BaseRunConfiguration.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            ProfileParams.Config.schema_extra(schema)
-            BaseRunConfiguration.Config.schema_extra(schema)
+
+class ServiceConfigurationParamsConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        add_extra_schema_types(
+            schema["properties"]["replicas"],
+            extra_types=[{"type": "integer"}, {"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["model"],
+            extra_types=[{"type": "string"}],
+        )
 
 
 class ServiceConfigurationParams(CoreModel):
@@ -705,18 +755,6 @@ class ServiceConfigurationParams(CoreModel):
         Field(description="List of probes used to determine job health"),
     ] = []
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["replicas"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["model"],
-                extra_types=[{"type": "string"}],
-            )
-
     @validator("port")
     def convert_port(cls, v) -> PortMapping:
         if isinstance(v, int):
@@ -783,25 +821,27 @@ class ServiceConfigurationParams(CoreModel):
         return v
 
 
+class ServiceConfigurationConfig(
+    ProfileParamsConfig,
+    BaseRunConfigurationConfig,
+    ServiceConfigurationParamsConfig,
+):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        ProfileParamsConfig.schema_extra(schema)
+        BaseRunConfigurationConfig.schema_extra(schema)
+        ServiceConfigurationParamsConfig.schema_extra(schema)
+
+
 class ServiceConfiguration(
     ProfileParams,
     BaseRunConfiguration,
     ConfigurationWithCommandsParams,
     ServiceConfigurationParams,
+    generate_dual_core_model(ServiceConfigurationConfig),
 ):
     type: Literal["service"] = "service"
 
-    class Config(
-        ProfileParams.Config,
-        BaseRunConfiguration.Config,
-        ServiceConfigurationParams.Config,
-    ):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            ProfileParams.Config.schema_extra(schema)
-            BaseRunConfiguration.Config.schema_extra(schema)
-            ServiceConfigurationParams.Config.schema_extra(schema)
-
 
 AnyRunConfiguration = Union[DevEnvironmentConfiguration, TaskConfiguration, ServiceConfiguration]
 
@@ -862,7 +902,7 @@ class DstackConfiguration(CoreModel):
         Field(discriminator="type"),
     ]
 
-    class Config(CoreModel.Config):
+    class Config(CoreConfig):
         json_loads = orjson.loads
         json_dumps = pydantic_orjson_dumps_with_indent
 

dstack/_internal/core/models/files.py

@@ -28,7 +28,7 @@ class FilePathMapping(CoreModel):
         Field(
             description=(
                 "The path in the container. Relative paths are resolved relative to"
-                " the repo directory"
+                " the working directory"
             )
         ),
     ]

dstack/_internal/core/models/fleets.py

@@ -2,13 +2,18 @@ import ipaddress
 import uuid
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import Field, root_validator, validator
 from typing_extensions import Annotated, Literal
 
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import ApplyAction, CoreModel
+from dstack._internal.core.models.common import (
+    ApplyAction,
+    CoreConfig,
+    CoreModel,
+    generate_dual_core_model,
+)
 from dstack._internal.core.models.envs import Env
 from dstack._internal.core.models.instances import Instance, InstanceOfferWithAvailability, SSHKey
 from dstack._internal.core.models.profiles import (
@@ -19,7 +24,7 @@ from dstack._internal.core.models.profiles import (
     TerminationPolicy,
     parse_idle_duration,
 )
-from dstack._internal.core.models.resources import Range, ResourcesSpec
+from dstack._internal.core.models.resources import ResourcesSpec
 from dstack._internal.utils.common import list_enum_values_for_annotation
 from dstack._internal.utils.json_schema import add_extra_schema_types
 from dstack._internal.utils.tags import tags_validator
@@ -141,6 +146,82 @@ class SSHParams(CoreModel):
         return value
 
 
+class FleetNodesSpec(CoreModel):
+    min: Annotated[
+        int, Field(description=("The minimum number of instances to maintain in the fleet"))
+    ]
+    target: Annotated[
+        int,
+        Field(
+            description=(
+                "The number of instances to provision on fleet apply. `min` <= `target` <= `max`"
+                " Defaults to `min`"
+            )
+        ),
+    ]
+    max: Annotated[
+        Optional[int],
+        Field(
+            description=(
+                "The maximum number of instances allowed in the fleet. Unlimited if not specified"
+            )
+        ),
+    ] = None
+
+    def dict(self, *args, **kwargs) -> Dict:
+        # super() does not work with pydantic-duality
+        res = CoreModel.dict(self, *args, **kwargs)
+        # For backward compatibility with old clients
+        # that do not ignore extra fields due to https://github.com/dstackai/dstack/issues/3066
+        if "target" in res and res["target"] == res["min"]:
+            del res["target"]
+        return res
+
+    @root_validator(pre=True)
+    def set_min_and_target_defaults(cls, values):
+        min_ = values.get("min")
+        target = values.get("target")
+        if min_ is None:
+            values["min"] = 0
+        if target is None:
+            values["target"] = values["min"]
+        return values
+
+    @validator("min")
+    def validate_min(cls, v: int) -> int:
+        if v < 0:
+            raise ValueError("min cannot be negative")
+        return v
+
+    @root_validator(skip_on_failure=True)
+    def _post_validate_ranges(cls, values):
+        min_ = values["min"]
+        target = values["target"]
+        max_ = values.get("max")
+        if target < min_:
+            raise ValueError("target must not be be less than min")
+        if max_ is not None and max_ < min_:
+            raise ValueError("max must not be less than min")
+        if max_ is not None and max_ < target:
+            raise ValueError("max must not be less than target")
+        return values
+
+
+class InstanceGroupParamsConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        del schema["properties"]["termination_policy"]
+        del schema["properties"]["termination_idle_time"]
+        add_extra_schema_types(
+            schema["properties"]["nodes"],
+            extra_types=[{"type": "integer"}, {"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["idle_duration"],
+            extra_types=[{"type": "string"}],
+        )
+
+
 class InstanceGroupParams(CoreModel):
     env: Annotated[
         Env,
@@ -151,7 +232,9 @@ class InstanceGroupParams(CoreModel):
         Field(description="The parameters for adding instances via SSH"),
     ] = None
 
-    nodes: Annotated[Optional[Range[int]], Field(description="The number of instances")] = None
+    nodes: Annotated[
+        Optional[FleetNodesSpec], Field(description="The number of instances in cloud fleet")
+    ] = None
     placement: Annotated[
         Optional[InstanceGroupPlacement],
         Field(description="The placement of instances: `any` or `cluster`"),
@@ -234,19 +317,15 @@ class InstanceGroupParams(CoreModel):
     termination_policy: Annotated[Optional[TerminationPolicy], Field(exclude=True)] = None
     termination_idle_time: Annotated[Optional[Union[str, int]], Field(exclude=True)] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any], model: Type):
-            del schema["properties"]["termination_policy"]
-            del schema["properties"]["termination_idle_time"]
-            add_extra_schema_types(
-                schema["properties"]["nodes"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["idle_duration"],
-                extra_types=[{"type": "string"}],
-            )
+    @validator("nodes", pre=True)
+    def parse_nodes(cls, v: Optional[Union[dict, str]]) -> Optional[dict]:
+        if isinstance(v, str) and ".." in v:
+            v = v.replace(" ", "")
+            min, max = v.split("..")
+            return dict(min=min or None, max=max or None)
+        elif isinstance(v, str) or isinstance(v, int):
+            return dict(min=v, max=v)
+        return v
 
     _validate_idle_duration = validator("idle_duration", pre=True, allow_reuse=True)(
         parse_idle_duration
@@ -258,7 +337,17 @@ class FleetProps(CoreModel):
     name: Annotated[Optional[str], Field(description="The fleet name")] = None
 
 
-class FleetConfiguration(InstanceGroupParams, FleetProps):
+class FleetConfigurationConfig(InstanceGroupParamsConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        InstanceGroupParamsConfig.schema_extra(schema)
+
+
+class FleetConfiguration(
+    InstanceGroupParams,
+    FleetProps,
+    generate_dual_core_model(FleetConfigurationConfig),
+):
     tags: Annotated[
         Optional[Dict[str, str]],
         Field(
@@ -273,7 +362,14 @@ class FleetConfiguration(InstanceGroupParams, FleetProps):
     _validate_tags = validator("tags", pre=True, allow_reuse=True)(tags_validator)
 
 
-class FleetSpec(CoreModel):
+class FleetSpecConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        prop = schema.get("properties", {})
+        prop.pop("merged_profile", None)
+
+
+class FleetSpec(generate_dual_core_model(FleetSpecConfig)):
     configuration: FleetConfiguration
     configuration_path: Optional[str] = None
     profile: Profile
@@ -283,12 +379,6 @@ class FleetSpec(CoreModel):
     # TODO: make merged_profile a computed field after migrating to pydanticV2
     merged_profile: Annotated[Profile, Field(exclude=True)] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any], model: Type) -> None:
-            prop = schema.get("properties", {})
-            prop.pop("merged_profile", None)
-
     @root_validator
     def _merged_profile(cls, values) -> Dict:
         try:

dstack/_internal/core/models/instances.py

@@ -7,7 +7,10 @@ import gpuhunt
 from pydantic import root_validator
 
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import CoreModel
+from dstack._internal.core.models.common import (
+    CoreModel,
+    FrozenCoreModel,
+)
 from dstack._internal.core.models.envs import Env
 from dstack._internal.core.models.health import HealthStatus
 from dstack._internal.core.models.volumes import Volume
@@ -117,14 +120,11 @@ class InstanceType(CoreModel):
     resources: Resources
 
 
-class SSHConnectionParams(CoreModel):
+class SSHConnectionParams(FrozenCoreModel):
     hostname: str
     username: str
     port: int
 
-    class Config(CoreModel.Config):
-        frozen = True
-
 
 class SSHKey(CoreModel):
     public: str