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

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

@@ -0,0 +1,222 @@
+import argparse
+import time
+
+from rich.table import Table
+
+from dstack._internal.cli.services.configurators.base import BaseApplyConfigurator
+from dstack._internal.cli.utils.common import (
+    LIVE_TABLE_PROVISION_INTERVAL_SECS,
+    confirm_ask,
+    console,
+)
+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.volumes import (
+    Volume,
+    VolumeConfiguration,
+    VolumePlan,
+    VolumeSpec,
+    VolumeStatus,
+)
+from dstack._internal.utils.common import local_time
+from dstack.api._public import Client
+
+
+class VolumeConfigurator(BaseApplyConfigurator[VolumeConfiguration]):
+    TYPE = ApplyConfigurationType.VOLUME
+
+    def apply_configuration(
+        self,
+        conf: VolumeConfiguration,
+        configuration_path: str,
+        command_args: argparse.Namespace,
+        configurator_args: argparse.Namespace,
+    ):
+        self.apply_args(conf, configurator_args)
+        spec = VolumeSpec(
+            configuration=conf,
+            configuration_path=configuration_path,
+        )
+        with console.status("Getting apply plan..."):
+            plan = _get_plan(api=self.api, spec=spec)
+        _print_plan_header(plan)
+
+        action_message = ""
+        confirm_message = ""
+        if plan.current_resource is None:
+            if plan.spec.configuration.name is not None:
+                action_message += (
+                    f"Volume [code]{plan.spec.configuration.name}[/] does not exist yet."
+                )
+            confirm_message += "Create the volume?"
+        else:
+            action_message += f"Found volume [code]{plan.spec.configuration.name}[/]."
+            if plan.current_resource.configuration == plan.spec.configuration:
+                if command_args.yes and not command_args.force:
+                    # --force is required only with --yes,
+                    # otherwise we may ask for force apply interactively.
+                    console.print(
+                        "No configuration changes detected. Use --force to apply anyway."
+                    )
+                    return
+                action_message += " No configuration changes detected."
+                confirm_message += "Re-create the volume?"
+            else:
+                action_message += " Configuration changes detected."
+                confirm_message += "Re-create the volume?"
+
+        console.print(action_message)
+        if not command_args.yes and not confirm_ask(confirm_message):
+            console.print("\nExiting...")
+            return
+
+        if plan.current_resource is not None:
+            with console.status("Deleting existing volume..."):
+                self.api.client.volumes.delete(
+                    project_name=self.api.project, names=[plan.current_resource.name]
+                )
+                # Volume deletion is async. Wait for volume to be deleted.
+                while True:
+                    try:
+                        self.api.client.volumes.get(
+                            project_name=self.api.project, name=plan.current_resource.name
+                        )
+                    except ResourceNotExistsError:
+                        break
+                    else:
+                        time.sleep(1)
+
+        with console.status("Creating volume..."):
+            volume = self.api.client.volumes.create(
+                project_name=self.api.project,
+                configuration=conf,
+            )
+        if command_args.detach:
+            console.print("Volume configuration submitted. Exiting...")
+            return
+        try:
+            with MultiItemStatus(
+                f"Provisioning [code]{volume.name}[/]...", console=console
+            ) as live:
+                while not _finished_provisioning(volume):
+                    table = get_volumes_table([volume])
+                    live.update(table)
+                    time.sleep(LIVE_TABLE_PROVISION_INTERVAL_SECS)
+                    volume = self.api.client.volumes.get(self.api.project, volume.name)
+        except KeyboardInterrupt:
+            if not command_args.yes and confirm_ask("Delete the volume before exiting?"):
+                with console.status("Deleting volume..."):
+                    self.api.client.volumes.delete(
+                        project_name=self.api.project, names=[volume.name]
+                    )
+            else:
+                console.print("Exiting... Volume provisioning will continue in the background.")
+            return
+        console.print(
+            get_volumes_table(
+                [volume],
+                verbose=volume.status == VolumeStatus.FAILED,
+                format_date=local_time,
+            )
+        )
+        if volume.status == VolumeStatus.FAILED:
+            console.print(
+                f"\n[error]Provisioning failed. Error: {volume.status_message or 'unknown'}[/]"
+            )
+            exit(1)
+
+    def delete_configuration(
+        self,
+        conf: VolumeConfiguration,
+        configuration_path: str,
+        command_args: argparse.Namespace,
+    ):
+        if conf.name is None:
+            console.print("[error]Configuration specifies no volume to delete[/]")
+            exit(1)
+
+        try:
+            self.api.client.volumes.get(
+                project_name=self.api.project,
+                name=conf.name,
+            )
+        except ResourceNotExistsError:
+            console.print(f"Volume [code]{conf.name}[/] does not exist")
+            exit(1)
+
+        if not command_args.yes and not confirm_ask(f"Delete the volume [code]{conf.name}[/]?"):
+            console.print("\nExiting...")
+            return
+
+        with console.status("Deleting volume..."):
+            self.api.client.volumes.delete(project_name=self.api.project, names=[conf.name])
+
+        console.print(f"Volume [code]{conf.name}[/] deleted")
+
+    @classmethod
+    def register_args(cls, parser: argparse.ArgumentParser):
+        configuration_group = parser.add_argument_group(f"{cls.TYPE.value} Options")
+        configuration_group.add_argument(
+            "-n",
+            "--name",
+            dest="name",
+            help="The volume name",
+        )
+
+    def apply_args(self, conf: VolumeConfiguration, args: argparse.Namespace):
+        if args.name:
+            conf.name = args.name
+
+
+def _get_plan(api: Client, spec: VolumeSpec) -> VolumePlan:
+    # TODO: Implement server-side /get_plan with an offer included
+    user = api.client.users.get_my_user()
+    current_resource = None
+    if spec.configuration.name is not None:
+        try:
+            current_resource = api.client.volumes.get(
+                project_name=api.project, name=spec.configuration.name
+            )
+        except ResourceNotExistsError:
+            pass
+    return VolumePlan(
+        project_name=api.project,
+        user=user.username,
+        spec=spec,
+        current_resource=current_resource,
+    )
+
+
+def _print_plan_header(plan: VolumePlan):
+    def th(s: str) -> str:
+        return f"[bold]{s}[/bold]"
+
+    configuration_table = Table(box=None, show_header=False)
+    configuration_table.add_column(no_wrap=True)  # key
+    configuration_table.add_column()  # value
+
+    configuration_table.add_row(th("Project"), plan.project_name)
+    configuration_table.add_row(th("User"), plan.user)
+    configuration_table.add_row(th("Configuration"), plan.spec.configuration_path)
+    configuration_table.add_row(th("Type"), plan.spec.configuration.type)
+
+    volume_type = "managed"
+    size = "-"
+    if plan.spec.configuration.size is not None:
+        size = str(plan.spec.configuration.size)
+    if plan.spec.configuration.volume_id is not None:
+        volume_type = "external"
+
+    configuration_table.add_row(th("Volume type"), volume_type)
+    configuration_table.add_row(th("Backend"), plan.spec.configuration.backend.value)
+    configuration_table.add_row(th("Region"), plan.spec.configuration.region)
+    configuration_table.add_row(th("Size"), size)
+
+    console.print(configuration_table)
+    console.print()
+
+
+def _finished_provisioning(volume: Volume) -> bool:
+    return volume.status in [VolumeStatus.ACTIVE, VolumeStatus.FAILED]

dstack/_internal/cli/services/events.py

@@ -0,0 +1,68 @@
+import uuid
+from collections.abc import Iterator
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import Optional
+
+from rich.text import Text
+
+from dstack._internal.cli.utils.common import console
+from dstack._internal.core.models.events import Event, EventTargetType
+from dstack._internal.server.schemas.events import LIST_EVENTS_DEFAULT_LIMIT
+from dstack.api.server._events import EventsAPIClient
+
+
+@dataclass
+class EventListFilters:
+    target_fleets: Optional[list[uuid.UUID]] = None
+    target_runs: Optional[list[uuid.UUID]] = None
+    target_volumes: Optional[list[uuid.UUID]] = None
+    target_gateways: Optional[list[uuid.UUID]] = None
+    target_secrets: Optional[list[uuid.UUID]] = None
+    within_projects: Optional[list[uuid.UUID]] = None
+    within_fleets: Optional[list[uuid.UUID]] = None
+    within_runs: Optional[list[uuid.UUID]] = None
+    include_target_types: Optional[list[EventTargetType]] = None
+
+
+class EventPaginator:
+    def __init__(self, client: EventsAPIClient) -> None:
+        self._client = client
+
+    def list(
+        self, filters: EventListFilters, since: Optional[datetime], ascending: bool
+    ) -> Iterator[Event]:
+        prev_id = None
+        prev_recorded_at = since
+        while True:
+            events = self._client.list(
+                prev_id=prev_id,
+                prev_recorded_at=prev_recorded_at,
+                limit=LIST_EVENTS_DEFAULT_LIMIT,
+                ascending=ascending,
+                **asdict(filters),
+            )
+            for event in events:
+                yield event
+            if len(events) < LIST_EVENTS_DEFAULT_LIMIT:
+                break
+            prev_id = events[-1].id
+            prev_recorded_at = events[-1].recorded_at
+
+
+def print_event(event: Event) -> None:
+    recorded_at = event.recorded_at.astimezone().strftime("%Y-%m-%d %H:%M:%S")
+    targets = ", ".join(f"{target.type} {target.name}" for target in event.targets)
+    message = [
+        Text(f"[{recorded_at}]", style="log.time"),
+    ]
+    if event.actor_user:
+        message.append(Text(f"[👤{event.actor_user}]", style="secondary"))
+    message += [
+        Text(f"[{targets}]", style="secondary"),
+        Text(event.message, style="log.message"),
+    ]
+    console.print(
+        *message,
+        soft_wrap=True,  # Strictly one line per event. Allows for grepping
+    )

dstack/_internal/cli/services/profile.py

@@ -0,0 +1,182 @@
+import argparse
+import os
+from typing import Union
+
+from dstack._internal.core.models.configurations import AnyRunConfiguration
+from dstack._internal.core.models.profiles import (
+    CreationPolicy,
+    Profile,
+    ProfileRetry,
+    SpotPolicy,
+    parse_duration,
+    parse_max_duration,
+)
+
+
+def register_profile_args(parser: argparse.ArgumentParser):
+    """
+    Registers `parser` with `dstack apply` run configuration
+    CLI arguments that override `profiles.yml` settings.
+    """
+    profile_group = parser.add_argument_group("Profile")
+    profile_group.add_argument(
+        "--profile",
+        metavar="NAME",
+        help="The name of the profile. Defaults to [code]$DSTACK_PROFILE[/]",
+        default=os.getenv("DSTACK_PROFILE"),
+        dest="profile",
+    )
+    profile_group.add_argument(
+        "--max-price",
+        metavar="PRICE",
+        type=float,
+        help="The maximum price per hour, in dollars",
+        dest="max_price",
+    )
+    profile_group.add_argument(
+        "--max-duration",
+        type=max_duration,
+        dest="max_duration",
+        help="The maximum duration of the run",
+        metavar="DURATION",
+    )
+    profile_group.add_argument(
+        "-b",
+        "--backend",
+        action="append",
+        metavar="NAME",
+        dest="backends",
+        help="The backends that will be tried for provisioning",
+    )
+    profile_group.add_argument(
+        "-r",
+        "--region",
+        action="append",
+        metavar="NAME",
+        dest="regions",
+        help="The regions that will be tried for provisioning",
+    )
+    profile_group.add_argument(
+        "--instance-type",
+        action="append",
+        metavar="NAME",
+        dest="instance_types",
+        help="The cloud-specific instance types that will be tried for provisioning",
+    )
+
+    fleets_group = parser.add_argument_group("Fleets")
+    fleets_group.add_argument(
+        "--fleet",
+        action="append",
+        metavar="NAME",
+        dest="fleets",
+        help="Consider only instances from the specified fleet(s) for reuse",
+    )
+    fleets_group_exc = fleets_group.add_mutually_exclusive_group()
+    fleets_group_exc.add_argument(
+        "-R",
+        "--reuse",
+        dest="creation_policy_reuse",
+        action="store_true",
+        help="Reuse an existing instance from fleet (do not provision a new one)",
+    )
+    fleets_group_exc.add_argument(
+        "--dont-destroy",
+        dest="dont_destroy",
+        action="store_true",
+        help="Do not destroy instance after the run is finished (if the run provisions a new instance)",
+    )
+    fleets_group_exc.add_argument(
+        "--idle-duration",
+        dest="idle_duration",
+        type=str,
+        help="Time to wait before destroying the idle instance (if the run provisions a new instance)",
+    )
+
+    spot_group = parser.add_argument_group("Spot policy")
+    spot_group_exc = spot_group.add_mutually_exclusive_group()
+    spot_group_exc.add_argument(
+        "--spot",
+        action="store_const",
+        dest="spot_policy",
+        const=SpotPolicy.SPOT,
+        help="Consider only spot instances",
+    )
+    spot_group_exc.add_argument(
+        "--on-demand",
+        action="store_const",
+        dest="spot_policy",
+        const=SpotPolicy.ONDEMAND,
+        help="Consider only on-demand instances",
+    )
+    spot_group_exc.add_argument(
+        "--spot-auto",
+        action="store_const",
+        dest="spot_policy",
+        const=SpotPolicy.AUTO,
+        help="Consider both spot and on-demand instances",
+    )
+    spot_group_exc.add_argument(
+        "--spot-policy",
+        type=SpotPolicy,
+        dest="spot_policy",
+        metavar="POLICY",
+        help="One of %s" % ", ".join([f"[code]{i.value}[/]" for i in SpotPolicy]),
+    )
+
+    retry_group = parser.add_argument_group("Retry policy")
+    retry_group_exc = retry_group.add_mutually_exclusive_group()
+    retry_group_exc.add_argument("--retry", action="store_const", dest="retry", const=True)
+    retry_group_exc.add_argument("--no-retry", action="store_const", dest="retry", const=False)
+    retry_group_exc.add_argument(
+        "--retry-duration", type=retry_duration, dest="retry_duration", metavar="DURATION"
+    )
+
+
+def apply_profile_args(
+    args: argparse.Namespace,
+    profile_settings: Union[Profile, AnyRunConfiguration],
+):
+    """
+    Overrides `profile_settings` settings with arguments registered by `register_profile_args()`.
+    """
+    # TODO: Re-assigned profile attributes are not validated by pydantic.
+    # So the validation will only be done by the server.
+    # Consider setting validate_assignment=True for modified pydantic models.
+    if args.backends:
+        profile_settings.backends = args.backends
+    if args.regions:
+        profile_settings.regions = args.regions
+    if args.instance_types:
+        profile_settings.instance_types = args.instance_types
+    if args.max_price is not None:
+        profile_settings.max_price = args.max_price
+    if args.max_duration is not None:
+        profile_settings.max_duration = args.max_duration
+
+    if args.fleets:
+        profile_settings.fleets = args.fleets
+    if args.idle_duration is not None:
+        profile_settings.idle_duration = args.idle_duration
+    elif args.dont_destroy:
+        profile_settings.idle_duration = -1
+    if args.creation_policy_reuse:
+        profile_settings.creation_policy = CreationPolicy.REUSE
+
+    if args.spot_policy is not None:
+        profile_settings.spot_policy = args.spot_policy
+
+    if args.retry is not None:
+        profile_settings.retry = args.retry
+    elif args.retry_duration is not None:
+        profile_settings.retry = ProfileRetry(
+            duration=args.retry_duration,
+        )
+
+
+def max_duration(v: str) -> int:
+    return parse_max_duration(v)
+
+
+def retry_duration(v: str) -> int:
+    return parse_duration(v)

dstack/_internal/cli/services/repos.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+import git
+
+from dstack._internal.cli.services.configurators.base import ArgsParser
+from dstack._internal.core.errors import CLIError
+from dstack._internal.core.models.repos.remote import GitRepoURL, RemoteRepo, RepoError
+from dstack._internal.core.models.repos.virtual import VirtualRepo
+from dstack._internal.utils.path import PathLike
+from dstack.api._public import Client
+
+
+def register_init_repo_args(parser: ArgsParser):
+    parser.add_argument(
+        "-t",
+        "--token",
+        metavar="OAUTH_TOKEN",
+        help="An authentication token to access a private Git repo",
+        type=str,
+        dest="gh_token",
+    )
+    parser.add_argument(
+        "--git-identity",
+        metavar="SSH_PRIVATE_KEY",
+        help="The private SSH key path to access a private Git repo",
+        type=str,
+        dest="git_identity_file",
+    )
+
+
+def init_default_virtual_repo(api: Client) -> VirtualRepo:
+    repo = VirtualRepo()
+    api.repos.init(repo)
+    return repo
+
+
+def get_repo_from_dir(repo_dir: PathLike) -> RemoteRepo:
+    repo_dir = Path(repo_dir)
+    if not repo_dir.exists():
+        raise CLIError(f"Path does not exist: {repo_dir}")
+    if not repo_dir.is_dir():
+        raise CLIError(f"Path is not a directory: {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 git.GitError as e:
+        raise CLIError(f"{e.__class__.__name__}: {e}") from e
+    except RepoError as e:
+        raise CLIError(str(e)) from e
+
+
+def get_repo_from_url(repo_url: str) -> RemoteRepo:
+    try:
+        return RemoteRepo.from_url(repo_url)
+    except git.GitError as e:
+        raise CLIError(f"{e.__class__.__name__}: {e}") from e
+    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/cli/services/resources.py

@@ -0,0 +1,54 @@
+import argparse
+
+from dstack._internal.cli.services.args import cpu_spec, disk_spec, gpu_spec, memory_spec
+from dstack._internal.cli.services.configurators.base import ArgsParser
+from dstack._internal.core.models import resources
+from dstack._internal.core.models.configurations import AnyRunConfiguration
+
+
+def register_resources_args(parser: ArgsParser) -> None:
+    parser.add_argument(
+        "--cpu",
+        type=cpu_spec,
+        help=(
+            "Request CPU for the run."
+            " The format is [code]ARCH[/]:[code]COUNT[/] (all parts are optional)"
+        ),
+        dest="cpu_spec",
+        metavar="SPEC",
+    )
+    parser.add_argument(
+        "--gpu",
+        type=gpu_spec,
+        help=(
+            "Request GPU for the run."
+            " The format is [code]NAME[/]:[code]COUNT[/]:[code]MEMORY[/] (all parts are optional)"
+        ),
+        dest="gpu_spec",
+        metavar="SPEC",
+    )
+    parser.add_argument(
+        "--memory",
+        type=memory_spec,
+        help="Request the size range of RAM for the run. Example [code]--memory 128GB..256GB[/]",
+        dest="memory_spec",
+        metavar="RANGE",
+    )
+    parser.add_argument(
+        "--disk",
+        type=disk_spec,
+        help="Request the size range of disk for the run. Example [code]--disk 100GB..[/]",
+        dest="disk_spec",
+        metavar="RANGE",
+    )
+
+
+def apply_resources_args(args: argparse.Namespace, conf: AnyRunConfiguration) -> None:
+    if args.cpu_spec:
+        conf.resources.cpu = resources.CPUSpec.parse_obj(args.cpu_spec)
+    if args.gpu_spec:
+        conf.resources.gpu = resources.GPUSpec.parse_obj(args.gpu_spec)
+    if args.memory_spec:
+        conf.resources.memory = args.memory_spec
+    if args.disk_spec:
+        conf.resources.disk = args.disk_spec