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

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

@@ -1,11 +1,11 @@
 from abc import ABC, abstractmethod
-from typing import Any, ClassVar, List, Optional
+from typing import Any, ClassVar, Generic, List, Optional, TypeVar
 from uuid import UUID
 
 from dstack._internal.core.backends.base.backend import Backend
 from dstack._internal.core.backends.models import (
-    AnyBackendConfig,
     AnyBackendConfigWithCreds,
+    AnyBackendConfigWithoutCreds,
 )
 from dstack._internal.core.errors import BackendInvalidCredentialsError
 from dstack._internal.core.models.backends.base import BackendType
@@ -15,6 +15,11 @@ from dstack._internal.core.models.common import CoreModel
 # We'll introduce our own base limit that can be customized per backend if required.
 TAGS_MAX_NUM = 25
 
+BackendConfigWithoutCredsT = TypeVar(
+    "BackendConfigWithoutCredsT", bound=AnyBackendConfigWithoutCreds
+)
+BackendConfigWithCredsT = TypeVar("BackendConfigWithCredsT", bound=AnyBackendConfigWithCreds)
+
 
 class BackendRecord(CoreModel):
     """
@@ -39,7 +44,7 @@ class StoredBackendRecord(BackendRecord):
     backend_id: UUID
 
 
-class Configurator(ABC):
+class Configurator(ABC, Generic[BackendConfigWithoutCredsT, BackendConfigWithCredsT]):
     """
     `Configurator` is responsible for configuring backends
     and initializing `Backend` instances from backend configs.
@@ -52,7 +57,7 @@ class Configurator(ABC):
     BACKEND_CLASS: ClassVar[type[Backend]]
 
     @abstractmethod
-    def validate_config(self, config: AnyBackendConfigWithCreds, default_creds_enabled: bool):
+    def validate_config(self, config: BackendConfigWithCredsT, default_creds_enabled: bool):
         """
         Validates backend config including backend creds and other parameters.
         Raises `ServerClientError` or its subclass if config is invalid.
@@ -61,9 +66,7 @@ class Configurator(ABC):
         pass
 
     @abstractmethod
-    def create_backend(
-        self, project_name: str, config: AnyBackendConfigWithCreds
-    ) -> BackendRecord:
+    def create_backend(self, project_name: str, config: BackendConfigWithCredsT) -> BackendRecord:
         """
         Sets up backend given backend config and returns
         text-encoded config and creds to be stored in the DB.
@@ -78,13 +81,22 @@ class Configurator(ABC):
         pass
 
     @abstractmethod
-    def get_backend_config(
-        self, record: StoredBackendRecord, include_creds: bool
-    ) -> AnyBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: StoredBackendRecord
+    ) -> BackendConfigWithCredsT:
+        """
+        Constructs `BackendConfig` with credentials included.
+        Used internally and when project admins need to see backend's creds.
+        """
+        pass
+
+    @abstractmethod
+    def get_backend_config_without_creds(
+        self, record: StoredBackendRecord
+    ) -> BackendConfigWithoutCredsT:
         """
-        Constructs `BackendConfig` to be returned in API responses.
-        Project admins may need to see backend's creds. In this case `include_creds` will be `True`.
-        Otherwise, no sensitive information should be included.
+        Constructs `BackendConfig` without sensitive information.
+        Used for API responses where creds should not be exposed.
         """
         pass
 

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.cloudrift.api_client import RiftClient
 from dstack._internal.core.backends.cloudrift.backend import CloudRiftBackend
 from dstack._internal.core.backends.cloudrift.models import (
-    AnyCloudRiftBackendConfig,
     AnyCloudRiftCreds,
     CloudRiftBackendConfig,
     CloudRiftBackendConfigWithCreds,
@@ -21,7 +20,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class CloudRiftConfigurator(Configurator):
+class CloudRiftConfigurator(
+    Configurator[
+        CloudRiftBackendConfig,
+        CloudRiftBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.CLOUDRIFT
     BACKEND_CLASS = CloudRiftBackend
 
@@ -40,12 +44,14 @@ class CloudRiftConfigurator(Configurator):
             auth=CloudRiftCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyCloudRiftBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> CloudRiftBackendConfigWithCreds:
+        config = self._get_config(record)
+        return CloudRiftBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> CloudRiftBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return CloudRiftBackendConfigWithCreds.__response__.parse_obj(config)
         return CloudRiftBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> CloudRiftBackend:

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.cudo import api_client
 from dstack._internal.core.backends.cudo.backend import CudoBackend
 from dstack._internal.core.backends.cudo.models import (
-    AnyCudoBackendConfig,
     CudoBackendConfig,
     CudoBackendConfigWithCreds,
     CudoConfig,
@@ -18,7 +17,12 @@ from dstack._internal.core.backends.cudo.models import (
 from dstack._internal.core.models.backends.base import BackendType
 
 
-class CudoConfigurator(Configurator):
+class CudoConfigurator(
+    Configurator[
+        CudoBackendConfig,
+        CudoBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.CUDO
     BACKEND_CLASS = CudoBackend
 
@@ -35,12 +39,12 @@ class CudoConfigurator(Configurator):
             auth=CudoCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyCudoBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> CudoBackendConfigWithCreds:
+        config = self._get_config(record)
+        return CudoBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> CudoBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return CudoBackendConfigWithCreds.__response__.parse_obj(config)
         return CudoBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> CudoBackend:

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

@@ -161,7 +161,10 @@ class DataCrunchCompute(
         try:
             self.client.instances.action(id_list=[instance_id], action="delete")
         except APIException as e:
-            if e.message == "Invalid instance id":
+            if e.message in [
+                "Invalid instance id",
+                "Can't discontinue a discontinued instance",
+            ]:
                 logger.debug("Skipping instance %s termination. Instance not found.", instance_id)
                 return
             raise
@@ -243,6 +246,7 @@ def _deploy_instance(
             hostname=hostname,
             description=description,
             startup_script_id=startup_script_id,
+            pricing="FIXED_PRICE",
             is_spot=is_spot,
             location=location,
             os_volume={"name": "OS volume", "size": disk_size},

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

@@ -10,7 +10,6 @@ from dstack._internal.core.backends.base.configurator import (
 )
 from dstack._internal.core.backends.datacrunch.backend import DataCrunchBackend
 from dstack._internal.core.backends.datacrunch.models import (
-    AnyDataCrunchBackendConfig,
     DataCrunchBackendConfig,
     DataCrunchBackendConfigWithCreds,
     DataCrunchConfig,
@@ -22,7 +21,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class DataCrunchConfigurator(Configurator):
+class DataCrunchConfigurator(
+    Configurator[
+        DataCrunchBackendConfig,
+        DataCrunchBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.DATACRUNCH
     BACKEND_CLASS = DataCrunchBackend
 
@@ -41,12 +45,14 @@ class DataCrunchConfigurator(Configurator):
             auth=DataCrunchCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyDataCrunchBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> DataCrunchBackendConfigWithCreds:
+        config = self._get_config(record)
+        return DataCrunchBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> DataCrunchBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return DataCrunchBackendConfigWithCreds.__response__.parse_obj(config)
         return DataCrunchBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> DataCrunchBackend:

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

@@ -11,7 +11,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.gcp import auth, resources
 from dstack._internal.core.backends.gcp.backend import GCPBackend
 from dstack._internal.core.backends.gcp.models import (
-    AnyGCPBackendConfig,
     GCPBackendConfig,
     GCPBackendConfigWithCreds,
     GCPConfig,
@@ -109,7 +108,12 @@ DEFAULT_REGIONS = REGIONS
 MAIN_REGION = "us-east1"
 
 
-class GCPConfigurator(Configurator):
+class GCPConfigurator(
+    Configurator[
+        GCPBackendConfig,
+        GCPBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.GCP
     BACKEND_CLASS = GCPBackend
 
@@ -147,12 +151,12 @@ class GCPConfigurator(Configurator):
             auth=GCPCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyGCPBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> GCPBackendConfigWithCreds:
+        config = self._get_config(record)
+        return GCPBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> GCPBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return GCPBackendConfigWithCreds.__response__.parse_obj(config)
         return GCPBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> GCPBackend:

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

@@ -7,7 +7,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.hotaisle.api_client import HotAisleAPIClient
 from dstack._internal.core.backends.hotaisle.backend import HotAisleBackend
 from dstack._internal.core.backends.hotaisle.models import (
-    AnyHotAisleBackendConfig,
     AnyHotAisleCreds,
     HotAisleBackendConfig,
     HotAisleBackendConfigWithCreds,
@@ -20,7 +19,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class HotAisleConfigurator(Configurator):
+class HotAisleConfigurator(
+    Configurator[
+        HotAisleBackendConfig,
+        HotAisleBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.HOTAISLE
     BACKEND_CLASS = HotAisleBackend
 
@@ -37,12 +41,14 @@ class HotAisleConfigurator(Configurator):
             auth=HotAisleCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyHotAisleBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> HotAisleBackendConfigWithCreds:
+        config = self._get_config(record)
+        return HotAisleBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> HotAisleBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return HotAisleBackendConfigWithCreds.__response__.parse_obj(config)
         return HotAisleBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> HotAisleBackend:

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

@@ -6,7 +6,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.kubernetes import utils as kubernetes_utils
 from dstack._internal.core.backends.kubernetes.backend import KubernetesBackend
 from dstack._internal.core.backends.kubernetes.models import (
-    AnyKubernetesBackendConfig,
     KubernetesBackendConfig,
     KubernetesBackendConfigWithCreds,
     KubernetesConfig,
@@ -18,7 +17,12 @@ from dstack._internal.utils.logging import get_logger
 logger = get_logger(__name__)
 
 
-class KubernetesConfigurator(Configurator):
+class KubernetesConfigurator(
+    Configurator[
+        KubernetesBackendConfig,
+        KubernetesBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.KUBERNETES
     BACKEND_CLASS = KubernetesBackend
 
@@ -40,12 +44,14 @@ class KubernetesConfigurator(Configurator):
             auth="",
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyKubernetesBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> KubernetesBackendConfigWithCreds:
+        config = self._get_config(record)
+        return KubernetesBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> KubernetesBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return KubernetesBackendConfigWithCreds.__response__.parse_obj(config)
         return KubernetesBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> KubernetesBackend:

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.lambdalabs import api_client
 from dstack._internal.core.backends.lambdalabs.backend import LambdaBackend
 from dstack._internal.core.backends.lambdalabs.models import (
-    AnyLambdaBackendConfig,
     LambdaBackendConfig,
     LambdaBackendConfigWithCreds,
     LambdaConfig,
@@ -20,7 +19,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class LambdaConfigurator(Configurator):
+class LambdaConfigurator(
+    Configurator[
+        LambdaBackendConfig,
+        LambdaBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.LAMBDA
     BACKEND_CLASS = LambdaBackend
 
@@ -37,12 +41,12 @@ class LambdaConfigurator(Configurator):
             auth=LambdaCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyLambdaBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> LambdaBackendConfigWithCreds:
+        config = self._get_config(record)
+        return LambdaBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> LambdaBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return LambdaBackendConfigWithCreds.__response__.parse_obj(config)
         return LambdaBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> LambdaBackend:

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

@@ -364,7 +364,7 @@ def _wait_for_instance(sdk: SDK, op: SDKOperation[Operation]) -> None:
         )
         time.sleep(WAIT_FOR_INSTANCE_UPDATE_INTERVAL)
         resources.LOOP.await_(
-            op.update(timeout=resources.REQUEST_TIMEOUT, metadata=resources.REQUEST_MD)
+            op.update(per_retry_timeout=resources.REQUEST_TIMEOUT, metadata=resources.REQUEST_MD)
         )
 
 

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

@@ -11,7 +11,6 @@ from dstack._internal.core.backends.nebius import resources
 from dstack._internal.core.backends.nebius.backend import NebiusBackend
 from dstack._internal.core.backends.nebius.fabrics import get_all_infiniband_fabrics
 from dstack._internal.core.backends.nebius.models import (
-    AnyNebiusBackendConfig,
     NebiusBackendConfig,
     NebiusBackendConfigWithCreds,
     NebiusConfig,
@@ -22,7 +21,12 @@ from dstack._internal.core.backends.nebius.models import (
 from dstack._internal.core.models.backends.base import BackendType
 
 
-class NebiusConfigurator(Configurator):
+class NebiusConfigurator(
+    Configurator[
+        NebiusBackendConfig,
+        NebiusBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.NEBIUS
     BACKEND_CLASS = NebiusBackend
 
@@ -60,12 +64,12 @@ class NebiusConfigurator(Configurator):
             auth=NebiusCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyNebiusBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> NebiusBackendConfigWithCreds:
+        config = self._get_config(record)
+        return NebiusBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> NebiusBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return NebiusBackendConfigWithCreds.__response__.parse_obj(config)
         return NebiusBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> NebiusBackend:

dstack/_internal/core/backends/nebius/resources.py

@@ -119,7 +119,7 @@ def wait_for_operation(
         if time.monotonic() + interval > deadline:
             raise TimeoutError(f"Operation {op.id} wait timeout")
         time.sleep(interval)
-        LOOP.await_(op.update(timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD))
+        LOOP.await_(op.update(per_retry_timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD))
 
 
 def get_region_to_project_id_map(
@@ -155,7 +155,7 @@ def validate_regions(configured: set[str], available: set[str]) -> None:
 def list_tenant_projects(sdk: SDK) -> Sequence[Container]:
     tenants = LOOP.await_(
         TenantServiceClient(sdk).list(
-            ListTenantsRequest(), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
+            ListTenantsRequest(), per_retry_timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
         )
     )
     if len(tenants.items) != 1:
@@ -164,7 +164,7 @@ def list_tenant_projects(sdk: SDK) -> Sequence[Container]:
     projects = LOOP.await_(
         ProjectServiceClient(sdk).list(
             ListProjectsRequest(parent_id=tenant_id, page_size=999),
-            timeout=REQUEST_TIMEOUT,
+            per_retry_timeout=REQUEST_TIMEOUT,
             metadata=REQUEST_MD,
         )
     )
@@ -238,7 +238,7 @@ def get_default_subnet(sdk: SDK, project_id: str) -> Subnet:
     subnets = LOOP.await_(
         SubnetServiceClient(sdk).list(
             ListSubnetsRequest(parent_id=project_id, page_size=999),
-            timeout=REQUEST_TIMEOUT,
+            per_retry_timeout=REQUEST_TIMEOUT,
             metadata=REQUEST_MD,
         )
     )
@@ -264,13 +264,15 @@ def create_disk(
         ),
     )
     with wrap_capacity_errors():
-        return LOOP.await_(client.create(request, timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD))
+        return LOOP.await_(
+            client.create(request, per_retry_timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD)
+        )
 
 
 def delete_disk(sdk: SDK, disk_id: str) -> None:
     LOOP.await_(
         DiskServiceClient(sdk).delete(
-            DeleteDiskRequest(id=disk_id), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
+            DeleteDiskRequest(id=disk_id), per_retry_timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
         )
     )
 
@@ -318,13 +320,17 @@ def create_instance(
         ),
     )
     with wrap_capacity_errors():
-        return LOOP.await_(client.create(request, timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD))
+        return LOOP.await_(
+            client.create(request, per_retry_timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD)
+        )
 
 
 def get_instance(sdk: SDK, instance_id: str) -> Instance:
     return LOOP.await_(
         InstanceServiceClient(sdk).get(
-            GetInstanceRequest(id=instance_id), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
+            GetInstanceRequest(id=instance_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            metadata=REQUEST_MD,
         )
     )
 
@@ -332,7 +338,9 @@ def get_instance(sdk: SDK, instance_id: str) -> Instance:
 def delete_instance(sdk: SDK, instance_id: str) -> SDKOperation[Operation]:
     return LOOP.await_(
         InstanceServiceClient(sdk).delete(
-            DeleteInstanceRequest(id=instance_id), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
+            DeleteInstanceRequest(id=instance_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            metadata=REQUEST_MD,
         )
     )
 
@@ -345,7 +353,7 @@ def create_cluster(sdk: SDK, name: str, project_id: str, fabric: str) -> SDKOper
                     metadata=ResourceMetadata(name=name, parent_id=project_id),
                     spec=GpuClusterSpec(infiniband_fabric=fabric),
                 ),
-                timeout=REQUEST_TIMEOUT,
+                per_retry_timeout=REQUEST_TIMEOUT,
                 metadata=REQUEST_MD,
             )
         )
@@ -354,6 +362,8 @@ def create_cluster(sdk: SDK, name: str, project_id: str, fabric: str) -> SDKOper
 def delete_cluster(sdk: SDK, cluster_id: str) -> None:
     return LOOP.await_(
         GpuClusterServiceClient(sdk).delete(
-            DeleteGpuClusterRequest(id=cluster_id), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
+            DeleteGpuClusterRequest(id=cluster_id),
+            per_retry_timeout=REQUEST_TIMEOUT,
+            metadata=REQUEST_MD,
         )
     )

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

@@ -10,7 +10,6 @@ from dstack._internal.core.backends.oci import resources
 from dstack._internal.core.backends.oci.backend import OCIBackend
 from dstack._internal.core.backends.oci.exceptions import any_oci_exception
 from dstack._internal.core.backends.oci.models import (
-    AnyOCIBackendConfig,
     OCIBackendConfig,
     OCIBackendConfigWithCreds,
     OCIConfig,
@@ -42,7 +41,12 @@ SUPPORTED_REGIONS = frozenset(
 )
 
 
-class OCIConfigurator(Configurator):
+class OCIConfigurator(
+    Configurator[
+        OCIBackendConfig,
+        OCIBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.OCI
     BACKEND_CLASS = OCIBackend
 
@@ -83,12 +87,12 @@ class OCIConfigurator(Configurator):
             auth=OCICreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyOCIBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> OCIBackendConfigWithCreds:
+        config = self._get_config(record)
+        return OCIBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> OCIBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return OCIBackendConfigWithCreds.__response__.parse_obj(config)
         return OCIBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> OCIBackend:

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

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.runpod import api_client
 from dstack._internal.core.backends.runpod.backend import RunpodBackend
 from dstack._internal.core.backends.runpod.models import (
-    AnyRunpodBackendConfig,
     RunpodBackendConfig,
     RunpodBackendConfigWithCreds,
     RunpodConfig,
@@ -18,7 +17,12 @@ from dstack._internal.core.backends.runpod.models import (
 from dstack._internal.core.models.backends.base import BackendType
 
 
-class RunpodConfigurator(Configurator):
+class RunpodConfigurator(
+    Configurator[
+        RunpodBackendConfig,
+        RunpodBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.RUNPOD
     BACKEND_CLASS = RunpodBackend
 
@@ -35,12 +39,12 @@ class RunpodConfigurator(Configurator):
             auth=RunpodCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyRunpodBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> RunpodBackendConfigWithCreds:
+        config = self._get_config(record)
+        return RunpodBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> RunpodBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return RunpodBackendConfigWithCreds.__response__.parse_obj(config)
         return RunpodBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> RunpodBackend:

dstack/_internal/core/backends/template/configurator.py.jinja

@@ -7,7 +7,6 @@ from dstack._internal.core.backends.base.configurator import (
 )
 from dstack._internal.core.backends.{{ backend_name|lower }}.backend import {{ backend_name }}Backend
 from dstack._internal.core.backends.{{ backend_name|lower }}.models import (
-    Any{{ backend_name }}BackendConfig,
     Any{{ backend_name }}Creds,
     {{ backend_name }}BackendConfig,
     {{ backend_name }}BackendConfigWithCreds,
@@ -20,7 +19,12 @@ from dstack._internal.core.models.backends.base import (
 )
 
 
-class {{ backend_name }}Configurator(Configurator):
+class {{ backend_name }}Configurator(
+    Configurator[
+        {{ backend_name }}BackendConfig,
+        {{ backend_name }}BackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.{{ backend_name|upper }}
     BACKEND_CLASS = {{ backend_name }}Backend
 
@@ -40,12 +44,12 @@ class {{ backend_name }}Configurator(Configurator):
             auth={{ backend_name }}Creds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> Any{{ backend_name }}BackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> {{ backend_name }}BackendConfigWithCreds:
+        config = self._get_config(record)
+        return {{ backend_name }}BackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> {{ backend_name }}BackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return {{ backend_name }}BackendConfigWithCreds.__response__.parse_obj(config)
         return {{ backend_name }}BackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> {{ backend_name }}Backend: