dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

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

@@ -1,15 +0,0 @@
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.vultr.compute import VultrCompute
-from dstack._internal.core.backends.vultr.config import VultrConfig
-from dstack._internal.core.models.backends.base import BackendType
-
-
-class VultrBackend(Backend):
-    TYPE: BackendType = BackendType.VULTR
-
-    def __init__(self, config: VultrConfig):
-        self.config = config
-        self._compute = VultrCompute(self.config)
-
-    def compute(self) -> VultrCompute:
-        return self._compute

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

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.vultr.compute import VultrCompute
+from dstack._internal.core.backends.vultr.models import VultrConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class VultrBackend(Backend):
+    TYPE = BackendType.VULTR
+    COMPUTE_CLASS = VultrCompute
+
+    def __init__(self, config: VultrConfig):
+        self.config = config
+        self._compute = VultrCompute(self.config)
+
+    def compute(self) -> VultrCompute:
+        return self._compute

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

@@ -4,15 +4,16 @@ from typing import List, Optional
 
 import requests
 
-from dstack._internal.core.backends.base import Compute
+from dstack._internal.core.backends.base.backend import Compute
 from dstack._internal.core.backends.base.compute import (
+    ComputeWithCreateInstanceSupport,
+    ComputeWithMultinodeSupport,
     generate_unique_instance_name,
-    get_job_instance_name,
     get_user_data,
 )
 from dstack._internal.core.backends.base.offers import get_catalog_offers
 from dstack._internal.core.backends.vultr.api_client import VultrApiClient
-from dstack._internal.core.backends.vultr.config import VultrConfig
+from dstack._internal.core.backends.vultr.models import VultrConfig
 from dstack._internal.core.errors import BackendError, ProvisioningError
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.instances import (
@@ -20,10 +21,8 @@ from dstack._internal.core.models.instances import (
     InstanceConfiguration,
     InstanceOffer,
     InstanceOfferWithAvailability,
-    SSHKey,
 )
-from dstack._internal.core.models.runs import Job, JobProvisioningData, Requirements, Run
-from dstack._internal.core.models.volumes import Volume
+from dstack._internal.core.models.runs import JobProvisioningData, Requirements
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -31,7 +30,11 @@ logger = get_logger(__name__)
 MAX_INSTANCE_NAME_LEN = 64
 
 
-class VultrCompute(Compute):
+class VultrCompute(
+    ComputeWithCreateInstanceSupport,
+    ComputeWithMultinodeSupport,
+    Compute,
+):
     def __init__(self, config: VultrConfig):
         super().__init__()
         self.config = config
@@ -54,23 +57,6 @@ class VultrCompute(Compute):
         ]
         return offers
 
-    def run_job(
-        self,
-        run: Run,
-        job: Job,
-        instance_offer: InstanceOfferWithAvailability,
-        project_ssh_public_key: str,
-        project_ssh_private_key: str,
-        volumes: List[Volume],
-    ) -> JobProvisioningData:
-        instance_config = InstanceConfiguration(
-            project_name=run.project_name,
-            instance_name=get_job_instance_name(run, job),
-            ssh_keys=[SSHKey(public=project_ssh_public_key.strip())],
-            user=run.user,
-        )
-        return self.create_instance(instance_offer, instance_config)
-
     def create_instance(
         self, instance_offer: InstanceOfferWithAvailability, instance_config: InstanceConfiguration
     ) -> JobProvisioningData:

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

@@ -0,0 +1,64 @@
+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):
+    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(self, record: BackendRecord, include_creds: bool) -> VultrBackendConfig:
+        config = self._get_config(record)
+        if include_creds:
+            return VultrBackendConfigWithCreds.__response__.parse_obj(config)
+        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/models/backends/__init__.py

@@ -1,184 +0,0 @@
-from typing import Union
-
-from dstack._internal.core.models.backends.aws import (
-    AWSConfigInfo,
-    AWSConfigInfoWithCreds,
-    AWSConfigInfoWithCredsPartial,
-    AWSConfigValues,
-)
-from dstack._internal.core.models.backends.azure import (
-    AzureConfigInfo,
-    AzureConfigInfoWithCreds,
-    AzureConfigInfoWithCredsPartial,
-    AzureConfigValues,
-)
-from dstack._internal.core.models.backends.cudo import (
-    CudoConfigInfo,
-    CudoConfigInfoWithCreds,
-    CudoConfigInfoWithCredsPartial,
-    CudoConfigValues,
-)
-from dstack._internal.core.models.backends.datacrunch import (
-    DataCrunchConfigInfo,
-    DataCrunchConfigInfoWithCreds,
-    DataCrunchConfigInfoWithCredsPartial,
-    DataCrunchConfigValues,
-)
-from dstack._internal.core.models.backends.dstack import (
-    DstackBaseBackendConfigInfo,
-    DstackConfigInfo,
-    DstackConfigValues,
-)
-from dstack._internal.core.models.backends.gcp import (
-    GCPConfigInfo,
-    GCPConfigInfoWithCreds,
-    GCPConfigInfoWithCredsPartial,
-    GCPConfigValues,
-)
-from dstack._internal.core.models.backends.kubernetes import (
-    KubernetesConfigInfo,
-    KubernetesConfigInfoWithCreds,
-    KubernetesConfigInfoWithCredsPartial,
-    KubernetesConfigValues,
-)
-from dstack._internal.core.models.backends.lambdalabs import (
-    LambdaConfigInfo,
-    LambdaConfigInfoWithCreds,
-    LambdaConfigInfoWithCredsPartial,
-    LambdaConfigValues,
-)
-from dstack._internal.core.models.backends.nebius import (
-    NebiusConfigInfo,
-    NebiusConfigInfoWithCreds,
-    NebiusConfigInfoWithCredsPartial,
-    NebiusConfigValues,
-)
-from dstack._internal.core.models.backends.oci import (
-    OCIConfigInfo,
-    OCIConfigInfoWithCreds,
-    OCIConfigInfoWithCredsPartial,
-    OCIConfigValues,
-)
-from dstack._internal.core.models.backends.runpod import (
-    RunpodConfigInfo,
-    RunpodConfigInfoWithCreds,
-    RunpodConfigInfoWithCredsPartial,
-    RunpodConfigValues,
-)
-from dstack._internal.core.models.backends.tensordock import (
-    TensorDockConfigInfo,
-    TensorDockConfigInfoWithCreds,
-    TensorDockConfigInfoWithCredsPartial,
-    TensorDockConfigValues,
-)
-from dstack._internal.core.models.backends.vastai import (
-    VastAIConfigInfo,
-    VastAIConfigInfoWithCreds,
-    VastAIConfigInfoWithCredsPartial,
-    VastAIConfigValues,
-)
-from dstack._internal.core.models.backends.vultr import (
-    VultrConfigInfo,
-    VultrConfigInfoWithCreds,
-    VultrConfigInfoWithCredsPartial,
-    VultrConfigValues,
-)
-from dstack._internal.core.models.common import CoreModel
-
-# The following models are the basis of the JSON-based backend API.
-# They are also the models used by the Configurator interface.
-# The JSON-based backend API is replaced by the YAML-based backend API and not used.
-# It's likely to be deprecated and removed.
-# Some of the models below like those needed for interactive backend setup could be removed then.
-# Still, others are going to stay as Configurator models to keep YAML-based configs and internal configs separated.
-
-# Backend config returned by the API
-AnyConfigInfoWithoutCreds = Union[
-    AWSConfigInfo,
-    AzureConfigInfo,
-    CudoConfigInfo,
-    DataCrunchConfigInfo,
-    GCPConfigInfo,
-    KubernetesConfigInfo,
-    LambdaConfigInfo,
-    NebiusConfigInfo,
-    OCIConfigInfo,
-    RunpodConfigInfo,
-    TensorDockConfigInfo,
-    VastAIConfigInfo,
-    VultrConfigInfo,
-    DstackConfigInfo,
-    DstackBaseBackendConfigInfo,
-]
-
-# Same as AnyConfigInfoWithoutCreds but also includes creds.
-# Used to create/update backend.
-# Also returned by the API to project admins so that they can see/update backend creds.
-AnyConfigInfoWithCreds = Union[
-    AWSConfigInfoWithCreds,
-    AzureConfigInfoWithCreds,
-    CudoConfigInfoWithCreds,
-    DataCrunchConfigInfoWithCreds,
-    GCPConfigInfoWithCreds,
-    KubernetesConfigInfoWithCreds,
-    LambdaConfigInfoWithCreds,
-    NebiusConfigInfoWithCreds,
-    OCIConfigInfoWithCreds,
-    RunpodConfigInfoWithCreds,
-    TensorDockConfigInfoWithCreds,
-    VastAIConfigInfoWithCreds,
-    VultrConfigInfoWithCreds,
-    DstackConfigInfo,
-]
-
-AnyConfigInfo = Union[AnyConfigInfoWithoutCreds, AnyConfigInfoWithCreds]
-
-# Same as AnyConfigInfoWithCreds but some fields may be optional.
-# Used for interactive setup with validation and suggestions (e.g. via UI).
-# If the backend does not need interactive setup, it's the same as AnyConfigInfoWithCreds.
-AnyConfigInfoWithCredsPartial = Union[
-    AWSConfigInfoWithCredsPartial,
-    AzureConfigInfoWithCredsPartial,
-    CudoConfigInfoWithCredsPartial,
-    DataCrunchConfigInfoWithCredsPartial,
-    GCPConfigInfoWithCredsPartial,
-    KubernetesConfigInfoWithCredsPartial,
-    LambdaConfigInfoWithCredsPartial,
-    NebiusConfigInfoWithCredsPartial,
-    OCIConfigInfoWithCredsPartial,
-    RunpodConfigInfoWithCredsPartial,
-    TensorDockConfigInfoWithCredsPartial,
-    VastAIConfigInfoWithCredsPartial,
-    VultrConfigInfoWithCredsPartial,
-    DstackConfigInfo,
-]
-
-# Suggestions for unfilled fields used in interactive setup.
-AnyConfigValues = Union[
-    AWSConfigValues,
-    AzureConfigValues,
-    CudoConfigValues,
-    DataCrunchConfigValues,
-    GCPConfigValues,
-    KubernetesConfigValues,
-    LambdaConfigValues,
-    NebiusConfigValues,
-    OCIConfigValues,
-    RunpodConfigValues,
-    TensorDockConfigValues,
-    VastAIConfigValues,
-    VultrConfigValues,
-    DstackConfigValues,
-]
-
-
-# In case we'll support multiple backends of the same type,
-# this adds backend name to backend config.
-class BackendInfo(CoreModel):
-    name: str
-    config: AnyConfigInfoWithoutCreds
-
-
-class BackendInfoYAML(CoreModel):
-    name: str
-    config_yaml: str

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

@@ -1,7 +1,4 @@
 import enum
-from typing import List, Optional
-
-from dstack._internal.core.models.common import CoreModel
 
 
 class BackendType(str, enum.Enum):
@@ -32,24 +29,8 @@ class BackendType(str, enum.Enum):
     LAMBDA = "lambda"
     LOCAL = "local"
     REMOTE = "remote"  # TODO: replace for LOCAL
-    NEBIUS = "nebius"
     OCI = "oci"
     RUNPOD = "runpod"
     TENSORDOCK = "tensordock"
     VASTAI = "vastai"
     VULTR = "vultr"
-
-
-class ConfigElementValue(CoreModel):
-    value: str
-    label: str
-
-
-class ConfigElement(CoreModel):
-    selected: Optional[str] = None
-    values: List[ConfigElementValue] = []
-
-
-class ConfigMultiElement(CoreModel):
-    selected: List[str] = []
-    values: List[ConfigElementValue] = []

dstack/_internal/core/models/configurations.py

@@ -1,6 +1,6 @@
 import re
 from enum import Enum
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import Field, ValidationError, conint, constr, root_validator, validator
 from typing_extensions import Annotated, Literal
@@ -11,8 +11,6 @@ from dstack._internal.core.models.envs import Env
 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_off_duration
-from dstack._internal.core.models.repos.base import Repo
-from dstack._internal.core.models.repos.virtual import VirtualRepo
 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
@@ -93,7 +91,9 @@ class BaseRunConfiguration(CoreModel):
         Optional[str],
         Field(description="The run name. If not specified, a random name is generated"),
     ] = None
-    image: Annotated[Optional[str], Field(description="The name of the Docker image to run")]
+    image: Annotated[Optional[str], Field(description="The name of the Docker image to run")] = (
+        None
+    )
     user: Annotated[
         Optional[str],
         Field(
@@ -104,7 +104,7 @@ class BaseRunConfiguration(CoreModel):
         ),
     ] = None
     privileged: Annotated[bool, Field(description="Run the container in privileged mode")] = False
-    entrypoint: Annotated[Optional[str], Field(description="The Docker entrypoint")]
+    entrypoint: Annotated[Optional[str], Field(description="The Docker entrypoint")] = None
     working_dir: Annotated[
         Optional[str],
         Field(
@@ -119,17 +119,17 @@ class BaseRunConfiguration(CoreModel):
     home_dir: str = "/root"
     registry_auth: Annotated[
         Optional[RegistryAuth], Field(description="Credentials for pulling a private Docker image")
-    ]
+    ] = None
     python: Annotated[
         Optional[PythonVersion],
         Field(description="The major version of Python. Mutually exclusive with `image`"),
-    ]
+    ] = None
     nvcc: Annotated[
         Optional[bool],
         Field(
             description="Use image with NVIDIA CUDA Compiler (NVCC) included. Mutually exclusive with `image`"
         ),
-    ]
+    ] = None
     single_branch: Annotated[
         Optional[bool],
         Field(
@@ -178,9 +178,6 @@ class BaseRunConfiguration(CoreModel):
         UnixUser.parse(v)
         return v
 
-    def get_repo(self) -> Repo:
-        return VirtualRepo()
-
 
 class BaseRunConfigurationWithPorts(BaseRunConfiguration):
     ports: Annotated[
@@ -208,8 +205,11 @@ class BaseRunConfigurationWithCommands(BaseRunConfiguration):
 
 
 class DevEnvironmentConfigurationParams(CoreModel):
-    ide: Annotated[Literal["vscode"], Field(description="The IDE to run")]
-    version: Annotated[Optional[str], Field(description="The version of the IDE")]
+    ide: Annotated[
+        Union[Literal["vscode"], Literal["cursor"]],
+        Field(description="The IDE to run. Supported values include `vscode` and `cursor`"),
+    ]
+    version: Annotated[Optional[str], Field(description="The version of the IDE")] = None
     init: Annotated[CommandsList, Field(description="The bash commands to run on startup")] = []
     inactivity_duration: Annotated[
         Optional[Union[Literal["off"], int, bool, str]],
@@ -221,10 +221,11 @@ class DevEnvironmentConfigurationParams(CoreModel):
                 " Inactivity is defined as the absence of SSH connections to the"
                 " dev environment, including VS Code connections, `ssh <run name>`"
                 " shells, and attached `dstack apply` or `dstack attach` commands."
-                " Use `off` for unlimited duration. Defaults to `off`"
+                " Use `off` for unlimited duration. Can be updated in-place."
+                " Defaults to `off`"
             )
         ),
-    ]
+    ] = None
 
     @validator("inactivity_duration", pre=True, allow_reuse=True)
     def parse_inactivity_duration(
@@ -424,4 +425,9 @@ class DstackConfiguration(CoreModel):
     ]
 
     class Config:
-        schema_extra = {"$schema": "http://json-schema.org/draft-07/schema#"}
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            schema["$schema"] = "http://json-schema.org/draft-07/schema#"
+            # Allow additionalProperties so that vscode and others not supporting
+            # top-level oneOf do not warn about properties being invalid.
+            schema["additionalProperties"] = True

dstack/_internal/core/models/envs.py

@@ -102,10 +102,11 @@ class Env(BaseModel):
     def copy(self, **kwargs) -> Self:
         # Env.copy() is tricky because it copies only the hidden top-level {"__root__": {...}}
         # structure, not the actual nested dict representing the env itself.
-        # To avoid possible bugs, we prohibit shallow copying altogether.
+        # So we copy __root__ explicitly in case of a shallow copy.
+        new_copy = super().copy(**kwargs)
         if not kwargs.get("deep", False):
-            raise TypeError(f"shallow copying of {self.__class__.__name__} is prohibited")
-        return super().copy(**kwargs)
+            new_copy.__root__ = new_copy.__root__.copy()
+        return new_copy
 
     def as_dict(self) -> Dict[str, str]:
         """

dstack/_internal/core/models/fleets.py

@@ -10,18 +10,17 @@ from typing_extensions import Annotated, Literal
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.envs import Env
-from dstack._internal.core.models.instances import InstanceOfferWithAvailability, SSHKey
-from dstack._internal.core.models.pools import Instance
+from dstack._internal.core.models.instances import Instance, InstanceOfferWithAvailability, SSHKey
 from dstack._internal.core.models.profiles import (
     Profile,
     ProfileParams,
     ProfileRetry,
     SpotPolicy,
     TerminationPolicy,
-    parse_duration,
     parse_idle_duration,
 )
 from dstack._internal.core.models.resources import Range, ResourcesSpec
+from dstack._internal.utils.json_schema import add_extra_schema_types
 
 
 class FleetStatus(str, Enum):
@@ -218,30 +217,27 @@ class InstanceGroupParams(CoreModel):
         Optional[float],
         Field(description="The maximum instance price per hour, in dollars", gt=0.0),
     ] = None
-
     idle_duration: Annotated[
         Optional[Union[Literal["off"], str, int]],
         Field(
             description="Time to wait before terminating idle instances. Defaults to `5m` for runs and `3d` for fleets. Use `off` for unlimited duration"
         ),
     ] = None
-    # Deprecated:
-    termination_policy: Annotated[
-        Optional[TerminationPolicy],
-        Field(
-            description="Deprecated in favor of `idle_duration`",
-        ),
-    ] = None
-    termination_idle_time: Annotated[
-        Optional[Union[str, int]],
-        Field(
-            description="Deprecated in favor of `idle_duration`",
-        ),
-    ] = None
 
-    _validate_termination_idle_time = validator(
-        "termination_idle_time", pre=True, allow_reuse=True
-    )(parse_duration)
+    # Deprecated and unused. Left for compatibility with 0.18 clients.
+    termination_policy: Annotated[Optional[TerminationPolicy], Field(exclude=True)] = None
+    termination_idle_time: Annotated[Optional[Union[str, int]], Field(exclude=True)] = None
+
+    class 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"}],
+            )
+
     _validate_idle_duration = validator("idle_duration", pre=True, allow_reuse=True)(
         parse_idle_duration
     )
@@ -290,8 +286,7 @@ class FleetSpec(CoreModel):
 
 
 class Fleet(CoreModel):
-    # id is Optional for backward compatibility within 0.18.x
-    id: Optional[uuid.UUID] = None
+    id: uuid.UUID
     name: str
     project_name: str
     spec: FleetSpec

dstack/_internal/core/models/gateways.py

@@ -76,12 +76,12 @@ class Gateway(CoreModel):
     # The ip address of the gateway instance
     ip_address: Optional[str]
     instance_id: Optional[str]
+    wildcard_domain: Optional[str]
+    default: bool
     # TODO: configuration fields are duplicated on top-level for backward compatibility with 0.18.x
-    # Remove in 0.19
+    # Remove after 0.19
     backend: BackendType
     region: str
-    default: bool
-    wildcard_domain: Optional[str]
 
 
 class GatewayPlan(CoreModel):

dstack/_internal/core/models/instances.py

@@ -1,5 +1,7 @@
+import datetime
 from enum import Enum
 from typing import List, Optional
+from uuid import UUID
 
 import gpuhunt
 from pydantic import root_validator
@@ -167,3 +169,25 @@ class InstanceStatus(str, Enum):
     @classmethod
     def finished_statuses(cls) -> List["InstanceStatus"]:
         return [cls.TERMINATING, cls.TERMINATED]
+
+
+class Instance(CoreModel):
+    id: UUID
+    project_name: str
+    backend: Optional[BackendType] = None
+    instance_type: Optional[InstanceType] = None
+    name: str
+    fleet_id: Optional[UUID] = None
+    fleet_name: Optional[str] = None
+    instance_num: int
+    job_name: Optional[str] = None  # deprecated, always None (instance can have more than one job)
+    hostname: Optional[str] = None
+    status: InstanceStatus
+    unreachable: bool = False
+    termination_reason: Optional[str] = None
+    created: datetime.datetime
+    region: Optional[str] = None
+    availability_zone: Optional[str] = None
+    price: Optional[float] = None
+    total_blocks: Optional[int] = None
+    busy_blocks: int = 0