@pineforge/codegen-pyodide 1.1.0 → 1.3.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,6 +868,7 @@ 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 {}),

package/pineforge_codegen/support_checker.py

@@ -2843,8 +2843,9 @@ class SupportChecker:
             # Bare suffix shorthand — Pine treats "D"/"W"/"M"/"S" as 1<suffix>.
             # Accept the same shorthand here.
             return None
-        if not digits.isdigit():
-            # catches "1.5", "-15", "abc", etc.
+        if not digits.isdecimal():
+            # catches "1.5", "-15", "abc", and digits int() does not read
+            # ("²"), etc.
             return f"non-integer timeframe magnitude '{digits}'"
         n = int(digits)
         if n <= 0:
@@ -2859,15 +2860,11 @@ class SupportChecker:
             return
         if not isinstance(tf_node, StringLiteral):
             return
-        err = self._validate_pine_tf_literal(tf_node.value)
-        if err is None:
+        refusal = invalid_tf_literal(tf_node.value, fn_label)
+        if refusal is None:
             return
-        self._err(
-            tf_node,
-            f"{fn_label}: invalid timeframe literal '{tf_node.value}'. "
-            "Expected Pine TF format like '1', '15', '1H', '1D', '15S'.",
-            hint=err,
-        )
+        message, hint = refusal
+        self._err(tf_node, message, hint=hint)
 
     def _check_request_security_lower_tf_symbol(self, node: FuncCall) -> None:
         """``request.security_lower_tf`` reads the chart's intrabars: the
@@ -2912,6 +2909,18 @@ class SupportChecker:
         self._check_tf_literal(tf_node, "request.security_lower_tf")
 
 
+def invalid_tf_literal(tf_str: str, fn_label: str) -> tuple[str, str] | None:
+    """``(message, hint)`` refusing ``tf_str`` as the timeframe of
+    ``fn_label`` (``request.security`` / ``request.security_lower_tf``), or
+    None when it is a Pine timeframe. The codegen refuses a timeframe string
+    it resolves from a constant or a helper parameter with the same text."""
+    err = SupportChecker._validate_pine_tf_literal(tf_str)
+    if err is None:
+        return None
+    return (f"{fn_label}: invalid timeframe literal '{tf_str}'. "
+            "Expected Pine TF format like '1', '15', '1H', '1D', '15S'.", err)
+
+
 # ---------------------------------------------------------------------------
 # Convenience entry point
 # ---------------------------------------------------------------------------

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "1.1.0",
+  "codegen": "1.3.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "37b1ca85a2006f6f07d52074a7180187536047bfbb857681978a372b1d7f9bef"
+  "sha256": "b058ef7c8ded42e7a80ccf551e62985e052d1e306aebf615ab9937544f060839"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "1.1.0",
+  "CODEGEN_VERSION": "1.3.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: