marketmyna 0.2.0__py3-none-any.whl

marketmyna/trading/backtest.py

@@ -0,0 +1,317 @@
+"""Strategy backtester.
+
+Rules that keep results honest:
+- signals are computed on a bar's close and filled at the NEXT bar's open
+  (no look-ahead);
+- stops / targets are checked inside each bar with its high/low; if both
+  could have been hit in the same bar the stop is assumed first;
+- a gap through the stop fills at the open, not at the stop;
+- every fill pays slippage and costs (commission + taxes) per side.
+"""
+
+from __future__ import annotations
+
+import itertools
+import math
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+from . import indicators as ind
+
+# id -> label, description, default params, optimisation grid
+STRATEGIES: dict[str, dict] = {
+    "ema_cross": {
+        "label": "EMA crossover",
+        "description": "Buy when the fast EMA crosses above the slow EMA; exit on the cross back.",
+        "params": {"fast": 9, "slow": 21},
+        "grid": {"fast": [5, 9, 12, 20], "slow": [21, 30, 50, 100]},
+    },
+    "breakout": {
+        "label": "Donchian breakout",
+        "description": "Buy a close above the N-day high; exit on a close below the M-day low.",
+        "params": {"entry_days": 20, "exit_days": 10},
+        "grid": {"entry_days": [10, 20, 55], "exit_days": [5, 10, 20]},
+    },
+    "rsi_reversion": {
+        "label": "RSI mean reversion",
+        "description": "Buy when RSI(14) closes below the lower level; exit above the upper level.",
+        "params": {"buy_below": 30, "sell_above": 55},
+        "grid": {"buy_below": [20, 25, 30, 35], "sell_above": [50, 55, 60, 70]},
+    },
+    "supertrend": {
+        "label": "Supertrend",
+        "description": "Long while Supertrend is up; exit when it turns down.",
+        "params": {"period": 10, "multiplier": 3.0},
+        "grid": {"period": [7, 10, 14], "multiplier": [2.0, 2.5, 3.0, 4.0]},
+    },
+    "sma_trend": {
+        "label": "Moving-average trend",
+        "description": "Long while the close is above its N-bar simple moving average.",
+        "params": {"period": 200},
+        "grid": {"period": [20, 50, 100, 150, 200]},
+    },
+    "vwma_cross": {
+        "label": "VWMA crossover",
+        "description": "Buy when the fast volume-weighted moving average crosses above the slow one; exit on the "
+                       "cross back. Volume-weighting gives heavy-volume days more say.",
+        "params": {"fast": 13, "slow": 19},
+        "grid": {"fast": [9, 13, 20], "slow": [19, 30, 50]},
+    },
+    "vwma_knn": {
+        "label": "VWMA crossover + kNN filter (experimental)",
+        "description": "The VWMA crossover, taken only when its nearest past crossovers (by ADX trend strength and "
+                       "MFI money flow) mostly went the right way. Experimental: on 19 large Indian and US stocks "
+                       "(10 years, judged on the unseen last 3) the filter cut returns from 13.9% to 1.6% on average "
+                       "and beat the plain crossover on only 4. Test it on your stock before trusting it.",
+        "params": {"fast": 13, "slow": 19, "k": 23, "min_vote": 2, "use_filter": 1},
+        "grid": {"fast": [9, 13, 20], "slow": [19, 30, 50], "min_vote": [0, 2, 5]},
+    },
+    "knn_supertrend": {
+        "label": "kNN-filtered Supertrend (experimental)",
+        "description": "An adaptive Supertrend (band tightens when a nearest-neighbour model of similar past market "
+                       "states is confident) taken only when that model leans up. Experimental: on 19 large stocks "
+                       "(unseen last 3 of 10 years) it averaged -2.3% against +9.4% for a plain Supertrend and beat "
+                       "it on 6. Test it on your stock before trusting it.",
+        "params": {"period": 10, "multiplier": 2.0, "min_score": 0.15, "k": 9, "horizon": 4},
+        "grid": {"multiplier": [1.5, 2.0, 3.0], "min_score": [0.0, 0.15, 0.3], "horizon": [4, 8]},
+    },
+}
+
+BARS_PER_YEAR = {"1d": 252, "1wk": 52, "1h": 252 * 7}
+
+
+@dataclass
+class Settings:
+    strategy: str = "ema_cross"
+    params: dict = field(default_factory=dict)
+    capital: float = 100000.0
+    sizing: str = "percent"  # percent (of equity) | risk (% of equity lost at the stop)
+    position_pct: float = 100.0
+    risk_pct: float = 1.0
+    stop_type: str = "none"  # none | percent | atr
+    stop_value: float = 2.0  # % or ATR multiple
+    target_r: Optional[float] = None  # take profit at N x the stop distance
+    cost_pct: float = 0.1  # per side: commission + taxes
+    slippage_pct: float = 0.05  # per side
+    allow_short: bool = False
+
+
+def signals(df: pd.DataFrame, strategy: str, p: dict) -> tuple[pd.Series, pd.Series]:
+    """(long_entry, long_exit) booleans evaluated on each bar's close.
+    Short trades use the mirror image: entry = long_exit, exit = long_entry."""
+    close = df["close"]
+    if strategy == "ema_cross":
+        fast, slow = ind.ema(close, int(p["fast"])), ind.ema(close, int(p["slow"]))
+        above = fast > slow
+        warm = pd.Series(np.arange(len(df)) >= int(p["slow"]), index=df.index)
+        return above & ~above.shift(1, fill_value=False) & warm, ~above & above.shift(1, fill_value=False) & warm
+    if strategy == "breakout":
+        hi = ind.donchian(df, int(p["entry_days"]))["upper"]
+        lo = ind.donchian(df, int(p["exit_days"]))["lower"]
+        return close > hi, close < lo
+    if strategy == "rsi_reversion":
+        r = ind.rsi(close)
+        return r < float(p["buy_below"]), r > float(p["sell_above"])
+    if strategy == "supertrend":
+        _, d = ind.supertrend(df, int(p["period"]), float(p["multiplier"]))
+        warm = pd.Series(np.arange(len(df)) > int(p["period"]), index=df.index)
+        return (d == 1) & (d.shift(1) == -1) & warm, (d == -1) & (d.shift(1) == 1) & warm
+    if strategy == "vwma_cross":
+        if "volume" not in df or df["volume"].fillna(0).sum() == 0:
+            raise ValueError("This strategy needs volume data")
+        from . import knn
+
+        f, sl = knn.vwma(df, int(p["fast"])), knn.vwma(df, int(p["slow"]))
+        above = f > sl
+        warm = sl.notna()
+        return above & ~above.shift(1, fill_value=False) & warm, ~above & above.shift(1, fill_value=False) & warm
+    if strategy == "vwma_knn":
+        if "volume" not in df or df["volume"].fillna(0).sum() == 0:
+            raise ValueError("This strategy needs volume data")
+        from . import knn
+
+        v = knn.crossover_vote(df, int(p["fast"]), int(p["slow"]), int(p["k"]))
+        ok = v["vote"] >= float(p["min_vote"]) if int(p.get("use_filter", 1)) else True
+        return (v["cross"] == 1) & ok, v["cross"] == -1
+    if strategy == "knn_supertrend":
+        from . import knn
+
+        a = knn.analog_score(df, horizon=int(p["horizon"]), k=int(p["k"]))
+        _, d = knn.adaptive_supertrend(df, a["agree"], int(p["period"]), float(p["multiplier"]))
+        state = (d == 1) & (a["score"] >= float(p["min_score"]))
+        return state & ~state.shift(1, fill_value=False), (d == -1) & (d.shift(1) == 1)
+    if strategy == "sma_trend":
+        sma = close.rolling(int(p["period"])).mean()
+        above = close > sma
+        return above & ~above.shift(1, fill_value=False) & sma.notna(), ~above & sma.notna()
+    raise ValueError(f"Unknown strategy '{strategy}'")
+
+
+def run(df: pd.DataFrame, s: Settings, interval: str = "1d") -> dict:
+    cols = ["open", "high", "low", "close"] + (["volume"] if "volume" in df else [])
+    df = df[cols].astype(float).dropna(subset=["open", "high", "low", "close"])
+    n = len(df)
+    params = {**STRATEGIES[s.strategy]["params"], **(s.params or {})}
+    long_in, long_out = (x.to_numpy() for x in signals(df, s.strategy, params))
+    atr = ind.atr(df, 14).to_numpy()
+    o, h, l, c = (df[k].to_numpy() for k in ("open", "high", "low", "close"))
+    times = df.index
+    slip, cost = s.slippage_pct / 100, s.cost_pct / 100
+
+    # Cash holds realised equity; open trades are marked to market, so long
+    # and short are symmetric: equity = cash + (price - entry) * qty * side.
+    cash, qty, side = s.capital, 0.0, 0  # side 1 long, -1 short
+    entry_px = stop = target = risk_per_unit = None
+    entry_i = 0
+    entry_fee = 0.0
+    pending: Optional[int] = None  # +1 open long, -1 open short, 0 close
+    trades: list[dict] = []
+    equity = np.empty(n)
+    bars_in = 0
+
+    def close_position(i: int, px: float, reason: str) -> None:
+        nonlocal cash, qty, side, entry_px, stop, target, risk_per_unit
+        fill = px * (1 - slip * side)
+        exit_fee = qty * fill * cost
+        gross = (fill - entry_px) * qty * side
+        cash += gross - exit_fee
+        pnl = gross - exit_fee - entry_fee
+        trades.append({
+            "side": "long" if side == 1 else "short",
+            "entry_time": times[entry_i].isoformat(), "exit_time": times[i].isoformat(),
+            "entry": round(entry_px, 4), "exit": round(fill, 4), "quantity": round(qty, 6),
+            "pnl": round(pnl, 2), "return_pct": round((fill / entry_px - 1) * 100 * side, 2),
+            "r": round(pnl / (risk_per_unit * qty), 2) if risk_per_unit and qty else None,
+            "bars": i - entry_i, "reason": reason,
+        })
+        qty, side, entry_px, stop, target, risk_per_unit = 0.0, 0, None, None, None, None
+
+    for i in range(n):
+        # 1) fill the previous bar's signal at this bar's open
+        if pending is not None:
+            if side != 0 and pending != side:
+                close_position(i, o[i], "signal")
+            if pending in (1, -1) and side == 0:
+                price_in = o[i] * (1 + slip * pending)
+                dist = None
+                if s.stop_type == "percent":
+                    dist = price_in * s.stop_value / 100
+                elif s.stop_type == "atr" and i > 0 and not math.isnan(atr[i - 1]):
+                    dist = atr[i - 1] * s.stop_value
+                if s.sizing == "risk" and dist:
+                    units = cash * s.risk_pct / 100 / dist
+                else:
+                    units = cash * s.position_pct / 100 / price_in
+                units = min(units, cash / (price_in * (1 + cost)))  # no leverage
+                if units > 0:
+                    side, qty, entry_px, entry_i, risk_per_unit = pending, units, price_in, i, dist
+                    stop = entry_px - dist * side if dist else None
+                    target = entry_px + dist * s.target_r * side if dist and s.target_r else None
+                    entry_fee = qty * entry_px * cost
+                    cash -= entry_fee
+            pending = None
+
+        # 2) stop / target inside the bar (stop first when both are possible)
+        if side != 0:
+            if stop is not None and ((side == 1 and l[i] <= stop) or (side == -1 and h[i] >= stop)):
+                close_position(i, min(o[i], stop) if side == 1 else max(o[i], stop), "stop")
+            elif target is not None and ((side == 1 and h[i] >= target) or (side == -1 and l[i] <= target)):
+                close_position(i, max(o[i], target) if side == 1 else min(o[i], target), "target")
+
+        # 3) signals on this close, filled at the next open
+        if i < n - 1:
+            if side == 1 and long_out[i]:
+                pending = -1 if s.allow_short else 0
+            elif side == -1 and long_in[i]:
+                pending = 1
+            elif side == 0:
+                if long_in[i]:
+                    pending = 1
+                elif s.allow_short and long_out[i]:
+                    pending = -1
+
+        if side != 0:
+            bars_in += 1
+        equity[i] = cash + ((c[i] - entry_px) * qty * side if side != 0 else 0.0)
+
+    if side != 0:
+        close_position(n - 1, c[-1], "end of test")
+        equity[-1] = cash
+
+    return _report(df, equity, trades, s, interval, bars_in)
+
+
+def _report(df: pd.DataFrame, equity: np.ndarray, trades: list[dict], s: Settings, interval: str, bars_in: int) -> dict:
+    n = len(df)
+    eq = pd.Series(equity, index=df.index)
+    peak = eq.cummax()
+    dd = (eq / peak - 1) * 100
+    rets = eq.pct_change().dropna()
+    per_year = BARS_PER_YEAR.get(interval, 252)
+    years = n / per_year if per_year else 0
+    total = (eq.iloc[-1] / s.capital - 1) * 100
+    pnls = [t["pnl"] for t in trades]
+    wins = [p for p in pnls if p > 0]
+    losses = [p for p in pnls if p <= 0]
+    rs = [t["r"] for t in trades if t["r"] is not None]
+    step = max(1, n // 500)
+    close = df["close"]
+    return {
+        "metrics": {
+            "total_return": round(total, 2),
+            "cagr": round(((eq.iloc[-1] / s.capital) ** (1 / years) - 1) * 100, 2) if years > 0 and eq.iloc[-1] > 0 else None,
+            "max_drawdown": round(float(dd.min()), 2),
+            "sharpe": round(float(rets.mean() / rets.std() * math.sqrt(per_year)), 2) if len(rets) > 2 and rets.std() > 0 else None,
+            "trades": len(trades),
+            "win_rate": round(len(wins) / len(trades) * 100, 1) if trades else None,
+            "profit_factor": round(sum(wins) / -sum(losses), 2) if losses and sum(losses) < 0 else None,
+            "avg_trade_pct": round(float(np.mean([t["return_pct"] for t in trades])), 2) if trades else None,
+            "avg_r": round(float(np.mean(rs)), 2) if rs else None,
+            "best_trade": max(pnls) if pnls else None,
+            "worst_trade": min(pnls) if pnls else None,
+            "avg_bars": round(float(np.mean([t["bars"] for t in trades])), 1) if trades else None,
+            "exposure": round(bars_in / n * 100, 1) if n else None,
+            "buy_hold_return": round((close.iloc[-1] / close.iloc[0] - 1) * 100, 2),
+            "final_equity": round(float(eq.iloc[-1]), 2),
+            "start": df.index[0].isoformat(), "end": df.index[-1].isoformat(), "bars": n,
+        },
+        "equity": [
+            {"time": t.isoformat(), "equity": round(float(v), 2), "buy_hold": round(float(s.capital * close.loc[t] / close.iloc[0]), 2),
+             "drawdown": round(float(d), 2)}
+            for t, v, d in list(zip(eq.index, eq.to_numpy(), dd.to_numpy()))[::step]
+        ],
+        "trades": trades,
+    }
+
+
+def split_test(df: pd.DataFrame, s: Settings, interval: str, train_frac: float = 0.7) -> dict:
+    """Same settings on the first 70% (in-sample) and the last 30% (out-of-sample)."""
+    cut = int(len(df) * train_frac)
+    return {"train": run(df.iloc[:cut], s, interval)["metrics"], "test": run(df.iloc[cut:], s, interval)["metrics"]}
+
+
+def optimize(df: pd.DataFrame, s: Settings, interval: str, objective: str = "sharpe", train_frac: float = 0.7,
+             min_trades: int = 3) -> dict:
+    """Grid-search the strategy's parameters on the training part only,
+    then report the winner on the unseen test part (walk-forward check)."""
+    grid = STRATEGIES[s.strategy]["grid"]
+    keys = list(grid)
+    cut = int(len(df) * train_frac)
+    train, test = df.iloc[:cut], df.iloc[cut:]
+    results = []
+    for combo in itertools.product(*(grid[k] for k in keys)):
+        p = dict(zip(keys, combo))
+        if s.strategy == "ema_cross" and p["fast"] >= p["slow"]:
+            continue
+        m = run(train, Settings(**{**s.__dict__, "params": p}), interval)["metrics"]
+        score = m.get(objective)
+        results.append({"params": p, "score": score if m["trades"] >= min_trades else None, **{k: m[k] for k in
+                        ("total_return", "sharpe", "max_drawdown", "trades", "win_rate", "profit_factor")}})
+    ranked = sorted((r for r in results if r["score"] is not None), key=lambda r: -r["score"])
+    best = ranked[0]["params"] if ranked else STRATEGIES[s.strategy]["params"]
+    test_metrics = run(test, Settings(**{**s.__dict__, "params": best}), interval)["metrics"]
+    return {"objective": objective, "best": best, "train": ranked[0] if ranked else None, "test": test_metrics,
+            "grid": results, "keys": keys}

marketmyna/trading/charges.py

@@ -0,0 +1,82 @@
+"""Trading charges per market and product (approximate public schedules;
+the broker's contract note is final). One implementation for the position
+sizer, the journal's automatic fees and the backtester's presets.
+
+India: discount-broker schedule (brokerage ₹20 or 0.03%, whichever is lower;
+0 for delivery) plus statutory STT, exchange transaction charge, SEBI fee,
+stamp duty and 18% GST. Rates as of 2025-26.
+US: commission (default 0) plus SEC fee and FINRA TAF on sells."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+RATES_AS_OF = "2025-26"
+
+INDIA = {
+    # product: (brokerage % per order, brokerage cap ₹, STT buy %, STT sell %, exchange %, stamp buy %)
+    "intraday": (0.03, 20.0, 0.0, 0.025, 0.00297, 0.003),
+    "delivery": (0.0, 0.0, 0.1, 0.1, 0.00297, 0.015),
+    "futures": (0.03, 20.0, 0.0, 0.02, 0.00173, 0.002),
+    # options: premium turnover; brokerage is a flat ₹20 per order
+    "options": (None, 20.0, 0.0, 0.1, 0.03503, 0.003),
+}
+SEBI_PCT = 0.0001
+GST_PCT = 18.0
+
+US_SEC_PER_MILLION = 27.80
+US_TAF_PER_SHARE = 0.000166
+US_TAF_CAP = 8.30
+
+
+def india(buy_value: float, sell_value: float, product: str) -> dict:
+    pct_brk, cap, stt_buy, stt_sell, exch, stamp = INDIA[product]
+    if pct_brk is None:
+        brokerage = (cap if buy_value else 0) + (cap if sell_value else 0)
+    else:
+        brokerage = sum(min(cap, v * pct_brk / 100) for v in (buy_value, sell_value) if v)
+    turnover = buy_value + sell_value
+    stt = buy_value * stt_buy / 100 + sell_value * stt_sell / 100
+    exchange = turnover * exch / 100
+    sebi = turnover * SEBI_PCT / 100
+    stamp_duty = buy_value * stamp / 100
+    gst = (brokerage + exchange + sebi) * GST_PCT / 100
+    return {"Brokerage": brokerage, "STT": stt, "Exchange txn": exchange, "SEBI": sebi,
+            "Stamp duty": stamp_duty, "GST": gst}
+
+
+def us(buy_value: float, sell_value: float, quantity: float, commission_pct: float, flat: float) -> dict:
+    orders = (1 if buy_value else 0) + (1 if sell_value else 0)
+    return {
+        "Commission": (buy_value + sell_value) * commission_pct / 100 + flat * orders,
+        "SEC fee": sell_value * US_SEC_PER_MILLION / 1_000_000,
+        "FINRA TAF": min(US_TAF_CAP, quantity * US_TAF_PER_SHARE) if sell_value else 0.0,
+    }
+
+
+def custom(buy_value: float, sell_value: float, commission_pct: float, flat: float) -> dict:
+    orders = (1 if buy_value else 0) + (1 if sell_value else 0)
+    return {"Commission %": (buy_value + sell_value) * commission_pct / 100, "Flat fees": flat * orders}
+
+
+def estimate(market: str, buy_value: float, sell_value: float, quantity: float = 0, product: Optional[str] = None,
+             commission_pct: float = 0.0, flat: float = 0.0) -> dict:
+    """Charges for one buy and/or one sell. Pass 0 for a side not traded
+    yet (an open position pays only the entry side)."""
+    if market == "india":
+        parts = india(buy_value, sell_value, product if product in INDIA else "delivery")
+    elif market in ("us", "global"):
+        parts = us(buy_value, sell_value, quantity, commission_pct, flat)
+    else:
+        parts = custom(buy_value, sell_value, commission_pct, flat)
+    parts = {k: round(v, 2) for k, v in parts.items()}
+    return {"total": round(sum(parts.values()), 2), "parts": parts, "rates_as_of": RATES_AS_OF}
+
+
+def for_trade(t: dict, exit_price: Optional[float] = None) -> float:
+    """Charges for a journal trade: entry side, plus exit side once closed."""
+    qty = t["quantity"]
+    entry_value = t["entry_price"] * qty
+    exit_value = (exit_price if exit_price is not None else t.get("exit_price") or 0) * qty
+    buy, sell = (entry_value, exit_value) if t.get("side", "long") == "long" else (exit_value, entry_value)
+    return estimate(t["market"], buy, sell, qty, t.get("product"))["total"]

marketmyna/trading/chart.py

@@ -0,0 +1,197 @@
+"""Chart payload for the Trade page: bars plus indicator series, pivots and
+opening range, all computed here (marketmyna/trading/indicators.py)."""
+
+from __future__ import annotations
+
+import math
+
+import pandas as pd
+
+from ..core.constants import TimeFrame
+from . import indicators as ind
+
+INTERVALS = ("1m", "5m", "15m", "30m", "1h", "1d", "1wk")
+INTRADAY = {"1m", "5m", "15m", "30m", "1h"}
+# Longest history Yahoo serves per bar size (and a sensible default).
+MAX_PERIOD = {"1m": "5d", "5m": "1mo", "15m": "1mo", "30m": "1mo", "1h": "6mo"}
+DEFAULT_PERIOD = {"1m": "1d", "5m": "5d", "15m": "5d", "30m": "1mo", "1h": "3mo", "1d": "1y", "1wk": "5y"}
+PERIOD_ORDER = ["1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y"]
+INDICATORS = ("vwap", "ema9", "ema21", "ema50", "ema200", "supertrend", "vwma", "knn_st")
+
+
+def clamp_period(interval: str, period: str | None) -> str:
+    period = period if period in PERIOD_ORDER else DEFAULT_PERIOD[interval]
+    limit = MAX_PERIOD.get(interval)
+    if limit and PERIOD_ORDER.index(period) > PERIOD_ORDER.index(limit):
+        return limit
+    return period
+
+
+def _times(index: pd.Index) -> list[int]:
+    """Bar times as exchange wall-clock seconds, so the chart's axis shows
+    9:15 for an NSE open whatever the viewer's timezone."""
+    idx = pd.DatetimeIndex(index)
+    if idx.tz is not None:
+        idx = idx.tz_localize(None)
+    return [int(t.value // 1_000_000_000) for t in idx]
+
+
+def _series(times: list[int], values: pd.Series) -> list[dict]:
+    return [
+        {"time": t, "value": round(float(v), 6)}
+        for t, v in zip(times, values.to_numpy())
+        if v is not None and not (isinstance(v, float) and math.isnan(v))
+    ]
+
+
+def normalize(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.rename(columns=str.lower)
+    for col in ("open", "high", "low"):
+        if col not in df:
+            df[col] = df["close"]
+    if "volume" not in df:
+        df["volume"] = 0.0
+    df = df[["open", "high", "low", "close", "volume"]].astype(float)
+    df = df[~df.index.duplicated(keep="last")].sort_index()
+    return df.dropna(subset=["close"])
+
+
+def _vwma_knn(df: pd.DataFrame, times: list[int], series: dict) -> list[dict]:
+    """VWMA 13 / 19 lines; each crossover marked with its kNN vote (experimental:
+    tested on 19 stocks it had no out-of-sample edge over the plain crossover):
+    solid when the filter would take it."""
+    from . import knn
+
+    fast, slow = knn.vwma(df, 13), knn.vwma(df, 19)
+    series["vwma13"] = _series(times, fast)
+    series["vwma19"] = _series(times, slow)
+    v = knn.crossover_vote(df, 13, 19, 23)
+    out = []
+    for t, c, vote in zip(times, v["cross"].to_numpy(), v["vote"].to_numpy()):
+        if c == 0 or (isinstance(vote, float) and math.isnan(vote)):
+            continue
+        up = c > 0
+        take = vote >= 2 if up else vote <= -2
+        out.append({"time": t, "kind": ("buy" if up else "sell") + ("" if take else "_skip"),
+                    "text": f"kNN {vote:+.0f}"})
+    return out
+
+
+def _knn_supertrend(df: pd.DataFrame, times: list[int], series: dict) -> tuple[list[dict], dict]:
+    """Adaptive Supertrend legs and the filtered strategy's entries / exits
+    (experimental, same rules as the backtest strategy knn_supertrend)."""
+    from . import knn
+
+    a = knn.analog_score(df)
+    line, d = knn.adaptive_supertrend(df, a["agree"], 10, 2.0)
+    series["knn_st_up"] = _series(times, line.where(d == 1))
+    series["knn_st_down"] = _series(times, line.where(d == -1))
+    state = (d == 1) & (a["score"] >= 0.15)
+    entry = (state & ~state.shift(1, fill_value=False)).to_numpy()
+    exit_ = ((d == -1) & (d.shift(1) == 1)).to_numpy()
+    out = [{"time": t, "kind": "buy", "text": "kNN buy"} for t, e in zip(times, entry) if e]
+    out += [{"time": t, "kind": "sell", "text": "exit"} for t, x in zip(times, exit_) if x]
+    last = a.dropna().iloc[-1] if a["score"].notna().any() else None
+    now = None if last is None else {"score": round(float(last["score"]), 3), "agree": round(float(last["agree"]), 3),
+                                     "trend": "up" if d.iloc[-1] == 1 else "down"}
+    return out, now
+
+
+def build_chart(df: pd.DataFrame, interval: str, wanted: list[str]) -> dict:
+    df = normalize(df)
+    if df.empty:
+        return {"bars": [], "series": {}, "markers": [], "knn": None, "pivots": None, "opening_range": None, "last": None}
+    times = _times(df.index)
+    bars = [
+        {"time": t, "open": o, "high": h, "low": low, "close": c, "volume": v}
+        for t, o, h, low, c, v in zip(times, *(df[k].round(6).tolist() for k in ("open", "high", "low", "close", "volume")))
+    ]
+    series: dict[str, list[dict]] = {}
+    markers: list[dict] = []
+    knn_now = None
+    intraday = interval in INTRADAY
+    for name in wanted:
+        if name == "vwap" and intraday and df["volume"].sum() > 0:
+            series["vwap"] = _series(times, ind.vwap(df))
+        elif name.startswith("ema") and name[3:].isdigit():
+            series[name] = _series(times, ind.ema(df["close"], int(name[3:])).where(
+                pd.Series(range(len(df)), index=df.index) >= int(name[3:]) - 1))
+        elif name == "supertrend" and len(df) > 12:
+            line, direction = ind.supertrend(df)
+            series["supertrend_up"] = _series(times, line.where(direction == 1))
+            series["supertrend_down"] = _series(times, line.where(direction == -1))
+        elif name == "vwma" and df["volume"].sum() > 0 and len(df) > 40:
+            markers += _vwma_knn(df, times, series)
+        elif name == "knn_st" and len(df) > 120:
+            extra, knn_now = _knn_supertrend(df, times, series)
+            markers += extra
+
+    # Pivots from the previous complete session.
+    pivots = None
+    if intraday:
+        days = df.groupby(ind.session_key(df.index))
+        sessions = list(days)
+        if len(sessions) >= 2:
+            prev = sessions[-2][1]
+            pivots = ind.pivots(float(prev["high"].max()), float(prev["low"].min()), float(prev["close"].iloc[-1]))
+    elif len(df) >= 2:
+        prev = df.iloc[-2]
+        pivots = ind.pivots(float(prev["high"]), float(prev["low"]), float(prev["close"]))
+
+    last = df.iloc[-1]
+    rsi = ind.rsi(df["close"]).iloc[-1] if len(df) > 15 else float("nan")
+    return {
+        "bars": bars,
+        "series": series,
+        "pivots": {k: round(v, 4) for k, v in pivots.items()} if pivots else None,
+        "opening_range": ind.opening_range(df) if intraday else None,
+        "markers": sorted(markers, key=lambda m: m["time"]),
+        "knn": knn_now,
+        "last": {
+            "time": times[-1],
+            "close": float(last["close"]),
+            "rsi": None if math.isnan(rsi) else round(float(rsi), 1),
+        },
+    }
+
+
+BINANCE_INTERVALS = {"1m": "1m", "5m": "5m", "15m": "15m", "30m": "30m", "1h": "1h", "1d": "1d", "1wk": "1w"}
+INTERVAL_SECONDS = {"1m": 60, "5m": 300, "15m": 900, "30m": 1800, "1h": 3600, "1d": 86400, "1wk": 604800}
+PERIOD_DAYS = {"1d": 1, "5d": 5, "1mo": 30, "3mo": 91, "6mo": 182, "1y": 365, "2y": 730, "5y": 1826}
+
+
+def binance_pair(symbol: str) -> str:
+    """BTC-USD -> BTCUSDT (the listing's crypto symbols are Binance USDT pairs)."""
+    base = symbol.upper().split("-")[0]
+    return base if base.endswith("USDT") else f"{base}USDT"
+
+
+def binance_klines(symbol: str, interval: str, period: str) -> pd.DataFrame:
+    """Crypto candles straight from Binance: real volume and no delay."""
+    import requests
+
+    limit = min(1000, max(2, PERIOD_DAYS.get(period, 30) * 86400 // INTERVAL_SECONDS[interval]))
+    r = requests.get("https://api.binance.com/api/v3/klines", timeout=10,
+                     params={"symbol": binance_pair(symbol), "interval": BINANCE_INTERVALS[interval], "limit": limit})
+    r.raise_for_status()
+    rows = r.json()
+    if not rows:
+        return pd.DataFrame()
+    df = pd.DataFrame(rows, columns=["t", "open", "high", "low", "close", "volume", *range(6)])
+    df.index = pd.to_datetime(df["t"], unit="ms", utc=True)
+    return df[["open", "high", "low", "close", "volume"]].astype(float)
+
+
+def fetch_bars(symbol: str, market: str, interval: str, period: str) -> pd.DataFrame:
+    from ..agent.agents import _resolve_fetcher
+
+    if market == "crypto":
+        try:
+            df = binance_klines(symbol, interval, period)
+            if not df.empty:
+                return df
+        except Exception as exc:  # fall back to the fetcher chain (Yahoo)
+            import logging
+
+            logging.getLogger(__name__).warning("Binance klines for %s failed: %s", symbol, exc)
+    return _resolve_fetcher(market).get_history(symbol, period=period, interval=TimeFrame(interval))