dstack 0.0.9__py3-none-any.whl → 0.20.7__py3-none-any.whl

dstack/aws/runs.py

@@ -1,79 +0,0 @@
-from typing import Optional, List
-
-from botocore.client import BaseClient
-
-from dstack import random_name
-from dstack.aws import run_names, logs, jobs, runners
-from dstack.backend import RunHead, AppHead, ArtifactHead
-from dstack.jobs import JobHead, Job
-
-
-def create_run(s3_client: BaseClient, logs_client: BaseClient, bucket_name: str, repo_user_name: str,
-               repo_name: str) -> str:
-    name = random_name.next_name()
-    run_name_index = run_names.next_run_name_index(s3_client, bucket_name, name)
-    run_name = f"{name}-{run_name_index}"
-    log_group_name = f"/dstack/jobs/{bucket_name}/{repo_user_name}/{repo_name}"
-    logs.create_log_group_if_not_exists(logs_client, bucket_name, log_group_name)
-    return run_name
-
-
-def _create_run(ec2_client: BaseClient, s3_client: BaseClient, bucket_name: str, job_head: JobHead,
-                include_request_heads: bool) -> RunHead:
-    app_heads = list(
-        map(lambda app_name: AppHead(job_head.job_id, app_name), job_head.app_names)) if job_head.app_names else None
-    artifact_heads = list(map(lambda artifact_path: ArtifactHead(job_head.job_id, artifact_path),
-                              job_head.artifact_paths)) if job_head.artifact_paths else None
-    request_heads = None
-    if include_request_heads and job_head.status.is_unfinished():
-        if request_heads is None:
-            request_heads = []
-        job = jobs.get_job(s3_client, bucket_name, job_head.repo_user_name, job_head.repo_name, job_head.job_id)
-        request_head = runners.get_request_head(ec2_client, job)
-        request_heads.append(request_head)
-    run_head = RunHead(job_head.repo_user_name, job_head.repo_name, job_head.run_name, job_head.workflow_name,
-                       job_head.provider_name, artifact_heads or None, job_head.status, job_head.submitted_at,
-                       job_head.tag_name, app_heads, request_heads)
-    return run_head
-
-
-def _update_run(ec2_client: BaseClient, s3_client: BaseClient, bucket_name: str, run: RunHead, job_head: JobHead,
-                include_request_heads: bool):
-    run.submitted_at = min(run.submitted_at, job_head.submitted_at)
-    if job_head.artifact_paths:
-        if run.artifact_heads is None:
-            run.artifact_heads = []
-        run.artifact_heads.extend(
-            list(map(lambda artifact_path: ArtifactHead(job.job_id, artifact_path), job_head.artifact_paths)))
-    if job_head.app_names:
-        if run.app_heads is None:
-            run.app_heads = []
-        run.app_heads.extend(list(map(lambda app_name: AppHead(job.job_id, app_name), job_head.app_names)))
-    if job_head.status.is_unfinished():
-        run.status = job_head.status
-        if include_request_heads:
-            if run.request_heads is None:
-                run.request_heads = []
-            job = jobs.get_job(s3_client, bucket_name, job_head.repo_user_name, job_head.repo_name, job_head.job_id)
-            request_head = runners.get_request_head(ec2_client, job)
-            run.request_heads.append(request_head)
-
-
-def get_run_heads(ec2_client: BaseClient, s3_client: BaseClient, bucket_name: str, repo_user_name, repo_name,
-                  job_heads: List[JobHead], include_request_heads: bool) -> List[RunHead]:
-    runs_by_id = {}
-    for job_head in job_heads:
-        run_id = ','.join([job_head.run_name, job_head.workflow_name or ''])
-        if run_id not in runs_by_id:
-            runs_by_id[run_id] = _create_run(ec2_client, s3_client, bucket_name, job_head, include_request_heads)
-        else:
-            run = runs_by_id[run_id]
-            _update_run(ec2_client, s3_client, bucket_name, run, job_head, include_request_heads)
-    return sorted(list(runs_by_id.values()), key=lambda r: r.submitted_at, reverse=True)
-
-
-def list_run_heads(ec2_client: BaseClient, s3_client: BaseClient, bucket_name: str, repo_user_name, repo_name,
-                   run_name: Optional[str], include_request_heads: bool) -> List[RunHead]:
-    job_heads = jobs.list_job_heads(s3_client, bucket_name, repo_user_name, repo_name, run_name)
-    return get_run_heads(ec2_client, s3_client, bucket_name, repo_user_name, repo_name, job_heads,
-                         include_request_heads)

dstack/aws/secrets.py

@@ -1,99 +0,0 @@
-import json
-from typing import List, Optional
-
-from botocore.client import BaseClient
-
-from dstack.aws import runners
-from dstack.backend import Secret
-
-
-def list_secret_names(secretsmanager_client: BaseClient, bucket_name: str) -> List[str]:
-    prefix = f"/dstack/{bucket_name}/secrets/"
-    response = secretsmanager_client.list_secrets(
-        MaxResults=50,
-        Filters=[
-            {
-                "Key": "name",
-                "Values": [prefix]
-            },
-            {
-                "Key": "tag-key",
-                "Values": ["dstack_bucket"]
-            },
-            {
-                "Key": "tag-value",
-                "Values": [bucket_name]
-            },
-        ]
-    )
-    return [s["Name"][len(prefix):] for s in response["SecretList"]]
-
-
-def get_secret(secretsmanager_client: BaseClient, bucket_name: str, secret_name: str) -> Optional[Secret]:
-    try:
-        return Secret(secret_name, secretsmanager_client.get_secret_value(
-            SecretId=f"/dstack/{bucket_name}/secrets/{secret_name}"
-        )["SecretString"])
-    except Exception as e:
-        if hasattr(e, "response") and e.response.get("Error") and e.response["Error"].get(
-                "Code") in ["ResourceNotFoundException", "InvalidRequestException"]:
-            return None
-        else:
-            raise e
-
-
-def add_secret(sts_client: BaseClient, iam_client: BaseClient, secretsmanager_client: BaseClient, bucket_name: str,
-               secret: Secret):
-    secret_id = f"/dstack/{bucket_name}/secrets/{secret.secret_name}"
-    secretsmanager_client.create_secret(
-        Name=secret_id,
-        SecretString=secret.secret_value,
-        Description="Generated by dstack",
-        Tags=[
-            {
-                'Key': 'owner',
-                'Value': 'dstack'
-            },
-            {
-                'Key': 'dstack_bucket',
-                'Value': bucket_name
-            }
-        ],
-    )
-    role_name = runners.role_name(iam_client, bucket_name)
-    account_id = sts_client.get_caller_identity()["Account"]
-    secretsmanager_client.put_resource_policy(
-        SecretId=secret_id,
-        ResourcePolicy=json.dumps(
-            {
-                "Version": "2012-10-17",
-                "Statement": [
-                    {
-                        "Effect": "Allow",
-                        "Principal": {"AWS": f"arn:aws:iam::{account_id}:role/{role_name}"},
-                        "Action": [
-                            "secretsmanager:GetSecretValue",
-                            "secretsmanager:ListSecrets",
-                        ],
-                        "Resource": "*"
-                    }
-                ]
-            }
-        )
-    )
-
-
-def update_secret(secretsmanager_client: BaseClient, bucket_name: str,
-                  secret: Secret):
-    secret_id = f"/dstack/{bucket_name}/secrets/{secret.secret_name}"
-    secretsmanager_client.put_secret_value(
-        SecretId=secret_id,
-        SecretString=secret.secret_value,
-    )
-
-
-def delete_secret(secretsmanager_client: BaseClient, bucket_name: str, secret_name: str):
-    secretsmanager_client.delete_secret(
-        SecretId=f"/dstack/{bucket_name}/secrets/{secret_name}",
-        ForceDeleteWithoutRecovery=True
-    )

dstack/aws/tags.py

@@ -1,138 +0,0 @@
-import sys
-import time
-from pathlib import Path
-from typing import Optional, List
-
-from botocore.client import BaseClient
-
-from dstack.aws import jobs, runs, artifacts, repos
-from dstack.backend import TagHead, BackendError, ArtifactHead
-from dstack.jobs import Job, JobStatus, ArtifactSpec
-from dstack.repo import RepoData
-
-
-def _unserialize_artifact_heads(artifact_heads):
-    return [ArtifactHead(a.split("=")[0], a.split("=")[1]) for a in
-            artifact_heads.split(':')] if artifact_heads else None
-
-
-def list_tag_heads(s3_client: BaseClient, bucket_name: str, repo_user_name: str, repo_name: str):
-    prefix = f"tags/{repo_user_name}/{repo_name}"
-    tag_head_prefix = f"{prefix}/l;"
-    response = s3_client.list_objects_v2(Bucket=bucket_name, Prefix=tag_head_prefix)
-    tag_heads = []
-    if "Contents" in response:
-        for obj in response["Contents"]:
-            tag_name, run_name, workflow_name, provider_name, created_at, artifact_heads = tuple(
-                obj["Key"][len(tag_head_prefix):].split(';'))
-            tag_heads.append(TagHead(repo_user_name, repo_name,
-                                     tag_name, run_name, workflow_name, provider_name, int(created_at),
-                                     _unserialize_artifact_heads(artifact_heads)))
-    return tag_heads
-
-
-def get_tag_head(s3_client: BaseClient, bucket_name: str, repo_user_name: str, repo_name: str, tag_name: str) -> \
-        Optional[TagHead]:
-    prefix = f"tags/{repo_user_name}/{repo_name}"
-    tag_head_prefix = f"{prefix}/l;{tag_name};"
-    response = s3_client.list_objects_v2(Bucket=bucket_name, Prefix=tag_head_prefix)
-    if response.get("Contents"):
-        run_name, workflow_name, provider_name, created_at, artifact_heads = tuple(
-            response["Contents"][0]["Key"][len(tag_head_prefix):].split(';'))
-        return TagHead(repo_user_name, repo_name,
-                       tag_name, run_name, workflow_name, provider_name, int(created_at),
-                       _unserialize_artifact_heads(artifact_heads))
-    else:
-        return None
-
-
-def _serialize_artifact_heads(tag_head):
-    return ':'.join(
-        [a.job_id + '=' + a.artifact_path for a in tag_head.artifact_heads]) if tag_head.artifact_heads else ''
-
-
-def _tag_head_key(tag_head: TagHead) -> str:
-    prefix = f"tags/{tag_head.repo_user_name}/{tag_head.repo_name}"
-    key = f"{prefix}/l;{tag_head.tag_name};" \
-          f"{tag_head.run_name};" \
-          f"{tag_head.workflow_name or ''};" \
-          f"{tag_head.provider_name or ''};" \
-          f"{tag_head.created_at};" \
-          f"{_serialize_artifact_heads(tag_head)}"
-    return key
-
-
-def create_tag_from_run(s3_client: BaseClient, bucket_name: str, repo_user_name: str, repo_name: str,
-                        tag_name: str, run_name: str, run_jobs: Optional[List[Job]]):
-    if run_jobs:
-        tag_jobs = run_jobs
-    else:
-        tag_jobs = []
-        job_with_anther_tag = None
-        job_heads = jobs.list_job_heads(s3_client, bucket_name, repo_user_name, repo_name, run_name)
-        for job_head in job_heads:
-            job = jobs.get_job(s3_client, bucket_name, repo_user_name, repo_name, job_head.job_id)
-            if job:
-                tag_jobs.append(job)
-                if job.tag_name and job.tag_name != tag_name:
-                    job_with_anther_tag = job
-        if job_with_anther_tag:
-            raise BackendError(f"The run '{job_with_anther_tag.run_name} refers to another tag: "
-                               f"{job_with_anther_tag.tag_name}'")
-        if not tag_jobs:
-            sys.exit(f"Cannot find the run '{run_name}'")
-
-    tag_head = TagHead(repo_user_name, repo_name, tag_name, run_name, tag_jobs[0].workflow_name,
-                       tag_jobs[0].provider_name, int(round(time.time() * 1000)),
-                       [ArtifactHead(run_job.job_id, artifact_spec.artifact_path) for run_job in tag_jobs for
-                        artifact_spec in run_job.artifact_specs or []] or None)
-    s3_client.put_object(Body="", Bucket=bucket_name, Key=_tag_head_key(tag_head))
-
-    if not run_jobs:
-        for job in tag_jobs:
-            job.tag_name = tag_name
-            jobs.update_job(s3_client, bucket_name, job)
-    repos.increment_repo_tags_count(s3_client, bucket_name, repo_user_name, repo_name)
-
-
-def delete_tag(s3_client: BaseClient, bucket_name: str, repo_user_name: str, repo_name: str, tag_head: TagHead):
-    tag_jobs = []
-    job_heads = jobs.list_job_heads(s3_client, bucket_name, repo_user_name, repo_name, tag_head.run_name)
-    for job_head in job_heads:
-        job = jobs.get_job(s3_client, bucket_name, repo_user_name, repo_name, job_head.job_id)
-        if job:
-            tag_jobs.append(job)
-    s3_client.delete_object(Bucket=bucket_name, Key=_tag_head_key(tag_head))
-    for job in tag_jobs:
-        job.tag_name = None
-        jobs.update_job(s3_client, bucket_name, job)
-    repos.decrement_repo_tags_count(s3_client, bucket_name, repo_user_name, repo_name)
-
-
-def create_tag_from_local_dirs(s3_client: BaseClient, logs_client: BaseClient, bucket_name: str, repo_data: RepoData,
-                               tag_name: str, local_dirs: List[str]):
-    local_paths = []
-    tag_artifacts = []
-    for local_dir in local_dirs:
-        path = Path(local_dir)
-        if path.is_dir():
-            local_paths.append(path)
-            tag_artifacts.append(path.name)
-        else:
-            sys.exit(f"The '{local_dir}' path doesn't refer to an existing directory")
-
-    run_name = runs.create_run(s3_client, logs_client, bucket_name, repo_data.repo_user_name, repo_data.repo_name)
-    job = Job(None, repo_data, run_name, None, "bash", JobStatus.DONE, int(round(time.time() * 1000)), "scratch",
-              None, None, None, [ArtifactSpec(a, False) for a in tag_artifacts], None, None, None, None, None, None,
-              None, None, None, tag_name)
-    jobs.create_job(s3_client, bucket_name, job, create_head=False)
-    for index, local_path in enumerate(local_paths):
-        artifacts.upload_job_artifact_files(s3_client, bucket_name, repo_data.repo_user_name, repo_data.repo_name,
-                                            job.job_id, tag_artifacts[index], local_path)
-    tag_head = TagHead(repo_data.repo_user_name, repo_data.repo_name, tag_name, run_name, job.workflow_name,
-                       job.provider_name, job.submitted_at,
-                       [ArtifactHead(job.job_id, a.artifact_path) for a in
-                        job.artifact_specs] if job.artifact_specs else None)
-    tag_head_key = _tag_head_key(tag_head)
-    s3_client.put_object(Body="", Bucket=bucket_name, Key=tag_head_key)
-    repos.increment_repo_tags_count(s3_client, bucket_name, repo_data.repo_user_name, repo_data.repo_name)

dstack/backend.py

@@ -1,299 +0,0 @@
-import sys
-from abc import ABC
-from enum import Enum
-from typing import List, Optional, Generator, Tuple, Dict
-
-from dstack.config import load_config, AwsBackendConfig, Config, BackendConfig
-from dstack.jobs import Job, JobStatus, JobHead, AppSpec
-from dstack.repo import RepoData, RepoCredentials
-from dstack.runners import Resources, Runner
-from dstack.util import _quoted
-
-
-class InstanceType:
-    def __init__(self, instance_name: str, resources: Resources):
-        self.instance_name = instance_name
-        self.resources = resources
-
-    def __str__(self) -> str:
-        return f'InstanceType(instance_name="{self.instance_name}", resources={self.resources})'.__str__()
-
-
-class RequestStatus(Enum):
-    RUNNING = "fullfilled"
-    PENDING = "provisioning"
-    TERMINATED = "terminated"
-    NO_CAPACITY = "no_capacity"
-
-
-class RequestHead:
-    def __init__(self, job_id: str, status: RequestStatus, message: Optional[str]):
-        self.job_id = job_id
-        self.status = status
-        self.message = message
-
-    def __str__(self) -> str:
-        return f'RequestStatus(job_id="{self.job_id}", status="{self.status.value}", ' \
-               f'message="{self.message})'
-
-
-class AppHead:
-    def __init__(self, job_id: str, app_name: str):
-        self.job_id = job_id
-        self.app_name = app_name
-
-    def __str__(self) -> str:
-        return f'AppHead(job_id="{self.job_id}", app_name="{self.app_name})'
-
-
-class ArtifactHead:
-    def __init__(self, job_id: str, artifact_path: str):
-        self.job_id = job_id
-        self.artifact_path = artifact_path
-
-    def __str__(self) -> str:
-        return f'ArtifactHead(job_id="{self.job_id}", artifact_path="{self.artifact_path})'
-
-
-class RunHead:
-    def __init__(self, repo_user_name: str, repo_name: str, run_name: str, workflow_name: Optional[str],
-                 provider_name: str, artifact_heads: Optional[List[ArtifactHead]], status: JobStatus, submitted_at: int,
-                 tag_name: Optional[str], app_heads: Optional[List[AppHead]],
-                 request_heads: Optional[List[RequestHead]]):
-        self.repo_user_name = repo_user_name
-        self.repo_name = repo_name
-        self.run_name = run_name
-        self.workflow_name = workflow_name
-        self.provider_name = provider_name
-        self.artifact_heads = artifact_heads
-        self.status = status
-        self.submitted_at = submitted_at
-        self.tag_name = tag_name
-        self.app_heads = app_heads
-        self.request_heads = request_heads
-
-    def __str__(self) -> str:
-        artifact_heads = (
-                "[" + ", ".join(map(lambda a: str(a), self.artifact_heads)) + "]") if self.artifact_heads else None
-        app_heads = ("[" + ", ".join(map(lambda a: str(a), self.app_heads)) + "]") if self.app_heads else None
-        request_heads = "[" + ", ".join(
-            map(lambda e: _quoted(str(e)), self.request_heads)) + "]" if self.request_heads else None
-        return f'Run(repo_user_name="{self.repo_user_name}", ' \
-               f'repo_name="{self.repo_name}", ' \
-               f'run_name="{self.run_name}", ' \
-               f'workflow_name={_quoted(self.workflow_name)}, ' \
-               f'provider_name="{self.provider_name}", ' \
-               f'status=JobStatus.{self.status.name}, ' \
-               f'submitted_at={self.submitted_at}, ' \
-               f'artifact_heads={artifact_heads}, ' \
-               f'tag_name={_quoted(self.tag_name)}, ' \
-               f'app_heads={app_heads}, ' \
-               f'request_heads={request_heads})'
-
-
-class LogEventSource(Enum):
-    STDOUT = "stdout"
-    STDERR = "stderr"
-
-
-class LogEvent:
-    def __init__(self, event_id: str, timestamp: int, job_id: Optional[str], log_message: str,
-                 log_source: LogEventSource):
-        self.event_id = event_id
-        self.timestamp = timestamp
-        self.job_id = job_id
-        self.log_message = log_message
-        self.log_source = log_source
-
-
-class BackendError(Exception):
-    def __init__(self, message: str):
-        self.message = message
-
-
-class TagHead:
-    def __init__(self, repo_user_name: str, repo_name: str, tag_name: str, run_name: str,
-                 workflow_name: Optional[str], provider_name: Optional[str], created_at: int,
-                 artifact_heads: Optional[List[ArtifactHead]]):
-        self.repo_user_name = repo_user_name
-        self.repo_name = repo_name
-        self.tag_name = tag_name
-        self.run_name = run_name
-        self.workflow_name = workflow_name
-        self.provider_name = provider_name
-        self.created_at = created_at
-        self.artifact_heads = artifact_heads
-
-    def __str__(self) -> str:
-        artifact_heads = (
-                "[" + ", ".join(map(lambda a: str(a), self.artifact_heads)) + "]") if self.artifact_heads else None
-        return f'TagHead(repo_user_name="{self.repo_user_name}", ' \
-               f'repo_name="{self.repo_name}", ' \
-               f'tag_name="{self.tag_name}", ' \
-               f'run_name="{self.run_name}", ' \
-               f'workflow_name={_quoted(self.workflow_name)}, ' \
-               f'provider_name="{_quoted(self.provider_name)}", ' \
-               f'created_at={self.created_at}, ' \
-               f'artifact_heads={artifact_heads})'
-
-
-class RepoHead:
-    def __init__(self, repo_user_name: str, repo_name: str, last_run_at: Optional[int], tags_count: int):
-        self.repo_user_name = repo_user_name
-        self.repo_name = repo_name
-        self.last_run_at = last_run_at
-        self.tags_count = tags_count
-
-    def __str__(self) -> str:
-        return f'RepoHead(repo_user_name="{self.repo_user_name}", ' \
-               f'repo_name="{self.repo_name}", ' \
-               f'last_run_at="{self.last_run_at}", ' \
-               f'tags_count="{self.tags_count}")'
-
-
-class Secret:
-    def __init__(self, secret_name: str, secret_value: str):
-        self.secret_name = secret_name
-        self.secret_value = secret_value
-
-    def __str__(self) -> str:
-        return f'RepoHead(secret_name="{self.secret_name}", ' \
-               f'secret_value_length={len(self.secret_value)})'
-
-
-class Backend(ABC):
-    def configure(self):
-        pass
-
-    def create_run(self, repo_user_name: str, repo_name: str) -> str:
-        pass
-
-    def submit_job(self, job: Job, counter: List[int]):
-        pass
-
-    def get_job(self, repo_user_name: str, repo_name: str, job_id: str) -> Optional[Job]:
-        pass
-
-    def list_job_heads(self, repo_user_name: str, repo_name: str, run_name: Optional[str] = None) -> List[JobHead]:
-        pass
-
-    def list_jobs(self, repo_user_name: str, repo_name: str, run_name: str) -> List[Job]:
-        pass
-
-    def run_job(self, job: Job) -> Runner:
-        pass
-
-    def stop_job(self, repo_user_name: str, repo_name: str, job_id: str, abort: bool):
-        pass
-
-    def delete_job_head(self, repo_user_name: str, repo_name: str, job_id: str):
-        pass
-
-    def stop_jobs(self, repo_user_name: str, repo_name: str, run_name: Optional[str], abort: bool):
-        job_heads = self.list_job_heads(repo_user_name, repo_name, run_name)
-        for job_head in job_heads:
-            if job_head.status.is_unfinished():
-                self.stop_job(repo_user_name, repo_name, job_head.job_id, abort)
-
-    def delete_job_heads(self, repo_user_name: str, repo_name: str, run_name: Optional[str]):
-        job_heads = []
-        for job_head in self.list_job_heads(repo_user_name, repo_name, run_name):
-            if job_head.status.is_finished():
-                job_heads.append(job_head)
-            else:
-                if run_name:
-                    sys.exit("The run is not finished yet. Stop the run first.")
-
-        for job_head in job_heads:
-            self.delete_job_head(repo_user_name, repo_name, job_head.job_id)
-
-    def list_run_heads(self, repo_user_name: str, repo_name: str, run_name: Optional[str] = None,
-                       include_request_heads: bool = True) -> List[RunHead]:
-        pass
-
-    def get_run_heads(self, repo_user_name: str, repo_name: str, job_heads: List[JobHead],
-                      include_request_heads: bool = True) -> List[RunHead]:
-        pass
-
-    def poll_logs(self, repo_user_name: str, repo_name: str, job_heads: List[JobHead], start_time: int,
-                  attached: bool) -> Generator[LogEvent, None, None]:
-        pass
-
-    def query_logs(self, repo_user_name: str, repo_name: str, run_name: str, start_time: int, end_time: Optional[int],
-                   next_token: Optional[str], job_host_names: Dict[str, Optional[str]],
-                   job_ports: Dict[str, Optional[List[int]]], job_app_specs: Dict[str, Optional[List[AppSpec]]]) \
-            -> Tuple[List[LogEvent], Optional[str], Dict[str, Optional[str]], Dict[str, Optional[List[int]]],
-                     Dict[str, Optional[List[AppSpec]]]]:
-        pass
-
-    def download_run_artifact_files(self, repo_user_name: str, repo_name: str, run_name: str,
-                                    output_dir: Optional[str]):
-        pass
-
-    def list_run_artifact_files(self, repo_user_name: str, repo_name: str, run_name: str) -> \
-            Generator[Tuple[str, str, int], None, None]:
-        pass
-
-    def list_tag_heads(self, repo_user_name: str, repo_name: str) -> List[TagHead]:
-        pass
-
-    def get_tag_head(self, repo_user_name: str, repo_name: str, tag_name: str) -> Optional[TagHead]:
-        pass
-
-    def add_tag_from_run(self, repo_user_name: str, repo_name: str, tag_name: str, run_name: str,
-                         run_jobs: Optional[List[Job]]):
-        pass
-
-    def add_tag_from_local_dirs(self, repo_data: RepoData, tag_name: str, local_dirs: List[str]):
-        pass
-
-    def delete_tag_head(self, repo_user_name: str, repo_name: str, tag_head: TagHead):
-        pass
-
-    def list_repo_heads(self) -> List[RepoHead]:
-        pass
-
-    def update_repo_last_run_at(self, repo_user_name: str, repo_name: str, last_run_at: int):
-        pass
-
-    def increment_repo_tags_count(self, repo_user_name: str, repo_name: str):
-        pass
-
-    def decrement_repo_tags_count(self, repo_user_name: str, repo_name: str):
-        pass
-
-    def delete_repo(self, repo_user_name: str, repo_name):
-        pass
-
-    def save_repo_credentials(self, repo_user_name: str, repo_name: str, repo_credentials: RepoCredentials):
-        pass
-
-    def list_run_artifact_files_and_folders(self, repo_user_name: str, repo_name: str, job_id: str,
-                                            path: str) -> List[Tuple[str, bool]]:
-        pass
-
-    def list_secret_names(self) -> List[str]:
-        pass
-
-    def get_secret(self, secret_name: str) -> Optional[Secret]:
-        pass
-
-    def add_secret(self, secret: Secret):
-        pass
-
-    def update_secret(self, secret: Secret):
-        pass
-
-    def delete_secret(self, secret_name: str):
-        pass
-
-
-def load_backend(config: Optional[Config] = None) -> Backend:
-    if not config:
-        config = load_config()
-    if isinstance(config.backend_config, AwsBackendConfig):
-        from dstack.aws import AwsBackend
-
-        return AwsBackend(config.backend_config)
-    else:
-        raise Exception(f"Unsupported backend: {config.backend_config}")

dstack/cli/app.py

@@ -1,41 +0,0 @@
-import os
-import sys
-import webbrowser
-from argparse import Namespace
-
-from git import InvalidGitRepositoryError
-from rich import print
-
-
-def apps_func(args: Namespace):
-    try:
-        dstack_config = get_config()
-        profile = dstack_config.get_profile("default")
-        workflows = get_runs(args.run_name, args.workflow_name, profile=profile)
-
-        apps = []
-        for workflow in filter(lambda w: not args.workflow_name or w.workflow_name == args.workflow_name, workflows):
-            for app in workflow.get("apps") or []:
-                apps.append(app)
-        if len(apps) > 0:
-            url = apps[0].get("url")
-            if url:
-                print(f"The application url is {url}")
-                print("Opening it in the browser...")
-                webbrowser.open(apps[0]["url"])
-                print(f"[grey58]OK[/]")
-            else:
-                sys.exit("Application is not initialized yet")
-        else:
-            sys.exit("No application is found")
-    except InvalidGitRepositoryError:
-        sys.exit(f"{os.getcwd()} is not a Git repo")
-    except ConfigurationError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("app", help="Open an app")
-
-    parser.add_argument("run_name", metavar="RUN", type=str, help="A name of a run")
-    parser.set_defaults(func=apps_func)