diff --git a/backtest_liquidity_sweep.py b/backtest_liquidity_sweep.py new file mode 100644 index 0000000..33f622d --- /dev/null +++ b/backtest_liquidity_sweep.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""backtest_liquidity_sweep.py — Liquiditäts-Sweeps (SMC/ICT) messen (B2). + +User-Vorgabe 2026-07-30 (mit Chart-Beispielen): die drei „wichtigsten Liquiditäts- +muster" für WTI in die Gesamtempfehlung aufnehmen — + A) **Equal Highs → Sell-Side-Sweep**: zwei ~gleiche Hochs bilden eine Stop-Zone; + der Kurs schießt KURZ darüber (Sweep), schließt zurück darunter → SHORT. + B) **Equal Lows → Buy-Side-Sweep**: Spiegelbild → LONG. + C) **Swing Liquidity**: markanter Swing-Punkt wird gesweept/retestet, dann Trade + in Richtung des höheren Timeframe-Trends (hier M30-EMA12/50 als HTF-Proxy). + +⚠ WARUM das trotz 15 verworfener Signal-Ideen einen eigenen Test verdient: Der +**Sweep ist ein FEHLAUSBRUCH** (Level kurz durchstochen, Schluss zurück im Bereich) — +eine andere Mechanik als die bereits verworfenen Muster (`backtest_doubletop.py` misst +den Nackenlinien-BRUCH, nicht den Fehlausbruch) und als die Struktur-/Volume-Profile- +Klasse. Verwandt ist er mit dem validierten P(break)-Modell: ein Sweep ist genau der +Fall „Level wird berührt/überschritten, hält aber" — dort ist die Vorhersage bereits +belegt (AUC 0,72), allerdings nur als EXIT, nicht als Entry. + +Methodik (wie alle Tests hier): Signal-TF M5, sequentielle 1-Positions-Sim, Live-Exit +(SL 2,0×ATR · Trail 1,5 ab 0,3 · Breakeven 1,3 · Time-Stop 120 min), Kosten = echter +Bar-Spread/ATR, 2 Halbjahre. Zusätzlich wird der SMC-eigene Exit geprüft +(Stop über/unter dem Sweep-Docht, Ziel = gegenüberliegende Liquidität), weil das +Setup laut Lehre damit steht und fällt. + +Maßstab: der einzige validierte Auto-Entry (Squeeze) liefert ØR +0,14…+0,23 · PF>1 +in BEIDEN Hälften. Alles darunter ist kein Kandidat für die Gesamtempfehlung. + +Die vom User nachgereichten WTI-Praxisregeln sind als ACHSEN eingebaut, statt sie +zu glauben: + · **Multi-TF** („Liquidität auf 4H/1H identifizieren, Entry auf 15M/5M") → die + Level-TF ist variabel (M5 / M30 / H1). Passt zum eigenen Befund von 2026-07-30 + (`backtest_level_tf.py`): M30-Level schlagen M5-Level deutlich. + · **Session-Timing** („Sweeps um 8:30–10:30 NY = 14:30–16:30 Berlin, oder 2–4 Uhr + asiatische Liquiditätsjagd") → Session-Filter als eigene Variante. + · **„Nicht jeder Sweep dreht — warte auf den Close zurück"** → ist die harte + Bedingung dieses Tests (Close muss im selben Bar zurück in der Zone sein). + · **DXY-Korrelation** → NICHT eingebaut: die Inter-Market-Klasse (Brent/DXY) wurde + 2026-07-19 gemessen und verworfen (`backtest_intermarket.py`, kippt zwischen den + Hälften). Ohne neuen Beleg keine zweite Runde. + · **„Sweep-Wick 0,50–1,00 $, kleiner sizen"** → im Test implizit über den + SMC-Exit (Stop am Docht) abgebildet; Sizing ist hier neutral (R-Rechnung). + +Aufruf: python backtest_liquidity_sweep.py [n_bars] +""" +from __future__ import annotations +import sys + +import MetaTrader5 as mt5 + +# ── Muster-Parameter (bewusst wenige, sonst Overfitting) ───────────────────── +_PIV_K = 3 # Swing-Pivot-Fenster +_EQ_TOL = 0.15 # „gleich" = beide Hochs/Tiefs innerhalb x×ATR +_EQ_MINGAP = 3 # min. Bars zwischen den beiden Pivots (sonst dieselbe Zacke) +_EQ_MAXGAP = 60 # max. Bars — danach ist die Zone kalt +_SWEEP_MIN = 0.05 # Sweep muss das Level um ≥ x×ATR überschießen (echter Stop-Grab) +_SWEEP_MAX = 1.00 # aber nicht mehr als x×ATR (sonst echter Ausbruch, kein Sweep) +_BACK_BARS = 3 # innerhalb so vieler Bars muss der Close zurück in die Zone +_LOOKBACK = 300 # Pivot-Suchfenster +_COOL = 12 # Cooldown zwischen Trades (Bars) +# Session-Fenster in BERLIN-Stunden (Broker ist UTC+3 → Berlin = Broker − 1 h). +# NY 8:30–10:30 ET ≈ 14:30–16:30 Berlin (EIA/Market-Open), Asia-Jagd 2–4 Uhr. +_SESS = {"NY": (14, 15, 16), "Asia": (2, 3, 4), "NY+Asia": (2, 3, 4, 14, 15, 16)} +_LEVEL_TFS = (("M5", 1), ("M30", 6), ("H1", 12)) # Level-Quelle (Multi-TF-Regel) + +# ── Exit (Live-Modell, identisch zu den anderen Backtests) ─────────────────── +_SL_ATR, _TRAIL, _TRAIL_ON, _BE_ON, _TIMESTOP, _MAXH = 2.0, 1.5, 0.3, 1.3, 24, 288 +_ATRMIN = 0.06 + + +def _atr_series(H, L, C, p=14): + tr = [0.0] + for i in range(1, len(C)): + tr.append(max(H[i] - L[i], abs(H[i] - C[i - 1]), abs(L[i] - C[i - 1]))) + out = [None] * len(C); run = 0.0 + for i in range(1, len(C)): + run += tr[i] + if i > p: run -= tr[i - p] + out[i] = run / min(i, p) + return out + + +def _ema_series(v, p): + k = 2.0 / (p + 1); o = [v[0]] + for x in v[1:]: + o.append(x * k + o[-1] * (1 - k)) + return o + + +def _sim_live(entry, d, atr, H, L, C, j0): + """Live-Exit: SL 2×ATR, Trailing 1,5 ab 0,3, Breakeven 1,3, Time-Stop.""" + eff = entry - d * _SL_ATR * atr; hw = entry; started = False + end = min(j0 + _MAXH, len(C) - 1); px = C[end] + for j in range(j0, end + 1): + if (L[j] <= eff) if d > 0 else (H[j] >= eff): px = eff; break + hw = max(hw, H[j]) if d > 0 else min(hw, L[j]) + prof = (C[j] - entry) * d + if prof >= _TRAIL_ON * atr: + started = True + cand = hw - d * _TRAIL * atr + if prof >= _BE_ON * atr: + cand = max(cand, entry) if d > 0 else min(cand, entry) + eff = max(eff, cand) if d > 0 else min(eff, cand) + if not started and (j - j0) >= _TIMESTOP: px = C[j]; break + return (px - entry) * d / atr + + +def _sim_smc(entry, d, atr, stop, target, H, L, C, j0): + """SMC-Exit laut Lehre: Stop über/unter dem Sweep-Docht, Ziel = gegenüber- + liegende Liquidität. Ohne Ziel → Live-Exit-Fallback.""" + if target is None: + return _sim_live(entry, d, atr, H, L, C, j0) + end = min(j0 + _MAXH, len(C) - 1); px = C[end] + for j in range(j0, end + 1): + hit_stop = (L[j] <= stop) if d > 0 else (H[j] >= stop) + hit_tgt = (H[j] >= target) if d > 0 else (L[j] <= target) + # konservativ: bei beidem im selben Bar zählt der Stop + if hit_stop: px = stop; break + if hit_tgt: px = target; break + return (px - entry) * d / atr + + +def _rep(name, Rs): + if not Rs or len(Rs) < 10: + print(f" {name:<40} n={len(Rs):>4} (zu wenige)"); return None + n = len(Rs); w = sum(1 for x in Rs if x > 0); s = sum(Rs) + up = sum(x for x in Rs if x > 0); dn = -sum(x for x in Rs if x < 0) + pf = up / dn if dn > 0 else 9.99 + print(f" {name:<40} n={n:>4} WR={100*w/n:>3.0f}% ØR={s/n:+.3f} " + f"PF={pf:.2f} ΣR={s:+.0f} worst={min(Rs):+.1f}") + return s / n + + +def find_pivots(H, L, step=1): + """Pivots auf der aggregierten Level-TF; Index = M5-Index, ab dem der Pivot + BEKANNT ist (Bestätigung braucht k Bars danach) → kein Look-ahead.""" + if step == 1: + ph = [(i, H[i]) for i in range(_PIV_K, len(H) - _PIV_K) + if H[i] == max(H[i - _PIV_K:i + _PIV_K + 1])] + pl = [(i, L[i]) for i in range(_PIV_K, len(L) - _PIV_K) + if L[i] == min(L[i - _PIV_K:i + _PIV_K + 1])] + return ph, pl + hh, ll = [], [] + for s0 in range(0, len(H) - step + 1, step): + hh.append(max(H[s0:s0 + step])); ll.append(min(L[s0:s0 + step])) + ph, pl = [], [] + for j in range(_PIV_K, len(hh) - _PIV_K): + avail = (j + _PIV_K + 1) * step + if hh[j] == max(hh[j - _PIV_K:j + _PIV_K + 1]): ph.append((avail, hh[j])) + if ll[j] == min(ll[j - _PIV_K:j + _PIV_K + 1]): pl.append((avail, ll[j])) + return ph, pl + + +def scan(H, L, C, SP, A, EF30, ES30, lo_i, hi_i, mode, smc_exit, + step=1, hours=None, BH=None): + """mode: 'eqh' (Equal Highs→Short), 'eql' (Equal Lows→Long), 'swing' (HTF-Trend). + `step` = Level-TF (1=M5, 6=M30, 12=H1) · `hours` = erlaubte Berlin-Stunden + (None = alle). Ein Pivot ist erst ab (idx+k+1) bekannt → kein Look-ahead.""" + ph, pl = find_pivots(H, L, step) + Rs = [] + def cost(i, atr): return (SP[i] if SP[i] > 0 else 0.0225) / atr + + i = max(lo_i, _LOOKBACK) + hi_i = min(hi_i, len(C) - _MAXH - 2) + while i < hi_i: + atr = A[i] + if not atr or atr < _ATRMIN: i += 1; continue + if hours is not None and BH is not None and BH[i] not in hours: + i += 1; continue + tol = _EQ_TOL * atr + # ── Liquiditätszone bestimmen ──────────────────────────────────────── + level = None; d = 0; zone_lo = None + if mode in ("eqh", "swing"): + # bekannte Hoch-Pivots im Fenster (bestätigt vor i) + hs = [(ix, p) for ix, p in ph if i - _LOOKBACK <= ix <= i - _PIV_K - 1] + if mode == "eqh" and len(hs) >= 2: + # zwei ~gleiche Hochs mit passendem Abstand + for a in range(len(hs) - 1, 0, -1): + for b in range(a - 1, -1, -1): + gap = hs[a][0] - hs[b][0] + if gap < _EQ_MINGAP: continue + if gap > _EQ_MAXGAP: break + if abs(hs[a][1] - hs[b][1]) <= tol: + level = max(hs[a][1], hs[b][1]); d = -1; break + if level is not None: break + elif mode == "swing" and hs: + level = hs[-1][1]; d = -1 + if mode in ("eql", "swing") and level is None: + ls = [(ix, p) for ix, p in pl if i - _LOOKBACK <= ix <= i - _PIV_K - 1] + if mode == "eql" and len(ls) >= 2: + for a in range(len(ls) - 1, 0, -1): + for b in range(a - 1, -1, -1): + gap = ls[a][0] - ls[b][0] + if gap < _EQ_MINGAP: continue + if gap > _EQ_MAXGAP: break + if abs(ls[a][1] - ls[b][1]) <= tol: + level = min(ls[a][1], ls[b][1]); d = 1; break + if level is not None: break + elif mode == "swing" and ls: + level = ls[-1][1]; d = 1 + if level is None or d == 0: i += 1; continue + + # ── Sweep prüfen: Bar i durchsticht das Level, Close kommt zurück ──── + if d < 0: # Equal Highs: High über Level, Close zurück darunter + over = H[i] - level + swept = (_SWEEP_MIN * atr <= over <= _SWEEP_MAX * atr) and C[i] < level + wick = H[i] + else: # Equal Lows: Low unter Level, Close zurück darüber + over = level - L[i] + swept = (_SWEEP_MIN * atr <= over <= _SWEEP_MAX * atr) and C[i] > level + wick = L[i] + if not swept: + i += 1; continue + # „Close zurück in die Zone" darf auch 1–_BACK_BARS Bars dauern; hier ist er + # bereits im Sweep-Bar erfüllt (strengste, sauberste Variante). + + # Swing-Modus: nur MIT dem HTF-Trend (M30-EMA12/50) handeln + if mode == "swing": + htf = 1 if EF30[i] > ES30[i] else -1 if EF30[i] < ES30[i] else 0 + if htf != d: i += 1; continue + + entry = C[i] + stop = wick + d * -1 * (0.05 * atr) # knapp jenseits des Sweep-Dochts + stop = (wick - 0.05 * atr) if d > 0 else (wick + 0.05 * atr) + # Ziel = gegenüberliegende Liquidität (nächster Pivot in Trade-Richtung) + if d < 0: + cands = [p for ix, p in pl if i - _LOOKBACK <= ix <= i - _PIV_K - 1 + and p < entry - 0.3 * atr] + target = max(cands) if cands else None + else: + cands = [p for ix, p in ph if i - _LOOKBACK <= ix <= i - _PIV_K - 1 + and p > entry + 0.3 * atr] + target = min(cands) if cands else None + + R = (_sim_smc(entry, d, atr, stop, target, H, L, C, i + 1) if smc_exit + else _sim_live(entry, d, atr, H, L, C, i + 1)) - cost(i, atr) + Rs.append(R) + i += _COOL + return Rs + + +def main(): + n = int(sys.argv[1]) if len(sys.argv) > 1 else 80000 + mt5.initialize(); sym = None + for c in ("SpotCrude", "USOIL", "WTI", "XTIUSD"): + if mt5.symbol_info(c): sym = c; break + bars = mt5.copy_rates_from_pos(sym, mt5.TIMEFRAME_M5, 0, n) + si = mt5.symbol_info(sym); point = si.point + mt5.shutdown() + H = [float(b["high"]) for b in bars]; L = [float(b["low"]) for b in bars] + C = [float(b["close"]) for b in bars]; SP = [float(b["spread"]) * point for b in bars] + A = _atr_series(H, L, C) + # HTF-Proxy für den Swing-Modus: M30 aus M5 aggregiert (6 Bars), auf M5 gemappt + c30 = [C[s + 5] for s in range(0, len(C) - 5, 6)] + e12 = _ema_series(c30, 12); e50 = _ema_series(c30, 50) + EF30 = [0.0] * len(C); ES30 = [0.0] * len(C) + for i in range(len(C)): + j = i // 6 - 1 + if 0 <= j < len(e12): EF30[i] = e12[j]; ES30[i] = e50[j] + # Berlin-Stunde je Bar (Broker UTC+3 → Berlin = Broker − 1 h, Sommerzeit) + from datetime import datetime, timezone + BH = [(datetime.fromtimestamp(int(b["time"]), timezone.utc).hour - 1) % 24 + for b in bars] + N = len(C); mid = N // 2 + + print("=" * 96) + print(f" LIQUIDITÄTS-SWEEPS (SMC) — {sym} M5 ({N} Bars, 2 Halbjahre)") + print(f" Sweep = Level um {_SWEEP_MIN}–{_SWEEP_MAX}×ATR durchstochen, Close zurück in der Zone") + print(f" Maßstab: validierter Squeeze ØR +0,14…+0,23 · PF>1 in BEIDEN Hälften") + print("=" * 96) + + verdict = {} + MODES = (("eqh", "A) Equal Highs -> SHORT"), + ("eql", "B) Equal Lows -> LONG"), + ("swing", "C) Swing-Liquidity (HTF)")) + # ── Achse 1: LEVEL-TF (Multi-TF-Regel „Liquidität auf höherem TF") × Exit ── + for tf_lbl, step in _LEVEL_TFS: + print("\n" + "=" * 96) + print(f"### LEVEL-TF {tf_lbl} — Liquidität auf {tf_lbl} identifiziert, Entry auf M5") + for exit_lbl, smc in (("Live-Exit", False), ("SMC-Exit", True)): + print(f"\n --- EXIT: {exit_lbl} ---") + for mode, mlabel in MODES: + for hl, lo, hi in (("H1", _LOOKBACK, mid), ("H2", mid, N)): + Rs = scan(H, L, C, SP, A, EF30, ES30, lo, hi, mode, smc, step) + oR = _rep(f"{mlabel} [{hl}]", Rs) + verdict.setdefault((f"{tf_lbl}/{exit_lbl}", mlabel), []).append(oR) + # ── Achse 2: SESSION-Filter (Level-TF M30, Live-Exit) ──────────────────── + print("\n" + "=" * 96) + print("### SESSION-FILTER (Level-TF M30, Live-Exit) — „Sweeps passieren um 14–16 / 2–4 Uhr\"") + for sess, hours in _SESS.items(): + print(f"\n --- Session: {sess} (Berlin-Stunden {hours}) ---") + for mode, mlabel in MODES[:2]: + for hl, lo, hi in (("H1", _LOOKBACK, mid), ("H2", mid, N)): + Rs = scan(H, L, C, SP, A, EF30, ES30, lo, hi, mode, False, 6, hours, BH) + oR = _rep(f"{mlabel} [{hl}]", Rs) + verdict.setdefault((f"M30/Sess-{sess}", mlabel), []).append(oR) + + print("\n" + "=" * 96) + print(" URTEIL (Kandidat für die Gesamtempfehlung nur, wenn ØR in BEIDEN Hälften") + print(" > 0 UND ≥ +0,14 = Squeeze-Band):") + any_ok = False + for (ex, m), vals in verdict.items(): + if len(vals) != 2 or any(v is None for v in vals): + print(f" {m:<38} {ex[:22]:<24} unvollständig"); continue + ok = all(v > 0 for v in vals); band = all(v >= 0.14 for v in vals) + mark = "✅ TRÄGT" if (ok and band) else ("⚠ positiv, unter Band" if ok else "❌ fällt durch") + if ok and band: any_ok = True + print(f" {m:<38} {ex[:22]:<24} H1 {vals[0]:+.3f} · H2 {vals[1]:+.3f} {mark}") + print("\n " + ("→ Kandidat gefunden: Parameter-Robustheit prüfen, dann als Verdict-Modul." + if any_ok else + "→ KEINE Variante trägt beidhälftig im Squeeze-Band → nicht in die " + "Gesamtempfehlung (höchstens als Anzeige).")) + + +if __name__ == "__main__": + main() diff --git a/core/engine.py b/core/engine.py index 7b722dd..9d1fbca 100644 --- a/core/engine.py +++ b/core/engine.py @@ -2088,6 +2088,133 @@ class TradingEngine: self._align_ts = now return getattr(self, "_align_cache", None) + def _loss_streak_today(self) -> tuple[int, int]: + """(Verlust-Trades heute, Trades heute) — für den Mental-Check der Entry- + Checkliste („nach 2 Losses Session beenden"). DB-Query ~120 s gecacht.""" + now = time.time() + if now - getattr(self, "_streak_ts", 0.0) > 120: + try: + import datetime as _dt + t0 = _dt.datetime.now(_BERLIN).replace( + hour=0, minute=0, second=0, microsecond=0).timestamp() + with self.history._connect() as conn: + rows = conn.execute( + "SELECT pnl FROM trades WHERE exit_time>=? AND pnl IS NOT NULL", + (t0,)).fetchall() + self._streak_cache = (sum(1 for r in rows if (r[0] or 0) < 0), len(rows)) + except Exception as e: + log.debug(f"loss_streak: {e}") + self._streak_cache = (0, 0) + self._streak_ts = now + return getattr(self, "_streak_cache", (0, 0)) + + def _entry_checklist(self, side: str, snap_parts: dict) -> dict: + """Prüft die Trade-Setup-Checkliste (User-Vorgabe 2026-07-30) für eine + geplante Eröffnung und liefert die VERLETZTEN Punkte zurück. + + Warum server-seitig: die Daten liegen alle hier (TF-Ampel, Struktur, Level, + News, Tages-P&L, Trade-Historie) — das Frontend soll nur anzeigen. + + Jeder Punkt: `state` = "fail" (klar dagegen) | "warn" (Vorsicht) | "ok". + Reine ENTSCHEIDUNGSHILFE — sie blockt nichts (wie der bisherige Dialog), + macht aber sichtbar, was gegen den Trade spricht. Die Gewichtung ist NICHT + aus einem Backtest, sondern aus (a) den im Projekt GEMESSENEN Leckagen + (Handeln ohne Signal, Nacht/teure Stunden, Verlust-Serien) und (b) der + vom User vorgegebenen Checkliste.""" + want = "LONG" if side == "long" else "SHORT" + d = 1 if want == "LONG" else -1 + items: list[dict] = [] + add = lambda k, st, lab, det: items.append( + {"key": k, "state": st, "label": lab, "detail": det}) + + wave = snap_parts.get("wave") or {} + market = snap_parts.get("market") or {} + # ── 1. Signal-Deckung (die gemessene Kern-Leckage) ─────────────────── + sig = (wave.get("signal") or "WARTEN") if isinstance(wave.get("signal"), str) \ + else ((wave.get("signal") or {}).get("signal") or "WARTEN") + if sig == want: + add("signal", "ok", "Empfehlung deckt den Trade", f"Signal {sig}") + elif sig in ("WARTEN", "—", None): + add("signal", "fail", "Keine Empfehlung (WARTEN)", + "gemessen: Trades ohne Signal sind die größte Verlustquelle") + else: + add("signal", "fail", f"Empfehlung steht GEGEN dich ({sig})", + "gemessen: 40 % Trefferquote gegen das Signal") + # ── 2. HTF-Trend klar? (Checklisten-Punkt 1) ───────────────────────── + turns = wave.get("tf_turns") or {} + htf = [turns.get(t, {}).get("dir") if isinstance(turns.get(t), dict) + else turns.get(t) for t in ("M30", "H1")] + htf = [x for x in htf if x in (1, -1, 0)] + if htf and all(x == d for x in htf): + add("htf", "ok", "HTF-Trend (M30+H1) trägt die Richtung", "") + elif htf and any(x == -d for x in htf): + add("htf", "fail", "HTF-Trend steht dagegen (M30/H1)", + "deine Regel: nur MIT dem HTF-Trend, niemals dagegen") + else: + add("htf", "warn", "HTF-Trend unklar/seitwärts", "kein klarer M30/H1-Trend") + # ── 3. Entry-Raum bis zum Gegenlevel (gemessen monoton) ────────────── + try: + dl = self._draw_levels() + atr = float((wave.get("pb_feats") or {}).get("atr") or 0.0) or 0.2 + bid = market.get("bid") + tgt = (dl.get("res") or [None])[0] if d > 0 else (dl.get("sup") or [None])[0] + if bid and tgt: + room = abs(tgt - bid) / atr + if room < 0.6: + add("room", "fail", f"Kein Raum: Level nur {room:.1f}×ATR entfernt", + "gemessen: <0,6×ATR Raum = negativer Erwartungswert") + elif room < 1.0: + add("room", "warn", f"Wenig Raum ({room:.1f}×ATR bis zum Level)", "") + else: + add("room", "ok", f"Raum bis zum Level: {room:.1f}×ATR", "") + except Exception: + pass + # ── 4. News-Konflikt (Checklisten-Punkt 3) ─────────────────────────── + ns = snap_parts.get("news_sentiment") + if isinstance(ns, (int, float)) and abs(ns) >= 0.5: + if (ns > 0) != (d > 0): + add("news", "fail", + f"News-Flow steht dagegen ({ns:+.2f})", + "stark bullische/bärische Schlagzeilen gegen deine Richtung") + else: + add("news", "ok", f"News-Flow stützt ({ns:+.2f})", "") + # ── 5. Kosten (Spread/ATR — gemessen Ø 0,265) ──────────────────────── + cr = snap_parts.get("cost_ratio") + if isinstance(cr, (int, float)) and cr > 0: + if cr >= 0.32: + add("cost", "fail", f"Kosten hoch ({cr:.2f}×ATR)", + "gemessen: ab ~0,32×ATR frisst der Spread den Edge") + elif cr >= 0.20: + add("cost", "warn", f"Kosten erhöht ({cr:.2f}×ATR)", "") + else: + add("cost", "ok", f"Kosten günstig ({cr:.2f}×ATR)", "") + # ── 6. Mental-Check: Verlust-Serie heute (Checklisten-Punkt 5) ─────── + losses, total = self._loss_streak_today() + day_total = float((snap_parts.get("day_pl") or {}).get("total") or 0.0) + if losses >= 2: + bal = float(self.data.balance or 0.0) + pct = (abs(day_total) / bal * 100.0) if (bal and day_total < 0) else 0.0 + add("streak", "fail", + f"Heute schon {losses} Verluste ({total} Trades, {day_total:+.0f} €" + + (f" = {pct:.0f}% des Kontos)" if pct else ")"), + "deine Regel: nach 2 Losses Session beenden") + elif day_total < 0: + add("streak", "warn", f"Tag im Minus ({day_total:+.0f} €)", "") + else: + add("streak", "ok", f"Tagesbilanz {day_total:+.0f} €", "") + # ── 7. Nacht-/Kostenfalle (gemessen: 0–7 Uhr Berlin) ───────────────── + try: + hb = datetime.now(_BERLIN).hour + if hb in _SQUEEZE_NIGHT: + add("hour", "fail", f"Nacht-Stunde ({hb}:00 Berlin)", + "gemessen: 0–7 Uhr = Kostenfalle (Spread ÷ dünner ATR)") + except Exception: + pass + fails = sum(1 for x in items if x["state"] == "fail") + warns = sum(1 for x in items if x["state"] == "warn") + return {"side": want, "items": items, "fails": fails, "warns": warns, + "verdict": ("stop" if fails >= 2 else "warn" if (fails or warns) else "ok")} + def snapshot_cached(self) -> dict: """Teilt EINEN frisch berechneten Snapshot über alle WS-Clients/HTTP- Aufrufe (TTL ~0,8 s). Spart SQLite/Verdict-Last bei mehreren Geräten — @@ -2309,7 +2436,7 @@ class TradingEngine: } sr_close_hint = self._sr_close_hint(market, position, wave_snap) stop_approach = self._stop_approach_hint(market, position, wave_snap) - return { + snap = { "ts": time.time(), "connected": self._connected, "running": self._running, @@ -2380,6 +2507,20 @@ class TradingEngine: "adverse15_count": self._adverse15_count, "last_trades": last_trades, } + # ── Entry-Checkliste je Richtung (User-Vorgabe 2026-07-30: „blende einen + # Hinweis ein, wenn die Checkliste gegen meine Eröffnung ist"). Wird im + # Order-Dialog angezeigt; blockt NICHT. Nutzt nur bereits berechnete Teile + # → kein zusätzlicher MT5-/DB-Zugriff im Snapshot-Pfad. + try: + _parts = {"wave": wave_snap, "market": market, + "news_sentiment": snap.get("news_sentiment"), + "cost_ratio": snap.get("cost_ratio"), "day_pl": day_pl} + snap["checklist"] = {"long": self._entry_checklist("long", _parts), + "short": self._entry_checklist("short", _parts)} + except Exception as e: + log.debug(f"entry_checklist: {e}") + snap["checklist"] = None + return snap def _sr_close_hint(self, market, position, wave_snap) -> dict | None: """S/R-Close-Empfehlung mit kalibriertem P(Durchbruch)-Modell (gemessen diff --git a/mql5/SR_Levels.mq5 b/mql5/SR_Levels.mq5 index 92f2bdf..997cf21 100644 --- a/mql5/SR_Levels.mq5 +++ b/mql5/SR_Levels.mq5 @@ -12,7 +12,13 @@ //| 4) Der Bot muss laufen (schreibt die CSV alle ~5 s). | //+------------------------------------------------------------------+ #property copyright "Oil Trading Bot" -#property version "1.13" +#property version "1.14" +// v1.14 (2026-07-30): Liquiditäts-LINIEN + Text-Labels ENTFERNT (User: „blende die +// liquiditätslinien aus, nur die Pfeile sollen rechtsbündig angezeigt werden"). +// Es bleibt NUR der Pfeil auf dem Wand-Preis, RECHTSBÜNDIG am aktuellen Rand +// (wird in RepositionLabels() nachgeführt, bleibt beim Scrollen rechts). +// Details (Seite/Größe/Dominanz/Preis) jetzt im TOOLTIP statt im Chart. +// Die pinke Liquiditäts-Trendlinie bleibt unverändert. // v1.13 (2026-07-30): Liquiditäts-Wände bekommen einen PFEIL in ihrer Wirkrichtung // (Lesart „die Wand hält" — Nachfrage stützt hoch, Angebot deckelt runter; // die GRÖSSERE Wand wird dicker gezeichnet + "<<"). NEU: pinke @@ -95,6 +101,17 @@ void RepositionLabels() ObjectMove(0, nm, 0, ct, pr); } } + // Liquiditäts-PFEILE rechtsbündig halten: die CSV ändert sich nicht bei jedem + // Tick, ohne Nachführung würden die Pfeile mit jeder neuen Kerze nach links + // wandern. Preis bleibt, nur die Zeit wird an den rechten Rand gezogen. + datetime rt = iTime(_Symbol, PERIOD_CURRENT, 0) + (datetime)(PeriodSeconds() * 2); + int na = ObjectsTotal(0, 0, OBJ_ARROW); + for(int i = 0; i < na; i++) + { + string nm = ObjectName(0, i, 0, OBJ_ARROW); + if(StringFind(nm, PFX + "ALQ_") == 0) + ObjectMove(0, nm, 0, rt, ObjectGetDouble(0, nm, OBJPROP_PRICE)); + } ChartRedraw(); } //+------------------------------------------------------------------+ @@ -277,54 +294,39 @@ void Redraw() if(lpx <= 0) continue; bool isBid = (side == "B"); color lcol = isBid ? InpWallBidColor : InpWallAskColor; - string nm = PFX + "LQ_" + side; - if(ObjectCreate(0, nm, OBJ_HLINE, 0, 0, lpx)) - { - ObjectSetInteger(0, nm, OBJPROP_COLOR, lcol); - ObjectSetInteger(0, nm, OBJPROP_STYLE, STYLE_DASH); - ObjectSetInteger(0, nm, OBJPROP_WIDTH, 2); - ObjectSetInteger(0, nm, OBJPROP_BACK, true); - ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); - } - else - ObjectMove(0, nm, 0, 0, lpx); - // Pfeil = Wirkrichtung der Wand (Feld 4: U/D). Lesart „die Wand HÄLT": - // Nachfrage-Wand stützt von unten (hoch), Angebots-Wand deckelt (runter). - // Feld 5 = 1 bei der GRÖSSEREN der beiden Wände → dickere Linie + "<<". + // ⚠ 2026-07-30 (User): KEINE waagerechte Linie und KEIN Text-Label mehr — + // der Chart war zu voll. Es bleibt NUR der Pfeil, RECHTSBÜNDIG am aktuellen + // Rand, auf dem Preisniveau der Wand. Die Details (Seite/Größe/Dominanz) + // stehen im TOOLTIP (Maus drüber) statt fest im Chart. string dirc = (k > 4) ? p[4] : (isBid ? "U" : "D"); bool isDom = (k > 5 && p[5] == "1"); - string arrow = (dirc == "U" ? CharToString(94) : CharToString(118)); // ^ / v - if(isDom) - ObjectSetInteger(0, nm, OBJPROP_WIDTH, 3); - string llbl = arrow + " " + (isBid ? "Liquidität NACHFRAGE " : "Liquidität ANGEBOT ") - + DoubleToString(lsz, 0) + (isDom ? " <<" : ""); - string ltn = PFX + "TLQ_" + side; - if(ObjectCreate(0, ltn, OBJ_TEXT, 0, CenterTime(), lpx)) - { - ObjectSetString (0, ltn, OBJPROP_TEXT, llbl); - ObjectSetInteger(0, ltn, OBJPROP_COLOR, lcol); - ObjectSetInteger(0, ltn, OBJPROP_FONTSIZE, 9); - ObjectSetInteger(0, ltn, OBJPROP_ANCHOR, ANCHOR_LOWER); - ObjectSetInteger(0, ltn, OBJPROP_SELECTABLE, false); - } - else - { - ObjectMove(0, ltn, 0, CenterTime(), lpx); - ObjectSetString(0, ltn, OBJPROP_TEXT, llbl); - } - // Echtes Pfeil-Objekt am rechten Rand (Wingdings 233 hoch / 234 runter) — - // deutlicher sichtbar als das Textzeichen im Label. string an = PFX + "ALQ_" + side; - datetime atime = CenterTime() + (datetime)(PeriodSeconds() * 6); + // Rechter Rand = aktuelle (rechteste) Kerze + kleiner Versatz, damit der + // Pfeil frei neben dem Kursverlauf steht und beim Scrollen rechts bleibt. + datetime atime = iTime(_Symbol, PERIOD_CURRENT, 0) + + (datetime)(PeriodSeconds() * 2); if(ObjectCreate(0, an, OBJ_ARROW, 0, atime, lpx)) { ObjectSetInteger(0, an, OBJPROP_ARROWCODE, (dirc == "U" ? 233 : 234)); ObjectSetInteger(0, an, OBJPROP_COLOR, lcol); - ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 3 : 2)); + ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 4 : 2)); + ObjectSetInteger(0, an, OBJPROP_ANCHOR, ANCHOR_LEFT); ObjectSetInteger(0, an, OBJPROP_SELECTABLE, false); } else + { ObjectMove(0, an, 0, atime, lpx); + ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 4 : 2)); + ObjectSetInteger(0, an, OBJPROP_COLOR, lcol); + ObjectSetInteger(0, an, OBJPROP_ARROWCODE, (dirc == "U" ? 233 : 234)); + } + ObjectSetString(0, an, OBJPROP_TOOLTIP, + (isBid ? "Liquiditaet NACHFRAGE " : "Liquiditaet ANGEBOT ") + + DoubleToString(lsz, 0) + (isDom ? " (dominant)" : "") + + " @ " + DoubleToString(lpx, (int)_Digits)); + // evtl. noch vorhandene Alt-Objekte (Linie/Label aus v1.13) entfernen + ObjectDelete(0, PFX + "LQ_" + side); + ObjectDelete(0, PFX + "TLQ_" + side); continue; } // Liquiditäts-TRENDLINIE: LT;t1;p1;t2;p2; (pink, nach rechts verlängert). diff --git a/web/app.js b/web/app.js index 381ec58..be000fd 100644 --- a/web/app.js +++ b/web/app.js @@ -874,8 +874,37 @@ document.querySelectorAll(".btn[data-side]").forEach(btn => { if (btn.disabled) return; const side = btn.dataset.side; if (side === "long" || side === "short") { - const info = recInfo(side); // WARTEN/Gegen-Signal → Hinweis, der - if (info.danger) { // bestätigt werden muss (kein Block) + // ── Entry-Checkliste (User-Vorgabe 2026-07-30): zeigt VOR der Eröffnung, + // was dagegen spricht — auch dann, wenn ein Signal da ist (der alte Dialog + // kam nur bei WARTEN/Gegen-Signal). Blockt nicht, macht nur sichtbar. + const cl = (lastSnap.checklist || {})[side]; + const info = recInfo(side); + if (cl && (cl.fails > 0 || cl.warns > 0)) { + const ICON = { fail: "❌", warn: "⚠", ok: "✅" }; + const bad = cl.items.filter(x => x.state !== "ok"); + const good = cl.items.filter(x => x.state === "ok"); + let body = bad.map(x => `${ICON[x.state]} ${x.label}` + + (x.detail ? `\n ${x.detail}` : "")).join("\n"); + if (good.length) body += `\n\n${good.map(x => `✅ ${x.label}`).join("\n")}`; + // Eigene Zahlen zur Ausrichtung ergänzen (gemessene Kern-Leckage) + const al = lastSnap.alignment || null; + const sigNow = (lastSnap.wave_signal || {}).signal || "WARTEN"; + const isWait0 = (sigNow === "WARTEN" || sigNow === "—"); + if (al && cl.items.some(x => x.key === "signal" && x.state === "fail")) { + const grp = isWait0 ? al.none : al.against, ref = al.with; + const f = g => (g && g.n >= 5) + ? `${g.wr}% Treffer · ${g.pnl >= 0 ? "+" : ""}${fmt(g.pnl, 0)} € (n${g.n})` : null; + const own = f(grp), rf = f(ref); + if (own) body += `\n\n📊 Deine Trades ${isWait0 ? "OHNE" : "GEGEN"} Signal: ${own}`; + if (rf) body += `\n📊 Mit Signal: ${rf}`; + } + const head = cl.verdict === "stop" + ? `🛑 Checkliste sagt NEIN (${cl.fails} Punkte dagegen)` + : `⚠ Checkliste: ${cl.fails} dagegen, ${cl.warns} Vorsicht`; + const ok = await modal(head, body + `\n\n${side.toUpperCase()} trotzdem eröffnen?`, + "confirm", true); + if (!ok) return; + } else if (info.danger) { // Fallback: alter Hinweis (kein Block) const sig = (lastSnap.wave_signal || {}).signal || "WARTEN"; const isWait = (sig === "WARTEN" || sig === "—"); const head = isWait diff --git a/web/index.html b/web/index.html index f321f09..1f13142 100644 --- a/web/index.html +++ b/web/index.html @@ -6,7 +6,7 @@ Oil · MT5 - + @@ -229,6 +229,6 @@ - +