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

dstack/api/_public/runs.py

@@ -16,23 +16,21 @@ import dstack.api as api
 from dstack._internal.core.consts import DSTACK_RUNNER_HTTP_PORT, DSTACK_RUNNER_SSH_PORT
 from dstack._internal.core.errors import ClientError, ConfigurationError, ResourceNotExistsError
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import ApplyAction
 from dstack._internal.core.models.configurations import AnyRunConfiguration, PortMapping
-from dstack._internal.core.models.pools import Instance
 from dstack._internal.core.models.profiles import (
     CreationPolicy,
     Profile,
     ProfileRetryPolicy,
     SpotPolicy,
     TerminationPolicy,
+    UtilizationPolicy,
 )
 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 ResourcesSpec
 from dstack._internal.core.models.runs import (
     Job,
     JobSpec,
-    PoolInstanceOffers,
-    Requirements,
     RunPlan,
     RunSpec,
     RunStatus,
@@ -190,14 +188,14 @@ class Run(ABC):
         job_num: int = 0,
     ) -> Iterable[bytes]:
         """
-        Iterate through run's log messages
+        Iterate through run's log messages.
 
         Args:
-            start_time: minimal log timestamp
-            diagnose: return runner logs if `True`
+            start_time: Minimal log timestamp.
+            diagnose: Return runner logs if `True`.
 
         Yields:
-            log messages
+            Log messages.
         """
         if diagnose is False and self._ssh_attach is not None:
             yield from self._attached_logs()
@@ -227,17 +225,17 @@ class Run(ABC):
 
     def refresh(self):
         """
-        Get up-to-date run info
+        Get up-to-date run info.
         """
         self._run = self._api_client.runs.get(self._project, self._run.run_spec.run_name)
         logger.debug("Refreshed run %s: %s", self.name, self.status)
 
     def stop(self, abort: bool = False):
         """
-        Terminate the instance and detach
+        Terminate the instance and detach.
 
         Args:
-            abort: gracefully stop the run if `False`
+            abort: Gracefully stop the run if `False`.
         """
         self._api_client.runs.stop(self._project, [self.name], abort)
         logger.debug("%s run %s", "Aborted" if abort else "Stopped", self.name)
@@ -255,7 +253,7 @@ class Run(ABC):
         Establish an SSH tunnel to the instance and update SSH config
 
         Args:
-            ssh_identity_file: SSH keypair to access instances
+            ssh_identity_file: SSH keypair to access instances.
 
         Raises:
             dstack.api.PortUsedError: If ports are in use or the run is attached by another process.
@@ -392,7 +390,7 @@ class ServiceModel:
 
 class RunCollection:
     """
-    Operations with runs
+    Operations with runs.
     """
 
     def __init__(
@@ -405,6 +403,122 @@ class RunCollection:
         self._project = project
         self._client = client
 
+    def get_run_plan(
+        self,
+        configuration: AnyRunConfiguration,
+        repo: Optional[Repo] = None,
+        profile: Optional[Profile] = None,
+        configuration_path: Optional[str] = None,
+    ) -> RunPlan:
+        """
+        Get a run plan.
+        Use this method to see the run plan before applying the cofiguration.
+
+        Args:
+            configuration (Union[Task, Service, DevEnvironment]): The run configuration.
+            repo (Union[LocalRepo, RemoteRepo, VirtualRepo, None]):
+                The repo to use for the run. Pass `None` if repo is not needed.
+            profile: The profile to use for the run.
+            configuration_path: The path to the configuration file. Omit if the configuration is not loaded from a file.
+
+        Returns:
+            Run plan.
+        """
+        if repo is None:
+            repo = VirtualRepo()
+
+        run_spec = RunSpec(
+            run_name=configuration.name,
+            repo_id=repo.repo_id,
+            repo_data=repo.run_repo_data,
+            repo_code_hash=None,  # `apply_plan` will fill it
+            working_dir=configuration.working_dir,
+            configuration_path=configuration_path,
+            configuration=configuration,
+            profile=profile,
+            ssh_key_pub=Path(self._client.ssh_identity_file + ".pub").read_text().strip(),
+        )
+        logger.debug("Getting run plan")
+        run_plan = self._api_client.runs.get_plan(self._project, run_spec)
+        return run_plan
+
+    def apply_plan(
+        self,
+        run_plan: RunPlan,
+        repo: Optional[Repo] = None,
+        reserve_ports: bool = True,
+    ) -> Run:
+        """
+        Apply the run plan.
+        Use this method to apply run plans returned by `get_run_plan`.
+
+        Args:
+            run_plan: The result of `get_run_plan` call.
+            repo (Union[LocalRepo, RemoteRepo, VirtualRepo, None]):
+                The repo to use for the run. Should be the same repo that is passed to `get_run_plan`.
+            reserve_ports: Reserve local ports before applying. Use if you'll attach to the run.
+
+        Returns:
+            Submitted run.
+        """
+        ports_lock = None
+        if reserve_ports:
+            # TODO handle multiple jobs
+            ports_lock = _reserve_ports(run_plan.job_plans[0].job_spec)
+
+        if repo is None:
+            repo = VirtualRepo()
+        else:
+            # Do not upload the diff without a repo (a default virtual repo)
+            # since upload_code() requires a repo to be initialized.
+            with tempfile.TemporaryFile("w+b") as fp:
+                run_plan.run_spec.repo_code_hash = repo.write_code_file(fp)
+                fp.seek(0)
+                self._api_client.repos.upload_code(
+                    project_name=self._project,
+                    repo_id=repo.repo_id,
+                    code_hash=run_plan.run_spec.repo_code_hash,
+                    fp=fp,
+                )
+        run = self._api_client.runs.apply_plan(self._project, run_plan)
+        return self._model_to_submitted_run(run, ports_lock)
+
+    def apply_configuration(
+        self,
+        configuration: AnyRunConfiguration,
+        repo: Optional[Repo] = None,
+        profile: Optional[Profile] = None,
+        configuration_path: Optional[str] = None,
+        reserve_ports: bool = True,
+    ) -> Run:
+        """
+        Apply the run configuration.
+        Use this method to apply configurations without getting a run plan first.
+
+        Args:
+            configuration (Union[Task, Service, DevEnvironment]): The run configuration.
+            repo (Union[LocalRepo, RemoteRepo, VirtualRepo, None]):
+                The repo to use for the run. Pass `None` if repo is not needed.
+            profile: The profile to use for the run.
+            configuration_path: The path to the configuration file. Omit if the configuration is not loaded from a file.
+            reserve_ports: Reserve local ports before applying. Use if you'll attach to the run.
+
+        Returns:
+            Submitted run.
+        """
+        run_plan = self.get_run_plan(
+            configuration=configuration,
+            repo=repo,
+            profile=profile,
+            configuration_path=configuration_path,
+        )
+        run = self.apply_plan(
+            run_plan=run_plan,
+            repo=repo,
+            reserve_ports=reserve_ports,
+        )
+        return run
+
     def submit(
         self,
         configuration: AnyRunConfiguration,
@@ -422,31 +536,30 @@ class RunCollection:
         run_name: Optional[str] = None,
         reserve_ports: bool = True,
     ) -> Run:
-        """
-        Submit a run
+        # """
+        # Submit a run
 
-        Args:
-            configuration (Union[Task, Service]): A run configuration.
-            configuration_path: The path to the configuration file, relative to the root directory of the repo.
-            repo (Union[LocalRepo, RemoteRepo, VirtualRepo]): A repo to mount to the run.
-            backends: A list of allowed backend for provisioning.
-            regions: A list of cloud regions for provisioning.
-            resources: The requirements to run the configuration. Overrides the configuration's resources.
-            spot_policy: A spot policy for provisioning.
-            retry_policy (RetryPolicy): A retry policy.
-            max_duration: The max instance running duration in seconds.
-            max_price: The max instance price in dollars per hour for provisioning.
-            working_dir: A working directory relative to the repo root directory
-            run_name: A desired name of the run. Must be unique in the project. If not specified, a random name is assigned.
-            reserve_ports: Whether local ports should be reserved in advance.
+        # Args:
+        #     configuration (Union[Task, Service]): A run configuration.
+        #     configuration_path: The path to the configuration file, relative to the root directory of the repo.
+        #     repo (Union[LocalRepo, RemoteRepo, VirtualRepo]): A repo to mount to the run.
+        #     backends: A list of allowed backend for provisioning.
+        #     regions: A list of cloud regions for provisioning.
+        #     resources: The requirements to run the configuration. Overrides the configuration's resources.
+        #     spot_policy: A spot policy for provisioning.
+        #     retry_policy (RetryPolicy): A retry policy.
+        #     max_duration: The max instance running duration in seconds.
+        #     max_price: The max instance price in dollars per hour for provisioning.
+        #     working_dir: A working directory relative to the repo root directory
+        #     run_name: A desired name of the run. Must be unique in the project. If not specified, a random name is assigned.
+        #     reserve_ports: Whether local ports should be reserved in advance.
 
-        Returns:
-            submitted run
-        """
+        # Returns:
+        #     Submitted run.
+        # """
+        logger.warning("The submit() method is deprecated in favor of apply_configuration().")
         if repo is None:
-            repo = configuration.get_repo()
-            if repo is None:
-                raise ConfigurationError("Repo is required for this type of configuration")
+            repo = VirtualRepo()
             # TODO: Add Git credentials to RemoteRepo and if they are set, pass them here to RepoCollection.init
             self._client.repos.init(repo)
 
@@ -467,24 +580,21 @@ class RunCollection:
         )
         return self.exec_plan(run_plan, repo, reserve_ports=reserve_ports)
 
-    def get_offers(self, profile: Profile, requirements: Requirements) -> PoolInstanceOffers:
-        return self._api_client.runs.get_offers(self._project, profile, requirements)
-
-    def create_instance(self, profile: Profile, requirements: Requirements) -> Instance:
-        return self._api_client.runs.create_instance(self._project, profile, requirements)
-
-    # TODO: [Andrey] I guess we need to drop profile-related fields (currently retry is not reflected there)
+    # Deprecated in favor of get_run_plan()
     def get_plan(
         self,
         configuration: AnyRunConfiguration,
         repo: Optional[Repo] = None,
         configuration_path: Optional[str] = None,
+        # Unused profile args are deprecated and removed but
+        # kept for signature backward compatibility.
         backends: Optional[List[BackendType]] = None,
         regions: Optional[List[str]] = None,
         instance_types: Optional[List[str]] = None,
         resources: Optional[ResourcesSpec] = None,
         spot_policy: Optional[SpotPolicy] = None,
         retry_policy: Optional[ProfileRetryPolicy] = None,
+        utilization_policy: Optional[UtilizationPolicy] = None,
         max_duration: Optional[Union[int, str]] = None,
         max_price: Optional[float] = None,
         working_dir: Optional[str] = None,
@@ -504,11 +614,9 @@ class RunCollection:
         # Returns:
         #     run plan
         # """
-
+        logger.warning("The get_plan() method is deprecated in favor of get_run_plan().")
         if repo is None:
-            repo = configuration.get_repo()
-            if repo is None:
-                raise ConfigurationError("Repo is required for this type of configuration")
+            repo = VirtualRepo()
 
         if working_dir is None:
             working_dir = "."
@@ -534,16 +642,12 @@ class RunCollection:
             reservation=reservation,
             spot_policy=spot_policy,
             retry=None,
-            retry_policy=retry_policy,
+            utilization_policy=utilization_policy,
             max_duration=max_duration,
             stop_duration=stop_duration,
             max_price=max_price,
-            pool_name=pool_name,
-            instance_name=instance_name,
             creation_policy=creation_policy,
             idle_duration=idle_duration,
-            termination_policy=termination_policy,
-            termination_idle_time=termination_policy_idle,
         )
         run_spec = RunSpec(
             run_name=run_name,
@@ -574,45 +678,28 @@ class RunCollection:
         reserve_ports: bool = True,
     ) -> Run:
         # """
-        # Execute run plan
-        #
+        # Execute the run plan.
+
         # Args:
-        #     run_plan: result of `get_plan` call
-        #     repo: repo to use for the run
-        #     reserve_ports: reserve local ports before submit
-        #
+        #     run_plan: Result of `get_run_plan` call.
+        #     repo: Repo to use for the run.
+        #     reserve_ports: Reserve local ports before submit.
+
         # Returns:
-        #     submitted run
+        #     Submitted run.
         # """
-        ports_lock = None
-        if reserve_ports:
-            # TODO handle multiple jobs
-            ports_lock = _reserve_ports(run_plan.job_plans[0].job_spec)
-
-        with tempfile.TemporaryFile("w+b") as fp:
-            run_plan.run_spec.repo_code_hash = repo.write_code_file(fp)
-            fp.seek(0)
-            self._api_client.repos.upload_code(
-                self._project, repo.repo_id, run_plan.run_spec.repo_code_hash, fp
-            )
-        # Calling submit when action is CREATE since apply_plan is not backward-compatible.
-        # Otherwise, apply_plan can replace submit, i.e. it creates the run if it does not exist.
-        # TODO: Remove in 0.19
-        if run_plan.action == ApplyAction.UPDATE:
-            run = self._api_client.runs.apply_plan(self._project, run_plan)
-        else:
-            run = self._api_client.runs.submit(self._project, run_plan.run_spec)
-        return self._model_to_submitted_run(run, ports_lock)
+        logger.warning("The exec_plan() method is deprecated in favor of apply_plan().")
+        return self.apply_plan(run_plan=run_plan, repo=repo, reserve_ports=reserve_ports)
 
     def list(self, all: bool = False) -> List[Run]:
         """
-        List runs
+        List runs.
 
         Args:
-            all: show all runs (active and finished) if `True`
+            all: Show all runs (active and finished) if `True`.
 
         Returns:
-            list of runs
+            List of runs.
         """
         # Return only one page of latest runs (<=100). Returning all the pages may be costly.
         # TODO: Consider introducing `since` filter with a reasonable default.
@@ -631,13 +718,13 @@ class RunCollection:
 
     def get(self, run_name: str) -> Optional[Run]:
         """
-        Get run by run name
+        Get run by run name.
 
         Args:
-            run_name: run name
+            run_name: Run name.
 
         Returns:
-            The run or `None` if not found
+            The run or `None` if not found.
         """
         try:
             run = self._api_client.runs.get(self._project, run_name)

dstack/api/server/__init__.py

@@ -13,7 +13,6 @@ from dstack.api.server._fleets import FleetsAPIClient
 from dstack.api.server._gateways import GatewaysAPIClient
 from dstack.api.server._logs import LogsAPIClient
 from dstack.api.server._metrics import MetricsAPIClient
-from dstack.api.server._pools import PoolAPIClient
 from dstack.api.server._projects import ProjectsAPIClient
 from dstack.api.server._repos import ReposAPIClient
 from dstack.api.server._runs import RunsAPIClient
@@ -30,23 +29,26 @@ _RETRY_INTERVAL = 1
 
 class APIClient:
     """
-    Low-level API client for interacting with dstack server. Implements all API endpoints
+    Low-level API client for interacting with the `dstack` server.
+    Supports all HTTP API endpoints.
 
     Attributes:
         users: operations with users
         projects: operations with projects
         backends: operations with backends
+        fleets: operations with fleets
         runs: operations with runs
+        metrics: operations with metrics
         logs: operations with logs
         gateways: operations with gateways
-        pools: operations with pools
+        volumes: operations with volumes
     """
 
     def __init__(self, base_url: str, token: str):
         """
         Args:
-            base_url: API endpoints prefix, e.g. `http://127.0.0.1:3000/`
-            token: API token
+            base_url: The API endpoints prefix, e.g. `http://127.0.0.1:3000/`.
+            token: The API token.
         """
         self._base_url = base_url.rstrip("/")
         self._token = token
@@ -72,6 +74,10 @@ class APIClient:
     def backends(self) -> BackendsAPIClient:
         return BackendsAPIClient(self._request)
 
+    @property
+    def fleets(self) -> FleetsAPIClient:
+        return FleetsAPIClient(self._request)
+
     @property
     def repos(self) -> ReposAPIClient:
         return ReposAPIClient(self._request)
@@ -96,14 +102,6 @@ class APIClient:
     def gateways(self) -> GatewaysAPIClient:
         return GatewaysAPIClient(self._request)
 
-    @property
-    def pool(self) -> PoolAPIClient:
-        return PoolAPIClient(self._request)
-
-    @property
-    def fleets(self) -> FleetsAPIClient:
-        return FleetsAPIClient(self._request)
-
     @property
     def volumes(self) -> VolumesAPIClient:
         return VolumesAPIClient(self._request)

dstack/api/server/_backends.py

@@ -2,10 +2,8 @@ from typing import List
 
 from pydantic import parse_obj_as
 
-from dstack._internal.core.models.backends import (
-    AnyConfigInfoWithCreds,
-    AnyConfigInfoWithCredsPartial,
-    AnyConfigValues,
+from dstack._internal.core.backends.models import (
+    AnyBackendConfigWithCreds,
 )
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.server.schemas.backends import DeleteBackendsRequest
@@ -17,26 +15,24 @@ class BackendsAPIClient(APIClientGroup):
         resp = self._request("/api/backends/list_types")
         return parse_obj_as(List[BackendType], resp.json())
 
-    def config_values(self, config: AnyConfigInfoWithCredsPartial) -> AnyConfigValues:
-        resp = self._request("/api/backends/config_values", body=config.json())
-        return parse_obj_as(AnyConfigValues, resp.json())
-
     def create(
-        self, project_name: str, config: AnyConfigInfoWithCreds
-    ) -> AnyConfigInfoWithCredsPartial:
+        self, project_name: str, config: AnyBackendConfigWithCreds
+    ) -> AnyBackendConfigWithCreds:
         resp = self._request(f"/api/project/{project_name}/backends/create", body=config.json())
-        return parse_obj_as(AnyConfigInfoWithCredsPartial, resp.json())
+        return parse_obj_as(AnyBackendConfigWithCreds, resp.json())
 
     def update(
-        self, project_name: str, config: AnyConfigInfoWithCreds
-    ) -> AnyConfigInfoWithCredsPartial:
+        self, project_name: str, config: AnyBackendConfigWithCreds
+    ) -> AnyBackendConfigWithCreds:
         resp = self._request(f"/api/project/{project_name}/backends/update", body=config.json())
-        return parse_obj_as(AnyConfigInfoWithCredsPartial, resp.json())
+        return parse_obj_as(AnyBackendConfigWithCreds, resp.json())
 
     def delete(self, project_name: str, backends_names: List[BackendType]):
         body = DeleteBackendsRequest(backends_names=backends_names)
         self._request(f"/api/project/{project_name}/backends/delete", body=body.json())
 
-    def config_info(self, project_name: str, backend_name: BackendType) -> AnyConfigInfoWithCreds:
+    def config_info(
+        self, project_name: str, backend_name: BackendType
+    ) -> AnyBackendConfigWithCreds:
         resp = self._request(f"/api/project/{project_name}/backends/{backend_name}/config_info")
-        return parse_obj_as(AnyConfigInfoWithCreds, resp.json())
+        return parse_obj_as(AnyBackendConfigWithCreds, resp.json())

dstack/api/server/_fleets.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 from pydantic import parse_obj_as
 
@@ -22,7 +22,7 @@ class FleetsAPIClient(APIClientGroup):
         body = GetFleetRequest(name=name)
         resp = self._request(
             f"/api/project/{project_name}/fleets/get",
-            body=body.json(exclude={"id"}),  # `id` is not supported in pre-0.18.36 servers
+            body=body.json(),
         )
         return parse_obj_as(Fleet.__response__, resp.json())
 
@@ -55,60 +55,20 @@ class FleetsAPIClient(APIClientGroup):
         self._request(f"/api/project/{project_name}/fleets/delete_instances", body=body.json())
 
 
-_ExcludeDict = dict[str, Union[bool, set[str], "_ExcludeDict"]]
-
-
-def _get_fleet_spec_excludes(fleet_spec: FleetSpec) -> Optional[_ExcludeDict]:
-    spec_excludes: _ExcludeDict = {}
-    configuration_excludes: _ExcludeDict = {}
+def _get_fleet_spec_excludes(fleet_spec: FleetSpec) -> Optional[Dict]:
+    """
+    Returns `fleet_spec` exclude mapping to exclude certain fields from the request.
+    Use this method to exclude new fields when they are not set to keep
+    clients backward-compatibility with older servers.
+    """
+    spec_excludes: Dict[str, Any] = {}
+    configuration_excludes: Dict[str, Any] = {}
     profile_excludes: set[str] = set()
-    ssh_config_excludes: _ExcludeDict = {}
-    ssh_hosts_excludes: set[str] = set()
-
-    # TODO: Can be removed in 0.19
-    if fleet_spec.configuration_path is None:
-        spec_excludes["configuration_path"] = True
-    if fleet_spec.configuration.ssh_config is not None:
-        if fleet_spec.configuration.ssh_config.proxy_jump is None:
-            ssh_config_excludes["proxy_jump"] = True
-        if all(
-            isinstance(h, str) or h.proxy_jump is None
-            for h in fleet_spec.configuration.ssh_config.hosts
-        ):
-            ssh_hosts_excludes.add("proxy_jump")
-        if all(
-            isinstance(h, str) or h.internal_ip is None
-            for h in fleet_spec.configuration.ssh_config.hosts
-        ):
-            ssh_hosts_excludes.add("internal_ip")
-        if all(
-            isinstance(h, str) or h.blocks == 1 for h in fleet_spec.configuration.ssh_config.hosts
-        ):
-            ssh_hosts_excludes.add("blocks")
-    # client >= 0.18.30 / server <= 0.18.29 compatibility tweak
-    if fleet_spec.configuration.reservation is None:
-        configuration_excludes["reservation"] = True
-    if fleet_spec.profile is not None and fleet_spec.profile.reservation is None:
-        profile_excludes.add("reservation")
-    if fleet_spec.configuration.idle_duration is None:
-        configuration_excludes["idle_duration"] = True
-    if fleet_spec.profile is not None and fleet_spec.profile.idle_duration is None:
-        profile_excludes.add("idle_duration")
-    # client >= 0.18.38 / server <= 0.18.37 compatibility tweak
-    if fleet_spec.profile is not None and fleet_spec.profile.stop_duration is None:
-        profile_excludes.add("stop_duration")
-    # client >= 0.18.41 / server <= 0.18.40 compatibility tweak
-    if fleet_spec.configuration.availability_zones is None:
-        configuration_excludes["availability_zones"] = True
-    if fleet_spec.profile is not None and fleet_spec.profile.availability_zones is None:
-        profile_excludes.add("availability_zones")
-    if fleet_spec.configuration.blocks == 1:
-        configuration_excludes["blocks"] = True
-
-    if ssh_hosts_excludes:
-        ssh_config_excludes["hosts"] = {"__all__": ssh_hosts_excludes}
-    if ssh_config_excludes:
-        configuration_excludes["ssh_config"] = ssh_config_excludes
+    # Fields can be excluded like this:
+    # if fleet_spec.configuration.availability_zones is None:
+    #     configuration_excludes["availability_zones"] = True
+    # if fleet_spec.profile is not None and fleet_spec.profile.availability_zones is None:
+    #     profile_excludes.add("availability_zones")
     if configuration_excludes:
         spec_excludes["configuration"] = configuration_excludes
     if profile_excludes:

dstack/api/server/_gateways.py

@@ -1,8 +1,7 @@
-from typing import List, Optional
+from typing import List
 
 from pydantic import parse_obj_as
 
-from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.gateways import Gateway, GatewayConfiguration
 from dstack._internal.server.schemas.gateways import (
     CreateGatewayRequest,
@@ -24,22 +23,12 @@ class GatewaysAPIClient(APIClientGroup):
         resp = self._request(f"/api/project/{project_name}/gateways/get", body=body.json())
         return parse_obj_as(Gateway.__response__, resp.json())
 
-    # gateway_name, backend_type, region are left for backward-compatibility with 0.18.x
-    # TODO: Remove in 0.19
     def create(
         self,
         project_name: str,
-        gateway_name: Optional[str] = None,
-        backend_type: Optional[BackendType] = None,
-        region: Optional[str] = None,
-        configuration: Optional[GatewayConfiguration] = None,
+        configuration: GatewayConfiguration,
     ) -> Gateway:
-        body = CreateGatewayRequest(
-            name=gateway_name,
-            backend_type=backend_type,
-            region=region,
-            configuration=configuration,
-        )
+        body = CreateGatewayRequest(configuration=configuration)
         resp = self._request(f"/api/project/{project_name}/gateways/create", body=body.json())
         return parse_obj_as(Gateway.__response__, resp.json())
 

dstack/api/server/_repos.py

@@ -6,7 +6,6 @@ from dstack._internal.core.models.repos import AnyRepoInfo, RemoteRepoCreds, Rep
 from dstack._internal.server.schemas.repos import (
     DeleteReposRequest,
     GetRepoRequest,
-    RemoteRepoCredsDto,
     SaveRepoCredsRequest,
 )
 from dstack.api.server._group import APIClientGroup
@@ -32,9 +31,7 @@ class ReposAPIClient(APIClientGroup):
         body = SaveRepoCredsRequest(
             repo_id=repo_id,
             repo_info=repo_info,
-            repo_creds=RemoteRepoCredsDto.from_remote_repo_creds(repo_creds)
-            if repo_creds
-            else None,
+            repo_creds=repo_creds,
         )
         self._request(f"/api/project/{project_name}/repos/init", body=body.json())