@pineforge/codegen-pyodide 1.0.1 → 1.2.0

package/pineforge_codegen/errors.py

@@ -32,6 +32,29 @@ class Diagnostic:
     message: str
     hint: str | None = None
 
+    # The stable code (``PF-E1203`` / ``PF-W0412``) and named arguments of the
+    # catalog template the English ``message`` and ``hint`` render from
+    # (``diagnostic_codes``, ``diagnostics_catalog.json``). Both are read off
+    # the text when first asked for, after the transpile: the text and the
+    # C++ never depend on them.
+    @property
+    def code(self) -> str:
+        return self._coded()[0]
+
+    @property
+    def args(self) -> dict:
+        return self._coded()[1]
+
+    def _coded(self) -> tuple[str, dict]:
+        severity = getattr(self.level, "value", self.level)
+        key = (severity, self.message, self.hint)
+        cached = self.__dict__.get("_pf_coded")
+        if cached is None or cached[0] != key:
+            from .diagnostic_codes import classify
+            cached = (key, classify(severity, self.message, self.hint))
+            self.__dict__["_pf_coded"] = cached
+        return cached[1]
+
 
 class CompileError(Exception):
     def __init__(self, diagnostics: list[Diagnostic]):

package/pineforge_codegen/external_requests.py

@@ -85,6 +85,19 @@ _RECORDED_PARAMS = {
 # RequestRef}``: the run stops there only when no data is installed for the
 # request that carries the same ref (``REQUEST_REF_ANNOTATION``).
 UNPINNED_ANNOTATION = "pf_request_unpinned"
+CAPABILITY_UNPINNED_ANNOTATION = "pf_capability_unpinned_requests"
+
+
+def _record_unpinned_capability(program, request):
+    notes = program.annotations = dict(program.annotations or {})
+    sites = notes.setdefault(CAPABILITY_UNPINNED_ANNOTATION, [])
+    sites.append({
+        "function": f"request.{request.callee.member}",
+        "symbol_node": request.args[0] if request.args else request.kwargs.get("symbol"),
+        "tf_node": request.args[1] if len(request.args) > 1 else request.kwargs.get("timeframe"),
+        "lookahead_node": request.kwargs.get("lookahead"),
+        "gaps_node": request.kwargs.get("gaps"),
+    })
 REQUEST_REF_ANNOTATION = "pf_request_ref"
 # On a request whose symbol can select the chart's or another symbol's: it
 # read the chart before it read a feed, and keeps that lowering where no feed
@@ -785,10 +798,12 @@ def lower_no_data_requests(program: Program) -> Program:
             backed.append(node)
             continue
         if lowering == ABSENT_LOWERING:
+            _record_unpinned_capability(program, node)
             node.annotations = {**node.annotations, UNPINNED_ANNOTATION: unpinned_message(node)}
             continue
         swaps[id(node)] = _na_of(node, funcs)
         if lowering == "unpinned":
+            _record_unpinned_capability(program, node)
             unpinned.append(node)
     if unpinned or backed:
         index = ScriptIndex(program)
@@ -853,11 +868,15 @@ def unpin_requests(program: Program, reasons: dict[int, str]) -> None:
                 "results."))
             continue
         lowered = _na_of(request, funcs)
+        _record_unpinned_capability(program, request)
         marker = (request.annotations or {}).get(UNPINNED_ANNOTATION)
         if isinstance(marker, dict):
             lowered.annotations = {**(lowered.annotations or {}),
                                    UNPINNED_ANNOTATION: marker["message"]}
         swaps[request_id] = lowered
+        # The request leaves the program; its lowering is the deferred
+        # refusal's now (``request_discovery`` lists it so).
+        request.annotations = {**(request.annotations or {}), LOWERING_ANNOTATION: "unpinned"}
         warnings.append(pass_warning(
             request,
             f"{spell_call(request)}: no data is pinned for this request; the run stops with "

package/pineforge_codegen/request_discovery.py

@@ -0,0 +1,506 @@
+"""The other symbols' data a script requests, listed before it runs.
+
+``transpile_full(...)["requests"]`` names every request site that reads
+another symbol's feed, so a host can fetch the bars a run needs before it
+starts it. A run supplies another symbol's bars as one feed per (symbol
+string, timeframe) and the engine looks a site's feed up byte for byte
+(``codegen/emit_top.py``, ``_emit_foreign_security_registration``), so each
+entry states both the way registration computes them:
+
+    {"line": 7, "fn": "request.security",
+     "symbol":    {"kind": "input", "title": "Other symbol", "default": "BINANCE:ETHUSDT"},
+     "timeframe": {"kind": "chart"},
+     "lookahead": false, "gaps": false, "ignore_invalid_symbol": false}
+
+The sites are the registrations the C++ makes: ``request.security`` of
+another symbol that the support checker lowered onto its feed
+(``external_requests.FEED_LOWERING``), one entry per context a helper's call
+paths give it (``security_contexts``), with the feed column a footprint reads
+(``column``). A site whose value reaches display and alert sinks only is
+lowered to ``na`` and reads nothing, and a helper nothing reaches never runs:
+neither is listed. A deferred refusal -- another symbol's request whose value
+can reach a trade but which registration cannot key before the first bar --
+is listed with an ``unresolvable`` symbol: its first read stops the run.
+Every other request reads no feed: the chart's symbol, ``request.*`` of
+fundamentals (recorded series, not bars) and ``request.security_lower_tf`` of
+another symbol (it stops the run where it is evaluated).
+
+Names are expanded as registration expands them
+(``_substitute_tf_input_reads``: the expression the C++ renders and the run
+evaluates before the first bar), and a ``value`` is computed only over
+``ScriptIndex.registration_value``'s grammar -- literals, inputs at their
+defaults, ``+ == != and or not``, ternaries and ``ticker.inherit`` /
+``standard`` -- so discovery states a value where the run computes the same
+one from the same expression.
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import (
+    BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier, MemberAccess, NaLiteral,
+    NumberLiteral, StringLiteral, Subscript, SwitchStmt, Ternary, UnaryOp,
+)
+from .errors import CompileError, Phase
+from .external_requests import FEED_LOWERING, LOWERING_ANNOTATION, _nodes
+from .pine_spelling import is_input_call, pine_string_literal
+from .security_contexts import _REGISTRATION_INPUTS, ScriptIndex, _reached, ticker_symbol_arg
+
+# A deferred refusal's lowering (``support_checker._lower_no_data_request``,
+# ``external_requests.unpin_requests``).
+_UNPINNED_LOWERING = "unpinned"
+# The chart's own timeframe where a fold meets ``timeframe.period``.
+_CHART = object()
+_UNKNOWN = object()
+# A folded value longer than any symbol or timeframe is no key.
+_MAX_VALUE_CHARS = 1024
+# Names a fold follows, one through another, and nodes it visits, before it
+# gives up (the value is then unknown).
+_MAX_FOLD_DEPTH = 256
+_MAX_FOLD_STEPS = 100_000
+
+
+class _Fold:
+    """One value's fold: each name expanded and folded once."""
+
+    def __init__(self, gen) -> None:
+        self.gen = gen
+        self.names: dict[str, object] = {}
+        self.steps = 0
+_PRECEDENCE = {"or": 1, "and": 2, "==": 3, "!=": 3, "<": 4, "<=": 4, ">": 4, ">=": 4,
+               "+": 5, "-": 5, "*": 6, "/": 6, "%": 6}
+
+
+def request_sites(program) -> list[FuncCall]:
+    """The ``request.security`` calls the support checker lowered onto
+    another symbol's feed or to a deferred refusal, outside the helpers
+    nothing reaches: taken before the passes that replace a refusal by its
+    ``na`` (``lower_no_data_requests``) or turn a feed back into one
+    (``unpin_requests``), which mark it so."""
+    sites = [node for node in _nodes(program)
+             if isinstance(node, FuncCall) and _call_name(node) == ("request", "security")
+             and (node.annotations or {}).get(LOWERING_ANNOTATION)
+             in (FEED_LOWERING, _UNPINNED_LOWERING)]
+    if not sites:
+        return sites
+    index = ScriptIndex(program)
+    reached = _reached(index)
+    return [site for site in sites
+            if (owner := index.owner.get(id(site))) not in index.funcs or owner in reached]
+
+
+def discover_requests(gen, ctx, sites: list[FuncCall]) -> list[dict]:
+    """The requests of another symbol's data (module docstring), by line,
+    each distinct entry once."""
+    entries: list[tuple[tuple, dict]] = []
+    calls = {call.sec_id: call for call in ctx.security_calls}
+    mutable_reads = set(gen._security_tf_mutable_reads)
+
+    def add(loc, entry: dict) -> None:
+        entry = {"line": loc.line if loc is not None else None, "fn": "request.security",
+                 **entry}
+        where = (loc.line or 0, loc.col or 0) if loc is not None else (0, 0)
+        entries.append(((*where, len(entries)), entry))
+
+    budget = getattr(gen, "_budget", None)
+    foreign = [info for info in gen._security_eval_info if info.get("foreign")]
+    helpers: set[str] = set()
+    unreached: set[str] = set()
+    if any(getattr(calls.get(info["sec_id"]), "containing_func", "") for info in foreign):
+        # A helper nothing reaches never runs: its registration is never read.
+        index = ScriptIndex(ctx.ast)
+        helpers = set(index.funcs)
+        unreached = helpers - _reached(index)
+    try:
+        for info in foreign:
+            helper = getattr(calls.get(info["sec_id"]), "containing_func", "")
+            if helper in helpers and helper in unreached:
+                continue
+            # Past the time budget the rest are listed as written, unexpanded:
+            # discovery never fails a script that transpiled.
+            expand = _within(budget)
+            entry = {
+                "symbol": _guarded(_symbol, gen, info["symbol_node"], expand=expand),
+                "timeframe": _guarded(_registered_timeframe, gen, info, expand=expand),
+                "lookahead": bool(info.get("lookahead_on")),
+                "gaps": bool(info.get("gaps_on")),
+                "ignore_invalid_symbol": _guarded(
+                    _flag, gen, info.get("ignore_invalid_node"), expand=expand),
+            }
+            column = gen._security_footprint_column(info["sec_id"])
+            if column:
+                entry["column"] = column
+            add(getattr(calls.get(info["sec_id"]), "loc", None), entry)
+        for site in sites:
+            if (site.annotations or {}).get(LOWERING_ANNOTATION) != _UNPINNED_LOWERING:
+                continue
+            # The C++ never registered it, so nothing expands its names here:
+            # its arguments are listed as written.
+            symbol, timeframe = _request_args(site)
+            gaps, lookahead = _gaps_lookahead(site)
+            ignore = site.kwargs.get("ignore_invalid_symbol")
+            add(site.loc, {
+                "symbol": {"kind": "unresolvable", "expr": _spell(symbol)},
+                "timeframe": _guarded(_timeframe, gen, timeframe, expand=False),
+                "lookahead": _barmerge(lookahead, "lookahead_on"),
+                "gaps": _barmerge(gaps, "gaps_on"),
+                "ignore_invalid_symbol": (
+                    False if ignore is None else
+                    ignore.value if isinstance(ignore, BoolLiteral) else None),
+            })
+    finally:
+        # Expanding a name registers a reassigned global's read with the
+        # first-bar replay; generation is over, so leave its record as it was.
+        gen._security_tf_mutable_reads = mutable_reads
+    out: list[dict] = []
+    for _, entry in sorted(entries, key=lambda item: item[0]):
+        if entry not in out:
+            out.append(entry)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Symbol and timeframe
+# ---------------------------------------------------------------------------
+
+def _within(budget) -> bool:
+    """Whether the transpile's time budget still holds."""
+    if budget is None:
+        return True
+    try:
+        budget.check(phase=Phase.CODEGEN)
+    except CompileError:
+        return False
+    return True
+
+
+def _guarded(classify, gen, node, **options):
+    """``classify(gen, node)``; a shape it does not know is listed as
+    computed, with no value: discovery never fails a script that
+    transpiled."""
+    try:
+        return classify(gen, node, **options)
+    except Exception:  # noqa: BLE001
+        if isinstance(node, dict):
+            node = node.get("tf_node")
+        return None if classify is _flag else {"kind": "computed", "expr": _spell(node)}
+
+
+def _symbol(gen, node, expand: bool = True) -> dict:
+    """``literal`` / ``input`` / ``computed`` as registration computes the
+    symbol string the run keys its feed on."""
+    resolved = _passthrough(_expand(gen, node) if expand else node)
+    if isinstance(resolved, StringLiteral):
+        return {"kind": "literal", "value": resolved.value}
+    if _is_registered_input(resolved):
+        return _input(gen, resolved)
+    if not expand:
+        return {"kind": "computed", "expr": _spell(node)}
+    return _computed(gen, node, resolved, timeframe=False)
+
+
+def _registered_timeframe(gen, info: dict, expand: bool = True) -> dict:
+    """The timeframe a feed site registers with (``_resolve_security_tf``'s
+    ``tf`` / ``tf_expr``, ``configure_security_evaluators``). ``input_tf_``
+    is the chart's: a run reading another symbol's feed takes the chart's
+    bars unaggregated (the engine refuses it otherwise)."""
+    tf, tf_expr = info.get("tf"), info.get("tf_expr")
+    if tf:
+        return {"kind": "literal", "value": canonical_timeframe(tf)}
+    if tf == "" or tf_expr in ("input_tf_", "script_tf_"):
+        return {"kind": "chart"}
+    return _timeframe(gen, info.get("tf_node"), expand=expand)
+
+
+def _timeframe(gen, node, expand: bool = True) -> dict:
+    """A timeframe registration expands (``expand``), or as written."""
+    if node is None:
+        return {"kind": "chart"}
+    resolved = _expand(gen, node) if expand else node
+    if isinstance(resolved, StringLiteral):
+        if resolved.value == "":
+            return {"kind": "chart"}
+        return {"kind": "literal", "value": canonical_timeframe(resolved.value)}
+    if _is_timeframe_period(resolved):
+        return {"kind": "chart"}
+    if _is_registered_input(resolved, timeframe=True):
+        return _input(gen, resolved)
+    if not expand:
+        return {"kind": "computed", "expr": _spell(node)}
+    return _computed(gen, node, resolved, timeframe=True)
+
+
+def canonical_timeframe(tf: str) -> str:
+    """The engine's spelling of a feed's timeframe
+    (``canonical_symbol_timeframe``): Pine's bare ``D`` / ``W`` / ``M`` /
+    ``S`` folded to ``1D`` / ``1W`` / ``1M`` / ``1S``, any other text kept
+    as it is (whole minutes ``"240"``, ``<n>D|W|M|S``; a feed matches no
+    other spelling)."""
+    return "1" + tf if tf in ("D", "W", "M", "S") else tf
+
+
+def _input(gen, call: FuncCall) -> dict:
+    default = _input_default(gen, call)
+    return {"kind": "input", "title": gen._get_input_title(call),
+            "default": None if default is _UNKNOWN else default}
+
+
+def _computed(gen, node, resolved, *, timeframe: bool) -> dict:
+    out = {"kind": "computed", "expr": _spell(node)}
+    value = _fold(_Fold(gen), resolved)
+    if value is _CHART and timeframe:
+        out["value"] = ""
+    elif isinstance(value, str):
+        out["value"] = canonical_timeframe(value) if timeframe and value else value
+    titles: list[str] = []
+    for call in _input_calls(gen, resolved):
+        title = gen._get_input_title(call)
+        if title not in titles:
+            titles.append(title)
+    if titles:
+        out["inputs"] = titles
+    return out
+
+
+def _flag(gen, node, expand: bool = True) -> bool | None:
+    """``ignore_invalid_symbol`` as registration reads it: false when left
+    out, else its value at the inputs' defaults (None when unknown)."""
+    if node is None:
+        return False
+    if not expand:
+        return node.value if isinstance(node, BoolLiteral) else None
+    value = _fold(_Fold(gen), _expand(gen, node))
+    return value if isinstance(value, bool) else None
+
+
+def _expand(gen, node):
+    """``node`` with its names expanded as registration expands them."""
+    return gen._substitute_tf_input_reads(node, set())
+
+
+def _passthrough(node):
+    """``ticker.inherit`` / ``ticker.standard`` render their symbol argument
+    unchanged (``visit_call``)."""
+    while (isinstance(node, FuncCall) and _call_name(node) in (
+            ("ticker", "inherit"), ("ticker", "standard"))):
+        symbol = ticker_symbol_arg(node)
+        if symbol is None:
+            break
+        node = symbol
+    return node
+
+
+def _is_registered_input(node, timeframe: bool = False) -> bool:
+    """An input whose value registration reads: ``input.symbol`` /
+    ``string`` (``timeframe`` for a timeframe), or ``input()`` of a string."""
+    if not is_input_call(node):
+        return False
+    ns, name = _call_name(node)
+    if ns is None:
+        default = node.args[0] if node.args else node.kwargs.get("defval")
+        return isinstance(default, StringLiteral)
+    return name in (_REGISTRATION_INPUTS - {"bool"}) or (timeframe and name == "timeframe")
+
+
+def _input_default(gen, call: FuncCall):
+    default = gen._get_input_default(call)
+    if isinstance(default, (StringLiteral, BoolLiteral, NumberLiteral)):
+        return default.value
+    return _UNKNOWN
+
+
+def _input_calls(gen, node) -> list[FuncCall]:
+    """The input calls ``node`` reads, through the names registration
+    expands (a ``switch``'s too), in source order."""
+    found: dict[int, FuncCall] = {}
+    seen: set[str] = set()
+    pending = [node]
+    while pending:
+        for item in _nodes(pending.pop()):
+            if is_input_call(item):
+                found.setdefault(id(item), item)
+            elif isinstance(item, Identifier) and item.name not in seen:
+                seen.add(item.name)
+                expanded = _expand(gen, item)
+                if expanded is not item:
+                    pending.append(expanded)
+    return sorted(found.values(), key=lambda call: (call.loc.line, call.loc.col)
+                  if call.loc is not None else (0, 0))
+
+
+def _fold(state: _Fold, node, depth: int = 0):
+    """The value at the inputs' defaults of an expression in
+    ``ScriptIndex.registration_value``'s grammar (and, for a timeframe, a
+    ``switch`` of single-expression arms, as registration renders it), else
+    ``_UNKNOWN``. The chart's own symbol strings are the chart's (unknown
+    here); ``timeframe.period`` is ``_CHART``."""
+    state.steps += 1
+    if depth > _MAX_FOLD_DEPTH or state.steps > _MAX_FOLD_STEPS:
+        return _UNKNOWN
+    depth += 1
+    if isinstance(node, (StringLiteral, BoolLiteral)):
+        return node.value
+    if isinstance(node, NumberLiteral):
+        return node.value
+    if _is_timeframe_period(node):
+        return _CHART
+    if isinstance(node, Identifier):
+        # A name registration expands (a switch's subject: the expansion
+        # leaves a switch as written); one it keeps has no value here.
+        if node.name not in state.names:
+            state.names[node.name] = _UNKNOWN  # a name read inside its own value
+            expanded = _expand(state.gen, node)
+            state.names[node.name] = (_UNKNOWN if expanded is node
+                                      else _fold(state, expanded, depth))
+        return state.names[node.name]
+    if isinstance(node, SwitchStmt):
+        return _fold_switch(state, node, depth)
+    if isinstance(node, FuncCall):
+        if is_input_call(node):
+            ns, name = _call_name(node)
+            if ns is None or name in _REGISTRATION_INPUTS or name == "timeframe":
+                return _input_default(state.gen, node)
+            return _UNKNOWN
+        passed = _passthrough(node)
+        return _UNKNOWN if passed is node else _fold(state, passed, depth)
+    if isinstance(node, Ternary):
+        condition = _fold(state, node.condition, depth)
+        if not isinstance(condition, bool):
+            return _UNKNOWN
+        return _fold(state, node.true_val if condition else node.false_val, depth)
+    if isinstance(node, UnaryOp):
+        operand = _fold(state, node.operand, depth)
+        return (not operand) if node.op == "not" and isinstance(operand, bool) else _UNKNOWN
+    if isinstance(node, BinOp) and node.op in ("+", "==", "!=", "and", "or"):
+        left = _fold(state, node.left, depth)
+        if left is _UNKNOWN or left is _CHART:
+            return _UNKNOWN
+        right = _fold(state, node.right, depth)
+        if right is _UNKNOWN or right is _CHART:
+            return _UNKNOWN
+        if node.op == "+":
+            if not (isinstance(left, str) and isinstance(right, str)
+                    and len(left) + len(right) <= _MAX_VALUE_CHARS):
+                return _UNKNOWN
+            return left + right
+        if node.op in ("and", "or"):
+            if not (isinstance(left, bool) and isinstance(right, bool)):
+                return _UNKNOWN
+            return (left and right) if node.op == "and" else (left or right)
+        if type(left) is not type(right):
+            return _UNKNOWN
+        return (left == right) if node.op == "==" else (left != right)
+    return _UNKNOWN
+
+
+def _fold_switch(state: _Fold, node: SwitchStmt, depth: int):
+    """A timeframe ``switch`` as registration renders it
+    (``_security_tf_switch_runtime_expr``): the first arm whose value equals
+    the subject (or whose condition holds), else the default arm, else the
+    chart's timeframe; every arm one expression."""
+    subject = None
+    if node.expr is not None:
+        subject = _fold(state, node.expr, depth)
+        if subject is _UNKNOWN or subject is _CHART:
+            return _UNKNOWN
+
+    def arm(body):
+        if len(body) != 1 or not isinstance(body[0], ExprStmt) or isinstance(
+                body[0].expr, NaLiteral):
+            return _UNKNOWN
+        return _fold(state, body[0].expr, depth)
+
+    default = node.default_body or None
+    for condition, body in node.cases:
+        if condition is None:
+            default = default or body
+            continue
+        value = _fold(state, condition, depth)
+        if value is _UNKNOWN or value is _CHART:
+            return _UNKNOWN
+        if (value is True if node.expr is None
+                else type(value) is type(subject) and value == subject):
+            return arm(body)
+    return arm(default) if default else _CHART
+
+
+# ---------------------------------------------------------------------------
+# Call shapes and spelling
+# ---------------------------------------------------------------------------
+
+def _call_name(node: FuncCall) -> tuple[str | None, str | None]:
+    callee = node.callee
+    if isinstance(callee, Identifier):
+        return None, callee.name
+    if isinstance(callee, MemberAccess) and isinstance(callee.object, Identifier):
+        return callee.object.name, callee.member
+    return None, None
+
+
+def _is_timeframe_period(node) -> bool:
+    """``timeframe.period`` or ``timeframe.main_period``: the chart's."""
+    return (isinstance(node, MemberAccess) and node.member in ("period", "main_period")
+            and isinstance(node.object, Identifier) and node.object.name == "timeframe")
+
+
+def _request_args(node: FuncCall):
+    symbol = node.args[0] if node.args else node.kwargs.get("symbol")
+    timeframe = node.args[1] if len(node.args) > 1 else node.kwargs.get("timeframe")
+    return symbol, timeframe
+
+
+def _gaps_lookahead(node: FuncCall):
+    gaps = node.kwargs.get("gaps")
+    if gaps is None and len(node.args) > 3:
+        gaps = node.args[3]
+    lookahead = node.kwargs.get("lookahead")
+    if lookahead is None and len(node.args) > 4:
+        lookahead = node.args[4]
+    return gaps, lookahead
+
+
+def _barmerge(node, on: str) -> bool | None:
+    """A ``barmerge.*`` constant's flag; left out is off; None when computed."""
+    if node is None:
+        return False
+    if (isinstance(node, MemberAccess) and isinstance(node.object, Identifier)
+            and node.object.name == "barmerge"):
+        return node.member == on
+    return None
+
+
+def _spell(node, parent: int = 0, right: bool = False) -> str:
+    """``node`` spelled as Pine source (display only)."""
+    if node is None:
+        return ""
+    if isinstance(node, StringLiteral):
+        return pine_string_literal(node.value)
+    if isinstance(node, BoolLiteral):
+        return "true" if node.value else "false"
+    if isinstance(node, NumberLiteral):
+        return str(node.value)
+    if isinstance(node, NaLiteral):
+        return "na"
+    if isinstance(node, Identifier):
+        return node.name
+    if isinstance(node, MemberAccess):
+        return f"{_spell(node.object, 9)}.{node.member}"
+    if isinstance(node, FuncCall):
+        args = [_spell(a) for a in node.args]
+        args += [f"{key} = {_spell(value)}" for key, value in node.kwargs.items()]
+        return f"{_spell(node.callee, 9)}({', '.join(args)})"
+    if isinstance(node, Subscript):
+        return f"{_spell(node.object, 9)}[{_spell(node.index)}]"
+    if isinstance(node, UnaryOp):
+        text = f"not {_spell(node.operand, 7)}" if node.op == "not" else (
+            f"{node.op}{_spell(node.operand, 7)}")
+        return f"({text})" if parent > 7 else text
+    if isinstance(node, BinOp):
+        level = _PRECEDENCE.get(node.op, 5)
+        text = (f"{_spell(node.left, level)} {node.op} "
+                f"{_spell(node.right, level, right=True)}")
+        return f"({text})" if level < parent or (right and level == parent) else text
+    if isinstance(node, Ternary):
+        text = (f"{_spell(node.condition, 1)} ? {_spell(node.true_val)} : "
+                f"{_spell(node.false_val)}")
+        return f"({text})" if parent else text
+    return "..."

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "1.0.1",
+  "codegen": "1.2.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "2ad9a8595850ce2c485dcddb049fd738097d9149d2136ce83a951a506541a113"
+  "sha256": "7c9654f79d188babd5034d3ebedd2cdd60a8ec2866b70d8ad863a9f06341420e"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "1.0.1",
+  "CODEGEN_VERSION": "1.2.0",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",

package/transpile.worker.mjs

@@ -32,6 +32,10 @@ def _diagnostic_entries(diagnostics) -> list:
             "col": loc.col if loc else 1,
             "message": message,
             "severity": getattr(d.level, "value", "error"),
+            # The stable code and named arguments of the catalog templates the
+            # message (and the hint after " — ") render from.
+            "code": d.code,
+            "args": d.args,
         }
         end_col = getattr(loc, "end_col", None) if loc else None
         if end_col is not None:
@@ -49,7 +53,8 @@ def transpile_json(source: str) -> str:
     # A script that transpiled carries its warnings in the same entry format.
     return json.dumps({"ok": True, "cpp": full["cpp"], "inputs": full["inputs"],
                        "strategyParams": full["strategyParams"],
-                       "diagnostics": _diagnostic_entries(full["diagnostics"])})
+                       "diagnostics": _diagnostic_entries(full["diagnostics"]),
+                       "requests": full["requests"]})
 `;
 
 const post = (m) => self.postMessage(m);