mostlyright-data 0.9.0__py3-none-any.whl

mostlyright/data_harness/nbrender/outputs_text.py

@@ -0,0 +1,400 @@
+"""Group D · text outputs (D16, D17, D18, D23, D24): stdout, stderr, result, traceback, progress.
+
+Routed to from ``document._render_output``.  ANSI escapes are stripped via :func:`parse.strip_ansi`
+and never honored — only its SGR-bold flag maps to weight 600 (D17/D23).  Tracebacks are
+re-tokenized here, not passed through: strip the ANSI, then color frames/arrows/source ourselves,
+and collapse site-packages frames behind a static bar.  Progress (D24) re-derives its fraction from
+:func:`parse.detect_tqdm` over the output text.  Every string that reaches HTML passes through
+:func:`parse.esc`; no literal color is emitted here — all styling resolves to a rule in
+``tokens.build_css``, including the three ``.nb-tb-*`` classes of the D23 source mini-theme.
+"""
+
+from __future__ import annotations
+
+import re
+
+from mostlyright.data_harness.nbrender.parse import (
+    Output,
+    RenderContext,
+    detect_tqdm,
+    esc,
+    strip_ansi,
+)
+
+# Long-output trigger for the D24 scrolled box.  The design fires at more than 8 lines or 96px;
+# pixel height is not measurable at render time, so the logical line count carries the trigger.
+_SCROLL_LINE_THRESHOLD = 8
+
+# --- D23 traceback re-tokenizer ---------------------------------------------------------------
+# Python keywords for the traceback source mini-theme.  Hardcoded as data rather than importing the
+# stdlib ``keyword`` module, which is outside the sanctioned stdlib subset.
+_PY_KEYWORDS = frozenset(
+    {
+        "False",
+        "None",
+        "True",
+        "and",
+        "as",
+        "assert",
+        "async",
+        "await",
+        "break",
+        "class",
+        "continue",
+        "def",
+        "del",
+        "elif",
+        "else",
+        "except",
+        "finally",
+        "for",
+        "from",
+        "global",
+        "if",
+        "import",
+        "in",
+        "is",
+        "lambda",
+        "nonlocal",
+        "not",
+        "or",
+        "pass",
+        "raise",
+        "return",
+        "try",
+        "while",
+        "with",
+        "yield",
+        "match",
+        "case",
+    }
+)
+
+# One-physical-line source lexer.  Traceback source arrives as individual dedented lines, which the
+# stdlib ``tokenize`` module rejects; a regex lexer is robust to fragments.  Only three token
+# classes are colored (keyword / string / comment); everything else keeps the body color.  The
+# trailing ``any`` alternative guarantees every character is consumed (so an unterminated quote is
+# never silently dropped).
+_PY_TOK_RE = re.compile(
+    r"(?P<com>\#[^\n]*)"
+    r"|(?P<str>\"(?:\\.|[^\"\\\n])*\"|'(?:\\.|[^'\\\n])*')"
+    r"|(?P<word>[A-Za-z_][A-Za-z0-9_]*)"
+    r"|(?P<ws>\s+)"
+    r"|(?P<other>[^\sA-Za-z_\"'#]+)"
+    r"|(?P<any>.)"
+)
+
+# `----> 3 code` (current frame) and `--> 118 code` (nested) — arrow, line number, source.
+_ARROW_RE = re.compile(r"^(?P<lead>\s*)(?P<arrow>-+>)(?P<sp>\s+)(?P<num>\d+)(?P<rest>.*)$")
+# `      118    code` — bare line-numbered source.
+_NUM_RE = re.compile(r"^(?P<lead>\s*)(?P<num>\d+)(?P<rest>\s.*)?$")
+# The ipython banner rule of dashes above the exception name.
+_DASH_RE = re.compile(r"^\s*-{3,}\s*$")
+# Frame location headers.
+_LOC_RE = re.compile(r"^\s*(Cell|File|Input) ")
+_TB_LABEL = "Traceback (most recent call last)"
+_CARET = "▸"  # ▸ · sanctioned B09 collapse glyph
+
+
+def _plural(count: int, word: str) -> str:
+    """`3 frame` -> `3 frames`; `1 frame` -> `1 frame`.  Terse, no locale handling."""
+    return f"{count} {word}" + ("s" if count != 1 else "")
+
+
+# --- D16 · stdout -----------------------------------------------------------------------------
+
+
+def render_stdout(out: Output, ctx: RenderContext) -> str:
+    """D16 · stdout stream — labeled well, pre-wrap; long runs scroll (D24 box).
+
+    Consecutive stdout merging is an upstream concern (one :class:`Output` per stream record
+    reaches here); this renders one well per record.  ANSI is stripped, not honored — a stray SGR
+    escape never reaches the page as a control byte.  Over :data:`_SCROLL_LINE_THRESHOLD` lines the
+    body moves into the D24 scrolled box with an "output scrolled" note.
+    """
+    text = strip_ansi(out.text).text
+    label = '<div class="nb-out-label">stdout</div>'
+    lines = text.splitlines()
+    if len(lines) > _SCROLL_LINE_THRESHOLD:
+        hidden = len(lines) - _SCROLL_LINE_THRESHOLD
+        note = "output scrolled · " + _plural(hidden, "more line")
+        body = (
+            '<div class="nb-scrolled"><pre>' + esc(text) + "</pre></div>"
+            '<div class="nb-scrolled-note">' + esc(note) + "</div>"
+        )
+    else:
+        body = "<pre>" + esc(text) + "</pre>"
+    return '<div class="nb-well nb-stdout">' + label + body + "</div>"
+
+
+# --- D17 · stderr / warnings ------------------------------------------------------------------
+
+
+def render_stderr(out: Output, ctx: RenderContext) -> str:
+    """D17 · stderr / warnings — rust text; ANSI stripped, SGR bold maps to weight 600.
+
+    The dashed top separator that connects stderr to a preceding stdout well lives in the shared
+    ``.nb-stderr`` rule.  The dispatch signature carries no predecessor, so the separator renders on
+    every stderr well rather than only when it follows stdout.  Per-span bold is not available from
+    the shared helper — a single bold flag bolds the whole block.
+    """
+    stripped = strip_ansi(out.text)
+    content = esc(stripped.text)
+    if stripped.bold:
+        content = '<span class="nb-sgr-bold">' + content + "</span>"
+    return (
+        '<div class="nb-well nb-stderr">'
+        '<div class="nb-out-label">stderr</div>'
+        "<pre>" + content + "</pre>"
+        "</div>"
+    )
+
+
+# --- D18 · execute_result (plain text) --------------------------------------------------------
+
+
+def render_result_text(out: Output, ctx: RenderContext) -> str:
+    """D18 · execute_result plain text — bare pre, no well, in the Out[n] content column.
+
+    Faithful to the object repr: escaped, not ANSI-stripped, so a repr that legitimately contains
+    escape-like text is preserved verbatim.
+    """
+    text = out.text_of("text/plain") or out.text
+    return '<pre class="nb-result-plain">' + esc(text) + "</pre>"
+
+
+# --- D24 · progress ---------------------------------------------------------------------------
+
+
+def _fmt_pct(fraction: float) -> str:
+    """Fraction (0..1) to a bare CSS percentage number, no trailing zero noise."""
+    return f"{fraction * 100:g}"
+
+
+def _indeterminate_label(text: str) -> str:
+    """Best-effort description label from an indeterminate tqdm frame (`desc: |...`)."""
+    last = text.rsplit("\r", 1)[-1].strip()
+    match = re.match(r"\s*([^|:%]+?)\s*[:|]", last)
+    return match.group(1).strip() if match else ""
+
+
+def render_progress(out: Output, ctx: RenderContext) -> str:
+    """D24 · progress — determinate tqdm track/fill/stat, else an indeterminate yellow bar.
+
+    ``document`` routes here only when :func:`parse.detect_tqdm` matched (a determinate frame with
+    n/total); the indeterminate branch renders a fixed 30% yellow bar for direct callers.  The
+    scrolled long-output box (also D24) is reached through :func:`render_stdout`, since long
+    non-tqdm stdout dispatches to D16, not here.
+    """
+    text = out.text if out.text else out.text_of("text/plain")
+    prog = detect_tqdm(text)
+    if prog is not None:
+        width = _fmt_pct(prog.fraction)
+        return (
+            '<div class="nb-progress">'
+            '<span class="nb-progress-label">' + esc(prog.label) + "</span>"
+            '<div class="nb-progress-track">'
+            '<div class="nb-progress-fill" style="width: ' + width + '%"></div>'
+            "</div>"
+            '<span class="nb-progress-stat">' + esc(prog.stat) + "</span>"
+            "</div>"
+        )
+    label = _indeterminate_label(text)
+    return (
+        '<div class="nb-progress">'
+        '<span class="nb-progress-label">' + esc(label) + "</span>"
+        '<div class="nb-progress-track">'
+        '<div class="nb-progress-fill nb-progress-fill--indeterminate"></div>'
+        "</div>"
+        '<span class="nb-progress-stat"></span>'
+        "</div>"
+    )
+
+
+# --- D23 · traceback --------------------------------------------------------------------------
+
+
+def _tokenize_code(code: str) -> str:
+    """Colorize one source fragment with the three-class traceback theme; escape every piece."""
+    parts: list[str] = []
+    for match in _PY_TOK_RE.finditer(code):
+        kind = match.lastgroup
+        value = match.group()
+        if kind == "com":
+            parts.append('<span class="nb-tb-com">' + esc(value) + "</span>")
+        elif kind == "str":
+            parts.append('<span class="nb-tb-str">' + esc(value) + "</span>")
+        elif kind == "word" and value in _PY_KEYWORDS:
+            parts.append('<span class="nb-tb-kw">' + esc(value) + "</span>")
+        else:
+            parts.append(esc(value))
+    return "".join(parts)
+
+
+def _render_source_line(line: str) -> str:
+    """Render a numbered (optionally arrowed) source line: arrow span + line number + tokens."""
+    match = _ARROW_RE.match(line)
+    if match:
+        return (
+            esc(match.group("lead"))
+            + '<span class="nb-tb-arrow">'
+            + esc(match.group("arrow"))
+            + "</span>"
+            + esc(match.group("sp"))
+            + esc(match.group("num"))
+            + _tokenize_code(match.group("rest"))
+        )
+    match = _NUM_RE.match(line)
+    if match:
+        return (
+            esc(match.group("lead"))
+            + esc(match.group("num"))
+            + _tokenize_code(match.group("rest") or "")
+        )
+    return _tokenize_code(line)
+
+
+def _render_tb_line(line: str, is_final: bool) -> str:
+    """One body line: final exception (weight 600), frame location, blank, or source."""
+    if is_final:
+        return '<span class="nb-tb-final">' + esc(line) + "</span>"
+    if line.strip() == "":
+        return ""
+    if _LOC_RE.match(line):
+        return '<span class="nb-tb-loc">' + esc(line) + "</span>"
+    return _render_source_line(line)
+
+
+def _collapse_bar(count: int) -> str:
+    """B09-style static bar standing in for a run of collapsed site-packages frames."""
+    return (
+        '<div class="nb-collapse">'
+        '<span class="nb-collapse-caret">'
+        + _CARET
+        + "</span>"
+        + esc(_plural(count, "library frame"))
+        + '<span class="nb-collapse-spacer"></span>'
+        "</div>"
+    )
+
+
+def _trim_blank_edges(
+    payload: list[tuple[str, bool]],
+) -> list[tuple[str, bool]]:
+    """Drop leading/trailing blank non-final lines so a pre never renders empty edge rows."""
+    start, end = 0, len(payload)
+    while start < end and not payload[start][1] and payload[start][0].strip() == "":
+        start += 1
+    while end > start and not payload[end - 1][1] and payload[end - 1][0].strip() == "":
+        end -= 1
+    return payload[start:end]
+
+
+def _render_tb_body(out: Output) -> str:
+    """Re-tokenize the ANSI-laden traceback into user-frame pres and collapsed library-frame bars.
+
+    Steps: strip ANSI; drop the dashes banner and the "…Traceback (most recent call last)" header
+    (both hoisted into the header bar); split off the final exception line; group the rest into
+    frames by location header; render user frames as pre blocks and each run of site-packages
+    frames as a single B09 count bar; append the final exception line in weight 600.
+    """
+    lines = [strip_ansi(raw).text for raw in (out.traceback or [])]
+    cleaned = [
+        line for line in lines if not _DASH_RE.match(line) and not line.rstrip().endswith(_TB_LABEL)
+    ]
+
+    # Final exception line: prefer the model's ename/evalue; drop the matching trailing body line so
+    # it is not rendered twice.  With no ename, fall back to the last non-empty body line.
+    final_text: str | None = None
+    if out.ename:
+        final_text = f"{out.ename}: {out.evalue}" if out.evalue else str(out.ename)
+    last_index = next((i for i in range(len(cleaned) - 1, -1, -1) if cleaned[i].strip()), None)
+    if last_index is not None:
+        if final_text is not None and cleaned[last_index].strip().startswith(str(out.ename)):
+            cleaned.pop(last_index)
+        elif final_text is None:
+            final_text = cleaned[last_index].strip()
+            cleaned.pop(last_index)
+
+    # Group into frames by location header; lines before the first header are preamble.
+    frames: list[tuple[bool, list[str]]] = []
+    preamble: list[str] = []
+    current: tuple[bool, list[str]] | None = None
+    for line in cleaned:
+        if _LOC_RE.match(line):
+            if current is not None:
+                frames.append(current)
+            is_lib = "site-packages" in line or "dist-packages" in line
+            current = (is_lib, [line])
+        elif current is None:
+            preamble.append(line)
+        else:
+            current[1].append(line)
+    if current is not None:
+        frames.append(current)
+
+    # Ordered render blocks: shown ('pre') vs collapsed library run ('lib').
+    blocks: list[list] = []
+
+    def push_lines(more: list[str]) -> None:
+        entries = [(line, False) for line in more]
+        if blocks and blocks[-1][0] == "pre":
+            blocks[-1][1].extend(entries)
+        else:
+            blocks.append(["pre", entries])
+
+    def push_lib() -> None:
+        if blocks and blocks[-1][0] == "lib":
+            blocks[-1][1] += 1
+        else:
+            blocks.append(["lib", 1])
+
+    if preamble:
+        push_lines(preamble)
+    for is_lib, frame_lines in frames:
+        if is_lib:
+            push_lib()
+        else:
+            push_lines(frame_lines)
+
+    if final_text is not None:
+        if blocks and blocks[-1][0] == "pre":
+            blocks[-1][1].append((final_text, True))
+        else:
+            blocks.append(["pre", [(final_text, True)]])
+
+    parts: list[str] = []
+    for kind, payload in blocks:
+        if kind == "lib":
+            parts.append(_collapse_bar(payload))
+            continue
+        trimmed = _trim_blank_edges(payload)
+        if not trimmed:
+            continue
+        rendered = "\n".join(_render_tb_line(line, is_final) for line, is_final in trimmed)
+        parts.append('<pre class="nb-tb-body">' + rendered + "</pre>")
+
+    if not parts:
+        fallback = final_text or (str(out.evalue) if out.evalue else "")
+        parts.append(
+            '<pre class="nb-tb-body"><span class="nb-tb-final">' + esc(fallback) + "</span></pre>"
+        )
+    return "".join(parts)
+
+
+def render_traceback(out: Output, ctx: RenderContext) -> str:
+    """D23 · traceback — native error output, re-tokenized body, library frames collapsed.
+
+    The exception name and the "Traceback (most recent call last)" caption are hoisted into the
+    header bar; the body carries frames, arrows, source, and the final exception line.  ``role`` is
+    ``alert`` only in connected mode, where the error is new; a static export is silent.
+    """
+    head_name = esc(out.ename) if out.ename else "Traceback"
+    head = (
+        '<div class="nb-tb-head">'
+        '<span class="nb-tb-name">' + head_name + "</span>"
+        '<span class="nb-tb-label">' + esc(_TB_LABEL) + "</span>"
+        "</div>"
+    )
+    role = ' role="alert"' if ctx.mode == "connected" else ""
+    return '<div class="nb-tb"' + role + ">" + head + _render_tb_body(out) + "</div>"