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

{pineforge_codegen-0.7.4 → pineforge_codegen-0.7.6}/.github/workflows/release.yml

@@ -40,12 +40,24 @@ jobs:
       OVERRIDE:      ${{ inputs.override }}
       PYTHONHASHSEED: "0"   # deterministic gate runtime (match gate.yml)
     steps:
+      # Org GitHub App token (no PAT — never expires). Authorizes BOTH the
+      # release commit/tag push to protected main (the App is a bypass actor on
+      # the org ruleset) AND the downstream hub dispatch. Scoped to this repo +
+      # the hub. Minted first so checkout can push with it.
+      - name: Mint org App token
+        id: app
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.PINEFORGE_APP_ID }}
+          private-key: ${{ secrets.PINEFORGE_APP_PRIVATE_KEY }}
+          owner: pineforge-4pass
+          repositories: pineforge-codegen-oss,pineforge-release
+
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
         with:
           fetch-depth: 0
-          # PAT (RELEASE_PAT) needed if a branch ruleset on `main` blocks
-          # GITHUB_TOKEN pushes. Falls back to GITHUB_TOKEN if unset.
-          token: ${{ secrets.RELEASE_PAT || secrets.GITHUB_TOKEN }}
+          # App token bypasses the main ruleset for the release commit/tag push.
+          token: ${{ steps.app.outputs.token }}
 
       - name: Compute new version
         id: ver
@@ -132,8 +144,8 @@ jobs:
       - name: Create GitHub Release
         if: ${{ !inputs.dry_run }}
         env:
-          # Org disables write for the default Actions token; use the admin PAT.
-          GH_TOKEN:    ${{ secrets.RELEASE_PAT }}
+          # Org disables write for the default Actions token; use the App token.
+          GH_TOKEN:    ${{ steps.app.outputs.token }}
           NEW_VERSION: ${{ steps.ver.outputs.new }}
         run: |
           gh release create "v${NEW_VERSION}" \
@@ -141,3 +153,22 @@ jobs:
             --generate-notes \
             --notes "Install: \`pip install pineforge-codegen==${NEW_VERSION}\`" \
             dist/*
+
+      # Notify the pineforge-release hub: it bumps its CODEGEN_VERSION pin,
+      # rebuilds the combined image, and fans out to the MCPs. FAIL LOUD (no
+      # continue-on-error) — a dropped notify means downstream never picks up the
+      # new codegen. Uses the App token minted above (no PAT). Runs AFTER the
+      # PyPI publish so the version is installable.
+      - name: Dispatch codegen-release -> pineforge-release
+        if: ${{ !inputs.dry_run }}
+        env:
+          GH_TOKEN:    ${{ steps.app.outputs.token }}
+          NEW_VERSION: ${{ steps.ver.outputs.new }}
+          RUN_ID:      ${{ github.run_id }}
+        run: |
+          set -euo pipefail
+          gh api repos/pineforge-4pass/pineforge-release/dispatches \
+            -f event_type=codegen-release \
+            -F "client_payload[version]=${NEW_VERSION}" \
+            -F "client_payload[run_id]=${RUN_ID}"
+          echo "dispatched codegen-release -> pineforge-release (${NEW_VERSION})"

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

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

@@ -0,0 +1 @@
+0.7.6

{pineforge_codegen-0.7.4 → pineforge_codegen-0.7.6}/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.6}/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.6}/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