dstack 0.19.27__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
@@ -276,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}`")
@@ -331,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:
@@ -381,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[
@@ -484,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"):
@@ -621,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:
@@ -646,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):
@@ -719,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):
@@ -797,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]
 
@@ -876,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/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 (
@@ -202,6 +207,21 @@ class FleetNodesSpec(CoreModel):
         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,
@@ -297,20 +317,6 @@ 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:
@@ -331,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(
@@ -346,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
@@ -356,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

dstack/_internal/core/models/profiles.py

@@ -6,7 +6,12 @@ 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 CoreModel, Duration
+from dstack._internal.core.models.common import (
+    CoreConfig,
+    CoreModel,
+    Duration,
+    generate_dual_core_model,
+)
 from dstack._internal.utils.common import list_enum_values_for_annotation
 from dstack._internal.utils.cron import validate_cron
 from dstack._internal.utils.json_schema import add_extra_schema_types
@@ -112,7 +117,16 @@ class RetryEvent(str, Enum):
     ERROR = "error"
 
 
-class ProfileRetry(CoreModel):
+class ProfileRetryConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        add_extra_schema_types(
+            schema["properties"]["duration"],
+            extra_types=[{"type": "string"}],
+        )
+
+
+class ProfileRetry(generate_dual_core_model(ProfileRetryConfig)):
     on_events: Annotated[
         Optional[List[RetryEvent]],
         Field(
@@ -128,14 +142,6 @@ class ProfileRetry(CoreModel):
         Field(description="The maximum period of retrying the run, e.g., `4h` or `1d`"),
     ] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["duration"],
-                extra_types=[{"type": "string"}],
-            )
-
     _validate_duration = validator("duration", pre=True, allow_reuse=True)(parse_duration)
 
     @root_validator
@@ -146,7 +152,16 @@ class ProfileRetry(CoreModel):
         return values
 
 
-class UtilizationPolicy(CoreModel):
+class UtilizationPolicyConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        add_extra_schema_types(
+            schema["properties"]["time_window"],
+            extra_types=[{"type": "string"}],
+        )
+
+
+class UtilizationPolicy(generate_dual_core_model(UtilizationPolicyConfig)):
     _min_time_window = "5m"
 
     min_gpu_utilization: Annotated[
@@ -171,14 +186,6 @@ class UtilizationPolicy(CoreModel):
         ),
     ]
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["time_window"],
-                extra_types=[{"type": "string"}],
-            )
-
     @validator("time_window", pre=True)
     def validate_time_window(cls, v: Union[int, str]) -> int:
         v = parse_duration(v)
@@ -219,6 +226,28 @@ class Schedule(CoreModel):
         return self.cron
 
 
+class ProfileParamsConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        del schema["properties"]["pool_name"]
+        del schema["properties"]["instance_name"]
+        del schema["properties"]["retry_policy"]
+        del schema["properties"]["termination_policy"]
+        del schema["properties"]["termination_idle_time"]
+        add_extra_schema_types(
+            schema["properties"]["max_duration"],
+            extra_types=[{"type": "boolean"}, {"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["stop_duration"],
+            extra_types=[{"type": "boolean"}, {"type": "string"}],
+        )
+        add_extra_schema_types(
+            schema["properties"]["idle_duration"],
+            extra_types=[{"type": "string"}],
+        )
+
+
 class ProfileParams(CoreModel):
     backends: Annotated[
         Optional[List[BackendType]],
@@ -358,27 +387,6 @@ class ProfileParams(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]) -> None:
-            del schema["properties"]["pool_name"]
-            del schema["properties"]["instance_name"]
-            del schema["properties"]["retry_policy"]
-            del schema["properties"]["termination_policy"]
-            del schema["properties"]["termination_idle_time"]
-            add_extra_schema_types(
-                schema["properties"]["max_duration"],
-                extra_types=[{"type": "boolean"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["stop_duration"],
-                extra_types=[{"type": "boolean"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["idle_duration"],
-                extra_types=[{"type": "string"}],
-            )
-
     _validate_max_duration = validator("max_duration", pre=True, allow_reuse=True)(
         parse_max_duration
     )
@@ -403,17 +411,28 @@ class ProfileProps(CoreModel):
     ] = False
 
 
-class Profile(ProfileProps, ProfileParams):
+class ProfileConfig(ProfileParamsConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        ProfileParamsConfig.schema_extra(schema)
+
+
+class Profile(
+    ProfileProps,
+    ProfileParams,
+    generate_dual_core_model(ProfileConfig),
+):
     pass
 
 
-class ProfilesConfig(CoreModel):
-    profiles: List[Profile]
+class ProfilesConfigConfig(CoreConfig):
+    json_loads = orjson.loads
+    json_dumps = pydantic_orjson_dumps_with_indent
+    schema_extra = {"$schema": "http://json-schema.org/draft-07/schema#"}
 
-    class Config(CoreModel.Config):
-        json_loads = orjson.loads
-        json_dumps = pydantic_orjson_dumps_with_indent
-        schema_extra = {"$schema": "http://json-schema.org/draft-07/schema#"}
+
+class ProfilesConfig(generate_dual_core_model(ProfilesConfigConfig)):
+    profiles: List[Profile]
 
     def default(self) -> Optional[Profile]:
         for p in self.profiles:

dstack/_internal/core/models/repos/remote.py

@@ -11,7 +11,7 @@ from pydantic import Field
 from typing_extensions import Literal
 
 from dstack._internal.core.errors import DstackError
-from dstack._internal.core.models.common import CoreModel
+from dstack._internal.core.models.common import CoreConfig, generate_dual_core_model
 from dstack._internal.core.models.repos.base import BaseRepoInfo, Repo
 from dstack._internal.utils.hash import get_sha256, slugify
 from dstack._internal.utils.path import PathLike
@@ -24,21 +24,33 @@ class RepoError(DstackError):
     pass
 
 
-class RemoteRepoCreds(CoreModel):
+class RemoteRepoCredsConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        del schema["properties"]["protocol"]
+
+
+class RemoteRepoCreds(generate_dual_core_model(RemoteRepoCredsConfig)):
     clone_url: str
-    private_key: Optional[str]
-    oauth_token: Optional[str]
+    private_key: Optional[str] = None
+    oauth_token: Optional[str] = None
 
     # TODO: remove in 0.20. Left for compatibility with CLI <=0.18.44
     protocol: Annotated[Optional[str], Field(exclude=True)] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]) -> None:
-            del schema["properties"]["protocol"]
 
+class RemoteRepoInfoConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        del schema["properties"]["repo_host_name"]
+        del schema["properties"]["repo_port"]
+        del schema["properties"]["repo_user_name"]
 
-class RemoteRepoInfo(BaseRepoInfo):
+
+class RemoteRepoInfo(
+    BaseRepoInfo,
+    generate_dual_core_model(RemoteRepoInfoConfig),
+):
     repo_type: Literal["remote"] = "remote"
     repo_name: str
 
@@ -47,13 +59,6 @@ class RemoteRepoInfo(BaseRepoInfo):
     repo_port: Annotated[Optional[int], Field(exclude=True)] = None
     repo_user_name: Annotated[Optional[str], Field(exclude=True)] = None
 
-    class Config(BaseRepoInfo.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]) -> None:
-            del schema["properties"]["repo_host_name"]
-            del schema["properties"]["repo_port"]
-            del schema["properties"]["repo_user_name"]
-
 
 class RemoteRunRepoData(RemoteRepoInfo):
     repo_branch: Optional[str] = None