Update app.py

app.py

@@ -1,50 +1,49 @@
 """
-RCEA Lite v1.0 — Forex Edition (GitHub CSV)
-Regime-Conditioned Evidence Accumulation + BOCPD.
-Causal. No supervised ML. No API key required.
+RCEA Lite v1.0 — yfinance Edition
+Regime-Conditioned Evidence Accumulation. Causal HMM. No supervised ML.
 """
 
 import math, time, warnings
 from datetime import datetime, timezone
+from typing import List, Optional
 
 import numpy as np
 import pandas as pd
+import yfinance as yf
 import gradio as gr
 from hmmlearn import hmm
 
 warnings.filterwarnings("ignore")
 
 # ---------- Config ----------
-GITHUB_RAW = "https://raw.githubusercontent.com/ejtraderLabs/historical-data/main"
-FOREX_SYMBOLS = [
-    "EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD",
-    "USDCHF", "EURGBP", "EURJPY", "GBPJPY", "EURCHF",
-    "AUDJPY", "XAUUSD",
-]
-TF_MAP = {"15m": "m15", "1h": "h1", "4h": "h4", "1d": "d1"}
-COMMISSION, SLIPPAGE = 0.0002, 0.0001
+COMMISSION, SLIPPAGE = 0.001, 0.0005
 COST = 2 * (COMMISSION + SLIPPAGE)
 REGIME_NAMES = ["TREND", "MEAN_REVERSION", "COMPRESSION"]
 HMM_K = 3
 TRAIN_FRAC, PURGE, EMBARGO = 0.60, 5, 3
 MIN_HMM, MIN_SIG = 150, 80
 FEAT_COLS = ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_ma"]
-TARGET_BARS = 2000
 
-BOCPD_HAZARD = 1.0 / 250.0
-BOCPD_MAX_RUN = 300
-BOCPD_PRIOR_MU, BOCPD_PRIOR_KAPPA = 0.0, 0.1
-BOCPD_PRIOR_ALPHA, BOCPD_PRIOR_BETA = 0.1, 1e-4
+# 30 USDT paritesi (yfinance sembolleri)
+COINS = [
+    "BTC-USD", "ETH-USD", "BNB-USD", "SOL-USD", "XRP-USD",
+    "ADA-USD", "DOGE-USD", "AVAX-USD", "TRX-USD", "DOT-USD",
+    "LINK-USD", "MATIC-USD", "LTC-USD", "BCH-USD", "UNI-USD",
+    "ATOM-USD", "ETC-USD", "XLM-USD", "NEAR-USD", "APT-USD",
+    "ARB-USD", "OP-USD", "FIL-USD", "INJ-USD", "SUI-USD",
+    "SEI-USD", "TIA-USD", "AAVE-USD", "MKR-USD", "GRT-USD",
+]
 
-
-# ---------- Helpers ----------
-def _f(x):
-    try:
-        v = float(x); return v if math.isfinite(v) else None
-    except (TypeError, ValueError):
-        return None
+# yfinance interval mapping + max period per interval
+YF_TF = {
+    "15m": ("15m", "60d"),
+    "1h":  ("1h",  "730d"),
+    "4h":  ("1h",  "730d"),   # 4h yok → 1h'den resample
+    "1d":  ("1d",  "5y"),
+}
 
 
+# ---------- Helpers ----------
 def _sig(x):
     return 1.0 / (1.0 + math.exp(-x)) if x >= 0 else math.exp(x) / (1.0 + math.exp(x))
 
@@ -72,105 +71,79 @@ def _rsi(c, p=14):
     return 100.0 - 100.0 / (1.0 + rs)
 
 
-# ---------- BOCPD ----------
-def _student_t_pdf(x, mu, kappa, alpha, beta):
-    scale2 = np.maximum(beta * (kappa + 1.0) / (alpha * kappa), 1e-12)
-    df = 2.0 * alpha
-    z = (x - mu) / np.sqrt(scale2)
-    log_norm = (math.lgamma((df + 1.0) / 2.0) - math.lgamma(df / 2.0)
-                - 0.5 * np.log(df * np.pi) - 0.5 * np.log(scale2))
-    return np.exp(log_norm - 0.5 * (df + 1.0) * np.log1p(z * z / df))
+# ---------- yfinance Data Layer ----------
+def fetch_pairs(n=30):
+    """Return fixed 30-coin USDT list (yfinance)."""
+    out = COINS[:max(30, min(30, int(n)))]
+    print(f"[RCEA] {len(out)} yfinance pairs resolved", flush=True)
+    return out
 
 
-def bocpd_changepoint_prob(returns, hazard=BOCPD_HAZARD, max_run=BOCPD_MAX_RUN):
-    n = len(returns); cp_prob = np.zeros(n)
-    R = np.array([1.0])
-    mu_arr = np.array([BOCPD_PRIOR_MU]); kappa_arr = np.array([BOCPD_PRIOR_KAPPA])
-    alpha_arr = np.array([BOCPD_PRIOR_ALPHA]); beta_arr = np.array([BOCPD_PRIOR_BETA])
-
-    for t in range(n):
-        x = returns[t]
-        pred = _student_t_pdf(x, mu_arr, kappa_arr, alpha_arr, beta_arr)
-        growth = R * pred * (1.0 - hazard)
-        cp = np.sum(R * pred * hazard)
-        denom = cp + growth.sum()
-        cp_prob[t] = cp / denom if denom > 1e-300 else 0.0
-
-        R_new = np.empty(len(R) + 1); R_new[0] = cp; R_new[1:] = growth
-        s = R_new.sum(); R_new = R_new / s if s > 1e-300 else np.array([1.0])
-
-        new_mu = np.empty(len(R_new)); new_kappa = np.empty(len(R_new))
-        new_alpha = np.empty(len(R_new)); new_beta = np.empty(len(R_new))
-        new_mu[0] = BOCPD_PRIOR_MU; new_kappa[0] = BOCPD_PRIOR_KAPPA
-        new_alpha[0] = BOCPD_PRIOR_ALPHA; new_beta[0] = BOCPD_PRIOR_BETA
-        new_kappa[1:] = kappa_arr + 1.0
-        new_mu[1:] = (kappa_arr * mu_arr + x) / new_kappa[1:]
-        new_alpha[1:] = alpha_arr + 0.5
-        new_beta[1:] = beta_arr + 0.5 * kappa_arr * (x - mu_arr) ** 2 / new_kappa[1:]
-
-        if len(R_new) > max_run:
-            R_new = R_new[:max_run]; new_mu = new_mu[:max_run]
-            new_kappa = new_kappa[:max_run]; new_alpha = new_alpha[:max_run]
-            new_beta = new_beta[:max_run]; R_new = R_new / R_new.sum()
-
-        R = R_new; mu_arr = new_mu; kappa_arr = new_kappa
-        alpha_arr = new_alpha; beta_arr = new_beta
-    return cp_prob
-
-
-# ---------- Data (GitHub CSV) ----------
-def fetch_pairs(n, api_key=None):
-    pairs = FOREX_SYMBOLS[:max(1, min(n, len(FOREX_SYMBOLS)))]
-    print(f"[RCEA] {len(pairs)} forex symbols selected", flush=True)
-    return pairs
-
-
-def fetch_klines(symbol, timeframe, api_key=None, target_bars=TARGET_BARS):
-    tf = TF_MAP.get(timeframe)
-    if tf is None:
+def fetch_klines(inst_id, timeframe, target_bars=1000):
+    """
+    Fetch OHLCV from Yahoo Finance via yfinance.
+    For 4h, downloads 1h and resamples to 4H.
+    Returns None if insufficient data.
+    """
+    if timeframe not in YF_TF:
         return None
-    symbol = symbol.upper()
-    url = f"{GITHUB_RAW}/{symbol}/{symbol}{tf}.csv"
+    interval, period = YF_TF[timeframe]
+
     try:
-        df = pd.read_csv(url)
+        raw = yf.download(
+            inst_id,
+            interval=interval,
+            period=period,
+            auto_adjust=False,
+            progress=False,
+            threads=False,
+        )
     except Exception as e:
-        print(f"[RCEA] {symbol} CSV fetch failed: {e}", flush=True)
+        print(f"[RCEA] {inst_id} download failed: {e}", flush=True)
+        return None
+
+    if raw is None or raw.empty:
+        print(f"[RCEA] {inst_id}: empty data", flush=True)
         return None
 
-    df.columns = [c.strip().lower() for c in df.columns]
-    if "date" in df.columns:
-        df = df.rename(columns={"date": "datetime"})
-    elif "time" in df.columns:
-        df = df.rename(columns={"time": "datetime"})
+    # yfinance multiindex flatten (tek sembolde bile MultiIndex dönebilir)
+    if isinstance(raw.columns, pd.MultiIndex):
+        raw.columns = raw.columns.get_level_values(0)
 
-    required = {"open", "high", "low", "close"}
-    if not required.issubset(df.columns):
-        print(f"[RCEA] {symbol}: missing columns", flush=True)
+    raw = raw.rename(columns=str.lower)
+    needed = ["open", "high", "low", "close", "volume"]
+    if not all(c in raw.columns for c in needed):
+        print(f"[RCEA] {inst_id}: missing columns {raw.columns.tolist()}", flush=True)
         return None
 
-    for col in ["open", "high", "low", "close"]:
-        df[col] = pd.to_numeric(df[col], errors="coerce")
-    if "tick_volume" in df.columns:
-        df["volume"] = pd.to_numeric(df["tick_volume"], errors="coerce").fillna(0.0)
-    elif "volume" in df.columns:
-        df["volume"] = pd.to_numeric(df["volume"], errors="coerce").fillna(0.0)
-    else:
-        df["volume"] = 0.0
+    df = raw[needed].copy()
+    df = df.dropna(subset=["open", "high", "low", "close"])
+    df = df[df["close"] > 0]
+
+    # 4h resample
+    if timeframe == "4h":
+        df = df.resample("4H").agg({
+            "open": "first", "high": "max", "low": "min",
+            "close": "last", "volume": "sum",
+        }).dropna()
 
-    df = df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
-    if len(df) > target_bars:
-        df = df.iloc[-target_bars:].reset_index(drop=True)
     if len(df) < MIN_HMM:
-        print(f"[RCEA] {symbol}: insufficient rows ({len(df)})", flush=True)
+        print(f"[RCEA] {inst_id}: only {len(df)} bars (< {MIN_HMM})", flush=True)
         return None
-    return df[["open", "high", "low", "close", "volume"]]
+
+    # Son target_bars
+    df = df.tail(target_bars).reset_index(drop=True)
+    return df
 
 
 # ---------- Features ----------
 def features(df):
-    c = df["close"].values.astype(float); h = df["high"].values.astype(float)
-    lo = df["low"].values.astype(float); n = len(c)
-    o = pd.DataFrame(index=df.index); o["close"] = c
+    c = df["close"].values.astype(float)
+    h = df["high"].values.astype(float)
+    lo = df["low"].values.astype(float)
+    n = len(c)
+    o = pd.DataFrame(index=df.index)
+    o["close"] = c
     r = np.zeros(n); r[1:] = np.diff(c) / c[:-1]; o["ret"] = r
     a14 = _atr(h, lo, c, 14); o["atr"] = a14
     o["atr_norm"] = a14 / np.where(c > 0, c, 1.0)
@@ -192,7 +165,8 @@ def features(df):
     ae = np.where(a14 > 1e-12, (c - rm) / a14, 0.0); o["atr_extension"] = np.nan_to_num(ae)
     a5, a20 = _atr(h, lo, c, 5), _atr(h, lo, c, 20)
     o["vol_ratio"] = np.where(a20 > 1e-12, a5 / a20, 1.0)
-    ph, pl_ = np.roll(h, 1), np.roll(lo, 1); ph[0], pl_[0] = h[0], lo[0]
+    ph, pl_ = np.roll(h, 1), np.roll(lo, 1)
+    ph[0], pl_[0] = h[0], lo[0]
     o["prev_high"], o["prev_low"] = ph, pl_
     o["breakout"] = np.where(c > ph, 1.0, np.where(c < pl_, -1.0, 0.0))
     return o.replace([np.inf, -np.inf], np.nan).fillna(0.0)
@@ -213,7 +187,8 @@ def fit_hmm(f):
 
 
 def forward_filter(m, f):
-    n = len(f); post = np.ones((n, HMM_K)) / HMM_K
+    n = len(f)
+    post = np.ones((n, HMM_K)) / HMM_K
     ntr = min(max(MIN_HMM, int(n * TRAIN_FRAC)), n - 20)
     if ntr < 10: return post
     X = (f[FEAT_COLS].values - m._mu) / m._sd
@@ -234,9 +209,10 @@ def forward_filter(m, f):
     return post
 
 
-# ---------- Evidence + BOCPD blend ----------
-def evidence(f, rp, lam, cp_prob):
-    n = len(f); c = f["close"].values; ef = f["ema_fast"].values; es = f["ema_slow"].values
+# ---------- Evidence ----------
+def evidence(f, rp, lam):
+    n = len(f)
+    c = f["close"].values; ef = f["ema_fast"].values; es = f["ema_slow"].values
     eff = f["efficiency"].values; mom = f["momentum"].values; am = f["atr_move"].values
     rd = f["rsi_dev"].values; dm = f["dist_ma"].values; ae = f["atr_extension"].values
     vr = f["vol_ratio"].values; bo = f["breakout"].values
@@ -251,39 +227,51 @@ def evidence(f, rp, lam, cp_prob):
         em[i] = np.tanh(s * 2.0)
         contr = max(0.0, 1.0 - vr[i])
         ec[i] = np.tanh(bo[i] * (0.5 + 0.5 * contr) * 2.0)
-    rp_blended = rp * (1.0 - cp_prob[:, None]) + (1.0 / HMM_K) * cp_prob[:, None]
-    raw = rp_blended[:, 0] * et + rp_blended[:, 1] * em + rp_blended[:, 2] * ec
+    raw = rp[:, 0] * et + rp[:, 1] * em + rp[:, 2] * ec
     acc = np.zeros(n); acc[0] = raw[0]
     for i in range(1, n): acc[i] = lam * acc[i - 1] + (1 - lam) * raw[i]
     pl = np.array([_sig(4.0 * x) for x in acc])
-    return acc, pl, 1.0 - pl, rp_blended
+    return acc, pl, 1.0 - pl
 
 
 # ---------- Signal + Backtest ----------
-def latest_signal(f, rp_blended, acc, pl, ps, thr, mconf, cp_prob):
+def latest_signal(f, rp, acc, pl, ps, thr, mconf):
     i = len(f) - 1
     if i < MIN_SIG: return None
-    p = rp_blended[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+    p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
     if conf < mconf: return None
     e, l, s = float(acc[i]), float(pl[i]), float(ps[i])
     sig = "LONG" if e > thr and l > 0.5 else "SHORT" if e < -thr and s > 0.5 else "NO TRADE"
     return {"signal": sig, "evidence": e, "P_long": l, "P_short": s,
             "regime_probs": {REGIME_NAMES[j]: float(p[j]) for j in range(HMM_K)},
             "dominant_regime": REGIME_NAMES[dom], "regime_conf": conf,
-            "changepoint": float(cp_prob[i]), "close": float(f["close"].values[i])}
+            "close": float(f["close"].values[i])}
 
 
-def backtest(sym, f, rp_blended, acc, pl, ps, thr, mconf, maxhold, cp_prob):
+def backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold):
     n = len(f); c = f["close"].values; h = f["high"].values; lo = f["low"].values
     atr = f["atr"].values
     trades = []; in_pos = False; ei = eprice = d = sp = tp = 0
     reg = ""; rconf = 0.0
-    start = min(max(int(n * TRAIN_FRAC) + PURGE + EMBARGO, 30), n - 2)
+
+    train_end = int(n * TRAIN_FRAC)
+    start = train_end + PURGE + EMBARGO
+    start = max(start, 30)
+    start = min(start, n - 2)
+
+    if start < n:
+        pass_thr = int((np.abs(acc[start:]) > thr).sum())
+        pass_conf = int((rp[start:].max(axis=1) >= mconf).sum())
+        both = int(((np.abs(acc[start:]) > thr) &
+                    (rp[start:].max(axis=1) >= mconf)).sum())
+        print(f"[BT] {sym}: n={n} start={start} window={n-start} "
+              f"thr_pass={pass_thr} conf_pass={pass_conf} both={both}",
+              flush=True)
 
     for i in range(start, n):
         if not in_pos:
-            p = rp_blended[i]; dom = int(np.argmax(p)); conf = float(p[dom])
-            if conf < mconf or cp_prob[i] > 0.5: continue
+            p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+            if conf < mconf: continue
             ed = 1 if acc[i] > thr and pl[i] > 0.5 else -1 if acc[i] < -thr and ps[i] > 0.5 else 0
             if ed == 0 or atr[i] < 1e-12: continue
             eprice = c[i] * (1.0 + SLIPPAGE * ed); d = ed; ei = i; in_pos = True
@@ -322,12 +310,13 @@ def metrics(trades):
     r = np.array([t["net_return"] for t in trades])
     w, l = r[r > 0], r[r <= 0]
     gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
-    eq = np.cumprod(1 + r); peak = np.maximum.accumulate(eq); dd = (eq - peak) / peak
+    eq = np.cumprod(1 + r); peak = np.maximum.accumulate(eq)
+    dd = (eq - peak) / peak
     longs = [t for t in trades if t["direction"] == "LONG"]
     shorts = [t for t in trades if t["direction"] == "SHORT"]
     lw = sum(1 for t in longs if t["win"]); sw = sum(1 for t in shorts if t["win"])
-    return dict(total_trades=len(r), win_rate=len(w) / len(r),
-                profit_factor=gp / gl if gl > 1e-12 else 999.0,
+    return dict(total_trades=len(r),
+                win_rate=len(w) / len(r), profit_factor=gp / gl if gl > 1e-12 else 999.0,
                 net_expectancy=float(r.mean()), avg_win=float(w.mean()) if len(w) else 0.0,
                 avg_loss=float(l.mean()) if len(l) else 0.0,
                 max_drawdown=float(dd.min()) if len(dd) else 0.0,
@@ -344,9 +333,11 @@ def regime_table(trades):
         rt = [t for t in trades if t["regime"] == reg]
         if not rt:
             rows.append({"Regime": reg, "Trades": 0, "WinRate": 0.0, "PF": 0.0, "NetExp": 0.0}); continue
-        n = np.array([t["net_return"] for t in rt]); w, l = n[n > 0], n[n <= 0]
+        n = np.array([t["net_return"] for t in rt])
+        w, l = n[n > 0], n[n <= 0]
         gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
-        rows.append({"Regime": reg, "Trades": len(rt), "WinRate": round(len(w) / len(rt), 4),
+        rows.append({"Regime": reg, "Trades": len(rt),
+                     "WinRate": round(len(w) / len(rt), 4),
                      "PF": round(gp / gl, 4) if gl > 1e-12 else 999.0,
                      "NetExp": round(float(n.mean()), 6)})
     return pd.DataFrame(rows)
@@ -357,67 +348,80 @@ def coin_table(trades):
     rows = []
     for sym in sorted({t["symbol"] for t in trades}):
         st = [t for t in trades if t["symbol"] == sym]
-        n = np.array([t["net_return"] for t in st]); w = n[n > 0]
-        rows.append({"Symbol": sym, "Trades": len(st), "WinRate": round(len(w) / len(st), 4),
-                     "NetExp": round(float(n.mean()), 6), "TotalNet": round(float(n.sum()), 6)})
+        n = np.array([t["net_return"] for t in st])
+        w = n[n > 0]
+        rows.append({"Symbol": sym, "Trades": len(st),
+                     "WinRate": round(len(w) / len(st), 4),
+                     "NetExp": round(float(n.mean()), 6),
+                     "TotalNet": round(float(n.sum()), 6)})
     return pd.DataFrame(rows).sort_values("TotalNet", ascending=False)
 
 
 # ---------- Pipeline ----------
-def run(timeframe, n_pairs, thr, lam, mconf, maxhold, progress=gr.Progress()):
+def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
     def err(msg, detail=""):
         return msg, detail, pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
-    n_pairs = max(1, min(12, int(n_pairs)))
-    thr = max(0.0, min(1.0, float(thr))); lam = max(0.0, min(0.99, float(lam)))
-    mconf = max(0.0, min(1.0, float(mconf))); maxhold = max(5, min(200, int(maxhold)))
-    if timeframe not in TF_MAP:
+    n_coins = max(30, min(30, int(n_coins)))   # sabit 30
+    thr = max(0.0, min(1.0, float(thr)))
+    lam = max(0.0, min(0.99, float(lam)))
+    mconf = max(0.0, min(1.0, float(mconf)))
+    maxhold = max(5, min(200, int(maxhold)))
+
+    if timeframe not in YF_TF:
         return err("ERROR: Invalid timeframe")
 
-    progress(0.02, desc="Selecting forex symbols...")
-    pairs = fetch_pairs(n_pairs)
+    progress(0.02, desc="Resolving yfinance pairs...")
+    try: pairs = fetch_pairs(n_coins)
+    except Exception as e: return err(f"ERROR fetching pairs: {e}")
+    if not pairs:
+        return err("ERROR: No pairs resolved.")
 
     signals, trades, analyzed, failed = [], [], 0, []
     for i, sym in enumerate(pairs):
         progress((i + 1) / len(pairs) * 0.9, desc=f"{sym} ({i+1}/{len(pairs)})")
+        time.sleep(0.25)   # yfinance rate-limit nezaketi
         df = fetch_klines(sym, timeframe)
         if df is None:
             failed.append(sym); continue
         try:
-            f = features(df); m = fit_hmm(f)
-            if m is None: failed.append(sym); continue
+            f = features(df)
+            m = fit_hmm(f)
+            if m is None:
+                print(f"[RCEA] {sym}: HMM fit failed (n={len(f)})", flush=True)
+                failed.append(sym); continue
             rp = forward_filter(m, f)
-            cp_prob = bocpd_changepoint_prob(f["ret"].values)
-            acc, pl, ps, rp_blended = evidence(f, rp, lam, cp_prob)
-            s = latest_signal(f, rp_blended, acc, pl, ps, thr, mconf, cp_prob)
+            acc, pl, ps = evidence(f, rp, lam)
+            s = latest_signal(f, rp, acc, pl, ps, thr, mconf)
             if s: s["symbol"] = sym; signals.append(s)
-            sym_trades = backtest(sym, f, rp_blended, acc, pl, ps, thr, mconf, maxhold, cp_prob)
+            sym_trades = backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold)
             trades.extend(sym_trades)
-            print(f"[RCEA] {sym}: candles={len(f)} cp_recent={cp_prob[-1]:.3f} "
-                  f"signal={s['signal'] if s else 'NONE'} trades={len(sym_trades)}", flush=True)
+            print(f"[RCEA] {sym}: candles={len(f)} signal={s['signal'] if s else 'NONE'} "
+                  f"trades={len(sym_trades)}", flush=True)
             analyzed += 1
         except Exception as e:
             print(f"[RCEA] {sym}: EXC {e}", flush=True); failed.append(sym)
     progress(1.0, desc="Done")
 
-    scan = ["# RCEA Lite — Forex + BOCPD",
-            f"**Timeframe:** {timeframe}",
-            f"**Pairs requested:** {n_pairs}",
+    scan = ["# RCEA Lite — yfinance Market Scan",
+            f"**Timeframe:** {timeframe} | **yfinance interval:** {YF_TF[timeframe][0]}",
+            f"**Coins:** {len(pairs)} (fixed list)",
             f"**Analyzed:** {analyzed}",
             f"**Failed:** {len(failed)}",
             f"**Total trades:** {len(trades)}",
             f"**Threshold:** {thr} | **λ:** {lam} | **MinConf:** {mconf} | **MaxHold:** {maxhold}",
             f"**UTC:** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}"]
     if len(trades) < 30:
-        scan.append(f"\n⚠️ Only {len(trades)} trades. Try threshold=0.04, λ=0.65, MinConf=0.25.")
+        scan.append(f"\n⚠️ Only {len(trades)} trades. Try threshold=0.04, "
+                    f"λ=0.65, MinConf=0.25.")
     scan_report = "\n".join(scan)
 
     if signals:
         sig_df = pd.DataFrame([{
             "Symbol": s["symbol"], "Signal": s["signal"],
-            "Evidence": round(s["evidence"], 4), "P(Long)": round(s["P_long"], 4),
-            "P(Short)": round(s["P_short"], 4), "Regime": s["dominant_regime"],
-            "Regime Conf": round(s["regime_conf"], 4), "Changepoint": round(s["changepoint"], 4),
+            "Evidence": round(s["evidence"], 4),
+            "P(Long)": round(s["P_long"], 4), "P(Short)": round(s["P_short"], 4),
+            "Regime": s["dominant_regime"], "Regime Conf": round(s["regime_conf"], 4),
             "P(Trend)": round(s["regime_probs"]["TREND"], 4),
             "P(MeanRev)": round(s["regime_probs"]["MEAN_REVERSION"], 4),
             "P(Compress)": round(s["regime_probs"]["COMPRESSION"], 4),
@@ -426,19 +430,20 @@ def run(timeframe, n_pairs, thr, lam, mconf, maxhold, progress=gr.Progress()):
         sig_df = sig_df.sort_values(["_p", "Evidence"], ascending=[True, False]).drop(columns="_p")
     else:
         sig_df = pd.DataFrame(columns=["Symbol", "Signal", "Evidence", "P(Long)", "P(Short)",
-                                        "Regime", "Regime Conf", "Changepoint", "P(Trend)",
-                                        "P(MeanRev)", "P(Compress)", "Close"])
+                                        "Regime", "Regime Conf", "P(Trend)", "P(MeanRev)",
+                                        "P(Compress)", "Close"])
 
     if trades:
         tr_df = pd.DataFrame([{
-            "Symbol": t["symbol"], "Direction": t["direction"], "Entry Bar": t["entry_bar"],
-            "Exit Bar": t["exit_bar"], "Bars": t["bars_held"],
+            "Symbol": t["symbol"], "Direction": t["direction"],
+            "Entry Bar": t["entry_bar"], "Exit Bar": t["exit_bar"],
+            "Bars": t["bars_held"],
             "Entry": round(t["entry_price"], 6), "Exit": round(t["exit_price"], 6),
             "Stop": round(t["stop_price"], 6), "Target": round(t["target_price"], 6),
-            "Reason": t["exit_reason"], "Gross": round(t["gross_return"], 6),
-            "Net": round(t["net_return"], 6), "Regime": t["regime"],
-            "Regime Conf": round(t["regime_conf"], 4), "Win": t["win"]} for t in trades]
-        ).sort_values(["Symbol", "Entry Bar"])
+            "Reason": t["exit_reason"],
+            "Gross": round(t["gross_return"], 6), "Net": round(t["net_return"], 6),
+            "Regime": t["regime"], "Regime Conf": round(t["regime_conf"], 4),
+            "Win": t["win"]} for t in trades]).sort_values(["Symbol", "Entry Bar"])
     else:
         tr_df = pd.DataFrame(columns=["Symbol", "Direction", "Entry Bar", "Exit Bar", "Bars",
                                        "Entry", "Exit", "Stop", "Target", "Reason",
@@ -447,10 +452,13 @@ def run(timeframe, n_pairs, thr, lam, mconf, maxhold, progress=gr.Progress()):
     m = metrics(trades)
     m_str = "\n".join([
         "# Performance Metrics (net of costs)",
-        f"**Total trades:** {m['total_trades']}", f"**Win rate:** {m['win_rate']:.2%}",
-        f"**Profit factor:** {m['profit_factor']:.3f}", f"**Net expectancy:** {m['net_expectancy']:.6f}",
+        f"**Total trades:** {m['total_trades']}",
+        f"**Win rate:** {m['win_rate']:.2%}",
+        f"**Profit factor:** {m['profit_factor']:.3f}",
+        f"**Net expectancy:** {m['net_expectancy']:.6f}",
         f"**Avg win / loss:** {m['avg_win']:.6f} / {m['avg_loss']:.6f}",
-        f"**Max DD:** {m['max_drawdown']:.2%}", f"**Net compounded:** {m['net_compounded_return']:.2%}",
+        f"**Max DD:** {m['max_drawdown']:.2%}",
+        f"**Net compounded:** {m['net_compounded_return']:.2%}",
         f"**Long:** {m['long_trades']} ({m['long_win_rate']:.2%}) | "
         f"**Short:** {m['short_trades']} ({m['short_win_rate']:.2%})",
     ])
@@ -461,13 +469,13 @@ def run(timeframe, n_pairs, thr, lam, mconf, maxhold, progress=gr.Progress()):
 
 
 # ---------- UI ----------
-with gr.Blocks(title="RCEA Lite v1.0 — Forex") as demo:
-    gr.Markdown("# RCEA Lite v1.0 — Forex Edition\n"
-                "HMM + BOCPD · Causal · No supervised ML · Data: GitHub CSV (no API key)")
+with gr.Blocks(title="RCEA Lite v1.0 — yfinance") as demo:
+    gr.Markdown("# RCEA Lite v1.0 — yfinance Edition\n"
+                "HMM regime detection (causal forward filtering) · No supervised ML · Data: Yahoo Finance")
     with gr.Row():
         with gr.Column(scale=1):
             tf = gr.Dropdown(["15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
-            nc = gr.Slider(1, 12, value=12, step=1, label="Pairs")
+            nc = gr.Slider(30, 30, value=30, step=1, label="Coins (fixed 30)")
             thr_i = gr.Slider(0.0, 1.0, value=0.06, step=0.01, label="Evidence threshold")
             lam_i = gr.Slider(0.0, 0.99, value=0.70, step=0.01, label="Memory λ")
             mc_i = gr.Slider(0.0, 1.0, value=0.30, step=0.01, label="Min regime confidence")
@@ -480,11 +488,11 @@ with gr.Blocks(title="RCEA Lite v1.0 — Forex") as demo:
         with gr.Tab("📡 Signals"): sig_tbl = gr.Dataframe(interactive=False, wrap=True)
         with gr.Tab("📜 Trades"): tr_tbl = gr.Dataframe(interactive=False, wrap=True)
         with gr.Tab("📊 Regime"): reg_tbl = gr.Dataframe(interactive=False)
-        with gr.Tab("🪙 Pairs"): coin_tbl = gr.Dataframe(interactive=False)
+        with gr.Tab("🪙 Coins"): coin_tbl = gr.Dataframe(interactive=False)
     btn.click(run, inputs=[tf, nc, thr_i, lam_i, mc_i, mh_i],
               outputs=[scan_out, met_out, sig_tbl, tr_tbl, reg_tbl, coin_tbl])
-    gr.Markdown("---\n**Data:** ejtraderLabs/historical-data (12 forex pairs, 10y OHLCV). "
-                "Net of 0.02% commission + 0.01% slippage per side.")
+    gr.Markdown("---\n**Data source:** Yahoo Finance (yfinance). "
+                "Net of 0.10% commission + 0.05% slippage per side.")
 
 
 if __name__ == "__main__":