Update app.py

app.py

@@ -1,1218 +1,847 @@
-"""
-OKX Value Intelligence v1 — Compact Fair-Value & Risk Platform (OKX Spot, USDT pairs)
-======================================================================================
-Data integrity > model complexity. Fair value > momentum. Margin of safety > prediction.
-
-Veri kaynağı: OKX public REST API (anahtar gerekmez) — spot ticker, günlük mumlar, perp funding / open interest.
-Veri etiketleri:  [R] OKX'ten alınan   [D] türetilen   [A] kullanıcı varsayımı
-UYARI: Kripto varlıkların bilançosu/nakit akışı yoktur. "Fair value" fiyat-hacim verisinden türetilen
-istatistiksel referanstır (içsel değer değildir). Backtest/yatırım tavsiyesi değildir.
-"""
-
-import logging
-import math
-import tempfile
+# app.py
+# GOSHAWK ALBION MARKET AI
+# Tek dosyalık, çalıştırılabilir Market Intelligence uygulaması.
+# Gerekli paketler: gradio, lightgbm, pandas, numpy, plotly, requests, scikit-learn
+
+import os
 import time
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional, Tuple
+import warnings
+import datetime as dt
+from typing import List, Dict, Tuple, Optional
 
-import gradio as gr
 import numpy as np
 import pandas as pd
-import plotly.graph_objects as go
 import requests
+import plotly.graph_objects as go
+import plotly.express as px
+
+import lightgbm as lgb
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+import gradio as gr
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-logger = logging.getLogger("okx_v1")
-
-# ============================================================================
-# CONFIG & UNIVERSE
-# ============================================================================
-
-OKX_BASE = "https://www.okx.com"
-REQUEST_DELAY_SEC = 0.12          # OKX public limit: 20 req / 2 s per endpoint
-CACHE_TTL_HOURS = 1
-LOOKBACK_DAYS = 500               # günlük mum derinliği (300 + 2x100 sayfa)
-MIN_PEERS = 5
-DEFAULT_UNIVERSE_N = 100
-MIN_VOL_USDT = 1_000_000          # 24s hacim alt sınırı (evren filtresi)
-
-STABLES = {"USDC", "DAI", "TUSD", "FDUSD", "USDE", "PYUSD", "USDG", "USDD", "EURC", "BUSD", "USTC", "USDP", "EURT", "XAUT"}
-
-# Kategori (segment) haritası — listede olmayan varlıklar "Other"
-CATEGORY_MAP = {
-    "Majors": ["BTC", "ETH", "SOL", "XRP", "BNB", "ADA", "TRX", "LTC", "BCH", "AVAX", "DOT", "TON"],
-    "Alt L1": ["ATOM", "NEAR", "APT", "SUI", "SEI", "ALGO", "ICP", "FIL", "HBAR", "XLM", "ETC", "EOS", "XTZ", "VET",
-               "THETA", "TIA", "KAS", "MINA", "FLOW", "S", "FTM", "KAVA", "CFX", "EGLD"],
-    "DeFi": ["UNI", "AAVE", "MKR", "LDO", "CRV", "SNX", "COMP", "DYDX", "INJ", "JUP", "ENA", "ONDO", "PENDLE", "1INCH",
-             "SUSHI", "CAKE", "RUNE", "GMX", "ETHFI", "EIGEN"],
-    "Infra/L2": ["ARB", "OP", "POL", "MATIC", "LINK", "GRT", "STX", "IMX", "STRK", "ZK", "MNT", "PYTH", "API3", "W", "BLUR", "ZRO"],
-    "Meme": ["DOGE", "SHIB", "PEPE", "WIF", "BONK", "FLOKI", "TRUMP", "PNUT", "MEME", "TURBO", "NEIRO", "BOME", "MEW", "ORDI"],
-    "AI/Gaming": ["FET", "RENDER", "RNDR", "WLD", "TAO", "AGIX", "OCEAN", "AR", "SAND", "MANA", "AXS", "GALA", "APE", "ENS", "AIXBT", "VIRTUAL"],
-}
-CATEGORY = {b: cat for cat, bases in CATEGORY_MAP.items() for b in bases}
-SEGMENTS = list(CATEGORY_MAP.keys()) + ["Other"]
-
-FALLBACK_BASES = ["BTC", "ETH", "SOL", "XRP", "DOGE", "ADA", "AVAX", "LINK", "DOT", "LTC", "BCH", "TRX", "UNI", "ATOM",
-                  "NEAR", "APT", "ARB", "OP", "SUI", "FIL", "ICP", "ETC", "XLM", "HBAR", "AAVE", "MKR", "LDO", "INJ",
-                  "SHIB", "PEPE", "WIF", "BONK", "FET", "RENDER", "GRT", "IMX", "SAND", "MANA", "TIA", "SEI"]
-
-_cache: Dict[str, Tuple[datetime, Any]] = {}
-_TICK: Dict[str, Any] = {"ts": 0.0, "data": {}}
-SETTINGS: Dict[str, Any] = {"perp": True}
-LAST: Dict[str, Any] = {"df": None, "failed": [], "universe": []}
-_session = requests.Session()
-_session.headers.update({"User-Agent": "okx-value-intelligence/1.0"})
-
-
-def _cget(k):
-    if k in _cache:
-        ts, v = _cache[k]
-        if datetime.now() - ts < timedelta(hours=CACHE_TTL_HOURS):
-            return v
+warnings.filterwarnings("ignore")
+
+# ---------------------------------------------------------------------------
+# SABİTLER
+# ---------------------------------------------------------------------------
+
+API_BASE = "https://europe.albion-online-data.com/api/v2"
+
+CITIES = [
+    "Bridgewatch",
+    "Fort Sterling",
+    "Lymhurst",
+    "Martlock",
+    "Thetford",
+    "Caerleon",
+]
+
+# 100 popüler ürün (T4-T6 kaynaklar, ekipmanlar, tüketim malları)
+_ITEM_POOL = [
+    "T4_BAG", "T5_BAG", "T6_BAG", "T7_BAG", "T8_BAG",
+    "T4_CAPE", "T5_CAPE", "T6_CAPE", "T7_CAPE", "T8_CAPE",
+    "T4_ARMOR_PLATE_SET1", "T5_ARMOR_PLATE_SET1", "T6_ARMOR_PLATE_SET1",
+    "T4_ARMOR_LEATHER_SET1", "T5_ARMOR_LEATHER_SET1", "T6_ARMOR_LEATHER_SET1",
+    "T4_ARMOR_CLOTH_SET1", "T5_ARMOR_CLOTH_SET1", "T6_ARMOR_CLOTH_SET1",
+    "T4_HEAD_PLATE_SET1", "T5_HEAD_PLATE_SET1", "T6_HEAD_PLATE_SET1",
+    "T4_HEAD_LEATHER_SET1", "T5_HEAD_LEATHER_SET1", "T6_HEAD_LEATHER_SET1",
+    "T4_HEAD_CLOTH_SET1", "T5_HEAD_CLOTH_SET1", "T6_HEAD_CLOTH_SET1",
+    "T4_SHOES_PLATE_SET1", "T5_SHOES_PLATE_SET1", "T6_SHOES_PLATE_SET1",
+    "T4_SHOES_LEATHER_SET1", "T5_SHOES_LEATHER_SET1", "T6_SHOES_LEATHER_SET1",
+    "T4_SHOES_CLOTH_SET1", "T5_SHOES_CLOTH_SET1", "T6_SHOES_CLOTH_SET1",
+    "T4_MAIN_SWORD", "T5_MAIN_SWORD", "T6_MAIN_SWORD",
+    "T4_MAIN_AXE", "T5_MAIN_AXE", "T6_MAIN_AXE",
+    "T4_MAIN_BOW", "T5_MAIN_BOW", "T6_MAIN_BOW",
+    "T4_MAIN_CROSSBOW", "T5_MAIN_CROSSBOW", "T6_MAIN_CROSSBOW",
+    "T4_MAIN_FIRE", "T5_MAIN_FIRE", "T6_MAIN_FIRE",
+    "T4_MAIN_FROST", "T5_MAIN_FROST", "T6_MAIN_FROST",
+    "T4_MAIN_HOLY", "T5_MAIN_HOLY", "T6_MAIN_HOLY",
+    "T4_MAIN_NATURE", "T5_MAIN_NATURE", "T6_MAIN_NATURE",
+    "T4_MAIN_CURSED", "T5_MAIN_CURSED", "T6_MAIN_CURSED",
+    "T4_MAIN_HAMMER", "T5_MAIN_HAMMER", "T6_MAIN_HAMMER",
+    "T4_MAIN_SPEAR", "T5_MAIN_SPEAR", "T6_MAIN_SPEAR",
+    "T4_MAIN_MACE", "T5_MAIN_MACE", "T6_MAIN_MACE",
+    "T4_OFF_SHIELD", "T5_OFF_SHIELD", "T6_OFF_SHIELD",
+    "T4_OFF_TORCH", "T5_OFF_TORCH", "T6_OFF_TORCH",
+    "T4_OFF_BOOK", "T5_OFF_BOOK", "T6_OFF_BOOK",
+    "T4_2H_STAFF", "T5_2H_STAFF", "T6_2H_STAFF",
+    "T4_2H_BOW", "T5_2H_BOW", "T6_2H_BOW",
+    "T4_2H_CROSSBOW", "T5_2H_CROSSBOW", "T6_2H_CROSSBOW",
+    "T4_2H_FIRE", "T5_2H_FIRE", "T6_2H_FIRE",
+    "T4_2H_FROST", "T5_2H_FROST", "T6_2H_FROST",
+    "T4_2H_HOLY", "T5_2H_HOLY", "T6_2H_HOLY",
+    "T4_2H_NATURE", "T5_2H_NATURE", "T6_2H_NATURE",
+    "T4_2H_CURSED", "T5_2H_CURSED", "T6_2H_CURSED",
+    "T4_2H_HAMMER", "T5_2H_HAMMER", "T6_2H_HAMMER",
+    "T4_2H_SPEAR", "T5_2H_SPEAR", "T6_2H_SPEAR",
+    "T4_2H_MACE", "T5_2H_MACE", "T6_2H_MACE",
+]
+ITEM_IDS = list(dict.fromkeys(_ITEM_POOL))[:100]
+
+def item_display_name(item_id: str) -> str:
+    return item_id.replace("_", " ").title()
+
+SETUP_FEE_RATE = 0.025          # %2.5 listeleme ücreti
+TRANSACTION_TAX_RATE = 0.08     # %8 satış vergisi (Premium olmayan varsayılan)
+
+DATA_DIR = "gos_hawk_data"
+os.makedirs(DATA_DIR, exist_ok=True)
+
+MODEL_DIR = os.path.join(DATA_DIR, "models")
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+PURGE_HOURS = 24
+EMBARGO_HOURS = 24
+MIN_TRAIN_SAMPLES = 500
+
+REQUEST_TIMEOUT = 30
+MAX_RETRIES = 3
+RETRY_BACKOFF = 2
+
+# ---------------------------------------------------------------------------
+# YARDIMCI FONKSİYONLAR
+# ---------------------------------------------------------------------------
+
+def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
+    for attempt in range(MAX_RETRIES):
+        try:
+            resp = requests.get(url, params=params, timeout=REQUEST_TIMEOUT)
+            if resp.status_code == 200:
+                return resp.json()
+            elif resp.status_code == 429:
+                time.sleep(RETRY_BACKOFF * (attempt + 1))
+                continue
+            else:
+                print(f"API hatası: {resp.status_code} - {url}")
+                return None
+        except requests.exceptions.Timeout:
+            print(f"Zaman aşımı (deneme {attempt+1}/{MAX_RETRIES}): {url}")
+        except requests.exceptions.RequestException as e:
+            print(f"İstek hatası (deneme {attempt+1}/{MAX_RETRIES}): {e}")
+        time.sleep(RETRY_BACKOFF * (attempt + 1))
     return None
 
 
-def _cset(k, v):
-    _cache[k] = (datetime.now(), v)
+def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1") -> pd.DataFrame:
+    all_data = []
+    chunk_size = 50
+    for i in range(0, len(item_ids), chunk_size):
+        chunk = item_ids[i:i+chunk_size]
+        items_str = ",".join(chunk)
+        locations_str = ",".join(cities)
+        url = f"{API_BASE}/stats/prices/{items_str}.json"
+        params = {"locations": locations_str, "qualities": qualities}
+        data = safe_request(url, params)
+        if data:
+            all_data.extend(data)
+        time.sleep(0.2)
+    if not all_data:
+        return pd.DataFrame()
+    df = pd.DataFrame(all_data)
+    for col in ["sell_price_min_date", "sell_price_max_date", "buy_price_min_date", "buy_price_max_date"]:
+        if col in df.columns:
+            df[col] = pd.to_datetime(df[col], errors="coerce")
+    return df
+
+
+def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 24, qualities: str = "1") -> pd.DataFrame:
+    all_records = []
+    chunk_size = 30
+    for i in range(0, len(item_ids), chunk_size):
+        chunk = item_ids[i:i+chunk_size]
+        items_str = ",".join(chunk)
+        locations_str = ",".join(cities)
+        url = f"{API_BASE}/stats/history/{items_str}.json"
+        params = {"locations": locations_str, "qualities": qualities, "time-scale": time_scale}
+        data = safe_request(url, params)
+        if data:
+            for entry in data:
+                item_id = entry.get("item_id")
+                loc = entry.get("location")
+                quality = entry.get("quality", 1)
+                for point in entry.get("data", []):
+                    all_records.append({
+                        "item_id": item_id,
+                        "city": loc,
+                        "quality": quality,
+                        "timestamp": point.get("timestamp"),
+                        "avg_price": point.get("avg_price"),
+                        "item_count": point.get("item_count", 0),
+                    })
+        time.sleep(0.3)
+    if not all_records:
+        return pd.DataFrame()
+    df = pd.DataFrame(all_records)
+    df["timestamp"] = pd.to_datetime(df["timestamp"], errors="coerce")
+    df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce")
+    df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0)
+    return df
+
+
+def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return df
+    df = df[df["avg_price"] > 0].copy()
+    if "item_id" in df.columns:
+        for item in df["item_id"].unique():
+            mask = df["item_id"] == item
+            if mask.sum() < 10:
+                continue
+            lower = df.loc[mask, "avg_price"].quantile(0.005)
+            upper = df.loc[mask, "avg_price"].quantile(0.995)
+            df.loc[mask, "avg_price"] = df.loc[mask, "avg_price"].clip(lower, upper)
+    df = df.sort_values(["item_id", "city", "timestamp"]).reset_index(drop=True)
+    return df
 
 
-# ============================================================================
-# SMALL HELPERS
-# ============================================================================
+def save_to_csv(df: pd.DataFrame, name: str) -> str:
+    if df.empty:
+        return ""
+    path = os.path.join(DATA_DIR, f"{name}_{dt.datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")
+    df.to_csv(path, index=False)
+    return path
 
-def num(x) -> Optional[float]:
-    try:
-        if x is None or x == "":
-            return None
-        v = float(x)
-        return None if (np.isnan(v) or np.isinf(v)) else v
-    except Exception:
-        return None
 
+# ---------------------------------------------------------------------------
+# FEATURE ENGINEERING
+# ---------------------------------------------------------------------------
 
-def div(a, b) -> Optional[float]:
-    a, b = num(a), num(b)
-    if a is None or b is None or b == 0:
-        return None
-    return a / b
+def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
+    delta = series.diff()
+    gain = delta.clip(lower=0).rolling(period).mean()
+    loss = (-delta.clip(upper=0)).rolling(period).mean()
+    rs = gain / loss.replace(0, np.nan)
+    rsi = 100 - (100 / (1 + rs))
+    return rsi.fillna(50)
 
 
-def real_ret(nominal, infl) -> Optional[float]:
-    return None if nominal is None else (1 + nominal) / (1 + infl) - 1
+def build_features(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return df
 
+    df = df.sort_values(["item_id", "city", "timestamp"]).copy()
 
-def lin(x, bad, good) -> Optional[float]:
-    """Linear 0-100 scale; works for bad>good as well."""
-    if x is None:
-        return None
-    return float(np.clip((x - bad) / (good - bad), 0, 1) * 100)
+    df["hour"] = df["timestamp"].dt.hour
+    df["dayofweek"] = df["timestamp"].dt.dayofweek
+    df["is_weekend"] = (df["dayofweek"] >= 5).astype(int)
 
+    group_cols = ["item_id", "city"]
 
-def wavg(items) -> Tuple[Optional[float], float]:
-    v = [(s, w) for s, w in items if s is not None]
-    tw = sum(w for _, w in items)
-    if not v or tw == 0:
-        return None, 0.0
-    sw = sum(w for _, w in v)
-    return sum(s * w for s, w in v) / sw, sw / tw
+    for lag in [1, 3, 6, 12, 24, 48]:
+        df[f"lag_{lag}h"] = df.groupby(group_cols)["avg_price"].shift(lag)
 
+    df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
+    for chg in [1, 6, 12, 24]:
+        df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
 
-def anyc(*c) -> Optional[bool]:
-    v = [x for x in c if x is not None]
-    return None if not v else any(v)
+    for window in [6, 12, 24, 48]:
+        df[f"ma_{window}h"] = df.groupby(group_cols)["avg_price"].transform(
+            lambda x: x.rolling(window, min_periods=window).mean()
+        )
 
+    df["rsi_14"] = df.groupby(group_cols)["avg_price"].transform(lambda x: compute_rsi(x, 14))
 
-def fm(x, d=2):
-    return "N/A" if x is None else f"{x:,.{d}f}"
+    df["volatility_24h"] = df.groupby(group_cols)["log_price"].transform(
+        lambda x: x.rolling(24, min_periods=12).std()
+    )
 
+    df["volume_ma_24h"] = df.groupby(group_cols)["item_count"].transform(
+        lambda x: x.rolling(24, min_periods=12).mean()
+    )
+    df["volume_ratio"] = df["item_count"] / df["volume_ma_24h"].replace(0, np.nan)
 
-def fpx(x):
-    """Fiyat biçimi: BTC (100k) ile PEPE (0.00001) aynı yerde okunabilsin."""
-    if x is None:
-        return "N/A"
-    a = abs(x)
-    if a >= 1000:
-        return f"{x:,.0f}"
-    if a >= 1:
-        return f"{x:,.2f}"
-    if a >= 0.01:
-        return f"{x:.4f}"
-    return f"{x:.4g}"
+    city_avg = df.groupby(["item_id", "timestamp"])["avg_price"].transform("mean")
+    df["city_price_deviation"] = (df["avg_price"] - city_avg) / city_avg.replace(0, np.nan)
 
+    df["target_return_24h"] = df.groupby(group_cols)["log_price"].shift(-24)
 
-def rsig(x, n=5):
-    return None if x is None else float(f"{x:.{n}g}")
+    return df
 
 
-def fp(x, d=1):
-    return "N/A" if x is None else f"{x * 100:.{d}f}%"
+# ---------------------------------------------------------------------------
+# MODEL EĞİTİMİ
+# ---------------------------------------------------------------------------
 
+FEATURE_COLS = [
+    "hour", "dayofweek", "is_weekend",
+    "lag_1h", "lag_3h", "lag_6h", "lag_12h", "lag_24h", "lag_48h",
+    "chg_1h", "chg_6h", "chg_12h", "chg_24h",
+    "ma_6h", "ma_12h", "ma_24h", "ma_48h",
+    "rsi_14", "volatility_24h",
+    "volume_ma_24h", "volume_ratio",
+    "city_price_deviation",
+    "item_code", "city_code",
+]
 
-def pct(x, d=1):
-    return None if x is None else round(x * 100, d)
 
+def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series, pd.DataFrame]:
+    if featured_df.empty:
+        return pd.DataFrame(), pd.Series(dtype=float), pd.DataFrame()
 
-def norm_sym(t: str) -> str:
-    """'btc', 'eth/usdt', 'SOLUSDT', 'BTC-USDT-SWAP' -> OKX spot instId (BTC-USDT)."""
-    s = (t or "").strip().upper().replace("/", "-").replace("_", "-").replace(" ", "")
-    if not s:
-        return ""
-    if s.endswith("-SWAP"):
-        s = s[:-5]
-    if "-" in s:
-        parts = s.split("-")
-        return f"{parts[0]}-{parts[1]}" if len(parts) >= 2 and parts[1] else f"{parts[0]}-USDT"
-    for q in ("USDT", "USDC"):
-        if s.endswith(q) and len(s) > len(q):
-            return f"{s[:-len(q)]}-{q}"
-    return f"{s}-USDT"
-
-
-def mk_params(infl, rw, rtg, rg, pt, cv) -> Dict[str, float]:
-    return dict(infl=infl / 100, rw=rw / 100, rtg=rtg / 100, rg=rg / 100, pt=pt / 100, conv=cv / 100)
-
-
-def tier_of(v: Optional[float]) -> str:
-    if v is None:
-        return "Tier-4 (<5M)"
-    if v >= 100e6:
-        return "Tier-1 (≥100M)"
-    if v >= 20e6:
-        return "Tier-2 (20-100M)"
-    if v >= 5e6:
-        return "Tier-3 (5-20M)"
-    return "Tier-4 (<5M)"
-
-
-# ============================================================================
-# OKX DATA ACQUISITION
-# ============================================================================
-
-def okx_get(path: str, params: Optional[Dict[str, str]] = None, retries: int = 3) -> Optional[List[Any]]:
-    """OKX v5 public GET. Returns list (maybe empty) on success, None on failure."""
-    url = OKX_BASE + path
-    for k in range(retries):
-        try:
-            r = _session.get(url, params=params, timeout=15)
-            if r.status_code == 429:
-                time.sleep(1.0 * (k + 1))
-                continue
-            r.raise_for_status()
-            j = r.json()
-            code = str(j.get("code"))
-            if code == "0":
-                return j.get("data") or []
-            if code == "50011":  # rate limit
-                time.sleep(1.0 * (k + 1))
-                continue
-            logger.debug("OKX %s %s -> code %s %s", path, params, code, j.get("msg"))
-            return None
-        except Exception as e:
-            logger.warning("OKX %s failed (%s/%s): %s", path, k + 1, retries, e)
-            time.sleep(0.5 * (k + 1))
-    return None
+    df = featured_df.copy()
+    df["item_code"] = df["item_id"].astype("category").cat.codes
+    df["city_code"] = df["city"].astype("category").cat.codes
 
+    model_df = df.dropna(subset=FEATURE_COLS + ["target_return_24h"]).copy()
 
-def get_tickers(force: bool = False) -> Dict[str, Dict[str, Any]]:
-    if not force and _TICK["data"] and time.time() - _TICK["ts"] < 120:
-        return _TICK["data"]
-    rows = okx_get("/api/v5/market/tickers", {"instType": "SPOT"})
-    if rows:
-        _TICK["data"] = {r["instId"]: r for r in rows if r.get("instId")}
-        _TICK["ts"] = time.time()
-    return _TICK["data"]
+    if len(model_df) > 100:
+        lower = model_df["target_return_24h"].quantile(0.001)
+        upper = model_df["target_return_24h"].quantile(0.999)
+        model_df["target_return_24h"] = model_df["target_return_24h"].clip(lower, upper)
 
+    X = model_df[FEATURE_COLS]
+    y = model_df["target_return_24h"]
+    meta = model_df[["item_id", "city", "timestamp", "avg_price", "target_return_24h"]].copy()
 
-def is_excluded(base: str) -> bool:
-    return base in STABLES or base.endswith(("3L", "3S", "5L", "5S"))
+    return X, y, meta
 
 
-def build_universe(n: int = DEFAULT_UNIVERSE_N) -> Tuple[List[str], str]:
-    """Top-N OKX spot USDT pairs by 24h quote volume (stablecoin / leveraged tokens excluded)."""
-    tk = get_tickers(force=True)
-    rows = []
-    for inst, r in tk.items():
-        if not inst.endswith("-USDT"):
-            continue
-        if is_excluded(inst[:-5]):
+def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMRegressor]:
+    if len(X) < MIN_TRAIN_SAMPLES:
+        print(f"Yetersiz veri: {len(X)} < {MIN_TRAIN_SAMPLES}")
+        return None
+
+    split_idx = int(len(X) * 0.8)
+    X_train, X_val = X.iloc[:split_idx], X.iloc[split_idx:]
+    y_train, y_val = y.iloc[:split_idx], y.iloc[split_idx:]
+
+    model = lgb.LGBMRegressor(
+        objective="regression",
+        metric="mae",
+        boosting_type="gbdt",
+        num_leaves=31,
+        learning_rate=0.05,
+        n_estimators=500,
+        feature_fraction=0.8,
+        bagging_fraction=0.8,
+        bagging_freq=5,
+        verbose=-1,
+        random_state=42,
+        n_jobs=-1,
+    )
+
+    callbacks = [
+        lgb.early_stopping(stopping_rounds=50, verbose=False),
+        lgb.log_evaluation(period=0),
+    ]
+
+    model.fit(
+        X_train, y_train,
+        eval_set=[(X_val, y_val)],
+        eval_metric="mae",
+        callbacks=callbacks,
+    )
+
+    return model
+
+
+def predict_24h_returns(model: lgb.LGBMRegressor, latest_features: pd.DataFrame) -> pd.DataFrame:
+    if latest_features.empty or model is None:
+        return pd.DataFrame()
+
+    missing = [c for c in FEATURE_COLS if c not in latest_features.columns]
+    if missing:
+        print(f"Eksik özellikler: {missing}")
+        return pd.DataFrame()
+
+    X_pred = latest_features[FEATURE_COLS].dropna()
+    if X_pred.empty:
+        return pd.DataFrame()
+
+    preds = model.predict(X_pred)
+    result = latest_features.loc[X_pred.index, ["item_id", "city", "avg_price", "item_count"]].copy()
+    result["predicted_log_return_24h"] = preds
+    result["predicted_return_pct"] = (np.exp(preds) - 1) * 100
+    result["predicted_price_24h"] = result["avg_price"] * np.exp(preds)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# WALK-FORWARD BACKTEST
+# ---------------------------------------------------------------------------
+
+def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
+    if featured_df.empty:
+        return {"error": "Veri yok."}
+
+    df = featured_df.sort_values("timestamp").copy()
+    unique_times = df["timestamp"].sort_values().unique()
+
+    if len(unique_times) < 100:
+        return {"error": "Backtest için yeterli zaman noktası yok."}
+
+    test_size = len(unique_times) // (n_splits + 1)
+    results = []
+    all_predictions = []
+
+    for i in range(n_splits):
+        test_start_idx = test_size * (i + 1) + PURGE_HOURS
+        test_end_idx = test_start_idx + test_size
+        if test_end_idx > len(unique_times):
+            break
+
+        train_end_idx = test_start_idx - EMBARGO_HOURS - PURGE_HOURS
+        if train_end_idx <= 0:
             continue
-        v = num(r.get("volCcy24h"))  # SPOT: quote currency (USDT) cinsinden 24s hacim
-        if v is None or v < MIN_VOL_USDT:
+
+        train_times = unique_times[:train_end_idx]
+        test_times = unique_times[test_start_idx:test_end_idx]
+
+        train_df = df[df["timestamp"].isin(train_times)]
+        test_df = df[df["timestamp"].isin(test_times)]
+
+        if len(train_df) < MIN_TRAIN_SAMPLES or len(test_df) < 50:
             continue
-        rows.append((v, inst))
-    rows.sort(reverse=True)
-    if rows:
-        return [i for _, i in rows[:n]], "OKX tickers (24s hacme göre)"
-    return [f"{b}-USDT" for b in FALLBACK_BASES][:n], "⚠️ ticker listesi alınamadı → gömülü yedek liste"
 
+        X_train, y_train, _ = prepare_model_data(train_df)
+        X_test, y_test, meta_test = prepare_model_data(test_df)
 
-def fetch_candles(inst: str, n: int = LOOKBACK_DAYS) -> Optional[pd.DataFrame]:
-    rows = okx_get("/api/v5/market/candles", {"instId": inst, "bar": "1D", "limit": "300"})
-    if not rows:
-        return None
-    allr = list(rows)
-    oldest = int(rows[-1][0])
-    while len(allr) < n:
-        time.sleep(REQUEST_DELAY_SEC)
-        more = okx_get("/api/v5/market/history-candles", {"instId": inst, "bar": "1D", "after": str(oldest), "limit": "100"})
-        if not more:
-            break
-        allr.extend(more)
-        new_oldest = int(more[-1][0])
-        if new_oldest >= oldest:
-            break
-        oldest = new_oldest
-        if len(more) < 100:
-            break
-    cols = ["ts", "open", "high", "low", "close", "vol", "volccy", "volq", "confirm"]
-    recs = []
-    for r in allr:
-        r = list(r) + [None] * (9 - len(r))
-        recs.append(r[:9])
-    df = pd.DataFrame(recs, columns=cols)
-    for c in cols:
-        df[c] = pd.to_numeric(df[c], errors="coerce")
-    df["confirm"] = df["confirm"].fillna(1)
-    df = df.dropna(subset=["ts", "close"]).drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
-    df = df[df["close"] > 0].reset_index(drop=True)
-    df["volq"] = df["volq"].where(df["volq"].notna(), df["close"] * df["vol"])
-    df["date"] = pd.to_datetime(df["ts"], unit="ms", utc=True)
-    return df.tail(n).reset_index(drop=True)
-
-
-def fetch_perp(inst: str) -> Tuple[Optional[float], Optional[float]]:
-    """Perp funding rate (8h) ve open interest (USD). Perp yoksa (None, None)."""
-    parts = inst.split("-")
-    swap = f"{parts[0]}-{parts[1]}-SWAP" if len(parts) >= 2 else None
-    if not swap:
-        return None, None
-    funding, oi_usd = None, None
-    fr = okx_get("/api/v5/public/funding-rate", {"instId": swap})
-    if fr:
-        funding = num(fr[0].get("fundingRate"))
-    if funding is not None:
-        time.sleep(REQUEST_DELAY_SEC)
-        oi = okx_get("/api/v5/public/open-interest", {"instType": "SWAP", "instId": swap})
-        if oi:
-            oi_usd = num(oi[0].get("oiUsd"))
-    return funding, oi_usd
-
-
-def _tail(a, k, min_frac=0.6):
-    return a[-k:] if len(a) > 0 and len(a) >= int(np.ceil(k * min_frac)) else None
-
-
-def metrics_from_candles(conf: pd.DataFrame, price: float, bid: Optional[float] = None, ask: Optional[float] = None) -> Dict[str, Any]:
-    """Pure function: confirmed daily candles + live price -> derived [D] metrics."""
-    c = conf["close"].to_numpy(float)
-    h = conf["high"].to_numpy(float)
-    vb = conf["vol"].to_numpy(float)
-    vq = conf["volq"].to_numpy(float)
-    n = len(c)
-    m: Dict[str, Any] = {"hist_days": n}
-    lr = np.diff(np.log(c)) if n >= 2 else np.array([])
-    rets = c[1:] / c[:-1] - 1 if n >= 2 else np.array([])
-
-    def ret_k(k):
-        return price / c[-k] - 1 if n >= k else None
-
-    m["ret30"], m["ret90"], m["ret365"] = ret_k(30), ret_k(90), ret_k(365)
-
-    def vol_k(k):
-        t = _tail(lr, k)
-        return float(np.std(t, ddof=1) * np.sqrt(365)) if t is not None and len(t) >= 15 else None
-
-    m["vol30"], m["vol90"], m["vol365"] = vol_k(30), vol_k(90), vol_k(365)
-    m["sharpe"] = m["sortino"] = None
-    t = _tail(lr, 365)
-    if t is not None and len(t) >= 100:
-        sd = float(np.std(t, ddof=1))
-        if sd > 1e-12:
-            m["sharpe"] = float(np.mean(t) / sd * np.sqrt(365))
-        dd = float(np.sqrt(np.mean(np.minimum(t, 0) ** 2)))
-        if dd > 1e-12:
-            m["sortino"] = float(np.mean(t) / dd * np.sqrt(365))
-    w = c[-365:]
-    m["maxdd"] = None
-    if len(w) >= 60:
-        cs = np.append(w, price)
-        m["maxdd"] = float(np.max(1 - cs / np.maximum.accumulate(cs)))
-    m["hi365"], m["dd_high"] = None, None
-    if n >= 30:
-        hi = float(max(np.nanmax(h[-365:]), price))
-        m["hi365"], m["dd_high"] = hi, 1 - price / hi
-    m["sma50"] = float(np.mean(c[-50:])) if n >= 50 else None
-    m["sma200"] = float(np.mean(c[-200:])) if n >= 200 else None
-    m["vwap365"] = None
-    if n >= 120:
-        sb, sq = np.nansum(vb[-365:]), np.nansum(vq[-365:])
-        if sb > 0 and sq > 0:
-            m["vwap365"] = float(sq / sb)
-    m["trend_fair"] = m["trend_g"] = m["trend_z"] = m["trend_sigma"] = None
-    if n >= 120:
-        mm = min(n, 500)
-        y, x = np.log(c[-mm:]), np.arange(mm, dtype=float)
-        slope, icpt = np.polyfit(x, y, 1)
-        sigma = float(np.std(y - (icpt + slope * x), ddof=2))
-        fit_now = icpt + slope * mm
-        m["trend_fair"] = float(np.exp(fit_now))
-        m["trend_g"] = float(np.exp(slope * 365) - 1)
-        m["trend_sigma"] = sigma
-        if sigma > 1e-9:
-            m["trend_z"] = float((np.log(price) - fit_now) / sigma)
-    q30, q90 = _tail(vq, 30), _tail(vq, 90)
-    m["vq30"] = float(np.nanmean(q30)) if q30 is not None else None
-    m["vq90"] = float(np.nanmean(q90)) if q90 is not None else None
-    m["vol_ratio"] = div(m["vq30"], m["vq90"]) if (m["vq90"] or 0) > 0 else None
-    m["vcv"] = float(np.nanstd(q90) / np.nanmean(q90)) if q90 is not None and np.nanmean(q90) > 0 else None
-    r90 = _tail(rets, 90)
-    m["worst90"] = float(np.min(r90)) if r90 is not None else None
-    m["var95"] = float(-np.percentile(r90, 5)) if r90 is not None else None
-    m["spread_bps"] = None
-    if bid and ask and bid > 0 and ask > 0 and ask >= bid:
-        m["spread_bps"] = (ask - bid) / ((ask + bid) / 2) * 1e4
-    return m
-
-
-def fetch(inst: str, force: bool = False) -> Optional[Dict[str, Any]]:
-    key = f"t_{inst}"
-    if not force:
-        c = _cget(key)
-        if c is not None:
-            return c
-    try:
-        df = fetch_candles(inst)
-        tk = get_tickers().get(inst)
-        if tk is None:
-            rows = okx_get("/api/v5/market/ticker", {"instId": inst})
-            tk = rows[0] if rows else None
-        funding, oi_usd = fetch_perp(inst) if SETTINGS.get("perp", True) else (None, None)
-    except Exception as e:
-        logger.warning("%s fetch failed: %s", inst, e)
-        return None
-    if df is None or df.empty:
-        return None
-    conf = df[df["confirm"] >= 1].reset_index(drop=True)
-    price = num(tk.get("last")) if tk else None
-    if price is None:
-        price = num(df["close"].iloc[-1])
-    if price is None or price <= 0 or len(conf) < 10:
-        return None
+        if len(X_train) < MIN_TRAIN_SAMPLES or len(X_test) < 10:
+            continue
 
-    flags: List[str] = []
-    notes: List[str] = []
-    mt = metrics_from_candles(conf, price, num(tk.get("bidPx")) if tk else None, num(tk.get("askPx")) if tk else None)
-    n = mt["hist_days"]
-    if tk is None:
-        flags.append("ticker missing (price from last candle)")
-    if n < 200:
-        flags.append(f"short history ({n} days; SMA200 unavailable)")
-    last_ts = int(conf["ts"].iloc[-1])
-    last_dt = pd.to_datetime(last_ts, unit="ms", utc=True)
-    age_h = (datetime.now(timezone.utc) - (last_dt + pd.Timedelta(days=1))).total_seconds() / 3600
-    if age_h > 48:
-        flags.append(f"stale candles ({age_h:.0f} h)")
-    first_ts = int(conf["ts"].iloc[0])
-    gaps = int(round((last_ts - first_ts) / 86_400_000)) + 1 - n
-    if gaps > 3:
-        flags.append(f"{gaps} missing daily candles")
-    zero_days = int((conf["volq"].to_numpy(float)[-90:] == 0).sum())
-    if zero_days > 3:
-        flags.append(f"{zero_days} zero-volume days (last 90)")
-    if abs(price / float(conf["close"].iloc[-1]) - 1) > 0.30:
-        flags.append("live price deviates >30% from last close")
-    if funding is None:
-        notes.append("no perp (funding/OI) data")
-
-    base = inst.split("-")[0]
-    open24 = num(tk.get("open24h")) if tk else None
-    vol24 = num(tk.get("volCcy24h")) if tk else None
-    d = {
-        "sym": inst, "name": base, "base": base, "price": price, "seg": CATEGORY.get(base, "Other"),
-        "sector": tier_of(mt["vq30"] if mt["vq30"] is not None else vol24), "vol24": vol24,
-        "chg24": (price / open24 - 1) if open24 else None, "funding": funding, "oi_usd": oi_usd,
-        "flags": flags, "notes": notes, "unit_ok": True, "last_dt": last_dt, "age_h": age_h,
-        "p_vwap": div(price, mt["vwap365"]), "p_sma200": div(price, mt["sma200"]),
-        "p_trend": div(price, mt["trend_fair"]), "p_high": div(price, mt["hi365"]),
-        "hist": conf[["date", "close"]].tail(365).reset_index(drop=True), "fetched": datetime.now().isoformat(),
-        **mt,
+        model = lgb.LGBMRegressor(
+            objective="regression",
+            metric="mae",
+            num_leaves=31,
+            learning_rate=0.05,
+            n_estimators=300,
+            verbose=-1,
+            random_state=42,
+            n_jobs=-1,
+        )
+        model.fit(X_train, y_train)
+
+        preds = model.predict(X_test)
+
+        mae = mean_absolute_error(y_test, preds)
+        rmse = np.sqrt(mean_squared_error(y_test, preds))
+        direction_correct = np.mean((y_test > 0) == (preds > 0))
+
+        baseline_preds = np.zeros_like(y_test)
+        baseline_mae = mean_absolute_error(y_test, baseline_preds)
+        baseline_rmse = np.sqrt(mean_squared_error(y_test, baseline_preds))
+
+        results.append({
+            "split": i + 1,
+            "train_samples": len(X_train),
+            "test_samples": len(X_test),
+            "mae": round(float(mae), 6),
+            "rmse": round(float(rmse), 6),
+            "direction_accuracy": round(float(direction_correct), 4),
+            "baseline_mae": round(float(baseline_mae), 6),
+            "baseline_rmse": round(float(baseline_rmse), 6),
+            "mae_improvement_pct": round(float((1 - mae / baseline_mae) * 100), 2) if baseline_mae > 0 else 0.0,
+        })
+
+        test_meta = meta_test.copy()
+        test_meta["predicted_return"] = preds
+        test_meta["actual_return"] = y_test.values
+        all_predictions.append(test_meta)
+
+    if not results:
+        return {"error": "Backtest tamamlanamadı (yeterli veri yok)."}
+
+    if all_predictions:
+        sim_df = pd.concat(all_predictions)
+        total_cost_rate = SETUP_FEE_RATE + TRANSACTION_TAX_RATE
+        sim_df["net_return"] = sim_df["actual_return"] - total_cost_rate
+        sim_df["gross_return"] = sim_df["actual_return"]
+        sim_df["trade_signal"] = sim_df["predicted_return"] > 0
+        sim_trades = sim_df[sim_df["trade_signal"]].copy()
+
+        if len(sim_trades) > 0:
+            avg_net_return = sim_trades["net_return"].mean()
+            win_rate = (sim_trades["net_return"] > 0).mean()
+            total_trades = len(sim_trades)
+            profitable_trades = int((sim_trades["net_return"] > 0).sum())
+            simulation = {
+                "total_trades": int(total_trades),
+                "avg_net_return_per_trade_pct": round(float(avg_net_return * 100), 4),
+                "win_rate_pct": round(float(win_rate * 100), 2),
+                "profitable_trades": profitable_trades,
+            }
+        else:
+            simulation = {"total_trades": 0, "avg_net_return_per_trade_pct": 0.0, "win_rate_pct": 0.0, "profitable_trades": 0}
+    else:
+        simulation = {}
+
+    return {
+        "results": results,
+        "simulation": simulation,
+        "n_splits_completed": len(results),
     }
-    _cset(key, d)
-    return d
 
 
-def cached_ds() -> List[Dict[str, Any]]:
-    return [v for k, (ts, v) in _cache.items() if k.startswith("t_") and v is not None]
+# ---------------------------------------------------------------------------
+# VERİ HATTI
+# ---------------------------------------------------------------------------
 
+class DataPipeline:
+    def __init__(self):
+        self.history_df = pd.DataFrame()
+        self.prices_df = pd.DataFrame()
+        self.featured_df = pd.DataFrame()
+        self.model = None
+        self.last_update = None
+        self.status_message = "Veri yüklenmedi."
+        self._backtest_cache = None
 
-MULTS = ["p_vwap", "p_sma200", "p_trend", "p_high", "ret90", "vol90", "sharpe"]
-POS_ONLY = {"p_vwap", "p_sma200", "p_trend", "p_high"}
+    def fetch_data(self, item_ids: List[str] = None, cities: List[str] = None):
+        if item_ids is None:
+            item_ids = ITEM_IDS
+        if cities is None:
+            cities = CITIES
 
+        self.status_message = "API'den veri çekiliyor..."
+        hist = fetch_history(item_ids, cities)
+        prices = fetch_current_prices(item_ids, cities)
 
-def build_medians(ds) -> Dict[str, Dict[str, Tuple[Optional[float], int]]]:
-    groups: Dict[str, list] = {}
-    for d in ds:
-        groups.setdefault(d["seg"], []).append(d)
-    med = {}
-    for k, g in groups.items():
-        m = {}
-        for f in MULTS:
-            v = [x[f] for x in g if x.get(f) is not None and (f not in POS_ONLY or (0 < x[f] < 300))]
-            m[f] = (float(np.median(v)) if len(v) >= MIN_PEERS else None, len(v))
-        med[k] = m
-    return med
+        if hist.empty:
+            self.status_message = "Tarihsel veri alınamadı. API bağlantısını kontrol edin."
+            return
 
+        self.history_df = clean_market_data(hist)
+        self.prices_df = prices
+        self.status_message = f"{len(self.history_df)} satır tarihsel veri, {len(self.prices_df)} anlık fiyat alındı."
 
-# ============================================================================
-# VALUATION ENGINE  (fiyat-bazlı fair value; fundamental yoktur)
-# ============================================================================
+        save_to_csv(self.history_df, "history")
+        save_to_csv(self.prices_df, "prices")
 
-def dep_value(anchor, g0, wacc, tg, years=5) -> Optional[Dict[str, float]]:
-    """Discounted Expected Price: anchor fiyatı 5 yıl boyunca g0 -> tg doğrusal sönen drift ile büyütülür,
-    gereken getiri (wacc) ile bugüne iskonto edilir. DCF'in nakit akışsız karşılığıdır."""
-    if None in (anchor, g0, wacc, tg) or anchor <= 0 or wacc <= tg:
-        return None
-    p = anchor
-    for t in range(1, years + 1):
-        g = g0 + (tg - g0) * (t - 1) / (years - 1)
-        p *= 1 + g
-    return {"p_future": p, "per_unit": p / (1 + wacc) ** years}
-
-
-def assumptions(P, rg=None, rw=None):
-    rg = P["rg"] if rg is None else rg
-    rw = P["rw"] if rw is None else rw
-    i = P["infl"]
-    return (1 + rg) * (1 + i * P["pt"]) - 1, (1 + rw) * (1 + i) - 1, (1 + P["rtg"]) * (1 + i) - 1  # g0, wacc, tg (nominal)
-
-
-def anchor_of(d) -> Optional[float]:
-    v = [x for x in (d.get("trend_fair"), d.get("vwap365"), d.get("sma200")) if x is not None and x > 0]
-    return float(np.median(v)) if len(v) >= 2 else None
-
-
-def dep_try(anchor, g0, wacc, tg):
-    if anchor is None:
-        return None, "needs >=2 price anchors (trend / VWAP / SMA200)"
-    if anchor <= 0:
-        return None, "non-positive anchor"
-    if wacc <= tg:
-        return None, "discount rate <= terminal drift"
-    r = dep_value(anchor, g0, wacc, tg)
-    if r is None or r["per_unit"] <= 0:
-        return None, "value <= 0"
-    return r["per_unit"], f"anchor {fpx(anchor)} → {fpx(r['p_future'])} (5y) → discounted"
-
-
-def relative_value(d, med) -> Tuple[Optional[float], str]:
-    m = med.get(d["seg"])
-    if not m:
-        return None, "no peer group"
-    vals = []
-    if m["p_vwap"][0] and d.get("vwap365"):
-        vals.append(m["p_vwap"][0] * d["vwap365"])
-    if m["p_sma200"][0] and d.get("sma200"):
-        vals.append(m["p_sma200"][0] * d["sma200"])
-    if m["p_trend"][0] and d.get("trend_fair"):
-        vals.append(m["p_trend"][0] * d["trend_fair"])
-    vals = [v for v in vals if v > 0]
-    if not vals:
-        return None, f"<{MIN_PEERS} valid peers"
-    return float(np.mean(vals)), f"{len(vals)} category-median multiple(s)"
-
-
-def intrinsic(d, P, med, rg=None, rw=None):
-    g0, wacc, tg = assumptions(P, rg, rw)
-    m: Dict[str, Tuple[Optional[float], str]] = {}
-    tf = d.get("trend_fair")
-    m["Log-Trend Regression"] = ((tf, f"trend {fp(d.get('trend_g'))}/yıl, z={fm(d.get('trend_z'))}") if tf else (None, "needs >=120 days of candles"))
-    vw = d.get("vwap365")
-    m["VWAP 365D"] = ((vw, "hacim-ağırlıklı maliyet bazı vekili") if vw else (None, "needs >=120 days"))
-    s2 = d.get("sma200")
-    m["SMA 200D"] = ((s2, "200 günlük ortalama") if s2 else (None, "needs >=200 days"))
-    m["Discounted Expected Price"] = dep_try(anchor_of(d), g0, wacc, tg)
-    m["Relative"] = relative_value(d, med)
-    vals = [v for v, _ in m.values() if v is not None and v > 0]
-    return m, (float(np.median(vals)) if vals else None)
-
-
-def reverse_dcf(d, P):
-    base = anchor_of(d)
-    if base is None or base <= 0:
-        return None, "anchor unavailable (needs >=2 of trend / VWAP / SMA200)"
-    _, wacc0, tg = assumptions(P)
-
-    def solve(wacc):
-        if wacc <= tg:
-            return None
-        f = lambda g: dep_value(base, g, wacc, tg)["per_unit"]
-        lo, hi = -0.9, 3.0
-        if not (f(lo) <= d["price"] <= f(hi)):
-            return None
-        for _ in range(80):
-            mid = (lo + hi) / 2
-            lo, hi = (mid, hi) if f(mid) < d["price"] else (lo, mid)
-        return (lo + hi) / 2
-
-    rows = []
-    for dw in (-0.03, 0.0, 0.03):
-        rw = P["rw"] + dw
-        w = (1 + rw) * (1 + P["infl"]) - 1
-        g = solve(w)
-        rows.append({"Real discount rate": fp(rw), "Nominal discount rate": fp(w), "Implied drift (nominal, yr1)": fp(g),
-                     "Implied (real)": fp(real_ret(g, P["infl"]))})
-    return rows, "ok"
-
-
-def scenarios(d, P, med, probs):
-    SC = [("Bear", -0.04, 0.03, 0.85), ("Base", 0.0, 0.0, 1.0), ("Bull", 0.04, -0.02, 1.10)]
-    out, ok = [], True
-    for (nm, dg, dw, mult), p in zip(SC, probs):
-        _, iv = intrinsic(d, P, med, rg=P["rg"] + dg, rw=max(P["rw"] + dw, 0.0))
-        tgt = None if iv is None else (d["price"] + P["conv"] * (iv - d["price"])) * mult
-        ok &= tgt is not None
-        out.append({"Scenario": nm, "Real growth": fp(P["rg"] + dg), "Real disc. rate": fp(max(P["rw"] + dw, 0)),
-                    "Multiple factor": mult, "Intrinsic": iv, "Target": tgt, "Prob": p})
-    if not ok:
-        return out, None
-    pw = sum(o["Prob"] * o["Target"] for o in out)
-    nom = pw / d["price"] - 1
-    tot = nom  # spot: temettü/gelir yok
-    return out, dict(pw=pw, nominal=nom, total=tot, real=real_ret(tot, P["infl"]), real_price=real_ret(nom, P["infl"]), dy_known=True)
-
-
-def validate_probs(bear, base):
-    bull = 100 - bear - base
-    if bear < 0 or base < 0 or bull < -1e-9:
-        return None
-    return (bear / 100, base / 100, bull / 100)
-
-
-# ============================================================================
-# QUALITY, MARKET HEALTH, RISK
-# ============================================================================
-
-def quality(d):
-    q = {k: d.get(k) for k in ("ret30", "ret90", "ret365", "vol30", "vol90", "vol365", "sharpe", "sortino", "maxdd", "dd_high",
-                               "trend_z", "spread_bps", "vq30", "vq90", "vol_ratio", "vcv", "worst90", "var95", "hist_days")}
-    q["sma_gap"] = div(d.get("sma50"), d.get("sma200"))
-    q["sma_gap"] = None if q["sma_gap"] is None else q["sma_gap"] - 1
-    return q
-
-
-def market_health(d):
-    """9 ikili bileşenli piyasa sağlığı skoru (Piotroski benzeri). Hesaplanamayan bileşen N/A."""
-    def cmp(a, b, op):
-        return None if a is None or b is None else op(a, b)
-
-    fr = d.get("funding")
-    comps = [
-        ("1 Price > SMA200", cmp(d.get("price"), d.get("sma200"), lambda a, b: a > b)),
-        ("2 SMA50 > SMA200", cmp(d.get("sma50"), d.get("sma200"), lambda a, b: a > b)),
-        ("3 90d return > 0", cmp(d.get("ret90"), 0, lambda a, b: a > b)),
-        ("4 Volatility falling (30d < 90d)", cmp(d.get("vol30"), d.get("vol90"), lambda a, b: a < b)),
-        ("5 Volume not shrinking (30d >= 90d avg)", cmp(d.get("vq30"), d.get("vq90"), lambda a, b: a >= b)),
-        ("6 Drawdown from 1Y high < 40%", cmp(d.get("dd_high"), 0.40, lambda a, b: a < b)),
-        ("7 Sharpe (1Y) > 0", cmp(d.get("sharpe"), 0, lambda a, b: a > b)),
-        ("8 Spread < 10 bps", cmp(d.get("spread_bps"), 10, lambda a, b: a < b)),
-        ("9 Funding not crowded (|f| < 0.03%/8h)", None if fr is None else abs(fr) < 0.0003),
+        self.featured_df = build_features(self.history_df)
+        self._backtest_cache = None
+
+    def train_model(self):
+        if self.featured_df.empty:
+            self.status_message = "Önce veri çekmelisiniz."
+            return False
+
+        X, y, _ = prepare_model_data(self.featured_df)
+        if len(X) < MIN_TRAIN_SAMPLES:
+            self.status_message = f"Yetersiz örnek: {len(X)} (min {MIN_TRAIN_SAMPLES})"
+            return False
+
+        self.model = train_global_model(X, y)
+        if self.model is None:
+            self.status_message = "Model eğitimi başarısız."
+            return False
+
+        self.status_message = f"Model eğitildi ({len(X)} örnek)."
+        self.last_update = dt.datetime.now()
+        return True
+
+    def get_latest_predictions(self) -> pd.DataFrame:
+        if self.featured_df.empty or self.model is None:
+            return pd.DataFrame()
+
+        latest = self.featured_df.sort_values("timestamp").groupby(["item_id", "city"]).tail(1).copy()
+        latest["item_code"] = latest["item_id"].astype("category").cat.codes
+        latest["city_code"] = latest["city"].astype("category").cat.codes
+
+        preds = predict_24h_returns(self.model, latest)
+
+        if not preds.empty and not self.prices_df.empty:
+            price_info = self.prices_df[["item_id", "city", "sell_price_min", "buy_price_max"]].copy()
+            preds = preds.merge(price_info, on=["item_id", "city"], how="left")
+            preds["spread"] = preds["sell_price_min"] - preds["buy_price_max"]
+        else:
+            preds["spread"] = np.nan
+
+        preds["confidence"] = (1.0 - preds["volatility_24h"].clip(0, 0.2) / 0.2).fillna(0.5).clip(0, 1)
+
+        total_cost = SETUP_FEE_RATE + TRANSACTION_TAX_RATE
+        preds["net_return_pct"] = preds["predicted_return_pct"] - (total_cost * 100)
+
+        return preds
+
+    def get_backtest(self):
+        if self._backtest_cache is None:
+            self._backtest_cache = walk_forward_backtest(self.featured_df)
+        return self._backtest_cache
+
+
+pipeline = DataPipeline()
+
+
+# ---------------------------------------------------------------------------
+# GRADIO YARDIMCI FONKSİYONLARI
+# ---------------------------------------------------------------------------
+
+def get_dashboard_metrics():
+    if pipeline.featured_df.empty:
+        return pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Veri yok"]})
+
+    df = pipeline.featured_df
+    metrics = {
+        "Toplam Gözlem": len(df),
+        "Ürün Sayısı": df["item_id"].nunique(),
+        "Şehir Sayısı": df["city"].nunique(),
+        "Tarih Aralığı": f"{df['timestamp'].min().date()} - {df['timestamp'].max().date()}",
+        "Ortalama Fiyat": f"{df['avg_price'].mean():.0f} silver",
+        "Ortalama Hacim": f"{df['item_count'].mean():.1f}",
+        "Model Durumu": "Eğitildi" if pipeline.model else "Eğitilmedi",
+    }
+    return pd.DataFrame(list(metrics.items()), columns=["Metrik", "Değer"])
+
+
+def get_analysis_table():
+    if pipeline.featured_df.empty:
+        return pd.DataFrame()
+
+    latest = pipeline.featured_df.sort_values("timestamp").groupby(["item_id", "city"]).tail(1).copy()
+
+    if not pipeline.prices_df.empty:
+        latest = latest.merge(
+            pipeline.prices_df[["item_id", "city", "sell_price_min", "buy_price_max"]],
+            on=["item_id", "city"], how="left"
+        )
+
+    latest["Ürün"] = latest["item_id"].apply(item_display_name)
+    latest["Şehir"] = latest["city"]
+    latest["Mevcut Fiyat"] = latest["avg_price"].round(0)
+    latest["Hacim (24s)"] = latest["item_count"].fillna(0).astype(int)
+    latest["Spread"] = (latest.get("sell_price_min", np.nan) - latest.get("buy_price_max", np.nan)).round(0)
+    latest["Likidite"] = pd.cut(latest["item_count"], bins=[-1, 10, 50, 200, np.inf], labels=["Düşük", "Orta", "İyi", "Yüksek"])
+
+    cols = ["Ürün", "Şehir", "Mevcut Fiyat", "Hacim (24s)", "Spread", "Likidite"]
+    return latest[cols].sort_values("Hacim (24s)", ascending=False).head(100)
+
+
+def get_prediction_table():
+    preds = pipeline.get_latest_predictions()
+    if preds.empty:
+        return pd.DataFrame()
+
+    preds["Ürün"] = preds["item_id"].apply(item_display_name)
+    preds["Şehir"] = preds["city"]
+    preds["Mevcut Fiyat"] = preds["avg_price"].round(0)
+    preds["Tahmini Fiyat (24s)"] = preds["predicted_price_24h"].round(0)
+    preds["Tahmini Değişim %"] = preds["predicted_return_pct"].round(2)
+    preds["Güvenilirlik"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
+    preds["Spread"] = preds["spread"].round(0)
+    preds["Net Getiri % (maliyet sonrası)"] = preds["net_return_pct"].round(2)
+    preds["Likidite"] = pd.cut(preds["item_count"], bins=[-1, 10, 50, 200, np.inf], labels=["Düşük", "Orta", "İyi", "Yüksek"])
+
+    cols = [
+        "Ürün", "Şehir", "Mevcut Fiyat", "Tahmini Fiyat (24s)",
+        "Tahmini Değişim %", "Güvenilirlik", "Spread", "Likidite",
+        "Net Getiri % (maliyet sonrası)"
     ]
-    n = sum(1 for _, v in comps if v is not None)
-    return sum(1 for _, v in comps if v), n, comps
-
-
-def risk_engine(d, q, cov):
-    fl = []
-
-    def add(name, w, cond, detail):
-        fl.append((name, w, None if cond is None else ("TRIGGERED" if cond else "OK"), detail))
-
-    price, s2, fr = d.get("price"), d.get("sma200"), d.get("funding")
-    add("Extreme volatility", 12, None if q["vol90"] is None else q["vol90"] > 1.2, "90d annualized vol > 120%")
-    add("Deep drawdown", 12, None if q["dd_high"] is None else q["dd_high"] > 0.5, "price >50% below 1Y high")
-    add("Downtrend", 10, None if s2 is None else price < s2, "price < SMA200")
-    add("Thin liquidity", 10, None if q["vq30"] is None else q["vq30"] < 5e6, "30d avg daily volume < 5M USDT")
-    add("Wide spread", 8, None if q["spread_bps"] is None else q["spread_bps"] > 15, "bid/ask spread > 15 bps")
-    add("Volume collapse", 8, None if q["vol_ratio"] is None else q["vol_ratio"] < 0.5, "30d avg volume < 50% of 90d avg")
-    add("Crash day", 8, None if q["worst90"] is None else q["worst90"] < -0.15, "worst daily return (90d) < -15%")
-    add("Tail risk (VaR95)", 8, None if q["var95"] is None else q["var95"] > 0.08, "daily 95% VaR (90d) > 8%")
-    add("Overextension", 8, anyc(None if q["trend_z"] is None else q["trend_z"] > 2,
-                                 None if d.get("p_sma200") is None else d["p_sma200"] > 1.6),
-        "trend z-score > 2 or price > 1.6x SMA200")
-    add("Funding crowding", 6, None if fr is None else abs(fr) > 0.0005, "|funding| > 0.05% per 8h")
-    add("Data reliability", 10, cov < 0.7 or bool(d["flags"]), f"coverage<70% or integrity flags ({len(d['flags'])})")
-    ev_w = sum(w for _, w, st, _ in fl if st is not None)
-    score = None if ev_w == 0 else 100 * sum(w for _, w, st, _ in fl if st == "TRIGGERED") / ev_w
-    return score, fl
-
-
-# ============================================================================
-# SCORING & ANALYSIS
-# ============================================================================
-
-WEIGHTS = {"Majors": (.30, .25, .25, .20), "Meme": (.25, .15, .20, .40)}
-DEFAULT_W = (.30, .25, .20, .25)
-
-
-def coverage(d):
-    f = [d.get("price"), d.get("vq30"), d.get("spread_bps"), d.get("sma50"), d.get("sma200"), d.get("vwap365"),
-         d.get("trend_fair"), d.get("vol90"), d.get("sharpe"), d.get("maxdd"), d.get("ret90"), d.get("ret365")]
-    return sum(x is not None for x in f) / len(f)
-
-
-def analyze(d, P, med, probs=(0.25, 0.5, 0.25)):
-    A: Dict[str, Any] = {"d": d}
-    infl = P["infl"]
-    q = quality(d)
-    A["q"] = q
-    A["methods"], A["iv"] = intrinsic(d, P, med)
-    A["mos"] = (A["iv"] - d["price"]) / A["iv"] if A["iv"] else None
-    rv, A["rel_note"] = relative_value(d, med)
-    A["rel_mos"] = (rv - d["price"]) / rv if rv else None
-    A["pio"] = market_health(d)
-    A["cov"] = coverage(d)
-    A["risk"], A["flags"] = risk_engine(d, q, A["cov"])
-    rret365, rret90 = real_ret(q["ret365"], infl), real_ret(q["ret90"], infl)
-    liq = math.log10(q["vq30"]) if q["vq30"] and q["vq30"] > 0 else None
-
-    vi = [(lin(A["mos"], -0.3, 0.5), 4), (lin(A["rel_mos"], -0.3, 0.5), 2), (lin(d.get("trend_z"), 2, -2), 2),
-          (lin(d.get("p_sma200"), 1.6, 0.8), 1), (lin(q["dd_high"], 0.0, 0.6), 1)]
-    qi = [(lin(rret365, -0.5, 1.5), 3), (lin(q["sharpe"], -0.5, 2.0), 3), (lin(q["sortino"], -0.5, 3.0), 2),
-          (lin(q["maxdd"], 0.8, 0.25), 2), (lin(rret90, -0.3, 0.5), 1), (lin(q["vcv"], 2, 0.3), 1)]
-    sc, n, _ = A["pio"]
-    si = [(lin(liq, 6, 9), 3), (lin(q["spread_bps"], 30, 2), 2), (lin(q["hist_days"], 90, 500), 2),
-          (lin(q["vol90"], 1.5, 0.4), 2), (lin(sc / n, 0.3, 0.8) if n >= 5 else None, 2)]
-    A["val"], A["val_cov"] = wavg(vi)
-    A["qual"], A["qual_cov"] = wavg(qi)
-    A["str"], A["str_cov"] = wavg(si)
-    w = WEIGHTS.get(d["seg"], DEFAULT_W)
-    comps = [A["val"], A["qual"], A["str"], None if A["risk"] is None else 100 - A["risk"]]
-    if A["val"] is None or A["qual"] is None:
-        A["composite"] = None
-    else:
-        av = [(c, wt) for c, wt in zip(comps, w) if c is not None]
-        A["composite"] = sum(c * wt for c, wt in av) / sum(wt for _, wt in av) * min(1.0, A["cov"] / 0.7)
-    sev = any("stale" in f or "missing daily" in f or "deviates" in f for f in d["flags"])
-    lvl = 2 if A["cov"] >= 0.85 else 1 if A["cov"] >= 0.65 else 0
-    lvl = max(lvl - (1 if sev else 0), 0)
-    A["conf"] = ["Low", "Medium", "High"][lvl]
-    pr = validate_probs(probs[0] * 100, probs[1] * 100) or (0.25, 0.5, 0.25)
-    A["scen"], A["exp"] = scenarios(d, P, med, pr)
-    return A
-
-
-# ============================================================================
-# OUTPUT BUILDERS
-# ============================================================================
-
-def get_A(ticker, P, probs=(0.25, 0.5, 0.25)):
-    sym = norm_sym(ticker)
-    d = fetch(sym)
-    if d is None:
-        return None, f"⚠️ {sym or '?'} OKX'ten çekilemedi (parite yok, geçmiş yetersiz ya da ağ hatası)."
-    return analyze(d, P, build_medians(cached_ds()), probs), None
-
-
-def price_fig(d, extra=None):
+    return preds[cols].sort_values("Tahmini Değişim %", ascending=False)
+
+
+def get_arbitrage_table():
+    if pipeline.prices_df.empty:
+        return pd.DataFrame()
+
+    prices = pipeline.prices_df.copy()
+    prices = prices[prices["sell_price_min"] > 0]
+
+    buy = prices.loc[prices.groupby("item_id")["sell_price_min"].idxmin()][["item_id", "city", "sell_price_min"]]
+    buy.columns = ["item_id", "buy_city", "buy_price"]
+
+    sell = prices.loc[prices.groupby("item_id")["buy_price_max"].idxmax()][["item_id", "city", "buy_price_max"]]
+    sell.columns = ["item_id", "sell_city", "sell_price"]
+
+    arb = buy.merge(sell, on="item_id")
+    arb = arb[arb["sell_price"] > arb["buy_price"]].copy()
+
+    # Alışta setup fee, satışta setup fee + transaction tax
+    arb["brüt_kâr"] = arb["sell_price"] - arb["buy_price"]
+    arb["toplam_maliyet"] = (
+        arb["buy_price"] * SETUP_FEE_RATE
+        + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
+    )
+    arb["net_kâr"] = arb["brüt_kâr"] - arb["toplam_maliyet"]
+    arb["kâr_marjı_%"] = (arb["net_kâr"] / arb["buy_price"]) * 100
+
+    arb = arb[arb["net_kâr"] > 0].sort_values("kâr_marjı_%", ascending=False)
+
+    arb["Ürün"] = arb["item_id"].apply(item_display_name)
+    arb["Alış Şehri"] = arb["buy_city"]
+    arb["Satış Şehri"] = arb["sell_city"]
+    arb["Alış Fiyatı"] = arb["buy_price"].round(0)
+    arb["Satış Fiyatı"] = arb["sell_price"].round(0)
+    arb["Net Kâr"] = arb["net_kâr"].round(0)
+    arb["Kâr Marjı %"] = arb["kâr_marjı_%"].round(1)
+
+    cols = ["Ürün", "Alış Şehri", "Satış Şehri", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Kâr Marjı %"]
+    return arb[cols].head(50)
+
+
+def get_model_performance_plot():
+    if pipeline.model is None:
+        return go.Figure().update_layout(title="Model eğitilmedi", template="plotly_dark")
+
     try:
-        h = d["hist"]
-        if h is None or h.empty:
-            return None
-        f = go.Figure(go.Scatter(x=h["date"], y=h["close"], mode="lines", name="Close"))
-        for nm, v in (extra or {}).items():
-            if v:
-                f.add_hline(y=v, line_dash="dot", annotation_text=nm)
-        f.update_layout(title=f"{d['sym']} — 1Y (OKX, USDT)", template="plotly_white", height=380, margin=dict(l=10, r=10, t=40, b=10))
-        return f
-    except Exception:
-        return None
+        importance = pipeline.model.feature_importances_
+        feature_names = pipeline.model.feature_name_
+        df_imp = pd.DataFrame({"Özellik": feature_names, "Önem": importance}).sort_values("Önem", ascending=True).tail(20)
+        fig = px.bar(df_imp, x="Önem", y="Özellik", orientation="h", title="Feature Importance (Top 20)", template="plotly_dark")
+        return fig
+    except Exception as e:
+        return go.Figure().update_layout(title=f"Grafik hatası: {e}", template="plotly_dark")
 
 
-def scan_row(A):
-    d, q = A["d"], A["q"]
-    sc, n, _ = A["pio"]
-    e = A["exp"]
-    return {
-        "Pair": d["sym"], "Segment": d["seg"], "Tier": d["sector"], "Price": rsig(d["price"]),
-        "Composite": None if A["composite"] is None else round(A["composite"], 1),
-        "Fair value": rsig(A["iv"]),
-        "MoS %": None if A["mos"] is None else round(A["mos"] * 100, 1),
-        "vs VWAP365 %": None if d["p_vwap"] is None else round((d["p_vwap"] - 1) * 100, 1),
-        "Ret 90d %": pct(q["ret90"]), "Vol 90d %": pct(q["vol90"], 0),
-        "Sharpe 1Y": None if q["sharpe"] is None else round(q["sharpe"], 2),
-        "MaxDD 1Y %": pct(q["maxdd"], 0),
-        "Health": f"{sc}/{n} (cov {n}/9)" if n else "N/A",
-        "Risk": None if A["risk"] is None else round(A["risk"], 0),
-        "Exp Return % (12M)": None if not e else round(e["total"] * 100, 1),
-        "Real Exp Return %": None if not e or e["real"] is None else round(e["real"] * 100, 1),
-        "Vol30d avg (M USDT)": None if q["vq30"] is None else round(q["vq30"] / 1e6, 1),
-        "Funding % (8h)": None if d["funding"] is None else round(d["funding"] * 100, 4),
-        "Coverage %": round(A["cov"] * 100), "Confidence": A["conf"],
-    }
+def get_backtest_outputs():
+    bt = pipeline.get_backtest()
+
+    if "error" in bt:
+        return pd.DataFrame({"Hata": [bt["error"]]}), go.Figure().update_layout(title="Backtest hatası", template="plotly_dark"), pd.DataFrame()
 
+    results_df = pd.DataFrame(bt["results"])
+
+    fig = go.Figure()
+    fig.add_trace(go.Bar(name="Model MAE", x=results_df["split"], y=results_df["mae"], marker_color="cyan"))
+    fig.add_trace(go.Bar(name="Baseline MAE", x=results_df["split"], y=results_df["baseline_mae"], marker_color="gray"))
+    fig.update_layout(
+        title="Walk-Forward Backtest: MAE Karşılaştırması",
+        xaxis_title="Split",
+        yaxis_title="MAE (log getiri)",
+        barmode="group",
+        template="plotly_dark",
+    )
+
+    if bt.get("simulation"):
+        sim_df = pd.DataFrame([bt["simulation"]])
+    else:
+        sim_df = pd.DataFrame()
+
+    return results_df, fig, sim_df
+
+
+def refresh_data_ui():
+    pipeline.fetch_data()
+    if not pipeline.featured_df.empty:
+        pipeline.train_model()
+
+    bt_table, bt_fig, sim_table = get_backtest_outputs()
+
+    return (
+        pipeline.status_message,
+        get_dashboard_metrics(),
+        get_analysis_table(),
+        get_prediction_table(),
+        get_arbitrage_table(),
+        get_model_performance_plot(),
+        bt_table,
+        bt_fig,
+        sim_table,
+    )
+
+
+def initial_load():
+    return (
+        get_dashboard_metrics(),
+        get_analysis_table(),
+        get_prediction_table(),
+        get_arbitrage_table(),
+        get_model_performance_plot(),
+        pd.DataFrame(),
+        go.Figure().update_layout(title="Verileri yenilemek için butona tıklayın", template="plotly_dark"),
+        pd.DataFrame(),
+    )
+
+
+# ---------------------------------------------------------------------------
+# GRADIO ARAYÜZÜ
+# ---------------------------------------------------------------------------
+
+with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hue="cyan", secondary_hue="slate")) as demo:
+
+    gr.Markdown(
+        """
+        # 🦅 GOSHAWK ALBION MARKET AI
+        **Profesyonel Market Intelligence Dashboard** | Avrupa Sunucusu
+        *LightGBM tabanlı 24 saatlik fiyat tahmini ve arbitraj analizi.*
+
+        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir ve kesin kazanç garantisi sunmaz. Geçmiş performans gelecek sonuçların göstergesi değildir.
+        """
+    )
+
+    with gr.Row():
+        refresh_btn = gr.Button("🔄 Verileri Yenile ve Modeli Eğit", variant="primary", scale=1)
+        status_text = gr.Textbox(label="Durum", interactive=False, scale=2)
+
+    with gr.Tabs():
+
+        with gr.TabItem("📊 Dashboard"):
+            dashboard_table = gr.Dataframe(label="Özet Metrikler", interactive=False)
+            gr.Markdown(
+                "### Kullanım\n"
+                "1. 'Verileri Yenile ve Modeli Eğit' butonuna tıklayın.\n"
+                "2. API'den gerçek piyasa verileri çekilir ve global LightGBM modeli eğitilir.\n"
+                "3. Diğer sekmelerden analizleri inceleyebilirsiniz.\n\n"
+                "*Veriler `gos_hawk_data/` dizininde CSV olarak saklanır.*"
+            )
+
+        with gr.TabItem("📦 100 Ürün Analizi"):
+            analysis_table = gr.Dataframe(label="Ürün Analizi (En yüksek hacimli 100 ürün)", interactive=False)
+
+        with gr.TabItem("🔮 24 Saatlik Fiyat Tahmini"):
+            prediction_table = gr.Dataframe(label="Tahminler (24 saatlik log getiri modeli)", interactive=False)
+            gr.Markdown(
+                "*Güvenilirlik, volatilite ve RSI tabanlı bir göstergedir. "
+                "Net getiri, %2.5 setup + %8 vergi düşülerek hesaplanmıştır. "
+                "Spread ve likidite düşükse işlem maliyeti artabilir.*"
+            )
+
+        with gr.TabItem("🚚 Şehirler Arası Arbitraj"):
+            arbitrage_table = gr.Dataframe(label="Arbitraj Fırsatları (işlem maliyetleri dahil)", interactive=False)
+            gr.Markdown(
+                "*Net kâr; alışta %2.5 setup fee, satışta %2.5 setup + %8 transaction tax düşülerek hesaplanmıştır. "
+                "Seyahat maliyeti ve zaman riski dahil değildir. Caerleon'a giriş/çıkış riski ayrıca değerlendirilmelidir.*"
+            )
+
+        with gr.TabItem("📈 Model Performansı"):
+            performance_plot = gr.Plot(label="Feature Importance")
+
+        with gr.TabItem("🧪 Walk-forward Backtest"):
+            backtest_table = gr.Dataframe(label="Split Sonuçları")
+            backtest_plot = gr.Plot(label="MAE Karşılaştırması")
+            simulation_table = gr.Dataframe(label="İşlem Simülasyonu (maliyetler sonrası)")
+            gr.Markdown(
+                "*Walk-forward backtest kronolojik split kullanır; purge (24s) ve embargo (24s) uygulanır. "
+                "Baseline, 'fiyat değişmez' (getiri=0) varsayımıdır. Simülasyon yalnızca modelin pozitif getiri öngördüğü işlemleri içerir.*"
+            )
+
+        with gr.TabItem("🗄️ Veri Yönetimi"):
+            gr.Markdown("Veriler `gos_hawk_data/` dizininde CSV olarak saklanır.")
+            data_status = gr.Textbox(label="Veri Durumu", interactive=False)
+            csv_files = gr.FileExplorer(root=DATA_DIR, label="Kayıtlı CSV Dosyaları")
+
+    refresh_btn.click(
+        fn=refresh_data_ui,
+        inputs=[],
+        outputs=[
+            status_text,
+            dashboard_table,
+            analysis_table,
+            prediction_table,
+            arbitrage_table,
+            performance_plot,
+            backtest_table,
+            backtest_plot,
+            simulation_table,
+        ],
+    )
+
+    demo.load(
+        fn=initial_load,
+        inputs=[],
+        outputs=[
+            dashboard_table,
+            analysis_table,
+            prediction_table,
+            arbitrage_table,
+            performance_plot,
+            backtest_table,
+            backtest_plot,
+            simulation_table,
+        ],
+    )
 
-def run_scan(force, extra, P, progress, n=DEFAULT_UNIVERSE_N):
-    base, src = build_universe(int(n))
-    syms = base + [norm_sym(x) for x in (extra or "").split(",") if x.strip()]
-    syms = [s for s in dict.fromkeys(syms) if s]
-    LAST["universe"] = syms
-    ds, failed = [], []
-    for i, s in enumerate(syms):
-        progress((i + 1) / len(syms), desc=f"Fetching {s}")
-        was_cached = (not force) and _cget(f"t_{s}") is not None
-        d = fetch(s, force)
-        (ds.append(d) if d else failed.append(s))
-        if not was_cached:
-            time.sleep(REQUEST_DELAY_SEC)
-    med = build_medians(ds)
-    rows = [scan_row(analyze(d, P, med)) for d in ds]
-    df = pd.DataFrame(rows)
-    LAST["df"], LAST["failed"] = df, failed
-    return df, failed, src
-
-
-def apply_filters(seg, minc, minm, sortby, desc):
-    df = LAST["df"]
-    if df is None or df.empty:
-        return None, None
-    x = df.copy()
-    if seg != "All":
-        x = x[x["Segment"] == seg]
-    x = x[x["Composite"].fillna(-1) >= minc]
-    if minm > -100:
-        x = x[x["MoS %"].fillna(-1e9) >= minm]
-    x = x.sort_values(sortby, ascending=not desc, na_position="last")
-    f = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", prefix="okx_v1_")
-    x.to_csv(f.name, index=False)
-    return x, f.name
-
-
-def md_report(A, P):
-    d = A["d"]
-    L = [f"## {d['sym']} — OKX Spot",
-         f"**{d['seg']}** · {d['sector']} · Fiyat **{fpx(d['price'])} USDT** · 24s {fp(d['chg24'])} · "
-         f"Son kapanmış mum: {d['last_dt'].date() if d['last_dt'] is not None else 'N/A'}",
-         f"**Composite {fm(A['composite'], 0)}** | Valuation {fm(A['val'], 0)} | Quality {fm(A['qual'], 0)} | "
-         f"Strength {fm(A['str'], 0)} | Risk {fm(A['risk'], 0)} (düşük=iyi) | Coverage {fp(A['cov'], 0)} | "
-         f"Confidence **{A['conf']}**",
-         f"**Fair value [D]:** {fpx(A['iv'])} USDT · Margin of Safety {fp(A['mos'])}"]
-    if d["funding"] is not None:
-        L.append(f"**Perp [R]:** funding {fp(d['funding'], 4)} / 8s · Open interest {fm((d['oi_usd'] or 0) / 1e6, 1) if d['oi_usd'] else 'N/A'} M USD")
-    L.append("\n| Yöntem | Değer | Not |\n|---|---|---|")
-    for k, (v, n) in A["methods"].items():
-        L.append(f"| {k} | {fpx(v)} | {n} |")
-    if d["flags"]:
-        L.append("\n**⚠️ Veri bayrakları:** " + "; ".join(d["flags"]))
-    L.append("\n*Fair value = mevcut yöntemlerin medyanı (fiyat-hacim bazlı referans, fundamental değil). "
-             "Skorlar evren içi göreceli, açıklanabilir heuristiklerdir.*")
-    return "\n".join(L)
-
-
-def radar_fig(A):
-    cats = ["Valuation", "Quality", "Strength", "Safety (100-Risk)"]
-    v = [A["val"], A["qual"], A["str"], None if A["risk"] is None else 100 - A["risk"]]
-    v = [x or 0 for x in v]
-    f = go.Figure(go.Scatterpolar(r=v + v[:1], theta=cats + cats[:1], fill="toself"))
-    f.update_layout(polar=dict(radialaxis=dict(range=[0, 100])), height=340, margin=dict(l=30, r=30, t=30, b=20))
-    return f
-
-
-# ============================================================================
-# SELF TEST (synthetic)
-# ============================================================================
-
-def self_test() -> str:
-    res = []
-
-    def chk(name, cond):
-        res.append(("✅ " if cond else "❌ ") + name)
-
-    r = dep_value(100, 0, 0.10, 0)
-    chk("DEP: g=0,tg=0, 10% → 100/1.1^5", r is not None and abs(r["per_unit"] - 100 / 1.1 ** 5) < 1e-9)
-    chk("DEP refuses wacc<=tg", dep_value(100, 0.1, 0.05, 0.05) is None)
-    chk("DEP refuses anchor<=0", dep_value(-5, 0.1, 0.2, 0.05) is None)
-    chk("DEP refuses missing input", dep_value(None, 0.1, 0.2, 0.05) is None)
-    chk("Real return 50% nom / 25% infl = 20%", abs(real_ret(0.5, 0.25) - 0.2) < 1e-12)
-    chk("div by zero → None", div(1, 0) is None and div(None, 2) is None)
-    P = dict(infl=0.30, rw=0.10, rtg=0.01, rg=0.03, pt=0.5, conv=0.5)
-    g0, w, tg = assumptions(P)
-    chk("Discount rate > terminal drift (defaults)", w > tg)
-    chk("Probabilities 25/50 → 25/50/25 sum=1", validate_probs(25, 50) is not None and abs(sum(validate_probs(25, 50)) - 1) < 1e-9)
-    chk("Probabilities 70/50 rejected", validate_probs(70, 50) is None)
-    # reverse valuation consistency
-    d = {"trend_fair": 100.0, "vwap365": 100.0, "sma200": 100.0, "price": 100 / 1.1 ** 5}
-    P2 = dict(infl=0.0, rw=0.10, rtg=0.0, rg=0.0, pt=0.0, conv=0.5)
-    rows, _ = reverse_dcf(d, P2)
-    chk("Reverse: price = 100/1.1^5 → implied drift≈0",
-        rows is not None and abs(float(rows[1]["Implied drift (nominal, yr1)"].rstrip("%"))) < 0.05)
-    # market health incompleteness
-    sc, n, _ = market_health({})
-    chk("Market health all-missing → 0 available (not 9/9)", n == 0 and sc == 0)
-    # peer rule
-    ds = [{"seg": "X", "p_vwap": 1.0 + 0.1 * i, **{m: None for m in MULTS if m != "p_vwap"}} for i in range(4)]
-    chk("Category median needs >=5 peers", build_medians(ds)["X"]["p_vwap"][0] is None)
-    ds += [{"seg": "X", "p_vwap": 1.2, **{m: None for m in MULTS if m != "p_vwap"}}]
-    chk("Category median with 5 peers computed", build_medians(ds)["X"]["p_vwap"][0] is not None)
-    chk("Symbol normalisation", norm_sym("btc") == "BTC-USDT" and norm_sym("eth/usdt") == "ETH-USDT"
-        and norm_sym("SOLUSDT") == "SOL-USDT" and norm_sym("btc-usdt-swap") == "BTC-USDT" and norm_sym("BTC-USDC") == "BTC-USDC")
-    chk("Stablecoin / leveraged exclusion", is_excluded("USDC") and is_excluded("BTC3L") and not is_excluded("BTC"))
-    # metrics on a deterministic exponential series (+0.1% / day)
-    nd = 400
-    close = 100 * 1.001 ** np.arange(nd)
-    conf = pd.DataFrame({"close": close, "high": close * 1.01, "vol": np.full(nd, 1000.0), "volq": close * 1000.0})
-    mt = metrics_from_candles(conf, float(close[-1] * 1.001), 99.9, 100.1)
-    chk("Metrics: log-trend growth ≈ 1.001^365-1", mt["trend_g"] is not None and abs(mt["trend_g"] - (1.001 ** 365 - 1)) < 1e-6)
-    chk("Metrics: monotonic series → max drawdown 0", mt["maxdd"] is not None and abs(mt["maxdd"]) < 1e-12)
-    chk("Metrics: SMA200 = mean of last 200 closes", mt["sma200"] is not None and abs(mt["sma200"] - close[-200:].mean()) < 1e-9)
-    chk("Metrics: spread 20 bps for 99.9/100.1", mt["spread_bps"] is not None and abs(mt["spread_bps"] - 20.0) < 0.01)
-    chk("Metrics: 90d return", mt["ret90"] is not None and abs(mt["ret90"] - (close[-1] * 1.001 / close[-90] - 1)) < 1e-12)
-    return "\n".join(res)
-
-
-# ============================================================================
-# GRADIO UI
-# ============================================================================
-
-SORT_COLS = ["Composite", "MoS %", "vs VWAP365 %", "Ret 90d %", "Vol 90d %", "Sharpe 1Y", "MaxDD 1Y %", "Risk",
-             "Exp Return % (12M)", "Real Exp Return %", "Vol30d avg (M USDT)", "Coverage %"]
-
-
-def build_ui():
-    with gr.Blocks(title="OKX Value Intelligence v1", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# OKX Value Intelligence v1\n**⚠️ Veri: OKX public API (spot fiyat/hacim, günlük mumlar, perp funding/OI). "
-                    "Kripto varlıkların bilançosu yoktur: 'Fair value' fiyat-hacim verisinden türetilen istatistiksel referanstır, içsel değer değildir. "
-                    "Eksik veri `N/A` gösterilir, asla sıfırla doldurulmaz. 12 aylık senaryolar heuristiktir, istatistiksel tahmin değildir. "
-                    "Yatırım tavsiyesi değildir.**")
-        with gr.Accordion("⚙️ Varsayımlar [A] (tüm sekmeler için)", open=False):
-            with gr.Row():
-                s_infl = gr.Slider(0, 20, 3, step=0.5, label="Enflasyon (%)")
-                s_rw = gr.Slider(1, 40, 8, step=0.5, label="Reel iskonto / gereken getiri (%)")
-                s_rtg = gr.Slider(0, 15, 3, step=0.25, label="Reel terminal drift (%)")
-            with gr.Row():
-                s_rg = gr.Slider(-30, 60, 8, step=0.5, label="Baz reel drift (%)")
-                s_pt = gr.Slider(0, 100, 50, step=5, label="Enflasyonun nominal drift'e geçişi (%)")
-                s_cv = gr.Slider(0, 100, 50, step=5, label="12 ay içinde değer-fiyat farkının kapanma oranı (%)")
-        PI = [s_infl, s_rw, s_rtg, s_rg, s_pt, s_cv]
-
-        with gr.Tabs():
-            with gr.Tab("📊 Market Scanner"):
-                with gr.Row():
-                    scan_btn = gr.Button("Run Scanner", variant="primary", scale=2)
-                    force = gr.Checkbox(label="Force refresh", value=False)
-                    perp = gr.Checkbox(label="Perp verisi (funding/OI)", value=True)
-                with gr.Row():
-                    nuni = gr.Slider(20, 200, DEFAULT_UNIVERSE_N, step=10, label="Evren: 24s hacme göre ilk N OKX USDT paritesi")
-                    extra = gr.Textbox(label="Ek pariteler (virgülle, örn: PEPE,WIF,SOL-USDT)", value="")
-                with gr.Row():
-                    f_seg = gr.Dropdown(["All"] + SEGMENTS, value="All", label="Segment")
-                    f_c = gr.Slider(0, 100, 0, step=5, label="Min composite")
-                    f_m = gr.Slider(-100, 100, -100, step=5, label="Min MoS % (-100 = kapalı)")
-                with gr.Row():
-                    f_sort = gr.Dropdown(SORT_COLS, value="Composite", label="Sırala")
-                    f_desc = gr.Checkbox(label="Azalan", value=True)
-                    f_btn = gr.Button("Filtreyi uygula")
-                status = gr.Markdown()
-                table = gr.Dataframe(interactive=False, wrap=True)
-                csv = gr.File(label="CSV indir")
-                FI = [f_seg, f_c, f_m, f_sort, f_desc]
-
-                def do_scan(frc, prp, nu, ext, *a, progress=gr.Progress()):
-                    P = mk_params(*a[:6])
-                    seg, c, m, so, de = a[6:]
-                    SETTINGS["perp"] = bool(prp)
-                    df, failed, src = run_scan(frc, ext, P, progress, nu)
-                    if df.empty:
-                        return None, None, "⚠️ Veri çekilemedi (OKX'e erişilemiyor olabilir)."
-                    x, path = apply_filters(seg, c, m, so, de)
-                    msg = f"✅ {len(df)} parite tarandı · evren: {src} · coverage ort. %{df['Coverage %'].mean():.0f}"
-                    if failed:
-                        msg += f" · ⚠️ Çekilemeyen ({len(failed)}): " + ", ".join(failed)
-                    return x, path, msg
-
-                def do_filter(*a):
-                    x, path = apply_filters(*a)
-                    return x, path
-
-                scan_btn.click(do_scan, [force, perp, nuni, extra] + PI + FI, [table, csv, status])
-                f_btn.click(do_filter, FI, [table, csv])
-
-            with gr.Tab("🔍 Asset Analysis"):
-                with gr.Row():
-                    t1 = gr.Textbox(value="BTC", label="Parite (örn: BTC, ETH-USDT)", scale=2)
-                    b1 = gr.Button("Analyze", variant="primary")
-                md1 = gr.Markdown()
-                with gr.Row():
-                    p1 = gr.Plot()
-                    r1 = gr.Plot()
-
-                def company(t, *a):
-                    P = mk_params(*a)
-                    A, err = get_A(t, P)
-                    if err:
-                        return err, None, None
-                    d = A["d"]
-                    return md_report(A, P), price_fig(d, {"Fair value": A["iv"], "VWAP365": d.get("vwap365"), "SMA200": d.get("sma200")}), radar_fig(A)
-
-                b1.click(company, [t1] + PI, [md1, p1, r1])
-
-            with gr.Tab("🧮 Fair Value Calculator"):
-                with gr.Row():
-                    t2 = gr.Textbox(value="ETH", label="Parite", scale=2)
-                    b2 = gr.Button("Calculate", variant="primary")
-                md2 = gr.Markdown()
-                p2 = gr.Plot()
-
-                def calc(t, *a):
-                    P = mk_params(*a)
-                    A, err = get_A(t, P)
-                    if err:
-                        return err, None
-                    d = A["d"]
-                    g0, w, tg = assumptions(P)
-                    L = [f"### {d['sym']} — {d['seg']}",
-                         f"**Varsayımlar [A]:** yıl-1 nominal drift {fp(g0)} (reel {fp(P['rg'])}, enflasyon geçişi %{P['pt'] * 100:.0f}) · "
-                         f"nominal iskonto {fp(w)} · nominal terminal drift {fp(tg)}",
-                         f"**Fiyat çıpaları [D]:** Log-trend {fpx(d.get('trend_fair'))} · VWAP365 {fpx(d.get('vwap365'))} · SMA200 {fpx(d.get('sma200'))} "
-                         f"→ DEP çıpası (medyan) **{fpx(anchor_of(d))}**",
-                         f"**Trend [D]:** yıllık log-trend drift {fp(d.get('trend_g'))} · fiyatın trende göre sapması z={fm(d.get('trend_z'))}σ"]
-                    L.append("\n| Yöntem | Değer | Not |\n|---|---|---|")
-                    for k, (v, n) in A["methods"].items():
-                        L.append(f"| {k} | {fpx(v)} | {n} |")
-                    L.append(f"\n**Fair value (medyan): {fpx(A['iv'])}** · Fiyat {fpx(d['price'])} · MoS {fp(A['mos'])}")
-                    names = [k for k, (v, _) in A["methods"].items() if v]
-                    vals = [A["methods"][k][0] for k in names]
-                    f = go.Figure(go.Bar(x=["Price"] + names + ["Fair value"], y=[d["price"]] + vals + [A["iv"] or 0]))
-                    f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
-                    return "\n".join(L), f
-
-                b2.click(calc, [t2] + PI, [md2, p2])
-
-            with gr.Tab("↩️ Reverse Valuation"):
-                with gr.Row():
-                    t3 = gr.Textbox(value="SOL", label="Parite", scale=2)
-                    b3 = gr.Button("Solve", variant="primary")
-                md3 = gr.Markdown()
-                tb3 = gr.Dataframe(interactive=False)
-
-                def rev(t, *a):
-                    P = mk_params(*a)
-                    A, err = get_A(t, P)
-                    if err:
-                        return err, None
-                    d = A["d"]
-                    rows, note = reverse_dcf(d, P)
-                    if rows is None:
-                        return f"**{d['sym']}**: ⚠️ {note}", None
-                    g0, _, _ = assumptions(P)
-                    md = (f"**{d['sym']}** fiyat {fpx(d['price'])} → piyasanın fiyatladığı yıl-1 drift (5 yıl, terminale doğru sönümlenir; çıpa {fpx(anchor_of(d))}).\n\n"
-                          f"Mevcut varsayım yıl-1 drift: {fp(g0)} · Tarihsel log-trend drift (yıllık): {fp(d.get('trend_g'))} · "
-                          f"Son 365g getiri: {fp(d.get('ret365'))}\n\n"
-                          "Not: Zorunlu bir 'doğru' yoktur; implied drift makul görünmüyorsa piyasa beklentisi ya aşırı iyimser ya da kötümserdir.")
-                    return md, pd.DataFrame(rows)
-
-                b3.click(rev, [t3] + PI, [md3, tb3])
-
-            with gr.Tab("💎 Market Quality"):
-                with gr.Row():
-                    t4 = gr.Textbox(value="BTC", label="Parite", scale=2)
-                    b4 = gr.Button("Show", variant="primary")
-                md4 = gr.Markdown()
-                tb4 = gr.Dataframe(interactive=False)
-                tb4b = gr.Dataframe(interactive=False)
-
-                def qual(t, *a):
-                    P = mk_params(*a)
-                    A, err = get_A(t, P)
-                    if err:
-                        return err, None, None
-                    q, d = A["q"], A["d"]
-                    pc = lambda x: fp(x)
-                    rows = [("Return 30d [D]", pc(q["ret30"])), ("Return 90d [D]", pc(q["ret90"])), ("Return 365d [D]", pc(q["ret365"])),
-                            ("Return 365d (reel) [D]", pc(real_ret(q["ret365"], P["infl"]))),
-                            ("Volatility 30d (ann.) [D]", pc(q["vol30"])), ("Volatility 90d (ann.) [D]", pc(q["vol90"])),
-                            ("Volatility 365d (ann.) [D]", pc(q["vol365"])), ("Sharpe 1Y (rf=0) [D]", fm(q["sharpe"])),
-                            ("Sortino 1Y [D]", fm(q["sortino"])), ("Max drawdown 1Y [D]", pc(q["maxdd"])),
-                            ("Drawdown from 1Y high [D]", pc(q["dd_high"])), ("SMA50 / SMA200 gap [D]", pc(q["sma_gap"])),
-                            ("Trend z-score [D]", fm(q["trend_z"])), ("Spread (bps) [R]", fm(q["spread_bps"], 1)),
-                            ("Avg daily volume 30d (M USDT) [R]", fm(None if q["vq30"] is None else q["vq30"] / 1e6, 1)),
-                            ("Volume 30d / 90d [D]", fm(q["vol_ratio"])), ("Volume variation (CV) [D]", fm(q["vcv"])),
-                            ("Worst day (90d) [D]", pc(q["worst90"])), ("Daily VaR95 (90d) [D]", pc(q["var95"])),
-                            ("Funding (8h) [R]", fp(d["funding"], 4)), ("History (days) [R]", fm(q["hist_days"], 0))]
-                    sc, n, comps = A["pio"]
-                    cp = [(c, "N/A" if v is None else ("1" if v else "0")) for c, v in comps]
-                    md = (f"**{d['sym']}** — Market health: **{sc}/{n}** (hesaplanabilen {n}/9)" +
-                          ("" if n == 9 else " ⚠️ eksik bileşen var; skor tam değildir.") +
-                          (" Perp bulunmayan varlıklarda funding bileşeni N/A olur." if d["funding"] is None else ""))
-                    return md, pd.DataFrame(rows, columns=["Metric", "Value"]), pd.DataFrame(cp, columns=["Health component", "Result"])
-
-                b4.click(qual, [t4] + PI, [md4, tb4, tb4b])
-
-            with gr.Tab("🛡️ Risk Analysis"):
-                with gr.Row():
-                    t5 = gr.Textbox(value="DOGE", label="Parite", scale=2)
-                    b5 = gr.Button("Assess", variant="primary")
-                md5 = gr.Markdown()
-                tb5 = gr.Dataframe(interactive=False)
-
-                def risk_tab(t, *a):
-                    P = mk_params(*a)
-                    A, err = get_A(t, P)
-                    if err:
-                        return err, None
-                    rows = [{"Flag": n, "Weight": w, "Status": s or "N/A", "Rule": dt} for n, w, s, dt in A["flags"]]
-                    return (f"**{A['d']['sym']}** Risk skoru: **{fm(A['risk'], 0)}/100** (yalnızca değerlendirilebilen bayraklar üzerinden; "
-                            f"düşük = iyi). Coverage {fp(A['cov'], 0)}."), pd.DataFrame(rows)
-
-                b5.click(risk_tab, [t5] + PI, [md5, tb5])
-
-            with gr.Tab("🏭 Category Comparison"):
-                with gr.Row():
-                    t6 = gr.Textbox(value="SOL", label="Parite (opsiyonel)", scale=2)
-                    b6 = gr.Button("Compare", variant="primary")
-                md6 = gr.Markdown()
-                tb6 = gr.Dataframe(interactive=False)
-                p6 = gr.Plot()
-
-                def sector(t, *a):
-                    P = mk_params(*a)
-                    ds = cached_ds()
-                    if not ds:
-                        return "Önce Market Scanner'ı çalıştırın (medyanlar önbellekteki paritelerden hesaplanır).", None, None
-                    med = build_medians(ds)
-                    rows = []
-                    for seg, m in sorted(med.items()):
-                        r = {"Segment": seg, "Peers": sum(1 for d in ds if d["seg"] == seg)}
-                        for f in MULTS:
-                            v, n = m[f]
-                            r[f] = None if v is None else round(v, 3)
-                        rows.append(r)
-                    fig, md = None, (f"Kategori medyanı için en az {MIN_PEERS} geçerli peer gerekir; yetersizse `None`. "
-                                     "p_vwap = fiyat/VWAP365, p_sma200 = fiyat/SMA200, p_trend = fiyat/log-trend, p_high = fiyat/1Y zirve.")
-                    d = fetch(norm_sym(t)) if t.strip() else None
-                    if d:
-                        m = med.get(d["seg"])
-                        keys = ["p_vwap", "p_sma200", "p_trend", "p_high"]
-                        cv_ = [d[k] for k in keys]
-                        mv = [m[k][0] if m else None for k in keys]
-                        fig = go.Figure([go.Bar(name=d["sym"], x=keys, y=cv_), go.Bar(name="Category median", x=keys, y=mv)])
-                        fig.update_layout(barmode="group", template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
-                        md = f"**{d['sym']}** — {d['seg']} / {d['sector']}. " + md
-                    return md, pd.DataFrame(rows), fig
-
-                b6.click(sector, [t6] + PI, [md6, tb6, p6])
-
-            with gr.Tab("🎯 12-Month Scenarios"):
-                with gr.Row():
-                    t7 = gr.Textbox(value="BTC", label="Parite", scale=2)
-                    pb = gr.Slider(0, 100, 25, step=5, label="Bear olasılığı (%)")
-                    pm = gr.Slider(0, 100, 50, step=5, label="Base olasılığı (%) — Bull = kalan")
-                    b7 = gr.Button("Run", variant="primary")
-                md7 = gr.Markdown()
-                tb7 = gr.Dataframe(interactive=False)
-                p7 = gr.Plot()
-
-                def scen(t, bear, base, *a):
-                    P = mk_params(*a)
-                    pr = validate_probs(bear, base)
-                    if pr is None:
-                        return "⚠️ Bear + Base 100'ü aşamaz (Bull = 100 − Bear − Base).", None, None
-                    A, err = get_A(t, P, pr)
-                    if err:
-                        return err, None, None
-                    d, e = A["d"], A["exp"]
-                    rows = [{"Scenario": o["Scenario"], "Real growth": o["Real growth"], "Real disc. rate": o["Real disc. rate"],
-                             "Multiple factor": o["Multiple factor"], "Fair value": rsig(o["Intrinsic"]),
-                             "12M target": rsig(o["Target"]), "Probability": f"{o['Prob'] * 100:.0f}%"} for o in A["scen"]]
-                    if e is None:
-                        return f"**{d['sym']}**: ⚠️ Senaryo üretilemedi (fair value hesaplanamadı).", pd.DataFrame(rows), None
-                    md = (f"**{d['sym']}** · Olasılık-ağırlıklı hedef **{fpx(e['pw'])}** · Beklenen nominal fiyat getirisi {fp(e['nominal'])} · "
-                          f"Reel getiri {fp(e['real'])} (spot: temettü/gelir yok, getiri yalnızca fiyat)\n\n"
-                          f"*Heuristik: hedef = fiyat + k×(senaryo değeri − fiyat), k={P['conv'] * 100:.0f}%, çarpan faktörü uygulanır. "
-                          "İstatistiksel olarak doğrulanmış tahmin değildir.*")
-                    f = go.Figure(go.Bar(x=["Price", "Bear", "Base", "Bull", "Prob-weighted"],
-                                         y=[d["price"]] + [o["Target"] for o in A["scen"]] + [e["pw"]]))
-                    f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
-                    return md, pd.DataFrame(rows), f
-
-                b7.click(scen, [t7, pb, pm] + PI, [md7, tb7, p7])
-
-            with gr.Tab("📋 Data Quality Monitor"):
-                b8 = gr.Button("Check Data Quality", variant="primary")
-                md8 = gr.Markdown()
-                tb8 = gr.Dataframe(interactive=False, wrap=True)
-
-                def dq(progress=gr.Progress()):
-                    uni = LAST["universe"] or build_universe(DEFAULT_UNIVERSE_N)[0]
-                    rows, failed = [], []
-                    for i, s in enumerate(uni):
-                        progress((i + 1) / len(uni), desc=f"Checking {s}")
-                        was = _cget(f"t_{s}") is not None
-                        d = fetch(s)
-                        if d is None:
-                            failed.append(s)
-                            continue
-                        c = coverage(d)
-                        rows.append({"Pair": d["sym"], "Segment": d["seg"], "Coverage %": round(c * 100),
-                                     "Last candle": d["last_dt"].date().isoformat() if d["last_dt"] is not None else "N/A",
-                                     "Age (h)": round(d["age_h"]), "History (days)": d["hist_days"],
-                                     "Status": "OK" if c >= 0.7 and not d["flags"] else "CHECK",
-                                     "Flags": "; ".join(d["flags"] + d["notes"]) or "—"})
-                        if not was:
-                            time.sleep(REQUEST_DELAY_SEC * 0.5)
-                    df = pd.DataFrame(rows)
-                    avg = f"{df['Coverage %'].mean():.0f}%" if not df.empty else "N/A"
-                    return (f"Ortalama coverage: **{avg}** · Başarılı {len(rows)} · Çekilemeyen {len(failed)}: "
-                            + (", ".join(failed) or "—")), df
-
-                b8.click(dq, None, [md8, tb8])
-
-            with gr.Tab("📐 Methodology"):
-                gr.Markdown(METHODOLOGY)
-                b9 = gr.Button("Run self-test (synthetic data)")
-                o9 = gr.Textbox(label="Self-test", lines=18, interactive=False)
-                b9.click(self_test, None, o9)
-    return demo
-
-
-METHODOLOGY = """
-### Veri
-- **Kaynak:** yalnızca OKX public API (anahtar gerekmez): spot ticker (fiyat, bid/ask, 24s hacim), 500 günlük **günlük mumlar** (UTC), perp **funding rate** ve **open interest**.
-- **Evren:** 24s USDT hacmine göre ilk N OKX spot USDT paritesi (stablecoin ve kaldıraçlı tokenlar hariç, min 1M USDT/24s) + eklediğiniz pariteler. Ticker listesi alınamazsa gömülü yedek liste kullanılır.
-- Metrikler yalnızca **kapanmış** günlük mumlardan hesaplanır; canlı fiyat ticker'dan gelir.
-
-### Değerleme mimarisi (fundamental yoktur → fiyat-bazlı fair value)
-- **Log-Trend Regression:** son ≤500 günün ln(fiyat) doğrusal regresyonunun bugünkü değeri; yıllık trend drift'i ve fiyatın trendden σ cinsinden sapması (z) raporlanır.
-- **VWAP 365D:** hacim-ağırlıklı ortalama fiyat (yatırımcı maliyet bazı vekili). **SMA 200D:** uzun vadeli ortalama.
-- **Discounted Expected Price (DEP):** DCF'in nakit akışsız karşılığı. Çıpa = (trend, VWAP, SMA200) medyanı; 5 yıl boyunca yıl-1 drift'inden terminal drift'e doğrusal sönen büyüme uygulanır, gereken getiri (iskonto) ile bugüne indirgenir. Çıpa eksikse veya iskonto ≤ terminal drift ise **hesaplanmaz**.
-- **Relative:** kategori medyanı (en az 5 geçerli peer) p_vwap, p_sma200, p_trend çarpanları × varlığın kendi VWAP/SMA200/trend değeri.
-- **Fair value = mevcut yöntemlerin medyanı.** MoS = (FV − fiyat)/FV. Bu bir içsel değer değil, istatistiksel referanstır.
-- **Reverse Valuation:** fiyatı veren yıl-1 drift (bisection), iskonto oranı ±3 puan duyarlılığı.
-- **Enflasyon:** iskonto ve terminal drift reel girilir, nominale çevrilir; enflasyonun yalnızca ayarlanabilir bir kısmı drift'e yansır. Reel getiri = (1+nominal)/(1+enflasyon) − 1.
-- **Senaryolar:** Bear/Base/Bull = reel drift ∓4 puan, reel iskonto +3/−2 puan, çarpan faktörü 0.85/1.0/1.10; hedef = fiyat + k×(değer − fiyat). Olasılıklar ayarlanabilir, toplam %100 (Bull = kalan). Spot'ta temettü/gelir olmadığından getiri yalnızca fiyattır.
-
-### Skorlama (0-100, açıklanabilir)
-Composite = ağırlıklı ortalama (mevcut bileşenler üzerinden yeniden normalize) × min(1, coverage/0.7).
-| Segment | Valuation | Quality | Strength | Risk (ters) |
-|---|---|---|---|---|
-| Majors | 30 | 25 | 25 | 20 |
-| Meme | 25 | 15 | 20 | 40 |
-| Diğer (Alt L1, DeFi, Infra/L2, AI/Gaming, Other) | 30 | 25 | 20 | 25 |
-
-- **Valuation:** MoS, göreli MoS, trend z-score, fiyat/SMA200, 1Y zirveden iskonto.
-- **Quality:** reel 365g getiri, Sharpe, Sortino, max drawdown, reel 90g getiri, hacim istikrarı.
-- **Strength:** likidite (30g ort. hacim), spread, geçmiş uzunluğu, volatilite rejimi, market health skoru.
-- **Market Health (9 bileşen, Piotroski benzeri):** fiyat>SMA200, SMA50>SMA200, 90g getiri>0, volatilite düşüyor, hacim küçülmüyor, zirveden düşüş<%40, Sharpe>0, spread<10bps, funding kalabalık değil. Hesaplanamayan bileşen "N/A" olur ve skor `x/n` gösterilir.
-- **Risk (0-100):** 11 bayrak (aşırı volatilite, derin drawdown, düşüş trendi, ince likidite, geniş spread, hacim çöküşü, crash günü, VaR95, aşırı uzama, funding kalabalığı, veri güvenilirliği); yalnızca değerlendirilebilen bayrakların ağırlığı üzerinden hesaplanır.
-
-### Bilinen veri sınırlamaları
-- Fundamental/on-chain/market-cap verisi yoktur; fair value yalnızca fiyat-hacim geçmişine dayanır ve geçmiş trendin sürmesini ima etmez.
-- Yeni listelenen paritelerde geçmiş kısadır (SMA200/VWAP/trend hesaplanamayabilir → N/A, düşük coverage).
-- Kategori sınıflaması gömülü bir haritaya dayanır; haritada olmayan varlıklar "Other" olur. Peer sayısı <5 ise medyan hesaplanmaz.
-- OKX public API hız limitine tabidir; tarama sırasında istekler yavaşlatılır, 429/50011 hatalarında tekrar denenir.
-- Sonuçlar araştırma/eğitim amaçlıdır, yatırım tavsiyesi değildir.
-"""
 
 if __name__ == "__main__":
-    logger.info("Self-test:\n%s", self_test())
-    build_ui().launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)