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

dstack/_internal/cli/commands/apply.py

@@ -1,4 +1,5 @@
 import argparse
+from pathlib import Path
 
 from argcomplete import FilesCompleter
 
@@ -13,7 +14,7 @@ from dstack._internal.cli.services.repos import (
     init_repo,
     register_init_repo_args,
 )
-from dstack._internal.cli.utils.common import console
+from dstack._internal.cli.utils.common import console, warn
 from dstack._internal.core.errors import CLIError
 from dstack._internal.core.models.configurations import ApplyConfigurationType
 
@@ -65,6 +66,13 @@ class ApplyCommand(APIBaseCommand):
             help="Exit immediately after submitting configuration",
             action="store_true",
         )
+        self._parser.add_argument(
+            "--ssh-identity",
+            metavar="SSH_PRIVATE_KEY",
+            help="The private SSH key path for SSH tunneling",
+            type=Path,
+            dest="ssh_identity_file",
+        )
         repo_group = self._parser.add_argument_group("Repo Options")
         repo_group.add_argument(
             "-P",
@@ -111,6 +119,11 @@ class ApplyCommand(APIBaseCommand):
                 raise CLIError("Cannot read configuration from stdin if -y/--yes is not specified")
             if args.repo and args.no_repo:
                 raise CLIError("Either --repo or --no-repo can be specified")
+            if args.local:
+                warn(
+                    "Local repos are deprecated since 0.19.25 and will be removed soon."
+                    " Consider using `files` instead: https://dstack.ai/docs/concepts/tasks/#files"
+                )
             repo = None
             if args.repo:
                 repo = init_repo(
@@ -121,7 +134,6 @@ class ApplyCommand(APIBaseCommand):
                     local=args.local,
                     git_identity_file=args.git_identity_file,
                     oauth_token=args.gh_token,
-                    ssh_identity_file=args.ssh_identity_file,
                 )
             elif args.no_repo:
                 repo = init_default_virtual_repo(api=self.api)

dstack/_internal/cli/commands/init.py

@@ -4,7 +4,10 @@ from pathlib import Path
 
 from dstack._internal.cli.commands import BaseCommand
 from dstack._internal.cli.services.repos import init_repo, register_init_repo_args
-from dstack._internal.cli.utils.common import configure_logging, console
+from dstack._internal.cli.utils.common import configure_logging, confirm_ask, console, warn
+from dstack._internal.core.errors import ConfigurationError
+from dstack._internal.core.models.repos.base import RepoType
+from dstack._internal.core.services.configs import ConfigManager
 from dstack.api import Client
 
 
@@ -19,12 +22,55 @@ class InitCommand(BaseCommand):
             default=os.getenv("DSTACK_PROJECT"),
         )
         register_init_repo_args(self._parser)
+        # Deprecated since 0.19.25, ignored
+        self._parser.add_argument(
+            "--ssh-identity",
+            metavar="SSH_PRIVATE_KEY",
+            help=argparse.SUPPRESS,
+            type=Path,
+            dest="ssh_identity_file",
+        )
+        # A hidden mode for transitional period only, remove it with local repos
+        self._parser.add_argument(
+            "--remove",
+            help=argparse.SUPPRESS,
+            action="store_true",
+        )
 
     def _command(self, args: argparse.Namespace):
         configure_logging()
+        if args.remove:
+            config_manager = ConfigManager()
+            repo_path = Path.cwd()
+            repo_config = config_manager.get_repo_config(repo_path)
+            if repo_config is None:
+                raise ConfigurationError("The repo is not initialized, nothing to remove")
+            if repo_config.repo_type != RepoType.LOCAL:
+                raise ConfigurationError("`dstack init --remove` is for local repos only")
+            console.print(
+                f"You are about to remove the local repo {repo_path}\n"
+                "Only the record about the repo will be removed,"
+                " the repo files will remain intact\n"
+            )
+            if not confirm_ask("Remove the local repo?"):
+                return
+            config_manager.delete_repo_config(repo_config.repo_id)
+            config_manager.save()
+            console.print("Local repo has been removed")
+            return
         api = Client.from_config(
             project_name=args.project, ssh_identity_file=args.ssh_identity_file
         )
+        if args.local:
+            warn(
+                "Local repos are deprecated since 0.19.25 and will be removed soon."
+                " Consider using `files` instead: https://dstack.ai/docs/concepts/tasks/#files"
+            )
+        if args.ssh_identity_file:
+            warn(
+                "`--ssh-identity` in `dstack init` is deprecated and ignored since 0.19.25."
+                " Use this option with `dstack apply` and `dstack attach` instead"
+            )
         init_repo(
             api=api,
             repo_path=Path.cwd(),
@@ -33,6 +79,5 @@ class InitCommand(BaseCommand):
             local=args.local,
             git_identity_file=args.git_identity_file,
             oauth_token=args.gh_token,
-            ssh_identity_file=args.ssh_identity_file,
         )
         console.print("OK")

dstack/_internal/cli/commands/offer.py

@@ -1,29 +1,20 @@
 import argparse
-import contextlib
-import json
 from pathlib import Path
+from typing import List
 
 from dstack._internal.cli.commands import APIBaseCommand
-from dstack._internal.cli.services.configurators.run import (
-    BaseRunConfigurator,
-)
+from dstack._internal.cli.services.configurators.run import BaseRunConfigurator
 from dstack._internal.cli.utils.common import console
-from dstack._internal.cli.utils.run import print_run_plan
-from dstack._internal.core.models.configurations import (
-    ApplyConfigurationType,
-    TaskConfiguration,
-)
+from dstack._internal.cli.utils.gpu import print_gpu_json, print_gpu_table
+from dstack._internal.cli.utils.run import print_offers_json, print_run_plan
+from dstack._internal.core.errors import CLIError
+from dstack._internal.core.models.configurations import ApplyConfigurationType, TaskConfiguration
 from dstack._internal.core.models.runs import RunSpec
+from dstack._internal.server.schemas.gpus import GpuGroup
 from dstack.api.utils import load_profile
 
 
 class OfferConfigurator(BaseRunConfigurator):
-    # TODO: The command currently uses `BaseRunConfigurator` to register arguments.
-    #   This includes --env, --retry-policy, and other arguments that are unnecessary for this command.
-    #   Eventually, we should introduce a base `OfferConfigurator` that doesn't include those arguments—
-    #   `BaseRunConfigurator` will inherit from `OfferConfigurator`.
-    #
-    #   Additionally, it should have its own type: `ApplyConfigurationType.OFFER`.
     TYPE = ApplyConfigurationType.TASK
 
     @classmethod
@@ -32,10 +23,18 @@ class OfferConfigurator(BaseRunConfigurator):
         parser: argparse.ArgumentParser,
     ):
         super().register_args(parser, default_max_offers=50)
+        parser.add_argument(
+            "--group-by",
+            action="append",
+            help=(
+                "Group results by fields ([code]gpu[/code], [code]backend[/code], [code]region[/code], [code]count[/code]). "
+                "Optional, but if used, must include [code]gpu[/code]. "
+                "The use of [code]region[/code] also requires [code]backend[/code]. "
+                "Can be repeated or comma-separated (e.g. [code]--group-by gpu,backend[/code])."
+            ),
+        )
 
 
-# TODO: Support aggregated offers
-# TODO: Add tests
 class OfferCommand(APIBaseCommand):
     NAME = "offer"
     DESCRIPTION = "List offers"
@@ -70,49 +69,58 @@ class OfferCommand(APIBaseCommand):
             ssh_key_pub="(dummy)",
             profile=profile,
         )
+
+        if args.group_by:
+            args.group_by = self._process_group_by_args(args.group_by)
+
+        if args.group_by and "gpu" not in args.group_by:
+            group_values = ", ".join(args.group_by)
+            raise CLIError(f"Cannot group by '{group_values}' without also grouping by 'gpu'")
+
         if args.format == "plain":
-            status = console.status("Getting offers...")
+            with console.status("Getting offers..."):
+                if args.group_by:
+                    gpus = self._list_gpus(args, run_spec)
+                    print_gpu_table(gpus, run_spec, args.group_by, self.api.project)
+                else:
+                    run_plan = self.api.client.runs.get_plan(
+                        self.api.project,
+                        run_spec,
+                        max_offers=args.max_offers,
+                    )
+                    print_run_plan(run_plan, include_run_properties=False)
         else:
-            status = contextlib.nullcontext()
-        with status:
-            run_plan = self.api.client.runs.get_plan(
-                self.api.project,
-                run_spec,
-                max_offers=args.max_offers,
-            )
-
-        job_plan = run_plan.job_plans[0]
-
-        if args.format == "json":
-            # FIXME: Should use effective_run_spec from run_plan,
-            # since the spec can be changed by the server and plugins
-            output = {
-                "project": run_plan.project_name,
-                "user": run_plan.user,
-                "resources": job_plan.job_spec.requirements.resources.dict(),
-                "max_price": (job_plan.job_spec.requirements.max_price),
-                "spot": run_spec.configuration.spot_policy,
-                "reservation": run_plan.run_spec.configuration.reservation,
-                "offers": [],
-                "total_offers": job_plan.total_offers,
-            }
-
-            for offer in job_plan.offers:
-                output["offers"].append(
-                    {
-                        "backend": (
-                            "ssh" if offer.backend.value == "remote" else offer.backend.value
-                        ),
-                        "region": offer.region,
-                        "instance_type": offer.instance.name,
-                        "resources": offer.instance.resources.dict(),
-                        "spot": offer.instance.resources.spot,
-                        "price": float(offer.price),
-                        "availability": offer.availability.value,
-                    }
+            if args.group_by:
+                gpus = self._list_gpus(args, run_spec)
+                print_gpu_json(gpus, run_spec, args.group_by, self.api.project)
+            else:
+                run_plan = self.api.client.runs.get_plan(
+                    self.api.project,
+                    run_spec,
+                    max_offers=args.max_offers,
                 )
+                print_offers_json(run_plan, run_spec)
 
-            print(json.dumps(output, indent=2))
-            return
-        else:
-            print_run_plan(run_plan, include_run_properties=False)
+    def _process_group_by_args(self, group_by_args: List[str]) -> List[str]:
+        valid_choices = {"gpu", "backend", "region", "count"}
+        processed = []
+
+        for arg in group_by_args:
+            values = [v.strip() for v in arg.split(",") if v.strip()]
+            for value in values:
+                if value in valid_choices:
+                    processed.append(value)
+                else:
+                    raise CLIError(
+                        f"Invalid group-by value: '{value}'. Valid choices are: {', '.join(sorted(valid_choices))}"
+                    )
+
+        return processed
+
+    def _list_gpus(self, args: List[str], run_spec: RunSpec) -> List[GpuGroup]:
+        group_by = [g for g in args.group_by if g != "gpu"] or None
+        return self.api.client.gpus.list_gpus(
+            self.api.project,
+            run_spec,
+            group_by=group_by,
+        )

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

@@ -15,9 +15,11 @@ from dstack._internal.cli.services.configurators.base import (
     BaseApplyConfigurator,
 )
 from dstack._internal.cli.services.profile import apply_profile_args, register_profile_args
+from dstack._internal.cli.services.repos import init_default_virtual_repo
 from dstack._internal.cli.utils.common import (
     confirm_ask,
     console,
+    warn,
 )
 from dstack._internal.cli.utils.rich import MultiItemStatus
 from dstack._internal.cli.utils.run import get_runs_table, print_run_plan
@@ -40,6 +42,7 @@ from dstack._internal.core.models.configurations import (
     TaskConfiguration,
 )
 from dstack._internal.core.models.repos.base import Repo
+from dstack._internal.core.models.repos.local import LocalRepo
 from dstack._internal.core.models.resources import CPUSpec
 from dstack._internal.core.models.runs import JobStatus, JobSubmission, RunSpec, RunStatus
 from dstack._internal.core.services.configs import ConfigManager
@@ -76,17 +79,42 @@ class BaseRunConfigurator(ApplyEnvVarsConfiguratorMixin, BaseApplyConfigurator):
         self.apply_args(conf, configurator_args, unknown_args)
         self.validate_gpu_vendor_and_image(conf)
         self.validate_cpu_arch_and_image(conf)
-        if repo is None:
-            repo = self.api.repos.load(Path.cwd())
         config_manager = ConfigManager()
-        if repo.repo_dir is not None:
-            repo_config = config_manager.get_repo_config_or_error(repo.repo_dir)
-            self.api.ssh_identity_file = repo_config.ssh_key_path
-        else:
-            self.api.ssh_identity_file = get_ssh_keypair(
-                command_args.ssh_identity_file,
-                config_manager.dstack_key_path,
-            )
+        if repo is None:
+            repo_path = Path.cwd()
+            repo_config = config_manager.get_repo_config(repo_path)
+            if repo_config is None:
+                warn(
+                    "The repo is not initialized. Starting from 0.19.25, repos are optional\n"
+                    "There are three options:\n"
+                    "  - Run `dstack init` to initialize the current directory as a repo\n"
+                    "  - Specify `--repo`\n"
+                    "  - Specify `--no-repo` to not use any repo and supress this warning"
+                    " (this will be the default in the future versions)"
+                )
+                if not command_args.yes and not confirm_ask("Continue without the repo?"):
+                    console.print("\nExiting...")
+                    return
+                repo = init_default_virtual_repo(self.api)
+            else:
+                # Unlikely, but may raise ConfigurationError if the repo does not exist
+                # on the server side (stale entry in `config.yml`)
+                repo = self.api.repos.load(repo_path)
+                if isinstance(repo, LocalRepo):
+                    warn(
+                        f"{repo.repo_dir} is a local repo.\n"
+                        "Local repos are deprecated since 0.19.25"
+                        " and will be removed soon\n"
+                        "There are two options:\n"
+                        "  - Migrate to `files`: https://dstack.ai/docs/concepts/tasks/#files\n"
+                        "  - Specify `--no-repo` if you don't need the repo at all\n"
+                        "In either case, you can run `dstack init --remove` to remove the repo"
+                        " (only the record about the repo, not its files) and this warning"
+                    )
+        self.api.ssh_identity_file = get_ssh_keypair(
+            command_args.ssh_identity_file,
+            config_manager.dstack_key_path,
+        )
         profile = load_profile(Path.cwd(), configurator_args.profile)
         with console.status("Getting apply plan..."):
             run_plan = self.api.runs.get_run_plan(

dstack/_internal/cli/services/repos.py

@@ -1,12 +1,12 @@
+import argparse
 from pathlib import Path
 from typing import Optional
 
 from dstack._internal.cli.services.configurators.base import ArgsParser
 from dstack._internal.core.errors import CLIError
-from dstack._internal.core.models.repos.base import Repo, RepoType
+from dstack._internal.core.models.repos.base import Repo
 from dstack._internal.core.models.repos.remote import GitRepoURL, RemoteRepo, RepoError
 from dstack._internal.core.models.repos.virtual import VirtualRepo
-from dstack._internal.core.services.configs import ConfigManager
 from dstack._internal.core.services.repos import get_default_branch
 from dstack._internal.utils.path import PathLike
 from dstack.api._public import Client
@@ -28,49 +28,31 @@ def register_init_repo_args(parser: ArgsParser):
         type=str,
         dest="git_identity_file",
     )
-    parser.add_argument(
-        "--ssh-identity",
-        metavar="SSH_PRIVATE_KEY",
-        help="The private SSH key path for SSH tunneling",
-        type=Path,
-        dest="ssh_identity_file",
-    )
+    # Deprecated since 0.19.25
     parser.add_argument(
         "--local",
         action="store_true",
-        help="Do not use Git",
+        help=argparse.SUPPRESS,
     )
 
 
 def init_repo(
     api: Client,
-    repo_path: Optional[PathLike],
+    repo_path: PathLike,
     repo_branch: Optional[str],
     repo_hash: Optional[str],
     local: bool,
     git_identity_file: Optional[PathLike],
     oauth_token: Optional[str],
-    ssh_identity_file: Optional[PathLike],
 ) -> Repo:
-    init = True
-    if repo_path is None:
-        init = False
-        repo_path = Path.cwd()
     if Path(repo_path).exists():
         repo = api.repos.load(
             repo_dir=repo_path,
             local=local,
-            init=init,
+            init=True,
             git_identity_file=git_identity_file,
             oauth_token=oauth_token,
         )
-        if ssh_identity_file:
-            ConfigManager().save_repo_config(
-                repo_path=repo.get_repo_dir_or_error(),
-                repo_id=repo.repo_id,
-                repo_type=RepoType(repo.run_repo_data.repo_type),
-                ssh_key_path=ssh_identity_file,
-            )
     elif isinstance(repo_path, str):
         try:
             GitRepoURL.parse(repo_path)

dstack/_internal/cli/utils/common.py

@@ -103,3 +103,10 @@ def add_row_from_dict(table: Table, data: Dict[Union[str, int], Any], **kwargs):
         else:
             row.append("")
     table.add_row(*row, **kwargs)
+
+
+def warn(message: str):
+    if not message.endswith("\n"):
+        # Additional blank line for better visibility if there are more than one warning
+        message = f"{message}\n"
+    console.print(f"[warning][bold]{message}[/]")

dstack/_internal/cli/utils/gpu.py

@@ -0,0 +1,210 @@
+import shutil
+from typing import List
+
+from rich.table import Table
+
+from dstack._internal.cli.utils.common import console
+from dstack._internal.core.models.profiles import SpotPolicy
+from dstack._internal.core.models.runs import Requirements, RunSpec, get_policy_map
+from dstack._internal.server.schemas.gpus import GpuGroup
+
+
+def print_gpu_json(gpu_response, run_spec, group_by_cli, api_project):
+    """Print GPU information in JSON format."""
+    req = Requirements(
+        resources=run_spec.configuration.resources,
+        max_price=run_spec.merged_profile.max_price,
+        spot=get_policy_map(run_spec.merged_profile.spot_policy, default=SpotPolicy.AUTO),
+        reservation=run_spec.configuration.reservation,
+    )
+
+    if req.spot is None:
+        spot_policy = "auto"
+    elif req.spot:
+        spot_policy = "spot"
+    else:
+        spot_policy = "on-demand"
+
+    output = {
+        "project": api_project,
+        "user": "admin",  # TODO: Get actual user name
+        "resources": req.resources.dict(),
+        "spot_policy": spot_policy,
+        "max_price": req.max_price,
+        "reservation": run_spec.configuration.reservation,
+        "group_by": group_by_cli,
+        "gpus": [],
+    }
+
+    for gpu_group in gpu_response.gpus:
+        gpu_data = {
+            "name": gpu_group.name,
+            "memory_mib": gpu_group.memory_mib,
+            "vendor": gpu_group.vendor.value,
+            "availability": [av.value for av in gpu_group.availability],
+            "spot": gpu_group.spot,
+            "count": {"min": gpu_group.count.min, "max": gpu_group.count.max},
+            "price": {"min": gpu_group.price.min, "max": gpu_group.price.max},
+        }
+
+        if gpu_group.backend:
+            gpu_data["backend"] = gpu_group.backend.value
+        if gpu_group.backends:
+            gpu_data["backends"] = [b.value for b in gpu_group.backends]
+        if gpu_group.region:
+            gpu_data["region"] = gpu_group.region
+        if gpu_group.regions:
+            gpu_data["regions"] = gpu_group.regions
+
+        output["gpus"].append(gpu_data)
+
+    import json
+
+    print(json.dumps(output, indent=2))
+
+
+def print_gpu_table(gpus: List[GpuGroup], run_spec: RunSpec, group_by: List[str], project: str):
+    """Print GPU information in a formatted table."""
+    print_filter_info(run_spec, group_by, project)
+
+    has_single_backend = any(gpu_group.backend for gpu_group in gpus)
+    has_single_region = any(gpu_group.region for gpu_group in gpus)
+    has_multiple_regions = any(gpu_group.regions for gpu_group in gpus)
+
+    if has_single_backend and has_single_region:
+        backend_column = "BACKEND"
+        region_column = "REGION"
+    elif has_single_backend and has_multiple_regions:
+        backend_column = "BACKEND"
+        region_column = "REGIONS"
+    else:
+        backend_column = "BACKENDS"
+        region_column = None
+
+    table = Table(box=None, expand=shutil.get_terminal_size(fallback=(120, 40)).columns <= 110)
+    table.add_column("#")
+    table.add_column("GPU", no_wrap=True, ratio=2)
+    table.add_column("SPOT", style="grey58", ratio=1)
+    table.add_column("$/GPU", style="grey58", ratio=1)
+    table.add_column(backend_column, style="grey58", ratio=2)
+    if region_column:
+        table.add_column(region_column, style="grey58", ratio=2)
+    table.add_column()
+
+    for i, gpu_group in enumerate(gpus, start=1):
+        backend_text = ""
+        if gpu_group.backend:
+            backend_text = gpu_group.backend.value
+        elif gpu_group.backends:
+            backend_text = ", ".join(b.value for b in gpu_group.backends)
+
+        region_text = ""
+        if gpu_group.region:
+            region_text = gpu_group.region
+        elif gpu_group.regions:
+            if len(gpu_group.regions) <= 3:
+                region_text = ", ".join(gpu_group.regions)
+            else:
+                region_text = f"{len(gpu_group.regions)} regions"
+
+        if not region_column:
+            if gpu_group.regions and len(gpu_group.regions) > 3:
+                shortened_region_text = f"{len(gpu_group.regions)} regions"
+                backends_display = (
+                    f"{backend_text} ({shortened_region_text})"
+                    if shortened_region_text
+                    else backend_text
+                )
+            else:
+                backends_display = (
+                    f"{backend_text} ({region_text})" if region_text else backend_text
+                )
+        else:
+            backends_display = backend_text
+
+        memory_gb = f"{gpu_group.memory_mib // 1024}GB"
+        if gpu_group.count.min == gpu_group.count.max:
+            count_range = str(gpu_group.count.min)
+        else:
+            count_range = f"{gpu_group.count.min}..{gpu_group.count.max}"
+
+        gpu_spec = f"{gpu_group.name}:{memory_gb}:{count_range}"
+
+        spot_types = []
+        if "spot" in gpu_group.spot:
+            spot_types.append("spot")
+        if "on-demand" in gpu_group.spot:
+            spot_types.append("on-demand")
+        spot_display = ", ".join(spot_types)
+
+        if gpu_group.price.min == gpu_group.price.max:
+            price_display = f"{gpu_group.price.min:.4f}".rstrip("0").rstrip(".")
+        else:
+            min_formatted = f"{gpu_group.price.min:.4f}".rstrip("0").rstrip(".")
+            max_formatted = f"{gpu_group.price.max:.4f}".rstrip("0").rstrip(".")
+            price_display = f"{min_formatted}..{max_formatted}"
+
+        availability = ""
+        has_available = any(av.is_available() for av in gpu_group.availability)
+        has_unavailable = any(not av.is_available() for av in gpu_group.availability)
+
+        if has_unavailable and not has_available:
+            for av in gpu_group.availability:
+                if av.value in {"not_available", "no_quota", "idle", "busy"}:
+                    availability = av.value.replace("_", " ").lower()
+                    break
+
+        secondary_style = "grey58"
+        row_data = [
+            f"[{secondary_style}]{i}[/]",
+            gpu_spec,
+            f"[{secondary_style}]{spot_display}[/]",
+            f"[{secondary_style}]{price_display}[/]",
+            f"[{secondary_style}]{backends_display}[/]",
+        ]
+        if region_column:
+            row_data.append(f"[{secondary_style}]{region_text}[/]")
+        row_data.append(f"[{secondary_style}]{availability}[/]")
+
+        table.add_row(*row_data)
+
+    console.print(table)
+
+
+def print_filter_info(run_spec: RunSpec, group_by: List[str], project: str):
+    """Print filter information for GPU display."""
+    props = Table(box=None, show_header=False)
+    props.add_column(no_wrap=True)
+    props.add_column()
+
+    req = Requirements(
+        resources=run_spec.configuration.resources,
+        max_price=run_spec.merged_profile.max_price,
+        spot=get_policy_map(run_spec.merged_profile.spot_policy, default=SpotPolicy.AUTO),
+        reservation=run_spec.merged_profile.reservation,
+    )
+
+    pretty_req = req.pretty_format(resources_only=True)
+    max_price = f"${req.max_price:3f}".rstrip("0").rstrip(".") if req.max_price else "-"
+
+    if req.spot is None:
+        spot_policy = "auto"
+    elif req.spot:
+        spot_policy = "spot"
+    else:
+        spot_policy = "on-demand"
+
+    def th(s: str) -> str:
+        return f"[bold]{s}[/bold]"
+
+    props.add_row(th("Project"), project)
+    # TODO: Show user name
+    props.add_row(th("Resources"), pretty_req)
+    props.add_row(th("Spot policy"), spot_policy)
+    props.add_row(th("Max price"), max_price)
+    props.add_row(th("Reservation"), run_spec.configuration.reservation or "-")
+    if group_by:
+        props.add_row(th("Group by"), ", ".join(group_by))
+
+    console.print(props)
+    console.print()