dstack 0.19.25rc1__py3-none-any.whl → 0.19.27__py3-none-any.whl

dstack/_internal/cli/services/configurators/run.py

@@ -2,8 +2,8 @@ import argparse
 import subprocess
 import sys
 import time
-from pathlib import Path
-from typing import Dict, List, Optional, Set
+from pathlib import Path, PurePosixPath
+from typing import Dict, List, Optional, Set, TypeVar
 
 import gpuhunt
 from pydantic import parse_obj_as
@@ -15,12 +15,13 @@ from dstack._internal.cli.services.configurators.base import (
     BaseApplyConfigurator,
 )
 from dstack._internal.cli.services.profile import apply_profile_args, register_profile_args
-from dstack._internal.cli.services.repos import init_default_virtual_repo
-from dstack._internal.cli.utils.common import (
-    confirm_ask,
-    console,
-    warn,
+from dstack._internal.cli.services.repos import (
+    get_repo_from_dir,
+    init_default_virtual_repo,
+    is_git_repo_url,
+    register_init_repo_args,
 )
+from dstack._internal.cli.utils.common import confirm_ask, console, warn
 from dstack._internal.cli.utils.rich import MultiItemStatus
 from dstack._internal.cli.utils.run import get_runs_table, print_run_plan
 from dstack._internal.core.errors import (
@@ -31,28 +32,37 @@ from dstack._internal.core.errors import (
 )
 from dstack._internal.core.models.common import ApplyAction, RegistryAuth
 from dstack._internal.core.models.configurations import (
+    LEGACY_REPO_DIR,
     AnyRunConfiguration,
     ApplyConfigurationType,
-    BaseRunConfiguration,
-    BaseRunConfigurationWithPorts,
+    ConfigurationWithPortsParams,
     DevEnvironmentConfiguration,
     PortMapping,
     RunConfigurationType,
     ServiceConfiguration,
     TaskConfiguration,
 )
+from dstack._internal.core.models.repos import RepoHeadWithCreds
 from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.core.models.repos.local import LocalRepo
+from dstack._internal.core.models.repos.remote import RemoteRepo, RemoteRepoCreds
 from dstack._internal.core.models.resources import CPUSpec
 from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunSpec, RunStatus
 from dstack._internal.core.services.configs import ConfigManager
 from dstack._internal.core.services.diff import diff_models
+from dstack._internal.core.services.repos import (
+    InvalidRepoCredentialsError,
+    get_repo_creds_and_default_branch,
+    load_repo,
+)
 from dstack._internal.utils.common import local_time
 from dstack._internal.utils.interpolator import InterpolatorError, VariablesInterpolator
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.nested_list import NestedList, NestedListItem
+from dstack._internal.utils.path import is_absolute_posix_path
 from dstack.api._public.repos import get_ssh_keypair
 from dstack.api._public.runs import Run
+from dstack.api.server import APIClient
 from dstack.api.utils import load_profile
 
 _KNOWN_AMD_GPUS = {gpu.name.lower() for gpu in gpuhunt.KNOWN_AMD_GPUS}
@@ -63,56 +73,71 @@ _BIND_ADDRESS_ARG = "bind_address"
 
 logger = get_logger(__name__)
 
+RunConfigurationT = TypeVar("RunConfigurationT", bound=AnyRunConfiguration)
+
 
-class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
+class BaseRunConfigurator(
+    ApplyEnvVarsConfiguratorMixin,
+    BaseApplyConfigurator[RunConfigurationT],
+):
     TYPE: ApplyConfigurationType
 
     def apply_configuration(
         self,
-        conf: BaseRunConfiguration,
+        conf: RunConfigurationT,
         configuration_path: str,
         command_args: argparse.Namespace,
         configurator_args: argparse.Namespace,
         unknown_args: List[str],
-        repo: Optional[Repo] = None,
     ):
+        if configurator_args.repo and configurator_args.no_repo:
+            raise CLIError("Either --repo or --no-repo can be specified")
+
         self.apply_args(conf, configurator_args, unknown_args)
         self.validate_gpu_vendor_and_image(conf)
         self.validate_cpu_arch_and_image(conf)
-        config_manager = ConfigManager()
-        if repo is None:
-            repo_path = Path.cwd()
-            repo_config = config_manager.get_repo_config(repo_path)
-            if repo_config is None:
+
+        working_dir = conf.working_dir
+        if working_dir is None:
+            # Use the default working dir for the image for tasks and services if `commands`
+            # is not set (emulate pre-0.19.27 JobConfigutor logic), otherwise fall back to
+            # `/workflow`.
+            if isinstance(conf, DevEnvironmentConfiguration) or conf.commands:
+                # relative path for compatibility with pre-0.19.27 servers
+                conf.working_dir = "."
                 warn(
-                    "The repo is not initialized. Starting from 0.19.25, repos are optional\n"
-                    "There are three options:\n"
-                    "  - Run `dstack init` to initialize the current directory as a repo\n"
-                    "  - Specify `--repo`\n"
-                    "  - Specify `--no-repo` to not use any repo and supress this warning"
-                    " (this will be the default in the future versions)"
+                    f'The [code]working_dir[/code] is not set — using legacy default [code]"{LEGACY_REPO_DIR}"[/code].'
+                    " Future versions will default to the [code]image[/code]'s working directory."
                 )
-                if not command_args.yes and not confirm_ask("Continue without the repo?"):
-                    console.print("\nExiting...")
-                    return
-                repo = init_default_virtual_repo(self.api)
-            else:
-                # Unlikely, but may raise ConfigurationError if the repo does not exist
-                # on the server side (stale entry in `config.yml`)
-                repo = self.api.repos.load(repo_path)
-                if isinstance(repo, LocalRepo):
-                    warn(
-                        f"{repo.repo_dir} is a local repo.\n"
-                        "Local repos are deprecated since 0.19.25"
-                        " and will be removed soon\n"
-                        "There are two options:\n"
-                        "  - Migrate to `files`: https://dstack.ai/docs/concepts/tasks/#files\n"
-                        "  - Specify `--no-repo` if you don't need the repo at all\n"
-                        "In either case, you can run `dstack init --remove` to remove the repo"
-                        " (only the record about the repo, not its files) and this warning"
-                    )
+        elif not is_absolute_posix_path(working_dir):
+            legacy_working_dir = PurePosixPath(LEGACY_REPO_DIR) / working_dir
+            warn(
+                "[code]working_dir[/code] is relative."
+                f" Using legacy working directory [code]{legacy_working_dir}[/code]\n\n"
+                "Future versions will require absolute path\n"
+                f"To keep using legacy working directory, set"
+                f" [code]working_dir[/code] to [code]{legacy_working_dir}[/code]\n"
+            )
+        else:
+            # relative path for compatibility with pre-0.19.27 servers
+            try:
+                conf.working_dir = str(PurePosixPath(working_dir).relative_to(LEGACY_REPO_DIR))
+            except ValueError:
+                pass
+
+        if conf.repos and conf.repos[0].path is None:
+            warn(
+                "[code]repos[0].path[/code] is not set,"
+                f" using legacy repo path [code]{LEGACY_REPO_DIR}[/code]\n\n"
+                "In a future version the default value will be changed."
+                f" To keep using [code]{LEGACY_REPO_DIR}[/code], explicitly set"
+                f" [code]repos[0].path[/code] to [code]{LEGACY_REPO_DIR}[/code]\n"
+            )
+
+        config_manager = ConfigManager()
+        repo = self.get_repo(conf, configuration_path, configurator_args, config_manager)
         self.api.ssh_identity_file = get_ssh_keypair(
-            command_args.ssh_identity_file,
+            configurator_args.ssh_identity_file,
             config_manager.dstack_key_path,
         )
         profile = load_profile(Path.cwd(), configurator_args.profile)
@@ -204,6 +229,9 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
                         format_date=local_time,
                     )
                 )
+
+                _warn_fleet_autocreated(self.api.client, run)
+
                 console.print(
                     f"\n[code]{run.name}[/] provisioning completed [secondary]({run.status.value})[/]"
                 )
@@ -270,7 +298,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
 
     def delete_configuration(
         self,
-        conf: AnyRunConfiguration,
+        conf: RunConfigurationT,
         configuration_path: str,
         command_args: argparse.Namespace,
     ):
@@ -296,7 +324,14 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         console.print(f"Run [code]{conf.name}[/] deleted")
 
     @classmethod
-    def register_args(cls, parser: argparse.ArgumentParser, default_max_offers: int = 3):
+    def register_args(cls, parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--ssh-identity",
+            metavar="SSH_PRIVATE_KEY",
+            help="The private SSH key path for SSH tunneling",
+            type=Path,
+            dest="ssh_identity_file",
+        )
         configuration_group = parser.add_argument_group(f"{cls.TYPE.value} Options")
         configuration_group.add_argument(
             "-n",
@@ -308,7 +343,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             "--max-offers",
             help="Number of offers to show in the run plan",
             type=int,
-            default=default_max_offers,
+            default=3,
         )
         cls.register_env_args(configuration_group)
         configuration_group.add_argument(
@@ -335,8 +370,32 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
             dest="disk_spec",
         )
         register_profile_args(parser)
+        repo_group = parser.add_argument_group("Repo Options")
+        repo_group.add_argument(
+            "-P",
+            "--repo",
+            help=("The repo to use for the run. Can be a local path or a Git repo URL."),
+            dest="repo",
+        )
+        repo_group.add_argument(
+            "--repo-branch",
+            help="The repo branch to use for the run",
+            dest="repo_branch",
+        )
+        repo_group.add_argument(
+            "--repo-hash",
+            help="The hash of the repo commit to use for the run",
+            dest="repo_hash",
+        )
+        repo_group.add_argument(
+            "--no-repo",
+            help="Do not use any repo for the run",
+            dest="no_repo",
+            action="store_true",
+        )
+        register_init_repo_args(repo_group)
 
-    def apply_args(self, conf: BaseRunConfiguration, args: argparse.Namespace, unknown: List[str]):
+    def apply_args(self, conf: RunConfigurationT, args: argparse.Namespace, unknown: List[str]):
         apply_profile_args(args, conf)
         if args.run_name:
             conf.name = args.run_name
@@ -360,7 +419,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         except InterpolatorError as e:
             raise ConfigurationError(e.args[0])
 
-    def interpolate_env(self, conf: BaseRunConfiguration):
+    def interpolate_env(self, conf: RunConfigurationT):
         env_dict = conf.env.as_dict()
         interpolator = VariablesInterpolator({"env": env_dict}, skip=["secrets"])
         try:
@@ -380,7 +439,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         except InterpolatorError as e:
             raise ConfigurationError(e.args[0])
 
-    def validate_gpu_vendor_and_image(self, conf: BaseRunConfiguration) -> None:
+    def validate_gpu_vendor_and_image(self, conf: RunConfigurationT) -> None:
         """
         Infers and sets `resources.gpu.vendor` if not set, requires `image` if the vendor is AMD.
         """
@@ -441,7 +500,7 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
                 "`image` is required if `resources.gpu.vendor` is `tenstorrent`"
             )
 
-    def validate_cpu_arch_and_image(self, conf: BaseRunConfiguration) -> None:
+    def validate_cpu_arch_and_image(self, conf: RunConfigurationT) -> None:
         """
         Infers `resources.cpu.arch` if not set, requires `image` if the architecture is ARM.
         """
@@ -464,11 +523,159 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         if arch == gpuhunt.CPUArchitecture.ARM and conf.image is None:
             raise ConfigurationError("`image` is required if `resources.cpu.arch` is `arm`")
 
+    def get_repo(
+        self,
+        conf: RunConfigurationT,
+        configuration_path: str,
+        configurator_args: argparse.Namespace,
+        config_manager: ConfigManager,
+    ) -> Repo:
+        if configurator_args.no_repo:
+            return init_default_virtual_repo(api=self.api)
+
+        repo: Optional[Repo] = None
+        repo_head: Optional[RepoHeadWithCreds] = None
+        repo_branch: Optional[str] = configurator_args.repo_branch
+        repo_hash: Optional[str] = configurator_args.repo_hash
+        repo_creds: Optional[RemoteRepoCreds] = None
+        git_identity_file: Optional[str] = configurator_args.git_identity_file
+        git_private_key: Optional[str] = None
+        oauth_token: Optional[str] = configurator_args.gh_token
+        # Should we (re)initialize the repo?
+        # If any Git credentials provided, we reinitialize the repo, as the user may have provided
+        # updated credentials.
+        init = git_identity_file is not None or oauth_token is not None
+
+        url: Optional[str] = None
+        local_path: Optional[Path] = None
+        # dummy value, safe to join with any path
+        root_dir = Path(".")
+        # True if no repo specified, but we found one in `config.yml`
+        legacy_local_path = False
+        if repo_arg := configurator_args.repo:
+            if is_git_repo_url(repo_arg):
+                url = repo_arg
+            else:
+                local_path = Path(repo_arg)
+                # rel paths in `--repo` are resolved relative to the current working dir
+                root_dir = Path.cwd()
+        elif conf.repos:
+            repo_spec = conf.repos[0]
+            if repo_spec.url:
+                url = repo_spec.url
+            elif repo_spec.local_path:
+                local_path = Path(repo_spec.local_path)
+                # rel paths in the conf are resolved relative to the conf's parent dir
+                root_dir = Path(configuration_path).resolve().parent
+            else:
+                assert False, f"should not reach here: {repo_spec}"
+            if repo_branch is None:
+                repo_branch = repo_spec.branch
+            if repo_hash is None:
+                repo_hash = repo_spec.hash
+        else:
+            local_path = Path.cwd()
+            legacy_local_path = True
+        if url:
+            # "master" is a dummy value, we'll fetch the actual default branch later
+            repo = RemoteRepo.from_url(repo_url=url, repo_branch="master")
+            repo_head = self.api.repos.get(repo_id=repo.repo_id, with_creds=True)
+        elif local_path:
+            if legacy_local_path:
+                if repo_config := config_manager.get_repo_config(local_path):
+                    repo = load_repo(repo_config)
+                    repo_head = self.api.repos.get(repo_id=repo.repo_id, with_creds=True)
+                    if repo_head is not None:
+                        warn(
+                            "The repo is not specified but found and will be used in the run\n"
+                            "Future versions will not load repos automatically\n"
+                            "To prepare for future versions and get rid of this warning:\n"
+                            "- If you need the repo in the run, either specify [code]repos[/code]"
+                            " in the configuration or use [code]--repo .[/code]\n"
+                            "- If you don't need the repo in the run, either run"
+                            " [code]dstack init --remove[/code] once (it removes only the record"
+                            " about the repo, the repo files will remain intact)"
+                            " or use [code]--no-repo[/code]"
+                        )
+                    else:
+                        # ignore stale entries in `config.yml`
+                        repo = None
+                        init = False
+            else:
+                original_local_path = local_path
+                local_path = local_path.expanduser()
+                if not local_path.is_absolute():
+                    local_path = (root_dir / local_path).resolve()
+                if not local_path.exists():
+                    raise ConfigurationError(
+                        f"Invalid repo path: {original_local_path} -> {local_path}"
+                    )
+                local: bool = configurator_args.local
+                repo = get_repo_from_dir(local_path, local=local)
+                repo_head = self.api.repos.get(repo_id=repo.repo_id, with_creds=True)
+            if isinstance(repo, RemoteRepo):
+                repo_branch = repo.run_repo_data.repo_branch
+                repo_hash = repo.run_repo_data.repo_hash
+        else:
+            assert False, "should not reach here"
+
+        if repo is None:
+            return init_default_virtual_repo(api=self.api)
+
+        if isinstance(repo, RemoteRepo):
+            assert repo.repo_url is not None
+
+            if repo_head is not None and repo_head.repo_creds is not None:
+                if git_identity_file is None and oauth_token is None:
+                    git_private_key = repo_head.repo_creds.private_key
+                    oauth_token = repo_head.repo_creds.oauth_token
+            else:
+                init = True
+
+            try:
+                repo_creds, default_repo_branch = get_repo_creds_and_default_branch(
+                    repo_url=repo.repo_url,
+                    identity_file=git_identity_file,
+                    private_key=git_private_key,
+                    oauth_token=oauth_token,
+                )
+            except InvalidRepoCredentialsError as e:
+                raise CLIError(*e.args) from e
+
+            if repo_branch is None and repo_hash is None:
+                repo_branch = default_repo_branch
+                if repo_branch is None:
+                    raise CLIError(
+                        "Failed to automatically detect remote repo branch."
+                        " Specify branch or hash."
+                    )
+            repo = RemoteRepo.from_url(
+                repo_url=repo.repo_url, repo_branch=repo_branch, repo_hash=repo_hash
+            )
+
+        if init:
+            self.api.repos.init(
+                repo=repo,
+                git_identity_file=git_identity_file,
+                oauth_token=oauth_token,
+                creds=repo_creds,
+            )
 
-class RunWithPortsConfigurator(BaseRunConfigurator):
+        if isinstance(repo, LocalRepo):
+            warn(
+                f"{repo.repo_dir} is a local repo\n"
+                "Local repos are deprecated since 0.19.25 and will be removed soon\n"
+                "There are two options:\n"
+                "- Migrate to [code]files[/code]: https://dstack.ai/docs/concepts/tasks/#files\n"
+                "- Specify [code]--no-repo[/code] if you don't need the repo at all"
+            )
+
+        return repo
+
+
+class RunWithPortsConfiguratorMixin:
     @classmethod
-    def register_args(cls, parser: argparse.ArgumentParser):
-        super().register_args(parser)
+    def register_ports_args(cls, parser: argparse.ArgumentParser):
         parser.add_argument(
             "-p",
             "--port",
@@ -485,29 +692,42 @@ class RunWithPortsConfigurator(BaseRunConfigurator):
             metavar="HOST",
         )
 
-    def apply_args(
-        self, conf: BaseRunConfigurationWithPorts, args: argparse.Namespace, unknown: List[str]
+    def apply_ports_args(
+        self,
+        conf: ConfigurationWithPortsParams,
+        args: argparse.Namespace,
     ):
-        super().apply_args(conf, args, unknown)
         if args.ports:
             conf.ports = list(_merge_ports(conf.ports, args.ports).values())
 
 
-class TaskConfigurator(RunWithPortsConfigurator):
+class TaskConfigurator(RunWithPortsConfiguratorMixin, BaseRunConfigurator):
     TYPE = ApplyConfigurationType.TASK
 
+    @classmethod
+    def register_args(cls, parser: argparse.ArgumentParser):
+        super().register_args(parser)
+        cls.register_ports_args(parser)
+
     def apply_args(self, conf: TaskConfiguration, args: argparse.Namespace, unknown: List[str]):
         super().apply_args(conf, args, unknown)
+        self.apply_ports_args(conf, args)
         self.interpolate_run_args(conf.commands, unknown)
 
 
-class DevEnvironmentConfigurator(RunWithPortsConfigurator):
+class DevEnvironmentConfigurator(RunWithPortsConfiguratorMixin, BaseRunConfigurator):
     TYPE = ApplyConfigurationType.DEV_ENVIRONMENT
 
+    @classmethod
+    def register_args(cls, parser: argparse.ArgumentParser):
+        super().register_args(parser)
+        cls.register_ports_args(parser)
+
     def apply_args(
         self, conf: DevEnvironmentConfiguration, args: argparse.Namespace, unknown: List[str]
     ):
         super().apply_args(conf, args, unknown)
+        self.apply_ports_args(conf, args)
         if conf.ide == "vscode" and conf.version is None:
             conf.version = _detect_vscode_version()
             if conf.version is None:
@@ -677,6 +897,8 @@ def render_run_spec_diff(old_spec: RunSpec, new_spec: RunSpec) -> Optional[str]:
             if type(old_spec.profile) is not type(new_spec.profile):
                 item = NestedListItem("Profile")
             else:
+                assert old_spec.profile is not None
+                assert new_spec.profile is not None
                 item = NestedListItem(
                     "Profile properties:",
                     children=[
@@ -690,3 +912,16 @@ def render_run_spec_diff(old_spec: RunSpec, new_spec: RunSpec) -> Optional[str]:
             item = NestedListItem(spec_field.replace("_", " ").capitalize())
         nested_list.children.append(item)
     return nested_list.render()
+
+
+def _warn_fleet_autocreated(api: APIClient, run: Run):
+    if run._run.fleet is None:
+        return
+    fleet = api.fleets.get(project_name=run._project, name=run._run.fleet.name)
+    if not fleet.spec.autocreated:
+        return
+    warn(
+        f"\nNo existing fleet matched, so the run created a new fleet [code]{fleet.name}[/code].\n"
+        "Future dstack versions won't create fleets automatically.\n"
+        "Create a fleet explicitly: https://dstack.ai/docs/concepts/fleets/"
+    )

dstack/_internal/cli/services/configurators/volume.py

@@ -1,6 +1,6 @@
 import argparse
 import time
-from typing import List, Optional
+from typing import List
 
 from rich.table import Table
 
@@ -14,7 +14,6 @@ from dstack._internal.cli.utils.rich import MultiItemStatus
 from dstack._internal.cli.utils.volume import get_volumes_table
 from dstack._internal.core.errors import ResourceNotExistsError
 from dstack._internal.core.models.configurations import ApplyConfigurationType
-from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.core.models.volumes import (
     Volume,
     VolumeConfiguration,
@@ -26,7 +25,7 @@ from dstack._internal.utils.common import local_time
 from dstack.api._public import Client
 
 
-class VolumeConfigurator(BaseApplyConfigurator):
+class VolumeConfigurator(BaseApplyConfigurator[VolumeConfiguration]):
     TYPE: ApplyConfigurationType = ApplyConfigurationType.VOLUME
 
     def apply_configuration(
@@ -36,7 +35,6 @@ class VolumeConfigurator(BaseApplyConfigurator):
         command_args: argparse.Namespace,
         configurator_args: argparse.Namespace,
         unknown_args: List[str],
-        repo: Optional[Repo] = None,
     ):
         self.apply_args(conf, configurator_args, unknown_args)
         spec = VolumeSpec(

dstack/_internal/cli/services/profile.py

@@ -159,7 +159,7 @@ def apply_profile_args(
     if args.idle_duration is not None:
         profile_settings.idle_duration = args.idle_duration
     elif args.dont_destroy:
-        profile_settings.idle_duration = "off"
+        profile_settings.idle_duration = -1
     if args.creation_policy_reuse:
         profile_settings.creation_policy = CreationPolicy.REUSE
 

dstack/_internal/cli/services/repos.py

@@ -1,13 +1,13 @@
 import argparse
-from pathlib import Path
-from typing import Optional
+from typing import Literal, Union, overload
+
+import git
 
 from dstack._internal.cli.services.configurators.base import ArgsParser
 from dstack._internal.core.errors import CLIError
-from dstack._internal.core.models.repos.base import Repo
+from dstack._internal.core.models.repos.local import LocalRepo
 from dstack._internal.core.models.repos.remote import GitRepoURL, RemoteRepo, RepoError
 from dstack._internal.core.models.repos.virtual import VirtualRepo
-from dstack._internal.core.services.repos import get_default_branch
 from dstack._internal.utils.path import PathLike
 from dstack.api._public import Client
 
@@ -36,51 +36,38 @@ def register_init_repo_args(parser: ArgsParser):
     )
 
 
-def init_repo(
-    api: Client,
-    repo_path: PathLike,
-    repo_branch: Optional[str],
-    repo_hash: Optional[str],
-    local: bool,
-    git_identity_file: Optional[PathLike],
-    oauth_token: Optional[str],
-) -> Repo:
-    if Path(repo_path).exists():
-        repo = api.repos.load(
-            repo_dir=repo_path,
-            local=local,
-            init=True,
-            git_identity_file=git_identity_file,
-            oauth_token=oauth_token,
-        )
-    elif isinstance(repo_path, str):
-        try:
-            GitRepoURL.parse(repo_path)
-        except RepoError as e:
-            raise CLIError("Invalid repo path") from e
-        if repo_branch is None and repo_hash is None:
-            repo_branch = get_default_branch(repo_path)
-            if repo_branch is None:
-                raise CLIError(
-                    "Failed to automatically detect remote repo branch."
-                    " Specify --repo-branch or --repo-hash."
-                )
-        repo = RemoteRepo.from_url(
-            repo_url=repo_path,
-            repo_branch=repo_branch,
-            repo_hash=repo_hash,
-        )
-        api.repos.init(
-            repo=repo,
-            git_identity_file=git_identity_file,
-            oauth_token=oauth_token,
-        )
-    else:
-        raise CLIError("Invalid repo path")
-    return repo
-
-
 def init_default_virtual_repo(api: Client) -> VirtualRepo:
     repo = VirtualRepo()
     api.repos.init(repo)
     return repo
+
+
+@overload
+def get_repo_from_dir(repo_dir: PathLike, local: Literal[False] = False) -> RemoteRepo: ...
+
+
+@overload
+def get_repo_from_dir(repo_dir: PathLike, local: Literal[True]) -> LocalRepo: ...
+
+
+def get_repo_from_dir(repo_dir: PathLike, local: bool = False) -> Union[RemoteRepo, LocalRepo]:
+    if local:
+        return LocalRepo.from_dir(repo_dir)
+    try:
+        return RemoteRepo.from_dir(repo_dir)
+    except git.InvalidGitRepositoryError:
+        raise CLIError(
+            f"Git repo not found: {repo_dir}\n"
+            "Use `files` to mount an arbitrary directory:"
+            " https://dstack.ai/docs/concepts/tasks/#files"
+        )
+    except RepoError as e:
+        raise CLIError(str(e)) from e
+
+
+def is_git_repo_url(value: str) -> bool:
+    try:
+        GitRepoURL.parse(value)
+    except RepoError:
+        return False
+    return True

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

@@ -0,0 +1 @@
+# This package contains the implementation for the AMDDevCloud backend.

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

@@ -0,0 +1,16 @@
+from dstack._internal.core.backends.amddevcloud.compute import AMDDevCloudCompute
+from dstack._internal.core.backends.digitalocean_base.backend import BaseDigitalOceanBackend
+from dstack._internal.core.backends.digitalocean_base.models import BaseDigitalOceanConfig
+from dstack._internal.core.models.backends.base import BackendType
+
+
+class AMDDevCloudBackend(BaseDigitalOceanBackend):
+    TYPE = BackendType.AMDDEVCLOUD
+    COMPUTE_CLASS = AMDDevCloudCompute
+
+    def __init__(self, config: BaseDigitalOceanConfig, api_url: str):
+        self.config = config
+        self._compute = AMDDevCloudCompute(self.config, api_url=api_url, type=self.TYPE)
+
+    def compute(self) -> AMDDevCloudCompute:
+        return self._compute