bladekit 4.5.0__py3-none-any.whl

bladekit/_render.py

@@ -0,0 +1,683 @@
+"""Terminal rendering helpers (rich) for the CLI.
+
+Kept separate from CLI command wiring so the formatting logic is testable and the
+``rich`` import stays out of ``import bladekit``.
+"""
+
+from __future__ import annotations
+
+import base64
+import sys
+import time
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Optional, Union
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+if TYPE_CHECKING:  # rich ships no py.typed, so this is Any at runtime-lint time
+    from rich.status import Status
+
+console = Console()
+err_console = Console(stderr=True)
+
+# --------------------------------------------------------------------------
+# verbosity
+# --------------------------------------------------------------------------
+#
+# A single module-level flag toggled once from the CLI callback (and the
+# ``--verbose``/``-v`` flag on ``run``/``deploy``, honouring ``FORGE_VERBOSE``).
+# Every renderer branches on it via :func:`is_verbose` rather than threading a
+# parameter through every call site. In verbose mode the CLI keeps the raw,
+# chatty output (streamed build steps, per-transition state lines); in the
+# default clean mode it collapses each step to a single phase line.
+VERBOSE = False
+
+
+def set_verbose(value: bool) -> None:
+    """Set the global clean-vs-verbose rendering mode (CLI callback only)."""
+    global VERBOSE
+    VERBOSE = bool(value)
+
+
+def is_verbose() -> bool:
+    return VERBOSE
+
+# --------------------------------------------------------------------------
+# banners — Blade AI Fabric brand (PAAS-771)
+# --------------------------------------------------------------------------
+#
+# The art itself lives in _banner.py, generated by the design system and
+# vendored verbatim; these wrappers only decide WHEN to show which banner.
+# _banner.print_banner already prints nothing when stdout is not a terminal and
+# handles NO_COLOR / TERM=dumb, narrow terminals, legacy Windows consoles and
+# non-UTF-8 streams.
+
+
+def _stdout_is_tty() -> bool:
+    stream = sys.stdout
+    try:
+        return bool(stream.isatty())
+    except (AttributeError, ValueError):
+        return False
+
+
+def print_intro() -> None:
+    """The big Blade AI Fabric cartouche (``blade setup``); nothing when not a TTY."""
+    from . import __version__
+    from . import _banner
+
+    _banner.print_banner("intro", version=__version__)
+
+
+def print_version(label: str) -> None:
+    """``blade --version``: compact banner with ``label`` on a TTY, else plain ``label``."""
+    if _stdout_is_tty():
+        from . import _banner
+
+        _banner.print_banner("compact", text=label)
+    else:
+        sys.stdout.write(label + "\n")
+        sys.stdout.flush()
+
+
+def print_deployed(app_name: str, version: Optional[int] = None) -> None:
+    """Closing wink after a successful ``blade deploy`` (TTY only, else nothing)."""
+    from . import _banner
+
+    text = f"{app_name} is live" + (f" · v{version}" if version is not None else "")
+    _banner.print_banner("compact", text=text, expression="wink")
+
+
+# Colors per run state for a quick visual scan.
+_STATE_STYLE = {
+    "pending": "yellow",
+    "scheduled": "cyan",
+    "starting": "cyan",
+    "running": "blue",
+    "cancelling": "magenta",
+    "succeeded": "green",
+    "failed": "red",
+    "cancelled": "magenta",
+    "lost": "red",
+    "online": "green",
+    "unreachable": "yellow",
+    "decommissioned": "dim",
+    # image build states
+    "queued": "yellow",
+    "building": "blue",
+}
+
+
+def style_state(state: Optional[str]) -> Text:
+    s = state or "unknown"
+    return Text(s, style=_STATE_STYLE.get(s, "white"))
+
+
+def _parse_ts(ts: Optional[str]) -> Optional[datetime]:
+    if not ts:
+        return None
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def now_clock() -> str:
+    return datetime.now(timezone.utc).strftime("%H:%M:%S")
+
+
+def clock_from_ts(ts: Optional[str]) -> str:
+    dt = _parse_ts(ts)
+    if dt is None:
+        return now_clock()
+    return dt.astimezone(timezone.utc).strftime("%H:%M:%S")
+
+
+def duration_str(start: Optional[str], end: Optional[str]) -> str:
+    s = _parse_ts(start)
+    e = _parse_ts(end)
+    if s is None:
+        return "-"
+    if e is None:
+        e = datetime.now(timezone.utc)
+    secs = max(0.0, (e - s).total_seconds())
+    if secs < 60:
+        return f"{secs:.1f}s"
+    mins, rem = divmod(int(secs), 60)
+    if mins < 60:
+        return f"{mins}m{rem:02d}s"
+    hours, mins = divmod(mins, 60)
+    return f"{hours}h{mins:02d}m"
+
+
+def warn_logs_incomplete() -> None:
+    """One stderr line: the log ingester was unreadable, so the logs shown are partial (PAAS-701)."""
+    err_console.print("[yellow]logs incomplete[/yellow]: the log store is unavailable, retry later")
+
+
+def print_state_transition(state: str, ts: Optional[str] = None) -> None:
+    """One line per run state transition with a timestamp (progress feed)."""
+    clock = clock_from_ts(ts)
+    arrow = Text("•", style="dim")
+    err_console.print(
+        Text.assemble(
+            (f"[{clock}] ", "dim"),
+            arrow,
+            " ",
+            style_state(state),
+        )
+    )
+
+
+# --------------------------------------------------------------------------
+# phase rendering — fal-style status lines (Blade palette)
+# --------------------------------------------------------------------------
+#
+# A "phase" is one step of a longer flow (registering, building, deploying …).
+# On a TTY in clean mode it shows a live braille spinner while the step runs,
+# then rewrites the line in place to a green check + verb + final metadata +
+# duration; on failure it rewrites to a red cross and re-raises. When NOT a
+# terminal (CI, pipes) or in verbose mode it never uses cursor rewriting —
+# it prints a plain start line and a plain done/fail line — so redirected
+# output stays clean and deterministic.
+
+_CHECK = "✓"  # ✓ success
+_CROSS = "✗"  # ✗ failure
+_ARROW = "→"  # → result / endpoint
+_DOT = "·"    # · dim start marker (non-TTY)
+_SPINNER = "dots"  # rich's braille spinner (⠋⠙⠹…, includes U+280B)
+_GOLD = "#f2b92e"  # Blade gold (design-system --b-gold, the banner chevrons)
+
+# Colour of the resolved verb per terminal run/build state, for the final line.
+_RESOLVED_STYLE = {
+    "succeeded": ("bold green", _CHECK),
+    "failed": ("bold red", _CROSS),
+    "lost": ("bold red", _CROSS),
+    "cancelled": ("bold magenta", _CROSS),
+}
+
+Meta = Union[str, Text, None]
+
+
+def _is_runner_noise(line: str) -> bool:
+    """True for the runner's own internal log lines (prefixed ``[forge-runner]``:
+    drain notices, mount/setup chatter). Hidden in clean mode — it is never the
+    user program's output — and kept under ``--verbose``."""
+    return line.lstrip().startswith("[forge-runner]")
+
+
+def _append_meta(t: Text, meta: Meta) -> None:
+    """Append metadata to a line: a plain str is dimmed; a Text is kept as-is
+    (so callers can colour a URL cyan, embed a gold arrow, etc.)."""
+    if meta is None:
+        return
+    t.append("  ")
+    if isinstance(meta, Text):
+        t.append_text(meta)
+    else:
+        t.append(str(meta), style="dim")
+
+
+def _phase_status_text(verb: str, meta: Meta) -> Text:
+    """The renderable shown AFTER the spinner while a phase is running."""
+    t = Text()
+    t.append(verb, style="bold")
+    _append_meta(t, meta)
+    return t
+
+
+def _resolved_line(
+    glyph: str, glyph_style: str, verb: str, meta: Meta = None, dur: Optional[str] = None
+) -> Text:
+    """A completed/failed/start phase line: glyph + bold verb + meta + (dur)."""
+    t = Text()
+    t.append(glyph + " ", style=glyph_style)
+    t.append(verb, style="bold")
+    _append_meta(t, meta)
+    if dur:
+        t.append("  ")
+        t.append(f"({dur})", style="dim")
+    return t
+
+
+class _PhaseHandle:
+    """Handle yielded by :func:`phase`; lets the body update the metadata (live
+    on a TTY) and pin an explicit duration string (e.g. from build timestamps
+    rather than wall-clock)."""
+
+    def __init__(self, verb: str, meta: Meta, status: Optional["Status"] = None) -> None:
+        self.verb = verb
+        self.meta = meta
+        self.duration: Optional[str] = None
+        self._status = status
+
+    def update(self, *, meta: Meta = None, duration: Optional[str] = None) -> None:
+        if meta is not None:
+            self.meta = meta
+        if duration is not None:
+            self.duration = duration
+        if self._status is not None:
+            self._status.update(_phase_status_text(self.verb, self.meta))
+
+
+@contextmanager
+def phase(verb: str, meta: Meta = None, *, stream: Optional[Console] = None):
+    """Render one phase of a flow as a single status line.
+
+    TTY + clean mode: a live braille spinner while the block runs, rewritten in
+    place to a green check + final meta + duration on success, or a red cross on
+    failure (then re-raised).
+
+    Non-TTY or verbose: no cursor rewriting — a plain dim start line up front and
+    a plain done/fail line afterwards, so CI logs and pipes stay readable.
+
+    ``stream`` overrides the target Console (default: the shared stdout
+    ``console``) — used by ``blade image build``, whose stdout is reserved for
+    the machine-parsed ``--json`` result, so its phase decoration must land on
+    ``err_console`` instead.
+    """
+    target = stream or console
+    handle = _PhaseHandle(verb, meta)
+    start = time.monotonic()
+    live = target.is_terminal and not VERBOSE
+    status = None
+    if live:
+        status = target.status(
+            _phase_status_text(verb, meta), spinner=_SPINNER, spinner_style="cyan"
+        )
+        handle._status = status
+        status.start()
+    else:
+        target.print(_resolved_line(_DOT, "dim", verb, meta))
+    try:
+        yield handle
+    except BaseException:
+        if status is not None:
+            status.stop()
+        target.print(_resolved_line(_CROSS, "bold red", verb))
+        raise
+    if status is not None:
+        status.stop()
+    dur = handle.duration or f"{time.monotonic() - start:.1f}s"
+    target.print(_resolved_line(_CHECK, "bold green", verb, handle.meta, dur))
+
+
+def result_line(text: str, *, style: str = "cyan") -> None:
+    """An indented result line prefixed with the Blade gold arrow →
+    (endpoint URLs, routes)."""
+    t = Text("  ")
+    t.append(_ARROW + " ", style=_GOLD)
+    t.append(text, style=style)
+    console.print(t)
+
+
+def summary_line(text: str) -> None:
+    """A further-indented dim summary line under a phase (autoscaling bounds,
+    cold-start …)."""
+    console.print(Text("    " + text, style="dim"))
+
+
+# Runs created over a queue-mode GPU quota (namespace or org tier): their
+# creation response carried a *_GPU_QUOTA_REACHED warning, which is never
+# persisted server-side — so the creator records the run id here and
+# RunProgress labels the pending wait "waiting for quota" instead of the
+# misleading "waiting for capacity". Process-local, best-effort.
+_QUOTA_QUEUED_RUNS: set = set()
+
+
+def mark_quota_queued(run_id: str) -> None:
+    """Record that run_id was created at/over a queue-mode GPU quota."""
+    if run_id:
+        _QUOTA_QUEUED_RUNS.add(run_id)
+
+
+class RunProgress:
+    """Clean-mode progress for ``blade run``: a braille spinner while the run is
+    pending/scheduled/starting, which yields to the user program's stdout the
+    instant execution begins, then a resolved check/cross summary line at the
+    terminal state.
+
+    The user program's stdout/stderr is NEVER suppressed — the spinner only
+    covers the wait BEFORE output starts and is retired before the first log
+    line so it never fights the streamed output. On a non-TTY (or verbose mode
+    handled by the caller) there is no spinner: a plain start line up front and
+    a plain resolved line at the end.
+    """
+
+    _WAIT_STATES = frozenset({"pending", "scheduled", "starting"})
+
+    # The verb shown while the run is in each pre-execution state — so the
+    # spinner names the actual phase (fal-style) instead of a misleading
+    # "running" for the whole wait. `starting` is when the node pulls the image
+    # and creates the container, which dominates the wait, hence "pulling
+    # image".
+    _WAIT_VERB = {
+        "pending": "waiting for capacity",
+        "scheduled": "scheduling",
+        "starting": "pulling image",
+    }
+
+    def __init__(self, meta: Meta = None, run_id: Optional[str] = None) -> None:
+        self._meta = meta
+        self._start = time.monotonic()
+        self._status: Optional["Status"] = None
+        self._live = console.is_terminal and not VERBOSE
+        self._stopped = False
+        self._started = False
+        # Current pre-execution verb; refined by on_state as the run advances.
+        self._verb = "starting run"
+        self._printed_verb: Optional[str] = None  # non-TTY line de-dup
+        # Per-instance wait verbs: a quota-queued run (mark_quota_queued) waits
+        # on its quota, not on fleet capacity — name the actual phase.
+        self._wait_verbs = dict(self._WAIT_VERB)
+        if run_id is not None and run_id in _QUOTA_QUEUED_RUNS:
+            self._wait_verbs["pending"] = "waiting for quota"
+
+    def start(self) -> None:
+        self._started = True
+        if self._live:
+            self._status = console.status(
+                _phase_status_text(self._verb, self._meta),
+                spinner=_SPINNER,
+                spinner_style="cyan",
+            )
+            self._status.start()
+        # Non-TTY: nothing is printed up front — the first state transition
+        # emits the first `· <phase>` line (avoids a redundant generic line
+        # before the real phase is known).
+
+    def _print_wait_line(self, verb: str) -> None:
+        # Non-TTY: one dim `· <verb>` line per distinct phase (no cursor
+        # rewriting), so CI/pipe output shows the pull progression as plain
+        # lines without spam.
+        if verb == self._printed_verb:
+            return
+        self._printed_verb = verb
+        console.print(_resolved_line(_DOT, "dim", verb, self._meta))
+
+    def _stop_spinner(self) -> None:
+        if self._status is not None and not self._stopped:
+            self._status.stop()
+        self._stopped = True
+
+    def on_state(self, state: Optional[str]) -> None:
+        if state is None:
+            return
+        if state in self._WAIT_STATES:
+            # Refine the phase label (spinner text on a TTY, a new dim line
+            # otherwise) so the user sees "pulling image" during the pull
+            # rather than a static verb.
+            verb = self._wait_verbs.get(state, self._verb)
+            if verb == self._verb:
+                return
+            self._verb = verb
+            if self._live:
+                if self._status is not None:
+                    self._status.update(_phase_status_text(verb, self._meta))
+            else:
+                self._print_wait_line(verb)
+        else:
+            # Left the waiting states — retire the spinner so the user
+            # program's stdout starts on a clean line, never under a spinner.
+            self._stop_spinner()
+
+    def before_log(self) -> None:
+        # First byte of user output: retire the spinner unconditionally.
+        self._stop_spinner()
+
+    def finish(self, final_state: Optional[str]) -> None:
+        from ._constants import RUN_TERMINAL_STATES
+
+        self._stop_spinner()
+        if not self._started or final_state not in RUN_TERMINAL_STATES:
+            return
+        style, glyph = _RESOLVED_STYLE.get(final_state, ("bold red", _CROSS))
+        dur = f"{time.monotonic() - self._start:.1f}s"
+        console.print(_resolved_line(glyph, style, final_state, None, dur))
+
+
+class LogRenderer:
+    """Stateful renderer for a sequence of LogChunks from one stream.
+
+    LogChunks are flushed by forge-node purely by byte volume/time (every
+    100ms or at 32/64 KiB — see forge-node/internal/agent/logbuffer.go),
+    NOT aligned to ``\\n``/``\\r`` boundaries. A single logical line (e.g. a
+    tqdm/HF/whisper download bar) can straddle two chunks: the trailing
+    partial segment of chunk N has no following ``\\r``/``\\n`` *within that
+    chunk*, so treating each chunk independently prints it as if it were a
+    complete line, then prints the continuation from chunk N+1 as a second,
+    different-looking line for the SAME logical progress bar.
+
+    To render correctly we keep a per-stream (stdout/stderr) carry buffer of
+    the not-yet-terminated tail across calls, and only emit a segment once a
+    ``\\n`` confirms it is complete. In-place carriage-return progress (tqdm)
+    is still collapsed to the final state of each logical line, now applied
+    across carry+chunk instead of within a single chunk.
+    """
+
+    def __init__(self) -> None:
+        self._carry = {"stdout": "", "stderr": ""}
+
+    def feed(self, chunk: dict) -> None:
+        data = base64.b64decode(chunk.get("data_b64", ""))
+        text = data.decode("utf-8", "replace")
+        stream = "stderr" if chunk.get("stream", "stdout") == "stderr" else "stdout"
+        is_err = stream == "stderr"
+        target = err_console if is_err else console
+        style = "dim" if is_err else ""
+
+        buf = self._carry[stream] + text
+        # Split on newlines only (NOT splitlines, which also breaks on \r and
+        # turns one progress line into many). The last element has no
+        # trailing '\n' yet — it may be a complete-but-unterminated line or a
+        # mid-line fragment continued in the next chunk, so it is carried
+        # over rather than printed now.
+        parts = buf.split("\n")
+        self._carry[stream] = parts[-1]
+        for raw in parts[:-1]:
+            line = raw.rsplit("\r", 1)[-1].rstrip()
+            if not line:
+                continue
+            if is_err and not VERBOSE and _is_runner_noise(line):
+                continue
+            target.print(Text(line, style=style), highlight=False)
+
+        if chunk.get("truncated"):
+            self.flush(stream)
+            err_console.print(
+                Text("  … [log truncated by agent — output rate too high]", "yellow")
+            )
+
+    def flush(self, stream: Optional[str] = None) -> None:
+        """Emit any residual partial line(s) — call at eof / stream end."""
+        streams = [stream] if stream else ["stdout", "stderr"]
+        for s in streams:
+            raw = self._carry.get(s, "")
+            self._carry[s] = ""
+            line = raw.rsplit("\r", 1)[-1].rstrip()
+            if not line:
+                continue
+            if s == "stderr" and not VERBOSE and _is_runner_noise(line):
+                continue
+            target = err_console if s == "stderr" else console
+            style = "dim" if s == "stderr" else ""
+            target.print(Text(line, style=style), highlight=False)
+
+
+# Module-level default renderer for callers that render a single chunk at a
+# time without managing their own LogRenderer (keeps print_log_chunk's
+# existing call signature working, now stateful across calls).
+_default_renderer = LogRenderer()
+
+
+def print_log_chunk(chunk: dict) -> None:
+    """Render a single LogChunk (bytes are base64; decode UTF-8 with replacement,
+    conventions §8).
+
+    No stream prefix: stderr is NOT an error — tqdm bars, logging and
+    transformers/whisper download meters all write there — so we print it dimmed
+    (never red) and stdout at normal weight, letting brightness tell them apart
+    without an ``err|``/``out|`` label cluttering every line. In-place
+    carriage-return progress (tqdm) is collapsed to the final state of each
+    logical line, exactly as a real terminal renders ``\\r``, so a download bar
+    shows as one clean line instead of a wall of fragments + blank lines.
+
+    Stateful across calls (see :class:`LogRenderer`): a logical line split
+    across two LogChunks (chunk boundaries are byte/time-flush based, not
+    newline-aligned) is carried over and only emitted once its terminating
+    ``\\n`` arrives, instead of being rendered as two separate lines. Callers
+    that stream a bounded sequence of chunks to completion should call
+    :func:`flush_log_tail` afterwards to emit any unterminated final line.
+    """
+    _default_renderer.feed(chunk)
+
+
+def flush_log_tail() -> None:
+    """Flush the default renderer's residual partial line (call at stream end)."""
+    _default_renderer.flush()
+
+
+def runs_table(items: list) -> Table:
+    table = Table(title="runs", header_style="bold")
+    table.add_column("run_id", overflow="fold")
+    table.add_column("state")
+    table.add_column("app")
+    table.add_column("gpu")
+    table.add_column("created")
+    table.add_column("duration")
+    for r in items:
+        res = r.get("resources") or {}
+        table.add_row(
+            r.get("run_id", "-"),
+            style_state(r.get("state")),
+            r.get("app_name") or "-",
+            res.get("gpu_type", "-"),
+            clock_from_ts(r.get("created_at")),
+            duration_str(r.get("started_at"), r.get("finished_at")),
+        )
+    return table
+
+
+def _human_bytes(n: Optional[int]) -> str:
+    if n is None:
+        return "-"
+    f = float(n)
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if f < 1024 or unit == "TiB":
+            return f"{f:.0f}{unit}" if unit == "B" else f"{f:.1f}{unit}"
+        f /= 1024
+    return f"{f:.1f}TiB"
+
+
+def volumes_table(items: list) -> Table:
+    table = Table(title="volumes", header_style="bold")
+    table.add_column("volume_id", overflow="fold")
+    table.add_column("name")
+    table.add_column("generation")
+    table.add_column("size")
+    table.add_column("files")
+    table.add_column("last_committed")
+    for v in items:
+        table.add_row(
+            v.get("volume_id", "-"),
+            v.get("name", "-"),
+            str(v.get("current_generation", 0)),
+            _human_bytes(v.get("size_bytes")),
+            str(v.get("file_count")) if v.get("file_count") is not None else "-",
+            clock_from_ts(v.get("last_committed_at")) if v.get("last_committed_at") else "-",
+        )
+    return table
+
+
+def volume_files_table(items: list) -> Table:
+    table = Table(title="files", header_style="bold")
+    table.add_column("path", overflow="fold")
+    table.add_column("type")
+    table.add_column("size")
+    table.add_column("mode")
+    for f in items:
+        mode = f.get("mode")
+        table.add_row(
+            f.get("path", "-"),
+            f.get("type", "-"),
+            _human_bytes(f.get("size_bytes")) if f.get("type") == "file" else "-",
+            oct(mode)[2:] if isinstance(mode, int) else "-",
+        )
+    return table
+
+
+def secrets_table(items: list) -> Table:
+    table = Table(title="secrets", header_style="bold")
+    table.add_column("secret_id", overflow="fold")
+    table.add_column("name")
+    table.add_column("env_keys")
+    table.add_column("updated")
+    for s in items:
+        table.add_row(
+            s.get("secret_id", "-"),
+            s.get("name", "-"),
+            ", ".join(s.get("env_keys", [])) or "-",
+            clock_from_ts(s.get("updated_at") or s.get("created_at")),
+        )
+    return table
+
+
+def images_table(items: list) -> Table:
+    table = Table(title="image catalogue", header_style="bold")
+    table.add_column("alias")
+    table.add_column("registry_ref", overflow="fold")
+    table.add_column("enabled")
+    from ._image import to_display_image
+
+    for i in items:
+        table.add_row(
+            # The server lists forge/<name>; users write fabric/<name> (PAAS-771).
+            to_display_image(i.get("alias", "-")),
+            i.get("registry_ref", "-"),
+            "yes" if i.get("enabled") else "no",
+        )
+    return table
+
+
+def builds_table(items: list) -> Table:
+    table = Table(title="image builds", header_style="bold")
+    table.add_column("build_id", overflow="fold")
+    table.add_column("state")
+    table.add_column("hash")
+    table.add_column("created")
+    for b in items:
+        h = b.get("definition_hash", "")
+        table.add_row(
+            b.get("build_id", "-"),
+            style_state(b.get("state")),
+            (h[:16] + "…") if len(h) > 16 else h,
+            clock_from_ts(b.get("created_at")),
+        )
+    return table
+
+
+def nodes_table(items: list) -> Table:
+    table = Table(title="fleet", header_style="bold")
+    table.add_column("node_id", overflow="fold")
+    table.add_column("hostname")
+    table.add_column("state")
+    table.add_column("gpu_type")
+    table.add_column("free/total")
+    table.add_column("fake")
+    for n in items:
+        gpus = n.get("gpus") or []
+        total = len(gpus)
+        free = sum(1 for g in gpus if not g.get("reserved_by_run_id"))
+        gpu_types = sorted({g.get("gpu_type", "?") for g in gpus}) or ["-"]
+        table.add_row(
+            n.get("node_id", "-"),
+            n.get("hostname", "-"),
+            style_state(n.get("state")),
+            ",".join(gpu_types),
+            f"{free}/{total}",
+            "yes" if n.get("fake_gpu") else "no",
+        )
+    return table