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

dstack/cli/run.py

@@ -1,223 +0,0 @@
-import argparse
-import os
-import re
-import sys
-import time
-from argparse import Namespace
-from pathlib import Path
-from typing import List, Optional, Dict, Tuple, Any
-from urllib import parse
-
-import websocket
-import yaml
-from cursor import cursor
-from git import InvalidGitRepositoryError
-from jsonschema import validate, ValidationError
-from rich.console import Console
-from rich.progress import SpinnerColumn, Progress, TextColumn
-from rich.prompt import Confirm
-from websocket import WebSocketApp
-
-from dstack import providers
-from dstack.backend import load_backend, Backend, RequestStatus
-from dstack.cli.logs import poll_logs, since
-from dstack.cli.schema import workflows_schema_yaml
-from dstack.cli.status import status_func, _has_request_status
-from dstack.config import ConfigError
-from dstack.jobs import JobStatus, JobHead
-from dstack.repo import load_repo_data
-
-POLL_PROVISION_RATE_SECS = 3
-
-
-def _load_workflows():
-    root_folder = Path(os.getcwd()) / ".dstack"
-    if root_folder.exists():
-        workflows_file = root_folder / "workflows.yaml"
-        if workflows_file.exists():
-            return yaml.load(workflows_file.open(), Loader=yaml.FullLoader)
-        else:
-            return None
-    else:
-        return None
-
-
-def parse_run_args(args: Namespace) -> Tuple[str, List[str], Optional[str], Dict[str, Any]]:
-    provider_args = args.args + args.unknown
-    workflow_name = None
-    workflow_data = {}
-
-    workflows_yaml = _load_workflows()
-    workflows = (workflows_yaml.get("workflows") or []) if workflows_yaml is not None else []
-    if workflows:
-        validate(workflows_yaml, yaml.load(workflows_schema_yaml, Loader=yaml.FullLoader))
-    workflow_names = [w.get("name") for w in workflows]
-    workflow_providers = {w.get("name"): w.get("provider") for w in workflows}
-
-    if args.workflow_or_provider in workflow_names:
-        workflow_name = args.workflow_or_provider
-        workflow_data = next(w for w in workflows if w.get("name") == workflow_name)
-        provider_name = workflow_providers[workflow_name]
-    else:
-        if args.workflow_or_provider not in providers.get_provider_names():
-            sys.exit(f"No workflow or provider '{args.workflow_or_provider}' is found")
-
-        provider_name = args.workflow_or_provider
-
-    return provider_name, provider_args, workflow_name, workflow_data
-
-
-def poll_run(repo_user_name: str, repo_name: str, job_heads: List[JobHead], backend: Backend):
-    console = Console()
-    try:
-        console.print()
-        request_errors_printed = False
-        downloading = False
-        run = None
-        with Progress(TextColumn("[progress.description]{task.description}"), SpinnerColumn(),
-                      transient=True, ) as progress:
-            task = progress.add_task("Provisioning... It may take up to a minute.", total=None)
-            while True:
-                time.sleep(POLL_PROVISION_RATE_SECS)
-                _job_heads = [backend.get_job(repo_user_name, repo_name, job_head.job_id) for job_head in job_heads]
-                run = next(iter(backend.get_run_heads(repo_user_name, repo_name, _job_heads)))
-                if run.status == JobStatus.DOWNLOADING and not downloading:
-                    progress.update(task, description="Downloading deps... It may take a while.")
-                    downloading = True
-                elif run.status not in [JobStatus.SUBMITTED, JobStatus.DOWNLOADING]:
-                    progress.update(task, total=100)
-                    break
-                if _has_request_status(run, [RequestStatus.TERMINATED, RequestStatus.NO_CAPACITY]):
-                    if _has_request_status(run, [RequestStatus.TERMINATED]):
-                        progress.update(task, description=f"[red]Request(s) terminated[/]", total=100)
-                        break
-                    elif not request_errors_printed and _has_request_status(run, [RequestStatus.NO_CAPACITY]):
-                        progress.update(task, description=f"[dark_orange]No capacity[/]")
-                        request_errors_printed = True
-                elif request_errors_printed:
-                    progress.update(task, description="Provisioning... It may take up to a minute.")
-                    request_errors_printed = False
-        console.print("Provisioning... It may take up to a minute. [green]✓[/]")
-        console.print()
-        console.print("[grey58]To interrupt, press Ctrl+C.[/]")
-        console.print()
-        if len(job_heads) == 1 and run and run.status == JobStatus.RUNNING:
-            poll_logs_ws(backend, repo_user_name, repo_name, job_heads[0], console)
-        else:
-            poll_logs(backend, repo_user_name, repo_name, job_heads, since("1d"), attach=True, from_run=True)
-    except KeyboardInterrupt:
-        run_name = job_heads[0].run_name
-        if Confirm.ask(f" [red]Abort the run '{run_name}'?[/]"):
-            backend.stop_jobs(repo_user_name, repo_name, run_name, abort=True)
-            console.print(f"[grey58]OK[/]")
-
-
-def poll_logs_ws(backend: Backend, repo_user_name: str, repo_name: str,
-                 job_head: JobHead, console):
-    job = backend.get_job(repo_user_name, repo_name, job_head.job_id)
-
-    def on_message(ws: WebSocketApp, message):
-        pat = re.compile(f'http://(localhost|0.0.0.0|{job.host_name}):[\\S]*[^(.+)\\s\\n\\r]')
-        if re.search(pat, message):
-            if job.host_name and job.ports and job.app_specs:
-                for app_spec in job.app_specs:
-                    port = job.ports[app_spec.port_index]
-                    url_path = app_spec.url_path or ""
-                    url_query_params = app_spec.url_query_params
-                    url_query = ("?" + parse.urlencode(url_query_params)) if url_query_params else ""
-                    app_url = f"http://{job.host_name}:{port}"
-                    if url_path or url_query_params:
-                        app_url += "/"
-                        if url_query_params:
-                            app_url += url_query
-                    message = re.sub(pat, app_url, message)
-        sys.stdout.write(message)
-
-    def on_error(ws: WebSocketApp, err: Exception):
-        if isinstance(err, KeyboardInterrupt):
-            run_name = job_head.run_name
-            if Confirm.ask(f"\n [red]Abort the run '{run_name}'?[/]"):
-                backend.stop_jobs(repo_user_name, repo_name, run_name, abort=True)
-                console.print(f"[grey58]OK[/]")
-        else:
-            pass
-
-    def on_open(ws: WebSocketApp):
-        pass
-
-    def on_close(ws: WebSocketApp, close_status_code, close_msg):
-        pass
-
-    url = f"ws://{job.host_name}:4000/logsws"
-    cursor.hide()
-    ws = websocket.WebSocketApp(url, on_message=on_message, on_error=on_error, on_open=on_open,
-                                on_close=on_close)
-    ws.run_forever()
-    cursor.show()
-
-
-def run_workflow_func(args: Namespace):
-    if not args.workflow_or_provider:
-        print("Usage: dstack run [-h] WORKFLOW [-d] [-t TAG] [ARGS ...]\n")
-        workflows_yaml = _load_workflows()
-        workflows = (workflows_yaml or {}).get("workflows") or []
-        workflow_names = [w["name"] for w in workflows if w.get("name")]
-        print(f'Positional arguments:\n'
-              f'  WORKFLOW              {{{",".join(workflow_names)}}}\n')
-        print("Options:\n"
-              "  -t TAG, --tag TAG      A tag name. Warning, if the tag already exists, it will be overridden.\n"
-              "  -d, --detach           Do not poll for status update and logs\n"
-              "  -h, --help             Show this help output, or the help for a specified workflow or provider.\n")
-        print("To see the help output for a particular workflow, use the following command:\n"
-              "  dstack run WORKFLOW --help")
-    else:
-        try:
-            repo_data = load_repo_data()
-            backend = load_backend()
-
-            provider_name, provider_args, workflow_name, workflow_data = parse_run_args(args)
-
-            provider = providers.load_provider(provider_name)
-
-            if hasattr(args, "help") and args.help:
-                provider.help(workflow_name)
-                sys.exit()
-
-            provider.load(provider_args, workflow_name, workflow_data)
-            if args.tag_name:
-                tag_head = backend.get_tag_head(repo_data.repo_user_name, repo_data.repo_name, args.tag_name)
-                if tag_head:
-                    # if args.yes or Confirm.ask(f"[red]The tag '{args.tag_name}' already exists. "
-                    #                            f"Do you want to override it?[/]"):
-                    backend.delete_tag_head(repo_data.repo_user_name, repo_data.repo_name, tag_head)
-                    # else:
-                    #     return
-            run_name = backend.create_run(repo_data.repo_user_name, repo_data.repo_name)
-            jobs = provider.submit_jobs(run_name, args.tag_name)
-            backend.update_repo_last_run_at(repo_data.repo_user_name, repo_data.repo_name,
-                                            last_run_at=int(round(time.time() * 1000)))
-            status_func(Namespace(run_name=run_name, all=False))
-            if not args.detach:
-                poll_run(repo_data.repo_user_name, repo_data.repo_name, jobs, backend)
-
-        except ConfigError:
-            sys.exit(f"Call 'dstack config' first")
-        except InvalidGitRepositoryError:
-            sys.exit(f"{os.getcwd()} is not a Git repo")
-        except ValidationError as e:
-            sys.exit(f"There a syntax error in {os.getcwd()}/.dstack/workflows.yaml:\n\n{e}")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("run", help="Run a workflow", add_help=False)
-    parser.add_argument("workflow_or_provider", metavar="WORKFLOW", type=str,
-                        help="A name of a workflow", nargs="?")
-    parser.add_argument("-t", "--tag", metavar="TAG", help="A tag name. Warning, if the tag exists, "
-                                                           "it will be overridden.", type=str, dest="tag_name")
-    parser.add_argument("-d", "--detach", help="Do not poll for status update and logs", action="store_true")
-    # parser.add_argument("-y", "--yes", help="Don't ask for confirmation", action="store_true")
-    parser.add_argument("args", metavar="ARGS", nargs=argparse.ZERO_OR_MORE, help="Override provider arguments")
-    parser.add_argument('-h', '--help', action='store_true', default=argparse.SUPPRESS,
-                        help='Show this help message and exit')
-
-    parser.set_defaults(func=run_workflow_func)

dstack/cli/schema.py

@@ -1,46 +0,0 @@
-workflows_schema_yaml = """type: object
-additionalProperties: false
-properties:
-  workflows:
-    type: array
-    items:
-      type: object
-      properties:
-        name:
-          type: string
-          minLength: 1
-        help:
-          type: string
-          minLength: 1
-        deps:
-          type: array
-          items:
-            oneOf:
-              - type: string
-                minLength: 1
-              - type: object
-                properties:
-                  tag: 
-                    type: string
-                    minLength: 1
-                  mount:
-                    type: boolean
-                required:
-                  - tag                  
-              - type: object
-                properties:
-                  workflow: 
-                    type: string
-                    minLength: 1
-                  mount:
-                    type: boolean
-                required:
-                  - workflow                  
-          minItems: 1
-      additionalProperties: true
-      required:
-        - name
-        - provider
-required:
-  - workflows
-"""

dstack/cli/secrets.py

@@ -1,97 +0,0 @@
-import sys
-from argparse import Namespace
-
-from rich import print
-from rich.console import Console
-from rich.prompt import Confirm, Prompt
-from rich.table import Table
-
-from dstack.backend import load_backend, Secret
-from dstack.config import ConfigError
-
-
-def list_secrets_func(_: Namespace):
-    try:
-        backend = load_backend()
-        secret_names = backend.list_secret_names()
-        console = Console()
-        table = Table(box=None)
-        table.add_column("NAME", style="bold", no_wrap=True)
-        for secret_name in secret_names:
-            table.add_row(
-                secret_name
-            )
-        console.print(table)
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def add_secret_func(args: Namespace):
-    try:
-        backend = load_backend()
-        if backend.get_secret(args.secret_name):
-            if args.yes or Confirm.ask(f"[red]The secret '{args.secret_name}' already exists. "
-                                       f"Do you want to override it?[/]"):
-                secret_value = args.secret_value or Prompt.ask("Value", password=True)
-                backend.update_secret(Secret(args.secret_name, secret_value))
-                print(f"[grey58]OK[/]")
-            else:
-                return
-        else:
-            secret_value = args.secret_value or Prompt.ask("Value", password=True)
-            backend.add_secret(Secret(args.secret_name, secret_value))
-            print(f"[grey58]OK[/]")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def update_secret_func(args: Namespace):
-    try:
-        backend = load_backend()
-        if not backend.get_secret(args.secret_name):
-            sys.exit(f"The secret '{args.secret_name}' doesn't exist")
-        else:
-            secret_value = args.secret_value or Prompt.ask("Value", password=True)
-            backend.update_secret(Secret(args.secret_name, secret_value))
-            print(f"[grey58]OK[/]")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def delete_secret_func(args: Namespace):
-    try:
-        backend = load_backend()
-        secret = backend.get_secret(args.secret_name)
-        if not secret:
-            sys.exit(f"The secret '{args.secret_name}' doesn't exist")
-        elif Confirm.ask(f" [red]Delete the secret '{secret.secret_name}'?[/]"):
-            backend.delete_secret(secret.secret_name)
-            print(f"[grey58]OK[/]")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("secrets", help="Manage secrets")
-    parser.set_defaults(func=list_secrets_func)
-
-    subparsers = parser.add_subparsers()
-
-    subparsers.add_parser("list", help="List secrets")
-
-    add_secrets_parser = subparsers.add_parser("add", help="Add a secret")
-    add_secrets_parser.add_argument("secret_name", metavar="NAME", type=str, help="The name of the secret")
-    add_secrets_parser.add_argument("secret_value", metavar="VALUE", type=str, help="The value of the secret",
-                                    nargs="?")
-    add_secrets_parser.add_argument("-y", "--yes", help="Don't ask for confirmation", action="store_true")
-    add_secrets_parser.set_defaults(func=add_secret_func)
-
-    update_secrets_parser = subparsers.add_parser("update", help="Update a secret")
-    update_secrets_parser.add_argument("secret_name", metavar="NAME", type=str, help="The name of the secret")
-    update_secrets_parser.add_argument("secret_value", metavar="VALUE", type=str, help="The value of the secret",
-                                       nargs="?")
-    update_secrets_parser.set_defaults(func=update_secret_func)
-
-    delete_secrets_parser = subparsers.add_parser("delete", help="Delete a secret")
-    delete_secrets_parser.add_argument("secret_name", metavar="NAME", type=str, help="The name of the secret")
-    delete_secrets_parser.set_defaults(func=delete_secret_func)

dstack/cli/status.py

@@ -1,140 +0,0 @@
-import os
-import sys
-from argparse import Namespace
-from itertools import groupby
-from typing import List
-
-from git import InvalidGitRepositoryError
-from rich.console import Console
-from rich.table import Table
-
-from dstack.backend import load_backend, Backend, RunHead, RequestStatus
-from dstack.cli.common import pretty_date
-from dstack.config import ConfigError
-from dstack.jobs import JobStatus
-from dstack.repo import load_repo_data
-
-_status_colors = {
-    JobStatus.SUBMITTED: "yellow",
-    JobStatus.DOWNLOADING: "yellow",
-    JobStatus.RUNNING: "dark_sea_green4",
-    JobStatus.UPLOADING: "dark_sea_green4",
-    JobStatus.DONE: "gray74",
-    JobStatus.FAILED: "red",
-    JobStatus.STOPPED: "grey58",
-    JobStatus.STOPPING: "yellow",
-    JobStatus.ABORTING: "yellow",
-    JobStatus.ABORTED: "grey58",
-}
-
-
-def _status_color(run: RunHead, val: str, run_column: bool, status_column: bool):
-    if status_column and _has_request_status(run, [RequestStatus.TERMINATED, RequestStatus.NO_CAPACITY]):
-        color = "dark_orange"
-    else:
-        color = _status_colors.get(run.status)
-    return f"[{'bold ' if run_column else ''}{color}]{val}[/]" if color is not None else val
-
-
-def _has_request_status(run, statuses: List[RequestStatus]):
-    return run.status.is_unfinished() and any(filter(lambda s: s.status in statuses, run.request_heads or []))
-
-
-def status_func(args: Namespace):
-    try:
-        backend = load_backend()
-        print_runs(args, backend)
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-    except InvalidGitRepositoryError:
-        sys.exit(f"{os.getcwd()} is not a Git repo")
-
-
-def pretty_print_status(run: RunHead) -> str:
-    status_color = _status_colors.get(run.status)
-    status = run.status.value
-    status = status[:1].upper() + status[1:]
-    s = f"[{status_color}]{status}[/]"
-    if _has_request_status(run, [RequestStatus.TERMINATED]):
-        s += "\n[red]Request(s) terminated[/]"
-    elif _has_request_status(run, [RequestStatus.NO_CAPACITY]):
-        s += " \n[dark_orange]No capacity[/]"
-    return s
-
-
-def print_runs(args: Namespace, backend: Backend):
-    repo_data = load_repo_data()
-    job_heads = backend.list_job_heads(repo_data.repo_user_name, repo_data.repo_name, args.run_name)
-    runs = backend.get_run_heads(repo_data.repo_user_name, repo_data.repo_name, job_heads)
-    if not args.all:
-        unfinished = any(run.status.is_unfinished() for run in runs)
-        if unfinished:
-            runs = list(filter(lambda r: r.status.is_unfinished(), runs))
-        else:
-            runs = runs[:1]
-    runs = reversed(runs)
-
-    runs_by_name = [(run_name, list(run)) for run_name, run in groupby(runs, lambda run: run.run_name)]
-    console = Console()
-    table = Table(box=None)
-    table.add_column("RUN", style="bold", no_wrap=True)
-    table.add_column("WORKFLOW", style="grey58", width=16)
-    table.add_column("STATUS", no_wrap=True)
-    table.add_column("APPS", no_wrap=True)
-    table.add_column("ARTIFACTS", style="grey58", width=18)
-    table.add_column("SUBMITTED", style="grey58", no_wrap=True)
-    table.add_column("TAG", style="bold yellow", no_wrap=True)
-
-    for run_name, runs in runs_by_name:
-        for i in range(len(runs)):
-            run = runs[i]
-            submitted_at = pretty_date(round(run.submitted_at / 1000))
-            table.add_row(
-                _status_color(run, run_name, True, False),
-                _status_color(run, run.workflow_name or run.provider_name, False, False),
-                pretty_print_status(run),
-                _status_color(run, _app_heads(run.app_heads, run.status.name), False, False),
-                _status_color(run, '\n'.join([a.artifact_path for a in run.artifact_heads or []]), False, False),
-                _status_color(run, submitted_at, False, False),
-                _status_color(run, f"{run.tag_name}" if run.tag_name else "", False, False))
-    console.print(table)
-
-
-def pretty_duration_and_submitted_at(submitted_at, started_at=None, finished_at=None):
-    if started_at is not None and finished_at is not None:
-        _finished_at_milli = round(finished_at / 1000)
-        duration_milli = _finished_at_milli - round(started_at / 1000)
-        hours, remainder = divmod(duration_milli, 3600)
-        minutes, seconds = divmod(remainder, 60)
-        duration_str = ""
-        if int(hours) > 0:
-            duration_str += "{} hours".format(int(hours))
-        if int(minutes) > 0:
-            if int(hours) > 0:
-                duration_str += " "
-            duration_str += "{} mins".format(int(minutes))
-        if int(hours) == 0 and int(minutes) == 0:
-            duration_str = "{} secs".format(int(seconds))
-    else:
-        duration_str = "<none>"
-    submitted_at_str = pretty_date(round(submitted_at / 1000)) if submitted_at is not None else ""
-    return duration_str, submitted_at_str
-
-
-def _app_heads(apps, status):
-    if status == "RUNNING" and apps:
-        return "\n".join(map(lambda app: app.app_name, apps))
-    else:
-        return ""
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("ps", help="List runs")
-
-    parser.add_argument("run_name", metavar="RUN", type=str, nargs="?", help="A name of a run")
-    parser.add_argument("-a", "--all",
-                        help="Show status for all runs. "
-                             "By default, it shows only status for unfinished runs, or the last finished.",
-                        action="store_true")
-
-    parser.set_defaults(func=status_func)

dstack/cli/stop.py

@@ -1,53 +0,0 @@
-import os
-import sys
-from argparse import Namespace
-
-from git import InvalidGitRepositoryError
-from rich import print
-from rich.prompt import Confirm
-
-from dstack.backend import load_backend
-from dstack.config import ConfigError
-from dstack.repo import load_repo_data
-
-
-def _verb(abort: bool):
-    if abort:
-        return "Abort"
-    else:
-        return "Stop"
-
-
-def stop_func(args: Namespace):
-    if (args.run_name and (args.yes or Confirm.ask(f"[red]{_verb(args.abort)} the run '{args.run_name}'?[/]"))) \
-            or (args.all and (args.yes or Confirm.ask(f"[red]{_verb(args.abort)} all runs?[/]"))):
-        try:
-            repo_data = load_repo_data()
-            backend = load_backend()
-            job_heads = backend.list_job_heads(repo_data.repo_user_name, repo_data.repo_name, args.run_name)
-            if job_heads:
-                for job_head in job_heads:
-                    if job_head.status.is_unfinished():
-                        backend.stop_job(repo_data.repo_user_name, repo_data.repo_name, job_head.job_id, args.abort)
-            else:
-                sys.exit(f"Cannot find the run '{args.run_name}'")
-            print(f"[grey58]OK[/]")
-        except InvalidGitRepositoryError:
-            sys.exit(f"{os.getcwd()} is not a Git repo")
-        except ConfigError:
-            sys.exit(f"Call 'dstack config' first")
-    else:
-        if not args.run_name and not args.all:
-            sys.exit("Specify a run name or use --all to stop all workflows")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("stop", help="Stop runs")
-
-    parser.add_argument("run_name", metavar="RUN", type=str, nargs="?", help="A name of a run")
-    parser.add_argument("-a", "--all", help="Stop all unfinished runs", dest="all", action="store_true")
-    parser.add_argument("-x", "--abort", help="Don't wait for a graceful stop and abort the run immediately",
-                        dest="abort", action="store_true")
-    parser.add_argument("-y", "--yes", help="Don't ask for confirmation", action="store_true")
-
-    parser.set_defaults(func=stop_func)

dstack/cli/tags.py

@@ -1,100 +0,0 @@
-import sys
-from argparse import Namespace
-
-from rich import print
-from rich.console import Console
-from rich.prompt import Confirm
-from rich.table import Table
-
-from dstack.backend import load_backend
-from dstack.cli.common import pretty_date
-from dstack.config import ConfigError
-from dstack.repo import load_repo_data
-
-
-def list_tags_func(_: Namespace):
-    try:
-        backend = load_backend()
-        repo_data = load_repo_data()
-        tag_heads = backend.list_tag_heads(repo_data.repo_user_name, repo_data.repo_name)
-        console = Console()
-        table = Table(box=None)
-        table.add_column("TAG", style="bold", no_wrap=True)
-        table.add_column("RUN", style="grey58", no_wrap=True)
-        # table.add_column("WORKFLOW", style="grey58", width=12)
-        # table.add_column("PROVIDER", style="grey58", width=12)
-        table.add_column("ARTIFACTS", style="grey58", width=12)
-        table.add_column("CREATED", style="grey58", no_wrap=True)
-        for tag_head in tag_heads:
-            created_at = pretty_date(round(tag_head.created_at / 1000))
-            table.add_row(
-                tag_head.tag_name,
-                tag_head.run_name,
-                # tag_head.workflow_name,
-                # tag_head.provider_name,
-                '\n'.join([a.artifact_path for a in tag_head.artifact_heads or []]),
-                created_at
-            )
-        console.print(table)
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def add_tag_func(args: Namespace):
-    if args.run_name or args.artifact_paths:
-        try:
-            backend = load_backend()
-            repo_data = load_repo_data()
-            tag_head = backend.get_tag_head(repo_data.repo_user_name, repo_data.repo_name, args.tag_name)
-            if tag_head:
-                if args.yes or Confirm.ask(f"[red]The tag '{args.tag_name}' already exists. "
-                                           f"Do you want to override it?[/]"):
-                    backend.delete_tag_head(repo_data.repo_user_name, repo_data.repo_name, tag_head)
-                else:
-                    return
-            if args.run_name:
-                backend.add_tag_from_run(repo_data.repo_user_name, repo_data.repo_name, args.tag_name, args.run_name,
-                                         run_jobs=None)
-            else:
-                backend.add_tag_from_local_dirs(repo_data, args.tag_name, args.artifact_paths)
-            print(f"[grey58]OK[/]")
-        except ConfigError:
-            sys.exit(f"Call 'dstack config' first")
-    else:
-        sys.exit("Specify -r RUN or -a PATH to create a tag")
-
-
-def delete_tag_func(args: Namespace):
-    try:
-        backend = load_backend()
-        repo_data = load_repo_data()
-        tag_head = backend.get_tag_head(repo_data.repo_user_name, repo_data.repo_name, args.tag_name)
-        if not tag_head:
-            sys.exit(f"The tag '{args.tag_name}' doesn't exist")
-        elif Confirm.ask(f" [red]Delete the tag '{tag_head.tag_name}'?[/]"):
-            backend.delete_tag_head(repo_data.repo_user_name, repo_data.repo_name, tag_head)
-            print(f"[grey58]OK[/]")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("tags", help="Manage tags")
-    parser.set_defaults(func=list_tags_func)
-
-    subparsers = parser.add_subparsers()
-
-    subparsers.add_parser("list", help="List tags")
-
-    add_tags_parser = subparsers.add_parser("add", help="Add a tag")
-    add_tags_parser.add_argument("tag_name", metavar="TAG", type=str, help="The name of the tag")
-    add_tags_parser.add_argument("run_name", metavar="RUN", type=str, help="A name of a run", nargs="?")
-    add_tags_parser.add_argument("-a", "--artifact", metavar="PATH", type=str,
-                                 help="A path to local directory to upload as an artifact", action="append",
-                                 dest="artifact_paths")
-    parser.add_argument("-y", "--yes", help="Don't ask for confirmation", action="store_true")
-    add_tags_parser.set_defaults(func=add_tag_func)
-
-    delete_tags_parser = subparsers.add_parser("delete", help="Delete a tag")
-    delete_tags_parser.add_argument("tag_name", metavar="TAG_NAME", type=str, help="The name of the tag")
-    delete_tags_parser.set_defaults(func=delete_tag_func)