bruedemo 0.1.0__tar.gz

bruedemo-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+conformance/out/

bruedemo-0.1.0/ARCHITECTURE.md

@@ -0,0 +1,83 @@
+# Brue's job: the decision layer
+
+One sentence: given bars, Brue decides what a strategy does, and it makes
+those decisions identically everywhere. Everything else in a trading
+pipeline belongs to something else.
+
+```
+  DATA             ->      BRUE          ->     EXECUTION          ->  RESULTS
+  pandas / feeds /      the strategy         backtest: simulated       stats, trade
+  broker bars / csv     brain                fills inside Brue         ledger, equity
+                                             live: order intents  ->   broker adapter
+                                                                       (user's account)
+```
+
+## What Brue OWNS
+
+1. **Indicators.** ema, rsi, atr and the rest of the 143 builtins, computed
+   with fixed, conformance-locked semantics. Same inputs, same bits, on
+   every implementation.
+2. **Strategy logic.** Entries, exits, conditions, long/short. The part a
+   trader actually thinks about, written in a language built for exactly
+   that.
+3. **Position rules.** Sizing (including risk-based sizing off stop
+   distance), stops, targets, trailing stops, commission.
+4. **In backtest mode: the simulator.** Next-bar-open fills (an order
+   placed on the signal bar fills at the NEXT bar's open, never the signal
+   bar), bracket handling, and the full stats block. This is where "same
+   script, same numbers" is enforced.
+5. **In live mode: signals only.** The same logic evaluates on each new
+   bar and emits order INTENTS ("enter long, 2% risk, stop here"). Brue
+   never sends the order itself.
+
+## What Brue deliberately does NOT do
+
+- It never fetches data. Bars come in from the host (pandas frame, csv,
+  a feed, a broker terminal).
+- It never holds broker credentials.
+- It never talks to a broker. Executing an intent is the host's job,
+  through whatever adapter the user connects with their own account.
+- It never touches the filesystem or network from inside a script. A
+  strategy is pure logic over bars, which is what makes it safe to run in
+  a sandbox, in a browser, or on someone else's machine.
+
+That boundary is the product: the strategy is a portable artifact. The
+same script runs in the site editor, the cloud notebook, the desktop
+terminal, a Python session via `brue.backtest(script, df)`, and (once the
+live driver ships) against any connected broker, and every one of those
+produces bit-identical decisions because they are all the same
+conformance-tested engine. The pipe around the strategy is swappable; the
+strategy is yours.
+
+## How the pieces line up in Python
+
+```python
+import pandas as pd            # data: pandas' job
+import brue                    # decisions: Brue's job
+
+df = pd.read_csv("EURJPY_1h.csv")
+result = brue.backtest(SCRIPT, df, extended_stats=True)
+result.stats                   # dict of the canonical stats block
+result.trades_frame()          # trade ledger as a DataFrame
+result.equity_frame()          # per-bar equity with timestamps
+```
+
+The engine core under this API is a 1:1 port verified byte-for-byte
+against the reference implementation over the full conformance corpus
+(see PORTING.md for the rules and the verification ladder).
+
+## What still needs to be built (in order)
+
+1. **Package release.** Publish to PyPI so `pip install` works outside
+   this machine. (Name decision pending.)
+2. **Live driver.** The streaming counterpart of `backtest()`: feed bars
+   one at a time, get order intents out through a callback, with
+   semantics provably identical to the backtest of the same window.
+3. **Broker adapters.** A thin adapter contract that turns intents into
+   orders on the user's own account, paper-trading adapter first, then
+   real ones. Credentials always stay on the user's machine.
+4. **Host integrations.** The desktop terminal and notebook surfaces move
+   onto this engine so every surface runs the same code.
+5. **Spec + public conformance suite.** The rulebook and test corpus
+   published so third-party tooling can target the language without
+   semantic drift.

bruedemo-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: bruedemo
+Version: 0.1.0
+Summary: Internal test build of the Brue trading-strategy language engine. Will be republished under its final name; do not depend on this package.
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# bruedemo
+
+Internal TEST build of the Brue trading-strategy language engine
+(pure Python). Published for real-world install testing by the
+London Strategic Edge team only. The engine will be republished under
+its final name; do not depend on this package.
+
+```python
+import brue
+
+result = brue.backtest(script, dataframe)
+```

bruedemo-0.1.0/PORTING.md

@@ -0,0 +1,37 @@
+# brue-py: 1:1 Python port of brue-rust (owner decision 2026-07-21: the
+# shipping Brue engine is PYTHON; the Rust tree becomes the porting source).
+
+RULES FOR EVERY PORTED MODULE
+- Source of truth: /opt/lse-worker/brue-rust/src/<name>.rs. Port line by
+  line; keep the SAME module name (value.rs -> brue/value.py) and the SAME
+  function/struct names (Rust is snake_case already; structs become
+  dataclasses or plain classes with identical field names).
+- Semantics are the product. Preserve every documented quirk (na == na is
+  true, and/or evaluate both sides, division by zero -> na, compound-assign
+  coercion order, EMA SMA-seeding, float accumulation ORDER in indicators,
+  reference equality for colors/arrays/maps, byte-identical error messages
+  including "did you mean" tie-breaks).
+- Numbers: Python floats are IEEE754 doubles like Rust f64; keep operation
+  order identical. Never "simplify" running sums into vectorized forms.
+- jsmath/jsnum are V8-exact; port the fdlibm bit-twiddling as-is using
+  struct.pack/unpack for bit casts.
+- No third-party imports in the engine (stdlib only). numpy is BANNED in
+  engine modules (accumulation-order parity).
+- Comments: keep the Rust file's explanatory comments where they explain
+  WHY. Never use em dashes or en dashes anywhere.
+- Cross-module imports: from . import jsmath (etc.); keep function names so
+  parallel porting cannot desync interfaces.
+- Every module ends with nothing else: no __main__ blocks except cli.py.
+
+LAYOUT
+  brue/value.py errors.py jsnum.py jsmath.py tokenizer.py ast.py parser.py
+  indicators.py session.py data.py output.py builtins.py runtime.py
+  strategy.py quant.py cli.py __init__.py (__main__.py -> cli.main)
+
+VERIFICATION LADDER
+1. Module-level checks where possible (jsmath vs node mathcheck samples,
+   tokenizer/parser over the conformance corpus).
+2. Full conformance: conformance/run_all_py.sh compares `python -m brue run`
+   output against the RUST binary (itself 138/138 vs the TS reference),
+   NaN/Inf-exact, over corpus x generated datasets. The port is DONE only
+   when every case matches byte-for-byte.

bruedemo-0.1.0/README.md

@@ -0,0 +1,12 @@
+# bruedemo
+
+Internal TEST build of the Brue trading-strategy language engine
+(pure Python). Published for real-world install testing by the
+London Strategic Edge team only. The engine will be republished under
+its final name; do not depend on this package.
+
+```python
+import brue
+
+result = brue.backtest(script, dataframe)
+```

bruedemo-0.1.0/brue/__init__.py

@@ -0,0 +1,65 @@
+"""brue: pure-Python implementation of the Brue trading-strategy language.
+
+Ported 1:1 from the Rust engine (src/lib.rs); the conformance harness in
+conformance/ verifies byte-identical output against it.
+"""
+from __future__ import annotations
+
+
+
+def run_script(source, bars):
+    from .runtime import ExternalData
+    return run_script_with_data(source, bars, ExternalData())
+
+
+def run_script_with_data(source, bars, external):
+    from .runtime import RunOptions
+    return run_script_full(source, bars, external, {}, RunOptions())
+
+
+def run_script_full(source, bars, external, input_overrides, options):
+    """tokenize + parse + execute, errors shaped exactly like the reference."""
+    from . import parser, tokenizer
+    from .errors import BrueError
+
+    # Windows editors and Python text-mode writes produce CRLF; the
+    # tokenizer speaks LF. Normalize at every entry point.
+    source = source.replace("\r\n", "\n").replace("\r", "\n")
+    try:
+        tokens = tokenizer.tokenize(source)
+    except BrueError as e:
+        return _error_output(e)
+    try:
+        program = parser.parse(tokens)
+    except BrueError as e:
+        return _error_output(e)
+    from .runtime import execute_with_options
+    return execute_with_options(program, bars, input_overrides, external, options)
+
+
+# parse_time_arg and parse_bars_csv live in data.py, ported with Rust-exact
+# parsing (float()/int() alone are looser than f64::from_str: underscores,
+# unicode digits); re-exported here for the lib.rs-shaped public API.
+from .data import parse_bars_csv, parse_time_arg  # noqa: E402,F401
+from .api import BacktestResult, BrueScriptError, backtest  # noqa: E402,F401
+
+
+def _error_output(e):
+    from .output import ErrorInfo, ExecOutput
+    from .value import Value
+    return ExecOutput(
+        success=False,
+        commands=[],
+        errors=[ErrorInfo(message=e.message, line=e.loc.line, col=e.loc.col,
+                          phase=e.phase, suggestion=e.suggestion)],
+        inputs=[],
+        live_orders=[],
+        live_closes=[],
+        decl_title=Value.Null,
+        decl_overlay=Value.Bool(True),
+        decl_symbol=None,
+        decl_timeframe=None,
+        strategy_result=None,
+    )
+
+

bruedemo-0.1.0/brue/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

bruedemo-0.1.0/brue/api.py

@@ -0,0 +1,182 @@
+"""The Python-native front door for the brue package.
+
+The engine internals speak BarData lists and ExecOutput (ported 1:1 from
+the reference engine; conformance-locked, do not touch). This module is the
+convenience layer a Python user actually calls:
+
+    import brue
+
+    result = brue.backtest(script, df)        # df: pandas or rows
+    result.stats["netProfit"], result.trades, result.equity_curve
+
+Accepted data shapes: a pandas DataFrame (any case-insensitive subset of
+time/open/high/low/close/volume columns, time in epoch s, epoch ms, or
+datetimes), a list of dicts with those keys, a list of [t,o,h,l,c,v] rows,
+or a path to a csv. pandas is NOT a dependency: it is duck-typed, so the
+package installs clean without it.
+"""
+from __future__ import annotations
+
+import json
+
+
+class BrueScriptError(Exception):
+    """The script failed to tokenize/parse/run; message is user-facing."""
+
+    def __init__(self, errors):
+        self.errors = errors
+        first = errors[0] if errors else {}
+        super().__init__(first.get("message", "script error"))
+
+
+class BacktestResult:
+    """Friendly view over the engine's canonical output."""
+
+    def __init__(self, raw: dict, bar_times=None):
+        self.raw = raw
+        sr = raw.get("strategyResult") or {}
+        self.stats = {k: v for k, v in sr.items()
+                      if k not in ("trades", "equityCurve")}
+        self.trades = sr.get("trades", [])
+        # The engine emits one equity value per bar, no timestamps; the
+        # caller's bar times restore the x axis.
+        self.equity_curve = sr.get("equityCurve", [])
+        self.bar_times = bar_times or []
+
+    def trades_frame(self):
+        """The trade ledger as a pandas DataFrame (pandas required here)."""
+        import pandas as pd
+        return pd.DataFrame(self.trades)
+
+    def equity_frame(self):
+        import pandas as pd
+        df = pd.DataFrame({"equity": self.equity_curve})
+        if len(self.bar_times) == len(df):
+            df.insert(0, "time", pd.to_datetime(self.bar_times, unit="ms"))
+        return df
+
+    def __repr__(self):
+        s = self.stats
+        return (f"BacktestResult(trades={s.get('totalTrades')}, "
+                f"netProfit={s.get('netProfit')}, "
+                f"winRate={s.get('winRate')}, "
+                f"profitFactor={s.get('profitFactor')})")
+
+
+def _to_ms(t) -> float:
+    """Epoch seconds, epoch ms, or datetime-like -> epoch ms."""
+    if hasattr(t, "timestamp"):
+        return float(t.timestamp() * 1000.0)
+    x = float(t)
+    # Heuristic shared with the userdata importer: values before the year
+    # 5138 in seconds are seconds; anything bigger is already ms.
+    return x * 1000.0 if x < 1e11 else x
+
+
+def _bars_from_any(data):
+    from .runtime import BarData
+
+    if isinstance(data, str):
+        from . import parse_bars_csv
+        with open(data, encoding="utf-8") as f:
+            return parse_bars_csv(f.read())
+
+    # pandas DataFrame, duck-typed so pandas stays optional.
+    if hasattr(data, "columns") and hasattr(data, "itertuples"):
+        cols = {str(c).strip().lower(): c for c in data.columns}
+        tcol = next((cols[k] for k in ("time", "ts", "timestamp", "date",
+                                       "datetime") if k in cols), None)
+        need = [k for k in ("open", "high", "low", "close") if k not in cols]
+        if tcol is None or need:
+            missing = (["time"] if tcol is None else []) + need
+            raise ValueError(f"data is missing columns: {', '.join(missing)}")
+        # Follow the index when there is no time column? No: explicit only,
+        # a wrong guess silently shifts every fill.
+        out = []
+        vol = cols.get("volume")
+        for row in data.itertuples(index=False):
+            d = dict(zip(data.columns, row))
+            out.append(BarData(
+                time=_to_ms(d[tcol]),
+                open=float(d[cols["open"]]), high=float(d[cols["high"]]),
+                low=float(d[cols["low"]]), close=float(d[cols["close"]]),
+                volume=float(d[vol]) if vol is not None else 0.0))
+        return out
+
+    if isinstance(data, (list, tuple)) and data:
+        first = data[0]
+        if isinstance(first, dict):
+            return [BarData(time=_to_ms(r.get("time", r.get("ts", r.get("timestamp")))),
+                            open=float(r["open"]), high=float(r["high"]),
+                            low=float(r["low"]), close=float(r["close"]),
+                            volume=float(r.get("volume", 0.0)))
+                    for r in data]
+        if isinstance(first, (list, tuple)) and len(first) >= 5:
+            return [BarData(time=_to_ms(r[0]), open=float(r[1]), high=float(r[2]),
+                            low=float(r[3]), close=float(r[4]),
+                            volume=float(r[5]) if len(r) > 5 else 0.0)
+                    for r in data]
+    raise ValueError("unsupported data shape: pass a DataFrame, list of "
+                     "dicts, list of [t,o,h,l,c,v] rows, or a csv path")
+
+
+def indicator_series(script: str, data, inputs: dict | None = None) -> dict:
+    """
+    Run a Brue script as a chart INDICATOR: every plot() call becomes a
+    named series aligned to the bars. This is how hosts (the LSE Terminal,
+    notebooks) draw Brue-written indicators on live charts.
+
+    Returns {"plots": {name: [float per bar]}, "meta": {name: kwargs},
+             "overlay": bool, "inputs": [declared input() specs],
+             "times": [epoch ms per bar]}.
+    Raises BrueScriptError on script errors.
+    """
+    from . import run_script_full
+    from .runtime import ExternalData, RunOptions
+    from .value import Value
+
+    bars = _bars_from_any(data)
+    options = RunOptions()
+    options.collect_plots = True
+    overrides = {}
+    for k, v in (inputs or {}).items():
+        overrides[str(k)] = (Value.Bool(v) if isinstance(v, bool)
+                             else Value.Num(v) if isinstance(v, (int, float))
+                             else Value.Str(str(v)))
+    out = run_script_full(script, bars, ExternalData(), overrides, options)
+    raw = json.loads(out.to_json())
+    if not raw.get("success"):
+        raise BrueScriptError(raw.get("errors", []))
+    n = len(bars)
+    plots = {}
+    for name, points in getattr(out, "plots", {}).items():
+        col = [float("nan")] * n
+        for bar_i, v in points:
+            if 0 <= bar_i < n:
+                col[bar_i] = v
+        plots[name] = col
+    return {"plots": plots,
+            "meta": getattr(out, "plot_meta", {}),
+            "overlay": bool((raw.get("declaration") or {}).get("overlay", True)),
+            "inputs": raw.get("inputs", []),
+            "times": [b.time for b in bars]}
+
+
+def backtest(script: str, data, extended_stats: bool = False,
+             trade_from=None, trade_to=None) -> BacktestResult:
+    """Run a Brue strategy over the given bars, entirely in-process."""
+    from . import run_script_full
+    from .runtime import ExternalData, RunOptions
+
+    bars = _bars_from_any(data)
+    options = RunOptions()
+    options.extended_stats = bool(extended_stats)
+    if trade_from is not None:
+        options.trade_from = _to_ms(trade_from)
+    if trade_to is not None:
+        options.trade_to = _to_ms(trade_to)
+    out = run_script_full(script, bars, ExternalData(), {}, options)
+    raw = json.loads(out.to_json())
+    if not raw.get("success"):
+        raise BrueScriptError(raw.get("errors", []))
+    return BacktestResult(raw, bar_times=[b.time for b in bars])