add backtesting

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.13-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
@@ -11,6 +11,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
     && apt-get install -y --no-install-recommends nodejs \
     && (npm install -g openclaw || npm install -g clawdbot) \
+    && (openclaw --help >/dev/null 2>&1 || clawdbot --help >/dev/null 2>&1) \
     && rm -rf /var/lib/apt/lists/*
 
 # Python dependencies via uv + pyproject.toml.

README.md

@@ -20,6 +20,7 @@ This Space hosts the OpenClaw trading bot (paper-only). The LLM runs in a separa
 - OpenClaw bot Space (this repo) calls an external LLM Space for analysis and signal generation.
 - Paper trading via Alpaca API.
 - Trade logs stored to HF Hub storage (dataset repo).
+- Streamlit control center includes a built-in backtesting lab (backtesting.py + backtrader).
 
 **LLM Space (external)**
 - Expected to expose a simple HTTP inference endpoint.
@@ -28,6 +29,8 @@ This Space hosts the OpenClaw trading bot (paper-only). The LLM runs in a separa
 
 **Key Files**
 - `openclaw.json` defines providers, routing, tools, memory, and safety.
+- `app.py` provides gateway controls and strategy backtesting UI.
+- `tools/backtesting_runner.py` implements SMA crossover test runners for `backtesting.py` and `backtrader`.
 - `config/openclaw.env.example` lists all required env vars.
 - `skills/` contains architecture-only SKILL specs.
 - `tools/README.md` defines the tool surface to implement later.

app.py

@@ -2,10 +2,17 @@ import json
 import os
 import shutil
 import subprocess
+from datetime import date
 from pathlib import Path
 
+import pandas as pd
 import requests
 import streamlit as st
+from tools.backtesting_runner import (
+    load_price_data_from_csv_text,
+    load_price_data_from_yfinance,
+    run_backtest,
+)
 
 HF_PORT = int(os.getenv("PORT", "7860"))
 OPENCLAW_PORT = int(os.getenv("OPENCLAW_PORT", "8787"))
@@ -31,6 +38,10 @@ def init_state() -> None:
     st.session_state.setdefault("gateway_logs", [])
     st.session_state.setdefault("config_editor_text", load_config_text())
     st.session_state.setdefault("auto_started", False)
+    st.session_state.setdefault("backtest_result", None)
+    st.session_state.setdefault("backtest_data", None)
+    st.session_state.setdefault("backtest_params", None)
+    st.session_state.setdefault("backtest_error", "")
 
 
 def load_config_text() -> str:
@@ -157,6 +168,66 @@ def test_gateway(query: str) -> str:
         return f"Gateway request failed: {exc}"
 
 
+def build_strategy_frame(data: pd.DataFrame, fast_period: int, slow_period: int) -> pd.DataFrame:
+    frame = pd.DataFrame(index=data.index)
+    frame["Close"] = data["Close"]
+    frame["FastMA"] = data["Close"].rolling(window=fast_period).mean()
+    frame["SlowMA"] = data["Close"].rolling(window=slow_period).mean()
+    frame["Signal"] = 0
+    frame.loc[frame["FastMA"] > frame["SlowMA"], "Signal"] = 1
+    frame["SignalChange"] = frame["Signal"].diff().fillna(0)
+    return frame
+
+
+def render_backtest_visuals(result, data: pd.DataFrame, params: dict) -> None:
+    st.success(f"Backtest completed with {result.engine} ({result.input_rows} bars).")
+
+    metrics = result.metrics or {}
+    if metrics:
+        metric_cols = st.columns(max(1, min(4, len(metrics))))
+        for idx, (metric_name, metric_value) in enumerate(metrics.items()):
+            col = metric_cols[idx % len(metric_cols)]
+            val = f"{metric_value:.3f}" if isinstance(metric_value, float) else str(metric_value)
+            col.metric(metric_name, val)
+
+    viz = build_strategy_frame(data, params["fast_period"], params["slow_period"])
+    st.markdown("**Price + Moving Averages**")
+    st.line_chart(viz[["Close", "FastMA", "SlowMA"]], use_container_width=True)
+
+    signal_events = viz[viz["SignalChange"] != 0][["Close", "SignalChange"]].copy()
+    if not signal_events.empty:
+        signal_events["Event"] = signal_events["SignalChange"].map({1: "BUY", -1: "SELL"}).fillna("HOLD")
+        st.markdown("**Crossover Events**")
+        st.dataframe(signal_events[["Event", "Close"]], use_container_width=True)
+
+    if isinstance(result.equity_curve, pd.DataFrame) and not result.equity_curve.empty:
+        equity = result.equity_curve.copy()
+        if "Equity" not in equity.columns:
+            numeric_cols = equity.select_dtypes(include=["number"]).columns
+            if len(numeric_cols) > 0:
+                equity = equity.rename(columns={numeric_cols[0]: "Equity"})
+        if "Equity" in equity.columns:
+            st.markdown("**Equity Curve**")
+            st.line_chart(equity["Equity"], use_container_width=True)
+
+            drawdown = (equity["Equity"] / equity["Equity"].cummax() - 1.0) * 100.0
+            st.markdown("**Drawdown (%)**")
+            st.area_chart(drawdown, use_container_width=True)
+
+            returns = equity["Equity"].pct_change().dropna()
+            if not returns.empty:
+                st.markdown("**Return Distribution**")
+                hist = pd.DataFrame({"return": returns})
+                hist["bin"] = pd.cut(hist["return"], bins=30)
+                hist = hist.groupby("bin", observed=False).size().rename("count").reset_index()
+                hist["bin"] = hist["bin"].astype(str)
+                st.bar_chart(hist.set_index("bin")["count"], use_container_width=True)
+
+    if isinstance(result.trades, pd.DataFrame) and not result.trades.empty:
+        st.markdown("**Trades**")
+        st.dataframe(result.trades, use_container_width=True)
+
+
 st.set_page_config(page_title="OpenClaw Control Center", layout="wide")
 st.title("OpenClaw Control Center")
 st.caption("Manage gateway runtime, config, environment, and test calls from one UI.")
@@ -245,3 +316,87 @@ with test_col:
 with logs_col:
     st.subheader("Gateway Logs")
     st.code("\n".join(st.session_state["gateway_logs"][-LOG_MAX_LINES:]) or "No logs yet.")
+
+st.divider()
+st.subheader("Backtesting Lab")
+st.caption(
+    "Run SMA crossover tests with popular engines: backtesting.py and backtrader."
+)
+
+source_col, params_col = st.columns([3, 2])
+with source_col:
+    data_source = st.radio(
+        "Data Source",
+        options=["yfinance", "csv_upload"],
+        horizontal=True,
+    )
+    if data_source == "yfinance":
+        symbol = st.text_input("Symbol", value="AAPL")
+        date_col1, date_col2, interval_col = st.columns([1, 1, 1])
+        start_date = date_col1.date_input("Start", value=date(2022, 1, 1))
+        end_date = date_col2.date_input("End", value=date.today())
+        interval = interval_col.selectbox("Interval", options=["1d", "1h", "30m", "15m"], index=0)
+        uploaded_file = None
+    else:
+        uploaded_file = st.file_uploader("Upload CSV (Date/Open/High/Low/Close/Volume)", type=["csv"])
+        symbol = ""
+        start_date = None
+        end_date = None
+        interval = "1d"
+
+with params_col:
+    engine = st.selectbox("Engine", options=["backtesting.py", "backtrader"], index=0)
+    fast_period = st.number_input("Fast MA", min_value=2, max_value=200, value=10)
+    slow_period = st.number_input("Slow MA", min_value=3, max_value=400, value=30)
+    initial_cash = st.number_input("Initial Cash", min_value=1000.0, value=10000.0, step=1000.0)
+    commission = st.number_input(
+        "Commission (fraction)", min_value=0.0, max_value=0.1, value=0.001, format="%.5f"
+    )
+    run_bt = st.button("Run Backtest", use_container_width=True)
+
+if run_bt:
+    try:
+        if data_source == "yfinance":
+            data = load_price_data_from_yfinance(
+                symbol=symbol.strip().upper(),
+                start=str(start_date),
+                end=str(end_date),
+                interval=interval,
+            )
+        else:
+            if uploaded_file is None:
+                raise ValueError("Upload a CSV file first.")
+            data = load_price_data_from_csv_text(uploaded_file.getvalue().decode("utf-8"))
+
+        result = run_backtest(
+            engine=engine,
+            data=data,
+            fast_period=int(fast_period),
+            slow_period=int(slow_period),
+            initial_cash=float(initial_cash),
+            commission=float(commission),
+        )
+        st.session_state["backtest_result"] = result
+        st.session_state["backtest_data"] = data
+        st.session_state["backtest_params"] = {
+            "engine": engine,
+            "fast_period": int(fast_period),
+            "slow_period": int(slow_period),
+        }
+        st.session_state["backtest_error"] = ""
+    except Exception as exc:
+        st.session_state["backtest_error"] = str(exc)
+
+if st.session_state["backtest_error"]:
+    st.error(f"Backtest failed: {st.session_state['backtest_error']}")
+
+if (
+    st.session_state["backtest_result"] is not None
+    and isinstance(st.session_state["backtest_data"], pd.DataFrame)
+    and st.session_state["backtest_params"] is not None
+):
+    render_backtest_visuals(
+        st.session_state["backtest_result"],
+        st.session_state["backtest_data"],
+        st.session_state["backtest_params"],
+    )

pyproject.toml

@@ -3,8 +3,12 @@ name = "openclaw-space"
 version = "0.1.0"
 requires-python = ">=3.11"
 dependencies = [
+  "backtesting==0.3.3",
+  "backtrader==1.9.78.123",
+  "pandas==2.2.3",
   "requests==2.32.3",
   "streamlit==1.41.1",
+  "yfinance==0.2.54",
 ]
 
 [tool.uv]

tools/README.md

@@ -8,6 +8,11 @@ Expected modules:
   - `submit_order(signal)`
   - `list_positions()`
   - Safety: refuse non-paper base URL
+- `tools/backtesting_runner.py`
+  - `load_price_data_from_yfinance(...)`
+  - `load_price_data_from_csv_text(...)`
+  - `run_backtest(...)`
+  - Engines: `backtesting.py`, `backtrader`
 - `tools/hf_storage.py`
   - `append_trade(record)`
   - `append_report(record)`

tools/__init__.py

@@ -0,0 +1 @@
+# Tools package for OpenClaw local helpers.

tools/backtesting_runner.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from io import StringIO
+from typing import Any
+
+import backtrader as bt
+import pandas as pd
+import yfinance as yf
+from backtesting import Backtest, Strategy
+
+
+@dataclass
+class BacktestResult:
+    engine: str
+    metrics: dict[str, Any]
+    equity_curve: pd.DataFrame
+    trades: pd.DataFrame
+    input_rows: int
+
+
+def _normalize_ohlcv_columns(df: pd.DataFrame) -> pd.DataFrame:
+    if isinstance(df.columns, pd.MultiIndex):
+        df.columns = df.columns.get_level_values(0)
+
+    rename_map = {}
+    for col in df.columns:
+        lower = str(col).lower()
+        if lower == "open":
+            rename_map[col] = "Open"
+        elif lower == "high":
+            rename_map[col] = "High"
+        elif lower == "low":
+            rename_map[col] = "Low"
+        elif lower == "close":
+            rename_map[col] = "Close"
+        elif lower == "volume":
+            rename_map[col] = "Volume"
+    normalized = df.rename(columns=rename_map).copy()
+    for required in ["Open", "High", "Low", "Close"]:
+        if required not in normalized.columns:
+            raise ValueError(f"Missing required OHLC column: {required}")
+    if "Volume" not in normalized.columns:
+        normalized["Volume"] = 0
+    if not isinstance(normalized.index, pd.DatetimeIndex):
+        normalized.index = pd.to_datetime(normalized.index, utc=True, errors="coerce")
+    if normalized.index.tz is not None:
+        normalized.index = normalized.index.tz_convert("UTC").tz_localize(None)
+    normalized = normalized.dropna(subset=["Open", "High", "Low", "Close"])
+    normalized = normalized.sort_index()
+    return normalized
+
+
+def load_price_data_from_yfinance(
+    symbol: str,
+    start: str,
+    end: str,
+    interval: str = "1d",
+) -> pd.DataFrame:
+    df = yf.download(symbol, start=start, end=end, interval=interval, auto_adjust=False)
+    if df is None or df.empty:
+        raise ValueError(f"No market data returned for symbol: {symbol}")
+    return _normalize_ohlcv_columns(df)
+
+
+def load_price_data_from_csv_text(csv_text: str) -> pd.DataFrame:
+    df = pd.read_csv(StringIO(csv_text))
+    lowered = {str(c).lower(): c for c in df.columns}
+    if "date" in lowered:
+        date_col = lowered["date"]
+        df[date_col] = pd.to_datetime(df[date_col], utc=True, errors="coerce")
+        df = df.set_index(date_col)
+    elif "datetime" in lowered:
+        dt_col = lowered["datetime"]
+        df[dt_col] = pd.to_datetime(df[dt_col], utc=True, errors="coerce")
+        df = df.set_index(dt_col)
+    return _normalize_ohlcv_columns(df)
+
+
+class SmaCrossBacktestingPy(Strategy):
+    fast_period = 10
+    slow_period = 30
+
+    def init(self) -> None:
+        close = pd.Series(self.data.Close)
+        self.fast = self.I(lambda x: pd.Series(x).rolling(self.fast_period).mean(), close)
+        self.slow = self.I(lambda x: pd.Series(x).rolling(self.slow_period).mean(), close)
+
+    def next(self) -> None:
+        if self.fast[-1] > self.slow[-1] and not self.position:
+            self.buy()
+        elif self.fast[-1] < self.slow[-1] and self.position:
+            self.position.close()
+
+
+class SmaCrossBacktrader(bt.Strategy):
+    params = (("fast_period", 10), ("slow_period", 30))
+
+    def __init__(self) -> None:
+        self.fast = bt.indicators.SimpleMovingAverage(
+            self.data.close, period=self.params.fast_period
+        )
+        self.slow = bt.indicators.SimpleMovingAverage(
+            self.data.close, period=self.params.slow_period
+        )
+        self.crossover = bt.indicators.CrossOver(self.fast, self.slow)
+        self.equity_points: list[tuple[pd.Timestamp, float]] = []
+
+    def next(self) -> None:
+        if self.crossover > 0 and not self.position:
+            self.buy()
+        elif self.crossover < 0 and self.position:
+            self.close()
+        dt = self.data.datetime.datetime(0)
+        self.equity_points.append((pd.Timestamp(dt, tz="UTC"), self.broker.getvalue()))
+
+
+def run_backtesting_py(
+    data: pd.DataFrame,
+    fast_period: int,
+    slow_period: int,
+    initial_cash: float,
+    commission: float,
+) -> BacktestResult:
+    strategy_cls = type(
+        "ConfiguredSmaCrossBacktestingPy",
+        (SmaCrossBacktestingPy,),
+        {"fast_period": fast_period, "slow_period": slow_period},
+    )
+    bt_obj = Backtest(data, strategy_cls, cash=initial_cash, commission=commission)
+    stats = bt_obj.run()
+    equity_curve = stats.get("_equity_curve", pd.DataFrame())
+    trades = stats.get("_trades", pd.DataFrame())
+    metrics = {
+        "Return [%]": float(stats.get("Return [%]", 0.0)),
+        "Buy & Hold Return [%]": float(stats.get("Buy & Hold Return [%]", 0.0)),
+        "Sharpe Ratio": float(stats.get("Sharpe Ratio", 0.0) or 0.0),
+        "Max Drawdown [%]": float(stats.get("Max. Drawdown [%]", 0.0)),
+        "# Trades": int(stats.get("# Trades", 0)),
+        "Win Rate [%]": float(stats.get("Win Rate [%]", 0.0)),
+    }
+    return BacktestResult(
+        engine="backtesting.py",
+        metrics=metrics,
+        equity_curve=equity_curve,
+        trades=trades,
+        input_rows=len(data),
+    )
+
+
+def run_backtrader(
+    data: pd.DataFrame,
+    fast_period: int,
+    slow_period: int,
+    initial_cash: float,
+    commission: float,
+) -> BacktestResult:
+    cerebro = bt.Cerebro()
+    configured = type(
+        "ConfiguredSmaCrossBacktrader",
+        (SmaCrossBacktrader,),
+        {"params": (("fast_period", fast_period), ("slow_period", slow_period))},
+    )
+    cerebro.addstrategy(configured)
+    feed = bt.feeds.PandasData(dataname=data)
+    cerebro.adddata(feed)
+    cerebro.broker.setcash(initial_cash)
+    cerebro.broker.setcommission(commission=commission)
+    cerebro.addanalyzer(bt.analyzers.DrawDown, _name="drawdown")
+    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name="sharpe", timeframe=bt.TimeFrame.Days)
+    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="trades")
+
+    starting_value = cerebro.broker.getvalue()
+    run_result = cerebro.run()
+    ending_value = cerebro.broker.getvalue()
+    strategy = run_result[0]
+
+    dd = strategy.analyzers.drawdown.get_analysis()
+    sharpe = strategy.analyzers.sharpe.get_analysis()
+    ta = strategy.analyzers.trades.get_analysis()
+
+    total_closed = int(getattr(ta.total, "closed", 0) if hasattr(ta, "total") else 0)
+    won_total = int(getattr(ta.won, "total", 0) if hasattr(ta, "won") else 0)
+    win_rate = (won_total / total_closed * 100) if total_closed else 0.0
+    ret_pct = ((ending_value - starting_value) / starting_value * 100) if starting_value else 0.0
+
+    equity_curve = pd.DataFrame(strategy.equity_points, columns=["Time", "Equity"])
+    if not equity_curve.empty:
+        equity_curve = equity_curve.set_index("Time")
+
+    metrics = {
+        "Return [%]": float(ret_pct),
+        "Sharpe Ratio": float(sharpe.get("sharperatio", 0.0) or 0.0),
+        "Max Drawdown [%]": float(getattr(dd.max, "drawdown", 0.0) if hasattr(dd, "max") else 0.0),
+        "# Trades": total_closed,
+        "Win Rate [%]": float(win_rate),
+        "Final Equity": float(ending_value),
+    }
+    return BacktestResult(
+        engine="backtrader",
+        metrics=metrics,
+        equity_curve=equity_curve,
+        trades=pd.DataFrame(),
+        input_rows=len(data),
+    )
+
+
+def run_backtest(
+    engine: str,
+    data: pd.DataFrame,
+    fast_period: int,
+    slow_period: int,
+    initial_cash: float,
+    commission: float,
+) -> BacktestResult:
+    if fast_period >= slow_period:
+        raise ValueError("fast_period must be smaller than slow_period.")
+    if engine == "backtesting.py":
+        return run_backtesting_py(data, fast_period, slow_period, initial_cash, commission)
+    if engine == "backtrader":
+        return run_backtrader(data, fast_period, slow_period, initial_cash, commission)
+    raise ValueError(f"Unsupported engine: {engine}")