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

dstack/cli/artifacts.py

@@ -1,87 +0,0 @@
-import os
-import sys
-from argparse import Namespace
-
-from git import InvalidGitRepositoryError
-from rich.console import Console
-from rich.table import Table
-
-from dstack.backend import load_backend
-from dstack.config import ConfigError
-from dstack.repo import load_repo_data
-
-
-def _run_name(repo_data, backend, args):
-    if args.run_name_or_tag_name.startswith(":"):
-        tag_name = args.run_name_or_tag_name[1:]
-        tag_head = backend.get_tag_head(repo_data.repo_user_name, repo_data.repo_name, tag_name)
-        if tag_head:
-            return tag_head.run_name
-        else:
-            sys.exit(f"Cannot find the tag '{tag_name}'")
-    else:
-        run_name = args.run_name_or_tag_name
-        job_heads = backend.list_job_heads(repo_data.repo_user_name, repo_data.repo_name, run_name)
-        if job_heads:
-            return run_name
-        else:
-            sys.exit(f"Cannot find the run '{run_name}'")
-
-
-def download_func(args: Namespace):
-    try:
-        backend = load_backend()
-        repo_data = load_repo_data()
-        run_name = _run_name(repo_data, backend, args)
-        backend.download_run_artifact_files(repo_data.repo_user_name, repo_data.repo_name, run_name, args.output)
-    except InvalidGitRepositoryError:
-        sys.exit(f"{os.getcwd()} is not a Git repo")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def sizeof_fmt(num, suffix='B'):
-    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
-        if abs(num) < 1024.0:
-            return "%3.1f%s%s" % (num, unit, suffix)
-        num /= 1024.0
-    return "%.1f%s%s" % (num, 'Yi', suffix)
-
-
-def list_func(args: Namespace):
-    try:
-        backend = load_backend()
-        repo_data = load_repo_data()
-        run_name = _run_name(repo_data, backend, args)
-        run_artifact_files = backend.list_run_artifact_files(repo_data.repo_user_name, repo_data.repo_name, run_name)
-        console = Console()
-        table = Table(box=None)
-        table.add_column("ARTIFACT", style="bold", no_wrap=True)
-        table.add_column("FILE")
-        table.add_column("SIZE", style="dark_sea_green4")
-        previous_artifact_name = None
-        for (artifact_name, file_name, file_size) in run_artifact_files:
-            table.add_row(artifact_name if previous_artifact_name != artifact_name else "",
-                          file_name, sizeof_fmt(file_size))
-            previous_artifact_name = artifact_name
-        console.print(table)
-    except InvalidGitRepositoryError:
-        sys.exit(f"{os.getcwd()} is not a Git repo")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("artifacts", help="List or download artifacts")
-    subparsers = parser.add_subparsers()
-
-    list_parser = subparsers.add_parser("list", help="List artifacts", )
-    list_parser.add_argument("run_name_or_tag_name", metavar="RUN | :TAG", type=str, help="A name of a run or a tag")
-    list_parser.set_defaults(func=list_func)
-
-    download_parser = subparsers.add_parser("download", help="Download artifacts", )
-    download_parser.add_argument("run_name_or_tag_name", metavar="(RUN | :TAG)", type=str,
-                                 help="A name of a run or a tag")
-    download_parser.add_argument("-o", "--output", help="The directory to download artifacts to. "
-                                                        "By default, it's the current directory.", type=str)
-    download_parser.set_defaults(func=download_func)

dstack/cli/common.py

@@ -1,57 +0,0 @@
-import collections
-import typing as ty
-
-
-def pretty_date(time: ty.Any = False):
-    """
-    Get a datetime object or a int() Epoch timestamp and return a
-    pretty string like 'an hour ago', 'Yesterday', '3 months ago',
-    'just now', etc
-    """
-    from datetime import datetime
-    now = datetime.now()
-    if type(time) is int:
-        diff = now - datetime.fromtimestamp(time)
-    elif isinstance(time, datetime):
-        diff = now - time
-    elif not time:
-        diff = now - now
-    second_diff = diff.seconds
-    day_diff = diff.days
-
-    if day_diff < 0:
-        return ''
-
-    if day_diff == 0:
-        if second_diff < 10:
-            return "now"
-        if second_diff < 60:
-            return str(second_diff) + " sec ago"
-        if second_diff < 120:
-            return "1 min ago"
-        if second_diff < 3600:
-            return str(round(second_diff / 60)) + " mins ago"
-        if second_diff < 7200:
-            return "1 hour ago"
-        if second_diff < 86400:
-            return str(round(second_diff / 3600)) + " hours ago"
-    if day_diff == 1:
-        return "yesterday"
-    if day_diff < 7:
-        return str(day_diff) + " days ago"
-    if day_diff < 31:
-        return str(round(day_diff / 7)) + " weeks ago"
-    if day_diff < 365:
-        return str(round(day_diff / 30)) + " months ago"
-    return str(round(day_diff / 365)) + " years ago"
-
-
-def __flatten(d, parent_key='', sep='.'):
-    items = []
-    for k, v in d.items():
-        new_key = parent_key + sep + k if parent_key else k
-        if isinstance(v, collections.MutableMapping):
-            items.extend(__flatten(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)

dstack/cli/config.py

@@ -1,194 +0,0 @@
-import re
-from argparse import Namespace
-from importlib.util import find_spec
-from typing import Optional, List
-
-import boto3
-from rich import print
-from rich.prompt import Prompt
-
-from dstack.backend import load_backend
-from dstack.config import load_config, ConfigError, write_config, Config, AwsBackendConfig
-
-regions = [
-    ("US East, N. Virginia", "us-east-1"),
-    ("US East, Ohio", "us-east-2"),
-    ("US West, N. California", "us-west-1"),
-    ("US West, Oregon", "us-west-2"),
-    ("Asia Pacific, Singapore", "ap-southeast-1"),
-    ("Canada, Central", "ca-central-1"),
-    ("Europe, Frankfurt", "eu-central-1"),
-    ("Europe, Ireland", "eu-west-1"),
-    ("Europe, London", "eu-west-2"),
-    ("Europe, Paris", "eu-west-3"),
-    ("Europe, Stockholm", "eu-north-1"),
-]
-
-_is_termios_available = find_spec("termios") is not None
-
-
-def ask_choice(title: str, labels: List[str], values: List[str], selected_value: Optional[str],
-               show_choices: Optional[bool] = None) -> str:
-    if selected_value not in values:
-        selected_value = None
-    if _is_termios_available:
-        from simple_term_menu import TerminalMenu
-        print(f"[sea_green3 bold]?[/sea_green3 bold] [bold]{title}[/bold] "
-              "[gray46]Use arrows to move, type to filter[/gray46]")
-        try:
-            cursor_index = values.index(selected_value) if selected_value else None
-        except ValueError:
-            cursor_index = None
-        terminal_menu = TerminalMenu(menu_entries=labels, menu_cursor_style=["fg_red", "bold"],
-                                     menu_highlight_style=["fg_red", "bold"],
-                                     search_key=None,
-                                     search_highlight_style=["fg_purple"],
-                                     cursor_index=cursor_index)
-        chosen_menu_index = terminal_menu.show()
-        chosen_menu_label = labels[chosen_menu_index].replace("[", "\\[")
-        print(f"[sea_green3 bold]✓[/sea_green3 bold] [grey74]{chosen_menu_label}[/grey74]")
-        return values[chosen_menu_index]
-    else:
-        if len(values) < 6 and show_choices is None or show_choices is True:
-            return Prompt.ask(prompt=f"[sea_green3 bold]?[/sea_green3 bold] [bold]{title}[/bold]",
-                              choices=values, default=selected_value)
-        else:
-            value = Prompt.ask(prompt=f"[sea_green3 bold]?[/sea_green3 bold] [bold]{title}[/bold]",
-                               default=selected_value)
-            if value in values:
-                return value
-            else:
-                print(
-                    f"[red]Please select one of the available options: \\[{', '.join(values)}][/red]")
-                return ask_choice(title, labels, values, selected_value, show_choices)
-
-
-def ask_subnet(profile_name: Optional[str], region_name: str, default_subnet_id: Optional[str]) -> Optional[str]:
-    my_session = boto3.session.Session(profile_name=profile_name, region_name=region_name)
-    ec2_client = my_session.client("ec2")
-    subnets_response = ec2_client.describe_subnets()
-    existing_subnets = [s["SubnetId"] for s in subnets_response["Subnets"]]
-    subnet_options = ["Default [no preference]"]
-    subnet_options.extend([(s["SubnetId"] + " [" + s["VpcId"] + "]") for s in subnets_response["Subnets"]])
-    choice = ask_choice("Choose EC2 subnet", subnet_options, ["none"] + existing_subnets, default_subnet_id or "none",
-                        show_choices=True)
-    if choice == "none":
-        choice = None
-    return choice
-
-
-def config_func(_: Namespace):
-    default_profile_name = None
-    default_bucket_name = None
-    default_region_name = None
-    default_subnet_id = None
-    try:
-        config = load_config()
-        default_profile_name = config.backend_config.profile_name
-        default_region_name = config.backend_config.region_name
-        default_bucket_name = config.backend_config.bucket_name
-        default_subnet_id = config.backend_config.subnet_id
-    except ConfigError:
-        pass
-    profile_name = ask_profile_name(default_profile_name)
-    if not default_region_name:
-        try:
-            my_session = boto3.session.Session(profile_name=profile_name)
-            default_region_name = my_session.region_name
-        except Exception:
-            default_region_name = "us-east-1"
-    region_name = ask_choice("Choose AWS region", [(r[0] + " [" + r[1] + "]") for r in regions],
-                             [r[1] for r in regions], default_region_name)
-    if region_name != default_region_name:
-        default_bucket_name = None
-        default_subnet_id = None
-    bucket_name = ask_bucket(profile_name, region_name, default_bucket_name, default_subnet_id)
-    subnet_id = ask_subnet(profile_name, region_name, default_subnet_id)
-    config = Config(AwsBackendConfig(profile_name, region_name, bucket_name, subnet_id))
-    backend = load_backend(config)
-    backend.configure()
-    write_config(config)
-    print(f"[grey58]OK[/]")
-
-
-def ask_profile_name(default_profile_name):
-    profiles = []
-    try:
-        my_session = boto3.session.Session()
-        profiles.extend(my_session.available_profiles)
-    except Exception:
-        pass
-    if len(profiles) > 1:
-        profile_name = ask_choice("Choose AWS profile", profiles, profiles, default_profile_name)
-    elif len(profiles) == 1:
-        profile_name = profiles[0]
-        print(f"[sea_green3 bold]✓[/sea_green3 bold] [gray46]AWS profile: {profile_name}[/gray46]")
-    else:
-        profile_name = "default"
-        print(f"[sea_green3 bold]✓[/sea_green3 bold] [gray46]AWS profile: {profile_name}[/gray46]")
-    if profile_name == "default":
-        profile_name = None
-    return profile_name
-
-
-def ask_bucket(profile_name: Optional[str], region_name: str, default_bucket_name: Optional[str],
-               default_subnet_id: Optional[str]):
-    bucket_options = []
-    if not default_bucket_name:
-        try:
-            my_session = boto3.session.Session(profile_name=profile_name, region_name=region_name)
-            sts_client = my_session.client("sts")
-            account_id = sts_client.get_caller_identity()["Account"]
-            default_bucket_name = f"dstack-{account_id}-{region_name}"
-            bucket_options.append(f"Default [{default_bucket_name}]")
-        except Exception:
-            pass
-    else:
-        bucket_options.append(f"Default [{default_bucket_name}]")
-    bucket_options.append("Custom...")
-    if _is_termios_available and len(bucket_options) == 2:
-        from simple_term_menu import TerminalMenu
-        print("[sea_green3 bold]?[/sea_green3 bold] [bold]Choose S3 bucket[/bold] "
-              "[gray46]Use arrows to move, type to filter[/gray46]")
-        bucket_menu = TerminalMenu(bucket_options, menu_cursor_style=["fg_red", "bold"],
-                                   menu_highlight_style=["fg_red", "bold"],
-                                   search_highlight_style=["fg_purple"])
-        bucket_index = bucket_menu.show()
-        bucket_title = bucket_options[bucket_index].replace("[", "\\[")
-        print(f"[sea_green3 bold]✓[/sea_green3 bold] [grey74]{bucket_title}[/grey74]")
-    else:
-        bucket_index = 1
-    if bucket_index == 0 and default_bucket_name:
-        bucket_name = default_bucket_name
-        config = Config(AwsBackendConfig(profile_name, region_name, bucket_name, default_subnet_id))
-        backend = load_backend(config)
-        if backend.validate_bucket():
-            return bucket_name
-        else:
-            return ask_bucket(profile_name, region_name, default_bucket_name, default_subnet_id)
-    else:
-        return ask_bucket_name(profile_name, region_name, default_bucket_name, default_subnet_id)
-
-
-def ask_bucket_name(profile_name: Optional[str], region_name: str, default_bucket_name: Optional[str],
-                    default_subnet_id: Optional[str]):
-    bucket_name = Prompt.ask("[sea_green3 bold]?[/sea_green3 bold] [bold]Enter S3 bucket name[/bold]",
-                             default=default_bucket_name)
-    match = re.compile(r"(?!(^xn--|-s3alias$))^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$").match(bucket_name)
-    if match:
-        config = Config(AwsBackendConfig(profile_name, region_name, bucket_name, default_subnet_id))
-        backend = load_backend(config)
-        if backend.validate_bucket():
-            return bucket_name
-        else:
-            return ask_bucket(profile_name, region_name, default_bucket_name, default_subnet_id)
-    else:
-        print("[red bold]✗[/red bold] [red]Bucket name is not valid. "
-              "Check naming rules: "
-              "https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html[/red]")
-        return ask_bucket_name(profile_name, region_name, default_bucket_name, default_subnet_id)
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("config", help="Configure the backend")
-    parser.set_defaults(func=config_func)

dstack/cli/dashboard.py

@@ -1,26 +0,0 @@
-import argparse
-import os
-from argparse import Namespace
-
-import uvicorn
-
-from dstack import version
-
-
-def dashboard_func(args: Namespace):
-    os.environ["DSTACK_DASHBOARD_HOST"] = args.host
-    os.environ["DSTACK_DASHBOARD_PORT"] = str(args.port)
-    os.environ["DSTACK_DASHBOARD_HEADLESS"] = str(args.headless)
-    uvicorn.run("dstack.dashboard.main:app", host=args.host, port=args.port,
-                reload=version.__version__ is None, log_level="error")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("dashboard", help=argparse.SUPPRESS)
-    parser.add_argument("--host", metavar="HOST", type=str, help="Bind socket to this host.  Default: 127.0.0.1",
-                        default="127.0.0.1")
-    parser.add_argument("-p", "--port", metavar="PORT", type=int, help="Bind socket to this port. Default: 8000.",
-                        default=8000)
-    parser.add_argument("--headless", help="If false, will attempt to open a browser window on start. Default: false.",
-                        action="store_true")
-    parser.set_defaults(func=dashboard_func)

dstack/cli/delete.py

@@ -1,49 +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 delete_func(args: Namespace):
-    if (args.run_name and (args.yes or Confirm.ask(f"[red]Delete the run '{args.run_name}'?[/]"))) \
-            or (args.all and (args.yes or Confirm.ask("[red]Delete 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:
-                finished_job_heads = []
-                for job_head in job_heads:
-                    if job_head.status.is_finished():
-                        finished_job_heads.append(job_head)
-                    elif args.run_name:
-                        sys.exit("The run is not finished yet. Stop the run first.")
-                for job_head in finished_job_heads:
-                    backend.delete_job_head(repo_data.repo_user_name, repo_data.repo_name, job_head.job_id)
-                print(f"[grey58]OK[/]")
-            elif args.run_name:
-                sys.exit(f"Cannot find the run '{args.run_name}'")
-        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 delete all runs")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("delete", help="Delete runs")
-
-    parser.add_argument("run_name", metavar="RUN", type=str, nargs="?", help="A name of a run")
-    parser.add_argument("-a", "--all", help="Delete all finished runs", dest="all", action="store_true")
-    parser.add_argument("-y", "--yes", help="Don't ask for confirmation", action="store_true")
-
-    parser.set_defaults(func=delete_func)

dstack/cli/init.py

@@ -1,33 +0,0 @@
-import os
-import sys
-from argparse import Namespace
-
-from git import InvalidGitRepositoryError
-from rich import print
-
-from dstack.backend import load_backend
-from dstack.config import ConfigError
-from dstack.repo import load_repo_data
-
-
-def init_func(args: Namespace):
-    try:
-        local_repo_data = load_repo_data(args.gh_token, args.identity_file)
-        local_repo_data.ls_remote()
-        backend = load_backend()
-        backend.save_repo_credentials(local_repo_data.repo_user_name, local_repo_data.repo_name,
-                                      local_repo_data.repo_credentials())
-        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")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("init", help="Authorize dstack to access the current GitHub repo")
-    parser.add_argument("-t", "--token", metavar="GITHUB_TOKEN", help="An authentication token for GitHub", type=str,
-                        dest="gh_token")
-    parser.add_argument("-i", "--identity", metavar="SSH_PRIVATE_KEY", help="A path to the private SSH key file",
-                        type=str, dest="identity_file")
-    parser.set_defaults(func=init_func)

dstack/cli/logs.py

@@ -1,87 +0,0 @@
-import os
-import re
-import sys
-from argparse import Namespace
-from datetime import datetime, timedelta
-from typing import List
-
-from botocore.utils import parse_timestamp, datetime2timestamp
-from git import InvalidGitRepositoryError
-from rich import print
-
-from dstack.backend import load_backend, Backend
-from dstack.jobs import JobHead
-from dstack.repo import load_repo_data
-from dstack.config import ConfigError
-
-
-def _relative_timestamp_to_datetime(amount, unit):
-    multiplier = {
-        's': 1,
-        'm': 60,
-        'h': 3600,
-        'd': 24 * 3600,
-        'w': 7 * 24 * 3600,
-    }[unit]
-    return datetime.utcnow() + timedelta(seconds=amount * multiplier * -1)
-
-
-def since(timestamp):
-    regex = re.compile(
-        r"(?P<amount>\d+)(?P<unit>s|m|h|d|w)$"
-    )
-    re_match = regex.match(timestamp)
-    if re_match:
-        datetime_value = _relative_timestamp_to_datetime(
-            int(re_match.group('amount')), re_match.group('unit')
-        )
-    else:
-        datetime_value = parse_timestamp(timestamp)
-    return int(datetime2timestamp(datetime_value) * 1000)
-
-
-def logs_func(args: Namespace):
-    try:
-        backend = load_backend()
-        repo_data = load_repo_data()
-        start_time = since(args.since)
-        job_heads = backend.list_job_heads(repo_data.repo_user_name, repo_data.repo_name, args.run_name)
-        if job_heads:
-            poll_logs(backend, repo_data.repo_user_name, repo_data.repo_name, job_heads, start_time, args.attach)
-        else:
-            sys.exit(f"Cannot find the run '{args.run_name}'")
-    except InvalidGitRepositoryError:
-        sys.exit(f"{os.getcwd()} is not a Git repo")
-    except ConfigError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def poll_logs(backend: Backend, repo_user_name: str, repo_name: str, job_heads: List[JobHead], start_time: int,
-              attach: bool, from_run: bool = False):
-    try:
-        for event in backend.poll_logs(repo_user_name, repo_name, job_heads, start_time, attach):
-            print(event.log_message)
-    except KeyboardInterrupt as e:
-        if attach is True:
-            # The only way to exit from the --attach is to Ctrl-C. So
-            # we should exit the iterator rather than having the
-            # KeyboardInterrupt propagate to the rest of the command.
-            if from_run:
-                raise e
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("logs", help="Show logs")
-
-    # TODO: Add --format (short|detailed)
-    parser.add_argument("run_name", metavar="RUN", type=str, help="A name of a run")
-    parser.add_argument("-a", "--attach", help="Whether to continuously poll for new logs. By default, the command "
-                                               "will exit once there are no more logs to display. To exit from this "
-                                               "mode, use Control-C.", action="store_true")
-    parser.add_argument("-s", "--since",
-                        help="From what time to begin displaying logs. By default, logs will be displayed starting "
-                             "from 24 hours in the past. The value provided can be an ISO 8601 timestamp or a "
-                             "relative time. For example, a value of 5m would indicate to display logs starting five "
-                             "minutes in the past.", type=str, default="1d")
-
-    parser.set_defaults(func=logs_func)

dstack/cli/main.py

@@ -1,81 +0,0 @@
-import sys
-from argparse import ArgumentParser, SUPPRESS, Namespace
-
-from dstack.cli import app, logs, run, stop, artifacts, status, init, \
-    restart, delete, tags, config, dashboard, secrets
-from dstack.version import __version__ as version
-from rich import print
-
-
-def default_func(_: Namespace):
-    print("Usage: [bold]dstack [grey53][-h] [-v] [OPTIONS ...][/grey53] " +
-          "COMMAND [grey53][ARGS ...][/grey53][/bold]\n"
-          "\n"
-          "Not sure where to start? Call [yellow bold]dstack config[/yellow bold], followed by [yellow bold]dstack init[/yellow bold].\n"
-          "Define workflows in [bold].dstack/workflows.yaml[/bold] and run them via [bold]dstack run[/bold].\n"
-          "\n"
-          "Main commands:\n"
-          "  [bold]dstack run WORKFLOW [grey53][-d] [-t TAG] [ARGS ...][/grey53][/bold]           Run a workflow\n"
-          "  [bold]dstack ps [grey53][-a | RUN][/grey53][/bold]                                   Show [reset]run(s)[/reset] status\n"
-          "  [bold]dstack stop [grey53][-x] [-y][/grey53] [grey53]([/grey53]RUN [grey53]|[/grey53] -a[grey53])[/grey53][/bold]                       Stop [reset]run(s)[/reset]\n"
-          "  [bold]dstack logs [grey53][-a] [-s SINCE][/grey53] RUN[/bold]                        Show logs of a run\n"
-          "  [bold]dstack artifacts list [grey53]([/grey53]RUN [grey53]|[/grey53] :TAG[grey53])[/grey53][/bold]                     List artifacts\n"
-          "  [bold]dstack artifacts download [grey53]([/grey53]RUN [grey53]|[/grey53] :TAG[grey53])[/grey53][/bold]                 Download artifacts\n"
-          "\n"
-          "Other commands:\n"
-          # "dashboard      Launch a dashboard\n"
-          # "app            Open a running application\n"
-          "  [bold]dstack init [grey53][-t GITHUB_TOKEN | -i SSH_PRIVATE_KEY][/grey53][/bold]     " +
-          "Initialize the repo\n"
-          "  [bold]dstack config[/bold]                                          Configure the backend\n"
-          "  [bold]dstack tags add TAG [grey53]([/grey53]-r RUN [grey53]|[/grey53] -a PATH [grey53]...)[/grey53][/bold]             Add a tag\n"
-          "  [bold]dstack tags delete [grey53][-y][/grey53] TAG[/bold]                            Delete a tag\n"
-          "  [bold]dstack tags list[/bold]                                       List tags\n"
-          "  [bold]dstack secrets add [grey53][-y][/grey53] NAME [grey53][VALUE][/grey53][/bold]                   Add a secret\n"
-          "  [bold]dstack secrets list[/bold]                                    List secrets\n"
-          "  [bold]dstack secrets delete NAME[/bold]                             Delete a secret\n"
-          # "restart        Restart a run\n"
-          "  [bold]dstack delete [grey53][-y][/grey53] [grey53]([/grey53]RUN [grey53]|[/grey53] -a[grey53])[/grey53][/bold]                          Delete [reset]run(s)[/reset]\n"
-          "\n"
-          "Global options:\n"
-          "  [bold]-h[/bold], [bold]--help[/bold]                                             Show this help output\n"
-          "  [bold]-v[/bold], [bold]--version[/bold]                                          Show dstack version\n"
-          "\n"
-          "For more details, check https://docs.dstack.ai/reference/cli\n"
-          )
-
-
-def main():
-    parser = ArgumentParser(add_help=False)
-    parser.add_argument("-v", "--version", action="version", version=f"{version}", help="Show program's version")
-    parser.add_argument('-h', '--help', action='store_true', default=SUPPRESS,
-                        help='Show this help message and exit')
-    parser.set_defaults(func=default_func)
-
-    subparsers = parser.add_subparsers()
-
-    # app.register_parsers(subparsers)
-    artifacts.register_parsers(subparsers)
-    config.register_parsers(subparsers)
-    init.register_parsers(subparsers)
-    logs.register_parsers(subparsers)
-    delete.register_parsers(subparsers)
-    # restart.register_parsers(subparsers)
-    run.register_parsers(subparsers)
-    secrets.register_parsers(subparsers)
-    status.register_parsers(subparsers)
-    stop.register_parsers(subparsers)
-    tags.register_parsers(subparsers)
-    dashboard.register_parsers(subparsers)
-
-    if len(sys.argv) < 2:
-        default_func(Namespace())
-        exit(1)
-
-    args, unknown = parser.parse_known_args()
-    args.unknown = unknown
-    args.func(args)
-
-
-if __name__ == '__main__':
-    main()

dstack/cli/restart.py

@@ -1,43 +0,0 @@
-import json
-import sys
-from argparse import Namespace
-
-from rich import print
-import requests
-
-
-def default_restart_workflow(args: Namespace):
-    try:
-        dstack_config = get_config()
-        # TODO: Support non-default profiles
-        profile = dstack_config.get_profile("default")
-        headers = {
-            "Content-Type": f"application/json; charset=utf-8"
-        }
-        if profile.token is not None:
-            headers["Authorization"] = f"Bearer {profile.token}"
-
-        data = {"run_name": args.run_name, "clear": args.clear is True}
-        if args.workflow_name:
-            data["workflow_name"] = args.workflow_name
-        else:
-            data["all"] = True
-        response = requests.request(method="POST", url=f"{profile.server}/runs/workflows/restart",
-                                    data=json.dumps(data).encode("utf-8"),
-                                    headers=headers, verify=profile.verify)
-        if response.status_code != 200:
-            response.raise_for_status()
-        print(f"[grey58]OK[/]")
-    except ConfigurationError:
-        sys.exit(f"Call 'dstack config' first")
-
-
-def register_parsers(main_subparsers):
-    parser = main_subparsers.add_parser("restart", help="Restart a run")
-
-    parser.add_argument("run_name", metavar="RUN", type=str, help="A name of a run")
-    parser.add_argument("-c", "--clear",
-                        help="Clear logs and artifacts. By default, is false",
-                        action="store_true")
-
-    parser.set_defaults(func=default_restart_workflow)