pineforge-codegen 0.7.3__tar.gz → 0.7.5__tar.gz

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.7.3
+Version: 0.7.5
 Summary: PineScript v6 to C++ transpiler that targets the pineforge-engine runtime.
 Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-codegen-oss
 Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-codegen-oss/issues

pineforge_codegen-0.7.5/VERSION

@@ -0,0 +1 @@
+0.7.5

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/gate/glue.py

@@ -9,13 +9,13 @@ import sys
 if "/codegen" not in sys.path:
     sys.path.insert(0, "/codegen")
 
-from pineforge_codegen import transpile
+from pineforge_codegen import transpile_full
 from pineforge_codegen.errors import CompileError
 
 
 def transpile_json(source: str) -> str:
     try:
-        cpp = transpile(source)
+        full = transpile_full(source)
     except CompileError as e:
         diags = []
         for d in e.diagnostics:
@@ -32,4 +32,4 @@ def transpile_json(source: str) -> str:
                 entry["endCol"] = end_col
             diags.append(entry)
         return json.dumps({"ok": False, "error": str(e), "diagnostics": diags})
-    return json.dumps({"ok": True, "cpp": cpp})
+    return json.dumps({"ok": True, "cpp": full["cpp"], "inputs": full["inputs"], "strategyParams": full["strategyParams"]})

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/pineforge_codegen/__init__.py

@@ -51,3 +51,42 @@ def transpile(pine_source: str, *, check_support: bool = True, filename: str = "
     # ``if (trace_enabled_) { trace(...); ... }`` block.
     ctx.pf_trace_pragmas = pragmas
     return CodeGen(ctx).generate()
+
+
+def transpile_full(pine_source: str, *, check_support: bool = True,
+                   filename: str = "<input>") -> dict:
+    """Transpile like :func:`transpile`, plus the host-UI input manifest.
+
+    Runs ONE pipeline pass (Lexer -> Parser -> support check -> Analyzer ->
+    CodeGen.generate) and returns the generated C++ alongside the data the
+    cloud Studio needs to auto-build a backtest "override params" form:
+
+    - ``cpp``: the generated C++ source (identical to :func:`transpile`).
+    - ``inputs``: a list of ``InputDef`` dicts (one per top-level
+      ``var = input.*(...)`` declaration). Each has ``title`` / ``type`` /
+      ``default`` and optionally ``min`` / ``max`` / ``step`` / ``options``
+      (omitted when the corresponding signature argument is absent or
+      references a non-const value). See
+      :meth:`CodeGen.extract_input_manifest`.
+    - ``strategyParams``: the literal ``strategy(...)`` kwargs the analyzer
+      surfaced (e.g. ``initial_capital``, ``pyramiding``).
+
+    Args mirror :func:`transpile`.
+
+    Returns:
+        ``{"cpp": str, "inputs": list[dict], "strategyParams": dict}``.
+    """
+    pragmas = extract_pf_trace_pragmas(pine_source)
+    tokens = Lexer(pine_source, filename=filename).tokenize()
+    ast = Parser(tokens, source=pine_source, filename=filename).parse()
+    if check_support:
+        check_support_or_raise(ast, filename=filename)
+    ctx = Analyzer(ast, filename=filename).analyze()
+    ctx.pf_trace_pragmas = pragmas
+    gen = CodeGen(ctx)
+    cpp = gen.generate()
+    return {
+        "cpp": cpp,
+        "inputs": gen.extract_input_manifest(),
+        "strategyParams": dict(ctx.strategy_params),
+    }

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/pineforge_codegen/codegen/emit_top.py

@@ -611,17 +611,27 @@ class TopLevelEmitter:
             lines.append("                   static_cast<MagnifierDistribution>(magnifier_dist));")
         else:
             # The magnifier-aware run() overload handles ratio=1 (no
-            # aggregation) and empty itf/stf (auto-detect) on its own, so
-            # we only need to fall back to the simple ``run(bars, n)``
-            # path when the caller explicitly opted out of magnifier AND
-            # there is no timeframe aggregation in play. Previously the
-            # short-circuit ``itf.empty() || stf.empty() || itf == stf``
-            # silently dropped the bar_magnifier flag whenever the host
-            # passed empty TFs (the validator's default) — turning every
-            # magnifier-opt-in run into a non-magnifier run and producing
-            # 0.21% exit-price drift on the magnifier-distribution probes.
+            # aggregation), empty itf (auto-detect from bar timestamps),
+            # and empty stf (default-to-input) entirely on its own, so we
+            # route through it whenever ANY TF/magnifier knob is set. We
+            # only fall back to the simple ``run(bars, n)`` path when the
+            # caller passed NO magnifier AND NO timeframe at all.
+            #
+            # The previous guard ``(!itf.empty() && !stf.empty() && itf != stf)``
+            # required BOTH timeframes to be present before aggregating.
+            # The cloud caller passes ``input_tf=""`` (auto-detect) with a
+            # concrete ``script_tf="240"``; that made the guard false and
+            # the chosen ``script_tf`` was silently ignored — the strategy
+            # ran on raw 1m bars with no aggregation. It also dropped the
+            # bar_magnifier flag whenever the host passed empty TFs,
+            # producing 0.21% exit-price drift on the magnifier probes.
+            #
+            # Over-approximating to ``!itf.empty() || !stf.empty()`` is
+            # always correct: the TF-aware overload is a no-op when the
+            # ratio resolves to 1, so the only thing lost in that case is
+            # the precalc optimization — never correctness.
             lines.append("        bool needs_full_run = (bar_magnifier != 0)")
-            lines.append("            || (!itf.empty() && !stf.empty() && itf != stf);")
+            lines.append("            || !itf.empty() || !stf.empty();")
             lines.append("        if (!needs_full_run) {")
             lines.append("            strat->run(bars, n);")
             lines.append("        } else {")
@@ -865,7 +875,7 @@ class TopLevelEmitter:
         lines.append("             bool bar_magnifier = false,")
         lines.append("             int magnifier_samples = 4,")
         lines.append("             MagnifierDistribution magnifier_dist = MagnifierDistribution::ENDPOINTS) {")
-        lines.append("        bool needs_dynamic = bar_magnifier || (!input_tf.empty() && !script_tf.empty() && input_tf != script_tf);")
+        lines.append("        bool needs_dynamic = bar_magnifier || !input_tf.empty() || !script_tf.empty();")
         lines.append("        if (needs_dynamic) {")
         lines.append("            _use_precalc = false;")
         lines.append("        } else {")

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/pineforge_codegen/codegen/input.py

@@ -15,13 +15,32 @@ Mixin contract — host class must provide:
 
 from __future__ import annotations
 
-from ..ast_nodes import FuncCall, Identifier, MemberAccess, StringLiteral
+from ..ast_nodes import (
+    BoolLiteral,
+    FuncCall,
+    Identifier,
+    MemberAccess,
+    NumberLiteral,
+    StringLiteral,
+    VarDecl,
+)
 from .. import signatures as sigs
 
 
 class InputHelper:
     """``input.*`` call analysis helpers — defaults, titles, getter dispatch, enum guard."""
 
+    # Maps the input function short-name -> the form-facing type tag emitted in
+    # the input manifest (consumed by the host UI's override form). ``price``
+    # is a float slider, ``time`` an int timestamp; everything string-like
+    # collapses to "string".
+    _FORM_TYPE = {
+        "int": "int", "float": "float", "bool": "bool", "string": "string",
+        "source": "source", "enum": "enum", "price": "float", "time": "int",
+        "color": "string", "timeframe": "string", "session": "string",
+        "symbol": "string", "text_area": "string",
+    }
+
     def _is_input_call(self, node: FuncCall) -> bool:
         """True if ``node`` is an ``input(...)`` or ``input.<type>(...)`` call."""
         func_name, namespace = self._resolve_callee(node.callee)
@@ -187,3 +206,125 @@ class InputHelper:
                 f"{ename}.{dv.member} is not a member of enum {ename} "
                 "(internal: Analyzer should reject this first)"
             )
+
+    # ------------------------------------------------------------------
+    # Input manifest extraction (host UI override-form source of truth)
+    # ------------------------------------------------------------------
+
+    def _literal_or_none(self, node):
+        """Return a JSON scalar for a *const* literal AST node, else None.
+
+        ``None`` signals non-const (an identifier, computed expression, …) so
+        callers can omit a bound/option that references a runtime value.
+        Enum member refs (``Dir.Up``) collapse to the ``"Dir.Up"`` string tag.
+        """
+        if isinstance(node, StringLiteral):
+            return node.value
+        # BoolLiteral must be checked before NumberLiteral: a Pine ``true`` is a
+        # BoolLiteral (not a NumberLiteral), but guarding the order keeps intent
+        # explicit and future-proof against bool/int node overlap.
+        if isinstance(node, BoolLiteral):
+            return node.value
+        if isinstance(node, NumberLiteral):
+            return node.value
+        # enum member ref like ``Dir.Up`` -> "Dir.Up" (string tag)
+        if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
+            return f"{node.object.name}.{node.member}"
+        return None
+
+    def _merged_args(self, node: FuncCall, func_name, namespace):
+        """Merge positional args + kwargs into signature-positional order.
+
+        Returns ``(param_names | None, merged_list)``. Mirrors the merge logic
+        in :meth:`_get_input_title` / :meth:`_get_input_default` so manifest
+        extraction reads bounds/options off the same positions codegen does.
+        """
+        if namespace == "input" and func_name in sigs.INPUT_FUNCTIONS:
+            names = sigs.get_param_names("input", func_name)
+        elif func_name == "input" and namespace is None:
+            names = sigs.get_param_names(None, "input")
+        else:
+            names = None
+        merged = list(node.args)
+        if names:
+            for i, pname in enumerate(names):
+                if pname in node.kwargs:
+                    while len(merged) <= i:
+                        merged.append(None)
+                    if merged[i] is None:
+                        merged[i] = node.kwargs[pname]
+        return names, merged
+
+    def extract_input_manifest(self) -> list[dict]:
+        """Walk top-level ``var = input.*(...)`` decls into an InputDef list.
+
+        Each entry: ``{title, type, default[, min, max, step, options]}``. The
+        optional keys are emitted only when the corresponding signature
+        argument is a const literal; a bound/option referencing a non-literal
+        is omitted (never crashes). One pass over ``self.ctx.ast.body``.
+        """
+        out: list[dict] = []
+        for stmt in self.ctx.ast.body:
+            if not (
+                isinstance(stmt, VarDecl)
+                and isinstance(stmt.value, FuncCall)
+                and self._is_input_call(stmt.value)
+            ):
+                continue
+            node = stmt.value
+            func_name, namespace = self._resolve_callee(node.callee)
+            names, merged = self._merged_args(node, func_name, namespace)
+            title = self._get_input_title(node, var_name=stmt.name)
+            default_node = self._get_input_default(node)
+            default_val = (
+                self._literal_or_none(default_node)
+                if default_node is not None
+                else None
+            )
+            if namespace == "input":
+                form_type = self._FORM_TYPE.get(func_name, "string")
+            else:
+                # Plain ``input(...)``: Pine types the result by its defval.
+                # The codegen already emits the matching scalar getter, so the
+                # manifest must mirror that — infer from the resolved default's
+                # Python type. ``bool`` MUST be tested before ``int`` because
+                # ``isinstance(True, int)`` is True. A None/non-literal default
+                # falls back to "string".
+                if isinstance(default_val, bool):
+                    form_type = "bool"
+                elif isinstance(default_val, int):
+                    form_type = "int"
+                elif isinstance(default_val, float):
+                    form_type = "float"
+                elif isinstance(default_val, str):
+                    form_type = "string"
+                else:
+                    form_type = "string"
+            entry: dict = {
+                "title": title,
+                "type": form_type,
+                "default": default_val,
+            }
+            # Pull min/max/step/options by signature param name; emit only
+            # const literals so the override form never references a runtime
+            # value it can't reproduce.
+            if names:
+                idx = {n: i for i, n in enumerate(names)}
+                for key, pname in (("min", "minval"), ("max", "maxval"), ("step", "step")):
+                    i = idx.get(pname)
+                    if i is not None and i < len(merged) and merged[i] is not None:
+                        v = self._literal_or_none(merged[i])
+                        # bool is an int subclass — exclude it from numeric bounds
+                        if isinstance(v, (int, float)) and not isinstance(v, bool):
+                            entry[key] = v
+                oi = idx.get("options")
+                if oi is not None and oi < len(merged) and merged[oi] is not None:
+                    opts_node = merged[oi]
+                    elems = getattr(opts_node, "elements", None)
+                    if elems is not None:
+                        vals = [self._literal_or_none(e) for e in elems]
+                        # any non-const element -> omit the whole options list
+                        if vals and all(isinstance(v, str) for v in vals):
+                            entry["options"] = vals
+            out.append(entry)
+        return out

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/tests/golden/matrix_eigen_pca.cpp

@@ -233,7 +233,7 @@ public:
              bool bar_magnifier = false,
              int magnifier_samples = 4,
              MagnifierDistribution magnifier_dist = MagnifierDistribution::ENDPOINTS) {
-        bool needs_dynamic = bar_magnifier || (!input_tf.empty() && !script_tf.empty() && input_tf != script_tf);
+        bool needs_dynamic = bar_magnifier || !input_tf.empty() || !script_tf.empty();
         if (needs_dynamic) {
             _use_precalc = false;
         } else {
@@ -262,7 +262,7 @@ extern "C" {
         std::string itf = input_tf ? input_tf : "";
         std::string stf = script_tf ? script_tf : "";
         bool needs_full_run = (bar_magnifier != 0)
-            || (!itf.empty() && !stf.empty() && itf != stf);
+            || !itf.empty() || !stf.empty();
         if (!needs_full_run) {
             strat->run(bars, n);
         } else {

{pineforge_codegen-0.7.3 → pineforge_codegen-0.7.5}/tests/test_codegen_new.py

@@ -43,6 +43,40 @@ strategy("Test")
     assert "run_backtest" in cpp  # backward compat
 
 
+def test_run_backtest_full_routes_to_tf_aware_run_when_only_script_tf_set():
+    """Regression: a chosen script_tf must not be silently ignored.
+
+    The cloud caller passes ``input_tf=""`` (auto-detect) with a concrete
+    ``script_tf`` (e.g. "240"). The old ``run_backtest_full`` guard required
+    BOTH timeframes present (``!itf.empty() && !stf.empty() && itf != stf``),
+    so an empty input_tf made ``needs_full_run`` false and the strategy ran
+    on raw 1m bars — the chosen script_tf was dropped and no aggregation
+    happened. The fix over-approximates: route through the TF-aware overload
+    whenever ANY TF/magnifier knob is set.
+
+    This pins the emitted guard so the regression cannot silently return.
+    ``run_backtest_full`` is emitted for every strategy (no security calls
+    needed), so a bare strategy exercises the shim guard. The precalc-gating
+    ``run(...)`` overload is only emitted when there is a static TA call
+    site (``ta.sma`` here), so the body uses one to cover both guards.
+    """
+    cpp = _generate('//@version=6\nstrategy("T")\nx = ta.sma(close, 14)\nplot(x)\n')
+
+    # The C ABI shim guard must fire on a non-empty script_tf alone.
+    assert "bool needs_full_run = (bar_magnifier != 0)" in cpp
+    assert "|| !itf.empty() || !stf.empty();" in cpp
+    # The old AND-of-both-TFs guard must be gone.
+    assert "!itf.empty() && !stf.empty() && itf != stf" not in cpp
+
+    # The run(...) overload that gates precalc must also route dynamically
+    # whenever either TF is set (not only when both differ).
+    assert (
+        "bool needs_dynamic = bar_magnifier || !input_tf.empty() || !script_tf.empty();"
+        in cpp
+    )
+    assert "!input_tf.empty() && !script_tf.empty() && input_tf != script_tf" not in cpp
+
+
 # === Task 9: Basic structure and translations ===
 
 

pineforge_codegen-0.7.5/tests/test_extract_inputs.py

@@ -0,0 +1,107 @@
+from pineforge_codegen import transpile_full
+
+PREAMBLE = "//@version=6\nstrategy(\"T\")\n"
+
+
+def _full(body: str):
+    return transpile_full(PREAMBLE + body)
+
+
+def test_int_input_manifest():
+    r = _full("length = input.int(14, \"Length\", minval=2, maxval=200, step=2)\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Length")
+    assert inp["type"] == "int"
+    assert inp["default"] == 14
+    assert inp["min"] == 2
+    assert inp["max"] == 200
+    assert inp["step"] == 2
+
+
+def test_float_omits_absent_bounds():
+    r = _full("mult = input.float(2.0, \"Mult\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Mult")
+    assert inp["type"] == "float"
+    assert inp["default"] == 2.0
+    assert "min" not in inp and "max" not in inp
+
+
+def test_bool_and_title_fallback_to_var_name():
+    r = _full("use_x = input.bool(true)\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "use_x")
+    assert inp["type"] == "bool"
+    assert inp["default"] is True
+
+
+def test_string_options():
+    r = _full("mode = input.string(\"a\", \"Mode\", options=[\"a\", \"b\", \"c\"])\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Mode")
+    assert inp["type"] == "string"
+    assert inp["options"] == ["a", "b", "c"]
+
+
+def test_non_const_options_omitted():
+    # options referencing a non-literal must be omitted, not crash
+    r = _full("v = \"x\"\nmode = input.string(\"a\", \"Mode\", options=[v, \"b\"])\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Mode")
+    assert "options" not in inp
+
+
+def test_source_type():
+    r = _full("src = input.source(close, \"Source\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Source")
+    assert inp["type"] == "source"
+
+
+def test_plain_input_int_form_type():
+    r = _full("len = input(10, \"Xi\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Xi")
+    assert inp["type"] == "int"
+    assert inp["default"] == 10
+
+
+def test_plain_input_float_form_type():
+    r = _full("f = input(1.5, \"Xf\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Xf")
+    assert inp["type"] == "float"
+    assert inp["default"] == 1.5
+
+
+def test_plain_input_bool_form_type():
+    r = _full("b = input(true, \"Xb\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Xb")
+    assert inp["type"] == "bool"
+    assert inp["default"] is True
+
+
+def test_plain_input_string_form_type():
+    r = _full("s = input(\"a\", \"Xs\")\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Xs")
+    assert inp["type"] == "string"
+    assert inp["default"] == "a"
+
+
+def test_non_const_minval_bound_omitted():
+    # minval bound referencing a prior const-assigned identifier is non-literal
+    # at the call site -> "min" omitted, no crash, other facets unaffected.
+    r = _full("somevar = 2\nlen = input.int(14, \"Len\", minval=somevar, maxval=200, step=2)\n")
+    inp = next(i for i in r["inputs"] if i["title"] == "Len")
+    assert inp["default"] == 14
+    assert "min" not in inp
+    assert inp["max"] == 200
+    assert inp["step"] == 2
+
+
+def test_zero_inputs():
+    r = _full("a = close + 1\n")
+    assert r["inputs"] == []
+
+
+def test_strategy_params_surfaced():
+    r = transpile_full("//@version=6\nstrategy(\"T\", initial_capital=5000, pyramiding=2)\na = close\n")
+    assert r["strategyParams"]["initial_capital"] == 5000
+    assert r["strategyParams"]["pyramiding"] == 2
+
+
+def test_cpp_still_returned():
+    r = _full("length = input.int(14, \"Length\")\n")
+    assert 'get_input_int("Length", 14)' in r["cpp"]

pineforge_codegen-0.7.5/tests/test_glue_smoke.py

@@ -0,0 +1,43 @@
+"""Glue contract smoke test for gate/glue.py.
+
+Loads gate/glue.py directly (it carries a `sys.path.insert(0, "/codegen")`
+preamble; `pineforge_codegen` still resolves because the repo root is on
+sys.path when pytest runs from there) and asserts the transpile_json envelope:
+
+- valid source -> ok:true with inputs[] and strategyParams (the new manifest)
+- invalid source -> ok:false with a diagnostics key (error branch untouched)
+"""
+import importlib.util
+import json
+import os
+
+_REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_GLUE_PATH = os.path.join(_REPO_ROOT, "gate", "glue.py")
+
+
+def _load_glue():
+    spec = importlib.util.spec_from_file_location("pineforge_glue_under_test", _GLUE_PATH)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_valid_source_emits_manifest():
+    glue = _load_glue()
+    src = (
+        "//@version=6\n"
+        'strategy("T", initial_capital=5000)\n'
+        'length = input.int(14, "Length")\n'
+        "plot(close)\n"
+    )
+    d = json.loads(glue.transpile_json(src))
+    assert d["ok"] is True
+    assert any(i["title"] == "Length" for i in d["inputs"])
+    assert d["strategyParams"]["initial_capital"] == 5000
+
+
+def test_invalid_source_still_returns_error_envelope():
+    glue = _load_glue()
+    d = json.loads(glue.transpile_json("strategy("))
+    assert d["ok"] is False
+    assert "diagnostics" in d

pineforge_codegen-0.7.3/VERSION

@@ -1 +0,0 @@
-0.7.3