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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.7.4
+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.4 → 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.4 → 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.4 → 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.4/VERSION

@@ -1 +0,0 @@
-0.7.4