Delete app.py

app.py

@@ -1,1768 +0,0 @@
-import warnings
-warnings.filterwarnings("ignore")
-
-import os
-import re
-import time
-import tempfile
-
-import numpy as np
-import pandas as pd
-import yfinance as yf
-import gradio as gr
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-from sklearn.impute import SimpleImputer
-from sklearn.preprocessing import StandardScaler
-from sklearn.pipeline import Pipeline
-from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors
-from sklearn.isotonic import IsotonicRegression
-from sklearn.metrics import balanced_accuracy_score, accuracy_score
-
-APP_TITLE = "Goshawk Adaptive Risk Engine v5"
-ASSETS = ["BTC-USD", "ETH-USD", "SOL-USD", "AAPL", "MSFT", "NVDA", "SPY", "QQQ",
-          "GC=F", "EURUSD=X"]
-K_GRID = [5, 7, 9, 11, 15, 21]
-SL_GRID = [0.8, 1.0, 1.2, 1.5, 1.8, 2.0, 2.5, 3.0]
-RR_GRID = [1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0]
-CLASSES = [-1, 0, 1]
-SIDE_MODES = ["Long + Short", "Sadece Long", "Sadece Short"]
-IND_MODES = ["Kapalı", "Onay filtresi (KNN + ST/UT)", "Sadece indikatör"]
-COMBO_MODES = ["Kapalı", "Onay filtresi (KNN + birleşik)", "Sadece birleşik sinyal"]
-LDC_MODES = ["Kapalı", "Onay filtresi (Lorentzian)", "Sadece Lorentzian"]
-VP_MODES = ["Kapalı", "Onay filtresi (POC / Value Area)", "KNN özelliği + onay filtresi"]
-GANN_MODES = ["Kapalı", "Onay filtresi (Gann Box %50)"]
-SMC_MODES = ["Kapalı", "Onay filtresi (SMC yapı yönü)", "Sadece SMC (yapı kırılımı girişi)"]
-SMC_SRC = ["Swing yapı", "Internal yapı"]
-SMC_OBF = ["Atr", "Cumulative Mean Range"]
-GANN_LEVELS = [0.0, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0]
-GANN_FAN = [(8, "8x1"), (4, "4x1"), (3, "3x1"), (2, "2x1"), (1, "1x1"),
-            (1/2, "1x2"), (1/3, "1x3"), (1/4, "1x4"), (1/8, "1x8")]
-
-_CACHE = {}
-CACHE_TTL = 600  # saniye; Yahoo'yu gereksiz yere tekrar çağırmamak için
-
-
-# ---------------------------------------------------------------- veri / özellik
-def get_market_data(ticker, period):
-    key, now = (ticker, period), time.time()
-    if key in _CACHE and now - _CACHE[key][0] < CACHE_TTL:
-        return _CACHE[key][1].copy()
-    df = yf.download(ticker, period=period, interval="1d",
-                     auto_adjust=True, progress=False)
-    if df is None or df.empty:
-        raise ValueError(f"Yahoo Finance {ticker} verisi döndürmedi.")
-    if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.get_level_values(0)
-    df = df[["Open", "High", "Low", "Close", "Volume"]].dropna().copy()
-    df.index = pd.to_datetime(df.index)
-    _CACHE[key] = (now, df)
-    return df.copy()
-
-
-def calc_atr(df, n=14):
-    pc = df.Close.shift(1)
-    tr = pd.concat([(df.High - df.Low), (df.High - pc).abs(),
-                    (df.Low - pc).abs()], axis=1).max(axis=1)
-    return tr.ewm(alpha=1/n, adjust=False).mean()
-
-
-def calc_rsi(s, n=14):
-    d = s.diff()
-    up = d.clip(lower=0).ewm(alpha=1/n, adjust=False).mean()
-    dn = (-d.clip(upper=0)).ewm(alpha=1/n, adjust=False).mean()
-    rs = up / dn.replace(0, np.nan)
-    return 100 - 100/(1+rs)
-
-
-def make_features(df, vp=None):
-    c, v = df.Close, df.Volume
-    x = pd.DataFrame(index=df.index)
-    for n in [1, 2, 3, 5, 10, 20, 50]:
-        x[f"ret_{n}"] = c.pct_change(n)
-    for n in [5, 10, 20, 50]:
-        x[f"ema_gap_{n}"] = c/c.ewm(span=n, adjust=False).mean()-1
-    x["rsi_14"] = calc_rsi(c)/100
-    atr = calc_atr(df)
-    x["atr_pct"] = atr/c
-    x["range_pct"] = (df.High-df.Low)/c
-    x["body_pct"] = (df.Close-df.Open)/df.Open
-    daily_ret = c.pct_change()
-    x["vol_10"] = daily_ret.rolling(10).std()
-    x["vol_20"] = daily_ret.rolling(20).std()
-    x["volume_z20"] = (v-v.rolling(20).mean())/v.rolling(20).std().replace(0, np.nan)
-    x["volume_change"] = v.pct_change()
-    macd = c.ewm(span=12, adjust=False).mean()-c.ewm(span=26, adjust=False).mean()
-    x["macd_pct"] = macd/c
-    # v5: fiyat kanalı konumu ve Bollinger z-skoru
-    x["dist_hi_20"] = c/df.High.rolling(20).max()-1
-    x["dist_lo_20"] = c/df.Low.rolling(20).min()-1
-    x["bb_z20"] = (c-c.rolling(20).mean())/c.rolling(20).std().replace(0, np.nan)
-    if vp is not None:  # Volume Profile özellikleri (ileriye bakmaz)
-        x["vp_poc_gap"] = c/vp["poc"]-1
-        x["vp_va_pos"] = (c-vp["val"])/(vp["vah"]-vp["val"]).replace(0, np.nan)
-        x["vp_va_width"] = (vp["vah"]-vp["val"])/c
-    return x.replace([np.inf, -np.inf], np.nan), atr
-
-
-def supertrend(df, period=10, mult=3.0):
-    """TradingView ta.supertrend portu. dir: +1 yükseliş, -1 düşüş."""
-    atr = calc_atr(df, period).to_numpy(float)
-    h, l, c = df.High.to_numpy(float), df.Low.to_numpy(float), df.Close.to_numpy(float)
-    hl2 = (h+l)/2
-    n = len(c)
-    up, dn = hl2-mult*atr, hl2+mult*atr
-    trend = np.ones(n, dtype=int)
-    for i in range(1, n):
-        if c[i-1] > up[i-1]:
-            up[i] = max(up[i], up[i-1])
-        if c[i-1] < dn[i-1]:
-            dn[i] = min(dn[i], dn[i-1])
-        trend[i] = trend[i-1]
-        if trend[i-1] == -1 and c[i] > dn[i-1]:
-            trend[i] = 1
-        elif trend[i-1] == 1 and c[i] < up[i-1]:
-            trend[i] = -1
-    return trend, np.where(trend == 1, up, dn)
-
-
-def ut_bot(df, key=1.0, period=10):
-    """UT Bot Alerts (QuantNomad) portu. pos: +1 al, -1 sat, 0 henüz sinyal yok."""
-    c = df.Close.to_numpy(float)
-    nloss = key*calc_atr(df, period).to_numpy(float)
-    n = len(c)
-    stop, pos = np.zeros(n), np.zeros(n, dtype=int)
-    stop[0] = c[0]-nloss[0]
-    for i in range(1, n):
-        prev = stop[i-1]
-        if c[i] > prev and c[i-1] > prev:
-            stop[i] = max(prev, c[i]-nloss[i])
-        elif c[i] < prev and c[i-1] < prev:
-            stop[i] = min(prev, c[i]+nloss[i])
-        elif c[i] > prev:
-            stop[i] = c[i]-nloss[i]
-        else:
-            stop[i] = c[i]+nloss[i]
-        if c[i-1] < prev and c[i] > prev:
-            pos[i] = 1
-        elif c[i-1] > prev and c[i] < prev:
-            pos[i] = -1
-        else:
-            pos[i] = pos[i-1]
-    return pos, stop
-
-
-
-
-# ------------------------------------------- Smart Money Concepts (LuxAlgo) Python portu
-# Based on LuxAlgo Smart Money Concepts; attribution retained.
-# Original license: CC BY-NC-SA 4.0 — https://creativecommons.org/licenses/by-nc-sa/4.0/
-def mtf_prev_levels(df):
-    """Önceki gün / hafta / ay high-low (tamamlanmış dönem; ileriye bakma yok), mum bazında dizi."""
-    out = {}
-    for key, rule in (("d", "D"), ("w", "W"), ("m", "M")):
-        per = df.index.to_period(rule)
-        hi = df.High.groupby(per).max().shift(1)
-        lo = df.Low.groupby(per).min().shift(1)
-        out["p"+key+"h"] = hi.reindex(per).to_numpy(float)
-        out["p"+key+"l"] = lo.reindex(per).to_numpy(float)
-    return out
-
-
-def _smc_pivots(h, l, size):
-    """Pine leg(size) mantığı: pivotlar `size` mum sonra doğrulanır (ileriye bakma yok).
-    Dönüş: {doğrulama_mumu: [("H"|"L", seviye, pivot_mumu)]}"""
-    n = len(h)
-    hs, ls = pd.Series(h), pd.Series(l)
-    hmax = hs.rolling(size).max().to_numpy(float)
-    lmin = ls.rolling(size).min().to_numpy(float)
-    out, leg = {}, 0
-    for i in range(size, n):
-        new_leg = leg
-        if h[i-size] > hmax[i]:
-            new_leg = 0
-        elif l[i-size] < lmin[i]:
-            new_leg = 1
-        if new_leg != leg:
-            out.setdefault(i, []).append(("L", float(l[i-size]), i-size) if new_leg == 1
-                                         else ("H", float(h[i-size]), i-size))
-            leg = new_leg
-    return out
-
-
-def smc_analyze(df, swing_len=50, int_len=5, eq_len=3, eq_thr=0.1, ob_keep=5,
-                confluence=False, ob_filter="Atr"):
-    """LuxAlgo 'Smart Money Concepts' göstergesinin Python portu: swing/internal yapı (BOS, CHoCH),
-    order block, EQH/EQL, Fair Value Gap, premium/discount ve strong/weak high-low.
-    Pine kaynağından birebir değil; her mum yalnızca kendisine kadarki veriyi kullanır."""
-    n = len(df)
-    o, h, l, c = (df[k].to_numpy(float) for k in ("Open", "High", "Low", "Close"))
-    atr = calc_atr(df, 200).to_numpy(float)
-    pc_ = np.r_[c[0], c[:-1]]
-    tr_ = np.maximum(h-l, np.maximum(np.abs(h-pc_), np.abs(l-pc_)))
-    vm = (np.cumsum(tr_)/np.arange(1, n+1)) if ob_filter == "Cumulative Mean Range" else atr
-    hv = (h-l) >= 2*vm                        # yüksek volatilite mumları: OB için high/low yer değiştirir
-    # LuxAlgo Pine ile aynı gövde/fitil konfluens koşulları.
-    # Bearish koşul önceki portta ters yazılmıştı; burada Pine ifadesi birebir korunur.
-    bull_bar = (h-np.maximum(c, o)) > np.minimum(c, o-l) if confluence else np.ones(n, bool)
-    bear_bar = (h-np.maximum(c, o)) < np.minimum(c, o-l) if confluence else np.ones(n, bool)
-    ph, pl = np.where(hv, l, h), np.where(hv, h, l)
-    swing_len = int(min(max(swing_len, 3), max(n//4, 3)))
-    int_len = int(min(max(int_len, 2), swing_len))
-    P_s, P_i, P_e = (_smc_pivots(h, l, k) for k in (swing_len, int_len, int(eq_len)))
-
-    new = lambda: {"lvl": np.nan, "crossed": True, "idx": -1}
-    sh, sl_, ih, il = new(), new(), new(), new()
-    s_tr = np.zeros(n, dtype=int)
-    i_tr = np.zeros(n, dtype=int)
-    top_a, bot_a = np.full(n, np.nan), np.full(n, np.nan)
-    swh_a, swl_a = np.full(n, np.nan), np.full(n, np.nan)
-    st = it = 0
-    top, bot = h[0], l[0]
-    events, obs, points, eqs, fvgs = [], [], [], [], []
-    act = []
-    ob_sup_a, ob_res_a = np.full(n, np.nan), np.full(n, np.nan)
-    def _new_ob(d):
-        obs.append(d)
-        act.append(d)
-        if len(act) > 60:
-            act.pop(0)
-    prev_hi = prev_lo = np.nan
-    eq_h = eq_l = None
-    dsum = 0.0
-    for i in range(n):
-        # --- swing / internal pivotlar
-        for kind, lvl, bi in P_s.get(i, []):
-            if kind == "H":
-                points.append((bi, lvl, "HH" if (np.isfinite(prev_hi) and lvl > prev_hi) else "LH", "H"))
-                prev_hi = lvl
-                sh.update(lvl=lvl, crossed=False, idx=bi)
-                top = lvl
-            else:
-                points.append((bi, lvl, "LL" if (np.isfinite(prev_lo) and lvl < prev_lo) else "HL", "L"))
-                prev_lo = lvl
-                sl_.update(lvl=lvl, crossed=False, idx=bi)
-                bot = lvl
-        for kind, lvl, bi in P_i.get(i, []):
-            (ih if kind == "H" else il).update(lvl=lvl, crossed=False, idx=bi)
-        # --- EQH / EQL
-        for kind, lvl, bi in P_e.get(i, []):
-            thr = eq_thr*atr[i] if np.isfinite(atr[i]) else 0.0
-            if kind == "H":
-                if eq_h is not None and abs(eq_h[0]-lvl) < thr:
-                    eqs.append(("EQH", eq_h[1], eq_h[0], bi, lvl, i))
-                eq_h = (lvl, bi)
-            else:
-                if eq_l is not None and abs(eq_l[0]-lvl) < thr:
-                    eqs.append(("EQL", eq_l[1], eq_l[0], bi, lvl, i))
-                eq_l = (lvl, bi)
-        # --- order block mitigasyonu (High/Low)
-        for ob in act:
-            if ob["on"] and ((ob["bull"] and l[i] < ob["lo"]) or (not ob["bull"] and h[i] > ob["hi"])):
-                ob["on"] = False
-        act[:] = [o_ for o_ in act if o_["on"]]
-        # --- yapı kırılımları
-        if i > 0:
-            for internal, hp, lp in ((True, ih, il), (False, sh, sl_)):
-                tr = it if internal else st
-                extra_u = (not internal) or (ih["lvl"] != sh["lvl"] and bool(bull_bar[i]))
-                extra_d = (not internal) or (il["lvl"] != sl_["lvl"] and bool(bear_bar[i]))
-                if (np.isfinite(hp["lvl"]) and not hp["crossed"] and c[i] > hp["lvl"] >= c[i-1]
-                        and extra_u):
-                    events.append({"i": i, "kind": "CHoCH" if tr == -1 else "BOS", "bull": True,
-                                   "internal": internal, "lvl": hp["lvl"], "from": hp["idx"]})
-                    hp["crossed"] = True
-                    seg = pl[hp["idx"]:i]
-                    if len(seg):
-                        j = hp["idx"] + int(np.argmin(seg))
-                        _new_ob({"bull": True, "internal": internal, "hi": float(ph[j]),
-                                    "lo": float(pl[j]), "idx": j, "on": True})
-                    if internal:
-                        it = 1
-                    else:
-                        st = 1
-                if (np.isfinite(lp["lvl"]) and not lp["crossed"] and c[i] < lp["lvl"] <= c[i-1]
-                        and extra_d):
-                    events.append({"i": i, "kind": "CHoCH" if tr == 1 else "BOS", "bull": False,
-                                   "internal": internal, "lvl": lp["lvl"], "from": lp["idx"]})
-                    lp["crossed"] = True
-                    seg = ph[lp["idx"]:i]
-                    if len(seg):
-                        j = lp["idx"] + int(np.argmax(seg))
-                        _new_ob({"bull": False, "internal": internal, "hi": float(ph[j]),
-                                    "lo": float(pl[j]), "idx": j, "on": True})
-                    if internal:
-                        it = -1
-                    else:
-                        st = -1
-        s_tr[i], i_tr[i] = st, it
-        top, bot = max(top, h[i]), min(bot, l[i])
-        top_a[i], bot_a[i] = top, bot
-        swh_a[i], swl_a[i] = sh["lvl"], sl_["lvl"]
-        ob_sup_a[i] = max((o_["lo"] for o_ in act if o_["bull"] and o_["lo"] < c[i]), default=np.nan)
-        ob_res_a[i] = min((o_["hi"] for o_ in act if (not o_["bull"]) and o_["hi"] > c[i]), default=np.nan)
-        # --- Fair Value Gap
-        if i >= 2:
-            delta = (c[i-1]-o[i-1])/(o[i-1]*100) if o[i-1] else 0.0
-            dsum += abs(delta)
-            thr = dsum/max(i, 1)*2
-            for g in fvgs:
-                if g["on"] and ((g["bull"] and l[i] < g["bot"]) or (not g["bull"] and h[i] > g["top"])):
-                    g["on"] = False
-            if l[i] > h[i-2] and c[i-1] > h[i-2] and delta > thr:
-                fvgs.append({"bull": True, "top": float(l[i]), "bot": float(h[i-2]), "idx": i-1, "on": True})
-            elif h[i] < l[i-2] and c[i-1] < l[i-2] and -delta > thr:
-                fvgs.append({"bull": False, "top": float(l[i-2]), "bot": float(h[i]), "idx": i-1, "on": True})
-    live = lambda internal, bull: [o_ for o_ in obs if o_["on"] and o_["internal"] == internal
-                                   and o_["bull"] == bull][-int(ob_keep):]
-    return {"swing_trend": s_tr, "internal_trend": i_tr, "top": top_a, "bot": bot_a, "sw_hi": swh_a, "sw_lo": swl_a, "ob_sup": ob_sup_a, "ob_res": ob_res_a, **mtf_prev_levels(df),
-            "events": events, "points": points, "eq": eqs,
-            "obs": live(True, True)+live(True, False)+live(False, True)+live(False, False),
-            "fvg": [g for g in fvgs if g["on"]][-8:], "strong_high": st == -1, "strong_low": st == 1}
-
-
-def add_smc_traces(fig, S, index, last_n=150, kw=None):
-    """SMC katmanlarını son `last_n` mumluk grafiğe ekler."""
-    kw = kw or {}
-    n = len(index)
-    w0 = max(0, n-int(last_n))
-    xi = lambda k: index[min(max(int(k), w0), n-1)]
-    for e in S["events"]:
-        if e["i"] < w0:
-            continue
-        col = "#16a34a" if e["bull"] else "#dc2626"
-        xa, xb = xi(e["from"]), xi(e["i"])
-        fig.add_trace(go.Scatter(x=[xa, xb], y=[e["lvl"], e["lvl"]], mode="lines",
-                                 line=dict(width=1 if e["internal"] else 2, color=col,
-                                           dash="dash" if e["internal"] else "solid"),
-                                 showlegend=False, hoverinfo="skip"), **kw)
-        mid = xa + (xb-xa)/2
-        fig.add_trace(go.Scatter(x=[mid], y=[e["lvl"]], mode="text", text=[e["kind"]],
-                                 textposition="top center" if e["bull"] else "bottom center",
-                                 textfont=dict(size=9 if e["internal"] else 11, color=col),
-                                 showlegend=False, hoverinfo="skip"), **kw)
-    for ob in S["obs"]:
-        col = "34,197,94" if ob["bull"] else "239,68,68"
-        fig.add_shape(type="rect", x0=xi(ob["idx"]), x1=index[-1], y0=ob["lo"], y1=ob["hi"],
-                      line=dict(width=1 if ob["internal"] else 0, color=f"rgb({col})"),
-                      fillcolor=f"rgba({col},{0.12 if ob['internal'] else 0.22})", layer="below", **kw)
-    for g in S["fvg"]:
-        if g["idx"] < w0:
-            continue
-        col = "34,197,94" if g["bull"] else "239,68,68"
-        fig.add_shape(type="rect", x0=xi(g["idx"]), x1=index[-1], y0=g["bot"], y1=g["top"],
-                      line=dict(width=0), fillcolor=f"rgba({col},0.10)", layer="below", **kw)
-    for kind, xa_i, la, xb_i, lb, _ in S["eq"]:
-        if xb_i < w0:
-            continue
-        fig.add_trace(go.Scatter(x=[xi(xa_i), xi(xb_i)], y=[la, lb], mode="lines+text",
-                                 text=["", kind], textposition="top center" if kind == "EQH" else "bottom center",
-                                 line=dict(width=1, dash="dot", color="#64748b"),
-                                 textfont=dict(size=10, color="#64748b"), showlegend=False,
-                                 hoverinfo="skip"), **kw)
-    for bi, lvl, lab, kd in S["points"]:
-        if bi >= w0:
-            fig.add_trace(go.Scatter(x=[index[bi]], y=[lvl], mode="text", text=[lab],
-                                     textposition="top center" if kd == "H" else "bottom center",
-                                     textfont=dict(size=9, color="#475569"), showlegend=False,
-                                     hoverinfo="skip"), **kw)
-    if S.get("show_mtf"):
-        for k_, nm_ in (("pdh", "PDH"), ("pdl", "PDL"), ("pwh", "PWH"), ("pwl", "PWL"),
-                        ("pmh", "PMH"), ("pml", "PML")):
-            y_ = S[k_][-1]
-            if np.isfinite(y_):
-                fig.add_trace(go.Scatter(x=[index[w0], index[-1]], y=[y_, y_], mode="lines+text",
-                                         text=["", nm_], textposition="top left",
-                                         line=dict(width=1, dash="dashdot", color="#0ea5e9"),
-                                         textfont=dict(size=9, color="#0ea5e9"), showlegend=False,
-                                         hoverinfo="skip"), **kw)
-    top, bot = float(S["top"][-1]), float(S["bot"][-1])
-    if np.isfinite(top) and np.isfinite(bot) and top > bot:
-        x0 = index[max(0, n-35)]
-        rng_ = top-bot
-        for y0, y1, col, nm in [(top, top-0.05*rng_, "239,68,68", "Premium"),
-                                (bot+0.525*rng_, bot+0.475*rng_, "148,163,184", "Equilibrium"),
-                                (bot+0.05*rng_, bot, "34,197,94", "Discount")]:
-            fig.add_shape(type="rect", x0=x0, x1=index[-1], y0=y0, y1=y1, line=dict(width=0),
-                          fillcolor=f"rgba({col},0.16)", layer="below", **kw)
-        for y, nm in [(top, "Strong High" if S["strong_high"] else "Weak High"),
-                      (bot, "Strong Low" if S["strong_low"] else "Weak Low")]:
-            fig.add_trace(go.Scatter(x=[x0, index[-1]], y=[y, y], mode="lines+text", text=["", nm],
-                                     textposition="top left", line=dict(width=1, color="#64748b"),
-                                     textfont=dict(size=9, color="#64748b"), showlegend=False,
-                                     hoverinfo="skip"), **kw)
-
-# ------------------------------------------- Gann Box (Zeiierman) Python portu
-def gann_box(df, lookback=150, reverse=False, levels=GANN_LEVELS):
-    """Görünen aralıktaki (son `lookback` mum) en yüksek / en düşük noktadan Gann Box kurar.
-    Zeiierman'ın TradingView göstergesinin açıklamasına göre yazıldı (Pine kaynağı birebir değil).
-    up: düşük, yüksekten ÖNCE geldiyse True (yükseliş kutusu). reverse: yönü çevirir."""
-    w = df.tail(int(lookback))
-    if len(w) < 10:
-        return None
-    hi_i, lo_i = int(np.argmax(w.High.to_numpy(float))), int(np.argmin(w.Low.to_numpy(float)))
-    hi, lo = float(w.High.iloc[hi_i]), float(w.Low.iloc[lo_i])
-    if hi <= lo:
-        return None
-    up = lo_i < hi_i
-    if reverse:
-        up = not up
-    # kutu: pencerenin başı -> sonu; seviyeler lo + p*(hi-lo)
-    lv = {float(p): lo + float(p)*(hi-lo) for p in levels}
-    return {"x0": w.index[0], "x1": w.index[-1], "n": len(w), "hi": hi, "lo": lo,
-            "up": up, "levels": lv, "hi_date": w.index[hi_i], "lo_date": w.index[lo_i]}
-
-
-def gann_signal(df, lookback=150):
-    """Her mum için yalnızca geçmişe bakan Gann Box %50 konumu: kapanış orta çizgi üstünde +1,
-    altında -1 (kutu o muma kadarki son `lookback` mumdan kurulur)."""
-    lb = int(lookback)
-    hi = df.High.rolling(lb, min_periods=lb).max()
-    lo = df.Low.rolling(lb, min_periods=lb).min()
-    mid = (hi+lo)/2
-    c = df.Close
-    out = np.where(c > mid, 1, np.where(c < mid, -1, 0))
-    out = np.where(mid.isna(), 0, out)
-    return out.astype(int), ((c-lo)/(hi-lo).replace(0, np.nan)).to_numpy(float)
-
-
-def add_gann_traces(fig, gb, df_index, extend=True, fan=True, kw=None):
-    """Kutu, yüzde seviyeleri ve (isteğe bağlı) Gann Fan çizgilerini Plotly grafiğine ekler."""
-    kw = kw or {}
-    x0, x1, n = gb["x0"], gb["x1"], gb["n"]
-    step = (df_index[-1]-df_index[-2]) if len(df_index) > 1 else pd.Timedelta(days=1)
-    x_end = x1 + step*int(n*0.5) if extend else x1
-    hi, lo = gb["hi"], gb["lo"]
-    fig.add_shape(type="rect", x0=x0, x1=x1, y0=lo, y1=hi, line=dict(width=1, color="#64748b"),
-                  fillcolor="rgba(100,116,139,0.05)", layer="below", **kw)
-    pal = {0.0: "#16a34a", 0.236: "#84cc16", 0.382: "#eab308", 0.5: "#f59e0b",
-           0.618: "#f97316", 0.786: "#ef4444", 1.0: "#dc2626"}
-    for p, y in gb["levels"].items():
-        fig.add_trace(go.Scatter(x=[x0, x_end], y=[y, y], mode="lines+text",
-                                 text=["", f"Gann {p:.3f} · {fmt_p(y)}"], textposition="middle right",
-                                 line=dict(width=1, dash="dot", color=pal.get(p, "#94a3b8")),
-                                 name=f"Gann {p:.3f}", showlegend=False, hoverinfo="name+y"), **kw)
-    if fan:
-        # köşe: yükseliş kutusunda düşük (sol-alt), düşüşte yüksek (sol-üst); 1x1 = karşı köşeye köşegen
-        y_start = lo if gb["up"] else hi
-        sign = 1 if gb["up"] else -1
-        base = (hi-lo)/max(gb["n"]-1, 1)       # 1x1 eğimi (fiyat/mum)
-        steps = (x_end - x0)/step
-        for mult, nm in GANN_FAN:
-            y_end = y_start + sign*base*mult*steps
-            ya, yb = (y_start, y_end)
-            # kutu dışına taşan kısmı kes
-            lo_c, hi_c = lo - (hi-lo)*0.5, hi + (hi-lo)*0.5
-            if ya == yb:
-                continue
-            t_hit = min(1.0, max(0.0, ((hi_c if yb > ya else lo_c)-ya)/(yb-ya)))
-            xe = x0 + (x_end-x0)*t_hit
-            ye = ya + (yb-ya)*t_hit
-            fig.add_trace(go.Scatter(x=[x0, xe], y=[ya, ye], mode="lines",
-                                     line=dict(width=1.6 if mult == 1 else 0.8,
-                                               color="#2563eb" if mult == 1 else "#93c5fd"),
-                                     name=f"Gann Fan {nm}", showlegend=(mult == 1),
-                                     hoverinfo="name"), **kw)
-
-
-def _profile(h, l, v, bins):
-    """Bar hacmini high-low aralığına, kutularla örtüştüğü oranda dağıtır (VPVR mantığı)."""
-    lo, hi = float(np.min(l)), float(np.max(h))
-    if not (np.isfinite(lo) and np.isfinite(hi)) or hi <= lo:
-        return None
-    v = np.where(np.isfinite(v) & (v > 0), v, 0.0)
-    if v.sum() <= 0:          # hacim verisi yok (ör. forex) -> zaman bazlı profil
-        v = np.ones_like(v)
-    edges = np.linspace(lo, hi, bins+1)
-    step = (hi-lo)/bins
-    rng = np.maximum(h-l, 1e-12)
-    ov = np.clip(np.minimum(h[:, None], edges[None, 1:]) - np.maximum(l[:, None], edges[None, :-1]), 0, None)
-    frac = ov/rng[:, None]
-    zr = (h-l) <= 1e-12
-    if zr.any():
-        frac[zr] = 0.0
-        frac[zr, np.clip(((h[zr]-lo)/step).astype(int), 0, bins-1)] = 1.0
-    return edges, (frac*v[:, None]).sum(axis=0)
-
-
-def _value_area(edges, prof, va_pct):
-    pi = int(np.argmax(prof))
-    lo_i = hi_i = pi
-    acc, target = float(prof[pi]), va_pct*float(prof.sum())
-    nb = len(prof)
-    while acc < target and (lo_i > 0 or hi_i < nb-1):
-        up = prof[hi_i+1] if hi_i < nb-1 else -1.0
-        dn = prof[lo_i-1] if lo_i > 0 else -1.0
-        if up >= dn:
-            hi_i += 1
-            acc += up
-        else:
-            lo_i -= 1
-            acc += dn
-    return float((edges[pi]+edges[pi+1])/2), float(edges[lo_i]), float(edges[hi_i+1])
-
-
-def volume_profile(df, window=60, bins=24, va_pct=0.70):
-    """Kayan Volume Profile: her mum için son `window` mumdan POC / VAL / VAH.
-    Yalnızca o muma kadar olan veri kullanılır (ileriye bakma yok)."""
-    h, l, v = (df[c].to_numpy(float) for c in ("High", "Low", "Volume"))
-    n = len(h)
-    out = np.full((n, 3), np.nan)
-    for i in range(window-1, n):
-        sl = slice(i-window+1, i+1)
-        p = _profile(h[sl], l[sl], v[sl], bins)
-        if p is None:
-            continue
-        out[i] = _value_area(p[0], p[1], va_pct)
-    return pd.DataFrame(out, index=df.index, columns=["poc", "val", "vah"])
-
-
-def latest_profile(df, window, bins, va_pct):
-    w = df.tail(int(window))
-    p = _profile(w.High.to_numpy(float), w.Low.to_numpy(float), w.Volume.to_numpy(float), int(bins))
-    if p is None:
-        return None
-    poc, val, vah = _value_area(p[0], p[1], va_pct)
-    return p[0], p[1], poc, val, vah
-
-
-def vp_signal(df, atr, vp, ext_atr):
-    """+1: long onaylı (kapanış POC üstünde ve VAH'ın ext_atr*ATR'den fazla üstünde değil),
-    -1: short onaylı (POC altında ve VAL'ın ext_atr*ATR'den fazla altında değil), 0: onay yok."""
-    c, a = df.Close.to_numpy(float), atr.to_numpy(float)
-    poc, val, vah = (vp[k].to_numpy(float) for k in ("poc", "val", "vah"))
-    with np.errstate(invalid="ignore"):
-        ok_l = (c > poc) & ((c-vah) <= ext_atr*a)
-        ok_s = (c < poc) & ((val-c) <= ext_atr*a)
-    return np.where(ok_l, 1, np.where(ok_s, -1, 0)).astype(int)
-
-
-# ------------------------------------------- Lorentzian Classification (jdehorty) portu
-def adx_wilder(df, n=14):
-    h, l, c = df.High, df.Low, df.Close
-    up, dn = h.diff(), -l.diff()
-    plus = pd.Series(np.where((up > dn) & (up > 0), up, 0.0), index=df.index)
-    minus = pd.Series(np.where((dn > up) & (dn > 0), dn, 0.0), index=df.index)
-    tr = pd.concat([(h-l), (h-c.shift(1)).abs(), (l-c.shift(1)).abs()], axis=1).max(axis=1)
-    a = 1/n
-    atr = tr.ewm(alpha=a, adjust=False).mean()
-    pdi = 100*plus.ewm(alpha=a, adjust=False).mean()/atr
-    mdi = 100*minus.ewm(alpha=a, adjust=False).mean()/atr
-    dx = 100*(pdi-mdi).abs()/(pdi+mdi).replace(0, np.nan)
-    return dx.ewm(alpha=a, adjust=False).mean().to_numpy(float)
-
-
-def _norm01(x):
-    """Geçmiş min/max'a göre 0-1 ölçekleme (TV 'normalize'); yalnızca geçmişe bakar."""
-    s = pd.Series(x)
-    lo, hi = s.cummin(), s.cummax()
-    return ((s-lo)/(hi-lo).replace(0, np.nan)).to_numpy(float)
-
-
-def _ldc_features(df):
-    src = (df.High+df.Low+df.Close)/3
-    ema = lambda s, n: s.ewm(span=max(int(n), 1), adjust=False).mean()
-    rsi = lambda n: ema(calc_rsi(src, n)/100, 1).to_numpy(float)
-    e1 = ema(src, 10)
-    e2 = ema((src-e1).abs(), 10)
-    wt1 = ema((src-e1)/(0.015*e2).replace(0, np.nan), 11)
-    wt = _norm01((wt1-wt1.rolling(4).mean()).to_numpy(float))
-    ma = src.rolling(20).mean()
-    md = src.rolling(20).apply(lambda a: np.abs(a-a.mean()).mean(), raw=True)
-    cci = _norm01(((src-ma)/(0.015*md.replace(0, np.nan))).to_numpy(float))
-    adx = adx_wilder(df, 20)/100
-    # varsayılan öznitelikler: RSI(14,1), WT(10,11), CCI(20,1), ADX(20,2), RSI(9,1)
-    return np.column_stack([rsi(14), wt, cci, adx, rsi(9)]), src.to_numpy(float)
-
-
-def ldc_classify(df, k=8, max_back=2000, regime_thr=-0.1, kern_lb=8, kern_rw=8.0, x0=25,
-                 use_vol=True, use_regime=True, use_adx=False, adx_thr=20, use_kernel=True, exact=True):
-    """Machine Learning: Lorentzian Classification (jdehorty) Python portu.
-    Lorentzian mesafe = sum(log(1+|x-y|)); exact=True: gerçek k-NN, False: Pine'ın yaklaşık-NN döngüsü;
-    etiket = 4 bar sonraki yön. Filtreler: volatilite, rejim (Kalman eğimi), ADX; kernel:
-    Nadaraya-Watson rational quadratic. Her mum yalnızca kendisine kadarki veriyi kullanır.
-    state: +1 / -1 (ML sinyali + kernel eğimi aynı yönde), 0 onay yok."""
-    n = len(df)
-    F, s = _ldc_features(df)
-    y = np.full(n, np.nan)
-    y[:-4] = np.sign(s[4:]-s[:-4])
-    ok_f = np.isfinite(F).all(axis=1)
-    cand = ok_f & np.isfinite(y) & (np.arange(n) % 4 != 0)
-    kk = int(k)
-    cut = int(np.floor(kk*0.75+0.5))
-    pred = np.zeros(n)
-    for t in range(60, n):
-        if not ok_f[t]:
-            continue
-        hi_j = t-4                       # etiketi t'de bilinen son örnek
-        lo_j = max(0, hi_j-int(max_back)+1)
-        sel = np.flatnonzero(cand[lo_j:hi_j+1]) + lo_j
-        if len(sel) < kk:
-            continue
-        D = np.log1p(np.abs(F[sel]-F[t])).sum(axis=1)
-        if exact:   # gerçek k en yakın komşu (Lorentzian mesafe)
-            nn_ = np.argpartition(D, kk-1)[:kk]
-            pred[t] = y[sel][nn_].sum()
-            continue
-        last, dist, pr = -1.0, [], []   # Pine'ın kronolojik yaklaşık-NN döngüsü
-        for d, yv in zip(D.tolist(), y[sel].tolist()):
-            if d >= last:
-                dist.append(d)
-                pr.append(yv)
-                if len(dist) > kk:
-                    last = dist[cut]
-                    dist.pop(0)
-                    pr.pop(0)
-        pred[t] = sum(pr)
-
-    # --- filtreler
-    f_vol = (calc_atr(df, 1).to_numpy(float) > calc_atr(df, 10).to_numpy(float)) if use_vol \
-        else np.ones(n, bool)
-    f_reg = np.ones(n, bool)
-    if use_regime:
-        o4 = ((df.Open+df.High+df.Low+df.Close)/4).to_numpy(float)
-        hl = (df.High-df.Low).to_numpy(float)
-        v1 = v2 = kl = 0.0
-        klmf = np.zeros(n)
-        for i in range(n):
-            v1 = 0.2*(o4[i]-(o4[i-1] if i else o4[i]))+0.8*v1
-            v2 = 0.1*hl[i]+0.8*v2
-            om = abs(v1/v2) if v2 else 0.0
-            al = (-om**2+np.sqrt(om**4+16*om**2))/8
-            kl = al*o4[i]+(1-al)*kl
-            klmf[i] = kl
-        slope = pd.Series(np.abs(np.diff(klmf, prepend=klmf[0])))
-        ema_s = slope.ewm(span=200, adjust=False).mean()
-        f_reg = (((slope-ema_s)/ema_s.replace(0, np.nan)) >= float(regime_thr)).fillna(False).to_numpy(bool)
-    f_adx = (adx_wilder(df, 14) > float(adx_thr)) if use_adx else np.ones(n, bool)
-    filt = f_vol & f_reg & f_adx
-
-    sig = np.zeros(n, dtype=int)
-    for t in range(1, n):
-        sig[t] = 1 if (pred[t] > 0 and filt[t]) else -1 if (pred[t] < 0 and filt[t]) else sig[t-1]
-
-    # --- kernel regresyon (rational quadratic), yalnızca geçmiş barlar
-    L = int(kern_lb)+int(x0)
-    i_ = np.arange(L+1)
-    w = (1+i_**2/(float(kern_lb)**2*2*float(kern_rw)))**(-float(kern_rw))
-    yhat = np.full(n, np.nan)
-    for t in range(n):
-        m = min(L+1, t+1)
-        yhat[t] = (w[:m]*s[t-np.arange(m)]).sum()/w[:m].sum()
-    bull = np.r_[False, yhat[1:] > yhat[:-1]]
-    bear = np.r_[False, yhat[1:] < yhat[:-1]]
-    if use_kernel:
-        state = np.where((sig == 1) & bull, 1, np.where((sig == -1) & bear, -1, 0)).astype(int)
-    else:
-        state = sig.copy()
-    state[:60] = 0
-    return {"state": state, "signal": sig, "pred": pred, "yhat": yhat,
-            "vol": f_vol, "reg": f_reg, "adx": f_adx}
-
-
-def regime_labels(features, ref_vol):
-    # Volatilite kantilleri yalnızca geliştirme dönemi verisinden alınır (sızıntı yok).
-    q1, q2 = ref_vol.dropna().quantile([0.33, 0.67])
-    vol, trend = features["vol_20"], features["ema_gap_20"]
-    vname = np.where(vol <= q1, "LOW_VOL", np.where(vol >= q2, "HIGH_VOL", "MID_VOL"))
-    tname = np.where(trend > 0.02, "UP", np.where(trend < -0.02, "DOWN", "RANGE"))
-    return pd.Series([f"{t}_{v}" for t, v in zip(tname, vname)], index=features.index)
-
-
-def make_target(df, atr, horizon, threshold=0.20):
-    fwd = df.Close.shift(-horizon)/df.Close-1
-    band = threshold*(atr/df.Close)*np.sqrt(horizon)
-    y = pd.Series(np.where(fwd > band, 1, np.where(fwd < -band, -1, 0)), index=df.index)
-    return y.where(fwd.notna() & band.notna()), fwd
-
-
-# ---------------------------------------------------------------- model
-def pipe(k):
-    return Pipeline([
-        ("imputer", SimpleImputer(strategy="median")),
-        ("scale", StandardScaler()),
-        ("knn", KNeighborsClassifier(n_neighbors=int(k), weights="distance"))
-    ])
-
-
-def tune_k(X, y, h):
-    # İç kronolojik doğrulama; örtüşen etiketleri önlemek için ufuk kadar purge.
-    cut = int(len(X)*0.80)
-    tr_end = cut-h
-    if tr_end <= max(K_GRID)+20 or len(X)-cut < 25:
-        return 9, []
-    scores = []
-    for k in K_GRID:
-        model = pipe(k).fit(X.iloc[:tr_end], y.iloc[:tr_end])
-        pred = model.predict(X.iloc[cut:])
-        scores.append((float(balanced_accuracy_score(y.iloc[cut:], pred)), int(k)))
-    scores.sort(reverse=True)
-    return scores[0][1], scores
-
-
-def calibrate_current(raw_cal, y_cal, raw_cur, classes):
-    # Bire-karşı-hepsi isotonic kalibrasyon; küçük kalibrasyon setinde ham olasılık.
-    classes = list(classes)
-    raw_vec = np.zeros(len(CLASSES))
-    out = np.zeros(len(CLASSES))
-    for j, cls in enumerate(CLASSES):
-        if cls not in classes:
-            continue
-        ci = classes.index(cls)
-        val = raw_cur[0, ci]
-        raw_vec[j] = val
-        truth = (np.asarray(y_cal) == cls).astype(int)
-        if len(truth) >= 35 and len(np.unique(truth)) == 2:
-            iso = IsotonicRegression(out_of_bounds="clip").fit(raw_cal[:, ci], truth)
-            out[j] = iso.predict([val])[0]
-        else:
-            out[j] = val
-    if out.sum() > 0:
-        return out/out.sum()
-    if raw_vec.sum() > 0:
-        return raw_vec/raw_vec.sum()
-    return np.full(len(CLASSES), 1/3)
-
-
-# ---------------------------------------------------------------- bariyer / R
-def stop_dist(A, i, side, sl_atr):
-    return A["ind_sd"][side][i] if "ind_sd" in A else sl_atr*A["a"][i]
-
-
-def barrier_trade(A, i, side, sl_atr, rr, h):
-    """(getiri, çıkış_pozisyonu, neden) döndürür. Aynı mumda SL+TP varsa SL kabul edilir."""
-    entry, av = A["c"][i], A["a"][i]
-    if not np.isfinite(av) or av <= 0 or not np.isfinite(entry):
-        return None
-    if "ind_sd" in A:   # SL/TP indikatör seviyelerinden (ST / UT / Volume Profile)
-        sd = A["ind_sd"][side][i]
-        if not np.isfinite(sd) or sd <= 0:
-            return None
-        td = min(sd*rr, A["ind_cap"][side][i])
-    else:
-        sd = sl_atr*av
-        td = sd*rr
-    end = min(i+h, len(A["c"])-1)
-    for j in range(i+1, end+1):
-        hi, lo = A["h"][j], A["l"][j]
-        if side == 1:
-            sl_hit, tp_hit = lo <= entry-sd, hi >= entry+td
-        else:
-            sl_hit, tp_hit = hi >= entry+sd, lo <= entry-td
-        if sl_hit:
-            return -sd/entry, j, "SL"
-        if tp_hit:
-            return td/entry, j, "TP"
-    return side*(A["c"][end]-entry)/entry, end, "TIME"
-
-
-def optimize_barriers(A, pos, regimes_arr, side, cost, current_regime, h):
-    pos = list(pos)[-650:]
-    sel = [i for i in pos if regimes_arr[i] == current_regime]
-    if len(sel) < 35:
-        sel, used = pos, "GLOBAL_FALLBACK"
-    else:
-        used = str(current_regime)
-    results = []
-    for sl in ([1.0] if "ind_sd" in A else SL_GRID):
-        for rr in RR_GRID:
-            vals = []
-            for i in sel:
-                t = barrier_trade(A, i, side, sl, rr, h)
-                if t is not None:
-                    vals.append(t[0]-cost)
-            if len(vals) >= 35:
-                a = np.asarray(vals)
-                downside = np.sqrt(np.mean(np.minimum(a, 0)**2))
-                results.append((a.mean()-0.35*downside, sl, rr, len(a),
-                                a.mean(), (a > 0).mean()))
-    if not results:
-        return 1.5, 2.0, [], used
-    results.sort(reverse=True)
-    return float(results[0][1]), float(results[0][2]), results[:10], used
-
-
-# ---------------------------------------------------------------- risk / MC
-def dd_mult(dd):
-    return np.select([dd <= -0.20, dd <= -0.15, dd <= -0.10, dd <= -0.06],
-                     [0.20, 0.35, 0.50, 0.75], 1.0)
-
-
-def adaptive_risk(min_risk, max_risk, bacc, agreement, expectancy_r, n_trades, drawdown):
-    # Açık, deterministik politika (pekiştirmeli öğrenme değildir).
-    quality = np.clip((bacc-0.33)/0.20, 0, 1)
-    agree = np.clip((agreement-0.33)/0.50, 0, 1)
-    edge = np.clip(expectancy_r/0.30, 0, 1)
-    sample = np.clip(n_trades/40, 0, 1)
-    score = 0.30*quality+0.25*agree+0.30*edge+0.15*sample
-    risk = min_risk+(max_risk-min_risk)*score
-    if drawdown <= -0.20:
-        risk = min_risk
-    elif drawdown <= -0.15:
-        risk = min_risk+(risk-min_risk)*0.20
-    elif drawdown <= -0.10:
-        risk = min_risk+(risk-min_risk)*0.40
-    elif drawdown <= -0.06:
-        risk = min_risk+(risk-min_risk)*0.70
-    return float(np.clip(risk, min_risk, max_risk)), float(score)
-
-
-def simulate_equity(r_values, base_risk_pct):
-    eq, peak = 1.0, 1.0
-    curve, dds = [1.0], [0.0]
-    for r in r_values:
-        risk = base_risk_pct/100*float(dd_mult(eq/peak-1))
-        eq *= max(0.01, 1+risk*float(r))
-        peak = max(peak, eq)
-        curve.append(eq)
-        dds.append(eq/peak-1)
-    return np.array(curve), np.array(dds)
-
-
-def risk_path_mc(r_multiples, base_risk_pct, sims=2000, n_trades=100):
-    # R biriminde bootstrap; kayıp 1R ile sınırlanmaz (maliyet nedeniyle ~-1.05R olabilir).
-    if len(r_multiples) < 10:
-        return None
-    rng = np.random.default_rng(20261103)
-    S = rng.choice(np.asarray(r_multiples, float), size=(sims, n_trades), replace=True)
-    eq, peak, mdd = np.ones(sims), np.ones(sims), np.zeros(sims)
-    paths = np.empty((n_trades+1, sims))
-    paths[0] = 1.0
-    for t in range(n_trades):
-        risk = base_risk_pct/100*dd_mult(eq/peak-1)
-        eq = eq*np.maximum(0.01, 1+risk*S[:, t])
-        peak = np.maximum(peak, eq)
-        mdd = np.minimum(mdd, eq/peak-1)
-        paths[t+1] = eq
-    fin = eq-1
-    return {"median": float(np.median(fin)), "p05": float(np.percentile(fin, 5)),
-            "p95": float(np.percentile(fin, 95)), "dd95": float(np.percentile(mdd, 5)),
-            "ruin": float(np.mean(eq < 0.5)),
-            "pct": np.percentile(paths, [5, 25, 50, 75, 95], axis=1)-1.0}
-
-
-# ---------------------------------------------------------------- yardımcılar
-def fmt_p(x):
-    return f"{x:,.2f}" if abs(x) >= 100 else f"{x:,.4f}"
-
-
-def md_table(header, rows):
-    if not rows:
-        return "_Veri yok._"
-    out = ["| " + " | ".join(header) + " |", "|" + "|".join(["---"]*len(header)) + "|"]
-    out += ["| " + " | ".join(str(c) for c in r) + " |" for r in rows]
-    return "\n".join(out)
-
-
-def trade_stats(R, curve, dds, trades_df):
-    if len(R) == 0:
-        return None
-    wins, losses = R[R > 0].sum(), -R[R < 0].sum()
-    reasons = trades_df.exit_reason.value_counts().to_dict()
-    return {"n": len(R), "win": float((R > 0).mean()), "exp": float(R.mean()),
-            "pf": float(wins/losses) if losses > 0 else float("inf"),
-            "ret": float(curve[-1]-1), "mdd": float(dds.min()),
-            "tp": reasons.get("TP", 0), "sl": reasons.get("SL", 0),
-            "time": reasons.get("TIME", 0)}
-
-
-TRADE_COLS = ["entry_date", "exit_date", "side", "entry_price", "exit_reason",
-              "net_return_pct", "R", "regime"]
-
-
-# ---------------------------------------------------------------- grafikler
-def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=None, vp_prof=None,
-                 ldc=None, combo=None, gann=None, gann_fan=True, gann_extend=True, smc=None):
-    w = df.tail(150)
-    sub = vp is not None and vp_prof is not None
-    if sub:
-        fig = make_subplots(rows=1, cols=2, shared_yaxes=True,
-                            column_widths=[0.86, 0.14], horizontal_spacing=0.005)
-    else:
-        fig = go.Figure()
-    kw = dict(row=1, col=1) if sub else {}
-    fig.add_trace(go.Candlestick(x=w.index, open=w.Open, high=w.High, low=w.Low,
-                                 close=w.Close, name=ticker), **kw)
-    for n, col in [(20, "#f59e0b"), (50, "#3b82f6")]:
-        ema = df.Close.ewm(span=n, adjust=False).mean().tail(150)
-        fig.add_trace(go.Scatter(x=w.index, y=ema, mode="lines", name=f"EMA{n}",
-                                 line=dict(width=1.2, color=col)), **kw)
-    if ind is not None:
-        st_line, st_dir, ut_stop = (np.asarray(a)[-150:] for a in ind)
-        for d, col, nm in [(1, "#16a34a", "Supertrend ↑"), (-1, "#dc2626", "Supertrend ↓")]:
-            fig.add_trace(go.Scatter(x=w.index, y=np.where(st_dir == d, st_line, np.nan),
-                                     mode="lines", name=nm, line=dict(width=1.5, color=col)), **kw)
-        fig.add_trace(go.Scatter(x=w.index, y=ut_stop, mode="lines", name="UT trailing stop",
-                                 line=dict(width=1, dash="dot", color="#9333ea")), **kw)
-    if sub:
-        vw = vp.tail(150)
-        for k, col, dash, nm in [("poc", "#f59e0b", "solid", "POC"),
-                                 ("vah", "#64748b", "dash", "VAH"),
-                                 ("val", "#64748b", "dash", "VAL")]:
-            fig.add_trace(go.Scatter(x=w.index, y=vw[k], mode="lines", name=nm,
-                                     line=dict(width=1.4, color=col, dash=dash)), **kw)
-        edges, prof, poc, val, vah = vp_prof
-        mid = (edges[:-1]+edges[1:])/2
-        colors = ["#f59e0b" if edges[k] <= poc <= edges[k+1]
-                  else ("#60a5fa" if val <= mid[k] <= vah else "#cbd5e1")
-                  for k in range(len(mid))]
-        fig.add_trace(go.Bar(x=prof, y=mid, orientation="h", width=(edges[1]-edges[0])*0.95,
-                             marker_color=colors, name="Volume Profile", showlegend=False,
-                             hoverinfo="skip"), row=1, col=2)
-        fig.update_xaxes(showticklabels=False, row=1, col=2)
-    if ldc is not None:
-        yh = np.asarray(ldc["yhat"])[-150:]
-        rising = np.r_[False, np.diff(yh) > 0]
-        for flag, col, nm in [(True, "#16a34a", "Lorentzian kernel ↑"), (False, "#dc2626", "Lorentzian kernel ↓")]:
-            fig.add_trace(go.Scatter(x=w.index, y=np.where(rising == flag, yh, np.nan), mode="lines",
-                                     name=nm, line=dict(width=2, color=col)), **kw)
-        st_ = np.asarray(ldc["state"])[-150:]
-        prev = np.r_[0, st_[:-1]]
-        for d, nm, col, ycol, off in [(1, "LDC long", "#15803d", "Low", 0.995),
-                                      (-1, "LDC short", "#b91c1c", "High", 1.005)]:
-            m_ = (st_ == d) & (prev != d)
-            if m_.any():
-                fig.add_trace(go.Scatter(x=w.index[m_], y=w[ycol].to_numpy()[m_]*off, mode="markers",
-                                         name=nm, marker=dict(symbol="diamond", size=8, color=col,
-                                                              line=dict(width=1, color="white"))), **kw)
-    if combo is not None:
-        cs = np.asarray(combo)[-150:]
-        pv = np.r_[0, cs[:-1]]
-        for d, nm, col, ycol, off in [(1, "Birleşik LONG", "#f59e0b", "Low", 0.985),
-                                      (-1, "Birleşik SHORT", "#7c3aed", "High", 1.015)]:
-            m_ = (cs == d) & (pv != d)
-            if m_.any():
-                fig.add_trace(go.Scatter(x=w.index[m_], y=w[ycol].to_numpy()[m_]*off, mode="markers",
-                                         name=nm, marker=dict(symbol="star", size=12, color=col,
-                                                              line=dict(width=1, color="white"))), **kw)
-    if len(trades_df):
-        t = trades_df[trades_df.entry_date.isin(w.index)]
-        for side, sym, nm in [("LONG", "triangle-up", "OOS long"),
-                              ("SHORT", "triangle-down", "OOS short")]:
-            s = t[t.side == side]
-            if len(s):
-                fig.add_trace(go.Scatter(
-                    x=s.entry_date, y=s.entry_price, mode="markers", name=nm,
-                    marker=dict(symbol=sym, size=9,
-                                color=["#16a34a" if r > 0 else "#dc2626" for r in s.R],
-                                line=dict(width=1, color="white")),
-                    text=[f"R={r:.2f} · {why}" for r, why in zip(s.R, s.exit_reason)]), **kw)
-    if smc is not None:
-        add_smc_traces(fig, smc, df.index, last_n=150, kw=kw)
-    if gann is not None:
-        add_gann_traces(fig, gann, df.index, extend=gann_extend, fan=gann_fan, kw=kw)
-    if trade_ok:
-        fig.add_hline(y=stop, line_dash="dash", line_color="#dc2626", annotation_text="SL", **kw)
-        fig.add_hline(y=target, line_dash="dash", line_color="#16a34a", annotation_text="TP", **kw)
-    fig.update_layout(title=f"{ticker} Günlük — son 150 mum (üçgenler: OOS sinyalleri)"
-                            + (" + Volume Profile" if sub else "") + (" + Gann Box" if gann is not None else "") + (" + SMC" if smc is not None else ""),
-                      height=560, xaxis_rangeslider_visible=False)
-    return fig
-
-
-def prob_figure(p_down, p_flat, p_up):
-    fig = go.Figure(go.Bar(x=["DOWN", "FLAT", "UP"], y=[p_down*100, p_flat*100, p_up*100],
-                           marker_color=["#dc2626", "#9ca3af", "#16a34a"],
-                           text=[f"{p*100:.1f}%" for p in (p_down, p_flat, p_up)],
-                           textposition="outside"))
-    fig.update_layout(title="Kalibre edilmiş olasılıklar", height=300,
-                      yaxis=dict(range=[0, 100], title="%"), margin=dict(t=50, b=30))
-    return fig
-
-
-def equity_figure(curve, dds):
-    x = np.arange(len(curve))
-    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.7, 0.3],
-                        vertical_spacing=0.06)
-    fig.add_trace(go.Scatter(x=x, y=(curve-1)*100, mode="lines", name="Kümülatif getiri %"), 1, 1)
-    fig.add_trace(go.Scatter(x=x, y=dds*100, fill="tozeroy", name="Drawdown %",
-                             line=dict(color="#dc2626")), 2, 1)
-    fig.update_xaxes(title_text="İşlem #", row=2, col=1)
-    fig.update_layout(title="OOS backtest — adaptif risk ile bileşik özsermaye", height=520)
-    return fig
-
-
-def pf_gauge(pf, n):
-    shown = 3.0 if np.isinf(pf) else float(min(pf, 3.0))
-    fig = go.Figure(go.Indicator(
-        mode="gauge+number", value=shown,
-        number=dict(valueformat=".2f", suffix=" (∞)" if np.isinf(pf) else ""),
-        title=dict(text=f"Profit Factor — OOS ({n} işlem)"),
-        gauge=dict(
-            axis=dict(range=[0, 3]),
-            bar=dict(color="#1d4ed8"),
-            steps=[dict(range=[0, 1], color="#fecaca"),
-                   dict(range=[1, 1.5], color="#fef08a"),
-                   dict(range=[1.5, 3], color="#bbf7d0")],
-            threshold=dict(line=dict(color="black", width=3), thickness=0.8, value=1.0))))
-    fig.update_layout(height=320, margin=dict(t=70, b=20))
-    return fig
-
-
-def mc_figure(mc):
-    p = mc["pct"]*100
-    x = np.arange(p.shape[1])
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=x, y=p[0], line=dict(width=0), showlegend=False, hoverinfo="skip"))
-    fig.add_trace(go.Scatter(x=x, y=p[4], fill="tonexty", line=dict(width=0),
-                             fillcolor="rgba(59,130,246,0.15)", name="%5–%95"))
-    fig.add_trace(go.Scatter(x=x, y=p[1], line=dict(width=0), showlegend=False, hoverinfo="skip"))
-    fig.add_trace(go.Scatter(x=x, y=p[3], fill="tonexty", line=dict(width=0),
-                             fillcolor="rgba(59,130,246,0.30)", name="%25–%75"))
-    fig.add_trace(go.Scatter(x=x, y=p[2], line=dict(color="#1d4ed8", width=2), name="Medyan"))
-    fig.update_layout(title="Monte Carlo — 100 işlemlik getiri yelpazesi (%)",
-                      xaxis_title="İşlem #", yaxis_title="Getiri %", height=460)
-    return fig
-
-
-# ---------------------------------------------------------------- ana motor
-def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
-               max_leverage, fee, slip, train_window,
-               p_min, p_gap, flat_max, agree_min, bacc_min, min_trades,
-               skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
-               vp_mode, vp_window, vp_bins, vp_va, vp_ext,
-               ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
-               ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact,
-               combo_mode, combo_votes, ind_tpsl, tpsl_smin, tpsl_smax, tpsl_minrr,
-               gann_mode, gann_lb, gann_fan_on, gann_ext_on, gann_rev,
-               smc_mode, smc_src, smc_swing_len, smc_int_len, smc_zone, smc_draw,
-               smc_conf, smc_obf, smc_lvl):
-    try:
-        ticker = str(ticker).strip().upper()
-        h = int(horizon)
-        equity, fee, slip = float(equity), float(fee), float(slip)
-        min_risk, max_risk = float(min_risk), float(max_risk)
-        if max_risk < min_risk:
-            raise ValueError("Maksimum risk, minimum riskten küçük olamaz.")
-        cost = 2*(fee+slip)/100
-        allow = {1: side_mode != "Sadece Short", -1: side_mode != "Sadece Long"}
-
-        df = get_market_data(ticker, period)
-        if len(df) < 450:
-            raise ValueError("En az 450 günlük mum gerekli.")
-        df = df.iloc[:-1].copy()  # tamamlanmamış güncel mumu çıkar
-        vp_on = vp_mode != VP_MODES[0]
-        vp_feat = vp_mode == VP_MODES[2]
-        vp_win, vp_nb, vp_vap = int(vp_window), int(vp_bins), float(vp_va)
-        vp = volume_profile(df, vp_win, vp_nb, vp_vap)
-        X_all, atr_all = make_features(df, vp if vp_feat else None)
-        vp_arr = vp_signal(df, atr_all, vp, float(vp_ext))
-        vp_names = {1: "LONG onaylı", -1: "SHORT onaylı", 0: "onay yok"}
-        vp_no_vol = float(df.Volume.tail(vp_win).sum()) <= 0
-        lp = latest_profile(df, vp_win, vp_nb, vp_vap)
-        y_all, _ = make_target(df, atr_all, h)
-        gann_on = gann_mode != GANN_MODES[0]
-        gann_arr, gann_pos = gann_signal(df, int(gann_lb))
-        gann_now = int(gann_arr[-1])
-        GB = gann_box(df, int(gann_lb), bool(gann_rev))
-        smc_on = smc_mode != SMC_MODES[0]
-        smc_only = smc_mode == SMC_MODES[2]
-        SM = smc_analyze(df, int(smc_swing_len), int(smc_int_len), confluence=bool(smc_conf),
-                         ob_filter=smc_obf) if (smc_on or smc_draw) else None
-        smc_lvl_on = bool(smc_lvl) and SM is not None and smc_on
-        if SM is not None:
-            SM["show_mtf"] = bool(smc_lvl)
-        smc_arr = np.zeros(len(df), dtype=int)
-        if SM is not None:
-            smc_arr = (SM["swing_trend"] if smc_src == SMC_SRC[0] else SM["internal_trend"]).copy()
-            if smc_zone:   # LuxAlgo Premium/Discount kutuları: uçlarda %5, equilibrium %47.5-%52.5
-                top_, bot_ = SM["top"], SM["bot"]
-                rng_ = top_ - bot_
-                close_ = df.Close.to_numpy(float)
-                discount_edge = bot_ + 0.05*rng_
-                premium_edge = top_ - 0.05*rng_
-                zone_ = np.where(close_ <= discount_edge, 1,
-                                 np.where(close_ >= premium_edge, -1, 0))
-                smc_arr = np.where(zone_ == smc_arr, smc_arr, 0).astype(int)
-        smc_now = int(smc_arr[-1])
-        smc_entry = np.zeros(len(df), dtype=int)   # yalnızca yapı kırılımı mumlarında giriş
-        if SM is not None:
-            want_internal = smc_src == SMC_SRC[1]
-            ev_arr = np.zeros(len(df), dtype=int)
-            for e_ in SM["events"]:
-                if e_["internal"] == want_internal:
-                    ev_arr[e_["i"]] = 1 if e_["bull"] else -1
-            smc_entry = np.where(ev_arr == smc_arr, ev_arr, 0).astype(int)
-
-        valid = X_all.notna().all(axis=1) & y_all.notna()
-        X = X_all.loc[valid].copy()
-        y = y_all.loc[X.index].astype(int)
-        if len(X) < 300:
-            raise ValueError("Temiz özelliklerden sonra yeterli veri kalmadı.")
-
-        oos_n = min(180, max(75, int(len(X)*0.22)))
-        dev_end = len(X)-oos_n-h
-        if dev_end < 200:
-            raise ValueError("OOS ayrımı için yeterli geliştirme verisi yok.")
-        tw = int(train_window)
-        dev_X, dev_y = X.iloc[:dev_end], y.iloc[:dev_end]
-        if len(dev_X) > tw:
-            dev_X, dev_y = dev_X.iloc[-tw:], dev_y.iloc[-tw:]
-
-        regimes_all = regime_labels(X_all, X_all.loc[dev_X.index, "vol_20"])
-        reg_arr = regimes_all.to_numpy()
-        A = {"h": df.High.to_numpy(float), "l": df.Low.to_numpy(float),
-             "c": df.Close.to_numpy(float), "a": atr_all.to_numpy(float)}
-        pos_of = lambda idx: df.index.get_indexer(idx)
-
-        # --- indikatörler (Supertrend + UT Bot), tamamen Python'da
-        st_dir, st_line = supertrend(df, int(st_period), float(st_mult))
-        ut_pos, ut_stop = ut_bot(df, float(ut_key), int(ut_period))
-        ind_arr = np.where((st_dir == ut_pos) & (ut_pos != 0), ut_pos, 0).astype(int)
-        ind_only = ind_mode == "Sadece indikatör"
-        ind_confirm = ind_mode == IND_MODES[1]
-        ind_now = int(ind_arr[-1])
-
-        # --- Lorentzian Classification (ML + kernel) ve birleşik sinyal (oylama)
-        combo_on = combo_mode != COMBO_MODES[0]
-        combo_only = combo_mode == COMBO_MODES[2]
-        ldc_on = ldc_mode != LDC_MODES[0] and not combo_only
-        ldc_only = ldc_mode == LDC_MODES[2] and not combo_only
-        ldc_confirm = ldc_mode == LDC_MODES[1] and not combo_only
-        if combo_only:   # oylar zaten birleşik sinyale girer; tekil filtreler çift sayılmasın
-            ind_only = ind_confirm = vp_on = False
-        ind_only = ind_only and not ldc_only      # iki "Sadece" modu birlikteyse Lorentzian öncelikli
-        if smc_only:   # backtest yalnızca SMC girişlerine göre; diğer sinyal/filtre modları devre dışı
-            ind_only = ind_confirm = vp_on = ldc_on = ldc_only = ldc_confirm = False
-            combo_on = combo_only = False
-        need_ldc = ldc_mode != LDC_MODES[0] or combo_on
-        LD = ldc_classify(df, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
-                          use_vol=bool(ldc_use_vol), use_regime=bool(ldc_use_regime),
-                          use_adx=bool(ldc_use_adx), use_kernel=bool(ldc_kernel),
-                          exact=bool(ldc_exact)) if need_ldc else None
-        ldc_arr = LD["state"] if LD else np.zeros(len(df), dtype=int)
-        ldc_now = int(ldc_arr[-1])
-        vp_now = int(vp_arr[-1])
-        votes = np.vstack([ind_arr, ldc_arr, vp_arr])     # ST+UT, Lorentzian, Volume Profile
-        n_long, n_short = (votes == 1).sum(axis=0), (votes == -1).sum(axis=0)
-        mv = int(combo_votes)
-        combo_arr = np.where((n_long >= mv) & (n_short == 0), 1,
-                             np.where((n_short >= mv) & (n_long == 0), -1, 0)).astype(int)
-        combo_now = int(combo_arr[-1])
-
-        # --- indikatör bazlı SL/TP: en yakın ST / UT / VP seviyesi = invalidasyon (SL),
-        #     önündeki Value Area / POC seviyesi >= 1 ATR uzaktaysa TP üst sınırı
-        ind_tpsl = bool(ind_tpsl)
-        if ind_tpsl:
-            c_, a_ = A["c"], A["a"]
-            vpo, vpl, vph = (vp[k].to_numpy(float) for k in ("poc", "val", "vah"))
-
-            def nearest(levels, sign):   # sign=+1: seviye fiyatın altında, -1: üstünde
-                d = np.full(len(c_), np.inf)
-                for lv in levels:
-                    dd = sign*(c_-lv)
-                    ok = np.isfinite(dd) & (dd > 0)
-                    d = np.where(ok & (dd < d), dd, d)
-                return d
-            smin, smax = float(tpsl_smin), float(tpsl_smax)
-            sd_of = lambda d: np.clip(np.where(np.isfinite(d), d+0.1*a_, 1.5*a_), smin*a_, smax*a_)
-            cap_of = lambda d: np.where(d >= 1.0*a_, d, np.inf)
-            lv_l = [st_line, ut_stop, vpl] + ([SM["sw_lo"]] if (smc_only and SM is not None) else [])
-            lv_s = [st_line, ut_stop, vph] + ([SM["sw_hi"]] if (smc_only and SM is not None) else [])
-            cap_l, cap_s = [vpo, vph], [vpo, vpl]
-            if smc_lvl_on:   # Order Block + önceki D/W/M high-low: SL referansı ve TP sınırı
-                lv_l += [SM["ob_sup"], SM["pdl"], SM["pwl"], SM["pml"]]
-                lv_s += [SM["ob_res"], SM["pdh"], SM["pwh"], SM["pmh"]]
-                cap_l += [SM["ob_res"], SM["pdh"], SM["pwh"], SM["pmh"]]
-                cap_s += [SM["ob_sup"], SM["pdl"], SM["pwl"], SM["pml"]]
-            A["ind_sd"] = {1: sd_of(nearest(lv_l, 1)),
-                           -1: sd_of(nearest(lv_s, -1))}
-            A["ind_cap"] = {1: cap_of(nearest(cap_l, -1)),
-                            -1: cap_of(nearest(cap_s, 1))}
-
-        # --- K seçimi, kalibrasyon, güncel olasılık
-        best_k, k_scores = tune_k(dev_X, dev_y, h)
-        cal_n = min(120, max(45, int(len(dev_X)*0.20)))
-        fit_end = len(dev_X)-cal_n-h
-        if fit_end <= 100:
-            raise ValueError("Kalibrasyon için eğitim verisi yetersiz.")
-        fit_X, fit_y = dev_X.iloc[:fit_end], dev_y.iloc[:fit_end]
-        cal_X, cal_y = dev_X.iloc[fit_end+h:], dev_y.iloc[fit_end+h:]
-        cal_model = pipe(best_k).fit(fit_X, fit_y)
-        classes_now = cal_model.named_steps["knn"].classes_
-        current_x = X_all.iloc[[-1]]
-        probs = calibrate_current(cal_model.predict_proba(cal_X), cal_y.to_numpy(),
-                                  cal_model.predict_proba(current_x), classes_now)
-        p_down, p_flat, p_up = (float(p) for p in probs)
-
-        if side_mode == "Sadece Long":
-            side = 1
-        elif side_mode == "Sadece Short":
-            side = -1
-        else:
-            side = 1 if p_up >= p_down else -1
-        if ind_only and ind_now != 0 and allow[ind_now]:
-            side = ind_now
-        if ldc_only and ldc_now != 0 and allow[ldc_now]:
-            side = ldc_now
-        if combo_only and combo_now != 0 and allow[combo_now]:
-            side = combo_now
-        if smc_only and smc_now != 0 and allow[smc_now]:
-            side = smc_now
-        p_side, p_opp = (p_up, p_down) if side == 1 else (p_down, p_up)
-
-        imp, scaler = cal_model.named_steps["imputer"], cal_model.named_steps["scale"]
-        nn = NearestNeighbors(n_neighbors=best_k).fit(scaler.transform(imp.transform(fit_X)))
-        _, idx = nn.kneighbors(scaler.transform(imp.transform(current_x)))
-        agreement = float((fit_y.iloc[idx[0]].to_numpy() == side).mean())
-        if ind_only:  # indikatör modunda: son 10 mumda yönün sürekliliği
-            agreement = float((ind_arr[-10:] == side).mean())
-        if ldc_only:
-            agreement = float((ldc_arr[-10:] == side).mean())
-        if combo_only:
-            agreement = float((combo_arr[-10:] == side).mean())
-        if smc_only:
-            agreement = float((smc_arr[-10:] == side).mean())
-
-        # --- yön bazlı TP/SL optimizasyonu (yalnızca geliştirme verisi)
-        current_regime = str(regimes_all.iloc[-1])
-        dev_pos = pos_of(dev_X.index)
-        params, top, regime_used = {}, [], "—"
-
-        def opt_pos(s_):
-            f_ = list(dev_pos)
-            if ind_only or ind_confirm:
-                f_ = [i for i in f_ if ind_arr[i] == s_]
-            if ldc_on:
-                f_ = [i for i in f_ if ldc_arr[i] == s_]
-            if combo_on:
-                f_ = [i for i in f_ if combo_arr[i] == s_]
-            if vp_on:
-                f_ = [i for i in f_ if vp_arr[i] == s_]
-            if gann_on:
-                f_ = [i for i in f_ if gann_arr[i] == s_]
-            if smc_on and not smc_only:
-                f_ = [i for i in f_ if smc_arr[i] == s_]
-            if smc_only:
-                f_ = [i for i in f_ if smc_entry[i] == s_]
-            return f_ if len(f_) >= 35 else dev_pos
-        for s in (1, -1):
-            if allow[s]:
-                sl_s, rr_s, top_s, used_s = optimize_barriers(
-                    A, opt_pos(s), reg_arr, s, cost, current_regime, h)
-                params[s] = (sl_s, rr_s)
-                if s == side:
-                    top, regime_used = top_s, used_s
-        sl, rr = params[side]
-
-        # --- dokunulmamış OOS bloğu
-        oos_X = X.iloc[dev_end+h:]
-        oos_y = y.loc[oos_X.index]
-        oos_pred = pipe(best_k).fit(dev_X, dev_y).predict(oos_X)
-        oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
-        oos_acc = float(accuracy_score(oos_y, oos_pred))
-        oos_pos_arr = pos_of(oos_X.index)
-        if ldc_only:  # Lorentzian yönü OOS'ta tahmin yerine geçer
-            oos_pred = ldc_arr[oos_pos_arr]
-            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
-            oos_acc = float(accuracy_score(oos_y, oos_pred))
-        if combo_only:  # birleşik sinyal OOS'ta tahmin yerine geçer
-            oos_pred = combo_arr[oos_pos_arr]
-            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
-            oos_acc = float(accuracy_score(oos_y, oos_pred))
-        if ind_only:  # indikatör yönü OOS'ta tahmin yerine geçer
-            oos_pred = ind_arr[oos_pos_arr]
-            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
-            oos_acc = float(accuracy_score(oos_y, oos_pred))
-
-        if smc_only:   # metrik: SMC yön durumu; işlem: yapı kırılımı mumları
-            oos_pred = smc_arr[oos_pos_arr]
-            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
-            oos_acc = float(accuracy_score(oos_y, oos_pred))
-            oos_pred = smc_entry[oos_pos_arr]
-        rows, busy = [], -1
-        for i, pred in zip(oos_pos_arr, oos_pred):
-            pred = int(pred)
-            if pred == 0 or not allow[pred]:
-                continue
-            if ind_confirm and ind_arr[i] != pred:
-                continue
-            if vp_on and vp_arr[i] != pred:
-                continue
-            if gann_on and gann_arr[i] != pred:
-                continue
-            if smc_on and smc_arr[i] != pred:
-                continue
-            if ldc_confirm and ldc_arr[i] != pred:
-                continue
-            if combo_on and combo_arr[i] != pred:
-                continue
-            if skip_overlap and i <= busy:
-                continue
-            sl_p, rr_p = params[pred]
-            t = barrier_trade(A, i, pred, sl_p, rr_p, h)
-            if t is None:
-                continue
-            ret, j, why = t
-            net = ret-cost
-            r = net/max(stop_dist(A, i, pred, sl_p)/A["c"][i], 1e-12)
-            rows.append((df.index[i], df.index[j], "LONG" if pred == 1 else "SHORT",
-                         A["c"][i], why, net*100, r, reg_arr[i]))
-            busy = j
-        trades_df = pd.DataFrame(rows, columns=TRADE_COLS)
-        R = trades_df.R.to_numpy() if len(trades_df) else np.array([])
-        expectancy_r = float(R.mean()) if len(R) else 0.0
-
-        recent = df.Close.tail(30)
-        drawdown = float(recent.iloc[-1]/recent.cummax().iloc[-1]-1)
-        risk_pct, _ = adaptive_risk(min_risk, max_risk, oos_bacc, agreement,
-                                    expectancy_r, len(R), drawdown)
-        curve, dds = simulate_equity(R, risk_pct)
-        stats = trade_stats(R, curve, dds, trades_df)
-        mc = risk_path_mc(R, risk_pct) if len(R) else None
-
-        # --- güncel seviyeler ve pozisyon
-        entry, cur_atr = float(df.Close.iloc[-1]), float(atr_all.iloc[-1])
-        if ind_tpsl:
-            stop_d = float(A["ind_sd"][side][-1])
-            target_d = float(min(stop_d*rr, A["ind_cap"][side][-1]))
-            cl_ = float(A["c"][-1])
-            cands = {"Supertrend": float(st_line[-1]), "UT trailing stop": float(ut_stop[-1]),
-                     "VP " + ("VAL" if side == 1 else "VAH"):
-                         float((vp.val if side == 1 else vp.vah).iloc[-1])}
-            if smc_lvl_on:
-                kk_ = ("ob_sup", "pdl", "pwl", "pml") if side == 1 else ("ob_res", "pdh", "pwh", "pmh")
-                for k_, nm_ in zip(kk_, ("SMC OB", "Önceki gün", "Önceki hafta", "Önceki ay")):
-                    cands[nm_] = float(SM[k_][-1])
-            if smc_only and SM is not None:
-                cands["SMC swing " + ("low" if side == 1 else "high")] = float(SM["sw_lo" if side == 1 else "sw_hi"][-1])
-            valid = {k_: side*(cl_-v_) for k_, v_ in cands.items() if np.isfinite(v_) and side*(cl_-v_) > 0}
-            sl_name = min(valid, key=valid.get) if valid else "ATR varsayılan (seviye yok)"
-        else:
-            stop_d, target_d = sl*cur_atr, sl*cur_atr*rr
-        stop = entry-stop_d if side == 1 else entry+stop_d
-        target = entry+target_d if side == 1 else entry-target_d
-
-        risk_cash = equity*risk_pct/100
-        cost_per_unit = stop_d+entry*cost
-        qty = risk_cash/cost_per_unit if cost_per_unit > 0 else 0.0
-        max_notional = equity*float(max_leverage)
-        capped = qty*entry > max_notional
-        if capped:
-            qty = max_notional/entry
-        if whole_units:
-            qty = float(np.floor(qty))
-        notional = qty*entry
-        actual_risk = qty*cost_per_unit
-        margin = notional/max(float(max_leverage), 1)
-
-        # --- işlem kapısı (her kontrol ayrı gösterilir)
-        checks = [
-            ("Y��n izni", side_mode, "—", allow[side]),
-            ("P(yön)", f"{p_side:.1%}", f"≥ {p_min:.0%}", p_side >= p_min),
-            ("P(yön) − P(karşı)", f"{(p_side-p_opp):.1%}", f"≥ {p_gap:.0%}", (p_side-p_opp) >= p_gap),
-            ("P(FLAT)", f"{p_flat:.1%}", f"< {flat_max:.0%}", p_flat < flat_max),
-            ("Komşu yön uyumu", f"{agreement:.1%}", f"≥ {agree_min:.0%}", agreement >= agree_min),
-            ("OOS balanced acc.", f"{oos_bacc:.3f}", f"≥ {bacc_min:.2f}", oos_bacc >= bacc_min),
-            ("OOS işlem sayısı", f"{len(R)}", f"≥ {int(min_trades)}", len(R) >= int(min_trades)),
-            ("OOS expectancy", f"{expectancy_r:.3f}R", "> 0", expectancy_r > 0),
-        ]
-        dname = {1: "LONG ↑", -1: "SHORT ↓", 0: "belirsiz"}
-        ind_check = ("İndikatör yönü (ST + UT aynı)", dname[ind_now], "yönle aynı", ind_now == side)
-        if ind_only or ldc_only or combo_only or smc_only:
-            keep = ("Yön izni", "OOS balanced acc.", "OOS işlem sayısı", "OOS expectancy")
-            if smc_only:
-                keep = tuple(k_ for k_ in keep if k_ != "OOS balanced acc.")
-            checks = [c for c in checks if c[0] in keep]
-        if ind_only or ind_confirm:
-            checks.insert(1, ind_check)
-        if ldc_on:
-            checks.insert(1, ("Lorentzian yönü (ML + kernel)", dname[ldc_now], "yönle aynı",
-                              ldc_now == side))
-        if combo_on:
-            nv = int(sum(1 for v_ in (ind_now, ldc_now, vp_now) if v_ == side))
-            no_ = int(sum(1 for v_ in (ind_now, ldc_now, vp_now) if v_ == -side))
-            checks.insert(1, ("Birleşik sinyal (ST+UT · Lorentzian · VP)", f"{nv}/3 oy, karşı {no_}",
-                              f"≥ {mv} oy, karşı oy yok", combo_now == side))
-        if ind_tpsl:
-            rr_now = target_d/stop_d if stop_d > 0 else 0.0
-            checks.append(("İndikatör R:R (TP/SL)", f"{rr_now:.2f}", f"≥ {float(tpsl_minrr):g}",
-                           rr_now >= float(tpsl_minrr)))
-        if vp_on:
-            checks.insert(1, ("Volume Profile (POC/VA konumu)", vp_names[int(vp_arr[-1])],
-                              "yönle aynı", int(vp_arr[-1]) == side))
-        if gann_on:
-            checks.insert(1, ("Gann Box (%50 konumu)", dname[gann_now], "yönle aynı", gann_now == side))
-        if smc_on:
-            checks.insert(1, (f"SMC yapı yönü ({smc_src}" + (" + premium/discount)" if smc_zone else ")"),
-                              dname[smc_now], "yönle aynı", smc_now == side))
-        trade_ok = all(c[3] for c in checks)
-        if trade_ok:
-            signal = "LONG" if side == 1 else "SHORT"
-        else:
-            signal = "WAIT — İŞLEM AÇMA"
-            qty = notional = margin = actual_risk = 0.0
-        gate_md = md_table(["Kontrol", "Değer", "Eşik", "Durum"],
-                           [(n, v, t, "✅" if ok else "❌") for n, v, t, ok in checks])
-
-        # --- rapor
-        if stats:
-            pf = "∞" if np.isinf(stats["pf"]) else f"{stats['pf']:.2f}"
-            oos_md = md_table(["Ölçüm", "Değer"], [
-                ("İşlem sayısı", stats["n"]),
-                ("Kazanma oranı", f"{stats['win']:.1%}"),
-                ("Expectancy", f"{stats['exp']:.3f}R"),
-                ("Profit factor", pf),
-                (f"Toplam getiri (risk {risk_pct:.2f}%)", f"{stats['ret']:.2%}"),
-                ("Maks. drawdown", f"{stats['mdd']:.2%}"),
-                ("Çıkış dağılımı TP / SL / süre", f"{stats['tp']} / {stats['sl']} / {stats['time']}"),
-            ])
-            g = trades_df.groupby("regime").R.agg(["count", "mean", lambda s: (s > 0).mean()])
-            reg_md = md_table(["Rejim", "İşlem", "Ort. R", "Kazanma"],
-                              [(r, int(c), f"{m:.3f}", f"{w:.1%}")
-                               for r, (c, m, w) in g.iterrows()])
-        else:
-            oos_md = reg_md = "_OOS işlem yok._"
-
-        mc_text = (
-            f"100 işlem · 2.000 bootstrap senaryosu · medyan: {mc['median']:.2%} · "
-            f"%5 kötü sonuç: {mc['p05']:.2%} · %95 iyi sonuç: {mc['p95']:.2%} · "
-            f"%5 kuyruk max DD: {mc['dd95']:.2%} · "
-            f"%50 sermaye altına inme frekansı: {mc['ruin']:.1%}"
-            if mc else "Monte Carlo için yeterli OOS işlem yok.")
-        ind_md = md_table(["İndikatör", "Yön", "Seviye"], [
-            (f"Supertrend ({int(st_period)}, {float(st_mult):g})", dname[int(st_dir[-1])], fmt_p(float(st_line[-1]))),
-            (f"UT Bot ({float(ut_key):g}, {int(ut_period)})", dname[int(ut_pos[-1])], fmt_p(float(ut_stop[-1]))),
-            ("Bileşik (ikisi aynı yönde)", dname[ind_now], "—")])
-        if lp is not None:
-            _, _, poc_n, val_n, vah_n = lp
-            pos_txt = ("VA üstünde" if entry > vah_n else "VA altında" if entry < val_n
-                       else "VA içinde · POC üstü" if entry > poc_n else "VA içinde · POC altı")
-            vp_md = md_table(["Seviye", "Fiyat"], [
-                ("VAH (Value Area üst)", fmt_p(vah_n)), ("POC (en yüksek hacim)", fmt_p(poc_n)),
-                ("VAL (Value Area alt)", fmt_p(val_n)), ("Son kapanış", f"{fmt_p(entry)} — {pos_txt}"),
-                ("VP yön onayı", vp_names[int(vp_arr[-1])])])
-        else:
-            vp_md = "_Profil hesaplanamadı._"
-        vp_note = (f"Pencere {vp_win} mum · {vp_nb} kutu · Value Area %{vp_vap*100:.0f} · "
-                   f"uzama sınırı {float(vp_ext):g} ATR."
-                   + (" Hacim verisi yok → zaman bazlı profil kullanıldı." if vp_no_vol else "")
-                   + (" Mod Kapalı: yalnızca bilgi amaçlı." if not vp_on else ""))
-        if SM is not None:
-            last_ev = [e for e in SM["events"] if not e["internal"]][-1:] or [None]
-            last_iv = [e for e in SM["events"] if e["internal"]][-1:] or [None]
-            evtxt = lambda e: "—" if e is None else (f"{e['kind']} {'↑' if e['bull'] else '↓'} · {fmt_p(e['lvl'])} · "
-                                                    f"{df.index[e['i']].date()}")
-            tp_, bt_ = float(SM["top"][-1]), float(SM["bot"][-1])
-            zpos = (entry-bt_)/(tp_-bt_) if tp_ > bt_ else float("nan")
-            zname = ("—" if not np.isfinite(zpos) else
-                     "Premium" if zpos >= 0.95 else
-                     "Discount" if zpos <= 0.05 else
-                     "Equilibrium")
-            obt = lambda b: [o_ for o_ in SM["obs"] if o_["bull"] == b and not o_["internal"]][-1:]
-            ob_txt = lambda b: (f"{fmt_p(obt(b)[0]['lo'])} – {fmt_p(obt(b)[0]['hi'])}" if obt(b) else "—")
-            smc_md = md_table(["Bileşen", "Değer"], [
-                ("Swing yapı yönü", dname[int(SM["swing_trend"][-1])]),
-                ("Internal yapı yönü", dname[int(SM["internal_trend"][-1])]),
-                ("Son swing kırılımı", evtxt(last_ev[0])), ("Son internal kırılımı", evtxt(last_iv[0])),
-                ("Premium / Discount", f"{zname}" + (f" (%{zpos*100:.0f})" if np.isfinite(zpos) else "")),
-                ("Strong/Weak High · Low", f"{'Strong' if SM['strong_high'] else 'Weak'} {fmt_p(tp_)} · "
-                                           f"{'Strong' if SM['strong_low'] else 'Weak'} {fmt_p(bt_)}"),
-                ("Aktif swing OB (bull)", ob_txt(True)), ("Aktif swing OB (bear)", ob_txt(False)),
-                ("Önceki gün H / L", f"{fmt_p(SM['pdh'][-1])} / {fmt_p(SM['pdl'][-1])}"),
-                ("Önceki hafta H / L", f"{fmt_p(SM['pwh'][-1])} / {fmt_p(SM['pwl'][-1])}"),
-                ("Önceki ay H / L", f"{fmt_p(SM['pmh'][-1])} / {fmt_p(SM['pml'][-1])}"),
-                ("Açık FVG sayısı", len(SM["fvg"])), ("SMC yön onayı", dname[smc_now])])
-            smc_note = (f"Swing {int(smc_swing_len)} · internal {int(smc_int_len)} mum"
-                        + (" · premium/discount kapısı açık" if smc_zone else "")
-                        + (" · internal confluence filtresi (LuxAlgo Pine koşulları)" if smc_conf else "")
-                        + " · BOS/CHoCH yalnızca pivot doğrulandıktan ve kapanış seviyesi kırdıktan sonra sayılır"
-                        + f" · OB filtresi: {smc_obf}"
-                        + (" · OB + önceki D/W/M seviyeleri SL/TP'de" if smc_lvl_on else "")
-                        + (" · Mod Kapalı: yalnızca bilgi/grafik." if not smc_on else "") + ".")
-        else:
-            smc_md, smc_note = "_Mod kapalı._", ""
-        if GB is not None:
-            gpos = gann_pos[-1]
-            gann_md = md_table(["Seviye", "Fiyat"],
-                [(f"{p:.3f}" + (" (orta)" if p == 0.5 else ""), fmt_p(y)) for p, y in sorted(GB["levels"].items(), reverse=True)]
-                + [("Son kapanış", f"{fmt_p(entry)} — kutu içi konum %{gpos*100:.0f}" if np.isfinite(gpos) else fmt_p(entry)),
-                   ("Kutu yönü", "yükseliş (düşük → yüksek)" if GB["up"] else "düşüş (yüksek → düşük)"),
-                   ("Gann yön onayı", dname[gann_now])])
-            gann_note = (f"Pencere {int(gann_lb)} mum · yüksek {GB['hi_date'].date()} · düşük {GB['lo_date'].date()}"
-                         + (" · yön çevrildi (reverse)" if gann_rev else "")
-                         + (" · Mod Kapalı: yalnızca bilgi amaçlı." if not gann_on else "") + ".")
-        else:
-            gann_md, gann_note = "_Kutu hesaplanamadı._", ""
-        if LD is not None:
-            fl = lambda on, arr: "kapalı" if not on else ("✅" if bool(arr[-1]) else "❌")
-            ldc_md = md_table(["Bileşen", "Değer"], [
-                ("Lorentzian yönü (ML + kernel)", dname[ldc_now]),
-                ("ML sinyali (filtreli)", dname[int(LD["signal"][-1])]),
-                ("ML tahmin skoru", f"{int(LD['pred'][-1]):+d} / ±{int(ldc_k)}"),
-                ("Kernel tahmini · eğim", f"{fmt_p(float(LD['yhat'][-1]))} · "
-                                          f"{'↑' if LD['yhat'][-1] > LD['yhat'][-2] else '↓'}"),
-                ("Volatilite / Rejim / ADX filtresi",
-                 f"{fl(ldc_use_vol, LD['vol'])} / {fl(ldc_use_regime, LD['reg'])} / {fl(ldc_use_adx, LD['adx'])}")])
-            ldc_note = (f"{int(ldc_k)} komşu · en fazla {int(ldc_back)} geçmiş mum · kernel "
-                        f"({int(ldc_kern_lb)}, {float(ldc_kern_rw):g}) · rejim eşiği {float(ldc_regime):g}.")
-        else:
-            ldc_md, ldc_note = "_Mod kapalı._", ""
-        if combo_on:
-            combo_md = md_table(["Kaynak", "Oy"], [
-                ("Supertrend + UT Bot", dname[ind_now]), ("Lorentzian (ML + kernel)", dname[ldc_now]),
-                ("Volume Profile (POC/VA)", dname[vp_now]),
-                ("**Birleşik sinyal**", f"**{dname[combo_now]}** (en az {mv} oy, karşı oy yok)")])
-        else:
-            combo_md = "_SMC-only modunda devre dışı._" if smc_only else "_Mod kapalı._"
-        if ind_tpsl:
-            capped = target_d < stop_d*rr-1e-12
-            tp_title = "indikatörlerden türetildi"
-            tpsl_note = (f"SL: en yakın invalidasyon seviyesi — **{sl_name}** (+0,1 ATR tampon, "
-                         f"{float(tpsl_smin):g}–{float(tpsl_smax):g} ATR aralığına sıkıştırılır). "
-                         f"TP: {rr:.2f}R katı"
-                         + (", önündeki VA/POC/SMC OB/MTF seviyesinde sınırlandı" if capped else "")
-                         + ". Optimize edilen tek parametre R katıdır.\n\n")
-        else:
-            tp_title, tpsl_note = "optimize", ""
-        k_text = " | ".join(f"K={k}: {s:.3f}" for s, k in sorted(k_scores, reverse=True)) or "—"
-        overlap_note = ("tek pozisyon (çakışma yok)" if skip_overlap
-                        else "çakışan sinyaller bağımsız işlem sayıldı")
-        report = f"""
-# {signal}
-
-**Son kapanmış mum:** {df.index[-1].date()} · **{ticker} referans fiyatı:** {fmt_p(entry)} · **Ufuk:** {h} gün
-
-## Kapı kontrolleri
-{gate_md}
-
-## {ticker} — Kalibre edilmiş KNN
-| Ölçüm | Değer |
-|---|---:|
-| P(UP) / P(FLAT) / P(DOWN) | {p_up:.1%} / {p_flat:.1%} / {p_down:.1%} |
-| Seçilen K | {best_k} |
-| OOS accuracy | {oos_acc:.3f} |
-| Güncel rejim | {current_regime} |
-
-**K seçim skorları:** {k_text}
-
-## İndikatörler — mod: {ind_mode}
-{ind_md}
-
-## Birleşik sinyal — mod: {combo_mode}
-{combo_md}
-
-## Lorentzian Classification — mod: {ldc_mode}
-{ldc_md}
-
-{ldc_note}
-
-## Volume Profile — mod: {vp_mode}
-{vp_md}
-
-{vp_note}
-
-## Smart Money Concepts (LuxAlgo) — mod: {smc_mode}
-{smc_md}
-
-{smc_note}
-
-## Gann Box (Zeiierman) — mod: {gann_mode}
-{gann_md}
-
-{gann_note}
-
-## TP / SL ({'LONG' if side == 1 else 'SHORT'} için {tp_title})
-| Parametre | Değer |
-|---|---:|
-| SL | {stop_d/cur_atr:.2f} ATR |
-| TP | {target_d/stop_d:.2f}R |
-| Stop-loss | {fmt_p(stop)} |
-| Take-profit | {fmt_p(target)} |
-| ATR(14) | {fmt_p(cur_atr)} |
-
-{tpsl_note}TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geliştirme dönemine geri dönülür.
-
-## OOS backtest ({overlap_note})
-{oos_md}
-
-**Rejim bazlı OOS:**
-
-{reg_md}
-
-## Risk-bütçeli pozisyon ({ticker})
-| Parametre | Değer |
-|---|---:|
-| Hesap büyüklüğü | ${equity:,.2f} |
-| Adaptif risk | {risk_pct:.3f}% |
-| Risk bütçesi | ${risk_cash:,.2f} |
-| Varlık miktarı (birim) | {qty:.8f} |
-| Nominal pozisyon | ${notional:,.2f} |
-| Tahmini teminat | ${margin:,.2f} |
-| Tahmini stop kaybı + maliyet | ${actual_risk:,.2f} |
-| Kaldıraç sınırı | {"Uygulandı" if capped else "Uygulanmadı"} |
-| Son 30 günlük kapanış DD | {drawdown:.2%} |
-
-## Monte Carlo
-{mc_text}
-"""
-        top_df = pd.DataFrame(top, columns=["score", "SL_ATR", "TP_R", "samples",
-                                            "mean_net_return", "win_rate"])
-        if ind_tpsl and not top_df.empty:
-            top_df["SL_ATR"] = "indikatör"
-        if not top_df.empty:
-            top_df["score"] = top_df.score.map(lambda v: f"{v:.5f}")
-            top_df["mean_net_return"] = top_df.mean_net_return.map(lambda v: f"{v:.3%}")
-            top_df["win_rate"] = top_df.win_rate.map(lambda v: f"{v:.1%}")
-
-        csv_path = None
-        if len(trades_df):
-            safe = re.sub(r"[^A-Za-z0-9_-]", "_", ticker)
-            csv_path = os.path.join(tempfile.gettempdir(), f"goshawk_{safe}_oos_trades.csv")
-            trades_df.to_csv(csv_path, index=False)
-
-        price_fig = price_figure(df, ticker, trades_df, trade_ok, stop, target,
-                                 ind=(st_line, st_dir, ut_stop),
-                                 vp=vp if (vp_on or combo_on) else None, vp_prof=lp,
-                                 ldc=LD, combo=combo_arr if combo_on else None,
-                                 gann=GB, gann_fan=bool(gann_fan_on), gann_extend=bool(gann_ext_on), smc=SM)
-        eq_fig = equity_figure(curve, dds) if len(R) else None
-        pf_fig = pf_gauge(stats["pf"], stats["n"]) if stats else None
-        mc_fig = mc_figure(mc) if mc else None
-
-        disclaimer = (
-            "**Araştırma prototipi; otomatik emir göndermez.** KNN olasılık kalibrasyonu tek bir "
-            "tarihsel kalibrasyon dilimine dayanır ve küçük örneklerde ham olasılığa geri döner. "
-            "TP/SL optimizasyonu geliştirme döneminde ve yön bazında yapılır; son dönem OOS olarak "
-            "ayrılır. Rejim etiketleri geliştirme verisinin volatilite kantillerine dayanır; canlı "
-            "dağılım değişebilir. Adaptif risk yüzdesi OOS metriklerinden türetildiği için OOS "
-            "özsermaye eğrisi iyimser olabilir. Günlük mumda SL ve TP aynı mumda görülürse SL "
-            "varsayılır. Monte Carlo, OOS R-multiple serisini bootstrap eder; bağımsızlık varsayımı "
-            "seri korelasyonunu ve rejim değişimini tam modellemez. Pozisyon hesabı spot miktar "
-            "varsayar; CFD lot sözleşmesi, spread, funding, swap, komisyon, minimum lot, marjin ve "
-            "broker fiyatı farklı olabilir. Gap ve kayma kaybı planlanan riskin üstüne çıkarabilir. "
-            "Supertrend ve UT Bot, TradingView formüllerinin Python portudur; ATR başlangıcı ve veri kaynağı yüzünden TV değerlerinden küçük sapmalar olabilir. Birleşik sinyal; ST+UT, Lorentzian ve Volume Profile oylarının birleşimidir. İndikatör bazlı TP/SL, en yakın ST/UT/VP seviyesini invalidasyon sayar ve ATR aralığına sıkıştırır. Lorentzian Classification, jdehorty'nin TradingView göstergesinin Python portudur (ANN komşu seçimi, filtreler ve kernel regresyon); Pine kaynağıyla birebir aynı sonuç vermeyebilir ve yalnızca günlük mumda çalışır. Volume Profile, günlük OHLCV'den (her mumun hacmi high–low aralığına eşit dağıtılarak) yaklaşık hesaplanır; TradingView VPVR'nin alt-zaman dilimi verisiyle birebir aynı olmaz. Gann Box, Zeiierman göstergesinin açıklamasına göre yazılmış bir Python portudur (Pine kaynağı birebir alınmadı); kutu son N mumun en yüksek/en düşük noktasından kurulur, Gann Fan 1x1 köşegeni ve katlarıyla çizilir, Gann Curves/Angles eklenmedi. Onay filtresi, kapanışın kutu %50 çizgisine göre konumuna bakar ve geçmişe bakan (kayan) pencere kullanır. SMC, LuxAlgo göstergesinin açıklamasına göre yazılmış bir Python portudur (Pine kaynağı birebir değil): swing/internal yapı, BOS/CHoCH, order block (high/low mitigasyonu), EQH/EQL, FVG ve premium/discount hesaplanır; mum boyama yoktur; internal confluence ve OB filtresi, Pine formüllerinin hafızadan yazılmış karşılığıdır. OB ve önceki gün/hafta/ay high-low seviyeleri, «TP/SL'i indikatörlerden türet» açıkken en yakın seviye SL referansı ve TP sınırı olarak backtest'e girer. Sadece SMC modunda işlemler yalnızca seçilen yapıdaki (swing/internal) BOS/CHoCH kırılım mumunda, kırılım yönünde açılır; SL en yakın ST/UT/VP/SMC swing seviyesinden, TP R katından türetilir; diğer sinyal modları devre dışıdır. Pivotlar pencere kadar mum sonra doğrulanır, bu yüzden sinyal geç gelir. SMC kavramlarının istatistiksel geçerliliği kanıtlı değildir; OOS sonuçlarıyla doğrulayın. Canlı hesap öncesi paper trading ve broker bazlı doğrulama zorunludur."
-        )
-        return (report, prob_figure(p_down, p_flat, p_up), price_fig, eq_fig, pf_fig, mc_fig,
-                top_df, csv_path, disclaimer)
-
-    except Exception as exc:
-        return (f"# Hata\n{type(exc).__name__}: {exc}", None, None, None, None, None,
-                pd.DataFrame(), None,
-                "Veri bağlantısını ve parametreleri kontrol edin.")
-
-
-# ---------------------------------------------------------------- arayüz
-with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "# GOSHAWK — Multi-Asset Adaptive Risk Engine v5\n"
-        "Kalibre KNN · adaptif K · yön bazlı TP/SL · bağımsız OOS backtest · "
-        "R-multiple Monte Carlo · drawdown bazlı risk · kapı kontrolleri."
-    )
-    with gr.Row():
-        with gr.Column():
-            ticker = gr.Dropdown(ASSETS, value="BTC-USD", allow_custom_value=True,
-                                 label="Varlık (listeden seç ya da Yahoo sembolü yaz)")
-            period = gr.Dropdown(["2y", "5y", "10y", "max"], value="5y", label="Veri geçmişi")
-            horizon = gr.Dropdown([3, 5, 10], value=5, label="Tahmin ufku (gün)")
-            side_mode = gr.Radio(SIDE_MODES, value="Long + Short", label="İzin verilen yön")
-            ind_mode = gr.Radio(IND_MODES, value="Kapalı", label="İndikatör modu (Supertrend + UT Bot)")
-            vp_mode = gr.Radio(VP_MODES, value="Kapalı", label="Volume Profile modu")
-            ldc_mode = gr.Radio(LDC_MODES, value="Kapalı", label="Lorentzian Classification modu")
-            combo_mode = gr.Radio(COMBO_MODES, value=COMBO_MODES[2],
-                                  label="Birleşik sinyal (ST+UT · Lorentzian · Volume Profile oylaması)")
-            gann_mode = gr.Radio(GANN_MODES, value=GANN_MODES[0], label="Gann Box modu (Zeiierman)")
-            smc_mode = gr.Radio(SMC_MODES, value=SMC_MODES[0], label="Smart Money Concepts modu (LuxAlgo)")
-            ind_tpsl = gr.Checkbox(value=True, label="TP/SL'i indikatörlerden türet (ST / UT / VP seviyeleri)")
-            train_window = gr.Slider(300, 1500, value=900, step=50, label="Maksimum eğitim penceresi")
-        with gr.Column():
-            equity = gr.Number(value=10000, label="Hesap büyüklüğü (USD)")
-            max_leverage = gr.Slider(1, 10, value=3, step=1, label="Azami kaldıraç")
-            min_risk = gr.Slider(0.05, 0.5, value=0.10, step=0.05, label="Minimum risk (%)")
-            max_risk = gr.Slider(0.25, 1.5, value=0.75, step=0.05, label="Maksimum risk (%)")
-            fee = gr.Number(value=0.05, label="Tek yön komisyon (%)")
-            slip = gr.Number(value=0.03, label="Tek yön slippage (%)")
-    with gr.Accordion("Gelişmiş: işlem kapısı eşikleri ve simülasyon", open=False):
-        with gr.Row():
-            p_min = gr.Slider(0.34, 0.70, value=0.43, step=0.01, label="Min. P(yön)")
-            p_gap = gr.Slider(0.0, 0.40, value=0.12, step=0.01, label="Min. P(yön) − P(karşı)")
-            flat_max = gr.Slider(0.30, 0.90, value=0.60, step=0.01, label="Maks. P(FLAT)")
-        with gr.Row():
-            agree_min = gr.Slider(0.30, 0.90, value=0.55, step=0.01, label="Min. komşu uyumu")
-            bacc_min = gr.Slider(0.30, 0.60, value=0.36, step=0.01, label="Min. OOS balanced acc.")
-            min_trades = gr.Slider(5, 50, value=15, step=1, label="Min. OOS işlem sayısı")
-        with gr.Row():
-            st_period = gr.Slider(5, 30, value=10, step=1, label="Supertrend ATR periyodu")
-            st_mult = gr.Slider(1.0, 6.0, value=3.0, step=0.1, label="Supertrend çarpanı")
-            ut_key = gr.Slider(0.5, 4.0, value=1.0, step=0.1, label="UT Bot key value")
-            ut_period = gr.Slider(5, 30, value=10, step=1, label="UT Bot ATR periyodu")
-        with gr.Row():
-            combo_votes = gr.Slider(1, 3, value=2, step=1, label="Birleşik sinyal: min. aynı yön oyu (karşı oy yok)")
-            tpsl_smin = gr.Slider(0.3, 2.0, value=0.8, step=0.1, label="İndikatör SL alt sınır (ATR)")
-            tpsl_smax = gr.Slider(1.5, 6.0, value=3.0, step=0.1, label="İndikatör SL üst sınır (ATR)")
-            tpsl_minrr = gr.Slider(0.5, 3.0, value=1.0, step=0.1, label="Min. R:R (kapı)")
-        with gr.Row():
-            ldc_k = gr.Slider(1, 30, value=8, step=1, label="Lorentzian komşu sayısı")
-            ldc_back = gr.Slider(300, 3000, value=2000, step=100, label="Lorentzian maks. geçmiş mum")
-            ldc_regime = gr.Slider(-2.0, 2.0, value=-0.1, step=0.1, label="Rejim eşiği")
-        with gr.Row():
-            ldc_kern_lb = gr.Slider(3, 50, value=8, step=1, label="Kernel lookback")
-            ldc_kern_rw = gr.Slider(0.25, 25, value=8, step=0.25, label="Kernel göreli ağırlık")
-        with gr.Row():
-            ldc_use_vol = gr.Checkbox(value=True, label="Volatilite filtresi")
-            ldc_use_regime = gr.Checkbox(value=True, label="Rejim filtresi")
-            ldc_use_adx = gr.Checkbox(value=False, label="ADX filtresi (eşik 20)")
-            ldc_kernel = gr.Checkbox(value=True, label="Kernel ile onayla")
-            ldc_exact = gr.Checkbox(value=True, label="Gerçek en yakın komşu (kapalı: Pine yaklaşık-NN)")
-        with gr.Row():
-            vp_window = gr.Slider(20, 250, value=60, step=5, label="Volume Profile penceresi (mum)")
-            vp_bins = gr.Slider(12, 60, value=24, step=2, label="Fiyat kutusu sayısı")
-            vp_va = gr.Slider(0.50, 0.90, value=0.70, step=0.05, label="Value Area oranı")
-            vp_ext = gr.Slider(0.5, 4.0, value=1.5, step=0.1, label="Maks. uzama (ATR) — kovalamayı engeller")
-        with gr.Row():
-            gann_lb = gr.Slider(30, 150, value=150, step=5, label="Gann Box penceresi (mum)")
-            gann_fan_on = gr.Checkbox(value=True, label="Gann Fan göster")
-            gann_ext_on = gr.Checkbox(value=True, label="Kutuyu geleceğe uzat (Extend)")
-            gann_rev = gr.Checkbox(value=False, label="Reverse (yönü çevir)")
-        with gr.Row():
-            smc_src = gr.Radio(SMC_SRC, value=SMC_SRC[0], label="SMC yön kaynağı")
-            smc_swing_len = gr.Slider(10, 100, value=50, step=5, label="SMC swing yapı uzunluğu")
-            smc_int_len = gr.Slider(3, 15, value=5, step=1, label="SMC internal yapı uzunluğu")
-            smc_zone = gr.Checkbox(value=False, label="Premium/Discount kapısı (long=discount, short=premium)")
-            smc_draw = gr.Checkbox(value=True, label="SMC katmanlarını grafikte göster")
-        with gr.Row():
-            smc_conf = gr.Checkbox(value=False, label="Internal confluence filtresi (zayıf kırılımları ele)")
-            smc_obf = gr.Radio(SMC_OBF, value=SMC_OBF[0], label="Order Block volatilite filtresi")
-            smc_lvl = gr.Checkbox(value=True, label="SMC seviyeleri TP/SL'de kullan (Order Block + önceki gün/hafta/ay H-L)")
-        with gr.Row():
-            skip_overlap = gr.Checkbox(value=False, label="Açık pozisyon varken yeni sinyali atla (tek pozisyon)")
-            whole_units = gr.Checkbox(value=False, label="Miktarı tam sayıya yuvarla (hisse)")
-    run = gr.Button("Öğren, optimize et ve test et", variant="primary")
-
-    with gr.Tabs():
-        with gr.Tab("Sinyal"):
-            output = gr.Markdown()
-            prob_plot = gr.Plot()
-        with gr.Tab("Grafik"):
-            chart = gr.Plot()
-        with gr.Tab("OOS backtest"):
-            pf_plot = gr.Plot()
-            equity_plot = gr.Plot()
-        with gr.Tab("Monte Carlo"):
-            mc_plot = gr.Plot()
-        with gr.Tab("TP/SL optimizasyon"):
-            optimization = gr.Dataframe(label="En iyi TP/SL kombinasyonları", interactive=False)
-        with gr.Tab("İşlem kaydı"):
-            csv_file = gr.File(label="OOS işlemleri (CSV)", interactive=False)
-    disclaimer = gr.Markdown()
-
-    run.click(
-        run_engine,
-        inputs=[ticker, period, horizon, side_mode, equity, min_risk, max_risk,
-                max_leverage, fee, slip, train_window,
-                p_min, p_gap, flat_max, agree_min, bacc_min, min_trades,
-                skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
-                vp_mode, vp_window, vp_bins, vp_va, vp_ext,
-                ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
-                ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact,
-                combo_mode, combo_votes, ind_tpsl, tpsl_smin, tpsl_smax, tpsl_minrr,
-                gann_mode, gann_lb, gann_fan_on, gann_ext_on, gann_rev,
-                smc_mode, smc_src, smc_swing_len, smc_int_len, smc_zone, smc_draw,
-                smc_conf, smc_obf, smc_lvl],
-        outputs=[output, prob_plot, chart, equity_plot, pf_plot, mc_plot, optimization,
-                 csv_file, disclaimer],
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)