techtree 0.1.0__py3-none-any.whl

techtree/presentation/models.py

@@ -0,0 +1,358 @@
+"""The channel-neutral shape of a result. Spec section 7.13.
+
+Both renderers in this build — the terminal one and the compact one a gateway
+relays — consume exactly this payload, and nothing else draws a result. The
+payload is a contract about *what a result is*, never an assumption about how
+anyone draws it: numbers, labels, outcomes, caveats and next steps, with no
+markup, no colour and no channel anywhere in it.
+
+Three properties are load-bearing.
+
+*It is derived, never authored.* Every score, status and digest here is copied
+out of a signed :class:`~techtree.models.uplift_report.UpliftReport`. Nothing
+downstream can alter one, because nothing downstream is given the chance to
+compute one.
+
+*It is frozen.* The models are :class:`~techtree.models.base.ProtocolModel`
+subclasses even though the payload is not part of the frozen v0.1 protocol,
+which is why the schema version says ``presentation`` rather than a protocol
+object's name. Freezing means two renderings of one report cannot disagree
+because something mutated the payload between them.
+
+*It carries nothing hidden.* A hidden expected answer, a grader's source, or a
+credential has no field to enter through, and
+:func:`~techtree.presentation.sanitize.ensure_no_hidden_task_material` checks
+the free text that could carry one anyway.
+
+One thing that is not a field lives here too: :class:`TaskDisplay`, the
+reader's answer to how much of the per-task table they want, and
+:func:`selected_task_rows`, which turns that answer into rows. It is here
+rather than in either renderer because a reader who asks the same question of
+two channels has to be shown the same tasks, and two renderers that each kept
+their own idea of which rows "changed" means could quietly disagree about
+whether a tie is a change.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Final, Literal, Self
+
+from pydantic import Field, model_validator
+
+from techtree.models.base import Digest, NonEmptyString, ProtocolModel
+from techtree.models.cli import NextAction
+from techtree.receipts.execution import CostProvenance
+
+__all__ = [
+    "PRESENTATION_SCHEMA_VERSION",
+    "DerivedCost",
+    "EconomicsSource",
+    "PresentationCaveat",
+    "ScoreBar",
+    "SkillSummary",
+    "TaskDisplay",
+    "TaskOutcome",
+    "TaskResultRow",
+    "UpliftPresentationPayload",
+    "selected_task_rows",
+]
+
+#: Deliberately not in :mod:`techtree.constants`, which holds protocol schema
+#: versions. A presentation payload is a view, and spec section 3.5 keeps views
+#: out of the protocol.
+PRESENTATION_SCHEMA_VERSION: Final = "techtree.presentation.uplift.v1"
+
+
+type TaskOutcome = Literal["win", "loss", "tie"]
+"""Which way one task moved between the two variants."""
+
+
+type EconomicsSource = Literal[
+    "comparison_execution_record",
+    "episode_receipts",
+    "unavailable",
+]
+"""Where the cost and timing on a payload came from, if anywhere.
+
+Decisions document 0007 R6 puts the comparison's economics in a signed record
+of its own. A payload built from a run that has one says so; one built from a
+run that does not says that instead, and never quietly presents a number whose
+source it cannot name."""
+
+
+class ScoreBar(ProtocolModel):
+    """One score, and the text a renderer draws it as.
+
+    ``display`` is computed once, in the builder, so that the terminal and a
+    phone message draw the same bar from the same string rather than each
+    inventing a scale.
+    """
+
+    label: NonEmptyString
+    value: float
+    maximum: float = Field(gt=0.0)
+    display: NonEmptyString
+
+
+class TaskResultRow(ProtocolModel):
+    """What one committed task contributed to the comparison."""
+
+    position: int = Field(ge=0)
+    task_label: NonEmptyString
+    baseline_score: float
+    candidate_score: float
+    delta: float
+    outcome: TaskOutcome
+
+
+class TaskDisplay(StrEnum):
+    """Which task rows a reader asked to see."""
+
+    ALL = "all"
+    CHANGED = "changed"
+    REGRESSIONS = "regressions"
+    NONE = "none"
+
+
+#: Losses first, then wins, then ties. Within a group, committed task order.
+_OUTCOME_RANK: Final[dict[str, int]] = {"loss": 0, "win": 1, "tie": 2}
+
+
+def selected_task_rows(
+    rows: list[TaskResultRow], show: TaskDisplay
+) -> list[TaskResultRow]:
+    """Return the rows a reader asked for, worst first.
+
+    A reader scanning a table wants the rows that moved the wrong way, then the
+    ones that moved, then the rest, so the order is fixed here rather than left
+    to whichever channel is drawing. ``TaskDisplay.NONE`` selects nothing at
+    all, which is the honest reading of a reader who said they did not want the
+    table: a channel given no rows prints no table and no heading over it.
+
+    Selecting rows is all this does. No filter can change a count, because
+    every count a reader sees comes from the payload rather than from what a
+    channel happened to have room for.
+    """
+    if show is TaskDisplay.NONE:
+        return []
+    if show is TaskDisplay.REGRESSIONS:
+        chosen = [row for row in rows if row.outcome == "loss"]
+    elif show is TaskDisplay.CHANGED:
+        chosen = [row for row in rows if row.outcome != "tie"]
+    else:
+        chosen = list(rows)
+    return sorted(chosen, key=lambda row: (_OUTCOME_RANK[row.outcome], row.position))
+
+
+class SkillSummary(ProtocolModel):
+    """One side's Skill, described by size and content address.
+
+    A baseline with no Skill is a real state rather than a missing value: it is
+    what a Skill-insertion comparison measures against, so it has a label and
+    no digest.
+    """
+
+    label: NonEmptyString
+    root_digest: Digest | None
+    file_count: int = Field(ge=0)
+    total_bytes: int = Field(ge=0)
+
+
+class DerivedCost(ProtocolModel):
+    """A dollar figure worked out while rendering, from what the run recorded.
+
+    Decisions document 0007 R6 forbids exactly one thing about cost: a figure
+    presented as better sourced than it is. This is not a bill and is never
+    drawn as one, so everything it rests on travels with it — the two token
+    counts that were multiplied, the prices they were multiplied by, and the
+    day those prices were read.
+
+    ``cached_input_tokens`` and ``prices_name_a_cached_rate`` are carried
+    together because a provider that serves part of the prompt from its own
+    cache usually charges less for it. When the recorded prices name no cached
+    rate, every token is priced at the full rate and the reader is told the
+    figure is on the high side, which is the only direction an unstated
+    discount can move it. The count is ``None`` when the run recorded no
+    usable cache split, which is not the same as a run that cached nothing.
+    """
+
+    usd: float = Field(ge=0.0)
+    input_tokens: int = Field(ge=0)
+    output_tokens: int = Field(ge=0)
+    cached_input_tokens: int | None = Field(default=None, ge=0)
+    prices_name_a_cached_rate: bool
+    model_id: NonEmptyString
+    input_usd_per_mtok: float = Field(gt=0.0)
+    output_usd_per_mtok: float = Field(gt=0.0)
+    prices_recorded_on: NonEmptyString
+
+
+class PresentationCaveat(ProtocolModel):
+    """One thing a reader must know before believing what they just read.
+
+    Caveats are part of the payload rather than of a renderer, so that a
+    channel cannot drop one by being short of room.
+    """
+
+    code: NonEmptyString
+    severity: Literal["info", "warning", "error"]
+    text: NonEmptyString
+
+
+class UpliftPresentationPayload(ProtocolModel):
+    """One comparison, ready to be shown anywhere.
+
+    ``comparison_label`` names which result in the chain this is;
+    ``change_label`` names the one thing that differed between the two sides,
+    in the arrow form decisions document 0019 section 1 fixes. They are two
+    fields because they answer two questions — which receipt am I holding, and
+    what did it measure — and a channel with room for only one should not have
+    to guess which.
+    """
+
+    schema_version: Literal["techtree.presentation.uplift.v1"]
+    run_id: NonEmptyString
+    campaign_title: NonEmptyString
+    comparison_label: NonEmptyString
+    change_label: NonEmptyString
+    baseline_skill: SkillSummary
+    candidate_skill: SkillSummary
+    baseline_score: float
+    candidate_score: float
+    absolute_delta: float
+    relative_delta: float | None
+    wins: int = Field(ge=0)
+    losses: int = Field(ge=0)
+    ties: int = Field(ge=0)
+    task_rows: list[TaskResultRow]
+    baseline_tasks_scored_full: int | None
+    candidate_tasks_scored_full: int | None
+    baseline_tokens: int | None
+    candidate_tokens: int | None
+    baseline_seconds: float | None
+    candidate_seconds: float | None
+    baseline_model_turns: int | None
+    candidate_model_turns: int | None
+    baseline_rate_limited_calls: int | None
+    candidate_rate_limited_calls: int | None
+    every_rollout_completed: bool | None
+    economics_source: EconomicsSource
+    cost_usd: float | None = Field(default=None, ge=0.0)
+    cost_provenance: CostProvenance
+    derived_cost: DerivedCost | None = None
+    cost_unavailable_reason: NonEmptyString | None = None
+    decision: NonEmptyString
+    proof_grade: NonEmptyString
+    verification_status: NonEmptyString
+    caveats: list[PresentationCaveat]
+    next_actions: list[NextAction]
+
+    @model_validator(mode="after")
+    def _check_the_rows_and_the_counts_describe_one_comparison(self) -> Self:
+        """Reject a payload whose table and headline disagree."""
+        outcomes = [row.outcome for row in self.task_rows]
+        counts: tuple[tuple[TaskOutcome, int], ...] = (
+            ("win", self.wins),
+            ("loss", self.losses),
+            ("tie", self.ties),
+        )
+        for outcome, count in counts:
+            if outcomes.count(outcome) != count:
+                raise ValueError(
+                    f"the payload reports {count} {outcome} rows and carries "
+                    f"{outcomes.count(outcome)}"
+                )
+        positions = [row.position for row in self.task_rows]
+        if positions != sorted(positions) or len(set(positions)) != len(positions):
+            raise ValueError(
+                "task rows are carried in committed task order, each position once"
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_the_cost_is_never_shown_without_its_source(self) -> Self:
+        """Reject a payload whose cost claims a provenance it does not have.
+
+        Decisions document 0007 R6 forbids exactly one thing about cost: a
+        figure presented as better sourced than it is. The shape enforces the
+        pair here so that no renderer has to remember to.
+        """
+        known = self.cost_usd is not None
+        claims_source = self.cost_provenance is not CostProvenance.UNAVAILABLE
+        if known != claims_source:
+            raise ValueError(
+                "a cost figure needs a provenance and a provenance needs a "
+                f"figure; got {self.cost_usd!r} as {self.cost_provenance.value}"
+            )
+        if known and self.economics_source != "comparison_execution_record":
+            raise ValueError(
+                "a cost figure comes from the signed execution record; a "
+                f"payload sourced from {self.economics_source} has none"
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_a_derived_cost_never_stands_beside_a_reported_one(self) -> Self:
+        """Reject a payload carrying two answers to "what did this cost?".
+
+        A figure the provider reported is the better answer wherever there is
+        one, so a derived figure exists only in its absence. Two of them in one
+        payload would leave each channel free to pick, and two channels showing
+        one run would then be able to disagree about money.
+        """
+        if self.derived_cost is not None and self.cost_usd is not None:
+            raise ValueError(
+                "a cost is derived only when none was reported; this payload "
+                f"carries both {self.derived_cost.usd} and {self.cost_usd}"
+            )
+        figure = self.derived_cost is not None or self.cost_usd is not None
+        if figure == (self.cost_unavailable_reason is not None):
+            raise ValueError(
+                "a payload with no cost figure says what is missing, and one "
+                "with a figure has nothing to explain away"
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_the_counts_read_from_the_run_arrive_together(self) -> Self:
+        """Reject a payload that read half of one run's recorded traces.
+
+        Turns, throttling and whether every rollout finished are one reading of
+        one pair of recorded, digest-checked files. A payload holding some of
+        them and not the others would be describing a reading that never
+        happened.
+        """
+        read = (
+            self.baseline_model_turns,
+            self.candidate_model_turns,
+            self.baseline_rate_limited_calls,
+            self.candidate_rate_limited_calls,
+            self.every_rollout_completed,
+        )
+        if None in read and any(value is not None for value in read):
+            raise ValueError(
+                "the counts read from a run's recorded traces are all present "
+                f"or all absent; got {read}"
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_the_task_counts_fit_the_table(self) -> Self:
+        """Reject a headline count that no per-task table could produce."""
+        baseline = self.baseline_tasks_scored_full
+        candidate = self.candidate_tasks_scored_full
+        if baseline is None or candidate is None:
+            if baseline is not candidate:
+                raise ValueError(
+                    "both sides carry a task count or neither does; got "
+                    f"{(baseline, candidate)}"
+                )
+            return self
+        for count in (baseline, candidate):
+            if not 0 <= count <= len(self.task_rows):
+                raise ValueError(
+                    f"a side scored between 0 and {len(self.task_rows)} of the "
+                    f"comparison's tasks; got {count}"
+                )
+        return self

techtree/presentation/rich.py

@@ -0,0 +1,312 @@
+"""The terminal rendering. Spec section 7.15.
+
+This is the CLI's own renderer, and in the released product it is the whole
+terminal result path: a signed report becomes a neutral payload, and this draws
+it. No model is asked to explain a result, so nothing between the numbers and
+the reader can change one by drawing it.
+
+Four rules, and each one is about a reader rather than about a terminal.
+
+*Meaning is never carried by colour alone.* Every outcome is spelled ``WIN``,
+``LOSS`` or ``TIE``, every caveat is introduced by its severity in words, and a
+terminal with no colour at all loses nothing but decoration. ``NO_COLOR`` and
+``--no-color`` are honoured by the console the CLI builds, and Rich emits no
+escape sequences at all when stdout is not a terminal.
+
+*The rendering is deterministic.* No spinner, no progress animation, no clock,
+no dictionary iteration order: the same payload renders to the same bytes,
+which is what makes it testable at all.
+
+*The order is the order of trust.* What was compared, then the result, then the
+tasks, then what changed, then the caveats — so a reader who stops early stops
+having read the honest version. The caveats are never last-resort small print
+they can miss; a development-only or failed-verification result says so in the
+badge at the top as well.
+
+*Regressions come first.* A reader scanning a table wants the rows that moved
+the wrong way, then the ones that moved, then the rest.
+
+The payload's next actions are deliberately not drawn here. Every Techtree
+command ends with the same numbered next-steps block, rendered by the CLI from
+the envelope it returns, and a result that grew a second one of its own would
+be the only command in the product that answers that question twice.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from rich.console import Console
+from rich.table import Table
+
+from techtree.presentation.build import (
+    HELD_FIXED_LINE,
+    NOT_BROAD_CAPABILITY_LINE,
+    VERIFICATION_FAILED,
+    VERIFICATION_NOT_VERIFIED,
+    VERIFICATION_VERIFIED,
+    cost_explanation,
+    cost_summary,
+    decision_headline,
+    efficiency_sentence,
+    score_bars,
+    solved_line,
+    task_count_line,
+)
+from techtree.presentation.models import (
+    TaskDisplay,
+    UpliftPresentationPayload,
+    selected_task_rows,
+)
+
+__all__ = ["outcome_label", "render_uplift_console"]
+
+_SEVERITY_PREFIX: Final[dict[str, str]] = {
+    "info": "Note:",
+    "warning": "Warning:",
+    "error": "Error:",
+}
+
+_SEVERITY_STYLE: Final[dict[str, str]] = {
+    "info": "",
+    "warning": "yellow",
+    "error": "red",
+}
+
+_OUTCOME_LABEL: Final[dict[str, str]] = {
+    "win": "WIN",
+    "loss": "LOSS",
+    "tie": "TIE",
+}
+
+_VERIFICATION_BADGE: Final[dict[str, str]] = {
+    VERIFICATION_VERIFIED: "local proof verified offline",
+    VERIFICATION_FAILED: "LOCAL PROOF DID NOT VERIFY",
+    VERIFICATION_NOT_VERIFIED: "local proof not checked",
+}
+
+
+def outcome_label(outcome: str) -> str:
+    """Return the word a reader sees for one task's outcome."""
+    return _OUTCOME_LABEL[outcome]
+
+
+def render_uplift_console(
+    payload: UpliftPresentationPayload,
+    console: Console,
+    *,
+    show_tasks: TaskDisplay = TaskDisplay.CHANGED,
+) -> None:
+    """Render an accessible, side-by-side terminal result.
+
+    ``show_tasks`` is the reader's choice of how much of the per-task table to
+    print (spec section 7.21). It selects rows and nothing else: no filter here
+    can change a count, because the counts come from the payload.
+    """
+    _header(payload, console)
+    _primary(payload, console)
+    _tasks(payload, console, show_tasks)
+    _efficiency(payload, console)
+    _what_changed(payload, console)
+    _caveats(payload, console)
+
+
+def _header(payload: UpliftPresentationPayload, console: Console) -> None:
+    """Campaign, comparison, and the badge that says how much this is worth."""
+    console.print(payload.campaign_title)
+    console.print(payload.comparison_label)
+    console.print(
+        f"[{payload.proof_grade} · {_VERIFICATION_BADGE[payload.verification_status]}]"
+    )
+    console.print()
+
+
+def _primary(payload: UpliftPresentationPayload, console: Console) -> None:
+    """What was established, what is still failing, and the numbers under it.
+
+    The three lines at the top are the ones a reader repeats to somebody else,
+    so they are the three that have to be defensible on their own: what this
+    comparison showed, how much of the task family is still unsolved, and the
+    fact that none of it is evidence about broad capability.
+
+    Wins, losses and ties do not appear here. On this Climb the baseline scores
+    nothing on every task, so a tie means the candidate failed the task too,
+    and a headline of twenty-four wins and no losses would read as a clean
+    sweep over a run with twelve tasks still failing. The three words stay in
+    the per-task table below, where each one is beside the scores that produced
+    it.
+
+    The count leads the detail because it is the number a person reads a result
+    in. A mean of 0.667 and "24 of 36" are the same measurement, and only one
+    of them can be repeated to somebody over a table.
+    """
+    console.print(f"Result  {decision_headline(payload)}")
+    console.print(f"        {solved_line(payload)}")
+    console.print(f"        {NOT_BROAD_CAPABILITY_LINE}")
+    console.print()
+
+    counted = task_count_line(payload)
+    if counted is not None:
+        console.print(f"Tasks   {counted}")
+        console.print()
+
+    table = Table(box=None, show_header=False, pad_edge=False, padding=(0, 2))
+    table.add_column("side", no_wrap=True)
+    table.add_column("bar", no_wrap=True)
+    for bar in score_bars(payload):
+        table.add_row(bar.label, bar.display)
+    console.print(table)
+    console.print()
+
+    console.print(
+        f"Change  {payload.absolute_delta:+.3f} mean score  ({_relative(payload)})"
+    )
+    console.print()
+
+
+def _relative(payload: UpliftPresentationPayload) -> str:
+    """Say what a relative change is, or why there is not one."""
+    if payload.relative_delta is None:
+        return "no relative change: the baseline scored nothing"
+    return f"{payload.relative_delta:+.1%} relative"
+
+
+def _tasks(
+    payload: UpliftPresentationPayload, console: Console, show: TaskDisplay
+) -> None:
+    """The per-task table, regressions first."""
+    if show is TaskDisplay.NONE:
+        return
+    rows = selected_task_rows(payload.task_rows, show)
+    if not rows:
+        console.print(_nothing_selected(show))
+        console.print()
+        return
+
+    table = Table(box=None, pad_edge=False, padding=(0, 2))
+    table.add_column("Task", no_wrap=True)
+    table.add_column("Baseline", justify="right", no_wrap=True)
+    table.add_column("Candidate", justify="right", no_wrap=True)
+    table.add_column("Change", justify="right", no_wrap=True)
+    table.add_column("Outcome", no_wrap=True)
+    for row in rows:
+        table.add_row(
+            row.task_label,
+            f"{row.baseline_score:.3f}",
+            f"{row.candidate_score:.3f}",
+            f"{row.delta:+.3f}",
+            outcome_label(row.outcome),
+        )
+    console.print(table)
+    if len(rows) != len(payload.task_rows):
+        console.print(
+            f"Showing {len(rows)} of {len(payload.task_rows)} tasks. "
+            "Use --show-tasks all for the rest."
+        )
+    console.print()
+
+
+def _nothing_selected(show: TaskDisplay) -> str:
+    """Say why the table is empty, in terms of what was asked for.
+
+    An empty selection and an unchanged comparison are not the same fact, and
+    one sentence cannot honestly stand for both. Asking a run that solved
+    twenty-three tasks to list its regressions finds none, and answering that
+    with "every task scored the same" contradicts the three lines directly
+    above it — the reader is told the run improved and then told it did not.
+    So each selection says what its own emptiness means.
+    """
+    if show is TaskDisplay.REGRESSIONS:
+        return "No task scored worse with the Skill than without it."
+    if show is TaskDisplay.ALL:
+        return "This run recorded no tasks."
+    return "Every task scored the same on both sides."
+
+
+def _efficiency(payload: UpliftPresentationPayload, console: Console) -> None:
+    """Turns, tokens, time and cost, each shown with the source it came from.
+
+    Decisions document 0007 R6 governs the cost line: a figure is never printed
+    without saying where it is from, because "$4.10" and "$4.10, estimated" are
+    different claims and only one of them is about money that was actually
+    charged.
+
+    The sentence under the numbers is there because two durations side by side
+    are not a finding. What the two sides did differently is legible in how
+    many times each had to go back to the model, and that is the half of the
+    comparison a different machine would reproduce.
+    """
+    seconds = _pair(payload.baseline_seconds, payload.candidate_seconds, unit="s")
+    console.print("Efficiency")
+    turns = _pair(payload.baseline_model_turns, payload.candidate_model_turns)
+    console.print(f"  Turns    {turns}")
+    console.print(
+        f"  Tokens   {_pair(payload.baseline_tokens, payload.candidate_tokens)}"
+    )
+    console.print(f"  Time     {seconds}")
+    console.print(f"  Cost     {cost_summary(payload)}")
+    for line in cost_explanation(payload):
+        console.print(f"           {line}")
+    console.print(f"  Source   {_ECONOMICS_SOURCE[payload.economics_source]}")
+    sentence = efficiency_sentence(payload)
+    if sentence is not None:
+        console.print(f"  {sentence}")
+    console.print()
+
+
+def _pair(
+    baseline: float | int | None, candidate: float | int | None, *, unit: str = ""
+) -> str:
+    """Return both sides of one measurement, or say it was not recorded."""
+    if baseline is None and candidate is None:
+        return "not recorded for this run"
+    return f"baseline {_number(baseline, unit)}, candidate {_number(candidate, unit)}"
+
+
+def _number(value: float | int | None, unit: str) -> str:
+    """Return one measurement, or the word for an absent one.
+
+    Whole counts are grouped. A token total is seven digits in a real run, and
+    seven ungrouped digits are a number a reader has to count rather than read.
+    """
+    if value is None:
+        return "unavailable"
+    if isinstance(value, float):
+        return f"{value:.1f}{unit}"
+    return f"{value:,}{unit}"
+
+
+def _what_changed(payload: UpliftPresentationPayload, console: Console) -> None:
+    """The one declared difference, and the statement that it is the only one."""
+    console.print("What changed")
+    console.print(f"  {payload.change_label}")
+    for side, skill in (
+        ("Baseline ", payload.baseline_skill),
+        ("Candidate", payload.candidate_skill),
+    ):
+        digest = "none" if skill.root_digest is None else skill.root_digest
+        console.print(f"  {side}  {skill.label}")
+        console.print(f"             {digest}")
+    console.print(f"  {HELD_FIXED_LINE}")
+    console.print("  Each of those was checked against what the run actually did.")
+    console.print()
+
+
+#: Where the numbers above came from, said in the reader's terms.
+_ECONOMICS_SOURCE: Final[dict[str, str]] = {
+    "comparison_execution_record": "this run's signed execution record",
+    "episode_receipts": "the run's receipts; no execution record was written",
+    "unavailable": "nothing recorded it",
+}
+
+
+def _caveats(payload: UpliftPresentationPayload, console: Console) -> None:
+    """Every caveat, in payload order, introduced by severity in words."""
+    if not payload.caveats:
+        return
+    console.print("What this does and does not prove")
+    for caveat in payload.caveats:
+        console.print(
+            f"  {_SEVERITY_PREFIX[caveat.severity]} {caveat.text}",
+            style=_SEVERITY_STYLE[caveat.severity] or None,
+        )