Upload app.py

app.py

@@ -2972,6 +2972,172 @@ def load_stat_arb(sym_a, sym_b, bar, n_bars, hw, zw, entry, exit_, stop):
         return error_box(f"Stat-Arb hesaplanamadı: {e}"), _empty_fig("Hata", "Stat-Arb")
 
 
+# ---------------------------------------------------------------------------
+# OTOMATİK STAT-ARB TARAYICI  (tüm likit coinler, tüm çiftler)
+#   API/CPU verimliliği:
+#     1) Her coin yalnızca 1 kez çekilir (N coin = N istek dizisi; N² çift için ayrı istek YOK).
+#     2) Sonraki taramalarda yalnızca eksik son mumlar çekilir (tek istek) ve önbelleğe eklenir.
+#     3) Çiftler hunisi: getiri korelasyonu (tek matris işlemi) → EG-ADF (iki yön) → half-life → OOS teyidi
+#        → yalnızca ilk SA_TOP_K çifte tam backtest.
+# ---------------------------------------------------------------------------
+SA_CACHE_TTL = 600            # sn — bu süre içinde yeniden tarama ağa hiç çıkmaz
+SA_TOP_K = 15                 # tam backtest yapılacak en iyi çift sayısı
+SA_OOS_CRIT = -2.86           # sabit β ile test edilen OOS spread için standart ADF %5 kritik değeri
+SA_EXCLUDE = {"USDC", "DAI", "TUSD", "FDUSD", "USDD", "PYUSD", "USDG", "EURT", "USDT"}   # stabil / sabitlenmiş
+_SA_STORE, _SA_LOCK = {}, threading.Lock()
+
+
+def _sa_clean(df):
+    if "confirm" in df.columns:                      # oluşmakta olan (kapanmamış) mumu at
+        df = df[df["confirm"].astype(str) == "1"]
+    return df[["ts", "c"]].drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
+
+
+def _sa_closes(sym, bar, n):
+    """Coin başına kapanışlar: ilk seferde sayfalayarak, sonra yalnızca eksik son mumlar (1 istek)."""
+    now = time.time()
+    with _SA_LOCK:
+        hit = _SA_STORE.get((sym, bar))
+    if hit and len(hit[1]) >= n * 0.95:
+        if now - hit[0] < SA_CACHE_TTL:
+            return hit[1].tail(n)
+        old = hit[1]
+        step = old["ts"].diff().median()
+        try:
+            new = _sa_clean(fetch_candles(sym, bar, 100))
+            if len(new) and new["ts"].min() <= old["ts"].iloc[-1] + step:      # boşluk yok → birleştir
+                df = (pd.concat([old, new]).drop_duplicates("ts", keep="last")
+                      .sort_values("ts").tail(n + 50).reset_index(drop=True))
+                with _SA_LOCK:
+                    _SA_STORE[(sym, bar)] = (now, df)
+                return df.tail(n)
+        except Exception:
+            pass
+    df = _sa_clean(fetch_candles_long(sym, bar, n))
+    with _SA_LOCK:
+        _SA_STORE[(sym, bar)] = (now, df)
+    return df.tail(n)
+
+
+def _sa_universe(top_n):
+    """OKX spot'ta 24s USDT hacmine göre en likit top_n coin (stabiller hariç)."""
+    try:
+        tk = fetch_all_tickers("SPOT")
+    except Exception:
+        return list(SCAN_DEFAULT)[:top_n]
+    rows = []
+    for t in tk:
+        sid = t.get("instId", "")
+        if not sid.endswith("-USDT") or sid.split("-")[0] in SA_EXCLUDE:
+            continue
+        try:
+            rows.append((float(t.get("volCcy24h") or 0), sid))
+        except (TypeError, ValueError):
+            continue
+    rows.sort(reverse=True)
+    return [s for _, s in rows[:top_n]]
+
+
+def sa_find_pairs(px, min_corr=0.5, max_hl=48, crit=-3.34, hl_min=1.5):
+    """px: kapanış DataFrame'i (sütun = sembol). Hunide elenen çiftlerin EG/OOS özetlerini döndürür (sıralı)."""
+    L = np.log(px.values.astype(float))
+    T, N = L.shape
+    syms = list(px.columns)
+    C = np.corrcoef(np.diff(L, axis=0).T)
+    iu, ju = np.triu_indices(N, 1)
+    cv = C[iu, ju]
+    keep = np.where(cv >= min_corr)[0]
+    keep = keep[np.argsort(-cv[keep])][:3000]
+    h = T // 2
+    found = []
+    for k in keep:
+        i, j = int(iu[k]), int(ju[k])
+        best = None
+        for yi, xi in ((i, j), (j, i)):               # EG asimetriktir: iki yönü dene, güçlü olanı al
+            y, x = L[:, yi], L[:, xi]
+            b, a = np.polyfit(x, y, 1)
+            t, g = _adf_tstat(y - a - b * x)
+            if best is None or t < best[0]:
+                best = (t, g, b, a, yi, xi)
+        t, g, b, a, yi, xi = best
+        if t > crit or not (-1 < g < 0):
+            continue
+        hl = -math.log(2) / math.log(1 + g)
+        if not (hl_min <= hl <= max_hl):
+            continue
+        y, x = L[:, yi], L[:, xi]
+        b1, a1 = np.polyfit(x[:h], y[:h], 1)           # 1. yarıda β → 2. yarıda spread kalıcılığı (OOS)
+        t_oos, _ = _adf_tstat(y[h:] - a1 - b1 * x[h:])
+        b2 = np.polyfit(x[h:], y[h:], 1)[0]
+        found.append(dict(yi=yi, xi=xi, t=float(t), t_oos=float(t_oos), hl=float(hl), corr=float(cv[k]),
+                          beta=float(b), drift=float(abs(b2 - b1) / abs(b1)) if b1 else float("nan")))
+    found.sort(key=lambda d: (d["t_oos"] > SA_OOS_CRIT, d["t"]))      # önce OOS'u geçenler, sonra en negatif t
+    return found, syms, len(keep)
+
+
+def run_sa_scan(bar, n_bars, top_n, min_corr, max_hl, crit, entry, progress=gr.Progress()):
+    try:
+        n_bars, top_n = int(n_bars), int(top_n)
+        syms = _sa_universe(top_n)
+        closes, done = {}, 0
+        with ThreadPoolExecutor(max_workers=4) as ex:   # OKX limiti için 4 paralel
+            futs = {ex.submit(_sa_closes, s, bar, n_bars): s for s in syms}
+            for f in as_completed(futs):
+                done += 1
+                progress(0.85 * done / len(syms), desc=f"{futs[f]} ({done}/{len(syms)})")
+                try:
+                    d = f.result()
+                    if len(d) >= n_bars * 0.9:
+                        closes[futs[f]] = d.set_index("ts")["c"]
+                except Exception:
+                    continue
+        if len(closes) < 3:
+            return pd.DataFrame(), error_box("Yeterli coin verisi alınamadı (ağ / rate-limit). Biraz sonra tekrar deneyin.")
+        px = pd.concat(closes, axis=1).sort_index().tail(n_bars)
+        px = px.dropna(axis=1, thresh=int(len(px) * 0.9)).dropna(how="any")     # kısa geçmişli coinleri ele, ortak barlar
+        if len(px) < 250 or px.shape[1] < 3:
+            return pd.DataFrame(), error_box(f"Ortak veri yetersiz ({len(px)} bar, {px.shape[1]} coin). Bar sayısını artırın.")
+        progress(0.9, desc="Çiftler test ediliyor…")
+        found, cols, n_tested = sa_find_pairs(px, float(min_corr), float(max_hl), float(crit))
+        rows = []
+        for d in found[:SA_TOP_K]:
+            sa_, sb_ = cols[d["yi"]], cols[d["xi"]]
+            bt = pairs_backtest(px[sa_], px[sb_], 150, 48, float(entry), 0.5, 3.5)
+            zc, pc = float(bt["z"].iloc[-1]), int(bt["pos"].iloc[-1])
+            sig = ("LONG spread (A al / B sat)" if pc == 1 else "SHORT spread (A sat / B al)" if pc == -1 else
+                   "Giriş bölgesinde" if abs(zc) >= float(entry) else "Bekle")
+            rows.append({"A": sa_, "B": sb_, "EG t": round(d["t"], 2), "OOS t": round(d["t_oos"], 2),
+                         "OOS": "✓" if d["t_oos"] <= SA_OOS_CRIT else "✗",
+                         "Half-life (bar)": round(d["hl"], 1), "Korelasyon": round(d["corr"], 2),
+                         "β": round(d["beta"], 2), "β kayması %": round(d["drift"] * 100, 0),
+                         "Z": round(zc, 2), "Durum": sig, "İşlem": len(bt["trades"]),
+                         "Net getiri %": round(float(bt["eq"].iloc[-1] - 1) * 100, 2)})
+        n_oos = sum(1 for d in found if d["t_oos"] <= SA_OOS_CRIT)
+        exp_fp = 0.05 * n_tested
+        info = (section(f"OTOMATİK STAT-ARB TARAMA · {bar} · {px.shape[1]} coin · {len(px)} bar")
+                + f'<div class="mc-sub">{n_tested} çift korelasyon süzgecini geçti ve test edildi → {len(found)} çift EG/half-life eşiğini geçti, '
+                  f'{n_oos} tanesi OOS teyidini de geçti. <b>Çoklu test uyarısı:</b> %5 eşikte ~{exp_fp:.0f} yanlış pozitif beklenir; '
+                  f'“OOS ✓” ve makul half-life olmayanlara güvenmeyin. İlk {SA_TOP_K} çift gösteriliyor. '
+                  'Satıra tıklayınca A/B seçilir ve aşağıda tam analiz + backtest açılır.</div>')
+        if not rows:
+            return pd.DataFrame(), info + error_box("Kriterleri geçen çift yok. Bu normaldir; eşikleri gevşetmek sahte sinyal sayısını artırır.")
+        return pd.DataFrame(rows), info
+    except Exception as e:
+        return pd.DataFrame(), error_box(f"Tarama hatası: {e}")
+
+
+def sa_pick_pair(df, bar, evt: gr.SelectData):
+    """Taramada satıra tıklanınca A/B/zaman dilimini manuel analiz alanlarına yazar."""
+    try:
+        rv = getattr(evt, "row_value", None)
+        if rv:
+            return rv[0], rv[1], bar
+        r = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+        return df.iloc[r]["A"], df.iloc[r]["B"], bar
+    except Exception:
+        return gr.update(), gr.update(), gr.update()
+
+
 def tv_symbol(symbol):
     """OKX 'BTC-USDT' -> TradingView 'OKX:BTCUSDT'."""
     return "OKX:" + str(symbol or "BTC-USDT").replace("-", "").upper()
@@ -3046,6 +3212,23 @@ with gr.Blocks(title="OKX Quant Terminal") as demo:
             tv_html = gr.HTML()
         with gr.Tab("⚖️ İstatistiksel Arbitraj"):
             gr.Markdown("İki varlık arasında eşbütünleşme / spread z-skor tabanlı pairs trading + komisyonlu backtest.")
+            gr.Markdown("**🔎 Otomatik tarama:** OKX spot'ta hacme göre en likit coinlerin TÜM çiftlerini eşbütünleşme huni testinden geçirir "
+                        "(her coin 1 kez çekilir, tekrar taramada yalnızca yeni mumlar). Satıra tıkla → analiz otomatik açılır.")
+            with gr.Row():
+                sas_bar = gr.Dropdown(choices=BAR_OPTIONS, value="1H", label="Zaman Dilimi", scale=1)
+                sas_n = gr.Slider(300, 2000, value=600, step=100, label="Bar sayısı", scale=1)
+                sas_top = gr.Slider(10, 150, value=60, step=5, label="Coin sayısı (hacme göre)", scale=1)
+            with gr.Row():
+                sas_corr = gr.Slider(0.3, 0.95, value=0.5, step=0.05, label="Min getiri korelasyonu", scale=1)
+                sas_hl = gr.Slider(5, 200, value=48, step=1, label="Maks half-life (bar)", scale=1)
+                sas_crit = gr.Slider(-4.5, -2.9, value=-3.34, step=0.02, label="EG eşiği (t)", scale=1)
+            with gr.Row():
+                sas_btn = gr.Button("🔎 Tüm Coinleri Tara", variant="primary", scale=2)
+                sas_auto = gr.Checkbox(label="Otomatik tara (15 dk)", value=False, scale=1)
+            sas_timer = gr.Timer(900, active=False)
+            sas_html = gr.HTML()
+            sas_out = gr.Dataframe(interactive=False, wrap=True)
+            gr.Markdown("---\n**Manuel çift analizi**")
             with gr.Row():
                 sa_a = gr.Dropdown(choices=POPULAR_SYMBOLS, value="BTC-USDT", allow_custom_value=True, label="Varlık A", scale=2)
                 sa_b = gr.Dropdown(choices=POPULAR_SYMBOLS, value="ETH-USDT", allow_custom_value=True, label="Varlık B", scale=2)
@@ -3091,6 +3274,12 @@ with gr.Blocks(title="OKX Quant Terminal") as demo:
     risk_sl.release(refresh_signal, sig_inputs, sig_outputs)
     scan_btn.click(run_scanner, [scan_symbols, scan_bar, closed_cb, scan_mode], scan_out)
     sa_btn.click(load_stat_arb, [sa_a, sa_b, sa_bar, sa_n, sa_hw, sa_zw, sa_en, sa_ex, sa_st], [sa_html, sa_plot])
+    sas_in = [sas_bar, sas_n, sas_top, sas_corr, sas_hl, sas_crit, sa_en]
+    sas_btn.click(run_sa_scan, sas_in, [sas_out, sas_html])
+    sas_timer.tick(run_sa_scan, sas_in, [sas_out, sas_html])
+    sas_auto.change(lambda active: gr.Timer(active=active), sas_auto, sas_timer)
+    sas_out.select(sa_pick_pair, [sas_out, sas_bar], [sa_a, sa_b, sa_bar]).then(
+        load_stat_arb, [sa_a, sa_b, sa_bar, sa_n, sa_hw, sa_zw, sa_en, sa_ex, sa_st], [sa_html, sa_plot])
     demo.load(refresh_all, io_inputs, io_outputs)
     # TradingView sekmesi yalnızca sembol / zaman dilimi değişince yenilenir (15 sn'lik otomatik yenilemede iframe sıfırlanmasın)
     symbol_dd.change(tv_widget_html, [symbol_dd, bar_dd], tv_html)