Upload 10 files

README.md

@@ -1,10 +1,14 @@
 ---
 title: Vekalm
-emoji: 🚀
-colorFrom: pink
-colorTo: yellow
-sdk: docker
+emoji: 📈
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 5.9.1
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Vekalm — Forex + Crypto Signal Engine
+
+Gradio-based signal engine (Yahoo Finance data, no API key needed).

app.py

@@ -0,0 +1,779 @@
+"""
+============================================================================
+ PROFESSIONAL FOREX + CRYPTO INDICATOR & SIGNAL ENGINE  (single-file)
+============================================================================
+ Target      : Hugging Face Free Tier (2 vCPU / 16 GB RAM, no GPU)
+ Data source : Yahoo Finance via `yfinance` (free, no API key)
+ UI          : Gradio (works as a Hugging Face Space out of the box)
+
+ DESIGN GUARANTEES
+ -----------------
+ * NO lookahead bias  : any analysis at time T uses ONLY candles whose
+                        close time is <= T. The forming candle is dropped.
+ * NO repainting      : swing pivots require N confirmation bars, all
+                        higher-timeframe data is shifted by one full
+                        HTF bar before being merged down.
+ * Memory efficient   : float32 columns, bounded cache, capped history.
+ * CPU efficient      : fully vectorised numpy/pandas indicator and
+                        scoring pipeline (no per-bar Python loops except
+                        the trade simulator, which is O(n)).
+
+ HONEST LIMITATIONS
+ ------------------
+ * Yahoo Finance intraday history is limited (~7 days for 1m,
+   ~60 days for 2m-1h). Deep intraday backtests are not possible
+   with free data.
+ * Forex volume from Yahoo is unreliable/absent -> volume confirmation
+   is automatically skipped when volume is missing.
+ * No signal engine can guarantee profit. This engine maximises
+   robustness via multi-factor confirmation, but markets are
+   non-stationary: past performance never guarantees future results.
+============================================================================
+"""
+
+from __future__ import annotations
+
+import math
+import threading
+import time as _time
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+try:
+    import yfinance as yf
+except ImportError as _e:  # pragma: no cover
+    raise SystemExit("Missing dependency. Run:  pip install yfinance gradio pandas numpy") from _e
+
+# ============================================================================
+# 1. CONFIGURATION
+# ============================================================================
+
+# timeframe -> (yfinance base interval, resample rule or None, pandas offset)
+TIMEFRAMES: dict[str, tuple[str, Optional[str], timedelta]] = {
+    "1m":  ("1m",  None,   timedelta(minutes=1)),
+    "2m":  ("2m",  None,   timedelta(minutes=2)),
+    "5m":  ("5m",  None,   timedelta(minutes=5)),
+    "10m": ("5m",  "10min", timedelta(minutes=10)),   # resampled from 5m
+    "15m": ("15m", None,   timedelta(minutes=15)),
+    "30m": ("30m", None,   timedelta(minutes=30)),
+    "1h":  ("60m", None,   timedelta(hours=1)),
+    "2h":  ("60m", "2h",   timedelta(hours=2)),       # resampled from 1h
+    "1d":  ("1d",  None,   timedelta(days=1)),
+    "2d":  ("1d",  "2D",   timedelta(days=2)),        # resampled from 1d
+    "5d":  ("1d",  "5D",   timedelta(days=5)),        # resampled from 1d
+}
+
+# max lookback yfinance allows per base interval
+MAX_PERIOD: dict[str, str] = {
+    "1m": "7d", "2m": "60d", "5m": "60d", "15m": "60d",
+    "30m": "60d", "60m": "730d", "1d": "max",
+}
+
+# higher timeframe used for multi-timeframe confirmation
+HTF_MAP: dict[str, str] = {
+    "1m": "15m", "2m": "15m", "5m": "30m", "10m": "1h", "15m": "1h",
+    "30m": "2h", "1h": "1d", "2h": "1d", "1d": "5d", "2d": "5d", "5d": "5d",
+}
+
+RISK_PROFILES: dict[str, dict[str, float]] = {
+    "Conservative": {"sl_atr": 2.0, "rr": 1.5, "min_adx": 22.0},
+    "Balanced":     {"sl_atr": 1.5, "rr": 2.0, "min_adx": 18.0},
+    "Aggressive":   {"sl_atr": 1.2, "rr": 2.5, "min_adx": 14.0},
+}
+
+PIVOT_CONFIRM = 3          # bars needed to confirm a swing pivot (anti-repaint)
+MAX_ROWS = 20_000          # hard cap on candles kept in memory per dataframe
+CACHE_TTL = 55.0           # seconds a downloaded dataframe stays fresh
+CACHE_MAX_ENTRIES = 24     # bounded cache -> bounded memory
+
+POPULAR_SYMBOLS = [
+    "EURUSD=X", "GBPUSD=X", "USDJPY=X", "AUDUSD=X", "USDCAD=X", "USDCHF=X",
+    "NZDUSD=X", "EURGBP=X", "EURJPY=X", "GBPJPY=X",
+    "BTC-USD", "ETH-USD", "SOL-USD", "BNB-USD", "XRP-USD", "ADA-USD",
+    "DOGE-USD", "AVAX-USD", "DOT-USD", "LINK-USD",
+]
+
+# ============================================================================
+# 2. DATA FEED  (download + resample + bounded cache)
+# ============================================================================
+
+class DataFeed:
+    """Thread-safe, TTL-bounded market data feed built on yfinance."""
+
+    def __init__(self) -> None:
+        self._cache: dict[tuple[str, str], tuple[float, pd.DataFrame]] = {}
+        self._lock = threading.Lock()
+
+    # ---- public ------------------------------------------------------
+
+    def get(self, symbol: str, timeframe: str) -> pd.DataFrame:
+        """Return an OHLCV dataframe (UTC index) for symbol/timeframe."""
+        symbol = symbol.strip().upper()
+        if timeframe not in TIMEFRAMES:
+            raise ValueError(f"Unsupported timeframe '{timeframe}'.")
+        key = (symbol, timeframe)
+        now = _time.time()
+        with self._lock:
+            hit = self._cache.get(key)
+            if hit and now - hit[0] < CACHE_TTL:
+                return hit[1]
+        df = self._download(symbol, timeframe)
+        with self._lock:
+            if len(self._cache) >= CACHE_MAX_ENTRIES:
+                oldest = min(self._cache, key=lambda k: self._cache[k][0])
+                self._cache.pop(oldest, None)
+            self._cache[key] = (now, df)
+        return df
+
+    # ---- internals ---------------------------------------------------
+
+    @staticmethod
+    def _download(symbol: str, timeframe: str) -> pd.DataFrame:
+        base, rule, _ = TIMEFRAMES[timeframe]
+        period = MAX_PERIOD[base]
+        raw = yf.download(
+            tickers=symbol, interval=base, period=period,
+            auto_adjust=False, progress=False, threads=False,
+        )
+        if raw is None or raw.empty:
+            raise ValueError(
+                f"No data returned for '{symbol}'. "
+                "Check the symbol (forex: 'EURUSD=X', crypto: 'BTC-USD')."
+            )
+        if isinstance(raw.columns, pd.MultiIndex):
+            raw.columns = raw.columns.get_level_values(0)
+        df = raw[["Open", "High", "Low", "Close", "Volume"]].copy()
+        df.columns = ["open", "high", "low", "close", "volume"]
+        df = df.dropna(subset=["open", "high", "low", "close"])
+        # normalise index to UTC
+        idx = pd.DatetimeIndex(df.index)
+        df.index = idx.tz_convert("UTC") if idx.tz is not None else idx.tz_localize("UTC")
+        df = df[~df.index.duplicated(keep="last")].sort_index()
+        if rule:
+            df = (
+                df.resample(rule, label="left", closed="left")
+                .agg({"open": "first", "high": "max", "low": "min",
+                      "close": "last", "volume": "sum"})
+                .dropna(subset=["open", "high", "low", "close"])
+            )
+        for c in ("open", "high", "low", "close", "volume"):
+            df[c] = df[c].astype(np.float32)
+        if len(df) > MAX_ROWS:
+            df = df.iloc[-MAX_ROWS:]
+        return df
+
+
+FEED = DataFeed()
+
+
+def slice_no_lookahead(df: pd.DataFrame, timeframe: str,
+                       as_of: Optional[datetime]) -> pd.DataFrame:
+    """
+    Keep only candles fully CLOSED at `as_of`.
+    A candle opening at t with interval dt is usable only if t + dt <= as_of.
+    Passing None means "now" (the forming candle is still dropped).
+    """
+    dt = TIMEFRAMES[timeframe][2]
+    cutoff = (as_of or datetime.now(timezone.utc))
+    if cutoff.tzinfo is None:
+        cutoff = cutoff.replace(tzinfo=timezone.utc)
+    return df[df.index + dt <= cutoff]
+
+# ============================================================================
+# 3. INDICATORS  (all vectorised, all causal)
+# ============================================================================
+
+def _ema(s: pd.Series, n: int) -> pd.Series:
+    return s.ewm(span=n, adjust=False, min_periods=n).mean()
+
+
+def _rma(s: pd.Series, n: int) -> pd.Series:
+    """Wilder's smoothing (used by RSI / ATR / ADX)."""
+    return s.ewm(alpha=1.0 / n, adjust=False, min_periods=n).mean()
+
+
+def add_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    """Attach every indicator column. Pure function of PAST data only."""
+    o, h, l, c, v = df["open"], df["high"], df["low"], df["close"], df["volume"]
+
+    df["ema20"] = _ema(c, 20)
+    df["ema50"] = _ema(c, 50)
+    df["ema200"] = _ema(c, 200)
+
+    # RSI(14)
+    delta = c.diff()
+    gain = _rma(delta.clip(lower=0), 14)
+    loss = _rma((-delta).clip(lower=0), 14)
+    rs = gain / loss.replace(0, np.nan)
+    df["rsi"] = 100 - 100 / (1 + rs)
+
+    # MACD(12,26,9)
+    macd = _ema(c, 12) - _ema(c, 26)
+    sig = macd.ewm(span=9, adjust=False, min_periods=9).mean()
+    df["macd"], df["macd_sig"], df["macd_hist"] = macd, sig, macd - sig
+
+    # True range / ATR(14)
+    prev_c = c.shift(1)
+    tr = pd.concat([h - l, (h - prev_c).abs(), (l - prev_c).abs()], axis=1).max(axis=1)
+    df["atr"] = _rma(tr, 14)
+
+    # ADX(14)
+    up, dn = h.diff(), -l.diff()
+    plus_dm = pd.Series(np.where((up > dn) & (up > 0), up, 0.0), index=df.index)
+    minus_dm = pd.Series(np.where((dn > up) & (dn > 0), dn, 0.0), index=df.index)
+    atr_safe = df["atr"].replace(0, np.nan)
+    pdi = 100 * _rma(plus_dm, 14) / atr_safe
+    mdi = 100 * _rma(minus_dm, 14) / atr_safe
+    dx = 100 * (pdi - mdi).abs() / (pdi + mdi).replace(0, np.nan)
+    df["pdi"], df["mdi"], df["adx"] = pdi, mdi, _rma(dx, 14)
+
+    # Bollinger(20, 2)
+    mid = c.rolling(20).mean()
+    std = c.rolling(20).std(ddof=0)
+    df["bb_mid"], df["bb_up"], df["bb_lo"] = mid, mid + 2 * std, mid - 2 * std
+    df["bb_width"] = (df["bb_up"] - df["bb_lo"]) / mid.replace(0, np.nan)
+
+    # Rolling VWAP(50) — session VWAP is meaningless for 24h markets
+    has_volume = bool((v > 0).mean() > 0.5)
+    df.attrs["has_volume"] = has_volume
+    if has_volume:
+        tp = (h + l + c) / 3
+        pv = (tp * v).rolling(50).sum()
+        vv = v.rolling(50).sum().replace(0, np.nan)
+        df["vwap"] = pv / vv
+        df["vol_ma"] = v.rolling(20).mean()
+    else:
+        df["vwap"] = np.nan
+        df["vol_ma"] = np.nan
+
+    # --- Confirmed swing pivots (anti-repaint: confirmed PIVOT_CONFIRM bars later)
+    k = PIVOT_CONFIRM
+    win = 2 * k + 1
+    roll_max = h.rolling(win, center=True).max()
+    roll_min = l.rolling(win, center=True).min()
+    is_ph = (h == roll_max)
+    is_pl = (l == roll_min)
+    # value known only k bars AFTER the pivot -> shift by k
+    ph = h.where(is_ph).shift(k)
+    pl = l.where(is_pl).shift(k)
+    df["last_ph"] = ph.ffill()          # most recent CONFIRMED swing high
+    df["last_pl"] = pl.ffill()          # most recent CONFIRMED swing low
+    df["prev_ph"] = ph.dropna().shift(1).reindex(df.index).ffill()
+    df["prev_pl"] = pl.dropna().shift(1).reindex(df.index).ffill()
+
+    # --- Candlestick patterns (vectorised, causal)
+    body = (c - o).abs()
+    rng = (h - l).replace(0, np.nan)
+    upper = h - np.maximum(c, o)
+    lower = np.minimum(c, o) - l
+    po, pc = o.shift(1), c.shift(1)
+    df["pat_bull_engulf"] = ((pc < po) & (c > o) & (c >= po) & (o <= pc)).astype(np.int8)
+    df["pat_bear_engulf"] = ((pc > po) & (c < o) & (c <= po) & (o >= pc)).astype(np.int8)
+    df["pat_hammer"] = ((lower > 2 * body) & (upper < body) & (body / rng < 0.4)).astype(np.int8)
+    df["pat_star"] = ((upper > 2 * body) & (lower < body) & (body / rng < 0.4)).astype(np.int8)
+    return df
+
+# ============================================================================
+# 4. SCORING ENGINE  (vectorised multi-factor confluence, -100 .. +100)
+# ============================================================================
+
+WEIGHTS = {
+    "trend": 28.0, "momentum": 22.0, "structure": 20.0,
+    "location": 14.0, "pattern": 8.0, "volume": 8.0,
+}
+
+
+def compute_scores(df: pd.DataFrame) -> pd.DataFrame:
+    """Attach per-factor scores in [-1, 1] and total 'score' in [-100, 100]."""
+    c = df["close"]
+    n = len(df)
+    z = lambda: np.zeros(n, dtype=np.float32)
+
+    # ---- Trend: EMA stack + ADX direction
+    t = z()
+    t += np.where(c > df["ema20"], 0.25, -0.25)
+    t += np.where(df["ema20"] > df["ema50"], 0.25, -0.25)
+    t += np.where(df["ema50"] > df["ema200"], 0.25, -0.25)
+    adx_dir = np.sign((df["pdi"] - df["mdi"]).to_numpy(np.float32))
+    adx_str = np.clip((df["adx"].to_numpy(np.float32) - 15) / 25, 0, 1)
+    t += 0.25 * adx_dir * adx_str
+    df["s_trend"] = np.clip(t, -1, 1)
+
+    # ---- Momentum: RSI regime + MACD histogram
+    rsi = df["rsi"].to_numpy(np.float32)
+    m = z()
+    m += np.clip((rsi - 50) / 25, -1, 1) * 0.5
+    hist = df["macd_hist"].to_numpy(np.float32)
+    atr = df["atr"].to_numpy(np.float32)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        m += np.clip(np.nan_to_num(hist / (atr * 0.5)), -1, 1) * 0.5
+    # fade extremes: overbought longs / oversold shorts are penalised
+    m = np.where((rsi > 74) & (m > 0), m * 0.3, m)
+    m = np.where((rsi < 26) & (m < 0), m * 0.3, m)
+    df["s_momentum"] = np.clip(m, -1, 1)
+
+    # ---- Market structure: HH/HL vs LH/LL from confirmed pivots
+    hh = (df["last_ph"] > df["prev_ph"]).to_numpy()
+    hl = (df["last_pl"] > df["prev_pl"]).to_numpy()
+    lh = (df["last_ph"] < df["prev_ph"]).to_numpy()
+    ll = (df["last_pl"] < df["prev_pl"]).to_numpy()
+    s = z()
+    s = np.where(hh & hl, 1.0, s)
+    s = np.where(lh & ll, -1.0, s)
+    s = np.where(hh & ~hl, 0.4, s)
+    s = np.where(ll & ~lh, -0.4, s)
+    df["s_structure"] = s
+
+    # ---- Location: distance to confirmed S/R + Bollinger position
+    cv = c.to_numpy(np.float32)
+    atr_safe = np.where(atr > 0, atr, np.nan)
+    d_res = (df["last_ph"].to_numpy(np.float32) - cv) / atr_safe   # room above
+    d_sup = (cv - df["last_pl"].to_numpy(np.float32)) / atr_safe   # room below
+    loc = z()
+    loc += np.clip(np.nan_to_num(d_res) / 3, -1, 1) * 0.5   # room to run up
+    loc -= np.clip(np.nan_to_num(d_sup) / 3, -1, 1) * 0.5   # room to run down
+    bb_rng = (df["bb_up"] - df["bb_lo"]).to_numpy(np.float32)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        bb_pos = np.nan_to_num((cv - df["bb_lo"].to_numpy(np.float32)) / bb_rng, nan=0.5)
+    loc += (0.5 - np.clip(bb_pos, 0, 1))          # cheap = bullish location
+    df["s_location"] = np.clip(loc, -1, 1)
+
+    # ---- Candle patterns
+    p = z()
+    p += 0.6 * df["pat_bull_engulf"].to_numpy(np.float32)
+    p -= 0.6 * df["pat_bear_engulf"].to_numpy(np.float32)
+    p += 0.4 * df["pat_hammer"].to_numpy(np.float32)
+    p -= 0.4 * df["pat_star"].to_numpy(np.float32)
+    df["s_pattern"] = np.clip(p, -1, 1)
+
+    # ---- Volume confirmation (skipped when volume is unavailable)
+    if df.attrs.get("has_volume"):
+        with np.errstate(divide="ignore", invalid="ignore"):
+            vr = np.nan_to_num(df["volume"].to_numpy(np.float32)
+                               / df["vol_ma"].to_numpy(np.float32), nan=1.0)
+        candle_dir = np.sign((df["close"] - df["open"]).to_numpy(np.float32))
+        df["s_volume"] = np.clip(candle_dir * np.clip(vr - 1, -0.8, 1.5), -1, 1)
+        vwap_bias = np.sign(cv - df["vwap"].to_numpy(np.float32))
+        df["s_volume"] = np.clip(df["s_volume"] + 0.25 * np.nan_to_num(vwap_bias), -1, 1)
+    else:
+        df["s_volume"] = 0.0
+
+    total = z()
+    for name, w in WEIGHTS.items():
+        total += w * df[f"s_{name}"].to_numpy(np.float32)
+    df["score"] = np.clip(total, -100, 100)
+
+    # ---- Regime / noise filters (kill signals in bad conditions)
+    bbw = df["bb_width"].to_numpy(np.float32)
+    bbw_med = df["bb_width"].rolling(100, min_periods=30).median().to_numpy(np.float32)
+    squeeze = bbw < bbw_med * 0.55                 # dead / illiquid market
+    atr_pct = atr / np.where(cv > 0, cv, np.nan)
+    spike = atr_pct > np.nanmedian(atr_pct) * 4    # abnormal volatility spike
+    df["filter_ok"] = (~squeeze & ~np.nan_to_num(spike, nan=True)).astype(np.int8)
+    return df
+
+
+def htf_trend_series(symbol: str, base_tf: str,
+                     base_index: pd.DatetimeIndex) -> pd.Series:
+    """
+    Higher-timeframe trend (-1/0/+1) aligned onto the base timeframe index.
+    Shifted by ONE full HTF bar so only fully closed HTF candles are used.
+    """
+    htf = HTF_MAP[base_tf]
+    try:
+        hdf = FEED.get(symbol, htf)
+    except Exception:
+        return pd.Series(0.0, index=base_index)
+    if len(hdf) < 60:
+        return pd.Series(0.0, index=base_index)
+    e_fast = _ema(hdf["close"], 20)
+    e_slow = _ema(hdf["close"], 50)
+    trend = pd.Series(
+        np.sign((e_fast - e_slow).to_numpy(np.float32)), index=hdf.index
+    ).shift(1)                                        # anti-lookahead shift
+    # HTF bar timestamped t is usable only after t + htf_interval
+    trend.index = trend.index + TIMEFRAMES[htf][2]
+    return trend.reindex(trend.index.union(base_index)).ffill().reindex(base_index).fillna(0.0)
+
+# ============================================================================
+# 5. SIGNAL CONSTRUCTION
+# ============================================================================
+
+@dataclass
+class Signal:
+    symbol: str
+    timeframe: str
+    time: pd.Timestamp
+    action: str                 # BUY / SELL / HOLD
+    confidence: float           # 0..100
+    score: float
+    entry: float = 0.0
+    stop: float = 0.0
+    target: float = 0.0
+    rr: float = 0.0
+    reasons: list[str] = field(default_factory=list)
+    components: dict[str, float] = field(default_factory=dict)
+    htf_trend: float = 0.0
+    filtered: bool = False
+
+
+def build_signal(df: pd.DataFrame, symbol: str, timeframe: str,
+                 threshold: float, risk: str,
+                 htf: pd.Series) -> Signal:
+    """Build the signal for the LAST (most recent fully closed) candle."""
+    row = df.iloc[-1]
+    ts = df.index[-1]
+    profile = RISK_PROFILES[risk]
+    score = float(row["score"])
+    comp = {k: round(float(row[f"s_{k}"]), 2) for k in WEIGHTS}
+    ht = float(htf.iloc[-1]) if len(htf) else 0.0
+
+    sig = Signal(symbol=symbol, timeframe=timeframe, time=ts, action="HOLD",
+                 confidence=0.0, score=round(score, 1), components=comp, htf_trend=ht)
+
+    reasons: list[str] = []
+    direction = 1 if score >= threshold else (-1 if score <= -threshold else 0)
+
+    if direction == 0:
+        reasons.append(f"Confluence score {score:+.1f} inside neutral band ±{threshold:.0f}.")
+    if not bool(row["filter_ok"]):
+        sig.filtered = True
+        reasons.append("Regime filter active: volatility squeeze or abnormal spike — standing aside.")
+        direction = 0
+    if direction != 0 and float(row["adx"]) < profile["min_adx"]:
+        reasons.append(f"ADX {row['adx']:.1f} below {profile['min_adx']:.0f} minimum ({risk}) — trend too weak.")
+        direction = 0
+    if direction != 0 and ht != 0 and np.sign(direction) != np.sign(ht):
+        reasons.append(f"Higher timeframe ({HTF_MAP[timeframe]}) trend opposes the signal — vetoed.")
+        direction = 0
+
+    if direction == 0:
+        sig.reasons = reasons or ["No edge detected at this candle."]
+        return sig
+
+    atr = float(row["atr"])
+    entry = float(row["close"])
+    sl_dist = profile["sl_atr"] * atr
+    # anchor stop behind confirmed structure when it is tighter than pure ATR
+    if direction > 0 and not math.isnan(row["last_pl"]):
+        sl_dist = min(sl_dist * 1.4, max(sl_dist, entry - float(row["last_pl"]) + 0.25 * atr))
+    if direction < 0 and not math.isnan(row["last_ph"]):
+        sl_dist = min(sl_dist * 1.4, max(sl_dist, float(row["last_ph"]) - entry + 0.25 * atr))
+    tp_dist = sl_dist * profile["rr"]
+
+    sig.action = "BUY" if direction > 0 else "SELL"
+    sig.entry = entry
+    sig.stop = entry - direction * sl_dist
+    sig.target = entry + direction * tp_dist
+    sig.rr = round(tp_dist / sl_dist, 2)
+
+    conf = min(abs(score), 100.0)
+    if ht != 0 and np.sign(ht) == direction:
+        conf = min(conf + 10, 100)
+        reasons.append(f"Higher timeframe ({HTF_MAP[timeframe]}) trend agrees (+10 confidence).")
+    sig.confidence = round(conf, 1)
+
+    label = {"trend": "Trend", "momentum": "Momentum", "structure": "Structure",
+             "location": "S/R location", "pattern": "Candles", "volume": "Volume"}
+    for k, val in comp.items():
+        if val * direction > 0.15:
+            reasons.append(f"{label[k]} supports {sig.action} ({val:+.2f}).")
+        elif val * direction < -0.15:
+            reasons.append(f"{label[k]} disagrees ({val:+.2f}) — sized into confidence.")
+    reasons.append(f"ADX {row['adx']:.1f} confirms a tradeable trend regime.")
+    sig.reasons = reasons
+    return sig
+
+# ============================================================================
+# 6. BACKTESTER  (bar-by-bar replay of the exact same signal logic)
+# ============================================================================
+
+@dataclass
+class BacktestResult:
+    trades: pd.DataFrame
+    stats: dict[str, float | int | str]
+    monthly: pd.DataFrame
+
+
+def run_backtest(df: pd.DataFrame, htf: pd.Series, threshold: float,
+                 risk: str, max_hold: int = 200) -> BacktestResult:
+    """
+    Replays history: a signal on candle i is entered at the OPEN of candle
+    i+1 (no cheating), then walked forward until SL/TP/max-hold using
+    conservative intrabar assumptions (if both SL & TP touch -> count SL).
+    Results are reported in R-multiples (risk-normalised, symbol agnostic).
+    """
+    profile = RISK_PROFILES[risk]
+    sc = df["score"].to_numpy(np.float32)
+    adx = df["adx"].to_numpy(np.float32)
+    fok = df["filter_ok"].to_numpy(bool)
+    atr = df["atr"].to_numpy(np.float32)
+    o = df["open"].to_numpy(np.float32)
+    h = df["high"].to_numpy(np.float32)
+    l = df["low"].to_numpy(np.float32)
+    c = df["close"].to_numpy(np.float32)
+    ht = htf.reindex(df.index).fillna(0.0).to_numpy(np.float32)
+
+    long_ok = (sc >= threshold) & fok & (adx >= profile["min_adx"]) & (ht >= 0)
+    short_ok = (sc <= -threshold) & fok & (adx >= profile["min_adx"]) & (ht <= 0)
+
+    rows = []
+    n = len(df)
+    i = 200                                     # warmup for EMA200
+    while i < n - 2:
+        d = 1 if long_ok[i] else (-1 if short_ok[i] else 0)
+        if d == 0 or not np.isfinite(atr[i]) or atr[i] <= 0:
+            i += 1
+            continue
+        entry = o[i + 1]
+        sl_dist = profile["sl_atr"] * atr[i]
+        tp_dist = sl_dist * profile["rr"]
+        sl = entry - d * sl_dist
+        tp = entry + d * tp_dist
+        outcome, exit_px, j = 0.0, c[min(i + max_hold, n - 1)], i + 1
+        for j in range(i + 1, min(i + 1 + max_hold, n)):
+            hit_sl = l[j] <= sl if d > 0 else h[j] >= sl
+            hit_tp = h[j] >= tp if d > 0 else l[j] <= tp
+            if hit_sl:                          # conservative: SL first
+                outcome, exit_px = -1.0, sl
+                break
+            if hit_tp:
+                outcome, exit_px = profile["rr"], tp
+                break
+        else:
+            j = min(i + max_hold, n - 1)
+            exit_px = c[j]
+            outcome = d * (exit_px - entry) / sl_dist
+        rows.append({
+            "entry_time": df.index[i + 1], "exit_time": df.index[j],
+            "side": "BUY" if d > 0 else "SELL", "entry": float(entry),
+            "exit": float(exit_px), "r_multiple": round(float(outcome), 3),
+            "bars_held": int(j - i),
+        })
+        i = j + 1                               # one position at a time
+
+    trades = pd.DataFrame(rows)
+    if trades.empty:
+        return BacktestResult(trades, {"trades": 0, "note": "No trades generated — try a lower threshold."}, pd.DataFrame())
+
+    r = trades["r_multiple"].to_numpy()
+    wins, losses = r[r > 0], r[r <= 0]
+    equity = np.cumsum(r)
+    peak = np.maximum.accumulate(equity)
+    dd = equity - peak
+    gross_w = wins.sum() if len(wins) else 0.0
+    gross_l = -losses.sum() if len(losses) else 0.0
+
+    def _streak(mask: np.ndarray) -> int:
+        best = cur = 0
+        for m in mask:
+            cur = cur + 1 if m else 0
+            best = max(best, cur)
+        return best
+
+    stats = {
+        "trades": int(len(r)),
+        "win_rate_%": round(100 * len(wins) / len(r), 1),
+        "loss_rate_%": round(100 * len(losses) / len(r), 1),
+        "profit_factor": round(gross_w / gross_l, 2) if gross_l > 0 else float("inf"),
+        "expectancy_R": round(float(r.mean()), 3),
+        "avg_win_R": round(float(wins.mean()), 3) if len(wins) else 0.0,
+        "avg_loss_R": round(float(losses.mean()), 3) if len(losses) else 0.0,
+        "total_R": round(float(r.sum()), 2),
+        "max_drawdown_R": round(float(dd.min()), 2),
+        "sharpe_like": round(float(r.mean() / r.std() * math.sqrt(len(r))), 2) if r.std() > 0 else 0.0,
+        "max_consec_wins": _streak(r > 0),
+        "max_consec_losses": _streak(r <= 0),
+        "avg_bars_held": round(float(trades["bars_held"].mean()), 1),
+    }
+    monthly = (
+        trades.set_index("entry_time")["r_multiple"]
+        .resample("ME").agg(["count", "sum"])
+        .rename(columns={"count": "trades", "sum": "net_R"}).round(2)
+    )
+    monthly = monthly[monthly["trades"] > 0]
+    return BacktestResult(trades, stats, monthly)
+
+# ============================================================================
+# 7. HIGH-LEVEL API
+# ============================================================================
+
+def analyze(symbol: str, timeframe: str, as_of_text: str,
+            threshold: float, risk: str) -> Signal:
+    as_of = _parse_time(as_of_text)
+    df = slice_no_lookahead(FEED.get(symbol, timeframe), timeframe, as_of)
+    if len(df) < 220:
+        raise ValueError(
+            f"Only {len(df)} closed candles available at that time — need ≥220 "
+            "(EMA200 warmup). Pick a later time or a smaller timeframe."
+        )
+    df = compute_scores(add_indicators(df.copy()))
+    htf = htf_trend_series(symbol, timeframe, df.index)
+    return build_signal(df, symbol.upper(), timeframe, threshold, risk, htf)
+
+
+def backtest(symbol: str, timeframe: str, threshold: float, risk: str,
+             lookback_bars: int) -> BacktestResult:
+    df = slice_no_lookahead(FEED.get(symbol, timeframe), timeframe, None)
+    if lookback_bars > 0:
+        df = df.iloc[-min(lookback_bars, len(df)):]
+    if len(df) < 260:
+        raise ValueError(f"Only {len(df)} candles available — not enough for a meaningful backtest.")
+    df = compute_scores(add_indicators(df.copy()))
+    htf = htf_trend_series(symbol, timeframe, df.index)
+    return run_backtest(df, htf, threshold, risk)
+
+
+def _parse_time(text: str) -> Optional[datetime]:
+    text = (text or "").strip()
+    if not text or text.lower() in ("now", "latest", "live"):
+        return None
+    for fmt in ("%Y-%m-%d %H:%M", "%Y-%m-%d %H:%M:%S", "%Y-%m-%d", "%d-%m-%Y %H:%M", "%H:%M"):
+        try:
+            dt = datetime.strptime(text, fmt)
+            if fmt == "%H:%M":                       # today at HH:MM UTC
+                now = datetime.now(timezone.utc)
+                return now.replace(hour=dt.hour, minute=dt.minute, second=0, microsecond=0)
+            return dt.replace(tzinfo=timezone.utc)
+        except ValueError:
+            continue
+    raise ValueError("Time format not recognised. Use 'YYYY-MM-DD HH:MM' (UTC), 'HH:MM', or leave blank for live.")
+
+# ============================================================================
+# 8. GRADIO UI
+# ============================================================================
+
+def _fmt_price(x: float) -> str:
+    if x == 0:
+        return "-"
+    return f"{x:.6f}" if abs(x) < 10 else f"{x:,.4f}" if abs(x) < 1000 else f"{x:,.2f}"
+
+
+def _signal_md(s: Signal) -> str:
+    icon = {"BUY": "🟢", "SELL": "🔴", "HOLD": "🟡"}[s.action]
+    lines = [
+        f"## {icon} {s.action} — {s.symbol} ({s.timeframe})",
+        f"**Candle close (UTC):** {s.time}",
+        f"**Confluence score:** {s.score:+.1f} / ±100   |   **Confidence:** {s.confidence:.1f}%",
+        "",
+    ]
+    if s.action != "HOLD":
+        lines += [
+            "| Entry | Stop Loss | Take Profit | R : R |",
+            "|---|---|---|---|",
+            f"| {_fmt_price(s.entry)} | {_fmt_price(s.stop)} | {_fmt_price(s.target)} | 1 : {s.rr} |",
+            "",
+        ]
+    lines.append("**Factor breakdown** (−1 bearish … +1 bullish):")
+    lines.append("| Trend | Momentum | Structure | Location | Candles | Volume | HTF |")
+    lines.append("|---|---|---|---|---|---|---|")
+    c = s.components
+    htf_lbl = "Up" if s.htf_trend > 0 else "Down" if s.htf_trend < 0 else "Flat"
+    lines.append(
+        f"| {c['trend']:+.2f} | {c['momentum']:+.2f} | {c['structure']:+.2f} "
+        f"| {c['location']:+.2f} | {c['pattern']:+.2f} | {c['volume']:+.2f} | {htf_lbl} |"
+    )
+    lines.append("\n**Reasoning:**")
+    lines += [f"- {r}" for r in s.reasons]
+    lines.append("\n> ⚠️ Educational tool. No signal engine guarantees profit — always manage risk.")
+    return "\n".join(lines)
+
+
+def _stats_md(res: BacktestResult, symbol: str, timeframe: str) -> str:
+    if not res.stats.get("trades"):
+        return f"### Backtest — {symbol} ({timeframe})\n\n{res.stats.get('note', 'No trades.')}"
+    st = res.stats
+    lines = [
+        f"### Backtest — {symbol} ({timeframe})",
+        "",
+        "| Metric | Value | Metric | Value |",
+        "|---|---|---|---|",
+        f"| Trades | {st['trades']} | Win rate | {st['win_rate_%']}% |",
+        f"| Profit factor | {st['profit_factor']} | Expectancy | {st['expectancy_R']} R |",
+        f"| Total | {st['total_R']} R | Max drawdown | {st['max_drawdown_R']} R |",
+        f"| Avg win | {st['avg_win_R']} R | Avg loss | {st['avg_loss_R']} R |",
+        f"| Sharpe-like | {st['sharpe_like']} | Avg bars held | {st['avg_bars_held']} |",
+        f"| Max consec. wins | {st['max_consec_wins']} | Max consec. losses | {st['max_consec_losses']} |",
+    ]
+    if not res.monthly.empty:
+        lines += ["", "**Monthly:**", "", "| Month | Trades | Net R |", "|---|---|---|"]
+        for ts, row in res.monthly.iterrows():
+            lines.append(f"| {ts.strftime('%Y-%m')} | {int(row['trades'])} | {row['net_R']:+.2f} |")
+    lines.append("\n> Results are in R-multiples with conservative intrabar assumptions (ambiguous bars count as losses). Free Yahoo data limits intraday history depth.")
+    return "\n".join(lines)
+
+
+def launch_ui() -> None:
+    import gradio as gr
+
+    def ui_analyze(symbol, custom, timeframe, when, threshold, risk):
+        try:
+            sym = (custom or "").strip() or symbol
+            return _signal_md(analyze(sym, timeframe, when, float(threshold), risk))
+        except Exception as e:
+            return f"### ❌ Error\n\n{e}"
+
+    def ui_backtest(symbol, custom, timeframe, threshold, risk, bars):
+        try:
+            sym = (custom or "").strip() or symbol
+            res = backtest(sym, timeframe, float(threshold), risk, int(bars))
+            trades_df = res.trades.tail(200) if not res.trades.empty else pd.DataFrame()
+            return _stats_md(res, sym.upper(), timeframe), trades_df
+        except Exception as e:
+            return f"### ❌ Error\n\n{e}", pd.DataFrame()
+
+    def ui_compare(symbol, custom, threshold, risk, bars):
+        sym = (custom or "").strip() or symbol
+        rows = []
+        for tf in ("15m", "30m", "1h", "1d"):
+            try:
+                st = backtest(sym, tf, float(threshold), risk, int(bars)).stats
+                if st.get("trades"):
+                    rows.append({"timeframe": tf, **{k: st[k] for k in
+                                 ("trades", "win_rate_%", "profit_factor", "expectancy_R", "total_R", "max_drawdown_R")}})
+                else:
+                    rows.append({"timeframe": tf, "trades": 0})
+            except Exception as e:
+                rows.append({"timeframe": tf, "trades": f"error: {e}"})
+        return pd.DataFrame(rows)
+
+    with gr.Blocks(title="Forex + Crypto Signal Engine") as demo:
+        gr.Markdown("# 📈 Forex + Crypto Signal Engine\n"
+                    "Multi-factor confluence signals with strict no-lookahead / no-repaint guarantees. "
+                    "Data: Yahoo Finance (free). Educational use only.")
+        with gr.Row():
+            sym_dd = gr.Dropdown(POPULAR_SYMBOLS, value="BTC-USD", label="Symbol")
+            sym_tx = gr.Textbox(label="…or custom symbol", placeholder="e.g. EURUSD=X, PEPE24478-USD")
+            tf_dd = gr.Dropdown(list(TIMEFRAMES), value="15m", label="Timeframe")
+        with gr.Row():
+            thr = gr.Slider(15, 70, value=35, step=1, label="Signal threshold (higher = fewer, stronger signals)")
+            risk = gr.Radio(list(RISK_PROFILES), value="Balanced", label="Risk profile")
+
+        with gr.Tab("🔍 Signal (live or historical)"):
+            when = gr.Textbox(label="Analysis time — UTC (blank = live)",
+                              placeholder="YYYY-MM-DD HH:MM  or  HH:MM  or blank")
+            btn_a = gr.Button("Analyze", variant="primary")
+            out_a = gr.Markdown()
+            btn_a.click(ui_analyze, [sym_dd, sym_tx, tf_dd, when, thr, risk], out_a)
+
+        with gr.Tab("📊 Backtest"):
+            bars = gr.Slider(300, MAX_ROWS, value=3000, step=100, label="Lookback (bars)")
+            btn_b = gr.Button("Run backtest", variant="primary")
+            out_b = gr.Markdown()
+            out_t = gr.Dataframe(label="Trades (last 200)")
+            btn_b.click(ui_backtest, [sym_dd, sym_tx, tf_dd, thr, risk, bars], [out_b, out_t])
+
+        with gr.Tab("⚖️ Timeframe comparison"):
+            btn_c = gr.Button("Compare 15m / 30m / 1h / 1d", variant="primary")
+            out_c = gr.Dataframe(label="Per-timeframe backtest summary")
+            btn_c.click(ui_compare, [sym_dd, sym_tx, thr, risk, bars], out_c)
+
+    demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860)
+
+
+if __name__ == "__main__":
+    launch_ui()

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.44
+yfinance>=0.2.40
+pandas>=2.2
+numpy>=1.26