evalstone 0.1.0__tar.gz → 0.2.0__tar.gz

{evalstone-0.1.0 → evalstone-0.2.0}/.gitignore

@@ -42,3 +42,6 @@ npm-debug.log*
 
 # ── Evalstone run reports (written by `evalstone run`) ──────────────────
 **/evalstone-report.json
+
+# ── Celery beat state (written by `just beat`) ───────────────────────────
+**/celerybeat-schedule*

{evalstone-0.1.0 → evalstone-0.2.0}/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 All notable changes to `python/evalstone`. Semantic versioning; tags `lib-vX.Y.Z`.
 
+## 0.2.0 — 2026-10-14
+
+Attach a project to a center.
+
+- `center:` in `evalstone.yaml` (`url`, `project`, `api_key_env` — an `es_…` ingest key)
+  routes judge and prompt-target calls through the center's model proxy, so no provider
+  key lives on the machine running the suite; the project's judge settings pick the
+  model (per-check overrides, then the default), `--judge-model` still wins.
+- Judge verdicts are cached in the center (`CenterCache`); a center hiccup is a cache
+  miss, never a failed run.
+- `human` checks of an attached project look labels up in the center (`labels: center`,
+  the default when attached; a file path still works).
+- `evalstone run` pushes its report to the center (`push_runs: false` to opt out); a
+  failed push warns and leaves the exit code alone.
+- Prompt targets (the system under test) always use the local `providers:` + env keys,
+  even when attached — the center proxy is for judges only. The MCP server honours the
+  attach too.
+
+## 0.1.1 — 2026-10-13
+
+Judge switching and cost honesty.
+
+- **Named providers**: a `providers:` entry may name any adapter (`adapter:
+  openai | anthropic | gemini`), so `openrouter:`, `ollama:` and `openai:` can
+  coexist and a judge model reads `openrouter/anthropic/claude-haiku-5-5`.
+  Unknown provider names and adapters are reported with the known ones. A
+  named entry never falls back to the adapter's default key variable (one
+  vendor's key is never sent to another); a 401/403 without a key says so.
+- **`--judge-model provider/model`** on `evalstone run` and `gate` overrides
+  every judge's and pairwise comparison's model for that run — never the
+  target under test (`Context.judge_model`; `Config.context(judge_model=…)`).
+  Validated before the run starts; a typo exits 2.
+- **`short_circuit: true`** on a suite skips the judge checks on a sample that
+  a contract check (deterministic, safety, trajectory — not a human label,
+  which is a quality verdict the judge should still be compared against)
+  already failed. The skipped result is a failure, not an error
+  (`Score.skipped`, `RunSummary.skipped`, `CheckSummary.skipped`), so no paid
+  call is spent on an output that already failed and the error-rate gate is
+  not tripped. Off by default. Turning it on changes pass rates (a skipped
+  judge counts as a failure), so re-take your baseline when you enable it.
+- **Cheap-first ordering** now includes safety rules and human labels, not only
+  deterministic and trajectory checks.
+- **Gate**: with `max_cost_usd` set, a `WARN` line counts results from models
+  outside the price table (they count as $0). Gemini models priced from the
+  official table (2026-10-09); OpenAI models are set under `prices:`.
+
 ## 0.1.0 — 2026-10-13
 
 The first usable release: the hero path from `evalstone.yaml` to a gated run.

{evalstone-0.1.0 → evalstone-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evalstone
-Version: 0.1.0
+Version: 0.2.0
 Summary: The plug-and-play evals layer for LLM-based projects: datasets, checks, suites, runs and gates.
 Project-URL: Homepage, https://evalstone.com
 Project-URL: Documentation, https://evalstone.com/docs
@@ -65,8 +65,8 @@ evalstone gate nightly                   # exit 1 when the gate fails (CI)
 ```
 
 A fuller example — a small retrieval bot with a gated suite — lives in the
-repository under `samples/rag-bot` (`git clone` it, `pip install -e
-python/evalstone`, then `evalstone run nightly` inside the sample).
+repository under `samples/rag-bot` (`git clone` it, then `evalstone run nightly`
+inside the sample).
 
 Judges and prompt targets need a provider key in the environment
 (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, or any

{evalstone-0.1.0 → evalstone-0.2.0}/README.md

@@ -28,8 +28,8 @@ evalstone gate nightly                   # exit 1 when the gate fails (CI)
 ```
 
 A fuller example — a small retrieval bot with a gated suite — lives in the
-repository under `samples/rag-bot` (`git clone` it, `pip install -e
-python/evalstone`, then `evalstone run nightly` inside the sample).
+repository under `samples/rag-bot` (`git clone` it, then `evalstone run nightly`
+inside the sample).
 
 Judges and prompt targets need a provider key in the environment
 (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, or any

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/__init__.py

@@ -8,7 +8,7 @@ import types
 from importlib import import_module
 from typing import TYPE_CHECKING, Any
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 # Exports resolve on first access (PEP 562) so that importing the package — which
 # the pytest plugin does in every pytest session on the interpreter — costs

evalstone-0.2.0/src/evalstone/center.py

@@ -0,0 +1,253 @@
+"""Attach a project to an Evalstone center (``center:`` in evalstone.yaml).
+
+Attached, the library never holds a provider key: judge (and prompt-target) calls go
+through the center's model proxy, which resolves the model from the project's judge
+settings and dials the provider with the organization's key server-side. The judge
+cache lives in the center (one verdict serves every machine), ``human`` checks look
+labels up there, and every ``evalstone run`` pushes its report. ``providers:`` and
+``judges:`` in the YAML remain the standalone path.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+from pydantic import BaseModel
+
+from evalstone.providers import ChatRequest, ChatResponse, ProviderError
+from evalstone.score import MemoryCache, Score
+
+DEFAULT_KEY_ENV = "EVALSTONE_API_KEY"
+
+
+class CenterConfig(BaseModel):
+    url: str
+    project: str  # the center project id (uuid)
+    api_key_env: str = DEFAULT_KEY_ENV  # an ingest key (es_…) or a user token
+    timeout: float = 120.0  # a judge call waits on the provider behind the proxy
+    cache_timeout: float = 10.0  # cache and label lookups: a slow center is a miss, fast
+    push_runs: bool = True  # `evalstone run` pushes its report
+    cache: bool = True  # judge verdicts read/written in the center
+
+    def api_key(self) -> str | None:
+        return os.environ.get(self.api_key_env) or None
+
+
+class CenterError(ProviderError):
+    """The center refused or could not serve a request."""
+
+
+class CenterClient:
+    """Thin HTTP client for the center's project endpoints."""
+
+    def __init__(self, config: CenterConfig, *, client: Any = None) -> None:
+        self.config = config
+        key = config.api_key()
+        if not key:
+            raise CenterError(
+                f"center: no API key — set {config.api_key_env} (an ingest key from the "
+                "project's settings) in the environment"
+            )
+        self._client = client or httpx.Client(
+            base_url=config.url.rstrip("/"),
+            timeout=config.timeout,
+            headers={"Authorization": f"Bearer {key}"},
+        )
+        self._owns = client is None
+
+    def close(self) -> None:
+        if self._owns:
+            self._client.close()
+
+    # ── transport ────────────────────────────────────────────────────────
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        try:
+            return self._client.request(method, path, **kwargs)
+        except httpx.HTTPError as exc:
+            raise CenterError(f"center: {type(exc).__name__}: {exc}") from exc
+
+    @staticmethod
+    def _detail(resp: httpx.Response) -> str:
+        try:
+            body = resp.json()
+        except ValueError:
+            body = None
+        detail = body.get("detail") if isinstance(body, dict) else body
+        return str(detail)[:300] if detail else resp.text[:300]
+
+    def _json(self, method: str, path: str, **kwargs: Any) -> Any:
+        resp = self._request(method, path, **kwargs)
+        if resp.status_code >= 400:
+            raise CenterError(f"center: HTTP {resp.status_code}: {self._detail(resp)}")
+        try:
+            return resp.json()
+        except ValueError as exc:
+            raise CenterError(f"center: non-JSON response: {resp.text[:200]!r}") from exc
+
+    def _p(self, suffix: str) -> str:
+        return f"/projects/{self.config.project}{suffix}"
+
+    # ── endpoints ────────────────────────────────────────────────────────
+
+    def whoami(self) -> dict[str, Any]:
+        return self._json("GET", "/ingest/whoami")
+
+    def judge_settings(self) -> dict[str, Any]:
+        return self._json("GET", self._p("/judge-settings"))
+
+    def complete(
+        self, model: str | None, request: ChatRequest, *, check_key: str | None = None
+    ) -> ChatResponse:
+        """The proxy call: `model` is `<provider>/<model>` (or None → the center picks)."""
+        body = {
+            "model": model,
+            "check_key": check_key,
+            "system": request.system,
+            "messages": [m.model_dump() for m in request.messages],
+            "max_tokens": request.max_tokens,
+            "temperature": request.temperature,
+        }
+        data = self._json("POST", self._p("/model/complete"), json=body)
+        return ChatResponse.model_validate(data)
+
+    def cache_get(self, key: str) -> Score | None:
+        resp = self._request(
+            "GET", self._p(f"/judge-cache/{key}"), timeout=self.config.cache_timeout
+        )
+        if resp.status_code == 404:
+            return None
+        if resp.status_code >= 400:
+            raise CenterError(f"center: HTTP {resp.status_code}: {self._detail(resp)}")
+        return Score.model_validate(resp.json()["score"])
+
+    def cache_set(self, key: str, score: Score) -> None:
+        judge_version = (
+            (score.raw or {}).get("judge_version") if isinstance(score.raw, dict) else None
+        )
+        self._json(
+            "PUT",
+            self._p(f"/judge-cache/{key}"),
+            json={"score": score.model_dump(mode="json"), "judge_version": judge_version},
+            timeout=self.config.cache_timeout,
+        )
+
+    def label_lookup(
+        self, sample_id: str, output_hash: str, check: str | None
+    ) -> dict[str, Any] | None:
+        params = {"sample_key": sample_id, "output_hash": output_hash}
+        if check is not None:
+            params["check"] = check
+        resp = self._request(
+            "GET", self._p("/labels/lookup"), params=params, timeout=self.config.cache_timeout
+        )
+        if resp.status_code == 404:
+            return None
+        if resp.status_code >= 400:
+            raise CenterError(f"center: HTTP {resp.status_code}: {self._detail(resp)}")
+        return resp.json()
+
+    def push_run(self, report: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+        """Store a run report; returns (run, created) — 200 means the center had it already."""
+        resp = self._request("POST", self._p("/runs"), json=report)
+        if resp.status_code >= 400:
+            raise CenterError(f"center: HTTP {resp.status_code}: {self._detail(resp)}")
+        return resp.json(), resp.status_code == 201
+
+
+# ── the Providers surface, backed by the proxy ───────────────────────────
+
+
+class RemoteProvider:
+    """One named provider entry of the center (a `Provider` whose calls go through the proxy)."""
+
+    def __init__(self, name: str, client: CenterClient) -> None:
+        self.name = name
+        self._client = client
+
+    def complete(self, request: ChatRequest) -> ChatResponse:
+        return self._client.complete(f"{self.name}/{request.model}", request)
+
+
+class CenterProviders:
+    """Drop-in for ``evalstone.providers.Providers`` when a project is attached.
+
+    ``split``/``get``/``complete`` match the registry the judge check and prompt targets
+    call; the default model comes from the center's judge settings, so a check without
+    its own ``model`` resolves there.
+    """
+
+    def __init__(self, client: CenterClient, *, default_model: str | None = None) -> None:
+        self.client = client
+        self.default_model = default_model
+        self._instances: dict[str, RemoteProvider] = {}
+
+    def split(self, model: str | None) -> tuple[str, str]:
+        model = model or self.default_model
+        if not model:
+            raise ProviderError(
+                "no model given and the center project has no default judge model "
+                "(set it in the project's judge settings)"
+            )
+        if "/" not in model:
+            raise ProviderError(f"model must be '<provider>/<model>', got {model!r}")
+        name, _, bare = model.partition("/")
+        return name, bare
+
+    def get(self, name: str) -> RemoteProvider:
+        if name not in self._instances:
+            self._instances[name] = RemoteProvider(name, self.client)
+        return self._instances[name]
+
+    def complete(self, model: str | None, request_without_model: dict[str, Any]) -> ChatResponse:
+        name, bare = self.split(model)
+        req = ChatRequest(model=bare, **request_without_model)
+        return self.client.complete(f"{name}/{bare}", req)
+
+    def close(self) -> None:
+        self.client.close()
+
+
+class CenterCache:
+    """A ``ScoreCache`` in the center, with an in-process layer so a run asks once per key.
+
+    A center hiccup is a miss (a judge then pays for the call); it never fails the run.
+    """
+
+    def __init__(self, client: CenterClient) -> None:
+        self._client = client
+        self._local = MemoryCache()
+        self.errors: list[str] = []
+
+    def get(self, key: str) -> Score | None:
+        hit = self._local.get(key)
+        if hit is not None:
+            return hit
+        try:
+            score = self._client.cache_get(key)
+        except Exception as exc:
+            self.errors.append(f"{type(exc).__name__}: {exc}")
+            return None
+        if score is not None:
+            self._local.set(key, score)
+        return score
+
+    def set(self, key: str, score: Score) -> None:
+        self._local.set(key, score)
+        try:
+            self._client.cache_set(key, score)
+        except Exception as exc:
+            self.errors.append(f"{type(exc).__name__}: {exc}")
+
+
+__all__ = [
+    "DEFAULT_KEY_ENV",
+    "CenterCache",
+    "CenterClient",
+    "CenterConfig",
+    "CenterError",
+    "CenterProviders",
+    "RemoteProvider",
+]

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/checks/_base.py

@@ -151,3 +151,11 @@ def check(
 
 
 __all__ = ["CheckFn", "FunctionCheck", "Registry", "check", "registry"]
+
+
+def judge_model_for(ctx: Any, key: str, model: str | None) -> str | None:
+    """Which model a judge-style check uses: ``--judge-model`` (``ctx.judge_model``) beats the
+    attached project's per-check override (``ctx.extra["judge_models"][key]``) beats the
+    check's own ``model``. ``None`` falls through to the registry's default."""
+    overrides = (getattr(ctx, "extra", None) or {}).get("judge_models") or {}
+    return getattr(ctx, "judge_model", None) or overrides.get(key) or model

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/checks/comparison.py

@@ -11,7 +11,7 @@ from collections.abc import Mapping
 from typing import Any
 
 from evalstone._json import sha256
-from evalstone.checks._base import FunctionCheck
+from evalstone.checks._base import FunctionCheck, judge_model_for
 from evalstone.checks.judge import _json_text, extract_json
 from evalstone.dataset import Sample
 from evalstone.output import Output
@@ -64,11 +64,12 @@ def pairwise(
     """
     base_target: Target = baseline if isinstance(baseline, Target) else RecordedTarget(baseline)
     identity = {"v": 1, "rubric": rubric, "both_orders": both_orders}
+    unpriced: list[str] = []  # models of this sample's calls that the price table lacks
 
     def ask(ctx: Context, sample_input: str, a: str, b: str) -> tuple[str, str, float, float]:
         user = USER.format(input=sample_input, a=a, b=b)
         resp = ctx.providers.complete(
-            model,
+            judge_model_for(ctx, key, model),
             {
                 "system": SYSTEM.format(rubric=rubric.strip()),
                 "messages": [ChatMessage(role="user", content=user)],
@@ -76,13 +77,16 @@ def pairwise(
             },
         )
         winner, reason = parse_winner(resp.text)
+        if resp.cost_usd is None:
+            unpriced.append(resp.model)
         return winner, reason, resp.cost_usd or 0.0, resp.latency_ms
 
     def fn(sample: Sample, output: Output, ctx: Context) -> Score:
         if ctx.providers is None:
             return Score.errored("pairwise: no providers configured")
+        unpriced.clear()
         try:
-            resolved = "/".join(ctx.providers.split(model))
+            resolved = "/".join(ctx.providers.split(ctx.judge_model or model))
         except ProviderError as exc:
             return Score.errored(str(exc))
         version = sha256({**identity, "model": resolved})[:16]
@@ -130,7 +134,12 @@ def pairwise(
             reason=f"candidate {verdict}: " + " | ".join(r for r in reasons if r),
             cost_usd=cost,
             latency_ms=latency,
-            raw={"points": points, "orders": len(points), "judge_version": version},
+            raw={
+                "points": points,
+                "orders": len(points),
+                "judge_version": version,
+                "unpriced": bool(unpriced),
+            },
         )
         if ctx.cache is not None:
             ctx.cache.set(cache_key, score)

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/checks/human.py

@@ -85,8 +85,11 @@ def human(
     """Score from a person's label for this (sample, output); unlabelled → error.
 
     ``check`` selects labels recorded for a specific rubric (``evalstone label
-    --check``); ``None`` uses the overall grade.
+    --check``); ``None`` uses the overall grade. ``labels="center"`` (what an attached
+    project gets by default) looks the label up in the center instead of a file.
     """
+    if labels == "center":
+        return FunctionCheck(key, _center_lookup(check), kind=CheckKind.HUMAN)
     store_path = Path(labels)
     cached: dict[str, Any] = {}
 
@@ -121,4 +124,32 @@ def human(
     return FunctionCheck(key, fn, kind=CheckKind.HUMAN)
 
 
+def _center_lookup(check: str | None):
+    def fn(sample: Sample, output: Output, ctx: Any) -> Score:
+        client = (ctx.extra or {}).get("center_client") if ctx is not None else None
+        if client is None:
+            return Score.errored("human: labels=center but the run is not attached to a center")
+        try:
+            found = client.label_lookup(sample.id, output_hash(output), check)
+        except Exception as exc:  # a center hiccup is an error score, never a pass
+            return Score.errored(f"human: center lookup failed: {exc}")
+        if found is None:
+            return Score.errored(
+                f"no human label in the center for {sample.id} @ {output_hash(output)}"
+            )
+        reason = found.get("notes") or ("labelled pass" if found["passed"] else "labelled fail")
+        return Score(
+            value=found["value"],
+            passed=found["passed"],
+            reason=reason,
+            raw={
+                "labeler": found.get("labeler", ""),
+                "grade": found.get("raw"),
+                "at": found.get("labeled_at"),
+            },
+        )
+
+    return fn
+
+
 __all__ = ["Label", "LabelStore", "human", "output_hash"]

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/checks/judge.py

@@ -13,7 +13,7 @@ import re
 from typing import Any
 
 from evalstone._json import dumps, sha256
-from evalstone.checks._base import FunctionCheck
+from evalstone.checks._base import FunctionCheck, judge_model_for
 from evalstone.dataset import Sample
 from evalstone.output import Output
 from evalstone.providers import ChatMessage, ProviderError
@@ -134,8 +134,9 @@ def judge(
         providers = ctx.providers
         if providers is None:
             return Score.errored("judge: no providers configured (ctx.providers is None)")
+        chosen = judge_model_for(ctx, key, model)
         try:
-            resolved = "/".join(providers.split(model))
+            resolved = "/".join(providers.split(chosen))
         except ProviderError as exc:
             return Score.errored(str(exc))
         judge_version = sha256({**identity, "model": resolved})[:16]
@@ -176,7 +177,7 @@ def judge(
             )
         try:
             resp = providers.complete(
-                model,
+                chosen,
                 {
                     "system": system,
                     "messages": [ChatMessage(role="user", content=user)],

{evalstone-0.1.0 → evalstone-0.2.0}/src/evalstone/cli.py

@@ -14,8 +14,11 @@ from rich.markup import escape
 from rich.table import Table
 
 from evalstone import __version__
+from evalstone.center import CenterError
 from evalstone.config import CONFIG_FILENAME, Config
+from evalstone.providers import ProviderError
 from evalstone.run import DEFAULT_FAILURES, Run, compare
+from evalstone.score import Context
 
 app = typer.Typer(
     name="evalstone",
@@ -28,6 +31,11 @@ err = Console(stderr=True, soft_wrap=True)  # never wrap paths inside error mess
 
 ConfigOpt = typer.Option("evalstone.yaml", "--config", "-c", help="Path to evalstone.yaml")
 ReportOpt = typer.Option(None, "--report", "-r", help="Where to write the JSON report")
+JudgeModelOpt = typer.Option(
+    None,
+    "--judge-model",
+    help="Override every judge's model for this run (provider/model), e.g. to compare judges",
+)
 BaselineOpt = typer.Option(
     None, "--baseline", "-b", help="A previous report to gate regressions against"
 )
@@ -124,36 +132,83 @@ def run(
     baseline: Path | None = BaselineOpt,
     failures: int = FailuresOpt,
     strict: bool = typer.Option(False, "--strict", help="Exit 1 when the gate fails"),
+    judge_model: str | None = JudgeModelOpt,
 ) -> None:
     """Run a suite, print the table, write the JSON report."""
     cfg = _load(config)
     try:
         s, target = cfg.suite(suite)
-    except SUITE_ERRORS as exc:
+    except (*SUITE_ERRORS, CenterError) as exc:
         err.print(f"[red]{escape(str(exc))}[/red]")
         raise typer.Exit(2) from None
     base = _load_run(baseline) if baseline else None
+    if judge_model is not None:
+        try:
+            registry = cfg.provider_registry()
+            registry.get(registry.split(judge_model)[0])
+        except ProviderError as exc:
+            err.print(f"[red]--judge-model: {escape(str(exc))}[/red]")
+            raise typer.Exit(2) from None
+    try:
+        ctx = cfg.context(judge_model=judge_model)
+    except CenterError as exc:
+        err.print(f"[red]{escape(str(exc))}[/red]")
+        raise typer.Exit(2) from None
     with console.status(f"running {suite} over {len(s.dataset)} samples…"):
-        result = s.run(target, baseline=base, trigger="cli", ctx=cfg.context())
+        result = s.run(target, baseline=base, trigger="cli", ctx=ctx)
     console.print(_run_table(result))
+    _warn_cache_errors(ctx)
     _print_failures(result, failures)
     _print_gate(result)
     out = report or (cfg.root / cfg.report)
     result.to_json(out)
     console.print(f"\nreport → {out}")
+    _push_to_center(cfg, result)
     if strict and result.gate_passed is False:
         raise typer.Exit(1)
 
 
+def _warn_cache_errors(ctx: Context) -> None:
+    """Say so when the center cache was unreachable: those verdicts were paid for."""
+    errors = getattr(ctx.cache, "errors", None)
+    if errors:
+        err.print(
+            f"[yellow]center cache: {len(errors)} request(s) failed "
+            f"(first: {escape(errors[0][:160])}) — judges paid for those verdicts[/yellow]"
+        )
+
+
+def _push_to_center(cfg: Config, result: Run) -> None:
+    """Attached projects store every run in the center; a push failure warns, never fails."""
+    if cfg.center is None or not cfg.center.push_runs:
+        return
+    try:
+        stored, created = cfg.center_client().push_run(result.model_dump(mode="json"))
+    except Exception as exc:
+        err.print(f"[yellow]center: run not pushed — {escape(str(exc))}[/yellow]")
+        return
+    verb = "stored" if created else "already stored"
+    console.print(f"center → run {stored.get('id', '?')} {verb} ({cfg.center.url})")
+
+
 @app.command()
 def gate(
     suite: str = typer.Argument(..., help="Suite name from evalstone.yaml"),
     config: str = ConfigOpt,
     report: Path | None = ReportOpt,
     baseline: Path | None = BaselineOpt,
+    judge_model: str | None = JudgeModelOpt,
 ) -> None:
     """Run a suite and exit 1 if its gate fails (for CI)."""
-    run(suite=suite, config=config, report=report, baseline=baseline, failures=10, strict=True)
+    run(
+        suite=suite,
+        config=config,
+        report=report,
+        baseline=baseline,
+        failures=10,
+        strict=True,
+        judge_model=judge_model,
+    )
 
 
 @app.command("compare")