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

dstack/_internal/server/routers/pools.py

@@ -1,142 +0,0 @@
-from typing import List, Tuple
-
-from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-
-import dstack._internal.core.models.pools as models
-import dstack._internal.server.schemas.pools as schemas
-import dstack._internal.server.services.pools as pools
-from dstack._internal.core.errors import ConfigurationError
-from dstack._internal.core.models.pools import Instance
-from dstack._internal.server.db import get_session
-from dstack._internal.server.models import ProjectModel, UserModel
-from dstack._internal.server.schemas.pools import ListPoolsRequest
-from dstack._internal.server.schemas.runs import AddRemoteInstanceRequest
-from dstack._internal.server.security.permissions import Authenticated, ProjectMember
-from dstack._internal.server.utils.routers import get_base_api_additional_responses
-
-root_router = APIRouter(
-    prefix="/api/pools",
-    tags=["pool"],
-    responses=get_base_api_additional_responses(),
-    deprecated=True,
-)
-router = APIRouter(
-    prefix="/api/project/{project_name}/pool",
-    tags=["pool"],
-    responses=get_base_api_additional_responses(),
-    deprecated=True,
-)
-
-
-@root_router.post("/list_instances")
-async def list_pool_instances(
-    body: ListPoolsRequest,
-    session: AsyncSession = Depends(get_session),
-    user: UserModel = Depends(Authenticated()),
-) -> List[Instance]:
-    """
-    Returns all instances visible to user sorted by descending `created_at`.
-    `project_name` and `pool_name` can be specified as filters.
-
-    The results are paginated. To get the next page, pass `created_at` and `id` of
-    the last instance from the previous page as `prev_created_at` and `prev_id`.
-    """
-    return await pools.list_user_pool_instances(
-        session=session,
-        user=user,
-        project_names=[body.project_name] if body.project_name is not None else None,
-        fleet_ids=None,
-        pool_name=body.pool_name,
-        only_active=body.only_active,
-        prev_created_at=body.prev_created_at,
-        prev_id=body.prev_id,
-        limit=body.limit,
-        ascending=body.ascending,
-    )
-
-
-@router.post("/list")
-async def list_pool(
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> List[models.Pool]:
-    _, project = user_project
-    return await pools.list_project_pools(session=session, project=project)
-
-
-@router.post("/create")
-async def create_pool(
-    body: schemas.CreatePoolRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> None:
-    _, project = user_project
-    await pools.create_pool(session=session, project=project, name=body.name)
-
-
-@router.post("/set_default")
-async def set_default_pool(
-    body: schemas.SetDefaultPoolRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-):
-    _, project_model = user_project
-    await pools.set_default_pool(session, project_model, body.pool_name)
-
-
-@router.post("/delete")
-async def delete_pool(
-    body: schemas.DeletePoolRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> None:
-    _, project = user_project
-    await pools.delete_pool(session, project, body.name)
-
-
-@router.post("/show")
-async def show_pool(
-    body: schemas.ShowPoolRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> models.PoolInstances:
-    _, project = user_project
-    return await pools.show_pool_instances(session, project, pool_name=body.name)
-
-
-@router.post("/remove")
-async def remove_instance(
-    body: schemas.RemoveInstanceRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> None:
-    _, project_model = user_project
-    await pools.remove_instance(
-        session, project_model, body.pool_name, body.instance_name, body.force
-    )
-
-
-@router.post("/add_remote")
-async def add_instance(
-    body: AddRemoteInstanceRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> Instance:
-    if not body.host.strip() or not body.ssh_user.strip() or not body.ssh_keys:
-        raise ConfigurationError("Host, user or ssh keys are empty")
-
-    _, project = user_project
-    result = await pools.add_remote(
-        session,
-        project=project,
-        pool_name=body.pool_name,
-        instance_name=body.instance_name,
-        instance_network=body.instance_network,
-        region=body.region,
-        host=body.host,
-        port=body.port or 22,
-        ssh_user=body.ssh_user,
-        ssh_keys=body.ssh_keys,
-    )
-    return result

dstack/_internal/server/schemas/pools.py

@@ -1,38 +0,0 @@
-from datetime import datetime
-from typing import Optional
-from uuid import UUID
-
-from dstack._internal.core.models.common import CoreModel
-
-
-class DeletePoolRequest(CoreModel):
-    name: str
-    force: bool
-
-
-class CreatePoolRequest(CoreModel):
-    name: str
-
-
-class ShowPoolRequest(CoreModel):
-    name: Optional[str]
-
-
-class RemoveInstanceRequest(CoreModel):
-    pool_name: str
-    instance_name: str
-    force: bool = False
-
-
-class SetDefaultPoolRequest(CoreModel):
-    pool_name: str
-
-
-class ListPoolsRequest(CoreModel):
-    project_name: Optional[str]
-    pool_name: Optional[str]
-    only_active: bool = False
-    prev_created_at: Optional[datetime]
-    prev_id: Optional[UUID]
-    limit: int = 1000
-    ascending: bool = False

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

@@ -1,72 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, List, Optional
-
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.errors import BackendInvalidCredentialsError
-from dstack._internal.core.models.backends import (
-    AnyConfigInfo,
-    AnyConfigInfoWithCreds,
-    AnyConfigInfoWithCredsPartial,
-    AnyConfigValues,
-)
-from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.server.models import BackendModel, ProjectModel
-
-# Most clouds allow ~ 40-60 tags/labels per resource.
-# We'll introduce our own base limit that can be customized per backend if required.
-TAGS_MAX_NUM = 25
-
-
-class Configurator(ABC):
-    TYPE: BackendType
-
-    def get_default_configs(self) -> List[AnyConfigInfoWithCreds]:
-        """
-        Tries to detect backend creds on the machine and
-        automatically construct backend configs from the creds.
-        """
-        return []
-
-    @abstractmethod
-    def get_config_values(self, config: AnyConfigInfoWithCredsPartial) -> AnyConfigValues:
-        """
-        Validates backend config and returns possible values for unfilled config parameters.
-        """
-        pass
-
-    @abstractmethod
-    def create_backend(
-        self, project: ProjectModel, config: AnyConfigInfoWithCreds
-    ) -> BackendModel:
-        """
-        Creates BackendModel given backend config and creds.
-        It may perform backend initialization, create
-        cloud resources such as networks and managed identites, and
-        save additional configuration parameters.
-        """
-        pass
-
-    @abstractmethod
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyConfigInfo:
-        """
-        Constructs backend's ConfigInfo 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.
-        """
-        pass
-
-    @abstractmethod
-    def get_backend(self, model: BackendModel) -> Backend:
-        """
-        Returns Backend instance from config and creds stored in `model`.
-        """
-        pass
-
-
-def raise_invalid_credentials_error(
-    fields: Optional[List[List[str]]] = None, details: Optional[Any] = None
-):
-    msg = BackendInvalidCredentialsError.msg
-    if details:
-        msg += f": {details}"
-    raise BackendInvalidCredentialsError(fields=fields, msg=msg)

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

@@ -1,87 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.cudo import CudoBackend, CudoConfig, api_client
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.cudo import (
-    CudoConfigInfo,
-    CudoConfigInfoWithCreds,
-    CudoConfigInfoWithCredsPartial,
-    CudoConfigValues,
-    CudoCreds,
-    CudoStoredConfig,
-)
-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 = [
-    "no-luster-1",
-    "se-smedjebacken-1",
-    "gb-london-1",
-    "se-stockholm-1",
-    "us-newyork-1",
-    "us-santaclara-1",
-]
-
-DEFAULT_REGION = "no-luster-1"
-
-
-class CudoConfigurator(Configurator):
-    TYPE: BackendType = BackendType.CUDO
-
-    def get_config_values(self, config: CudoConfigInfoWithCredsPartial) -> CudoConfigValues:
-        config_values = CudoConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_cudo_api_key(config.creds.api_key)
-        config_values.regions = self._get_regions_element(
-            selected=config.regions or [DEFAULT_REGION]
-        )
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: CudoConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=CudoStoredConfig(**CudoConfigInfo.__response__.parse_obj(config).dict()).json(),
-            auth=DecryptedString(plaintext=CudoCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> CudoConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return CudoConfigInfoWithCreds.__response__.parse_obj(config)
-        return CudoConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> Backend:
-        config = self._get_backend_config(model)
-        return CudoBackend(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) -> CudoConfig:
-        return CudoConfig.__response__(
-            **json.loads(model.config),
-            creds=CudoCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_cudo_api_key(self, api_key: str):
-        client = api_client.CudoApiClient(api_key=api_key)
-        if not client.validate_api_key():
-            raise_invalid_credentials_error(fields=[["creds", "api_key"]])

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

@@ -1,79 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.datacrunch import DataCrunchBackend
-from dstack._internal.core.backends.datacrunch.config import DataCrunchConfig
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.datacrunch import (
-    AnyDataCrunchConfigInfo,
-    DataCrunchConfigInfo,
-    DataCrunchConfigInfoWithCreds,
-    DataCrunchConfigInfoWithCredsPartial,
-    DataCrunchConfigValues,
-    DataCrunchCreds,
-    DataCrunchStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import Configurator
-
-REGIONS = [
-    "FIN-01",
-    "ICE-01",
-]
-
-DEFAULT_REGION = "FIN-01"
-
-
-class DataCrunchConfigurator(Configurator):
-    TYPE: BackendType = BackendType.DATACRUNCH
-
-    def get_config_values(
-        self, config: DataCrunchConfigInfoWithCredsPartial
-    ) -> DataCrunchConfigValues:
-        config_values = DataCrunchConfigValues()
-        if config.creds is None:
-            return config_values
-        config_values.regions = self._get_regions_element(
-            selected=config.regions or [DEFAULT_REGION]
-        )
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: DataCrunchConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=DataCrunchStoredConfig(
-                **DataCrunchConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=DataCrunchCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyDataCrunchConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return DataCrunchConfigInfoWithCreds.__response__.parse_obj(config)
-        return DataCrunchConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> DataCrunchBackend:
-        config = self._get_backend_config(model)
-        return DataCrunchBackend(config=config)
-
-    def _get_backend_config(self, model: BackendModel) -> DataCrunchConfig:
-        return DataCrunchConfig.__response__(
-            **json.loads(model.config),
-            creds=DataCrunchCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    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/kubernetes.py

@@ -1,63 +0,0 @@
-from typing import List
-
-from dstack._internal.core.backends.kubernetes import KubernetesBackend
-from dstack._internal.core.backends.kubernetes.config import KubernetesConfig
-from dstack._internal.core.backends.kubernetes.utils import get_api_from_config_data
-from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.backends.kubernetes import (
-    AnyKubernetesConfigInfo,
-    KubernetesConfigInfo,
-    KubernetesConfigInfoWithCreds,
-    KubernetesConfigInfoWithCredsPartial,
-    KubernetesConfigValues,
-    KubernetesStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import (
-    Configurator,
-    raise_invalid_credentials_error,
-)
-from dstack._internal.utils.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class KubernetesConfigurator(Configurator):
-    TYPE: BackendType = BackendType.KUBERNETES
-
-    def get_default_configs(self) -> List[KubernetesConfigInfoWithCreds]:
-        # TODO: automatically pick up kubernetes config
-        return []
-
-    def get_config_values(
-        self, config: KubernetesConfigInfoWithCredsPartial
-    ) -> KubernetesConfigValues:
-        try:
-            api = get_api_from_config_data(config.kubeconfig.data)
-            api.list_node()
-        except Exception as e:
-            logger.debug("Invalid kubeconfig: %s", str(e))
-            raise_invalid_credentials_error(fields=[["kubeconfig"]])
-        return KubernetesConfigValues()
-
-    def create_backend(
-        self, project: ProjectModel, config: KubernetesConfigInfoWithCreds
-    ) -> BackendModel:
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=KubernetesStoredConfig.__response__.parse_obj(config).json(),
-            auth=DecryptedString(plaintext=""),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyKubernetesConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return KubernetesConfigInfoWithCreds.__response__.parse_obj(config)
-        return KubernetesConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> KubernetesBackend:
-        return KubernetesBackend(self._get_backend_config(model))
-
-    def _get_backend_config(self, model: BackendModel) -> KubernetesConfig:
-        return KubernetesConfig.__response__.parse_raw(model.config)

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

@@ -1,98 +0,0 @@
-import json
-from typing import List
-
-from dstack._internal.core.backends.lambdalabs import LambdaBackend, api_client
-from dstack._internal.core.backends.lambdalabs.config import LambdaConfig
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.lambdalabs import (
-    AnyLambdaConfigInfo,
-    LambdaConfigInfo,
-    LambdaConfigInfoWithCreds,
-    LambdaConfigInfoWithCredsPartial,
-    LambdaConfigValues,
-    LambdaCreds,
-    LambdaStoredConfig,
-)
-from dstack._internal.server.models import BackendModel, DecryptedString, ProjectModel
-from dstack._internal.server.services.backends.configurators.base import (
-    Configurator,
-    raise_invalid_credentials_error,
-)
-
-REGIONS = [
-    "us-south-1",
-    "us-south-2",
-    "us-south-3",
-    "us-west-2",
-    "us-west-1",
-    "us-midwest-1",
-    "us-west-3",
-    "us-east-1",
-    "us-east-2",
-    "europe-central-1",
-    "asia-south-1",
-    "me-west-1",
-    "asia-northeast-1",
-    "asia-northeast-2",
-]
-
-DEFAULT_REGION = "us-east-1"
-
-
-class LambdaConfigurator(Configurator):
-    TYPE: BackendType = BackendType.LAMBDA
-
-    def get_config_values(self, config: LambdaConfigInfoWithCredsPartial) -> LambdaConfigValues:
-        config_values = LambdaConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_lambda_api_key(config.creds.api_key)
-        config_values.regions = self._get_regions_element(
-            selected=config.regions or [DEFAULT_REGION]
-        )
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: LambdaConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=LambdaStoredConfig(
-                **LambdaConfigInfo.__response__.parse_obj(config).dict()
-            ).json(),
-            auth=DecryptedString(plaintext=LambdaCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> AnyLambdaConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return LambdaConfigInfoWithCreds.__response__.parse_obj(config)
-        return LambdaConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> LambdaBackend:
-        config = self._get_backend_config(model)
-        return LambdaBackend(config=config)
-
-    def _get_backend_config(self, model: BackendModel) -> LambdaConfig:
-        return LambdaConfig.__response__(
-            **json.loads(model.config),
-            creds=LambdaCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_lambda_api_key(self, api_key: str):
-        client = api_client.LambdaAPIClient(api_key=api_key)
-        if not client.validate_api_key():
-            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/nebius.py

@@ -1,85 +0,0 @@
-import json
-from typing import List
-
-import requests
-
-import dstack._internal.core.backends.nebius.api_client as api_client
-from dstack._internal.core.backends.base import Backend
-from dstack._internal.core.backends.nebius import NebiusBackend
-from dstack._internal.core.backends.nebius.config import NebiusConfig
-from dstack._internal.core.models.backends.base import (
-    BackendType,
-    ConfigElementValue,
-    ConfigMultiElement,
-)
-from dstack._internal.core.models.backends.nebius import (
-    NebiusConfigInfo,
-    NebiusConfigInfoWithCreds,
-    NebiusConfigInfoWithCredsPartial,
-    NebiusConfigValues,
-    NebiusCreds,
-    NebiusStoredConfig,
-)
-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 = ["eu-north1-c"]
-
-
-class NebiusConfigurator(Configurator):
-    TYPE: BackendType = BackendType.NEBIUS
-
-    def get_config_values(self, config: NebiusConfigInfoWithCredsPartial) -> NebiusConfigValues:
-        config_values = NebiusConfigValues()
-        if config.creds is None:
-            return config_values
-        self._validate_nebius_creds(config.creds)
-        # TODO(egor-s) cloud_id
-        # TODO(egor-s) folder_id
-        # TODO(egor-s) network_id
-        config_values.regions = self._get_regions_element(selected=config.regions or [])
-        return config_values
-
-    def create_backend(
-        self, project: ProjectModel, config: NebiusConfigInfoWithCreds
-    ) -> BackendModel:
-        if config.regions is None:
-            config.regions = REGIONS
-        self._validate_nebius_creds(config.creds)
-        return BackendModel(
-            project_id=project.id,
-            type=self.TYPE.value,
-            config=NebiusStoredConfig.__response__.parse_obj(config).json(),
-            auth=DecryptedString(plaintext=NebiusCreds.parse_obj(config.creds).json()),
-        )
-
-    def get_config_info(self, model: BackendModel, include_creds: bool) -> NebiusConfigInfo:
-        config = self._get_backend_config(model)
-        if include_creds:
-            return NebiusConfigInfoWithCreds.__response__.parse_obj(config)
-        return NebiusConfigInfo.__response__.parse_obj(config)
-
-    def get_backend(self, model: BackendModel) -> Backend:
-        config = self._get_backend_config(model)
-        return NebiusBackend(config=config)
-
-    def _get_backend_config(self, model: BackendModel) -> NebiusConfig:
-        return NebiusConfig.__response__(
-            **json.loads(model.config),
-            creds=NebiusCreds.parse_raw(model.auth.get_plaintext_or_error()),
-        )
-
-    def _validate_nebius_creds(self, creds: NebiusCreds):
-        try:
-            api_client.NebiusAPIClient(json.loads(creds.data)).get_token()
-        except requests.HTTPError:
-            raise_invalid_credentials_error(fields=[["creds", "data"]])
-
-    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