diff --git "a/app.py" "b/app.py"
new file mode 100644--- /dev/null
+++ "b/app.py"
@@ -0,0 +1,2036 @@
+"""
+OKX QUANT TERMINAL · v2 — ELITE SIGNAL ENGINE
+Hedge-fund-style crypto market analytics dashboard built on Gradio.
+
+Uses ONLY OKX's public (unauthenticated) market-data REST API:
+ - /api/v5/market/candles
+ - /api/v5/market/ticker
+ - /api/v5/market/tickers
+ - /api/v5/market/books
+ - /api/v5/public/funding-rate (türev duyarlılığı, isteğe bağlı)
+
+No API key, no order placement, no account access. This is a read-only
+analytics / signal-generation terminal, not an execution bot.
+
+v2 SİNYAL MOTORU — YENİLİKLER
+ * Yeni faktörler: Supertrend, Ichimoku bulutu, Donchian kırılımı (hacim teyitli),
+ piyasa yapısı (HH/HL – LH/LL), CMF, MFI, mum formasyonları, Bollinger/Keltner sıkışması
+ * Rejim ağırlıkları artık ADX ile SÜREKLİ (yumuşak) geçiş yapar (eski: sert eşik)
+ * Skor tanh ile ±10'a yumuşak sıkıştırılır; "GÜÇLÜ" sinyal için faktör konsensüsü + MTF şartı
+ * 2 kademeli çoklu zaman dilimi (MTF) teyidi
+ * Canlı mikro-yapı katmanı: emir defteri dengesizliği, funding rate, yakın destek/direnç
+ * Yapısal (S/R) stop + ATR stop, 3 kademeli hedef, hesap büyüklüğüne göre pozisyon boyutu
+ * Gerçek işlem simülasyonu (SL/TP/zaman çıkışı + komisyon): kazanma oranı, profit factor,
+ beklenti, R çarpanı, SQN, drawdown, Al&Tut karşılaştırması, yarım-Kelly risk önerisi
+ * Bileşenli GÜVEN skoru + A+ … D kalite notu, faktör katkı grafiği, sinyal işaretli fiyat grafiği
+ * "Sadece kapanmış mumlar" modu (repaint yok), veri önbelleği, paralel veri çekimi
+
+v3 SERT FİLTRELER — YÖN İSABETİNİ ARTIRMAYA YÖNELİK (sinyal sayısını azaltıp kaliteyi artırır)
+ * Rejim kapısı: ADX çok düşükken (belirgin trend yok) sinyal üretilmez
+ * Konsensüs kapısı: T/R faktörleri yeterince aynı yönde değilse (agree < eşik) sinyal BEKLE'ye düşer
+ * MTF sert kapısı: üst zaman dilimi net ters yöndeyse normal AL/SAT bile filtrelenir (GÜÇLÜ hariç)
+ * Emir defteri kapısı: defter sinyale güçlü ters yöndeyse sinyal filtrelenir
+ * Rejim + konsensüs kapıları canlı sinyal İLE backtest'te AYNI fonksiyonla uygulanır (tutarlılık)
+ * Backtest artık ilk-yarı/ikinci-yarı isabet oranını karşılaştırıp tutarsızlığı (rejim kayması /
+ olası aşırı-uyum) işaretliyor ve güven skorunu buna göre düşürüyor
+ * NOT: Bu filtreler sinyal kalitesini yükseltir ama hiçbir kombinasyon sürekli %80 isabeti garanti
+ edemez; kripto gibi gürültülü piyasalarda %55-60 tutarlı isabet + iyi R:R zaten güçlü kabul edilir
+"""
+
+import math
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import requests
+import gradio as gr
+
+try: # Hugging Face Spaces (ZeroGPU) — yerelde yoksa sessizce atla
+ import spaces
+ _gpu = spaces.GPU(duration=30)
+except Exception:
+ def _gpu(fn):
+ return fn
+
+# ---------------------------------------------------------------------------
+# CONFIG
+# ---------------------------------------------------------------------------
+OKX_BASE = "https://www.okx.com"
+TIMEOUT = 10
+CACHE_TTL = 8 # saniye — aynı mum verisini sekmeler arasında tekrar çekmemek için
+
+POPULAR_SYMBOLS = [
+ "BTC-USDT", "ETH-USDT", "SOL-USDT", "BNB-USDT", "XRP-USDT",
+ "DOGE-USDT", "ADA-USDT", "AVAX-USDT", "LINK-USDT", "TON-USDT",
+ "TRX-USDT", "DOT-USDT", "MATIC-USDT", "LTC-USDT", "NEAR-USDT",
+ "SUI-USDT", "APT-USDT", "ARB-USDT", "OP-USDT", "INJ-USDT",
+]
+
+BAR_OPTIONS = ["1m", "3m", "5m", "15m", "30m", "1H", "2H", "4H", "6H", "12H", "1D", "1W"]
+
+# approximate periods-per-year for each bar size, used to annualize risk stats
+BAR_TO_PERIODS_PER_YEAR = {
+ "1m": 365 * 24 * 60, "3m": 365 * 24 * 20, "5m": 365 * 24 * 12,
+ "15m": 365 * 24 * 4, "30m": 365 * 24 * 2, "1H": 365 * 24,
+ "2H": 365 * 12, "4H": 365 * 6, "6H": 365 * 4, "12H": 365 * 2,
+ "1D": 365, "1W": 52,
+}
+
+CHART_BG = "#0a0e14"
+
+# her zaman dilimi için "bir üst" zaman dilimi -> çoklu zaman dilimi (MTF) teyidi için
+MTF_MAP = {
+ "1m": "15m", "3m": "30m", "5m": "1H", "15m": "4H", "30m": "4H",
+ "1H": "4H", "2H": "1D", "4H": "1D", "6H": "1D", "12H": "1W",
+ "1D": "1W", "1W": "1W",
+}
+SLOW_BARS = {"4H", "6H", "12H", "1D", "1W"} # bu vadelerde emir defteri etkisi yarıya iner
+
+# --- Sinyal motoru parametreleri ---
+SIGNAL_THRESHOLD = 2.0 # |skor| >= bu değer -> AL / SAT
+STRONG_THRESHOLD = 4.5 # |skor| >= bu değer + konsensüs -> GÜÇLÜ
+WARMUP_BARS = 80 # Ichimoku (52+26) ısınması için minimum bar
+BACKTEST_LOOKBACK = 220 # walk-forward test penceresi (bar)
+SL_ATR, TP_ATR = 1.5, 2.5 # backtest ve varsayılan işlem planı (ATR çarpanları)
+MAX_HOLD_BARS = 24 # zaman çıkışı
+FEE_PER_SIDE = 0.001 # OKX spot taker ≈ %0.1 / yön
+TP_R_MULTIPLES = (TP_ATR / SL_ATR, 2.5, 4.0) # TP1/TP2/TP3 (R cinsinden)
+
+# --- v3 SERT FİLTRELER (gate) — düşük kaliteli sinyalleri eleyerek isabet oranını artırır ---
+# Not: bu eşikler sinyal SAYISINI azaltır, isabet oranını yükseltmeye çalışır. %80 gibi bir
+# oranın SÜREKLİ garanti edilebileceği bir gösterge kombinasyonu yoktur; bu filtreler sadece
+# düşük güvenilirlikli barları "BEKLE/NÖTR"e çevirerek kalan sinyallerin ortalama kalitesini yükseltir.
+MIN_REGIME_ADX = 12 # ADX bu değerin altında ve sıkışma yoksa -> belirgin trend yok, sinyal verilmez
+MIN_AGREE_FOR_SIGNAL = 0.55 # faktör konsensüsü (agree) bu oranın altındaysa sinyal BEKLE'ye düşer
+MTF_HARD_GATE = True # üst zaman dilimi (mtf1) net ters yöndeyse normal AL/SAT bile filtrelenir
+OB_HARD_GATE_IMB = 0.35 # emir defteri dengesizliği sinyale bu kadar ters ve güçlüyse sinyal filtrelenir
+STABILITY_MIN_SAMPLES = 12 # ilk-yarı/ikinci-yarı isabet stabilite kontrolü için min. sinyal sayısı
+STABILITY_MAX_GAP = 0.30 # iki yarı arasındaki isabet farkı bunu aşarsa "tutarsız" (rejim kayması) işaretlenir
+
+# --- v4 SİNİR AĞI (hafif, NumPy-only MLP) — kompozit skora öğrenilmiş bir yön-olasılığı katmanı ekler ---
+NN_HIDDEN = 12 # gizli katman nöron sayısı
+NN_EPOCHS = 300 # tam-batch gradient descent iterasyonu
+NN_LR = 0.05 # öğrenme oranı
+NN_L2 = 1e-3 # L2 düzenlileştirme (ezberlemeyi azaltmak için)
+NN_FORWARD = 5 # etiket ufku: forward bar sonra yön yukarı mı aşağı mı (directional_accuracy ile aynı)
+NN_MIN_TRAIN = 60 # bu kadar eğitim örneği altında model hiç kullanılmaz (güvenilmez)
+NN_WEIGHT = 1.6 # NN'in kompozit skora katkısının maksimum büyüklüğü (diğer faktörlerle aynı ölçek)
+NN_GATE_STRENGTH = 0.5 # NN, sinyale bu kadar (0-1) güçlü ters düşerse sinyal sert filtreyle elenir
+NN_CACHE_TTL = 45 # saniye — aynı (sembol, bar) için modeli bu süre boyunca yeniden eğitme
+
+
+# ---------------------------------------------------------------------------
+# OKX PUBLIC API WRAPPERS (önbellek + yeniden deneme)
+# ---------------------------------------------------------------------------
+_CACHE = {}
+_CACHE_LOCK = threading.Lock()
+
+
+def _cached(key, ttl, loader):
+ now = time.time()
+ with _CACHE_LOCK:
+ hit = _CACHE.get(key)
+ if hit and now - hit[0] < ttl:
+ return hit[1]
+ val = loader()
+ with _CACHE_LOCK:
+ _CACHE[key] = (time.time(), val)
+ if len(_CACHE) > 200: # eski kayıtları buda
+ for k in sorted(_CACHE, key=lambda x: _CACHE[x][0])[:60]:
+ _CACHE.pop(k, None)
+ return val
+
+
+def _get(path, params=None, retries=2):
+ for attempt in range(retries + 1):
+ try:
+ r = requests.get(f"{OKX_BASE}{path}", params=params, timeout=TIMEOUT)
+ r.raise_for_status()
+ data = r.json()
+ code = str(data.get("code"))
+ if code == "50011" and attempt < retries: # OKX rate-limit
+ time.sleep(0.5 * (attempt + 1))
+ continue
+ if code != "0":
+ raise RuntimeError(data.get("msg") or "OKX API hata döndürdü.")
+ return data["data"]
+ except requests.exceptions.RequestException as e:
+ if attempt < retries:
+ time.sleep(0.3 * (attempt + 1))
+ continue
+ raise RuntimeError(f"Ağ hatası: {e}")
+
+
+def fetch_candles(inst_id, bar="1H", limit=300):
+ def _load():
+ raw = _get("/api/v5/market/candles", {"instId": inst_id, "bar": bar, "limit": limit})
+ if not raw:
+ raise RuntimeError(f"{inst_id} için mum verisi bulunamadı (sembolü kontrol edin).")
+ cols = ["ts", "o", "h", "l", "c", "vol", "volCcy", "volCcyQuote", "confirm"]
+ df = pd.DataFrame(raw, columns=cols)
+ for c in ["o", "h", "l", "c", "vol"]:
+ df[c] = df[c].astype(float)
+ df["confirm"] = df["confirm"].astype(int)
+ df["ts"] = pd.to_datetime(df["ts"].astype(np.int64), unit="ms")
+ return df.sort_values("ts").reset_index(drop=True)
+
+ return _cached(("candles", inst_id, bar, limit), CACHE_TTL, _load).copy()
+
+
+def fetch_ticker(inst_id):
+ raw = _get("/api/v5/market/ticker", {"instId": inst_id})
+ return raw[0] if raw else {}
+
+
+def fetch_all_tickers(inst_type="SPOT"):
+ return _cached(("tickers", inst_type), 20, lambda: _get("/api/v5/market/tickers", {"instType": inst_type}))
+
+
+def fetch_orderbook(inst_id, depth=20):
+ raw = _get("/api/v5/market/books", {"instId": inst_id, "sz": depth})
+ return raw[0] if raw else {}
+
+
+def fetch_funding_rate(inst_id):
+ """Spot paritenin (BTC-USDT) sürekli vadeli karşılığının (BTC-USDT-SWAP) funding oranı."""
+ parts = inst_id.split("-")
+ if len(parts) != 2:
+ return None
+ raw = _get("/api/v5/public/funding-rate", {"instId": f"{inst_id}-SWAP"})
+ if not raw:
+ return None
+ return float(raw[0].get("fundingRate") or 0.0)
+
+
+# ---------------------------------------------------------------------------
+# TECHNICAL INDICATORS
+# ---------------------------------------------------------------------------
+def ema(s, p):
+ return s.ewm(span=p, adjust=False).mean()
+
+
+def sma(s, p):
+ return s.rolling(p).mean()
+
+
+def rsi(s, p=14):
+ d = s.diff()
+ gain = d.clip(lower=0)
+ loss = -d.clip(upper=0)
+ ag = gain.ewm(alpha=1 / p, adjust=False).mean()
+ al = loss.ewm(alpha=1 / p, adjust=False).mean()
+ rs = ag / al.replace(0, np.nan)
+ return (100 - 100 / (1 + rs)).fillna(50)
+
+
+def macd(s, fast=12, slow=26, signal=9):
+ line = ema(s, fast) - ema(s, slow)
+ sig = ema(line, signal)
+ return line, sig, line - sig
+
+
+def bollinger(s, p=20, k=2):
+ mid = sma(s, p)
+ std = s.rolling(p).std()
+ return mid + k * std, mid, mid - k * std
+
+
+def atr(df, p=14):
+ h, l, c = df["h"], df["l"], df["c"]
+ pc = c.shift(1)
+ tr = pd.concat([h - l, (h - pc).abs(), (l - pc).abs()], axis=1).max(axis=1)
+ return tr.ewm(alpha=1 / p, adjust=False).mean()
+
+
+def stochastic(df, k_p=14, d_p=3):
+ lo = df["l"].rolling(k_p).min()
+ hi = df["h"].rolling(k_p).max()
+ k = 100 * (df["c"] - lo) / (hi - lo).replace(0, np.nan)
+ d = k.rolling(d_p).mean()
+ return k.fillna(50), d.fillna(50)
+
+
+def vwap_window(df):
+ tp = (df["h"] + df["l"] + df["c"]) / 3
+ return (tp * df["vol"]).cumsum() / df["vol"].cumsum().replace(0, np.nan)
+
+
+def adx(df, p=14):
+ """ADX + yönsel indikatörler (+DI / -DI). Trend gücünü ölçer (0-100)."""
+ h, l, c = df["h"], df["l"], df["c"]
+ up_move = h.diff()
+ down_move = -l.diff()
+ plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0.0)
+ minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0.0)
+ tr = pd.concat([h - l, (h - c.shift(1)).abs(), (l - c.shift(1)).abs()], axis=1).max(axis=1)
+ atr_ = tr.ewm(alpha=1 / p, adjust=False).mean()
+ plus_di = 100 * pd.Series(plus_dm, index=df.index).ewm(alpha=1 / p, adjust=False).mean() / atr_.replace(0, np.nan)
+ minus_di = 100 * pd.Series(minus_dm, index=df.index).ewm(alpha=1 / p, adjust=False).mean() / atr_.replace(0, np.nan)
+ dx = ((plus_di - minus_di).abs() / (plus_di + minus_di).replace(0, np.nan)) * 100
+ adx_ = dx.ewm(alpha=1 / p, adjust=False).mean()
+ return adx_.fillna(0), plus_di.fillna(0), minus_di.fillna(0)
+
+
+def obv(df):
+ """On-Balance Volume: hacmin fiyat yönüyle kümülatif toplamı."""
+ direction = np.sign(df["c"].diff()).fillna(0)
+ return (direction * df["vol"]).cumsum()
+
+
+def supertrend(df, period=10, mult=3.0):
+ """Supertrend: ATR bantlı trend takipçisi. dir=+1 yükseliş, -1 düşüş. (nedensel, geleceğe bakmaz)"""
+ h, l, c = df["h"].to_numpy(), df["l"].to_numpy(), df["c"].to_numpy()
+ a = atr(df, period).to_numpy()
+ hl2 = (h + l) / 2
+ ub, lb = hl2 + mult * a, hl2 - mult * a
+ n = len(c)
+ fub, flb = ub.copy(), lb.copy()
+ direction = np.ones(n)
+ line = np.full(n, np.nan)
+ if n:
+ line[0] = flb[0]
+ for i in range(1, n):
+ fub[i] = ub[i] if (ub[i] < fub[i - 1] or c[i - 1] > fub[i - 1]) else fub[i - 1]
+ flb[i] = lb[i] if (lb[i] > flb[i - 1] or c[i - 1] < flb[i - 1]) else flb[i - 1]
+ if c[i] > fub[i - 1]:
+ direction[i] = 1
+ elif c[i] < flb[i - 1]:
+ direction[i] = -1
+ else:
+ direction[i] = direction[i - 1]
+ line[i] = flb[i] if direction[i] == 1 else fub[i]
+ return pd.Series(line, index=df.index), pd.Series(direction, index=df.index)
+
+
+def ichimoku(df):
+ """Tenkan/Kijun + bulut. Bulut, 26 bar önce hesaplanan Senkou A/B'nin bugüne kaydırılmış halidir
+ (yani nedensel: gelecek veri kullanılmaz)."""
+ h, l = df["h"], df["l"]
+ tenkan = (h.rolling(9).max() + l.rolling(9).min()) / 2
+ kijun = (h.rolling(26).max() + l.rolling(26).min()) / 2
+ span_a = (tenkan + kijun) / 2
+ span_b = (h.rolling(52).max() + l.rolling(52).min()) / 2
+ return tenkan, kijun, span_a.shift(26), span_b.shift(26)
+
+
+def mfi(df, p=14):
+ """Money Flow Index: hacim ağırlıklı RSI."""
+ tp = (df["h"] + df["l"] + df["c"]) / 3
+ rmf = tp * df["vol"]
+ d = tp.diff()
+ pos = rmf.where(d > 0, 0.0).rolling(p).sum()
+ neg = rmf.where(d < 0, 0.0).rolling(p).sum()
+ out = 100 - 100 / (1 + pos / neg.replace(0, np.nan))
+ out = out.where(~((neg == 0) & (pos > 0)), 100.0)
+ return out.fillna(50)
+
+
+def cmf(df, p=20):
+ """Chaikin Money Flow: kapanışın bar aralığındaki konumuna göre hacim akışı (-1..+1)."""
+ rng = (df["h"] - df["l"]).replace(0, np.nan)
+ mfm = ((df["c"] - df["l"]) - (df["h"] - df["c"])) / rng
+ mfv = mfm.fillna(0) * df["vol"]
+ return (mfv.rolling(p).sum() / df["vol"].rolling(p).sum().replace(0, np.nan)).fillna(0)
+
+
+def market_structure(df, w=10):
+ """+1: Higher-High & Higher-Low (yükseliş yapısı), -1: Lower-High & Lower-Low, 0: karışık."""
+ hi, lo = df["h"].rolling(w).max(), df["l"].rolling(w).min()
+ up = (hi > hi.shift(w)) & (lo > lo.shift(w))
+ dn = (hi < hi.shift(w)) & (lo < lo.shift(w))
+ return pd.Series(np.where(up, 1.0, np.where(dn, -1.0, 0.0)), index=df.index)
+
+
+def squeeze_indicator(df, ind):
+ """TTM tarzı sıkışma: Bollinger bantları Keltner kanalının İÇİNE girerse volatilite sıkışmıştır.
+ Dönüş: (sıkışma_açık, son 3 barda sıkışma çözüldü mü, momentum)"""
+ kc_mid = ind["ema20"]
+ kc_u, kc_l = kc_mid + 1.5 * ind["atr"], kc_mid - 1.5 * ind["atr"]
+ on = (ind["bb_lower"] > kc_l) & (ind["bb_upper"] < kc_u)
+ release = (~on) & on.shift(1, fill_value=False)
+ rel3 = release.astype(float).rolling(3, min_periods=1).max()
+ hh, ll = df["h"].rolling(20).max(), df["l"].rolling(20).min()
+ mom = df["c"] - ((hh + ll) / 2 + sma(df["c"], 20)) / 2
+ return on.astype(float), rel3, mom
+
+
+CANDLE_PATTERNS = [
+ ("pat_hammer", "Çekiç", 1),
+ ("pat_bull_eng", "Yükseliş Yutan Mum", 1),
+ ("pat_morning", "Sabah Yıldızı", 1),
+ ("pat_shooting", "Kayan Yıldız", -1),
+ ("pat_bear_eng", "Düşüş Yutan Mum", -1),
+ ("pat_evening", "Akşam Yıldızı", -1),
+]
+
+
+def candle_patterns(df):
+ """Vektörel mum formasyonu tespiti (yalnızca geçmiş barlar kullanılır)."""
+ o, h, l, c = df["o"], df["h"], df["l"], df["c"]
+ body = (c - o).abs()
+ rng = (h - l).replace(0, np.nan)
+ upper = h - np.maximum(o, c)
+ lower = np.minimum(o, c) - l
+ avg_body = body.rolling(10, min_periods=3).mean()
+ prior_down = c.shift(1) < c.shift(4)
+ prior_up = c.shift(1) > c.shift(4)
+
+ hammer = (lower >= 0.6 * rng) & (body <= 0.3 * rng) & (upper <= 0.15 * rng) & prior_down
+ shooting = (upper >= 0.6 * rng) & (body <= 0.3 * rng) & (lower <= 0.15 * rng) & prior_up
+ bull_eng = ((c.shift(1) < o.shift(1)) & (c > o) & (c >= o.shift(1)) & (o <= c.shift(1))
+ & (body > body.shift(1)) & prior_down)
+ bear_eng = ((c.shift(1) > o.shift(1)) & (c < o) & (c <= o.shift(1)) & (o >= c.shift(1))
+ & (body > body.shift(1)) & prior_up)
+ big2 = body.shift(2) > avg_body.shift(2)
+ small1 = body.shift(1) < 0.35 * body.shift(2)
+ mid2 = (o.shift(2) + c.shift(2)) / 2
+ morning = (c.shift(2) < o.shift(2)) & big2 & small1 & (c > o) & (c > mid2)
+ evening = (c.shift(2) > o.shift(2)) & big2 & small1 & (c < o) & (c < mid2)
+
+ raw = {"pat_hammer": hammer, "pat_shooting": shooting, "pat_bull_eng": bull_eng,
+ "pat_bear_eng": bear_eng, "pat_morning": morning, "pat_evening": evening}
+ return {k: v.fillna(False).astype(float) for k, v in raw.items()}
+
+
+def find_swings(series, window=3):
+ """Yerel tepe/dip (swing high/low) indekslerini bulur."""
+ n = len(series)
+ highs, lows = [], []
+ for i in range(window, n - window):
+ seg = series.iloc[i - window:i + window + 1]
+ if series.iloc[i] == seg.max():
+ highs.append(i)
+ if series.iloc[i] == seg.min():
+ lows.append(i)
+ return highs, lows
+
+
+def detect_divergence(df, ind, lookback=60, window=3):
+ """Fiyat ile RSI arasındaki son swing'leri karşılaştırarak klasik uyumsuzluğu tespit eder."""
+ n = len(df)
+ lb = min(lookback, n)
+ close = df["c"].iloc[-lb:].reset_index(drop=True)
+ rsi_s = ind["rsi"].iloc[-lb:].reset_index(drop=True)
+ highs, lows = find_swings(close, window)
+ result = {"bullish": False, "bearish": False}
+ if len(highs) >= 2:
+ h1, h2 = highs[-2], highs[-1]
+ if close.iloc[h2] > close.iloc[h1] and rsi_s.iloc[h2] < rsi_s.iloc[h1]:
+ result["bearish"] = True
+ if len(lows) >= 2:
+ l1, l2 = lows[-2], lows[-1]
+ if close.iloc[l2] < close.iloc[l1] and rsi_s.iloc[l2] > rsi_s.iloc[l1]:
+ result["bullish"] = True
+ return result
+
+
+def find_sr_levels(df, atr_v, window=5, lookback=200, max_levels=4):
+ """Swing tepe/diplerini kümeleyerek destek/direnç seviyeleri çıkarır.
+ Dönüş: (destekler, dirençler) — her biri [(seviye, temas_sayısı), ...], fiyata yakınlık sırasıyla."""
+ sub = df.iloc[-lookback:].reset_index(drop=True)
+ highs, _ = find_swings(sub["h"], window)
+ _, lows = find_swings(sub["l"], window)
+ pts = [float(sub["h"].iloc[i]) for i in highs] + [float(sub["l"].iloc[i]) for i in lows]
+ if not pts:
+ return [], []
+ price = float(df["c"].iloc[-1])
+ tol = max(0.6 * (atr_v if atr_v and atr_v > 0 else 0.0), price * 0.002)
+ pts.sort()
+ clusters, cur = [], [pts[0]]
+ for p in pts[1:]:
+ if p - float(np.mean(cur)) <= tol:
+ cur.append(p)
+ else:
+ clusters.append(cur)
+ cur = [p]
+ clusters.append(cur)
+ levels = [(float(np.mean(c)), len(c)) for c in clusters]
+ supports = sorted([lv for lv in levels if lv[0] < price], key=lambda x: -x[0])[:max_levels]
+ resists = sorted([lv for lv in levels if lv[0] > price], key=lambda x: x[0])[:max_levels]
+ return supports, resists
+
+
+def compute_indicators(df):
+ close = df["c"]
+ ind = {}
+ ind["rsi"] = rsi(close)
+ ind["macd_line"], ind["macd_signal"], ind["macd_hist"] = macd(close)
+ ind["ema20"] = ema(close, 20)
+ ind["ema50"] = ema(close, 50)
+ ind["ema200"] = ema(close, 200 if len(close) >= 200 else max(5, len(close) // 2))
+ ind["bb_upper"], ind["bb_mid"], ind["bb_lower"] = bollinger(close)
+ ind["atr"] = atr(df)
+ ind["stoch_k"], ind["stoch_d"] = stochastic(df)
+ ind["vwap"] = vwap_window(df)
+ ind["adx"], ind["plus_di"], ind["minus_di"] = adx(df)
+ ind["obv"] = obv(df)
+ ind["obv_ema"] = ema(ind["obv"], 20)
+ # --- v2 ek faktörler ---
+ ind["st_line"], ind["st_dir"] = supertrend(df)
+ ind["tenkan"], ind["kijun"], ind["ich_a"], ind["ich_b"] = ichimoku(df)
+ ind["mfi"] = mfi(df)
+ ind["cmf"] = cmf(df)
+ ind["rvol"] = (df["vol"] / sma(df["vol"], 20).replace(0, np.nan)).fillna(1.0)
+ ind["dc_hi20"] = df["h"].rolling(20).max().shift(1)
+ ind["dc_lo20"] = df["l"].rolling(20).min().shift(1)
+ ind["struct"] = market_structure(df)
+ ind["sq_on"], ind["sq_rel3"], ind["sq_mom"] = squeeze_indicator(df, ind)
+ ind["atr_rank"] = (ind["atr"] / close).rolling(100, min_periods=30).apply(
+ lambda x: float((x <= x[-1]).mean()), raw=True).fillna(0.5)
+ for name, ser in candle_patterns(df).items():
+ ind[name] = ser
+ # hızlı, nedensel erişim için numpy önbelleği (backtest döngüsünde .iloc yerine kullanılır)
+ arr = {k: v.to_numpy(dtype=float) for k, v in ind.items()}
+ for k in ("o", "h", "l", "c", "vol"):
+ arr[k] = df[k].to_numpy(dtype=float)
+ ind["_arr"] = arr
+ return ind
+
+
+# ---------------------------------------------------------------------------
+# COMPOSITE SIGNAL ENGINE v2 (multi-factor, rejim-uyarlamalı, konsensüs filtreli)
+# ---------------------------------------------------------------------------
+def _score_at(ind, i, verbose=False):
+ """Çoklu faktör puanlamasını verilen bar indeksinde hesaplar (yalnızca o ana kadarki veri).
+
+ İki faktör ailesi vardır:
+ T (TREND) : MACD, EMA dizilimi, VWAP, OBV, Supertrend, Ichimoku, Donchian kırılımı,
+ piyasa yapısı, CMF, sıkışma kırılımı, ADX/DI yönü
+ R (REVERSION) : RSI, Bollinger, Stokastik, MFI, mum formasyonları
+
+ ADX'e göre iki ailenin ağırlığı SÜREKLİ olarak kayar (w: 0=yatay … 1=güçlü trend).
+ Güçlü trendde karşı-trend (aşırı alım/satım) sinyalleri bastırılır; yatay piyasada trend takibi bastırılır.
+ Sonuç, tanh ile ±10 aralığına yumuşak sıkıştırılır.
+ Canlı sinyal ve tarihsel backtest AYNI fonksiyonu kullanır (tutarlılık + gelecek sızıntısı yok)."""
+ A = ind["_arr"]
+ price = A["c"][i]
+ items = [] # (etiket, grup, ham_puan, açıklama)
+
+ def add(label, group, raw, text):
+ items.append((label, group, float(raw), text))
+
+ # --- RSI (R) ---
+ rsi_v = A["rsi"][i]
+ if rsi_v < 30:
+ add("RSI", "R", 2, f"RSI aşırı satım bölgesinde ({rsi_v:.1f})")
+ elif rsi_v > 70:
+ add("RSI", "R", -2, f"RSI aşırı alım bölgesinde ({rsi_v:.1f})")
+ else:
+ add("RSI", "R", 0, f"RSI nötr bölgede ({rsi_v:.1f})")
+
+ # --- MACD histogramı (T) ---
+ hist_v = A["macd_hist"][i]
+ hist_prev = A["macd_hist"][i - 1] if i > 0 else 0.0
+ if hist_v > 0 and hist_v > hist_prev:
+ add("MACD", "T", 1.5, "MACD histogramı pozitif ve güçleniyor")
+ elif hist_v > 0:
+ add("MACD", "T", 0.5, "MACD histogramı pozitif")
+ elif hist_v < 0 and hist_v < hist_prev:
+ add("MACD", "T", -1.5, "MACD histogramı negatif ve zayıflıyor")
+ else:
+ add("MACD", "T", -0.5, "MACD histogramı negatif")
+
+ # --- EMA dizilimi (T) ---
+ e20, e50, e200 = A["ema20"][i], A["ema50"][i], A["ema200"][i]
+ if price > e20 > e50 > e200:
+ add("EMA Dizilimi", "T", 2, "Güçlü yükseliş trendi (Fiyat > EMA20 > EMA50 > EMA200)")
+ elif price > e20 and e20 > e50:
+ add("EMA Dizilimi", "T", 1, "Yükseliş trendi (kısa vadeli ortalamaların üzerinde)")
+ elif price < e20 < e50 < e200:
+ add("EMA Dizilimi", "T", -2, "Güçlü düşüş trendi (Fiyat < EMA20 < EMA50 < EMA200)")
+ elif price < e20 and e20 < e50:
+ add("EMA Dizilimi", "T", -1, "Düşüş trendi (kısa vadeli ortalamaların altında)")
+ else:
+ add("EMA Dizilimi", "T", 0, "Trend yatay / belirsiz")
+
+ # --- Bollinger konumu (R) ---
+ bb_u, bb_l = A["bb_upper"][i], A["bb_lower"][i]
+ if bb_u == bb_u and bb_l == bb_l and bb_u != bb_l:
+ bb_pos = (price - bb_l) / (bb_u - bb_l)
+ if bb_pos < 0.15:
+ add("Bollinger", "R", 1, "Fiyat Bollinger alt bandına yakın (olası tepki)")
+ elif bb_pos > 0.85:
+ add("Bollinger", "R", -1, "Fiyat Bollinger üst bandına yakın (olası tepki)")
+
+ # --- Stokastik (R) ---
+ k_v = A["stoch_k"][i]
+ if k_v < 20:
+ add("Stokastik", "R", 1, f"Stokastik aşırı satım bölgesinde ({k_v:.1f})")
+ elif k_v > 80:
+ add("Stokastik", "R", -1, f"Stokastik aşırı alım bölgesinde ({k_v:.1f})")
+
+ # --- MFI (R) ---
+ mfi_v = A["mfi"][i]
+ if mfi_v < 20:
+ add("MFI", "R", 1, f"MFI (hacimli RSI) aşırı satımda ({mfi_v:.1f})")
+ elif mfi_v > 80:
+ add("MFI", "R", -1, f"MFI (hacimli RSI) aşırı alımda ({mfi_v:.1f})")
+
+ # --- Mum formasyonları (R) ---
+ hits = []
+ for key, name, sgn in CANDLE_PATTERNS:
+ if A[key][i] > 0:
+ hits.append((name, sgn))
+ if hits:
+ raw = max(-1.5, min(1.5, float(sum(s for _, s in hits))))
+ add("Mum Formasyonu", "R", raw, "Mum formasyonu: " + ", ".join(n for n, _ in hits))
+
+ # --- VWAP (T) ---
+ vwap_v = A["vwap"][i]
+ if vwap_v == vwap_v:
+ if price > vwap_v:
+ add("VWAP", "T", 0.5, "Fiyat pencere VWAP'ının üzerinde")
+ else:
+ add("VWAP", "T", -0.5, "Fiyat pencere VWAP'ının altında")
+
+ # --- OBV (T) ---
+ obv_v, obv_e = A["obv"][i], A["obv_ema"][i]
+ if obv_e == obv_e:
+ if obv_v > obv_e:
+ add("OBV", "T", 0.5, "OBV hacim akışı yükseliş yönünde")
+ else:
+ add("OBV", "T", -0.5, "OBV hacim akışı düşüş yönünde")
+
+ # --- CMF (T) ---
+ cmf_v = A["cmf"][i]
+ if cmf_v > 0.05:
+ add("CMF", "T", 0.5, f"Chaikin para akışı pozitif ({cmf_v:+.2f}) — alıcılar baskın")
+ elif cmf_v < -0.05:
+ add("CMF", "T", -0.5, f"Chaikin para akışı negatif ({cmf_v:+.2f}) — satıcılar baskın")
+
+ # --- Supertrend (T) ---
+ st_d = A["st_dir"][i]
+ st_flip = i > 0 and A["st_dir"][i] != A["st_dir"][i - 1]
+ if st_d > 0:
+ add("Supertrend", "T", 1.5 + (0.5 if st_flip else 0),
+ "Supertrend YÜKSELİŞ moduna döndü (taze sinyal)" if st_flip else "Supertrend yükseliş modunda")
+ else:
+ add("Supertrend", "T", -(1.5 + (0.5 if st_flip else 0)),
+ "Supertrend DÜŞÜŞ moduna döndü (taze sinyal)" if st_flip else "Supertrend düşüş modunda")
+
+ # --- Ichimoku (T) ---
+ sa, sb = A["ich_a"][i], A["ich_b"][i]
+ if sa == sa and sb == sb:
+ top, bot = max(sa, sb), min(sa, sb)
+ if price > top:
+ add("Ichimoku Bulutu", "T", 1.5, "Fiyat Ichimoku bulutunun üzerinde (boğa bölgesi)")
+ elif price < bot:
+ add("Ichimoku Bulutu", "T", -1.5, "Fiyat Ichimoku bulutunun altında (ayı bölgesi)")
+ else:
+ add("Ichimoku Bulutu", "T", 0, "Fiyat Ichimoku bulutunun içinde (kararsız bölge)")
+ tk, kj = A["tenkan"][i], A["kijun"][i]
+ if tk == tk and kj == kj:
+ add("Tenkan/Kijun", "T", 0.5 if tk > kj else -0.5,
+ "Tenkan > Kijun (kısa vadeli momentum yukarı)" if tk > kj else "Tenkan < Kijun (kısa vadeli momentum aşağı)")
+
+ # --- Donchian kırılımı (T) ---
+ dhi, dlo, rvol = A["dc_hi20"][i], A["dc_lo20"][i], A["rvol"][i]
+ if dhi == dhi and dlo == dlo:
+ if price > dhi:
+ if rvol >= 1.2:
+ add("Donchian Kırılımı", "T", 1.5, f"20 barlık tepe HACİMLİ kırıldı (göreli hacim {rvol:.1f}x)")
+ else:
+ add("Donchian Kırılımı", "T", 0.75, f"20 barlık tepe kırıldı ama hacim zayıf ({rvol:.1f}x)")
+ elif price < dlo:
+ if rvol >= 1.2:
+ add("Donchian Kırılımı", "T", -1.5, f"20 barlık dip HACİMLİ kırıldı (göreli hacim {rvol:.1f}x)")
+ else:
+ add("Donchian Kırılımı", "T", -0.75, f"20 barlık dip kırıldı ama hacim zayıf ({rvol:.1f}x)")
+
+ # --- Piyasa yapısı (T) ---
+ st_v = A["struct"][i]
+ if st_v > 0:
+ add("Piyasa Yapısı", "T", 1, "Piyasa yapısı: Higher-High / Higher-Low (yükseliş yapısı)")
+ elif st_v < 0:
+ add("Piyasa Yapısı", "T", -1, "Piyasa yapısı: Lower-High / Lower-Low (düşüş yapısı)")
+
+ # --- Sıkışma (Bollinger ⊂ Keltner) ---
+ squeeze_on = A["sq_on"][i] > 0
+ mom = A["sq_mom"][i]
+ if A["sq_rel3"][i] > 0 and mom == mom and mom != 0:
+ d = 1 if mom > 0 else -1
+ add("Sıkışma Kırılımı", "T", 1.5 * d,
+ "Volatilite sıkışması yukarı yönde çözüldü" if d > 0 else "Volatilite sıkışması aşağı yönde çözüldü")
+ elif squeeze_on:
+ add("Sıkışma", "T", 0, "Volatilite sıkışması aktif — kırılım bekleniyor, sinyal güveni düşürüldü")
+
+ # --- REJİM (ADX) — sürekli ağırlıklandırma ---
+ adx_v = A["adx"][i]
+ w = min(max((adx_v - 15.0) / 15.0, 0.0), 1.0) if adx_v == adx_v else 0.0 # 0 = yatay, 1 = güçlü trend
+ trend_w = 0.5 + 0.8 * w
+ rev_w = 1.3 - 0.95 * w
+ di_dir = 1 if A["plus_di"][i] > A["minus_di"][i] else -1
+ add("ADX / DI Yönü", "T", di_dir * w, "") # yönsel bonus; w kadar ölçeklenir
+ if w >= 0.67:
+ regime = "TREND"
+ add("Rejim", "T", 0, f"ADX güçlü trend gösteriyor ({adx_v:.1f}) — trend faktörleri ağırlıklı, karşı-trend sinyaller bastırıldı")
+ elif w <= 0.33:
+ regime = "YATAY"
+ add("Rejim", "T", 0, f"ADX zayıf/yatay piyasa ({adx_v:.1f}) — ortalamaya dönüş faktörleri ağırlıklı")
+ else:
+ regime = "GEÇİŞ"
+ add("Rejim", "T", 0, f"ADX geçiş bölgesinde ({adx_v:.1f}) — faktör ağırlıkları dengeli karışım")
+
+ contribs = [(lab, (trend_w if g == "T" else rev_w) * raw, raw) for lab, g, raw, _ in items]
+ raw_total = sum(c for _, c, _ in contribs)
+ if squeeze_on:
+ raw_total *= 0.75
+ score = 10.0 * math.tanh(raw_total / 9.0)
+ bull_w = sum(c for _, c, _ in contribs if c > 0)
+ bear_w = -sum(c for _, c, _ in contribs if c < 0)
+
+ out = {
+ "score": score, "price": price, "adx": adx_v, "w": w, "regime": regime,
+ "bull_w": bull_w, "bear_w": bear_w, "squeeze_on": bool(squeeze_on),
+ "atr_rank": A["atr_rank"][i], "pat_hits": hits,
+ }
+ if verbose:
+ def tone(raw):
+ return "up" if raw > 0 else ("down" if raw < 0 else "flat")
+ out["reasons"] = [(tone(raw), text) for _, _, raw, text in items if text]
+ out["contribs"] = [(lab, c) for lab, c, raw in contribs if abs(c) > 1e-9]
+ return out
+
+
+def compute_score_series(ind, n):
+ """Son BACKTEST_LOOKBACK bar için (canlı bar dahil) skor serisi. Dönüş: (başlangıç_indeksi, [skor_dict,...])"""
+ start = min(max(WARMUP_BARS, n - BACKTEST_LOOKBACK), n - 1)
+ return start, [_score_at(ind, i) for i in range(start, n)]
+
+
+# ---------------------------------------------------------------------------
+# BACKTEST — yön doğruluğu + gerçek işlem simülasyonu (SL/TP/zaman çıkışı + komisyon)
+# ---------------------------------------------------------------------------
+def _factor_gate_ok(s):
+ """v3 sert filtre: bir skor barının 'kaliteli sinyal' sayılıp sayılmayacağını belirler.
+ Hem CANLI sinyalde hem BACKTEST'te AYNI fonksiyon kullanılır (tutarlılık, iyimser backtest yok).
+ İki koşul: (1) belirgin bir rejim var mı (ADX / sıkışma), (2) faktörler gerçekten aynı yönde mi
+ (konsensüs). Bu ikisi zayıfsa bar, isabet istatistiğine hiç dahil edilmez / işlem açılmaz."""
+ adx_v = s.get("adx")
+ if adx_v == adx_v and adx_v < MIN_REGIME_ADX and not s.get("squeeze_on"):
+ return False
+ tot = s["bull_w"] + s["bear_w"]
+ if tot <= 0:
+ return True
+ direction = 1 if s["score"] > 0 else -1
+ agree = (s["bull_w"] if direction > 0 else s["bear_w"]) / tot
+ return agree >= MIN_AGREE_FOR_SIGNAL
+
+
+def directional_accuracy(df, start, scores, forward=5, threshold=SIGNAL_THRESHOLD):
+ """Klasik test: sinyal 'forward' bar sonra doğru yönü göstermiş mi? (rejim kırılımlı,
+ v3 sert filtresinden geçen barlar üzerinden). Ayrıca ilk-yarı / ikinci-yarı isabet oranını
+ karşılaştırarak rejim kayması ya da parametre aşırı-uyumu (overfit) belirtisi olup olmadığını işaretler."""
+ c = df["c"].to_numpy()
+ n = len(c)
+ stats = {"all": [0, 0], "trend": [0, 0], "range": [0, 0]}
+ signal_hits = []
+ for i in range(start, n - forward):
+ s = scores[i - start]
+ if abs(s["score"]) < threshold or not _factor_gate_ok(s):
+ continue
+ correct = (s["score"] > 0) == (c[i + forward] > c[i])
+ regime = "trend" if s["adx"] >= 25 else "range"
+ for key in ("all", regime):
+ stats[key][1] += 1
+ if correct:
+ stats[key][0] += 1
+ signal_hits.append(correct)
+ if stats["all"][1] < 5:
+ return None
+
+ def pack(key):
+ ok, t = stats[key]
+ return {"accuracy": ok / t, "n_signals": t} if t > 0 else None
+
+ half1_acc = half2_acc = None
+ stable = True
+ if len(signal_hits) >= STABILITY_MIN_SAMPLES:
+ mid = len(signal_hits) // 2
+ h1, h2 = signal_hits[:mid], signal_hits[mid:]
+ half1_acc = sum(h1) / len(h1)
+ half2_acc = sum(h2) / len(h2)
+ stable = abs(half1_acc - half2_acc) <= STABILITY_MAX_GAP
+
+ return {
+ "accuracy": stats["all"][0] / stats["all"][1], "correct": stats["all"][0],
+ "n_signals": stats["all"][1], "forward_bars": forward,
+ "trend_regime": pack("trend"), "range_regime": pack("range"),
+ "half1_acc": half1_acc, "half2_acc": half2_acc, "stable": stable,
+ }
+
+
+def simulate_trades(df, ind, start, scores, threshold=SIGNAL_THRESHOLD):
+ """Sinyalleri sırayla (üst üste binmeden) işleme çevirir.
+ Giriş: sinyal barını izleyen barın AÇILIŞI (gerçekçi, ileri sızıntı yok).
+ Çıkış: SL (1.5×ATR) / TP (2.5×ATR) / 24 bar zaman çıkışı. Aynı barda ikisi de değerse SL öncelikli (kötümser)."""
+ A = ind["_arr"]
+ o, h, l, c, atr_a = A["o"], A["h"], A["l"], A["c"], A["atr"]
+ n = len(c)
+ trades = []
+ i = start
+ while i <= n - 2:
+ sd = scores[i - start]
+ s = sd["score"]
+ a = atr_a[i]
+ if abs(s) < threshold or not (a > 0) or not _factor_gate_ok(sd):
+ i += 1
+ continue
+ d = 1 if s > 0 else -1
+ entry = o[i + 1]
+ risk = SL_ATR * a
+ sl, tp = entry - d * risk, entry + d * TP_ATR * a
+ last = min(n - 1, i + 1 + MAX_HOLD_BARS)
+ exit_i, exit_px, why = None, None, None
+ for j in range(i + 1, last + 1):
+ hit_sl = (l[j] <= sl) if d > 0 else (h[j] >= sl)
+ hit_tp = (h[j] >= tp) if d > 0 else (l[j] <= tp)
+ if hit_sl:
+ exit_i, exit_px, why = j, sl, "SL"
+ break
+ if hit_tp:
+ exit_i, exit_px, why = j, tp, "TP"
+ break
+ if exit_i is None:
+ if last == i + 1 + MAX_HOLD_BARS:
+ exit_i, exit_px, why = last, c[last], "ZAMAN"
+ else:
+ break # veri bitti, işlem hâlâ açık — sonuçlandırılamaz
+ pnl = d * (exit_px - entry) / entry - 2 * FEE_PER_SIDE
+ r_mult = pnl / (risk / entry)
+ trades.append({"signal_i": i, "entry_i": i + 1, "exit_i": exit_i, "dir": d, "entry": entry,
+ "exit": exit_px, "pnl": pnl, "r": r_mult, "why": why, "score": s})
+ i = exit_i
+ return trades
+
+
+def summarize_trades(trades, df, start):
+ if len(trades) < 3:
+ return None
+ n = len(df)
+ pnl = np.array([t["pnl"] for t in trades])
+ r = np.array([t["r"] for t in trades])
+ wins, losses = pnl[pnl > 0], pnl[pnl <= 0]
+ gross_loss = abs(losses.sum())
+ pf = float(wins.sum() / gross_loss) if gross_loss > 0 else (99.0 if wins.sum() > 0 else 0.0)
+ win_rate = len(wins) / len(pnl)
+ win_r, loss_r = r[r > 0], r[r <= 0]
+ avg_win_r = float(win_r.mean()) if len(win_r) else 0.0
+ avg_loss_r = float(abs(loss_r.mean())) if len(loss_r) else 0.0
+ kelly = None
+ if avg_win_r > 0 and avg_loss_r > 0:
+ kelly = win_rate - (1 - win_rate) / (avg_win_r / avg_loss_r)
+ sqn = float(np.sqrt(min(len(r), 100)) * r.mean() / r.std()) if r.std() > 0 else 0.0
+
+ mult = np.ones(n - start)
+ for t in trades:
+ mult[t["exit_i"] - start] *= (1 + t["pnl"])
+ equity = np.cumprod(mult)
+ peak = np.maximum.accumulate(equity)
+ max_dd = float(((equity - peak) / peak).min())
+ c = df["c"].to_numpy()
+ bh = c[start:] / c[start]
+
+ streak = best = 0
+ for p in pnl:
+ streak = streak + 1 if p <= 0 else 0
+ best = max(best, streak)
+
+ def side(dirn):
+ sub = [t for t in trades if t["dir"] == dirn]
+ return {"n": len(sub), "win_rate": (sum(1 for t in sub if t["pnl"] > 0) / len(sub)) if sub else None}
+
+ stats = {
+ "n": len(trades), "win_rate": win_rate, "profit_factor": pf, "expectancy": float(pnl.mean()),
+ "avg_r": float(r.mean()), "sqn": sqn, "max_dd": max_dd, "total_return": float(equity[-1] - 1),
+ "bh_return": float(bh[-1] - 1), "max_consec_loss": best, "avg_win_r": avg_win_r,
+ "avg_loss_r": avg_loss_r, "kelly": kelly, "long": side(1), "short": side(-1),
+ }
+ return stats, equity, bh
+
+
+def run_backtest(df, ind, start, scores):
+ n = len(df)
+ if n - start < 20:
+ return None
+ acc = directional_accuracy(df, start, scores)
+ trades = simulate_trades(df, ind, start, scores)
+ summ = summarize_trades(trades, df, start)
+ bt = {"start": start, "acc": acc, "trades": trades, "stats": None, "equity": None, "bh": None}
+ if summ:
+ bt["stats"], bt["equity"], bt["bh"] = summ
+ return bt
+
+
+# ---------------------------------------------------------------------------
+# SİNİR AĞI (v4) — hafif, tek-gizli-katmanlı MLP, sadece NumPy (harici DL bağımlılığı yok)
+# ---------------------------------------------------------------------------
+# Neden torch/tensorflow değil: bu bir Gradio/HF Spaces panelidir; ağır bir DL kütüphanesi
+# başlangıç süresini ve dağıtım boyutunu ciddi artırır. Özellik sayısı azdır (13), örneklem
+# küçüktür (~150-250 bar) — bu ölçekte elle yazılmış küçük bir MLP, pratikte ağır kütüphanelerle
+# aynı işi görür ve tamamen şeffaftır (ne öğrendiği kolayca incelenebilir).
+#
+# SIZINTI KORUMASI: Model SADECE backtest penceresinin (start) BAŞLAMASINDAN ÖNCEKİ barlarla
+# eğitilir; skor serisi ile aynı mantık — canlı sinyal ve backtest aynı modeli, aynı nedensellikle
+# kullanır. Model, kendi eğitim setinin son %20'si üzerinde kaba bir in-sample doğruluk raporlar
+# (gerçek bir holdout değildir — sadece "bu model saçmalıyor mu" kontrolü; asıl doğrulama her
+# zaman directional_accuracy'nin backtest'idir).
+NN_FEATURE_NAMES = [
+ "RSI", "MACD Hist", "ADX", "+DI/-DI Farkı", "Stokastik", "MFI", "CMF",
+ "Göreli Hacim", "ATR Yüzdeliği", "Piyasa Yapısı", "Sıkışma", "Bollinger Konumu", "EMA20>EMA50",
+]
+
+
+def _nn_build_features(ind, idx):
+ """idx barındaki (yalnızca o ana kadarki veriyle, nedensel) normalize edilmiş öznitelik vektörü."""
+ A = ind["_arr"]
+ price = A["c"][idx]
+ e20, e50 = A["ema20"][idx], A["ema50"][idx]
+ bb_u, bb_l = A["bb_upper"][idx], A["bb_lower"][idx]
+ bb_pos = (price - bb_l) / (bb_u - bb_l) if (bb_u == bb_u and bb_u != bb_l) else 0.5
+ return np.array([
+ (A["rsi"][idx] - 50.0) / 50.0,
+ math.tanh(A["macd_hist"][idx] / (abs(price) * 0.002 + 1e-9)),
+ min(A["adx"][idx], 60.0) / 60.0 if A["adx"][idx] == A["adx"][idx] else 0.0,
+ (A["plus_di"][idx] - A["minus_di"][idx]) / 100.0,
+ (A["stoch_k"][idx] - 50.0) / 50.0,
+ (A["mfi"][idx] - 50.0) / 50.0,
+ max(-1.0, min(1.0, A["cmf"][idx])),
+ math.tanh(A["rvol"][idx] - 1.0),
+ (A["atr_rank"][idx] - 0.5) * 2.0,
+ float(A["struct"][idx]),
+ 1.0 if A["sq_on"][idx] > 0 else 0.0,
+ (bb_pos - 0.5) * 2.0,
+ 1.0 if e20 > e50 else -1.0,
+ ], dtype=float)
+
+
+def _nn_dataset(ind, start, forward=NN_FORWARD):
+ """Eğitim seti: SADECE start'tan ÖNCEKİ barlar (backtest/canlı penceresine sızıntı yok)."""
+ A = ind["_arr"]
+ c = A["c"]
+ lo = max(WARMUP_BARS, 30)
+ hi = start - forward # etiket için forward bar ileri bakar; bu da start'ı aşmamalı
+ if hi - lo < NN_MIN_TRAIN:
+ return None, None
+ X = np.stack([_nn_build_features(ind, i) for i in range(lo, hi)])
+ y = np.array([1.0 if c[i + forward] > c[i] else 0.0 for i in range(lo, hi)])
+ return X, y
+
+
+class _TinyMLP:
+ """Elle yazılmış, tek gizli katmanlı (ReLU) + sigmoid çıkışlı ileri-beslemeli sinir ağı.
+ Tam-batch gradient descent ile eğitilir; harici bir DL kütüphanesi gerektirmez."""
+
+ def __init__(self, n_in, n_hidden=NN_HIDDEN, seed=42):
+ rng = np.random.default_rng(seed)
+ self.w1 = rng.normal(0, math.sqrt(2.0 / n_in), (n_in, n_hidden))
+ self.b1 = np.zeros(n_hidden)
+ self.w2 = rng.normal(0, math.sqrt(2.0 / n_hidden), (n_hidden, 1))
+ self.b2 = np.zeros(1)
+ self.mu = np.zeros(n_in)
+ self.sigma = np.ones(n_in)
+
+ def _norm(self, X):
+ return (X - self.mu) / self.sigma
+
+ def fit(self, X, y, epochs=NN_EPOCHS, lr=NN_LR, l2=NN_L2):
+ self.mu = X.mean(axis=0)
+ self.sigma = X.std(axis=0) + 1e-8
+ Xn = self._norm(X)
+ yy = y.reshape(-1, 1)
+ n = len(Xn)
+ for _ in range(epochs):
+ z1 = Xn @ self.w1 + self.b1
+ a1 = np.maximum(z1, 0.0) # ReLU
+ z2 = a1 @ self.w2 + self.b2
+ p = 1.0 / (1.0 + np.exp(-z2)) # sigmoid
+ dz2 = (p - yy) / n
+ dw2 = a1.T @ dz2 + l2 * self.w2
+ db2 = dz2.sum(axis=0)
+ da1 = dz2 @ self.w2.T
+ dz1 = da1 * (z1 > 0)
+ dw1 = Xn.T @ dz1 + l2 * self.w1
+ db1 = dz1.sum(axis=0)
+ self.w1 -= lr * dw1
+ self.b1 -= lr * db1
+ self.w2 -= lr * dw2
+ self.b2 -= lr * db2
+ return self
+
+ def predict_proba(self, X):
+ Xn = self._norm(np.atleast_2d(X))
+ a1 = np.maximum(Xn @ self.w1 + self.b1, 0.0)
+ p = 1.0 / (1.0 + np.exp(-(a1 @ self.w2 + self.b2)))
+ return p.ravel()
+
+ def feature_importance(self):
+ """Kaba bir önem ölçüsü: her girişin ilk katman ağırlıklarındaki mutlak etkisi (yorumlanabilirlik için)."""
+ raw = np.abs(self.w1).sum(axis=1)
+ tot = raw.sum()
+ return (raw / tot) if tot > 0 else raw
+
+
+def get_nn_model(ind, start, symbol=None, bar=None):
+ """(sembol, bar, örneklem büyüklüğü) başına eğitilmiş modeli önbellekten döndürür; yoksa eğitir."""
+ def _train():
+ X, y = _nn_dataset(ind, start)
+ if X is None:
+ return None
+ model = _TinyMLP(X.shape[1]).fit(X, y)
+ k = max(10, int(len(X) * 0.2))
+ pred = (model.predict_proba(X[-k:]) > 0.5).astype(float)
+ return {
+ "model": model, "train_acc": float((pred == y[-k:]).mean()),
+ "n_samples": len(X), "base_rate": float(y.mean()),
+ }
+ key = ("nn_model", symbol, bar, start, len(ind["_arr"]["c"]))
+ try:
+ return _cached(key, NN_CACHE_TTL, _train)
+ except Exception:
+ return None
+
+
+# ---------------------------------------------------------------------------
+# CANLI KATMAN — üst zaman dilimleri, emir defteri, funding (backtest EDİLMEZ)
+# ---------------------------------------------------------------------------
+def _mtf_score(symbol, bar, closed_only):
+ hdf = fetch_candles(symbol, bar, 300)
+ if closed_only:
+ hdf = hdf[hdf["confirm"] == 1].reset_index(drop=True)
+ hind = compute_indicators(hdf)
+ r = _score_at(hind, len(hdf) - 1)
+ return {"bar": bar, "score": r["score"]}
+
+
+def _fetch_live_extras(symbol, bar, mtf, micro, closed_only):
+ """MTF / emir defteri / funding çağrılarını PARALEL yapar; hata veren parça sessizce atlanır."""
+ tasks = {}
+ with ThreadPoolExecutor(max_workers=4) as ex:
+ if mtf and symbol and bar:
+ b1 = MTF_MAP.get(bar)
+ if b1 and b1 != bar:
+ tasks["mtf1"] = ex.submit(_mtf_score, symbol, b1, closed_only)
+ b2 = MTF_MAP.get(b1)
+ if b2 and b2 not in (b1, bar):
+ tasks["mtf2"] = ex.submit(_mtf_score, symbol, b2, closed_only)
+ if micro and symbol:
+ tasks["ob"] = ex.submit(fetch_orderbook, symbol, 20)
+ tasks["fund"] = ex.submit(fetch_funding_rate, symbol)
+ out = {}
+ for k, f in tasks.items():
+ try:
+ out[k] = f.result()
+ except Exception:
+ out[k] = None
+ return out
+
+
+def build_trade_plan(price, direction, atr_v, supports, resists, acct=None, risk_pct=None):
+ """Yapısal (destek/direnç) stop uygun aralıktaysa onu, değilse ATR stop'unu kullanır.
+ 3 kademeli hedef + hesap büyüklüğüne göre pozisyon boyutu."""
+ d = direction
+ stop, stop_type = price - d * SL_ATR * atr_v, f"ATR × {SL_ATR}"
+ cand = None
+ if d > 0 and supports:
+ cand = supports[0][0] - 0.25 * atr_v
+ elif d < 0 and resists:
+ cand = resists[0][0] + 0.25 * atr_v
+ if cand is not None:
+ dist = abs(price - cand)
+ if 0.8 * atr_v <= dist <= 3.0 * atr_v and (cand < price if d > 0 else cand > price):
+ stop, stop_type = cand, "Yapısal (S/R arkası)"
+ risk = abs(price - stop)
+ plan = {
+ "direction": "LONG" if d > 0 else "SHORT", "entry": price, "stop_loss": stop, "stop_type": stop_type,
+ "risk_dist": risk, "risk_frac": risk / price,
+ "targets": [(price + d * risk * m, m) for m in TP_R_MULTIPLES], "sizing": None,
+ }
+ if acct and acct > 0 and risk_pct and risk_pct > 0 and risk > 0:
+ risk_amt = acct * risk_pct / 100.0
+ qty = risk_amt / risk
+ notional = qty * price
+ plan["sizing"] = {"risk_amount": risk_amt, "qty": qty, "notional": notional, "leverage": notional / acct}
+ return plan
+
+
+def compute_confidence(score, agree, mtf_state, hist_q, vol_q, nn_q=0.5):
+ mag = min(abs(score) / 8.0, 1.0)
+ conf = 100.0 * (0.30 * mag + 0.20 * agree + 0.15 * mtf_state + 0.15 * hist_q + 0.15 * nn_q + 0.05 * vol_q)
+ parts = {"Skor Büyüklüğü": mag, "Faktör Uyumu": agree, "MTF Teyidi": mtf_state,
+ "Tarihsel Kenar": hist_q, "Sinir Ağı Teyidi": nn_q, "Volatilite Rejimi": vol_q}
+ return min(conf, 100.0), parts
+
+
+def grade_from_conf(conf):
+ for thr, g, col in ((75, "A+", "#3ddc97"), (62, "A", "#7fe6b8"), (50, "B", "#f2b84b"), (38, "C", "#ff9aa8")):
+ if conf >= thr:
+ return g, col
+ return "D", "#ff5c72"
+
+
+def generate_signal(df, symbol=None, bar=None, mtf=True, micro=True, closed_only=False,
+ acct=None, risk_pct=None):
+ ind = compute_indicators(df)
+ n = len(df)
+ start, scores = compute_score_series(ind, n)
+ base = _score_at(ind, n - 1, verbose=True)
+ score, price, w = base["score"], base["price"], base["w"]
+ reasons, contribs = list(base["reasons"]), list(base["contribs"])
+ tags = []
+ if base["squeeze_on"]:
+ tags.append(("SIKIŞMA AKTİF", "#f2b84b"))
+ for name, sgn in base["pat_hits"]:
+ tags.append((name.upper(), "#3ddc97" if sgn > 0 else "#ff5c72"))
+
+ def overlay(label, delta, text):
+ nonlocal score
+ score += delta
+ reasons.append(("up" if delta > 0 else "down", text))
+ contribs.append((label, delta))
+
+ # --- Uyumsuzluk (RSI divergence) — reversion sinyali, rejime göre ağırlıklı ---
+ div = detect_divergence(df, ind)
+ div_weight = 1.5 - 1.1 * w # güçlü trendde 0.4, yatayda 1.5 (eski davranışla aynı uçlar)
+ if div["bullish"]:
+ overlay("Yükseliş Uyumsuzluğu", div_weight, "Yükseliş uyumsuzluğu tespit edildi (fiyat düşük dip, RSI yüksek dip)")
+ tags.append(("YÜKSELİŞ UYUMSUZLUĞU", "#3ddc97"))
+ if div["bearish"]:
+ overlay("Düşüş Uyumsuzluğu", -div_weight, "Düşüş uyumsuzluğu tespit edildi (fiyat yüksek tepe, RSI düşük tepe)")
+ tags.append(("DÜŞÜŞ UYUMSUZLUĞU", "#ff5c72"))
+
+ # --- Skor ivmesi ---
+ if n - 4 >= start:
+ momentum = base["score"] - scores[n - 4 - start]["score"]
+ if momentum > 1.5:
+ overlay("Skor İvmesi", 0.3, "Kompozit skor son barlarda hızla güçleniyor")
+ elif momentum < -1.5:
+ overlay("Skor İvmesi", -0.3, "Kompozit skor son barlarda hızla zayıflıyor")
+
+ # --- Canlı ekstralar (paralel çekim) ---
+ extras = _fetch_live_extras(symbol, bar, mtf, micro, closed_only)
+ sgn = 1 if score > 0 else (-1 if score < 0 else 0)
+
+ # --- 2 kademeli MTF teyidi ---
+ mtf_info, align_flags = [], []
+ for key, wt in (("mtf1", 1.0), ("mtf2", 0.6)):
+ m = extras.get(key)
+ if not m:
+ continue
+ hs = m["score"]
+ aligned = None
+ if abs(hs) >= 1.0 and sgn != 0:
+ aligned = bool(np.sign(hs) == sgn)
+ align_flags.append(aligned)
+ if aligned:
+ overlay(f"{m['bar']} Teyidi", sgn * wt, f"{m['bar']} zaman diliminde de aynı yönlü teyit var (skor {hs:+.1f})")
+ else:
+ overlay(f"{m['bar']} Çelişkisi", -sgn * wt, f"{m['bar']} zaman dilimi ters yönlü sinyal veriyor (skor {hs:+.1f}) — dikkat")
+ mtf_info.append({"bar": m["bar"], "score": round(hs, 2), "aligned": aligned})
+ mtf_state = (sum(1.0 for a in align_flags if a) / len(align_flags)) if align_flags else 0.5
+ mtf_opposed = any(a is False for a in align_flags)
+
+ # --- Emir defteri dengesizliği (derinlik ağırlıklı, kısa vadede anlamlı) ---
+ imb = None
+ ob = extras.get("ob")
+ if ob and ob.get("bids") and ob.get("asks"):
+ bw = sum(float(x[1]) / (k + 1) for k, x in enumerate(ob["bids"]))
+ aw = sum(float(x[1]) / (k + 1) for k, x in enumerate(ob["asks"]))
+ if bw + aw > 0:
+ imb = (bw - aw) / (bw + aw)
+ if abs(imb) >= 0.2:
+ delta = max(-0.8, min(0.8, imb * 2)) * (0.5 if bar in SLOW_BARS else 1.0)
+ overlay("Emir Defteri", delta,
+ f"Emir defterinde {'alış' if imb > 0 else 'satış'} baskısı (dengesizlik {imb * 100:+.0f}%)")
+
+ # --- Funding rate (kalabalık pozisyon = kontraryen) ---
+ fr = extras.get("fund")
+ if fr is not None:
+ if fr > 0.0005:
+ overlay("Funding", -0.6, f"Funding aşırı pozitif ({fr * 100:.3f}%) — kalabalık long, tasfiye riski")
+ elif fr > 0.0002:
+ overlay("Funding", -0.3, f"Funding yüksek pozitif ({fr * 100:.3f}%) — long tarafı kalabalık")
+ elif fr < -0.0005:
+ overlay("Funding", 0.6, f"Funding aşırı negatif ({fr * 100:.3f}%) — kalabalık short, sıkışma potansiyeli")
+ elif fr < -0.0002:
+ overlay("Funding", 0.3, f"Funding negatif ({fr * 100:.3f}%) — short tarafı kalabalık")
+
+ # --- Sinir Ağı (v4): öğrenilmiş yön olasılığı — sadece start'tan önceki barlarla eğitilir ---
+ nn_result, nn_prob, nn_dir, nn_strength = None, None, 0, 0.0
+ try:
+ nn_result = get_nn_model(ind, start, symbol, bar)
+ except Exception:
+ nn_result = None
+ if nn_result:
+ nn_prob = float(nn_result["model"].predict_proba(_nn_build_features(ind, n - 1))[0])
+ nn_dir = 1 if nn_prob > 0.5 else -1
+ nn_strength = abs(nn_prob - 0.5) * 2.0 # 0 (kararsız) .. 1 (çok emin)
+ sgn = 1 if score > 0 else (-1 if score < 0 else 0)
+ nn_delta = nn_dir * nn_strength * NN_WEIGHT
+ if sgn != 0 and nn_dir == sgn:
+ overlay("Sinir Ağı", nn_delta,
+ f"NN modeli aynı yönü destekliyor (P(yukarı)={nn_prob * 100:.0f}%, "
+ f"eğitim seti kaba isabeti %{nn_result['train_acc'] * 100:.0f}, n={nn_result['n_samples']})")
+ elif sgn != 0:
+ overlay("Sinir Ağı", nn_delta,
+ f"NN modeli ters yönde (P(yukarı)={nn_prob * 100:.0f}%, "
+ f"eğitim seti kaba isabeti %{nn_result['train_acc'] * 100:.0f}, n={nn_result['n_samples']}) — dikkat")
+ else:
+ reasons.append(("flat", f"NN modeli için yeterli geçmiş veri yok (en az {NN_MIN_TRAIN} bar gerekli) — bu katman devre dışı"))
+
+ # --- Destek / direnç yakınlığı ---
+ atr_v = float(ind["atr"].iloc[-1])
+ supports, resists = find_sr_levels(df, atr_v)
+ sgn = 1 if score > 0 else (-1 if score < 0 else 0)
+ if atr_v > 0 and sgn != 0:
+ if sgn > 0:
+ if resists and resists[0][1] >= 2 and (resists[0][0] - price) / atr_v <= 1.0:
+ lv, tc = resists[0]
+ overlay("Yakın Direnç", -0.8, f"Yakın direnç {fmt_price(lv)} ({tc} temas, {(lv - price) / atr_v:.1f} ATR) — yükselişi sınırlayabilir")
+ elif supports and supports[0][1] >= 2 and (price - supports[0][0]) / atr_v <= 0.5:
+ lv, tc = supports[0]
+ overlay("Destek Üstünde", 0.4, f"Fiyat güçlü destek {fmt_price(lv)} ({tc} temas) üzerinde")
+ else:
+ if supports and supports[0][1] >= 2 and (price - supports[0][0]) / atr_v <= 1.0:
+ lv, tc = supports[0]
+ overlay("Yakın Destek", 0.8, f"Yakın destek {fmt_price(lv)} ({tc} temas, {(price - lv) / atr_v:.1f} ATR) — düşüşü sınırlayabilir")
+ elif resists and resists[0][1] >= 2 and (resists[0][0] - price) / atr_v <= 0.5:
+ lv, tc = resists[0]
+ overlay("Direnç Altında", -0.4, f"Fiyat güçlü direnç {fmt_price(lv)} ({tc} temas) altında")
+
+ score = max(-10.0, min(10.0, score))
+
+ # --- Konsensüs + sınıflandırma ---
+ direction = 1 if score > 0 else -1
+ tot = base["bull_w"] + base["bear_w"]
+ agree = ((base["bull_w"] if direction > 0 else base["bear_w"]) / tot) if tot > 0 else 0.5
+ if abs(score) >= STRONG_THRESHOLD and agree >= 0.65 and not mtf_opposed:
+ signal, color = ("GÜÇLÜ AL", "#3ddc97") if score > 0 else ("GÜÇLÜ SAT", "#ff5c72")
+ elif abs(score) >= SIGNAL_THRESHOLD:
+ signal, color = ("AL", "#7fe6b8") if score > 0 else ("SAT", "#ff9aa8")
+ if abs(score) >= STRONG_THRESHOLD:
+ reasons.append(("flat", f"Skor güçlü bölgede ancak konsensüs ({agree * 100:.0f}%) veya MTF filtresini geçemedi — GÜÇLÜ yerine normal sinyal verildi"))
+ else:
+ signal, color = "BEKLE / NÖTR", "#f2b84b"
+
+ # --- v3 SERT FİLTRELER — düşük kaliteli AL/SAT'ları BEKLE'ye çevirir (isabet oranını artırmak için) ---
+ veto_reasons = []
+ adx_v = base["adx"]
+ if signal != "BEKLE / NÖTR":
+ if adx_v == adx_v and adx_v < MIN_REGIME_ADX and not base["squeeze_on"]:
+ veto_reasons.append(f"ADX çok düşük ({adx_v:.1f}) — belirgin bir trend/rejim yok, yön güvenilir değil")
+ if agree < MIN_AGREE_FOR_SIGNAL:
+ veto_reasons.append(f"Faktör konsensüsü zayıf (%{agree * 100:.0f}) — göstergeler birbiriyle çelişiyor")
+ if MTF_HARD_GATE and align_flags and align_flags[0] is False and "GÜÇLÜ" not in signal:
+ veto_reasons.append(f"Üst zaman dilimi ({mtf_info[0]['bar']}) net ters yönde — teyit yok")
+ if imb is not None and np.sign(imb) not in (0, direction) and abs(imb) >= OB_HARD_GATE_IMB:
+ veto_reasons.append(f"Emir defterinde sinyale güçlü ters yönde baskı var (dengesizlik {imb * 100:+.0f}%)")
+ if nn_result and nn_dir != direction and nn_strength >= NN_GATE_STRENGTH:
+ veto_reasons.append(f"NN modeli güçlü şekilde ters yönde (P(yukarı)={nn_prob * 100:.0f}%)")
+ if veto_reasons:
+ for vr in veto_reasons:
+ reasons.append(("flat", f"FİLTRE: {vr}"))
+ signal, color = "BEKLE / NÖTR", "#f2b84b"
+ tags.append(("SERT FİLTRE İLE ELENDİ", "#7c8797"))
+
+ is_neutral = signal == "BEKLE / NÖTR"
+
+ # --- Tarihsel doğrulama ---
+ backtest = run_backtest(df, ind, start, scores)
+ hist_q = 0.4
+ if backtest:
+ qs = []
+ acc = backtest["acc"]
+ if acc:
+ p_shrunk = (acc["correct"] + 5) / (acc["n_signals"] + 10) # Bayes büzülmesi (önsel %50)
+ qs.append(min(max((p_shrunk - 0.45) / 0.20, 0.0), 1.0))
+ if acc.get("stable") is False:
+ qs.append(0.2) # ilk/ikinci yarı isabeti tutarsız -> rejim kayması / overfit riski
+ reasons.append(("flat", f"Tarihsel isabet tutarsız: ilk yarı %{acc['half1_acc']*100:.0f} vs "
+ f"ikinci yarı %{acc['half2_acc']*100:.0f} — bu kenara temkinli yaklaşın"))
+ st = backtest["stats"]
+ if st:
+ qs.append(min(max((st["profit_factor"] - 0.8) / 0.8, 0.0), 1.0))
+ if qs:
+ hist_q = float(np.mean(qs))
+ rank = base["atr_rank"]
+ vol_q = 1.0 if 0.10 <= rank <= 0.90 else 0.5
+ if rank > 0.90:
+ reasons.append(("flat", f"Volatilite aşırı yüksek (ATR yüzdeliği %{rank * 100:.0f}) — stoplar geniş tutulmalı, güven düşürüldü"))
+ nn_q = 0.5
+ if nn_result:
+ nn_agree = 1.0 if nn_dir == direction else -1.0
+ nn_q = min(max(0.5 + nn_agree * nn_strength * (0.5 + 0.5 * nn_result["train_acc"]), 0.0), 1.0)
+ conf, conf_parts = compute_confidence(score, agree, mtf_state, hist_q, vol_q, nn_q)
+ grade, grade_color = ("—", "#7c8797") if is_neutral else grade_from_conf(conf)
+
+ plan = None
+ if not is_neutral and atr_v > 0:
+ plan = build_trade_plan(price, direction, atr_v, supports, resists, acct, risk_pct)
+
+ return {
+ "signal": signal, "score": round(score, 2), "confidence": round(conf, 1), "grade": grade,
+ "grade_color": grade_color, "color": color, "reasons": reasons, "contribs": contribs,
+ "indicators": ind, "price": price, "divergence": div, "mtf": mtf_info, "plan": plan,
+ "backtest": backtest, "regime": base["regime"], "adx": base["adx"], "atr_rank": rank,
+ "squeeze_on": base["squeeze_on"], "agree": agree, "bull_w": base["bull_w"], "bear_w": base["bear_w"],
+ "conf_parts": conf_parts, "tags": tags, "funding": fr, "imbalance": imb,
+ "supports": supports, "resists": resists, "atr": atr_v,
+ "nn": ({"prob_up": round(nn_prob, 3), "train_acc": round(nn_result["train_acc"], 3),
+ "n_samples": nn_result["n_samples"]} if nn_result else None),
+ }
+
+
+# ---------------------------------------------------------------------------
+# RISK ANALYTICS
+# ---------------------------------------------------------------------------
+def risk_metrics(df, bar):
+ ret = df["c"].pct_change().dropna()
+ if len(ret) < 5:
+ return None
+ periods = BAR_TO_PERIODS_PER_YEAR.get(bar, 365)
+ vol_annual = ret.std() * np.sqrt(periods)
+ mean_annual = ret.mean() * periods
+ sharpe = mean_annual / vol_annual if vol_annual > 0 else 0.0
+ cum = (1 + ret).cumprod()
+ peak = cum.cummax()
+ dd = (cum - peak) / peak
+ var95 = np.percentile(ret, 5)
+ tail = ret[ret <= var95]
+ cvar95 = tail.mean() if len(tail) else var95
+ return {
+ "volatility_annual": vol_annual, "return_annual": mean_annual, "sharpe": sharpe,
+ "max_drawdown": dd.min(), "current_dd": dd.iloc[-1],
+ "var95_bar": var95, "cvar95_bar": cvar95,
+ }
+
+
+# ---------------------------------------------------------------------------
+# FORMAT HELPERS
+# ---------------------------------------------------------------------------
+def _isnan(v):
+ return v is None or (isinstance(v, float) and math.isnan(v))
+
+
+def fmt_price(v):
+ if _isnan(v):
+ return "—"
+ av = abs(v)
+ if av >= 1000:
+ return f"{v:,.2f}"
+ if av >= 1:
+ return f"{v:,.4f}"
+ if av >= 0.01:
+ return f"{v:.6f}"
+ return f"{v:.8f}"
+
+
+def fmt_pct(v):
+ if _isnan(v):
+ return "—"
+ sign = "+" if v > 0 else ""
+ return f"{sign}{v * 100:.2f}%"
+
+
+def fmt_large(v):
+ if _isnan(v):
+ return "—"
+ av = abs(v)
+ if av >= 1e9:
+ return f"{v / 1e9:.2f}B"
+ if av >= 1e6:
+ return f"{v / 1e6:.2f}M"
+ if av >= 1e3:
+ return f"{v / 1e3:.2f}K"
+ return f"{v:.2f}"
+
+
+def metric_card(label, value, sub="", tone="neutral"):
+ tone_class = {"up": "mc-up", "down": "mc-down", "neutral": "mc-neutral"}.get(tone, "mc-neutral")
+ sub_html = f'{sub}
' if sub else ""
+ return (f'{label}
'
+ f'
{value}
{sub_html}
{title}
'
+
+
+def cards_row(cards):
+ return f'{"".join(cards)}
' if cards else ""
+
+
+def error_box(msg):
+ return f'⚠ {msg}
'
+
+
+# ---------------------------------------------------------------------------
+# CHART BUILDERS
+# ---------------------------------------------------------------------------
+def _base_layout(fig, title, height):
+ fig.update_layout(
+ template="plotly_dark", height=height, margin=dict(l=10, r=10, t=40, b=10),
+ paper_bgcolor=CHART_BG, plot_bgcolor=CHART_BG, title=title,
+ legend=dict(orientation="h", y=1.05, font=dict(size=10)),
+ font=dict(family="IBM Plex Mono, monospace", size=11),
+ )
+ return fig
+
+
+def _empty_fig(msg, title="", height=220):
+ fig = go.Figure()
+ fig.add_annotation(text=msg, x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False,
+ font=dict(size=13, color="#7c8797"))
+ fig.update_xaxes(visible=False)
+ fig.update_yaxes(visible=False)
+ return _base_layout(fig, title, height)
+
+
+def build_price_chart(df, ind, symbol, bar):
+ fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.75, 0.25], vertical_spacing=0.03)
+ fig.add_trace(go.Candlestick(
+ x=df["ts"], open=df["o"], high=df["h"], low=df["l"], close=df["c"], name=symbol,
+ increasing_line_color="#3ddc97", decreasing_line_color="#ff5c72"), row=1, col=1)
+ fig.add_trace(go.Scatter(x=df["ts"], y=ind["ema20"], name="EMA20",
+ line=dict(color="#5b8cff", width=1)), row=1, col=1)
+ fig.add_trace(go.Scatter(x=df["ts"], y=ind["ema50"], name="EMA50",
+ line=dict(color="#f2b84b", width=1)), row=1, col=1)
+ fig.add_trace(go.Scatter(x=df["ts"], y=ind["bb_upper"], name="BB Üst",
+ line=dict(color="rgba(150,160,255,0.45)", width=1, dash="dot")), row=1, col=1)
+ fig.add_trace(go.Scatter(x=df["ts"], y=ind["bb_lower"], name="BB Alt",
+ line=dict(color="rgba(150,160,255,0.45)", width=1, dash="dot"),
+ fill="tonexty", fillcolor="rgba(150,160,255,0.05)"), row=1, col=1)
+ vol_colors = np.where(df["c"] >= df["o"], "#3ddc97", "#ff5c72")
+ fig.add_trace(go.Bar(x=df["ts"], y=df["vol"], name="Hacim", marker_color=vol_colors, opacity=0.55),
+ row=2, col=1)
+ fig.update_layout(xaxis_rangeslider_visible=False)
+ return _base_layout(fig, f"{symbol} · {bar}", 520)
+
+
+def build_signal_price_chart(df, ind, symbol, bar, res):
+ """Sinyal sekmesinin ana grafiği: mum + Supertrend + Ichimoku bulutu + S/R + geçmiş sinyal işaretleri + işlem planı."""
+ n = len(df)
+ v0 = max(0, n - 200)
+ sl = slice(v0, n)
+ ts = df["ts"].iloc[sl]
+ fig = go.Figure()
+ fig.add_trace(go.Candlestick(
+ x=ts, open=df["o"].iloc[sl], high=df["h"].iloc[sl], low=df["l"].iloc[sl], close=df["c"].iloc[sl],
+ name=symbol, increasing_line_color="#3ddc97", decreasing_line_color="#ff5c72"))
+ # Ichimoku bulutu
+ fig.add_trace(go.Scatter(x=ts, y=ind["ich_a"].iloc[sl], line=dict(width=0), showlegend=False, hoverinfo="skip"))
+ fig.add_trace(go.Scatter(x=ts, y=ind["ich_b"].iloc[sl], line=dict(width=0), name="Ichimoku Bulutu",
+ fill="tonexty", fillcolor="rgba(120,140,255,0.10)", hoverinfo="skip"))
+ # Supertrend (yükseliş/düşüş ayrı renk)
+ st_line, st_dir = ind["st_line"].iloc[sl], ind["st_dir"].iloc[sl]
+ fig.add_trace(go.Scatter(x=ts, y=st_line.where(st_dir > 0), name="Supertrend ▲",
+ line=dict(color="#3ddc97", width=1.5), connectgaps=False))
+ fig.add_trace(go.Scatter(x=ts, y=st_line.where(st_dir < 0), name="Supertrend ▼",
+ line=dict(color="#ff5c72", width=1.5), connectgaps=False))
+ # Destek / direnç
+ for lv, tc in res["supports"][:3]:
+ fig.add_hline(y=lv, line=dict(color="rgba(61,220,151,0.55)", dash="dash", width=1),
+ annotation_text=f"D {fmt_price(lv)} ×{tc}", annotation_position="left",
+ annotation_font=dict(size=9, color="#3ddc97"))
+ for lv, tc in res["resists"][:3]:
+ fig.add_hline(y=lv, line=dict(color="rgba(255,92,114,0.55)", dash="dash", width=1),
+ annotation_text=f"R {fmt_price(lv)} ×{tc}", annotation_position="left",
+ annotation_font=dict(size=9, color="#ff5c72"))
+ # Geçmiş sinyal işlemleri
+ bt = res["backtest"]
+ if bt and bt["trades"]:
+ atr_a = ind["_arr"]["atr"]
+ for d, sym_, col, nm in ((1, "triangle-up", "#3ddc97", "Geçmiş LONG"), (-1, "triangle-down", "#ff5c72", "Geçmiş SHORT")):
+ tr = [t for t in bt["trades"] if t["dir"] == d and t["entry_i"] >= v0]
+ if not tr:
+ continue
+ xs = [df["ts"].iloc[t["entry_i"]] for t in tr]
+ ys = [(df["l"].iloc[t["entry_i"]] - 0.6 * atr_a[t["entry_i"]]) if d > 0
+ else (df["h"].iloc[t["entry_i"]] + 0.6 * atr_a[t["entry_i"]]) for t in tr]
+ hov = [f"{nm} · skor {t['score']:+.1f}{icon[t]} {txt}'
+ f'
{res["signal"]}
'
+ f'
'
+ f'
'
+ f'
'
+ f'
'
+ f'
FAKTÖR KONSENSÜSÜ · BOĞA %{bull_pct:.0f} / AYI %{100 - bull_pct:.0f}
'
+ f'
{k} %{v * 100:.0f}
' for k, v in res["conf_parts"].items())
+ tag_html = ""
+ if res["tags"]:
+ tag_html = '"
+ conf_html = f'{conf_tags}
'
+
+ # ---- İşlem planı + pozisyon boyutu ----
+ plan_cards, size_cards = [], []
+ if plan:
+ up = plan["direction"] == "LONG"
+ plan_cards = [
+ metric_card("ÖNERİLEN YÖN", plan["direction"], "", "up" if up else "down"),
+ metric_card("GİRİŞ", f"${fmt_price(plan['entry'])}"),
+ metric_card("STOP-LOSS", f"${fmt_price(plan['stop_loss'])}",
+ f"{plan['stop_type']} · %{plan['risk_frac'] * 100:.2f} risk", "down"),
+ ]
+ for k, (px, m) in enumerate(plan["targets"]):
+ plan_cards.append(metric_card(f"HEDEF {k + 1}", f"${fmt_price(px)}", f"{m:.2f}R", "up"))
+ sz = plan["sizing"]
+ if sz:
+ size_cards = [
+ metric_card("RİSK TUTARI", f"${fmt_large(sz['risk_amount'])}", f"Hesabın %{risk_pct:g}'i"),
+ metric_card("POZİSYON (USDT)", f"${fmt_large(sz['notional'])}", f"Miktar: {sz['qty']:.6g}"),
+ metric_card("KALDIRAÇ ETKİSİ", f"{sz['leverage']:.2f}x",
+ "Spot ile yetmez — kaldıraç gerekir" if sz["leverage"] > 1.0 else "Spot ile uygulanabilir",
+ "down" if sz["leverage"] > 1.0 else "up"),
+ ]
+ stats = bt["stats"] if bt else None
+ if stats is not None:
+ k = stats["kelly"]
+ if stats["n"] < 20:
+ kv, ks, kt = "—", "Örnek az (<20 işlem)", "neutral"
+ elif k is None or k <= 0:
+ kv, ks, kt = "Kenar yok", "Kelly ≤ 0", "down"
+ else:
+ half = min(k / 2, 0.03)
+ kv, ks, kt = f"%{half * 100:.2f}", f"Yarım-Kelly (tavan %3) · bilgi amaçlı", "up"
+ size_cards.append(metric_card("ÖNERİLEN RİSK", kv, ks, kt))
+
+ # ---- Backtest kartları ----
+ bt_cards = []
+ if stats:
+ L, S = stats["long"], stats["short"]
+ wr = lambda x: f"%{x['win_rate'] * 100:.0f}" if x["win_rate"] is not None else "—"
+ bt_cards = [
+ metric_card("İŞLEM SAYISI", f"{stats['n']}", f"Long {L['n']} ({wr(L)}) · Short {S['n']} ({wr(S)})"),
+ metric_card("KAZANMA ORANI", f"%{stats['win_rate'] * 100:.1f}", f"Maks. üst üste kayıp: {stats['max_consec_loss']}",
+ "up" if stats["win_rate"] >= 0.45 else "down"),
+ metric_card("PROFIT FACTOR", f"{stats['profit_factor']:.2f}", "Brüt kazanç / brüt kayıp",
+ "up" if stats["profit_factor"] >= 1.2 else "down"),
+ metric_card("BEKLENT�� / İŞLEM", fmt_pct(stats["expectancy"]), f"Ort. {stats['avg_r']:+.2f}R (komisyon dahil)",
+ "up" if stats["expectancy"] > 0 else "down"),
+ metric_card("SQN", f"{stats['sqn']:.2f}", "Sistem kalitesi (>2 iyi, >3 çok iyi)",
+ "up" if stats["sqn"] >= 2 else "neutral"),
+ metric_card("STRATEJİ MAKS. DD", fmt_pct(stats["max_dd"]), "", "down"),
+ metric_card("STRATEJİ vs AL&TUT", f"{fmt_pct(stats['total_return'])} / {fmt_pct(stats['bh_return'])}",
+ "Aynı dönem, komisyon dahil", "up" if stats["total_return"] > stats["bh_return"] else "down"),
+ ]
+ acc_cards = []
+ if bt and bt["acc"]:
+ a = bt["acc"]
+ acc_cards.append(metric_card("YÖN DOĞRULUĞU", f"%{a['accuracy'] * 100:.1f}",
+ f"{a['n_signals']} sinyal · {a['forward_bars']} bar ileri",
+ "up" if a["accuracy"] >= 0.5 else "down"))
+ if a.get("trend_regime"):
+ t = a["trend_regime"]
+ acc_cards.append(metric_card("DOĞRULUK · TREND", f"%{t['accuracy'] * 100:.1f}",
+ f"{t['n_signals']} sinyal (ADX ≥ 25)", "up" if t["accuracy"] >= 0.5 else "down"))
+ if a.get("range_regime"):
+ t = a["range_regime"]
+ acc_cards.append(metric_card("DOĞRULUK · YATAY", f"%{t['accuracy'] * 100:.1f}",
+ f"{t['n_signals']} sinyal (ADX < 25)", "up" if t["accuracy"] >= 0.5 else "down"))
+
+ # ---- Piyasa bağlamı ----
+ ctx = []
+ for m in res["mtf"]:
+ if m["aligned"] is None:
+ ctx.append(metric_card(f"{m['bar']} TEYİDİ", "Nötr", f"Üst zaman dilimi skoru: {m['score']}"))
+ else:
+ ctx.append(metric_card(f"{m['bar']} TEYİDİ", "Uyumlu ✓" if m["aligned"] else "Ters Yönlü ⚠",
+ f"Üst zaman dilimi skoru: {m['score']}", "up" if m["aligned"] else "down"))
+ if res["funding"] is not None:
+ f_ = res["funding"]
+ ctx.append(metric_card("FUNDING (8S)", f"{f_ * 100:+.4f}%", "Pozitif = long kalabalık",
+ "down" if f_ > 0.0002 else ("up" if f_ < -0.0002 else "neutral")))
+ if res["imbalance"] is not None:
+ im = res["imbalance"]
+ ctx.append(metric_card("DEFTER DENGESİ", f"{im * 100:+.0f}%", "Derinlik ağırlıklı",
+ "up" if im > 0.2 else ("down" if im < -0.2 else "neutral")))
+ if res["supports"]:
+ lv, tc = res["supports"][0]
+ ctx.append(metric_card("YAKIN DESTEK", f"${fmt_price(lv)}", f"{tc} temas · {(res['price'] - lv) / res['atr']:.1f} ATR", "up"))
+ if res["resists"]:
+ lv, tc = res["resists"][0]
+ ctx.append(metric_card("YAKIN DİRENÇ", f"${fmt_price(lv)}", f"{tc} temas · {(lv - res['price']) / res['atr']:.1f} ATR", "down"))
+ ctx.append(metric_card("VOLATİLİTE YÜZDELİĞİ", f"%{res['atr_rank'] * 100:.0f}", "ATR/fiyat, son 100 bar",
+ "down" if res["atr_rank"] > 0.9 else "neutral"))
+
+ reasons_box = (f'FAKTÖR ANALİZİ
'
+ f'
{_reasons_html(res["reasons"])} Backtest: son ~220 barda sinyaller üst üste binmeden işleme çevrilir; giriş bir sonraki barın açılışı, '
+ f'çıkış SL {SL_ATR}×ATR / TP {TP_ATR}×ATR / {MAX_HOLD_BARS} bar; komisyon %{FEE_PER_SIDE * 100:.1f}/yön dahildir. '
+ 'Emir defteri, funding, S/R ve MTF katmanları canlıdır, geçmişe uygulanamaz.
')
+
+ html = (panel + consensus + conf_html + tag_html
+ + (section("İŞLEM PLANI") + cards_row(plan_cards) if plan_cards else "")
+ + (section("POZİSYON BOYUTU") + cards_row(size_cards) if size_cards else "")
+ + (section("GEÇMİŞ PERFORMANS (WALK-FORWARD)") + cards_row(bt_cards) + cards_row(acc_cards) + bt_note
+ if (bt_cards or acc_cards) else "")
+ + section("PİYASA BAĞLAMI") + cards_row(ctx) + reasons_box)
+ return (html, build_signal_price_chart(df, ind, symbol, bar, res), build_factor_chart(res["contribs"], symbol),
+ build_backtest_chart(bt, df, symbol), build_signal_chart(df, ind, symbol))
+ except Exception as e:
+ return empty5(error_box(f"Veri alınamadı: {e}"))
+
+
+def load_risk(symbol, bar):
+ try:
+ df = fetch_candles(symbol, bar, 300)
+ rm = risk_metrics(df, bar)
+ if rm is None:
+ return error_box("Risk hesaplaması için yeterli veri yok."), go.Figure()
+ cards = [
+ metric_card("YILLIKLANDIRILMIŞ VOLATİLİTE", fmt_pct(rm["volatility_annual"])),
+ metric_card("YILLIKLANDIRILMIŞ GETİRİ", fmt_pct(rm["return_annual"]), "",
+ "up" if rm["return_annual"] >= 0 else "down"),
+ metric_card("SHARPE ORANI", f"{rm['sharpe']:.2f}", "", "up" if rm["sharpe"] > 0 else "down"),
+ metric_card("MAKS. DRAWDOWN", fmt_pct(rm["max_drawdown"]), "", "down"),
+ metric_card("GÜNCEL DRAWDOWN", fmt_pct(rm["current_dd"]), "",
+ "down" if rm["current_dd"] < 0 else "neutral"),
+ metric_card("VaR %95 (BAR)", fmt_pct(rm["var95_bar"]), "", "down"),
+ metric_card("CVaR %95 (BAR)", fmt_pct(rm["cvar95_bar"]), "", "down"),
+ ]
+ return cards_row(cards), build_equity_chart(df, symbol)
+ except Exception as e:
+ return error_box(f"Veri alınamadı: {e}"), go.Figure()
+
+
+def load_orderbook(symbol, depth):
+ try:
+ ob = fetch_orderbook(symbol, int(depth))
+ bids = [(float(p), float(s)) for p, s, *_ in ob.get("bids", [])]
+ asks = [(float(p), float(s)) for p, s, *_ in ob.get("asks", [])]
+ if not bids or not asks:
+ return error_box("Emir defteri verisi alınamadı."), go.Figure()
+ best_bid, best_ask = bids[0][0], asks[0][0]
+ spread = best_ask - best_bid
+ spread_pct = spread / best_ask if best_ask else 0.0
+ bid_vol = sum(s for _, s in bids)
+ ask_vol = sum(s for _, s in asks)
+ imbalance = (bid_vol - ask_vol) / (bid_vol + ask_vol) if (bid_vol + ask_vol) else 0.0
+ tone = "up" if imbalance > 0.05 else ("down" if imbalance < -0.05 else "neutral")
+ cards = [
+ metric_card("EN İYİ ALIŞ", f"${fmt_price(best_bid)}", "", "up"),
+ metric_card("EN İYİ SATIŞ", f"${fmt_price(best_ask)}", "", "down"),
+ metric_card("SPREAD", f"${fmt_price(spread)}", fmt_pct(spread_pct)),
+ metric_card("DEFTER DENGESİZLİĞİ", fmt_pct(imbalance), "Pozitif = alış baskısı", tone),
+ ]
+ return cards_row(cards), build_depth_chart(bids, asks, symbol)
+ except Exception as e:
+ return error_box(f"Veri alınamadı: {e}"), go.Figure()
+
+
+@_gpu
+def refresh_all(symbol, bar, depth, closed_only, acct, risk_pct):
+ ov_html, ov_fig = load_overview(symbol, bar)
+ sig = load_signal(symbol, bar, closed_only, acct, risk_pct)
+ risk_html, risk_fig = load_risk(symbol, bar)
+ ob_html, ob_fig = load_orderbook(symbol, depth)
+ return (ov_html, ov_fig, *sig, risk_html, risk_fig, ob_html, ob_fig)
+
+
+def refresh_signal(symbol, bar, closed_only, acct, risk_pct):
+ """Yalnızca sinyal sekmesini yeniler (risk/kapanmış-mum ayarı değişince hızlı güncelleme)."""
+ return load_signal(symbol, bar, closed_only, acct, risk_pct)
+
+
+SCAN_MODES = ["Tümü (skora göre)", "Yalnızca AL yönlü", "Yalnızca SAT yönlü", "Yalnızca yüksek kalite (A / A+)"]
+
+
+def _scan_one(sym, bar, all_tickers, closed_only):
+ df = fetch_candles(sym, bar, 300)
+ if closed_only:
+ df = df[df["confirm"] == 1].reset_index(drop=True)
+ # MTF ve mikro-yapı katmanları taramada kapalı (API yükünü azaltmak için); tekil analizde açık.
+ res = generate_signal(df, symbol=sym, bar=bar, mtf=False, micro=False, closed_only=closed_only)
+ rm = risk_metrics(df, bar)
+ t = all_tickers.get(sym, {})
+ last = float(t.get("last") or df["c"].iloc[-1])
+ open24h = float(t.get("open24h") or df["c"].iloc[0])
+ chg24h = (last - open24h) / open24h if open24h else 0.0
+ div = res["divergence"]
+ div_txt = "Yükseliş" if div["bullish"] else ("Düşüş" if div["bearish"] else "—")
+ bt = res["backtest"]
+ st = bt["stats"] if bt else None
+ acc = bt["acc"] if bt else None
+ return {
+ "Sembol": sym, "Fiyat": last, "24S %": round(chg24h * 100, 2), "Sinyal": res["signal"],
+ "Skor": res["score"], "Kalite": res["grade"], "Güven %": res["confidence"], "Rejim": res["regime"],
+ "RSI": round(res["indicators"]["rsi"].iloc[-1], 1), "ADX": round(res["adx"], 1),
+ "Sıkışma": "●" if res["squeeze_on"] else "—", "Uyumsuzluk": div_txt,
+ "Kazanma %": round(st["win_rate"] * 100, 1) if st else None,
+ "Profit Factor": round(st["profit_factor"], 2) if st else None,
+ "Beklenti %": round(st["expectancy"] * 100, 2) if st else None,
+ "Yön Doğruluğu %": round(acc["accuracy"] * 100, 1) if acc else None,
+ "Volatilite (Yıllık) %": round(rm["volatility_annual"] * 100, 1) if rm else None,
+ "Sharpe": round(rm["sharpe"], 2) if rm else None,
+ }
+
+
+def run_scanner(symbols_text, bar, closed_only=False, mode=SCAN_MODES[0], progress=gr.Progress()):
+ symbols = [s.strip().upper() for s in symbols_text.split(",") if s.strip()][:25]
+ if not symbols:
+ return pd.DataFrame()
+ try:
+ all_tickers = {t["instId"]: t for t in fetch_all_tickers("SPOT")}
+ except Exception:
+ all_tickers = {}
+
+ rows, done = [], 0
+ with ThreadPoolExecutor(max_workers=4) as ex: # ağ beklemesini paralelle (OKX limiti için 4 ile sınırlı)
+ futs = {ex.submit(_scan_one, s, bar, all_tickers, closed_only): s for s in symbols}
+ for f in as_completed(futs):
+ done += 1
+ progress(done / len(symbols), desc=f"{futs[f]} tarandı ({done}/{len(symbols)})")
+ try:
+ rows.append(f.result())
+ except Exception:
+ continue
+ if not rows:
+ return pd.DataFrame()
+ out = pd.DataFrame(rows)
+ if mode == SCAN_MODES[1]:
+ out = out[out["Skor"] >= SIGNAL_THRESHOLD].sort_values("Skor", ascending=False)
+ elif mode == SCAN_MODES[2]:
+ out = out[out["Skor"] <= -SIGNAL_THRESHOLD].sort_values("Skor", ascending=True)
+ elif mode == SCAN_MODES[3]:
+ out = out[out["Kalite"].isin(["A", "A+"])].sort_values("Güven %", ascending=False)
+ else:
+ out = out.sort_values("Skor", ascending=False)
+ return out.reset_index(drop=True)
+
+
+# ---------------------------------------------------------------------------
+# STYLE — dark "trading terminal" identity (deliberate, not default SaaS chrome)
+# ---------------------------------------------------------------------------
+HEAD = """
+Bu panel yalnızca eğitim ve bilgilendirme amaçlıdır; yatırım tavsiyesi '
+ 'değildir. Tüm veriler OKX genel (public) piyasa API\'sinden alınır; hiçbir API anahtarı '
+ 'kullanılmaz ve hiçbir gerçek emir gönderilmez. Kripto varlıklar yüksek oynaklık içerir; geçmiş '
+ 'performans (backtest dahil) gelecekteki sonuçların göstergesi değildir. Backtest sonuçları '
+ 'kısa örneklem üzerindedir ve istatistiksel olarak sınırlıdır.
'
+ )
+
+ io_inputs = [symbol_dd, bar_dd, depth_slider, closed_cb, acct_num, risk_sl]
+ io_outputs = [ov_html, ov_plot, sig_html, sig_map_plot, sig_factor_plot, sig_bt_plot, sig_ind_plot,
+ risk_html, risk_plot, ob_html, ob_plot]
+ sig_inputs = [symbol_dd, bar_dd, closed_cb, acct_num, risk_sl]
+ sig_outputs = [sig_html, sig_map_plot, sig_factor_plot, sig_bt_plot, sig_ind_plot]
+
+ refresh_btn.click(refresh_all, io_inputs, io_outputs)
+ timer.tick(refresh_all, io_inputs, io_outputs)
+ auto_cb.change(lambda active: gr.Timer(active=active), auto_cb, timer)
+ closed_cb.change(refresh_signal, sig_inputs, sig_outputs)
+ acct_num.submit(refresh_signal, sig_inputs, sig_outputs)
+ risk_sl.release(refresh_signal, sig_inputs, sig_outputs)
+ scan_btn.click(run_scanner, [scan_symbols, scan_bar, closed_cb, scan_mode], scan_out)
+ demo.load(refresh_all, io_inputs, io_outputs)
+
+demo.queue().launch(
+ theme=gr.themes.Base(primary_hue="blue", neutral_hue="slate"),
+ css=CSS,
+ head=HEAD,
+ ssr_mode=False,
+)