proofstep-cli 0.1.0__py3-none-any.whl

proofstep_cli/registry.py

@@ -0,0 +1,234 @@
+"""Build evaluator instances from suite specs.
+
+The registry lives in the CLI rather than in `evaluation-core`, because it is
+config-driven: it turns YAML into objects. Keeping it out of the core is what lets
+the core stay a pure library with no notion of a file format.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from proofstep_core.evaluators import (
+    CalibrationEvaluator,
+    ClassificationEvaluator,
+    Contains,
+    DiscriminationEvaluator,
+    ExactMatch,
+    JsonSchemaMatch,
+    LengthWithin,
+    LLMJudge,
+    NumericRange,
+    OperationalEvaluator,
+    RankingEvaluator,
+    RegexMatch,
+    SetComparison,
+)
+from proofstep_trajectory.evaluator import TrajectoryEvaluator
+
+if TYPE_CHECKING:
+    from proofstep_cli.suite.loader import LoadedSuite
+    from proofstep_cli.suite.schema import EvaluatorSpec
+
+CORPUS_TYPES = frozenset(
+    {"classification", "ranking", "calibration", "discrimination", "operational"}
+)
+
+
+class RegistryError(ValueError):
+    """An evaluator spec could not be turned into an evaluator."""
+
+
+def build_evaluators(loaded: LoadedSuite) -> tuple[list[Any], list[Any]]:
+    """Return (per-example evaluators, corpus evaluators).
+
+    The split is not cosmetic. Corpus metrics — F1, NDCG, percentiles — are not
+    means of per-example scores, and running them through per-example aggregation
+    would produce plausible, wrong numbers.
+    """
+    per_example: list[Any] = []
+    corpus: list[Any] = []
+
+    for spec in loaded.suite.evaluators:
+        built = _build_one(spec, loaded)
+        if spec.type in CORPUS_TYPES:
+            corpus.append(built)
+        else:
+            per_example.append(built)
+    return per_example, corpus
+
+
+def _build_one(spec: EvaluatorSpec, loaded: LoadedSuite) -> Any:  # noqa: PLR0911, PLR0912
+    field = spec.field or "output"
+
+    if spec.type == "exact_match":
+        return ExactMatch(
+            name=spec.name,
+            field=field,
+            expected_field=spec.expected_field,
+            normalize=spec.normalize,
+        )
+
+    if spec.type == "json_schema":
+        return JsonSchemaMatch(_load_schema(spec, loaded), name=spec.name, field=field)
+
+    if spec.type == "regex":
+        return RegexMatch(name=spec.name, field=field, allow=spec.allow, deny=spec.deny)
+
+    if spec.type == "contains":
+        return Contains(
+            spec.substrings,
+            name=spec.name,
+            field=field,
+            mode=spec.mode or "all",  # type: ignore[arg-type]
+            case_sensitive=spec.case_sensitive,
+        )
+
+    if spec.type == "length":
+        return LengthWithin(
+            name=spec.name,
+            field=field,
+            minimum=int(spec.minimum) if spec.minimum is not None else None,
+            maximum=int(spec.maximum) if spec.maximum is not None else None,
+            unit=spec.unit,
+        )
+
+    if spec.type == "numeric_range":
+        return NumericRange(
+            name=spec.name,
+            field=field,
+            minimum=spec.minimum,
+            maximum=spec.maximum,
+            inclusive=spec.inclusive,
+        )
+
+    if spec.type == "set_comparison":
+        return SetComparison(
+            name=spec.name,
+            field=field,
+            expected_field=spec.expected_field,
+            mode=spec.mode or "equals",  # type: ignore[arg-type]
+        )
+
+    if spec.type == "llm_judge":
+        assert spec.model is not None  # guaranteed by schema validation
+        return LLMJudge(
+            name=spec.name,
+            rubric=_load_rubric(spec, loaded),
+            model=spec.model,
+            inputs=spec.inputs,
+            mode="classify" if spec.labels else "rubric",
+            labels=spec.labels or None,
+            passing_labels=_passing_labels(spec),
+            scale=(spec.scale.min, spec.scale.max),
+            normalize=spec.scale.normalize,
+            temperature=spec.temperature,
+            seed=spec.seed,
+            votes=spec.votes,
+            timeout_s=spec.timeout_s,
+            max_retries=spec.max_retries,
+        )
+
+    if spec.type == "trajectory":
+        assert spec.policy is not None
+        return TrajectoryEvaluator(loaded.resolve_path(spec.policy), name=spec.name)
+
+    if spec.type == "classification":
+        return ClassificationEvaluator(
+            name=spec.name,
+            prediction_field=spec.prediction_field or "intent",
+            label_field=spec.label_field,
+            averaging=spec.averaging,
+            labels=spec.labels or None,
+        )
+
+    if spec.type == "ranking":
+        return RankingEvaluator(
+            name=spec.name,
+            k=spec.k,
+            ranking_field=spec.ranking_field or "results",
+            relevant_field=spec.relevant_field or "relevant",
+        )
+
+    if spec.type == "discrimination":
+        return DiscriminationEvaluator(
+            name=spec.name,
+            score_field=spec.prediction_field or "predicted",
+            outcome_field=spec.label_field or "correct",
+        )
+
+    if spec.type == "calibration":
+        return CalibrationEvaluator(
+            correct_field=spec.correct_field,
+            name=spec.name,
+            confidence_field=spec.confidence_field or "confidence",
+            prediction_field=spec.prediction_field or "intent",
+            label_field=spec.label_field or "intent",
+        )
+
+    if spec.type == "operational":
+        return OperationalEvaluator(name=spec.name, percentiles=spec.percentiles)
+
+    msg = f"no builder for evaluator type {spec.type!r}"
+    raise RegistryError(msg)
+
+
+def _load_schema(spec: EvaluatorSpec, loaded: LoadedSuite) -> dict[str, Any]:
+    if spec.schema_ is not None:
+        return spec.schema_
+    if spec.schema_path is None:
+        msg = f"evaluator {spec.name!r} needs `schema` or `schema_path`"
+        raise RegistryError(msg)
+    path = loaded.resolve_path(spec.schema_path)
+    try:
+        parsed = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        msg = f"evaluator {spec.name!r}: cannot read schema {path}: {exc}"
+        raise RegistryError(msg) from exc
+    if not isinstance(parsed, dict):
+        msg = f"evaluator {spec.name!r}: schema at {path} is not a JSON object"
+        raise RegistryError(msg)
+    return parsed
+
+
+def _passing_labels(spec: EvaluatorSpec) -> list[str] | None:
+    """The judge's passing labels, from the evaluator or its calibration block.
+
+    Two places because a suite that only calibrates does not need the evaluator-level field, and
+    one that only gates does not need the calibration block. Preferring the evaluator keeps the
+    scoring definition next to the scoring.
+    """
+    if spec.passing_labels:
+        return spec.passing_labels
+    if spec.calibration and spec.calibration.passing_labels:
+        return list(spec.calibration.passing_labels)
+    return None
+
+
+def load_rubric_text(spec: EvaluatorSpec, loaded: LoadedSuite) -> str:
+    """The rubric as text, wherever it came from.
+
+    Public because the evaluator's version hash is computed over the rubric *text*, not
+    its path: editing `rubrics/groundedness.md` in place redefines the metric, and a hash
+    over the path would leave the old calibration blessing a different ruler.
+    """
+    return _load_rubric(spec, loaded)
+
+
+def _load_rubric(spec: EvaluatorSpec, loaded: LoadedSuite) -> str:
+    if spec.rubric:
+        return spec.rubric
+    assert spec.rubric_path is not None
+    return loaded.resolve_path(spec.rubric_path).read_text(encoding="utf-8")
+
+
+def estimate_judge_calls(loaded: LoadedSuite, example_count: int) -> int:
+    """How many model calls a run will make, for `--dry-run`.
+
+    Being able to see the cost before paying it is the point: a suite can be
+    expensive, and discovering that after the fact is a bad way to learn.
+    """
+    return sum(
+        example_count * spec.votes for spec in loaded.suite.evaluators if spec.type == "llm_judge"
+    )

proofstep_cli/render/__init__.py

@@ -0,0 +1 @@
+"""Report renderers."""

proofstep_cli/render/calibration.py

@@ -0,0 +1,127 @@
+"""Terminal rendering of a calibration report.
+
+Ordered by what a reader has to decide: does this judge pass, why not, and what should
+change. κ comes before agreement because agreement alone is the number that misleads —
+90 % agreement on a 90 %-majority set means nothing, and putting it first invites exactly
+that reading.
+"""
+
+from __future__ import annotations
+
+from proofstep_cli.render.terminal import GREEN, RED, YELLOW, Style
+from proofstep_core.calibration import CalibrationReport, RequirementCheck
+
+
+def render(  # noqa: PLR0912 — a report is a sequence of small sections
+    report: CalibrationReport,
+    check: RequirementCheck,
+    *,
+    evaluator: str,
+    version_hash: str,
+    style: Style | None = None,
+) -> str:
+    theme = style or Style(colour=False, unicode_=True)
+    lines: list[str] = []
+
+    verdict = "pass" if check.satisfied else "fail"
+    lines.append(
+        f"{theme.mark(verdict)} calibration {evaluator} "
+        f"{theme.paint(version_hash, YELLOW if not check.satisfied else GREEN)}"
+    )
+    lines.append("")
+
+    kappa = _kappa_line(report)
+    lines.append(f"  {'κ':<22} {kappa}")
+    lines.append(
+        f"  {'agreement':<22} {report.agreement:.3f}  "
+        f"[{report.agreement_ci[0]:.3f}, {report.agreement_ci[1]:.3f}]"
+    )
+    lines.append(f"  {'examples':<22} {report.n_examples}")
+    if report.n_errored:
+        lines.append(
+            f"  {'errored calls':<22} "
+            f"{theme.paint(f'{report.n_errored} ({report.error_rate:.1%})', YELLOW)}"
+        )
+
+    # The directional rates, always both, always labelled with what they mean. Reporting
+    # a single "error rate" here would hide the only distinction that matters.
+    lines.append(
+        f"  {'false pass':<22} {_rate(report.false_pass_rate)}"
+        "   (judge passed what a human failed — ships defects)"
+    )
+    lines.append(
+        f"  {'false fail':<22} {_rate(report.false_fail_rate)}"
+        "   (judge failed what a human passed — erodes trust)"
+    )
+
+    if report.human_kappa is not None:
+        ceiling = f"{report.human_kappa:.3f} on {report.n_ceiling_examples} doubly-labelled"
+        if report.at_human_ceiling:
+            ceiling += theme.paint("  — judge is at the ceiling", GREEN)
+        lines.append(f"  {'human ceiling κ':<22} {ceiling}")
+
+    if report.leniency is not None:
+        lines.append(f"  {'leniency':<22} {report.leniency:+.2f} scale points vs humans")
+    if report.scale_compression is not None:
+        lines.append(f"  {'scale used':<22} {report.scale_compression:.0%} of the human spread")
+    if report.verbosity_bias is not None:
+        lines.append(f"  {'verbosity bias':<22} {report.verbosity_bias:+.2f}")
+
+    if report.position_bias is not None:
+        bias = report.position_bias
+        text = (
+            f"{bias.inconsistency_rate:.1%} inconsistent, "
+            f"{bias.first_position_rate:.1%} first-position"
+        )
+        lines.append(f"  {'order effects':<22} {theme.paint(text, RED) if bias.biased else text}")
+
+    lines.append(f"  {'cost':<22} {report.total_cost} total, {report.mean_cost} per example")
+    lines.append(
+        f"  {'latency':<22} p50 {report.p50_latency_ms:.0f}ms  p95 {report.p95_latency_ms:.0f}ms"
+    )
+
+    if report.per_class:
+        lines.append("")
+        lines.append("  per class")
+        lines.append(f"    {'label':<20} {'n':>5} {'recall':>8} {'precision':>10}  confused with")
+        for entry in report.per_class:
+            confusion = (
+                f"{entry.top_confusion[0]} x{entry.top_confusion[1]}" if entry.top_confusion else ""
+            )
+            lines.append(
+                f"    {entry.label:<20} {entry.support:>5} {entry.recall:>8.3f} "
+                f"{entry.precision:>10.3f}  {confusion}"
+            )
+
+    if check.failures:
+        lines.append("")
+        lines.append(theme.paint("  requirement not met", RED))
+        for failure in check.failures:
+            lines.append(f"    {theme.paint(theme.cross, RED)} {failure}")
+
+    if check.warnings:
+        lines.append("")
+        for warning in check.warnings:
+            lines.append(f"  {theme.paint(theme.warn, YELLOW)} {warning}")
+
+    if report.notes:
+        lines.append("")
+        for note in report.notes:
+            lines.append(f"  {theme.paint('note', YELLOW)} {note}")
+
+    return "\n".join(lines)
+
+
+def _kappa_line(report: CalibrationReport) -> str:
+    if report.kappa is None:
+        # Never printed as a number. "κ 0.000" would read as a measured result rather
+        # than an undefined one, and the reason is the actionable part.
+        return f"undefined — {report.kappa_undefined_reason}"
+    interval = f"  [{report.kappa_ci[0]:.3f}, {report.kappa_ci[1]:.3f}]" if report.kappa_ci else ""
+    return f"{report.kappa:.3f}{interval}  ({report.kappa_kind})"
+
+
+def _rate(value: float | None) -> str:
+    # "unmeasured" rather than 0.000: a rate over an empty denominator is not zero, and a
+    # calibration set with no negatives cannot show whether the judge catches anything.
+    return "unmeasured" if value is None else f"{value:.3f}"

proofstep_cli/render/markdown.py

@@ -0,0 +1,304 @@
+"""Render a report as the pull-request comment.
+
+Written from the JSON report rather than from live objects, so the Action can post a
+comment for a run it did not execute — and so this renderer is a pure function of a
+file, which makes it snapshot-testable with no GitHub involved.
+
+Two constraints shape the output:
+
+- **GitHub caps a comment at 65,536 characters.** Exceeding it fails the API call,
+  which would mean no comment at all. Truncation is therefore deliberate, ordered
+  worst-first, and always states what was dropped.
+- **The reader is skimming a PR.** The verdict and the blocking reason must be
+  visible without expanding anything; everything else goes in `<details>`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Comments are found and updated by this marker rather than by author or position,
+# so a re-run edits its own comment instead of appending a new one.
+MARKER = "<!-- proofstep-report -->"
+
+GITHUB_COMMENT_LIMIT = 65_536
+TRUNCATION_BUDGET = GITHUB_COMMENT_LIMIT - 2_000
+
+VERDICT_HEADLINE = {
+    "pass": ("✅", "Quality gates passed"),
+    "warn": ("⚠️", "Quality gates passed with warnings"),
+    "fail": ("❌", "Quality gates failed"),
+    "error": ("🚨", "Evaluation could not be completed"),
+}
+
+MAX_METRIC_ROWS = 40
+MAX_REGRESSIONS = 15
+MAX_FAILURES = 10
+
+
+def render(report: dict[str, Any], *, run_url: str | None = None) -> str:
+    """Build the comment body. Always returns something postable."""
+    verdict = str(report.get("verdict", "error"))
+    icon, headline = VERDICT_HEADLINE.get(verdict, VERDICT_HEADLINE["error"])
+
+    parts: list[str] = [MARKER, "", f"### {icon} Proofstep — {headline}", ""]
+    parts.extend(_summary(report))
+
+    if aborted := report.get("aborted_reason"):
+        parts += ["", f"> **Run aborted.** {aborted}", ""]
+
+    parts.extend(_blocking(report))
+    parts.extend(_metrics(report))
+    parts.extend(_regressions(report))
+    parts.extend(_failures(report))
+    parts.extend(_warnings(report))
+    parts.extend(_footer(report, run_url))
+
+    return _fit("\n".join(parts))
+
+
+def render_error(message: str, *, suite: str | None = None, run_url: str | None = None) -> str:
+    """A comment for a run that never produced a report.
+
+    Posting something is essential: an absent comment reads as "no problems found",
+    which is the opposite of what happened.
+    """
+    parts = [
+        MARKER,
+        "",
+        "### 🚨 Proofstep — evaluation did not run",
+        "",
+        f"The evaluation{f' for `{suite}`' if suite else ''} failed before producing a report.",
+        "",
+        "```",
+        message.strip()[:3000],
+        "```",
+        "",
+        "_No quality gates were evaluated, so this result says nothing about the change "
+        "itself — only that the evaluation could not complete._",
+    ]
+    if run_url:
+        parts += ["", f"[View workflow run]({run_url})"]
+    return "\n".join(parts)
+
+
+# ----------------------------------------------------------------------- sections
+
+
+def _summary(report: dict[str, Any]) -> list[str]:
+    totals = report.get("totals", {})
+    dataset = report.get("dataset", {})
+    gates = report.get("gates", [])
+
+    blocking = sum(1 for g in gates if g.get("verdict") in ("fail", "error") and g.get("blocking"))
+    warnings = sum(
+        1 for g in gates if g.get("verdict") in ("fail", "error") and not g.get("blocking")
+    )
+    passed = sum(1 for g in gates if g.get("verdict") == "pass")
+
+    rows = [
+        f"| Suite | `{report.get('suite', '?')}` |",
+        f"| Gates | {passed} passed, {blocking} blocking, {warnings} warning |",
+        f"| Examples | {totals.get('examples', 0)} ({totals.get('errors', 0)} failed) |",
+    ]
+    if dataset.get("content_hash"):
+        label = dataset.get("name") or "dataset"
+        if dataset.get("version"):
+            label = f"{label}@{dataset['version']}"
+        rows.append(f"| Dataset | `{label}` · `{dataset['content_hash'][:12]}` |")
+    if (cost := totals.get("total_cost")) is not None:
+        rows.append(f"| Cost | ${float(cost):.4f} |")
+    if commit := (report.get("git") or {}).get("commit"):
+        rows.append(f"| Commit | `{commit[:8]}` |")
+
+    return ["| | |", "|---|---|", *rows]
+
+
+def _blocking(report: dict[str, Any]) -> list[str]:
+    """The reason the build failed, above the fold and never collapsed."""
+    failures = [
+        g
+        for g in report.get("gates", [])
+        if g.get("verdict") in ("fail", "error") and g.get("blocking")
+    ]
+    if not failures:
+        return []
+
+    lines = ["", "#### Blocking failures", ""]
+    for gate in failures:
+        key = _metric_label(gate)
+        lines.append(f"- **`{key}`** — {gate.get('message', 'failed')}")
+    return lines
+
+
+def _metrics(report: dict[str, Any]) -> list[str]:
+    metrics = report.get("metrics", [])
+    if not metrics:
+        return []
+
+    gated = {(g.get("metric_key"), _slice_text(g.get("slice"))) for g in report.get("gates", [])}
+    interesting = [
+        m
+        for m in metrics
+        if m.get("slice") is None or (m.get("key"), _slice_text(m.get("slice"))) in gated
+    ]
+    hidden = len(metrics) - len(interesting)
+    shown = interesting[:MAX_METRIC_ROWS]
+
+    lines = [
+        "",
+        "<details><summary>Metrics</summary>",
+        "",
+        "| Metric | Baseline | Candidate | Δ | Gate |",
+        "|---|---:|---:|---:|---|",
+    ]
+    gates_by_key = {
+        (g.get("metric_key"), _slice_text(g.get("slice"))): g for g in report.get("gates", [])
+    }
+    for metric in sorted(shown, key=_metric_label):
+        gate = gates_by_key.get((metric.get("key"), _slice_text(metric.get("slice"))))
+        lines.append(
+            "| `{key}` | {baseline} | {candidate} | {delta} | {gate} |".format(
+                key=_metric_label(metric),
+                baseline=_number(metric.get("baseline")),
+                candidate=_number(metric.get("value")),
+                delta=_delta(metric.get("absolute_delta")),
+                gate=_gate_cell(gate),
+            )
+        )
+
+    trailing = []
+    if hidden or len(interesting) > MAX_METRIC_ROWS:
+        folded = hidden + max(0, len(interesting) - MAX_METRIC_ROWS)
+        trailing = ["", f"_{folded} further metric(s) in the JSON artifact._"]
+
+    return [*lines, *trailing, "", "</details>"]
+
+
+def _regressions(report: dict[str, Any]) -> list[str]:
+    regressions = report.get("regressed_examples", [])
+    if not regressions:
+        return []
+
+    lines = [
+        "",
+        f"<details><summary>Regressed examples ({len(regressions)})</summary>",
+        "",
+        "| Example | Metric | Baseline | Candidate |",
+        "|---|---|---:|---:|",
+    ]
+    for entry in regressions[:MAX_REGRESSIONS]:
+        lines.append(
+            f"| `{entry.get('example_id')}` | `{entry.get('metric')}` | "
+            f"{_number(entry.get('baseline_score'))} | {_number(entry.get('candidate_score'))} |"
+        )
+    if len(regressions) > MAX_REGRESSIONS:
+        lines += ["", f"_{len(regressions) - MAX_REGRESSIONS} more in the JSON artifact._"]
+    return [*lines, "", "</details>"]
+
+
+def _failures(report: dict[str, Any]) -> list[str]:
+    failures = report.get("failures", [])
+    if not failures:
+        return []
+
+    lines = ["", f"<details><summary>Failed examples ({len(failures)})</summary>", "", "```"]
+    for entry in failures[:MAX_FAILURES]:
+        lines.append(
+            f"{entry.get('example_id')}  {entry.get('status')}  {entry.get('error') or ''}"
+        )
+    if len(failures) > MAX_FAILURES:
+        lines.append(f"… {len(failures) - MAX_FAILURES} more")
+    return [*lines, "```", "", "</details>"]
+
+
+def _warnings(report: dict[str, Any]) -> list[str]:
+    notes = list(report.get("hints", []))
+    notes += list((report.get("baseline") or {}).get("warnings", []))
+    if not notes:
+        return []
+    return ["", "#### Notes", "", *[f"- {note}" for note in notes]]
+
+
+def _footer(report: dict[str, Any], run_url: str | None) -> list[str]:
+    links = []
+    if url := report.get("experiment_url"):
+        links.append(f"[View experiment]({url})")
+    if run_url:
+        links.append(f"[Workflow run]({run_url})")
+
+    baseline = report.get("baseline") or {}
+    if baseline.get("dataset_match") is False:
+        links.append("⚠️ compared against a different dataset")
+
+    footer = ["", "---", ""]
+    footer.append(" · ".join(links) if links else "_Run `proofstep eval` locally to reproduce._")
+    return footer
+
+
+# ------------------------------------------------------------------------ helpers
+
+
+def _fit(body: str) -> str:
+    """Keep the comment postable.
+
+    Truncating is not ideal, but a comment that exceeds the limit is rejected
+    outright — and no comment is far worse than a shortened one.
+    """
+    if len(body) <= TRUNCATION_BUDGET:
+        return body
+
+    notice = (
+        "\n\n---\n\n_This comment was truncated to fit GitHub's size limit. "
+        "The complete report is attached as a workflow artifact._\n"
+    )
+    keep = TRUNCATION_BUDGET - len(notice)
+    # Cut at a line boundary so the result is not half a table row.
+    trimmed = body[:keep].rsplit("\n", 1)[0]
+    return trimmed + notice
+
+
+def _metric_label(entry: dict[str, Any]) -> str:
+    key = entry.get("key") or entry.get("metric_key") or "?"
+    slice_text = _slice_text(entry.get("slice"))
+    return f"{key}[{slice_text}]" if slice_text else str(key)
+
+
+def _slice_text(slice_: dict[str, str] | None) -> str:
+    return ",".join(f"{k}={v}" for k, v in sorted(slice_.items())) if slice_ else ""
+
+
+def _gate_cell(gate: dict[str, Any] | None) -> str:
+    if gate is None:
+        return ""
+    icon = {"pass": "✅", "fail": "❌", "warn": "⚠️", "error": "🚨"}.get(gate.get("verdict", ""), "")
+    threshold = gate.get("threshold")
+    rule = gate.get("rule")
+    detail = ""
+    if threshold is not None and rule == "minimum":
+        detail = f" min {threshold:g}"
+    elif threshold is not None and rule == "maximum":
+        detail = f" max {threshold:g}"
+    elif threshold is not None and rule and "regression" in rule:
+        detail = f" maxΔ {threshold:g}"
+    if not gate.get("blocking"):
+        detail += " (warn)"
+    return f"{icon}{detail}"
+
+
+def _number(value: Any) -> str:
+    if value is None:
+        return "—"
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return str(value)
+    if number and (abs(number) >= 1000 or abs(number) < 0.001):
+        return f"{number:.4g}"
+    return f"{number:.4f}".rstrip("0").rstrip(".") or "0"
+
+
+def _delta(value: Any) -> str:
+    if value is None:
+        return "—"
+    return f"{float(value):+.4g}"