dstack 0.18.44__py3-none-any.whl → 0.19.0rc1__py3-none-any.whl

dstack/_internal/server/services/backends/configurators/runpod.py

@@ -1,67 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.runpod import RunpodBackend, RunpodConfig, api_client
-from dstack._internal.core.models.backends.base import BackendType, ConfigMultiElement
-from dstack._internal.core.models.backends.runpod import (
-    RunpodConfigInfo,
-    RunpodConfigInfoWithCreds,
-    RunpodConfigInfoWithCredsPartial,
-    RunpodConfigValues,
-    RunpodCreds,
-    RunpodStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends import Configurator
-from dstack._internal.server.services.backends.configurators.base import (
-    raise_invalid_credentials_error,
-)
-
-
-class RunpodConfigurator(Configurator):
-    TYPE: BackendType = BackendType.RUNPOD
-
-    def get_config_values(self, config: RunpodConfigInfoWithCredsPartial) -> RunpodConfigValues:
-        config_values = RunpodConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_runpod_api_key(config.creds.api_key)
-        config_values.regions = self._get_regions_element(selected=config.regions or [])
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: RunpodConfigInfoWithCreds
-    ) -> BackendModel:
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=RunpodStoredConfig(
-                **RunpodConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=RunpodCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> RunpodConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return RunpodConfigInfoWithCreds.__response__.parse_obj(config)
-        return RunpodConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> Backend:
-        config = self._get_backend_config(model)
-        return RunpodBackend(config=config)
-
-    def _get_regions_element(self, selected: List[str]) -> ConfigMultiElement:
-        return ConfigMultiElement(selected=selected)
-
-    def _get_backend_config(self, model: BackendModel) -> RunpodConfig:
-        return RunpodConfig(
-            **json.loads(model.config),
-            creds=RunpodCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_runpod_api_key(self, api_key: str):
-        client = api_client.RunpodApiClient(api_key=api_key)
-        if not client.validate_api_key():
-            raise_invalid_credentials_error(fields=[["creds", "api_key"]])

dstack/_internal/server/services/backends/configurators/tensordock.py

@@ -1,82 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.tensordock import TensorDockBackend, api_client
-from dstack._internal.core.backends.tensordock.config import TensorDockConfig
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.tensordock import (
-    AnyTensorDockConfigInfo,
-    TensorDockConfigInfo,
-    TensorDockConfigInfoWithCreds,
-    TensorDockConfigInfoWithCredsPartial,
-    TensorDockConfigValues,
-    TensorDockCreds,
-    TensorDockStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import (
-    Configurator,
-    raise_invalid_credentials_error,
-)
-
-# TensorDock regions are dynamic, currently we don't offer any filtering
-REGIONS = []
-
-
-class TensorDockConfigurator(Configurator):
-    TYPE: BackendType = BackendType.TENSORDOCK
-
-    def get_config_values(
-        self, config: TensorDockConfigInfoWithCredsPartial
-    ) -> TensorDockConfigValues:
-        config_values = TensorDockConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_tensordock_creds(config.creds.api_key, config.creds.api_token)
-        config_values.regions = self._get_regions_element(selected=config.regions or [])
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: TensorDockConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=TensorDockStoredConfig(
-                **TensorDockConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=TensorDockCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyTensorDockConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return TensorDockConfigInfoWithCreds.__response__.parse_obj(config)
-        return TensorDockConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> TensorDockBackend:
-        config = self._get_backend_config(model)
-        return TensorDockBackend(config=config)
-
-    def _get_backend_config(self, model: BackendModel) -> TensorDockConfig:
-        return TensorDockConfig.__response__(
-            **json.loads(model.config),
-            creds=TensorDockCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_tensordock_creds(self, api_key: str, api_token: str):
-        client = api_client.TensorDockAPIClient(api_key=api_key, api_token=api_token)
-        if not client.auth_test():
-            raise_invalid_credentials_error(fields=[["creds", "api_key"], ["creds", "api_token"]])
-
-    def _get_regions_element(self, selected: List[str]) -> ConfigMultiElement:
-        element = ConfigMultiElement(selected=selected)
-        for r in REGIONS:
-            element.values.append(ConfigElementValue(value=r, label=r))
-        return element

dstack/_internal/server/services/backends/configurators/vastai.py

@@ -1,80 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.vastai import VastAIBackend, api_client
-from dstack._internal.core.backends.vastai.config import VastAIConfig
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.vastai import (
-    AnyVastAIConfigInfo,
-    VastAIConfigInfo,
-    VastAIConfigInfoWithCreds,
-    VastAIConfigInfoWithCredsPartial,
-    VastAIConfigValues,
-    VastAICreds,
-    VastAIStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import (
-    Configurator,
-    raise_invalid_credentials_error,
-)
-
-# VastAI regions are dynamic, currently we don't offer any filtering
-REGIONS = []
-
-
-class VastAIConfigurator(Configurator):
-    TYPE: BackendType = BackendType.VASTAI
-
-    def get_config_values(self, config: VastAIConfigInfoWithCredsPartial) -> VastAIConfigValues:
-        config_values = VastAIConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_vastai_creds(config.creds.api_key)
-        config_values.regions = self._get_regions_element(selected=config.regions or [])
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: VastAIConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=VastAIStoredConfig(
-                **VastAIConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=VastAICreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyVastAIConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return VastAIConfigInfoWithCreds.__response__.parse_obj(config)
-        return VastAIConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> VastAIBackend:
-        config = self._get_backend_config(model)
-        return VastAIBackend(config=config)
-
-    def _get_backend_config(self, model: BackendModel) -> VastAIConfig:
-        return VastAIConfig.__response__(
-            **json.loads(model.config),
-            creds=VastAICreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_vastai_creds(self, api_key: str):
-        client = api_client.VastAIAPIClient(api_key=api_key)
-        if not client.auth_test():
-            raise_invalid_credentials_error(fields=[["creds", "api_key"]])
-
-    def _get_regions_element(self, selected: List[str]) -> ConfigMultiElement:
-        element = ConfigMultiElement(selected=selected)
-        for r in REGIONS:
-            element.values.append(ConfigElementValue(value=r, label=r))
-        return element

dstack/_internal/server/services/backends/configurators/vultr.py

@@ -1,80 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.vultr import VultrBackend, VultrConfig, api_client
-from dstack._internal.core.models.backends import (
-    VultrConfigInfoWithCreds,
-    VultrConfigInfoWithCredsPartial,
-    VultrConfigValues,
-)
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.vultr import (
-    VultrConfigInfo,
-    VultrCreds,
-    VultrStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends import Configurator
-from dstack._internal.server.services.backends.configurators.base import (
-    raise_invalid_credentials_error,
-)
-
-REGIONS = []
-
-
-class VultrConfigurator(Configurator):
-    TYPE: BackendType = BackendType.VULTR
-
-    def get_config_values(self, config: VultrConfigInfoWithCredsPartial) -> VultrConfigValues:
-        config_values = VultrConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_vultr_api_key(config.creds.api_key)
-        config_values.regions = self._get_regions_element(selected=config.regions or [])
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: VultrConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=VultrStoredConfig(
-                **VultrConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=VultrCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> VultrConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return VultrConfigInfoWithCreds.__response__.parse_obj(config)
-        return VultrConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> Backend:
-        config = self._get_backend_config(model)
-        return VultrBackend(config=config)
-
-    def _get_regions_element(self, selected: List[str]) -> ConfigMultiElement:
-        element = ConfigMultiElement(selected=selected)
-        for r in REGIONS:
-            element.values.append(ConfigElementValue(value=r, label=r))
-        return element
-
-    def _get_backend_config(self, model: BackendModel) -> VultrConfig:
-        return VultrConfig.__response__(
-            **json.loads(model.config),
-            creds=VultrCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    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/api/_public/pools.py

@@ -1,41 +0,0 @@
-from typing import List
-
-from dstack._internal.core.models.pools import Pool
-from dstack.api.server import APIClient
-
-
-class PoolInstance:
-    def __init__(self, api_client: APIClient, pool: Pool):
-        self._api_client = api_client
-        self._pool = pool
-
-    @property
-    def name(self) -> str:
-        return self._pool.name
-
-    def __str__(self) -> str:
-        return f"<PoolInstance '{self.name}'>"
-
-    def __repr__(self) -> str:
-        return f"<PoolInstance '{self.name}'>"
-
-
-class PoolCollection:
-    """
-    Operations with pools
-    """
-
-    def __init__(self, api_client: APIClient, project: str):
-        self._api_client = api_client
-        self._project = project
-
-    def list(self) -> List[PoolInstance]:
-        """
-        List available pool in the project
-
-        Returns:
-            pools
-        """
-        list_raw_pool = self._api_client.pool.list(project_name=self._project)
-        list_pool = [PoolInstance(self._api_client, instance) for instance in list_raw_pool]
-        return list_pool

dstack/api/_public/resources.py

@@ -1,105 +0,0 @@
-from typing import List, Optional, Union
-
-from dstack._internal.core.models.resources import (
-    DEFAULT_CPU_COUNT,
-    DEFAULT_GPU_COUNT,
-    DEFAULT_MEMORY_SIZE,
-    ComputeCapabilityLike,
-    DiskLike,
-    DiskSpec,
-    DiskSpecSchema,
-    GPULike,
-    GPUSpec,
-    GPUSpecSchema,
-    IntRangeLike,
-    MemoryLike,
-    MemoryRangeLike,
-    ResourcesSpec,
-    ResourcesSpecSchema,
-)
-
-
-# TODO(andrey): This method looks like a workaround and possibly must be reworked (replaced with something else).
-#   Currently it's only used by the `dstack pool add` command.
-def Resources(
-    *,
-    cpu: IntRangeLike = DEFAULT_CPU_COUNT,
-    memory: MemoryRangeLike = DEFAULT_MEMORY_SIZE,
-    gpu: Optional[GPULike] = None,
-    shm_size: Optional[MemoryLike] = None,
-    disk: Optional[DiskLike] = None,
-) -> ResourcesSpec:
-    """
-    Creates required resources specification.
-
-    Args:
-        cpu (Optional[Range[int]]): The number of CPUs
-        memory (Optional[Range[Memory]]): The size of RAM memory (e.g., `"16GB"`)
-        gpu (Optional[GPUSpec]): The GPU spec
-        shm_size (Optional[Range[Memory]]): The of shared memory (e.g., `"8GB"`). If you are using parallel communicating processes (e.g., dataloaders in PyTorch), you may need to configure this.
-        disk (Optional[DiskSpec]): The disk spec
-
-    Returns:
-        resources specification
-    """
-    return ResourcesSpec.parse_obj(
-        ResourcesSpecSchema(
-            cpu=cpu,
-            memory=memory,
-            gpu=gpu,
-            shm_size=shm_size,
-            disk=disk,
-        )
-    )
-
-
-def GPU(
-    *,
-    name: Optional[Union[List[str], str]] = None,
-    count: IntRangeLike = DEFAULT_GPU_COUNT,
-    memory: Optional[MemoryRangeLike] = None,
-    total_memory: Optional[MemoryRangeLike] = None,
-    compute_capability: Optional[ComputeCapabilityLike] = None,
-) -> GPUSpec:
-    """
-    Creates GPU specification.
-
-    Args:
-        name (Optional[List[str]]): The name of the GPU (e.g., `"A100"` or `"H100"`)
-        count (Optional[Range[int]]): The number of GPUs
-        memory (Optional[Range[Memory]]): The size of a single GPU memory (e.g., `"16GB"`)
-        total_memory (Optional[Range[Memory]]): The total size of all GPUs memory (e.g., `"32GB"`)
-        compute_capability (Optional[float]): The minimum compute capability of the GPU (e.g., `7.5`)
-
-    Returns:
-        GPU specification
-    """
-    return GPUSpec.parse_obj(
-        GPUSpecSchema(
-            name=name,
-            count=count,
-            memory=memory,
-            total_memory=total_memory,
-            compute_capability=compute_capability,
-        )
-    )
-
-
-def Disk(
-    *,
-    size: MemoryRangeLike,
-) -> DiskSpec:
-    """
-    Creates disk specification.
-
-    Args:
-        size (Range[Memory]): The size of the disk (e.g., `"100GB"`)
-
-    Returns:
-        disk specification
-    """
-    return DiskSpec.parse_obj(
-        DiskSpecSchema(
-            size=size,
-        )
-    )

dstack/api/server/_pools.py

@@ -1,63 +0,0 @@
-from typing import List, Optional
-
-from pydantic import parse_obj_as
-
-import dstack._internal.server.schemas.pools as schemas_pools
-from dstack._internal.core.models.instances import SSHKey
-from dstack._internal.core.models.pools import Instance, Pool, PoolInstances
-from dstack._internal.server.schemas.runs import AddRemoteInstanceRequest
-from dstack.api.server._group import APIClientGroup
-
-
-class PoolAPIClient(APIClientGroup):
-    def list(self, project_name: str) -> List[Pool]:
-        resp = self._request(f"/api/project/{project_name}/pool/list")
-        return parse_obj_as(List[Pool.__response__], resp.json())
-
-    def delete(self, project_name: str, pool_name: str, force: bool) -> None:
-        body = schemas_pools.DeletePoolRequest(name=pool_name, force=force)
-        self._request(f"/api/project/{project_name}/pool/delete", body=body.json())
-
-    def create(self, project_name: str, pool_name: str) -> None:
-        body = schemas_pools.CreatePoolRequest(name=pool_name)
-        self._request(f"/api/project/{project_name}/pool/create", body=body.json())
-
-    def show(self, project_name: str, pool_name: Optional[str]) -> PoolInstances:
-        body = schemas_pools.ShowPoolRequest(name=pool_name)
-        resp = self._request(f"/api/project/{project_name}/pool/show", body=body.json())
-        return parse_obj_as(PoolInstances.__response__, resp.json())
-
-    def remove(self, project_name: str, pool_name: str, instance_name: str, force: bool) -> None:
-        body = schemas_pools.RemoveInstanceRequest(
-            pool_name=pool_name, instance_name=instance_name, force=force
-        )
-        self._request(f"/api/project/{project_name}/pool/remove", body=body.json())
-
-    def set_default(self, project_name: str, pool_name: str) -> None:
-        body = schemas_pools.SetDefaultPoolRequest(pool_name=pool_name)
-        self._request(f"/api/project/{project_name}/pool/set_default", body=body.json())
-
-    def add_remote(
-        self,
-        project_name: str,
-        pool_name: Optional[str],
-        instance_name: Optional[str],
-        instance_network: Optional[str],
-        region: Optional[str],
-        host: str,
-        port: int,
-        ssh_user: str,
-        ssh_keys: List[SSHKey],
-    ) -> Instance:
-        body = AddRemoteInstanceRequest(
-            pool_name=pool_name,
-            instance_name=instance_name,
-            instance_network=instance_network,
-            region=region,
-            host=host,
-            port=port,
-            ssh_user=ssh_user,
-            ssh_keys=ssh_keys,
-        )
-        result = self._request(f"/api/project/{project_name}/pool/add_remote", body=body.json())
-        return parse_obj_as(Instance.__response__, result.json())