dstack 0.0.9__py3-none-any.whl → 0.20.7__py3-none-any.whl

dstack/_internal/core/backends/vultr/configurator.py

@@ -0,0 +1,71 @@
+import json
+
+from dstack._internal.core.backends.base.configurator import (
+    BackendRecord,
+    Configurator,
+    raise_invalid_credentials_error,
+)
+from dstack._internal.core.backends.models import (
+    VultrBackendConfigWithCreds,
+)
+from dstack._internal.core.backends.vultr import api_client
+from dstack._internal.core.backends.vultr.backend import VultrBackend
+from dstack._internal.core.backends.vultr.models import (
+    VultrBackendConfig,
+    VultrConfig,
+    VultrCreds,
+    VultrStoredConfig,
+)
+from dstack._internal.core.models.backends.base import (
+    BackendType,
+)
+
+REGIONS = []
+
+
+class VultrConfigurator(
+    Configurator[
+        VultrBackendConfig,
+        VultrBackendConfigWithCreds,
+    ]
+):
+    TYPE = BackendType.VULTR
+    BACKEND_CLASS = VultrBackend
+
+    def validate_config(self, config: VultrBackendConfigWithCreds, default_creds_enabled: bool):
+        self._validate_vultr_api_key(config.creds.api_key)
+
+    def create_backend(
+        self, project_name: str, config: VultrBackendConfigWithCreds
+    ) -> BackendRecord:
+        if config.regions is None:
+            config.regions = REGIONS
+        return BackendRecord(
+            config=VultrStoredConfig(
+                **VultrBackendConfig.__response__.parse_obj(config).dict()
+            ).json(),
+            auth=VultrCreds.parse_obj(config.creds).json(),
+        )
+
+    def get_backend_config_with_creds(self, record: BackendRecord) -> VultrBackendConfigWithCreds:
+        config = self._get_config(record)
+        return VultrBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> VultrBackendConfig:
+        config = self._get_config(record)
+        return VultrBackendConfig.__response__.parse_obj(config)
+
+    def get_backend(self, record: BackendRecord) -> VultrBackend:
+        config = self._get_config(record)
+        return VultrBackend(config=config)
+
+    def _get_config(self, record: BackendRecord) -> VultrConfig:
+        return VultrConfig.__response__(
+            **json.loads(record.config),
+            creds=VultrCreds.parse_raw(record.auth),
+        )
+
+    def _validate_vultr_api_key(self, api_key: str):
+        client = api_client.VultrApiClient(api_key=api_key)
+        if not client.validate_api_key():
+            raise_invalid_credentials_error(fields=[["creds", "api_key"]])

dstack/_internal/core/backends/vultr/models.py

@@ -0,0 +1,34 @@
+from typing import Annotated, List, Literal, Optional
+
+from pydantic import Field
+
+from dstack._internal.core.models.common import CoreModel
+
+
+class VultrAPIKeyCreds(CoreModel):
+    type: Annotated[Literal["api_key"], Field(description="The type of credentials")] = "api_key"
+    api_key: Annotated[str, Field(description="The API key")]
+
+
+AnyVultrCreds = VultrAPIKeyCreds
+VultrCreds = AnyVultrCreds
+
+
+class VultrBackendConfig(CoreModel):
+    type: Annotated[Literal["vultr"], Field(description="The type of backend")] = "vultr"
+    regions: Annotated[
+        Optional[List[str]],
+        Field(description="The list of Vultr regions. Omit to use all regions"),
+    ] = None
+
+
+class VultrBackendConfigWithCreds(VultrBackendConfig):
+    creds: Annotated[AnyVultrCreds, Field(description="The credentials")]
+
+
+class VultrStoredConfig(VultrBackendConfig):
+    pass
+
+
+class VultrConfig(VultrStoredConfig):
+    creds: AnyVultrCreds

dstack/_internal/core/compatibility/events.py

@@ -0,0 +1,13 @@
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.server.schemas.events import ListEventsRequest
+
+
+def get_list_events_excludes(request: ListEventsRequest) -> IncludeExcludeDictType:
+    list_gpus_excludes: IncludeExcludeDictType = {}
+    if request.target_volumes is None:
+        list_gpus_excludes["target_volumes"] = True
+    if request.target_gateways is None:
+        list_gpus_excludes["target_gateways"] = True
+    if request.target_secrets is None:
+        list_gpus_excludes["target_secrets"] = True
+    return list_gpus_excludes

dstack/_internal/core/compatibility/fleets.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+from dstack._internal.core.models.common import IncludeExcludeDictType, IncludeExcludeSetType
+from dstack._internal.core.models.fleets import ApplyFleetPlanInput, FleetSpec
+
+
+def get_get_plan_excludes(fleet_spec: FleetSpec) -> IncludeExcludeDictType:
+    get_plan_excludes: IncludeExcludeDictType = {}
+    spec_excludes = get_fleet_spec_excludes(fleet_spec)
+    if spec_excludes:
+        get_plan_excludes["spec"] = spec_excludes
+    return get_plan_excludes
+
+
+def get_apply_plan_excludes(plan_input: ApplyFleetPlanInput) -> IncludeExcludeDictType:
+    apply_plan_excludes: IncludeExcludeDictType = {}
+    spec_excludes = get_fleet_spec_excludes(plan_input.spec)
+    if spec_excludes:
+        apply_plan_excludes["spec"] = spec_excludes
+    current_resource = plan_input.current_resource
+    if current_resource is not None:
+        current_resource_excludes = {}
+        apply_plan_excludes["current_resource"] = current_resource_excludes
+    return {"plan": apply_plan_excludes}
+
+
+def get_create_fleet_excludes(fleet_spec: FleetSpec) -> IncludeExcludeDictType:
+    create_fleet_excludes: IncludeExcludeDictType = {}
+    spec_excludes = get_fleet_spec_excludes(fleet_spec)
+    if spec_excludes:
+        create_fleet_excludes["spec"] = spec_excludes
+    return create_fleet_excludes
+
+
+def get_fleet_spec_excludes(fleet_spec: FleetSpec) -> Optional[IncludeExcludeDictType]:
+    """
+    Returns `fleet_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: IncludeExcludeDictType = {}
+    configuration_excludes: IncludeExcludeDictType = {}
+    profile_excludes: IncludeExcludeSetType = set()
+
+    # Add excludes like this:
+    #
+    # if fleet_spec.configuration.tags is None:
+    #     configuration_excludes["tags"] = True
+    # if fleet_spec.profile.tags is None:
+    #     profile_excludes.add("tags")
+
+    if configuration_excludes:
+        spec_excludes["configuration"] = configuration_excludes
+    if profile_excludes:
+        spec_excludes["profile"] = profile_excludes
+    if spec_excludes:
+        return spec_excludes
+    return None

dstack/_internal/core/compatibility/gateways.py

@@ -0,0 +1,39 @@
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.core.models.gateways import GatewayConfiguration, GatewaySpec
+
+
+def get_gateway_spec_excludes(gateway_spec: GatewaySpec) -> IncludeExcludeDictType:
+    """
+    Returns `gateway_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: IncludeExcludeDictType = {}
+    spec_excludes["configuration"] = _get_gateway_configuration_excludes(
+        gateway_spec.configuration
+    )
+    return spec_excludes
+
+
+def get_create_gateway_excludes(configuration: GatewayConfiguration) -> IncludeExcludeDictType:
+    """
+    Returns an exclude mapping to exclude certain fields from the create gateway request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    create_gateway_excludes: IncludeExcludeDictType = {}
+    create_gateway_excludes["configuration"] = _get_gateway_configuration_excludes(configuration)
+    return create_gateway_excludes
+
+
+def _get_gateway_configuration_excludes(
+    configuration: GatewayConfiguration,
+) -> IncludeExcludeDictType:
+    configuration_excludes: IncludeExcludeDictType = {}
+
+    # Add excludes like this:
+    #
+    # if configuration.tags is None:
+    #     configuration_excludes["tags"] = True
+
+    return configuration_excludes

dstack/_internal/core/compatibility/gpus.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from dstack._internal.core.compatibility.runs import get_run_spec_excludes
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.server.schemas.gpus import ListGpusRequest
+
+
+def get_list_gpus_excludes(request: ListGpusRequest) -> Optional[IncludeExcludeDictType]:
+    list_gpus_excludes: IncludeExcludeDictType = {}
+    run_spec_excludes = get_run_spec_excludes(request.run_spec)
+    if run_spec_excludes is not None:
+        list_gpus_excludes["run_spec"] = run_spec_excludes
+    return list_gpus_excludes

dstack/_internal/core/compatibility/logs.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.server.schemas.logs import PollLogsRequest
+
+
+def get_poll_logs_excludes(request: PollLogsRequest) -> Optional[IncludeExcludeDictType]:
+    """
+    Returns exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    excludes: IncludeExcludeDictType = {}
+    return excludes if excludes else None

dstack/_internal/core/compatibility/runs.py

@@ -0,0 +1,86 @@
+from typing import Optional
+
+from dstack._internal.core.models.common import IncludeExcludeDictType, IncludeExcludeSetType
+from dstack._internal.core.models.runs import (
+    DEFAULT_REPLICA_GROUP_NAME,
+    ApplyRunPlanInput,
+    JobSpec,
+    RunSpec,
+)
+from dstack._internal.server.schemas.runs import GetRunPlanRequest, ListRunsRequest
+
+
+def get_list_runs_excludes(list_runs_request: ListRunsRequest) -> IncludeExcludeSetType:
+    excludes: IncludeExcludeSetType = set()
+    return excludes
+
+
+def get_apply_plan_excludes(plan: ApplyRunPlanInput) -> Optional[IncludeExcludeDictType]:
+    """
+    Returns `plan` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    apply_plan_excludes: IncludeExcludeDictType = {}
+    run_spec_excludes = get_run_spec_excludes(plan.run_spec)
+    if run_spec_excludes is not None:
+        apply_plan_excludes["run_spec"] = run_spec_excludes
+    current_resource = plan.current_resource
+    if current_resource is not None:
+        current_resource_excludes: IncludeExcludeDictType = {}
+        apply_plan_excludes["current_resource"] = current_resource_excludes
+        current_resource_excludes["run_spec"] = get_run_spec_excludes(current_resource.run_spec)
+        current_resource_excludes["jobs"] = {
+            "__all__": {
+                "job_spec": get_job_spec_excludes([job.job_spec for job in current_resource.jobs]),
+            }
+        }
+    return {"plan": apply_plan_excludes}
+
+
+def get_get_plan_excludes(request: GetRunPlanRequest) -> Optional[IncludeExcludeDictType]:
+    """
+    Excludes new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    get_plan_excludes: IncludeExcludeDictType = {}
+    run_spec_excludes = get_run_spec_excludes(request.run_spec)
+    if run_spec_excludes is not None:
+        get_plan_excludes["run_spec"] = run_spec_excludes
+    return get_plan_excludes
+
+
+def get_run_spec_excludes(run_spec: RunSpec) -> IncludeExcludeDictType:
+    """
+    Returns `run_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: IncludeExcludeDictType = {}
+    configuration_excludes: IncludeExcludeDictType = {}
+    profile_excludes: IncludeExcludeSetType = set()
+
+    # Add excludes like this:
+    #
+    # if run_spec.configuration.tags is None:
+    #     configuration_excludes["tags"] = True
+    # if run_spec.profile is not None and run_spec.profile.tags is None:
+    #     profile_excludes.add("tags")
+
+    if configuration_excludes:
+        spec_excludes["configuration"] = configuration_excludes
+    if profile_excludes:
+        spec_excludes["profile"] = profile_excludes
+    return spec_excludes
+
+
+def get_job_spec_excludes(job_specs: list[JobSpec]) -> IncludeExcludeDictType:
+    """
+    Returns `job_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: IncludeExcludeDictType = {}
+    if all(s.replica_group == DEFAULT_REPLICA_GROUP_NAME for s in job_specs):
+        spec_excludes["replica_group"] = True
+    return spec_excludes

dstack/_internal/core/compatibility/volumes.py

@@ -0,0 +1,37 @@
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.core.models.volumes import VolumeConfiguration, VolumeSpec
+
+
+def get_volume_spec_excludes(volume_spec: VolumeSpec) -> IncludeExcludeDictType:
+    """
+    Returns `volume_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: IncludeExcludeDictType = {}
+    spec_excludes["configuration"] = _get_volume_configuration_excludes(volume_spec.configuration)
+    return spec_excludes
+
+
+def get_create_volume_excludes(configuration: VolumeConfiguration) -> IncludeExcludeDictType:
+    """
+    Returns an exclude mapping to exclude certain fields from the create volume request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    create_volume_excludes: IncludeExcludeDictType = {}
+    create_volume_excludes["configuration"] = _get_volume_configuration_excludes(configuration)
+    return create_volume_excludes
+
+
+def _get_volume_configuration_excludes(
+    configuration: VolumeConfiguration,
+) -> IncludeExcludeDictType:
+    configuration_excludes: IncludeExcludeDictType = {}
+
+    # Add excludes like this:
+    #
+    # if configuration.tags is None:
+    #     configuration_excludes["tags"] = True
+
+    return configuration_excludes

dstack/_internal/core/consts.py

@@ -0,0 +1,8 @@
+# shim (runs on the host) HTTP API port
+DSTACK_SHIM_HTTP_PORT = 10998
+# runner (runs inside a container) HTTP API port
+DSTACK_RUNNER_HTTP_PORT = 10999
+# ssh server (runs alongside the runner inside a container) listen port
+DSTACK_RUNNER_SSH_PORT = 10022
+# legacy AWS, Azure, GCP, and OCI image for older GPUs
+DSTACK_OS_IMAGE_WITH_PROPRIETARY_NVIDIA_KERNEL_MODULES = "0.10"

dstack/_internal/core/errors.py

@@ -0,0 +1,160 @@
+import enum
+from typing import List, Optional
+
+
+class DstackError(Exception):
+    pass
+
+
+class ServerError(DstackError):
+    pass
+
+
+class ForbiddenError(ServerError):
+    pass
+
+
+class ClientError(DstackError):
+    pass
+
+
+class URLNotFoundError(ClientError):
+    pass
+
+
+class MethodNotAllowedError(ClientError):
+    pass
+
+
+class ServerClientErrorCode(str, enum.Enum):
+    UNSPECIFIED_ERROR = "error"
+    RESOURCE_EXISTS = "resource_exists"
+    RESOURCE_NOT_EXISTS = "resource_not_exists"
+    INVALID_CREDENTIALS = "invalid_credentials"
+    BACKEND_NOT_AVAILABLE = "backend_not_available"
+    REPO_DOES_NOT_EXIST = "repo_does_not_exist"
+    GATEWAY_ERROR = "gateway_error"
+
+
+class ServerClientError(ServerError, ClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.UNSPECIFIED_ERROR
+    msg: str = ""
+    fields: List[List[str]] = []
+
+    def __init__(self, msg: Optional[str] = None, fields: Optional[List[List[str]]] = None):
+        if msg is not None:
+            self.msg = msg
+        super().__init__(self.msg)  # show the message in stacktrace
+        if fields is not None:
+            self.fields = fields
+
+
+class ResourceExistsError(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.RESOURCE_EXISTS
+    msg = "Resource exists"
+
+
+class ResourceNotExistsError(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.RESOURCE_NOT_EXISTS
+    msg = "Resource not found"
+
+
+class BackendInvalidCredentialsError(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.INVALID_CREDENTIALS
+    msg = "Invalid credentials"
+
+
+class BackendNotAvailable(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.BACKEND_NOT_AVAILABLE
+    msg = "Backend not available"
+
+
+class RepoDoesNotExistError(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.REPO_DOES_NOT_EXIST
+
+    @staticmethod
+    def with_id(repo_id: str) -> "RepoDoesNotExistError":
+        return RepoDoesNotExistError(f"Repo {repo_id} does not exist")
+
+
+class GatewayError(ServerClientError):
+    code: ServerClientErrorCode = ServerClientErrorCode.GATEWAY_ERROR
+    msg = "Gateway error"
+
+
+class BackendError(DstackError):
+    pass
+
+
+class BackendAuthError(BackendError):
+    pass
+
+
+class ComputeError(BackendError):
+    pass
+
+
+class NoCapacityError(ComputeError):
+    pass
+
+
+class ProvisioningError(ComputeError):
+    pass
+
+
+class ComputeResourceNotFoundError(ComputeError):
+    pass
+
+
+class PlacementGroupInUseError(ComputeError):
+    pass
+
+
+class PlacementGroupNotSupportedError(ComputeError):
+    pass
+
+
+class NotYetTerminated(ComputeError):
+    """
+    Used by Compute.terminate_instance to signal that instance termination is not complete
+    and the method should be called again after some time to continue termination.
+    """
+
+    def __init__(self, details: str) -> None:
+        """
+        Args:
+            details: some details about the termination status
+        """
+        return super().__init__(details)
+
+
+class CLIError(DstackError):
+    pass
+
+
+class ConfigurationError(DstackError):
+    pass
+
+
+class SSHError(DstackError):
+    pass
+
+
+class SSHTimeoutError(SSHError):
+    pass
+
+
+class SSHConnectionRefusedError(SSHError):
+    pass
+
+
+class SSHKeyError(SSHError):
+    pass
+
+
+class SSHPortInUseError(SSHError):
+    pass
+
+
+class DockerRegistryError(DstackError):
+    pass

dstack/_internal/core/models/auth.py

@@ -0,0 +1,28 @@
+from typing import Annotated, Optional
+
+from pydantic import Field
+
+from dstack._internal.core.models.common import CoreModel
+
+
+class OAuthProviderInfo(CoreModel):
+    name: Annotated[str, Field(description="The OAuth2 provider name.")]
+    enabled: Annotated[
+        bool, Field(description="Whether the provider is configured on the server.")
+    ]
+
+
+class OAuthState(CoreModel):
+    """
+    A struct that the server puts in the OAuth2 state parameter.
+    """
+
+    value: Annotated[str, Field(description="A random string to protect against CSRF.")]
+    local_port: Annotated[
+        Optional[int],
+        Field(
+            description="If specified, the user is redirected to localhost:local_port after the redirect from the provider.",
+            ge=1,
+            le=65535,
+        ),
+    ] = None

dstack/_internal/core/models/backends/base.py

@@ -0,0 +1,48 @@
+import enum
+
+
+class BackendType(str, enum.Enum):
+    """
+    Attributes:
+        AMDDEVCLOUD (BackendType): AMD Developer Cloud
+        AWS (BackendType): Amazon Web Services
+        AZURE (BackendType): Microsoft Azure
+        CLOUDRIFT (BackendType): CloudRift
+        CUDO (BackendType): Cudo
+        DATACRUNCH (BackendType): DataCrunch (for backward compatibility)
+        DIGITALOCEAN (BackendType): DigitalOcean
+        DSTACK (BackendType): dstack Sky
+        GCP (BackendType): Google Cloud Platform
+        HOTAISLE (BackendType): Hot Aisle
+        KUBERNETES (BackendType): Kubernetes
+        LAMBDA (BackendType): Lambda Cloud
+        NEBIUS (BackendType): Nebius AI Cloud
+        OCI (BackendType): Oracle Cloud Infrastructure
+        RUNPOD (BackendType): Runpod Cloud
+        TENSORDOCK (BackendType): TensorDock Marketplace
+        VASTAI (BackendType): Vast.ai Marketplace
+        VERDA (BackendType): Verda Cloud
+        VULTR (BackendType): Vultr
+    """
+
+    AMDDEVCLOUD = "amddevcloud"
+    AWS = "aws"
+    AZURE = "azure"
+    CLOUDRIFT = "cloudrift"
+    CUDO = "cudo"
+    DATACRUNCH = "datacrunch"  # BackendType for backward compatibility
+    DIGITALOCEAN = "digitalocean"
+    DSTACK = "dstack"
+    GCP = "gcp"
+    HOTAISLE = "hotaisle"
+    KUBERNETES = "kubernetes"
+    LAMBDA = "lambda"
+    LOCAL = "local"
+    REMOTE = "remote"  # TODO: replace for LOCAL
+    NEBIUS = "nebius"
+    OCI = "oci"
+    RUNPOD = "runpod"
+    TENSORDOCK = "tensordock"
+    VASTAI = "vastai"
+    VERDA = "verda"
+    VULTR = "vultr"