""" 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 """ 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) # --------------------------------------------------------------------------- # 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 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ı)""" c = df["c"].to_numpy() n = len(c) stats = {"all": [0, 0], "trend": [0, 0], "range": [0, 0]} for i in range(start, n - forward): s = scores[i - start] if abs(s["score"]) < threshold: 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 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 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"), } 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: s = scores[i - start]["score"] a = atr_a[i] if abs(s) < threshold or not (a > 0): 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 # --------------------------------------------------------------------------- # 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): mag = min(abs(score) / 8.0, 1.0) conf = 100.0 * (0.35 * mag + 0.25 * agree + 0.15 * mtf_state + 0.20 * hist_q + 0.05 * vol_q) parts = {"Skor Büyüklüğü": mag, "Faktör Uyumu": agree, "MTF Teyidi": mtf_state, "Tarihsel Kenar": hist_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") # --- 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" 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)) 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ü")) conf, conf_parts = compute_confidence(score, agree, mtf_state, hist_q, vol_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, } # --------------------------------------------------------------------------- # 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'