Update app.py

app.py

@@ -1,985 +1,1068 @@
-"""
-Tickscope MCP + ML tahmin uygulaması (Gradio)
-
-Kurulum:
-    pip install gradio mcp pandas numpy scikit-learn plotly
-    # uv gerekli (uvx tickscope-mcp için):  pip install uv   veya https://docs.astral.sh/uv/
-Çalıştırma:
-    python app.py
-
-Akış:
-    1) uvx tickscope-mcp'yi stdio MCP sunucusu olarak başlatır
-    2) get_ohlcv ile mum verisini çeker
-    3) compute_indicators / deep_analyze çıktısını (varsa) Tickscope'tan alır
-    4) Yerel HistGradientBoosting modeli ile N bar sonrası yön olasılığı + aralık tahmini üretir
-
-Not: Eğitim/araştırma amaçlıdır, yatırım tavsiyesi değildir.
-"""
 
-import asyncio
-import json
-import math
-import os
+import warnings
+warnings.filterwarnings("ignore")
 
-import gradio as gr
+import time
 import numpy as np
 import pandas as pd
-import plotly.graph_objects as go
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
-from sklearn.ensemble import ExtraTreesClassifier, HistGradientBoostingClassifier
+import ccxt
+import gradio as gr
+
+from sklearn.ensemble import (
+    ExtraTreesClassifier,
+    HistGradientBoostingClassifier
+)
 from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import roc_auc_score
-from sklearn.pipeline import make_pipeline
+from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
-
-def _launcher():
-    """PATH'te uvx yoksa sırayla alternatifleri dener."""
-    import importlib.util
-    import shutil
-    import sys
-
-    if shutil.which("uvx"):
-        return "uvx", ["tickscope-mcp"]
-    if shutil.which("tickscope-mcp"):  # pip install tickscope-mcp
-        return "tickscope-mcp", []
-    if importlib.util.find_spec("uv"):  # pip install uv -> python -m uv
-        return sys.executable, ["-m", "uv", "tool", "run", "tickscope-mcp"]
-    raise RuntimeError("Tickscope başlatılamadı. Çalıştır: pip install tickscope-mcp")
-
-
-_CMD, _ARGS = _launcher()
-
-SERVER = StdioServerParameters(
-    command=_CMD,
-    args=_ARGS,
-    env={
-        **os.environ,
-        "TICKSCOPE_EXCHANGES": "binance,bybit,okx",
-        "TICKSCOPE_DEFAULT_EXCHANGE": "binance",
-    },
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import (
+    accuracy_score,
+    balanced_accuracy_score,
+    roc_auc_score
 )
 
-# Tool şemasındaki argüman adları sürümler arası değişebilir; şemaya bakıp eşleştiriyoruz.
-ALIASES = {
-    "symbol": ["symbol", "pair"],
-    "timeframe": ["timeframe", "interval", "tf", "period"],
-    "exchange": ["exchange"],
-    "limit": ["limit", "count", "n", "bars"],
-    "until": ["until", "end", "end_time", "endTime", "to", "before"],
-    "include_series": ["include_series", "includeSeries", "series", "with_series"],
-}
-
-EXTRA_TOOLS = ["detect_divergence", "detect_patterns", "analyze_structure",
-               "find_support_resistance", "detect_cross", "get_orderbook",
-               "get_ticker", "get_recent_trades", "server_status"]
-
-TF_MS = {"1m": 60_000, "5m": 300_000, "15m": 900_000, "1h": 3_600_000,
-         "4h": 14_400_000, "1d": 86_400_000}
-
-
-# ----------------------------------------------------------------- MCP yardımcıları
-def build_args(tool, **wanted):
-    props = (tool.inputSchema or {}).get("properties", {})
-    out = {}
-    for key, val in wanted.items():
-        if val in (None, ""):
-            continue
-        for name in ALIASES.get(key, [key]):
-            if name in props:
-                out[name] = val
-                break
-    return out
-
-
-async def call_tool(session, tools, name, **wanted):
-    tool = tools.get(name)
-    if tool is None:
-        return None
-    res = await session.call_tool(name, build_args(tool, **wanted))
-    text = "\n".join(getattr(c, "text", "") for c in res.content)
-    if res.isError:
-        return {"error": text}
-    if getattr(res, "structuredContent", None):
-        return res.structuredContent
-    try:
-        return json.loads(text)
-    except Exception:
-        return {"text": text}
-
-
-async def fetch_ohlcv(session, tools, symbol, timeframe, exchange, total):
-    """Borsa sayfa limiti (~1000) yüzünden geriye doğru sayfalayarak `total` muma kadar çeker.
-    Tool bitiş-zamanı parametresi desteklemiyorsa ilk sayfayla yetinir."""
-    tool = tools.get("get_ohlcv")
-    if tool is None:
-        return None
-    page = min(1000, total)
-    first = await call_tool(session, tools, "get_ohlcv", symbol=symbol,
-                            timeframe=timeframe, exchange=exchange, limit=page)
-    if first is None or (isinstance(first, dict) and "error" in first) or total <= page:
-        return first
-    props = (tool.inputSchema or {}).get("properties", {})
-    if not any(n in props for n in ALIASES["until"]):
-        return first  # sayfalama desteklenmiyor
-    try:
-        frames = [to_df(first)]
-    except Exception:
-        return first
-    got = len(frames[0])
-    epoch = pd.Timestamp("1970-01-01")
-    while got < total:
-        oldest = frames[-1]["ts"].iloc[0]
-        end_ms = int((oldest - epoch) // pd.Timedelta("1ms")) - 1
-        try:
-            res = await call_tool(session, tools, "get_ohlcv", symbol=symbol, timeframe=timeframe,
-                                  exchange=exchange, limit=page, until=end_ms)
-        except Exception:  # noqa: BLE001  (ör. Connection closed) -> eldeki sayfalarla devam
-            break
-        if res is None or (isinstance(res, dict) and "error" in res):
+
+# =========================================================
+# CONFIG
+# =========================================================
+
+SYMBOL = "BTC/USDT"
+
+FEATURES = [
+    "rsi",
+    "macd_pct",
+    "macd_signal_pct",
+    "macd_hist_pct",
+    "supertrend_direction",
+    "supertrend_distance",
+    "vwap_distance",
+    "atr_pct",
+    "return_1",
+    "return_3",
+    "return_6",
+    "volatility_14",
+    "volume_ratio",
+    "body_pct",
+    "high_low_pct"
+]
+
+
+# =========================================================
+# BINANCE DATA
+# =========================================================
+
+def fetch_data(timeframe="1h", candles=2000):
+
+    exchange = ccxt.binance({
+        "enableRateLimit": True,
+        "timeout": 20000
+    })
+
+    timeframe_ms = exchange.parse_timeframe(timeframe) * 1000
+
+    since = exchange.milliseconds() - candles * timeframe_ms
+    all_rows = []
+
+    while len(all_rows) < candles:
+
+        remaining = candles - len(all_rows)
+        limit = min(1000, remaining)
+
+        batch = exchange.fetch_ohlcv(
+            SYMBOL,
+            timeframe=timeframe,
+            since=since,
+            limit=limit
+        )
+
+        if not batch:
             break
-        try:
-            d = to_df(res)
-        except Exception:
+
+        all_rows.extend(batch)
+
+        last_timestamp = batch[-1][0]
+        new_since = last_timestamp + timeframe_ms
+
+        if new_since <= since:
             break
-        d = d[d["ts"] < oldest]
-        if d.empty:
+
+        since = new_since
+
+        if len(batch) < limit:
             break
-        frames.append(d)
-        got += len(d)
-    out = pd.concat(frames[::-1]).drop_duplicates("ts").sort_values("ts").tail(total)
-    return out.to_dict("records")
-
-
-# ----------------------------------------------------------------- 2. MCP: LiquidVision (türev verisi)
-# Uzak (HTTP) MCP, kurulum yok: https://liquidvision.app/mcp
-#  - Anahtarsız: yalnızca "sonuç" araçları (brief, positioning regime, cascades...) -> canlı bağlam.
-#  - Funding / OI GEÇMİŞİ (eğitim özelliği) ham-satır araçlarıdır; Pro/Bot anahtarı ister:
-#        LIQUIDVISION_API_KEY=lv_...   (X-API-Key olarak gönderilir)
-DERIV_URL = os.environ.get("LIQUIDVISION_URL", "https://liquidvision.app/mcp")
-DERIV_KEY = os.environ.get("LIQUIDVISION_API_KEY", "")
-LIVE_TOOLS = ["get_market_brief", "get_positioning_regime", "get_liquidation_cascades",
-              "get_microstructure", "get_funding_arbitrage", "get_funding_dispersion"]
-
-
-def _usdt(symbol):
-    """BTC/USDT veya BTC/USDT:USDT -> BTCUSDT"""
-    return symbol.strip().upper().split(":")[0].replace("/", "")
-
-
-def _find_rows(o):
-    if isinstance(o, list) and len(o) >= 5 and all(isinstance(x, dict) for x in o[:3]):
-        return o
-    if isinstance(o, dict):
-        for v in o.values():
-            r = _find_rows(v)
-            if r:
-                return r
-    return None
-
-
-def parse_series(payload, vkeys):
-    """Geçmiş çıktısında (şemadan bağımsız) zaman + değer kolonlarını bulup ts/v tablosu döndürür."""
-    rows = _find_rows(payload)
-    if not rows:
-        return None
-    d = pd.DataFrame(rows)
-    tcol = next((c for c in ("timestamp", "time", "ts", "t", "datetime", "fundingTime", "ts_ms", "hour", "bucket")
-                 if c in d), None)
-    vcol = next((c for c in vkeys if c in d), None)
-    if tcol is None or vcol is None:
-        return None
-    ts = d[tcol]
-    if pd.api.types.is_numeric_dtype(ts):
-        ts = pd.to_datetime(ts, unit="ms" if ts.iloc[-1] > 1e11 else "s")
-    else:
-        ts = pd.to_datetime(ts)
-    if getattr(ts.dt, "tz", None) is not None:
-        ts = ts.dt.tz_convert(None)
-    out = pd.DataFrame({"ts": ts.astype("datetime64[ns]"), "v": pd.to_numeric(d[vcol], errors="coerce")})
-    return out.dropna().drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
-
-
-def _funding_feats(f):
-    r = f["v"]
-    f["fund"] = r * 1e4                                     # baz puan
-    f["fund_z"] = (r - r.rolling(30).mean()) / (r.rolling(30).std() + 1e-12)
-    f["fund_chg"] = r.diff() * 1e4
-    f["fund_ma9"] = r.rolling(9).mean() * 1e4
-    return f.drop(columns=["v"]).dropna().reset_index(drop=True)
-
-
-def _oi_feats(f):
-    o = f["v"]
-    for k in (1, 4, 24):
-        f[f"oi_chg{k}"] = o.pct_change(k)
-    f["oi_z"] = (o - o.rolling(48).mean()) / (o.rolling(48).std() + 1e-12)
-    return f.drop(columns=["v"]).replace([np.inf, -np.inf], np.nan).dropna().reset_index(drop=True)
-
-
-async def fetch_deriv_features(symbol, exchange, timeframe, df):
-    """LiquidVision MCP'den canlı bağlam (ham çıktıya) + funding/OI geçmişi (özellik) çeker.
-    Dönen: (özellik tablosu | None, df (geçmiş kapsamına kırpılmış olabilir), ham çıktı sözlüğü)."""
-    extra = {}
-    try:
-        from mcp.client.streamable_http import streamablehttp_client
-    except Exception as e:  # noqa: BLE001
-        extra["deriv_error"] = f"mcp sürümü streamable HTTP desteklemiyor: {_root(e)} (pip install -U mcp)"
-        return None, df, extra
-    headers = {"X-API-Key": DERIV_KEY} if DERIV_KEY else {}
-    sym = _usdt(symbol)
-    hist = {}
-    try:
-        async with streamablehttp_client(DERIV_URL, headers=headers) as (r, w, _):
-            async with ClientSession(r, w) as session:
-                await session.initialize()
-                tools = {t.name: t for t in (await session.list_tools()).tools}
-                extra["deriv_available_tools"] = list(tools)
-                for name in LIVE_TOOLS:
-                    if name in tools:
-                        try:
-                            extra[f"deriv_{name}"] = await call_tool(
-                                session, tools, name, symbol=sym, exchange=exchange)
-                        except Exception as e:  # noqa: BLE001
-                            extra[f"deriv_{name}"] = {"error": _root(e)}
-                for name in ("get_funding_history", "get_open_interest_history"):
-                    if name in tools:
-                        try:
-                            hist[name] = await call_tool(session, tools, name, symbol=sym, exchange=exchange,
-                                                         timeframe=timeframe, limit=1000)
-                        except Exception as e:  # noqa: BLE001
-                            hist[name] = {"error": _root(e)}
-    except Exception as e:  # noqa: BLE001
-        extra["deriv_error"] = _root(e)
-        return None, df, extra
-
-    specs = {
-        "get_funding_history": (("funding_rate", "fundingRate", "rate", "funding", "value"), _funding_feats),
-        "get_open_interest_history": (("open_interest", "oi", "openInterest", "oi_usd", "value"), _oi_feats),
+
+        time.sleep(exchange.rateLimit / 1000)
+
+    if not all_rows:
+        raise RuntimeError("Binance veri döndürmedi.")
+
+    df = pd.DataFrame(
+        all_rows,
+        columns=[
+            "timestamp",
+            "open",
+            "high",
+            "low",
+            "close",
+            "volume"
+        ]
+    )
+
+    df = df.drop_duplicates("timestamp")
+    df = df.sort_values("timestamp")
+
+    df["timestamp"] = pd.to_datetime(
+        df["timestamp"],
+        unit="ms",
+        utc=True
+    )
+
+    df = df.set_index("timestamp")
+
+    for col in ["open", "high", "low", "close", "volume"]:
+        df[col] = pd.to_numeric(df[col], errors="coerce")
+
+    df = df.dropna()
+
+    # Son mum henüz tamamlanmamış olabilir.
+    if len(df) > 2:
+        df = df.iloc[:-1]
+
+    return df.tail(candles)
+
+
+# =========================================================
+# INDICATOR CALCULATIONS
+# =========================================================
+
+def calculate_indicators(df):
+
+    df = df.copy()
+
+    # -----------------------------------------------------
+    # ATR - Wilder RMA
+    # -----------------------------------------------------
+
+    previous_close = df["close"].shift(1)
+
+    tr = pd.concat([
+        df["high"] - df["low"],
+        (df["high"] - previous_close).abs(),
+        (df["low"] - previous_close).abs()
+    ], axis=1).max(axis=1)
+
+    df["atr"] = tr.ewm(
+        alpha=1 / 10,
+        adjust=False,
+        min_periods=10
+    ).mean()
+
+    # -----------------------------------------------------
+    # RSI 14
+    # -----------------------------------------------------
+
+    delta = df["close"].diff()
+
+    gain = delta.clip(lower=0)
+    loss = -delta.clip(upper=0)
+
+    avg_gain = gain.ewm(
+        alpha=1 / 14,
+        adjust=False,
+        min_periods=14
+    ).mean()
+
+    avg_loss = loss.ewm(
+        alpha=1 / 14,
+        adjust=False,
+        min_periods=14
+    ).mean()
+
+    rs = avg_gain / avg_loss.replace(0, np.nan)
+
+    df["rsi"] = 100 - (100 / (1 + rs))
+
+    # -----------------------------------------------------
+    # MACD 12,26,9
+    # -----------------------------------------------------
+
+    ema12 = df["close"].ewm(
+        span=12,
+        adjust=False
+    ).mean()
+
+    ema26 = df["close"].ewm(
+        span=26,
+        adjust=False
+    ).mean()
+
+    df["macd"] = ema12 - ema26
+
+    df["macd_signal"] = df["macd"].ewm(
+        span=9,
+        adjust=False
+    ).mean()
+
+    df["macd_hist"] = (
+        df["macd"] - df["macd_signal"]
+    )
+
+    # -----------------------------------------------------
+    # SUPERTREND 10,3
+    # -----------------------------------------------------
+
+    multiplier = 3.0
+
+    hl2 = (df["high"] + df["low"]) / 2
+
+    basic_upper = hl2 + multiplier * df["atr"]
+    basic_lower = hl2 - multiplier * df["atr"]
+
+    final_upper = basic_upper.copy()
+    final_lower = basic_lower.copy()
+
+    supertrend = pd.Series(
+        np.nan,
+        index=df.index
+    )
+
+    direction = pd.Series(
+        1,
+        index=df.index,
+        dtype=float
+    )
+
+    for i in range(1, len(df)):
+
+        previous_upper = final_upper.iloc[i - 1]
+        previous_lower = final_lower.iloc[i - 1]
+        previous_close_value = df["close"].iloc[i - 1]
+
+        current_upper = basic_upper.iloc[i]
+        current_lower = basic_lower.iloc[i]
+
+        if (
+            current_upper < previous_upper
+            or previous_close_value > previous_upper
+        ):
+            final_upper.iloc[i] = current_upper
+        else:
+            final_upper.iloc[i] = previous_upper
+
+        if (
+            current_lower > previous_lower
+            or previous_close_value < previous_lower
+        ):
+            final_lower.iloc[i] = current_lower
+        else:
+            final_lower.iloc[i] = previous_lower
+
+        previous_direction = direction.iloc[i - 1]
+        current_close = df["close"].iloc[i]
+
+        if previous_direction == -1:
+
+            if current_close > final_upper.iloc[i]:
+                direction.iloc[i] = 1
+            else:
+                direction.iloc[i] = -1
+
+        else:
+
+            if current_close < final_lower.iloc[i]:
+                direction.iloc[i] = -1
+            else:
+                direction.iloc[i] = 1
+
+        if direction.iloc[i] == 1:
+            supertrend.iloc[i] = final_lower.iloc[i]
+        else:
+            supertrend.iloc[i] = final_upper.iloc[i]
+
+    df["supertrend"] = supertrend
+    df["supertrend_direction"] = direction
+
+    # -----------------------------------------------------
+    # VWAP - UTC DAILY RESET
+    # -----------------------------------------------------
+
+    typical_price = (
+        df["high"] + df["low"] + df["close"]
+    ) / 3
+
+    daily_group = df.index.date
+
+    pv = typical_price * df["volume"]
+
+    cumulative_pv = pv.groupby(daily_group).cumsum()
+
+    cumulative_volume = (
+        df["volume"].groupby(daily_group).cumsum()
+    )
+
+    df["vwap"] = (
+        cumulative_pv /
+        cumulative_volume.replace(0, np.nan)
+    )
+
+    # -----------------------------------------------------
+    # ADDITIONAL FEATURES
+    # -----------------------------------------------------
+
+    df["macd_pct"] = df["macd"] / df["close"] * 100
+
+    df["macd_signal_pct"] = (
+        df["macd_signal"] / df["close"] * 100
+    )
+
+    df["macd_hist_pct"] = (
+        df["macd_hist"] / df["close"] * 100
+    )
+
+    df["supertrend_distance"] = (
+        df["close"] - df["supertrend"]
+    ) / df["close"] * 100
+
+    df["vwap_distance"] = (
+        df["close"] - df["vwap"]
+    ) / df["close"] * 100
+
+    df["atr_pct"] = df["atr"] / df["close"] * 100
+
+    df["return_1"] = df["close"].pct_change(1) * 100
+    df["return_3"] = df["close"].pct_change(3) * 100
+    df["return_6"] = df["close"].pct_change(6) * 100
+
+    df["volatility_14"] = (
+        df["return_1"].rolling(14).std()
+    )
+
+    volume_average = df["volume"].rolling(20).mean()
+
+    df["volume_ratio"] = (
+        df["volume"] /
+        volume_average.replace(0, np.nan)
+    )
+
+    df["body_pct"] = (
+        df["close"] - df["open"]
+    ) / df["open"] * 100
+
+    df["high_low_pct"] = (
+        df["high"] - df["low"]
+    ) / df["close"] * 100
+
+    return df
+
+
+# =========================================================
+# TARGET
+# =========================================================
+
+def prepare_dataset(df, horizon):
+
+    data = calculate_indicators(df)
+
+    future_close = data["close"].shift(-horizon)
+
+    data["target"] = (
+        future_close > data["close"]
+    ).astype(int)
+
+    # Son horizon mumunda gelecek hedefi bilinmez.
+    data = data.iloc[:-horizon].copy()
+
+    data = data.replace(
+        [np.inf, -np.inf],
+        np.nan
+    )
+
+    data = data.dropna(
+        subset=FEATURES + ["target", "atr"]
+    )
+
+    if len(data) < 500:
+        raise ValueError(
+            "Yeterli veri yok. Mum sayısını artır."
+        )
+
+    return data
+
+
+# =========================================================
+# MODELS
+# =========================================================
+
+def create_models():
+
+    models = {
+
+        "HistGradientBoosting":
+            HistGradientBoostingClassifier(
+                max_iter=180,
+                learning_rate=0.05,
+                max_leaf_nodes=15,
+                l2_regularization=2.0,
+                random_state=42
+            ),
+
+        "ExtraTrees":
+            ExtraTreesClassifier(
+                n_estimators=300,
+                max_depth=8,
+                min_samples_leaf=5,
+                max_features=0.8,
+                class_weight="balanced",
+                random_state=42,
+                n_jobs=-1
+            ),
+
+        "LogisticRegression":
+            Pipeline([
+                ("scaler", StandardScaler()),
+                ("model", LogisticRegression(
+                    C=0.2,
+                    max_iter=2000,
+                    class_weight="balanced",
+                    random_state=42
+                ))
+            ])
     }
-    feats = {}
-    for name, (vkeys, fn) in specs.items():
-        h = hist.get(name)
-        if h is None:
-            continue
-        if isinstance(h, dict) and "error" in h:
-            extra[f"deriv_{name}_error"] = _strip_series(h)
+
+    return models
+
+
+def ensemble_predict(X_train, y_train, X_test):
+
+    models = create_models()
+
+    probabilities = []
+
+    for name, model in models.items():
+
+        model.fit(X_train, y_train)
+
+        probability = model.predict_proba(X_test)[:, 1]
+
+        probabilities.append(probability)
+
+    ensemble_probability = np.mean(
+        probabilities,
+        axis=0
+    )
+
+    return ensemble_probability
+
+
+# =========================================================
+# WALK FORWARD VALIDATION
+# =========================================================
+
+def walk_forward_validation(X, y):
+
+    splitter = TimeSeriesSplit(n_splits=4)
+
+    scores = []
+    fold_results = []
+
+    for fold, (train_idx, test_idx) in enumerate(
+        splitter.split(X),
+        start=1
+    ):
+
+        X_train = X.iloc[train_idx]
+        X_test = X.iloc[test_idx]
+
+        y_train = y.iloc[train_idx]
+        y_test = y.iloc[test_idx]
+
+        if y_train.nunique() < 2:
             continue
-        s = parse_series(h, vkeys)
-        if s is None or len(s) < 80:
-            extra[f"deriv_{name}_raw"] = _strip_series(h)   # şema beklenenden farklı
+
+        probabilities = ensemble_predict(
+            X_train,
+            y_train,
+            X_test
+        )
+
+        predictions = (
+            probabilities >= 0.5
+        ).astype(int)
+
+        score = balanced_accuracy_score(
+            y_test,
+            predictions
+        )
+
+        scores.append(score)
+
+        fold_results.append(
+            f"Fold {fold}: {score * 100:.2f}%"
+        )
+
+    if not scores:
+        raise ValueError(
+            "Walk-forward validation yapılamadı."
+        )
+
+    return np.mean(scores), fold_results
+
+
+# =========================================================
+# BACKTEST
+# =========================================================
+
+def run_backtest(
+    raw,
+    test,
+    probabilities,
+    horizon,
+    threshold,
+    fee_pct
+):
+
+    trades = []
+
+    next_allowed_bar = -1
+
+    fee_rate = fee_pct / 100
+
+    for timestamp, row in test.iterrows():
+
+        raw_position = raw.index.get_loc(timestamp)
+
+        if raw_position < next_allowed_bar:
             continue
-        feats[name] = fn(s)
-    if not feats:
-        extra["deriv_note"] = ("Geçmiş özellik eklenmedi (ham-satır araçları için Pro/Bot anahtarı gerekir: "
-                               "LIQUIDVISION_API_KEY). Canlı bağlam ham çıktıda.")
-        return None, df, extra
-
-    # Geçmişin kapsamadığı eski mumları kırp; <800 bar kalıyorsa o seriyi at
-    usable = {k: v for k, v in feats.items() if (df["ts"] >= v["ts"].iloc[0]).sum() >= 800}
-    if not usable:
-        extra["deriv_note"] = "Geçmiş mum verisinin yalnızca küçük kısmını kapsıyor (<800 bar); özellik eklenmedi"
-        return None, df, extra
-    start = max(v["ts"].iloc[0] for v in usable.values())
-    d2 = df[df["ts"] >= start].reset_index(drop=True)
-    d2["ts"] = d2["ts"].astype("datetime64[ns]")
-    m = d2[["ts"]].copy()
-    for v in usable.values():
-        m = pd.merge_asof(m, v, on="ts", direction="backward")   # lookahead yok
-    m.index = d2.index
-    extra["deriv_used"] = {"seriler": list(usable), "baslangic": str(start), "bar": len(d2)}
-    return m.drop(columns=["ts"]).add_prefix("dv_"), d2, extra
-
-
-# compute_indicators'ın `indicators` parametresi ZORUNLUDUR ("rsi:14", "macd:12,26,9" biçiminde spec listesi).
-# 73 göstergenin adlarını bilmediğimiz için geniş bir aday listesi denenir; geçersiz adlar atlanır.
-IND_NAMES = [
-    "sma", "ema", "wma", "hma", "vwma", "dema", "tema", "zlema", "kama", "alma", "rma", "smma", "lsma", "vwap",
-    "bb", "bbands", "bollinger", "bbw", "bbp", "kc", "keltner", "donchian", "dc", "envelope", "ichimoku",
-    "supertrend", "psar", "sar", "rsi", "stochrsi", "stoch", "macd", "ppo", "roc", "mom", "momentum", "cci",
-    "willr", "williams", "ao", "awesome", "ac", "uo", "tsi", "trix", "cmo", "dpo", "kst", "coppock", "fisher",
-    "rvi", "mfi", "obv", "cmf", "ad", "adl", "eom", "fi", "force", "vpt", "nvi", "pvi", "kvo", "atr", "natr",
-    "tr", "stdev", "hv", "ulcer", "chop", "massindex", "adx", "dmi", "aroon", "vortex", "wavetrend", "wt",
-    "squeeze", "ttm", "heikinashi", "ha", "pivot", "zigzag", "linreg", "zscore", "cog", "bop", "qstick",
-    "pgo", "smi", "stc", "er", "efi",
-]
 
+        probability = float(
+            probabilities[test.index.get_loc(timestamp)]
+        )
 
-IND_CHUNK = 6
+        if probability >= threshold:
+            side = "LONG"
 
+        elif probability <= (1 - threshold):
+            side = "SHORT"
 
-async def fetch_indicators(symbol, timeframe, exchange, limit):
-    """Göstergeleri KÜÇÜK PARÇALAR halinde (her parça birkaç gösterge), ana oturumdan AYRI bir Tickscope sürecinde çeker.
-    Bir parça sunucuyu çökertirse ("Connection closed") yeni süreç açılır, o parçanın adları atlanır, kalanlarla devam edilir."""
-    out = {"by_indicator": {}, "failed": [], "mode": "chunked", "reconnects": 0, "last_error": None}
-    kw = dict(symbol=symbol, timeframe=timeframe, exchange=exchange, limit=limit, include_series=True)
-    chunks = [IND_NAMES[i:i + IND_CHUNK] for i in range(0, len(IND_NAMES), IND_CHUNK)]
-    i = 0
-    while i < len(chunks):
-        try:
-            async with stdio_client(SERVER) as (r, w):
-                async with ClientSession(r, w) as session:
-                    await session.initialize()
-                    tools = {t.name: t for t in (await session.list_tools()).tools}
-                    if "compute_indicators" not in tools:
-                        return None
-                    while i < len(chunks):
-                        names = chunks[i]
-                        res = await call_tool(session, tools, "compute_indicators", indicators=names, **kw)
-                        if isinstance(res, dict) and "error" not in res and extract_series(res, 0):
-                            out["by_indicator"][f"c{i}"] = res
-                        else:       # parçada geçersiz ad var: tek tek dene
-                            for name in names:
-                                r1 = await call_tool(session, tools, "compute_indicators", indicators=[name], **kw)
-                                if r1 is None or (isinstance(r1, dict) and "error" in r1):
-                                    out["failed"].append(name)
-                                else:
-                                    out["by_indicator"][name] = r1
-                        i += 1
-        except Exception as e:  # noqa: BLE001
-            out["reconnects"] += 1
-            out["last_error"] = _root(e)
-            out["failed"] += [n for n in chunks[i] if n not in out["by_indicator"]]   # çökertene dokunma, atla
-            i += 1
-            if out["reconnects"] > 6:
-                break
-    return out
-
-
-def _numeric_list(o, min_len):
-    return (isinstance(o, list) and len(o) >= min_len and
-            all(x is None or (isinstance(x, (int, float)) and not isinstance(x, bool)) for x in o[:50]))
-
-
-def extract_series(payload, n):
-    """compute_indicators çıktısında gezinip bar bazlı sayısal serileri bulur (şemadan bağımsız)."""
-    min_len = max(50, int(n * 0.5))
-    out = {}
-
-    def walk(o, path):
-        if isinstance(o, list):
-            if _numeric_list(o, min_len):
-                out[path] = o
-            elif len(o) >= min_len and all(isinstance(x, dict) for x in o[:3]):
-                for key in o[0]:
-                    vals = [r.get(key) if isinstance(r, dict) else None for r in o]
-                    if _numeric_list(vals, min_len) and key.lower() not in ("ts", "time", "timestamp", "t"):
-                        out[f"{path}.{key}"] = vals
-        elif isinstance(o, dict):
-            for k, v in o.items():
-                walk(v, f"{path}.{k}" if path else str(k))
-
-    walk(payload, "")
-    return out
-
-
-def indicator_features(ind, df: pd.DataFrame):
-    """Tickscope'un 73 göstergesinin zaman serilerini (varsa) df'e hizalı özellik tablosuna çevirir.
-    Fiyat seviyesi gibi duran (SMA/EMA/bant vb.) seriler kapanışa göre normalize edilir."""
-    if not isinstance(ind, dict) or "error" in ind:
-        return None
-    n = len(df)
-    close = df["close"].values
-    cols = {}
-    for path, vals in extract_series(ind, n).items():
-        s = pd.to_numeric(pd.Series(vals), errors="coerce").values.astype(float)
-        arr = np.full(n, np.nan)
-        m = min(len(s), n)
-        arr[-m:] = s[-m:]                      # seriler sondan hizalanır
-        if np.isnan(arr).all() or np.nanstd(arr) == 0:
+        else:
             continue
-        ref = np.nanmedian(close[-m:])
-        if ref and abs(np.nanmedian(arr) / ref - 1) < 0.5:   # fiyat seviyesi -> göreli mesafe
-            arr = arr / close - 1
-        name = "ts_" + "".join(ch if ch.isalnum() else "_" for ch in path).strip("_")
-        cols[name] = arr
-    if not cols:
-        return None
-    return pd.DataFrame(cols, index=df.index)
-
-
-def _strip_series(o, keep=3):
-    """Ham çıktıyı okunur tutmak için uzun serileri son `keep` değere kısaltır."""
-    if isinstance(o, list) and len(o) > 20:
-        return [f"... {len(o)} değer, son {keep}:"] + o[-keep:]
-    if isinstance(o, list):
-        return [_strip_series(x, keep) for x in o]
-    if isinstance(o, dict):
-        return {k: _strip_series(v, keep) for k, v in o.items()}
-    return o
-
-
-def to_df(payload) -> pd.DataFrame:
-    rows = payload
-    if isinstance(payload, dict):
-        for k in ("candles", "ohlcv", "data", "rows", "result"):
-            if k in payload:
-                rows = payload[k]
-                break
-    if not isinstance(rows, list) or not rows:
-        raise ValueError(f"OHLCV verisi okunamadı: {str(payload)[:300]}")
-
-    if isinstance(rows[0], (list, tuple)):
-        cols = ["ts", "open", "high", "low", "close", "volume"][: len(rows[0])]
-        df = pd.DataFrame(rows, columns=cols)
-    else:
-        df = pd.DataFrame(rows)
-        df = df.rename(columns={"timestamp": "ts", "time": "ts", "t": "ts", "date": "ts",
-                                "o": "open", "h": "high", "l": "low", "c": "close", "v": "volume"})
-    for c in ("open", "high", "low", "close", "volume"):
-        df[c] = pd.to_numeric(df[c], errors="coerce")
-    if pd.api.types.is_numeric_dtype(df["ts"]):
-        unit = "ms" if df["ts"].iloc[-1] > 1e11 else "s"
-        df["ts"] = pd.to_datetime(df["ts"], unit=unit)
-    else:
-        df["ts"] = pd.to_datetime(df["ts"])
-    return df.dropna(subset=["close"]).sort_values("ts").reset_index(drop=True)
-
-
-# ----------------------------------------------------------------- ML
-def make_features(df: pd.DataFrame):
-    c, h, l, o, v = df["close"], df["high"], df["low"], df["open"], df["volume"]
-    f = pd.DataFrame(index=df.index)
-    lr = np.log(c).diff()
-
-    # Getiri / momentum (çok ölçekli)
-    for n in (1, 2, 3, 6, 12, 24, 48, 96, 192):
-        f[f"ret{n}"] = c.pct_change(n)
-
-    # Çoklu zaman dilimi (lookahead'siz yuvarlanan pencereler): ~4x ve ~16x üst TF benzeri
-    dd = c.diff()
-    for k in (4, 16):
-        up_k = dd.clip(lower=0).ewm(alpha=1 / (14 * k), adjust=False).mean()
-        dn_k = (-dd.clip(upper=0)).ewm(alpha=1 / (14 * k), adjust=False).mean()
-        f[f"rsi_htf{k}"] = 100 - 100 / (1 + up_k / (dn_k + 1e-12))
-        f[f"ema_dist_htf{k}"] = c / c.ewm(span=20 * k, adjust=False).mean() - 1
-        f[f"chan_pos{k}"] = (c - l.rolling(20 * k).min()) / (h.rolling(20 * k).max() - l.rolling(20 * k).min() + 1e-12)
-        f[f"vol_htf{k}"] = lr.rolling(20 * k).std()
-
-    # Volatilite rejimi
-    for n in (6, 24, 96):
-        f[f"vol{n}"] = lr.rolling(n).std()
-    f["vol_ratio"] = f["vol6"] / (f["vol96"] + 1e-12)
-    f["vol_ratio2"] = f["vol24"] / (f["vol96"] + 1e-12)
-    f["ret24_z"] = f["ret24"] / (f["vol24"] * np.sqrt(24) + 1e-12)   # volatilite-normalize momentum
-    f["ret6_z"] = f["ret6"] / (f["vol24"] * np.sqrt(6) + 1e-12)
-
-    # RSI (iki periyot)
-    d = c.diff()
-    for n in (7, 14):
-        up = d.clip(lower=0).ewm(alpha=1 / n, adjust=False).mean()
-        dn = (-d.clip(upper=0)).ewm(alpha=1 / n, adjust=False).mean()
-        f[f"rsi{n}"] = 100 - 100 / (1 + up / (dn + 1e-12))
-
-    macd = c.ewm(span=12, adjust=False).mean() - c.ewm(span=26, adjust=False).mean()
-    f["macd_h"] = (macd - macd.ewm(span=9, adjust=False).mean()) / c
-    for n in (20, 50, 200):
-        f[f"ema_dist{n}"] = c / c.ewm(span=n, adjust=False).mean() - 1
-    f["ema_slope"] = c.ewm(span=20, adjust=False).mean().pct_change(5)
-
-    tr = pd.concat([h - l, (h - c.shift()).abs(), (l - c.shift()).abs()], axis=1).max(axis=1)
-    atr = tr.ewm(alpha=1 / 14, adjust=False).mean()
-    f["atr_pct"] = atr / c
-    f["hl_range"] = (h - l) / c
-
-    # ADX (trend gücü)
-    upm, dnm = h.diff(), -l.diff()
-    pdm = ((upm > dnm) & (upm > 0)) * upm
-    mdm = ((dnm > upm) & (dnm > 0)) * dnm
-    pdi = 100 * pdm.ewm(alpha=1 / 14, adjust=False).mean() / (atr + 1e-12)
-    mdi = 100 * mdm.ewm(alpha=1 / 14, adjust=False).mean() / (atr + 1e-12)
-    f["adx"] = (100 * (pdi - mdi).abs() / (pdi + mdi + 1e-12)).ewm(alpha=1 / 14, adjust=False).mean()
-    f["di_diff"] = pdi - mdi
-
-    # Stokastik + Bollinger + kanal konumu
-    ll, hh = l.rolling(14).min(), h.rolling(14).max()
-    f["stoch"] = (c - ll) / (hh - ll + 1e-12)
-    f["bb_pos"] = (c - c.rolling(20).mean()) / (2 * c.rolling(20).std() + 1e-12)
-    f["bb_width"] = 4 * c.rolling(20).std() / c.rolling(20).mean()
-    f["dist_hi50"] = c / h.rolling(50).max() - 1
-    f["dist_lo50"] = c / l.rolling(50).min() - 1
-
-    # Mum yapısı
-    rng = (h - l) + 1e-12
-    f["body"] = (c - o) / rng
-    f["upper_wick"] = (h - np.maximum(o, c)) / rng
-    f["lower_wick"] = (np.minimum(o, c) - l) / rng
-    f["close_loc"] = (c - l) / rng
-
-    # Hacim
-    f["vol_z"] = (v - v.rolling(48).mean()) / (v.rolling(48).std() + 1e-12)
-    f["vol_trend"] = v.rolling(6).mean() / (v.rolling(48).mean() + 1e-12)
-    f["signed_vol"] = (np.sign(d) * v).rolling(12).sum() / (v.rolling(12).sum() + 1e-12)  # OBV benzeri baskı
-    f["mfi_like"] = ((c - o) / rng * v).rolling(14).sum() / (v.rolling(14).sum() + 1e-12)
-
-    # İstatistiksel (otokorelasyon, çarpıklık)
-    f["autocorr"] = lr.rolling(48).corr(lr.shift(1))
-    f["skew48"] = lr.rolling(48).skew()
-
-    # Seans / zaman (döngüsel)
-    ts = df["ts"]
-    f["hour_sin"] = np.sin(2 * np.pi * ts.dt.hour / 24)
-    f["hour_cos"] = np.cos(2 * np.pi * ts.dt.hour / 24)
-    f["dow_sin"] = np.sin(2 * np.pi * ts.dt.dayofweek / 7)
-    f["dow_cos"] = np.cos(2 * np.pi * ts.dt.dayofweek / 7)
-    return f.replace([np.inf, -np.inf], np.nan), atr
-
-
-def _models(hp=None):
-    """hp (Optuna'dan): {"hgb": {...}, "et": {...}, "lr": {"C": ...}}; yoksa varsayılanlar."""
-    hp = hp or {}
-    h = {"max_depth": 3, "learning_rate": 0.04, "max_iter": 250, "l2_regularization": 2.0,
-         "min_samples_leaf": 40, **hp.get("hgb", {})}
-    e = {"n_estimators": 300, "max_depth": 6, "min_samples_leaf": 30, "max_features": 0.5, **hp.get("et", {})}
-    c = hp.get("lr", {}).get("C", 0.05)
-    return {
-        "hgb": HistGradientBoostingClassifier(**h, random_state=42),
-        "et": ExtraTreesClassifier(**e, n_jobs=-1, random_state=42),
-        "lr": make_pipeline(StandardScaler(), LogisticRegression(C=c, max_iter=500)),
-    }
 
+        entry = float(row["close"])
+        atr = float(row["atr"])
+
+        if not np.isfinite(atr) or atr <= 0:
+            continue
+
+        risk_distance = atr * 1.5
+
+        if side == "LONG":
+
+            stop = entry - risk_distance
+            target = entry + risk_distance * 2
 
-def _select(Xtr, ftr, k, thr=0.95):
-    """Yalnızca EĞİTİM verisiyle: |Spearman IC| sırasına göre, birbirine çok benzeyenleri (>thr) eleyerek k özellik seç."""
-    if k <= 0 or Xtr.shape[1] <= k:
-        return list(Xtr.columns)
-    ic = Xtr.rank().corrwith(pd.Series(np.asarray(ftr), index=Xtr.index).rank()).abs().fillna(0)
-    ic = ic.sort_values(ascending=False)
-    corr = Xtr.corr().abs().fillna(0)
-    keep = []
-    for c in ic.index:
-        if all(corr.at[c, o] < thr for o in keep):
-            keep.append(c)
-        if len(keep) >= k:
-            break
-    return keep
-
-
-def _fit_predict(Xtr, ytr, Xte, w=None, ftr=None, k=0, with_train=False, hp=None):
-    """Ensemble: HGB + ExtraTrees + Logistic -> olasılık ortalaması.
-    k>0: fold-içi özellik seçimi. with_train: eğitim verisi üzerindeki olasılıkları da döndür (aşırı uyum ölçümü için)."""
-    if k and ftr is not None:
-        sel = _select(Xtr, ftr, k)
-        Xtr, Xte = Xtr[sel], Xte[sel]
-    ps, pt = [], []
-    for name, m in _models(hp).items():
-        if name == "lr":
-            A, B = Xtr.fillna(0), Xte.fillna(0)
-            m.fit(A, ytr, logisticregression__sample_weight=w)
-        elif name == "et":
-            A, B = Xtr.fillna(0), Xte.fillna(0)
-            m.fit(A, ytr, sample_weight=w)
         else:
-            A, B = Xtr, Xte
-            m.fit(A, ytr, sample_weight=w)
-        ps.append(m.predict_proba(B)[:, 1])
-        if with_train:
-            pt.append(m.predict_proba(A)[:, 1])
-    p = np.mean(ps, axis=0)
-    return (p, np.mean(pt, axis=0)) if with_train else p
 
+            stop = entry + risk_distance
+            target = entry - risk_distance * 2
 
-def _trades(p, fwd, horizon, thr, fee):
-    """Örtüşmeyen (her `horizon` barda bir) işlemlerin net getirileri."""
-    p, fwd = p[::horizon], fwd[::horizon]
-    pos = np.where(p > thr, 1, np.where(p < 1 - thr, -1, 0))
-    pnl = pos * fwd - np.abs(pos) * fee
-    return pnl[pos != 0]
+        future = raw.iloc[
+            raw_position + 1:
+            raw_position + horizon + 1
+        ]
 
+        if len(future) < horizon:
+            continue
 
-def _stats(tr):
-    n = len(tr)
-    if n < 20:
-        return {"n": n, "mean": 0.0, "t": 0.0, "hit": np.nan, "pf": np.nan}
-    gp, gl = tr[tr > 0].sum(), -tr[tr < 0].sum()
-    return {"n": n, "mean": float(tr.mean()),
-            "t": float(tr.mean() / (tr.std() / np.sqrt(n) + 1e-12)),
-            "hit": float((tr > 0).mean()), "pf": float(gp / gl) if gl > 0 else np.inf}
+        exit_price = float(future["close"].iloc[-1])
+        exit_reason = "HORIZON"
 
+        for candle in future.itertuples():
 
-def _backtest(p, fwd, horizon, thr, fee):
-    return _stats(_trades(p, fwd, horizon, thr, fee))
+            high = float(candle.high)
+            low = float(candle.low)
 
+            if side == "LONG":
 
-def _nested(p, f, sizes, horizon, fee, grid=(0.52, 0.54, 0.56, 0.58, 0.60, 0.62)):
-    """Dürüst backtest: eşik her fold için YALNIZCA önceki fold'ların OOS'unda seçilir, sonra o fold'a uygulanır."""
-    bounds = np.cumsum([0] + list(sizes))
-    trades = []
-    for j in range(1, len(sizes)):
-        pp, ff = p[:bounds[j]], f[:bounds[j]]
-        best_thr, best_m = 0.55, -np.inf
-        for thr in (0.55,) + tuple(grid):
-            r = _backtest(pp, ff, horizon, thr, fee)
-            if r["n"] >= 30 and r["mean"] > best_m:
-                best_thr, best_m = thr, r["mean"]
-        trades.append(_trades(p[bounds[j]:bounds[j + 1]], f[bounds[j]:bounds[j + 1]], horizon, best_thr, fee))
-    return _stats(np.concatenate(trades) if trades else np.array([]))
+                # Aynı mumda iki seviyeye de dokunursa
+                # ihtiyatlı olarak stop önce kabul edilir.
+                if low <= stop:
+                    exit_price = stop
+                    exit_reason = "STOP"
+                    break
+
+                if high >= target:
+                    exit_price = target
+                    exit_reason = "TARGET"
+                    break
+
+            else:
+
+                if high >= stop:
+                    exit_price = stop
+                    exit_reason = "STOP"
+                    break
+
+                if low <= target:
+                    exit_price = target
+                    exit_reason = "TARGET"
+                    break
+
+        if side == "LONG":
+            gross_return = (exit_price - entry) / entry
+
+        else:
+            gross_return = (entry - exit_price) / entry
+
+        net_return = gross_return - (2 * fee_rate)
+
+        trades.append({
+            "time": timestamp,
+            "side": side,
+            "entry": entry,
+            "exit": exit_price,
+            "probability": probability,
+            "gross_return": gross_return * 100,
+            "net_return": net_return * 100,
+            "result": "WIN" if net_return > 0 else "LOSS",
+            "exit_reason": exit_reason
+        })
+
+        # Pozisyonlar çakışmasın.
+        next_allowed_bar = raw_position + horizon
+
+    if not trades:
 
+        return {
+            "count": 0,
+            "winrate": 0,
+            "profit_factor": 0,
+            "total_return": 0,
+            "trades": []
+        }
 
-class _Fixed:
-    """En iyi parametreleri aynı `suggest_*` arayüzüyle geri üretmek için."""
-    def __init__(self, params):
-        self.p = params
+    trade_df = pd.DataFrame(trades)
 
-    def suggest_int(self, name, *a, **k):
-        return self.p[name]
+    wins = trade_df[
+        trade_df["net_return"] > 0
+    ]["net_return"]
 
-    def suggest_float(self, name, *a, **k):
-        return self.p[name]
+    losses = trade_df[
+        trade_df["net_return"] < 0
+    ]["net_return"]
 
+    gross_profit = wins.sum()
+    gross_loss = abs(losses.sum())
+
+    profit_factor = (
+        gross_profit / gross_loss
+        if gross_loss > 0
+        else float("inf") if gross_profit > 0 else 0
+    )
+
+    winrate = (
+        len(wins) / len(trade_df)
+    ) * 100
+
+    total_return = trade_df["net_return"].sum()
 
-def _hp_space(t):
     return {
-        "hgb": {"max_depth": t.suggest_int("hgb_depth", 2, 5),
-                "learning_rate": t.suggest_float("hgb_lr", 0.01, 0.1, log=True),
-                "max_iter": t.suggest_int("hgb_iter", 100, 400, step=50),
-                "l2_regularization": t.suggest_float("hgb_l2", 0.5, 10.0, log=True),
-                "min_samples_leaf": t.suggest_int("hgb_leaf", 20, 200, step=20)},
-        "et": {"max_depth": t.suggest_int("et_depth", 3, 10),
-               "min_samples_leaf": t.suggest_int("et_leaf", 10, 100, step=10),
-               "max_features": t.suggest_float("et_mf", 0.2, 0.8)},
-        "lr": {"C": t.suggest_float("lr_C", 0.005, 0.5, log=True)},
+        "count": len(trade_df),
+        "winrate": winrate,
+        "profit_factor": profit_factor,
+        "total_return": total_return,
+        "trades": trades
     }
 
 
-def _tune(X, Y, F, W, horizon, n_trials, timeout=240):
-    """Optuna: hiperparametre + özellik sayısı (k) ayarı. YALNIZCA geliştirme verisinin ilk %40'ında
-    (iç walk-forward, 3 dilim) yapılır; asıl walk-forward OOS ve hold-out'a hiç dokunmaz.
-    Amaç: ortalama AUC − 0.5·std (kararsız/şanslı ayarları cezalandırır)."""
-    try:
-        import optuna
-    except Exception:  # noqa: BLE001
-        return {"error": "optuna kurulu değil (pip install optuna); varsayılan ayarlar kullanıldı"}
-    m = int(len(X) * 0.4)
-    if m < 500:
-        return {"error": f"Ayar bölgesi çok küçük ({m} bar < 500); Optuna atlandı, varsayılanlar kullanıldı"}
-    Xt, Yt, Ft, Wt = X.iloc[:m], Y.iloc[:m], F[:m], W[:m]
-    edges = np.linspace(int(m * 0.4), m, 4).astype(int)
-
-    def obj(trial):
-        hp = _hp_space(trial)
-        k = trial.suggest_int("k", 10, 80, step=10)
-        aucs = []
-        for j in range(3):
-            tr_end, te0, te1 = edges[j] - horizon, edges[j], edges[j + 1]
-            if tr_end < 80:
-                continue
-            p = _fit_predict(Xt.iloc[:tr_end], Yt.iloc[:tr_end], Xt.iloc[te0:te1],
-                             Wt[:tr_end], Ft[:tr_end], k, hp=hp)
-            try:
-                aucs.append(roc_auc_score(Yt.iloc[te0:te1], p))
-            except ValueError:
-                pass
-        return float(np.mean(aucs) - 0.5 * np.std(aucs)) if aucs else 0.5
-
-    optuna.logging.set_verbosity(optuna.logging.WARNING)
-    study = optuna.create_study(direction="maximize", sampler=optuna.samplers.TPESampler(seed=42))
-    study.optimize(obj, n_trials=int(n_trials), timeout=timeout)
-    bp = study.best_params
-    return {"hp": _hp_space(_Fixed(bp)), "k": int(bp["k"]), "score": float(study.best_value),
-            "trials": len(study.trials), "region": m}
-
-
-def _walk(X, Y, F, W, horizon, n_folds, k, hp=None):
-    """Purged expanding-window walk-forward. Döner: OOS olasılık, satır indeksi, fold boyutları, ort. train-test AUC farkı."""
-    n = len(X)
-    edges = np.linspace(int(n * 0.4), n, n_folds + 1).astype(int)
-    oos_p, oos_idx, sizes, gaps = [], [], [], []
-    for j in range(n_folds):
-        tr_end, te0, te1 = edges[j] - horizon, edges[j], edges[j + 1]
-        if tr_end < 80:
-            continue
-        p, ptr = _fit_predict(X.iloc[:tr_end], Y.iloc[:tr_end], X.iloc[te0:te1],
-                              W[:tr_end], F[:tr_end], k, with_train=True, hp=hp)
-        try:
-            gaps.append(roc_auc_score(Y.iloc[:tr_end], ptr) - roc_auc_score(Y.iloc[te0:te1], p))
-        except ValueError:
-            pass
-        oos_p.append(p)
-        oos_idx.extend(range(te0, te1))
-        sizes.append(te1 - te0)
-    if not oos_p:
-        raise ValueError("Walk-forward için yeterli veri yok. Mum sayısını artır.")
-    return (np.concatenate(oos_p), np.array(oos_idx), sizes,
-            float(np.mean(gaps)) if gaps else float("nan"))
-
-
-def predict(df: pd.DataFrame, horizon: int, fee: float = 0.0006, n_folds: int = 5, ext=None,
-            max_feat: int = 40, use_optuna: bool = False, n_trials: int = 25):
-    feats, atr = make_features(df)
-    n_ext = 0
-    if ext is not None:
-        ext = ext.replace([np.inf, -np.inf], np.nan)
-        w0 = min(60, len(df) // 5)
-        # ısınma sonrası %10'dan fazla boş olan Tickscope kolonlarını at
-        ext = ext.loc[:, ext.iloc[w0:].isna().mean() <= 0.10]
-        n_ext = ext.shape[1]
-        feats = pd.concat([feats, ext], axis=1)
-    close = df["close"]
-    fwd = close.shift(-horizon) / close - 1
-    y = (fwd > 0).astype(float)
-    y[fwd.isna()] = np.nan
-
-    feats = feats.dropna(axis=1, how="all")          # tamamen boş kolonları at (ör. hacim yoksa)
-    data = feats.copy()
-    data["y"], data["fwd"] = y, fwd
-    data["thr_move"] = (atr / close) * np.sqrt(horizon)
-    warm = min(60, len(data) // 5)                   # gösterge ısınma barları
-    train_df = data.iloc[warm:].dropna(subset=["y", "fwd", "thr_move"]).copy()
-    # Kalan NaN'ler (uzun pencereli göstergeler) satır silmek yerine doldurulur
-    train_df[list(feats.columns)] = train_df[list(feats.columns)].ffill().fillna(0)
-    if len(train_df) < 200:
-        raise ValueError(
-            f"Yeterli veri yok: {len(df)} mum geldi, {len(train_df)} kullanılabilir bar kaldı "
-            f"(en az 200 gerekir; ufuk={horizon}). Mum sayısını artır veya borsayı/sembolü kontrol et.")
-
-    cols = list(feats.columns)
-    X, Y = train_df[cols], train_df["y"].astype(int)
-    F, TM = train_df["fwd"].values, train_df["thr_move"].values
-    # Gürültü filtresi: çok küçük hareketleri (≈ yazı-tura) eğitimde ağırlıksız bırak
-    # ve büyük hareketlere daha fazla ağırlık ver.
-    W = np.clip(np.abs(F) / (TM + 1e-12), 0.05, 3.0)
-
-    # --- Geliştirme (ilk %80) / hiç dokunulmayan hold-out (son %20) ---
-    n_all = len(X)
-    n_dev = int(n_all * 0.8)
-    Xd, Yd, Fd, Wd = X.iloc[:n_dev], Y.iloc[:n_dev], F[:n_dev], W[:n_dev]
-
-    hp, tuned = None, None
-    if use_optuna:
-        tuned = _tune(Xd, Yd, Fd, Wd, horizon, n_trials)
-        if "error" not in tuned:
-            hp, max_feat = tuned["hp"], tuned["k"]
-
-    oos_p, oos_idx, sizes, gap = _walk(Xd, Yd, Fd, Wd, horizon, n_folds, max_feat, hp)
-    yo, fo = Yd.values[oos_idx], Fd[oos_idx]
-
-    # Teşhis (ablation): yalnızca temel (fiyat/hacim) özelliklerle aynı test
-    base_cols = [c for c in cols if not c.startswith(("ts_", "dv_"))]
-    auc_base = None
-    if len(base_cols) < len(cols):
-        pb, ib, _, _ = _walk(Xd[base_cols], Yd, Fd, Wd, horizon, n_folds, max_feat, hp)
-        try:
-            auc_base = float(roc_auc_score(Yd.values[ib], pb))
-        except ValueError:
-            auc_base = 0.5
+# =========================================================
+# MAIN ANALYSIS
+# =========================================================
+
+def analyze(
+    timeframe,
+    candles,
+    horizon,
+    threshold,
+    fee_pct
+):
 
-    acc = float(((oos_p > 0.5).astype(int) == yo).mean())
-    base = float(max(yo.mean(), 1 - yo.mean()))
     try:
-        auc = float(roc_auc_score(yo, oos_p))
-    except ValueError:
-        auc = 0.5
-    # AUC anlamlılığı: H0 (AUC=0.5) altında SE ≈ sqrt(1/(3·n_eff)); örtüşen etiketler için n_eff = n/ufuk
-    n_eff = max(len(oos_p) / horizon, 2.0)
-    z = (auc - 0.5) / math.sqrt(1.0 / (3.0 * n_eff))
-    auc_p = 0.5 * math.erfc(z / math.sqrt(2.0))
-
-    # Eşik taraması (yalnızca OOS üzerinde, işlem sayısı ≥ 30 şartıyla) — iyimser
-    best = {"thr": 0.55, **_backtest(oos_p, fo, horizon, 0.55, fee)}
-    for thr in (0.52, 0.54, 0.56, 0.58, 0.60, 0.62):
-        r = _backtest(oos_p, fo, horizon, thr, fee)
-        if r["n"] >= 30 and r["mean"] > best["mean"]:
-            best = {"thr": thr, **r}
-
-    # Dürüst (nested) backtest: eşik hiç görmediği fold'a uygulanır
-    nested = _nested(oos_p, fo, sizes, horizon, fee)
-
-    # Hold-out: gelişitirmede hiç kullanılmayan son %20; seçilen eşikle bir kez değerlendirilir
-    ho = None
-    tr_end = n_dev - horizon
-    if tr_end >= 200 and n_all - n_dev >= 100:
-        ph = _fit_predict(X.iloc[:tr_end], Y.iloc[:tr_end], X.iloc[n_dev:], W[:tr_end], F[:tr_end], max_feat, hp=hp)
+
+        candles = int(candles)
+        horizon = int(horizon)
+        threshold = float(threshold)
+        fee_pct = float(fee_pct)
+
+        if candles < 700:
+            return "En az 700 mum gerekli."
+
+        if horizon < 1 or horizon > 48:
+            return "Horizon 1 ile 48 arasında olmalı."
+
+        if not 0.50 < threshold < 0.90:
+            return "Threshold 0.50 ile 0.90 arasında olmalı."
+
+        if fee_pct < 0 or fee_pct > 1:
+            return "Komisyon 0 ile 1 arasında olmalı."
+
+        # -------------------------------------------------
+        # DATA
+        # -------------------------------------------------
+
+        raw = fetch_data(
+            timeframe=timeframe,
+            candles=candles
+        )
+
+        data = prepare_dataset(
+            raw,
+            horizon
+        )
+
+        X = data[FEATURES]
+        y = data["target"].astype(int)
+
+        # -------------------------------------------------
+        # CHRONOLOGICAL SPLIT
+        # -------------------------------------------------
+
+        split = int(len(data) * 0.80)
+
+        X_train = X.iloc[:split]
+        X_test = X.iloc[split:]
+
+        y_train = y.iloc[:split]
+        y_test = y.iloc[split:]
+
+        if y_train.nunique() < 2:
+            return "Eğitim verisinde iki sınıf da bulunmalı."
+
+        # -------------------------------------------------
+        # WALK FORWARD
+        # -------------------------------------------------
+
+        wf_score, fold_results = walk_forward_validation(
+            X_train,
+            y_train
+        )
+
+        # -------------------------------------------------
+        # FINAL HOLDOUT
+        # -------------------------------------------------
+
+        probabilities = ensemble_predict(
+            X_train,
+            y_train,
+            X_test
+        )
+
+        predictions = (
+            probabilities >= 0.5
+        ).astype(int)
+
+        accuracy = accuracy_score(
+            y_test,
+            predictions
+        )
+
+        balanced = balanced_accuracy_score(
+            y_test,
+            predictions
+        )
+
         try:
-            auc_h = float(roc_auc_score(Y.values[n_dev:], ph))
-        except ValueError:
-            auc_h = 0.5
-        ho = {"auc": auc_h, "bars": len(ph),
-              **_stats(_trades(ph, F[n_dev:], horizon, best["thr"], fee))}
-
-    # Son model: tüm veriyle, canlı tahmin
-    final_p = _fit_predict(X, Y, feats.iloc[[-1]][cols].ffill().fillna(0), W, F, max_feat, hp=hp)
-    p_up = float(final_p[0])
-
-    price, a = float(close.iloc[-1]), float(atr.iloc[-1])
-    move = a * np.sqrt(horizon)
-    center = price + (p_up - 0.5) * 2 * move
-    return {
-        "p_up": p_up, "acc": acc, "baseline": base, "auc": auc, "price": price, "atr": a,
-        "center": center, "low": center - move, "high": center + move,
-        "thr": best["thr"], "bt": best, "n_oos": len(oos_p), "fee": fee,
-        "n_ext": n_ext, "n_feat": len(cols), "auc_base": auc_base, "max_feat": max_feat,
-        "gap": gap, "auc_p": auc_p, "nested": nested, "holdout": ho, "tuned": tuned,
-    }
+            auc = roc_auc_score(
+                y_test,
+                probabilities
+            )
+        except Exception:
+            auc = 0.5
 
+        # -------------------------------------------------
+        # BACKTEST
+        # -------------------------------------------------
+
+        backtest = run_backtest(
+            raw=raw,
+            test=data.iloc[split:],
+            probabilities=probabilities,
+            horizon=horizon,
+            threshold=threshold,
+            fee_pct=fee_pct
+        )
+
+        # -------------------------------------------------
+        # CURRENT SIGNAL
+        # -------------------------------------------------
+
+        latest = calculate_indicators(raw).dropna(
+            subset=FEATURES + ["atr"]
+        ).iloc[-1]
+
+        latest_X = pd.DataFrame(
+            [latest[FEATURES].values],
+            columns=FEATURES
+        )
+
+        latest_probability = ensemble_predict(
+            X,
+            y,
+            latest_X
+        )[0]
+
+        p_up = float(latest_probability)
+        p_down = 1 - p_up
+
+        if p_up >= threshold:
+            signal = "LONG"
+
+        elif p_down >= threshold:
+            signal = "SHORT"
+
+        else:
+            signal = "NÖTR"
+
+        # -------------------------------------------------
+        # ENTRY / STOP / TARGET
+        # -------------------------------------------------
+
+        entry = float(latest["close"])
+        atr = float(latest["atr"])
+
+        if signal == "LONG":
+
+            stop = entry - 1.5 * atr
+            target = entry + 3.0 * atr
+
+        elif signal == "SHORT":
+
+            stop = entry + 1.5 * atr
+            target = entry - 3.0 * atr
+
+        else:
+
+            stop = None
+            target = None
+
+        # -------------------------------------------------
+        # INDICATOR INTERPRETATION
+        # -------------------------------------------------
+
+        rsi = float(latest["rsi"])
+
+        macd_value = float(latest["macd"])
+        macd_signal = float(latest["macd_signal"])
+
+        st_direction = int(
+            latest["supertrend_direction"]
+        )
+
+        vwap_distance = float(
+            latest["vwap_distance"]
+        )
+
+        indicator_text = (
+            f"RSI: {rsi:.2f}\n"
+            f"MACD: {'BULLISH' if macd_value > macd_signal else 'BEARISH'}\n"
+            f"Supertrend: {'BULLISH' if st_direction == 1 else 'BEARISH'}\n"
+            f"VWAP: {'ÜSTÜNDE' if vwap_distance > 0 else 'ALTINDA'}\n"
+            f"VWAP uzaklığı: {vwap_distance:.3f}%\n"
+        )
+
+        # -------------------------------------------------
+        # RESULTS
+        # -------------------------------------------------
+
+        pf = backtest["profit_factor"]
+
+        if np.isinf(pf):
+            pf_text = "∞"
+        else:
+            pf_text = f"{pf:.2f}"
+
+        if signal == "LONG":
+            signal_text = "LONG"
+        elif signal == "SHORT":
+            signal_text = "SHORT"
+        else:
+            signal_text = "NÖTR"
+
+        output = f"""
+# BTC/USDT AI ANALİZİ
+
+<badge> {signal_text} </badge>
+
+## Güncel tahmin
+
+| Metrik | Sonuç |
+|---|---:|
+| BTC fiyatı | {entry:,.2f} USDT |
+| LONG olasılığı | {p_up * 100:.2f}% |
+| SHORT olasılığı | {p_down * 100:.2f}% |
+| Model sinyali | **{signal}** |
+| Zaman dilimi | {timeframe} |
+| Tahmin horizon | {horizon} mum |
+
+## TradingView indikatörleri
+
+```text
+{indicator_text}
+```
+
+## İşlem seviyeleri
+
+| Seviye | Fiyat |
+|---|---:|
+| Giriş | {entry:,.2f} |
+| Stop Loss | {stop:,.2f if stop is not None else "—"} |
+| 2R Hedef | {target:,.2f if target is not None else "—"} |
+
+## Bağımsız hold-out test
+
+| Metrik | Sonuç |
+|---|---:|
+| Accuracy | {accuracy * 100:.2f}% |
+| Balanced Accuracy | {balanced * 100:.2f}% |
+| AUC | {auc:.4f} |
+| Walk-forward Balanced Accuracy | {wf_score * 100:.2f}% |
+
+## Backtest sonuçları
+
+| Metrik | Sonuç |
+|---|---:|
+| İşlem sayısı | {backtest["count"]} |
+| Win Rate | {backtest["winrate"]:.2f}% |
+| Profit Factor | {pf_text} |
+| Net toplam getiri | {backtest["total_return"]:.2f}% |
+| İşlem komisyonu | %{fee_pct:.3f} / taraf |
+
+## Walk-forward fold sonuçları
+
+""" + "\n".join(
+            f"- {x}" for x in fold_results
+        )
+
+        if backtest["trades"]:
+
+            trade_df = pd.DataFrame(
+                backtest["trades"]
+            )
+
+            output += "\n\n## Son backtest işlemleri\n\n"
+
+            output += trade_df.tail(15).to_markdown(
+                index=False
+            )
+
+        output += """
+
+---
+
+**Uyarı:** Bu bir istatistiksel model tahminidir, kesin fiyat tahmini değildir. Hold-out sonuçları geçmiş veriye aittir. Komisyon, kayma ve gerçek emir gerçekleşmesi sonuçları değiştirebilir. NÖTR sinyali işlem açmama anlamına gelir.
+"""
+
+        return output
+
+    except Exception as e:
+
+        return (
+            "# HATA\n\n"
+            f"`{type(e).__name__}: {str(e)}`\n\n"
+            "Bağlantıyı, Binance erişimini ve paket kurulumlarını kontrol et."
+        )
+
+
+# =========================================================
+# GRADIO UI
+# =========================================================
+
+with gr.Blocks(
+    title="BTC AI Indicator Ensemble"
+) as app:
+
+    gr.Markdown(
+        """
+# BTC AI — Indicator Ensemble
+MCP'siz, Binance verisiyle çalışan BTC/USDT tahmin sistemi.
+
+**Supertrend + RSI + MACD + VWAP + Machine Learning**
+"""
+    )
 
-# ----------------------------------------------------------------- Ana akış
-async def run_async(symbol, timeframe, exchange, horizon, limit):
-    extra = {}
-    async with stdio_client(SERVER) as (r, w):
-        async with ClientSession(r, w) as session:
-            await session.initialize()
-            tools = {t.name: t for t in (await session.list_tools()).tools}
-
-            ohlcv = await fetch_ohlcv(session, tools, symbol, timeframe, exchange, int(limit))
-            if ohlcv is None:
-                raise RuntimeError(f"get_ohlcv bulunamadı. Mevcut tool'lar: {list(tools)}")
-            if isinstance(ohlcv, dict) and "error" in ohlcv:
-                raise RuntimeError(ohlcv["error"])
-
-            # Buradan sonrası opsiyonel: sunucu çökse bile elimizdeki mum verisiyle devam edilir
-            deep = None
-            try:
-                deep = await call_tool(session, tools, "deep_analyze", symbol=symbol,
-                                       timeframe=timeframe, exchange=exchange)
-            except Exception as e:  # noqa: BLE001
-                extra["deep_analyze_error"] = _root(e)
-            for name in EXTRA_TOOLS:
-                if name not in tools:
-                    continue
-                try:
-                    extra[name] = await call_tool(session, tools, name, symbol=symbol,
-                                                  timeframe=timeframe, exchange=exchange)
-                except Exception as e:  # noqa: BLE001
-                    extra[name] = {"error": _root(e)}
-            extra["_available_tools"] = list(tools)
-            ci = tools.get("compute_indicators")
-            if ci is not None:   # gerçek gösterge adlarını görebilmek için araç açıklaması
-                extra["_compute_indicators_description"] = (getattr(ci, "description", "") or "")[:4000]
-
-    # Göstergeler: ayrı Tickscope süreçleri (ana oturum kapandıktan sonra; DuckDB kilidi çakışmasın)
-    ind = None
-    try:
-        ind = await fetch_indicators(symbol, timeframe, exchange, int(limit))
-    except Exception as e:  # noqa: BLE001
-        extra["indicators_error"] = _root(e)
-    if isinstance(ind, dict):
-        ser = extract_series(ind, 0)
-        extra["_ts_diag"] = {"seri_sayisi": len(ser),
-                             "seri_uzunluklari": sorted({len(v) for v in ser.values()})[:10],
-                             "yeniden_baglanma": ind.get("reconnects"), "son_hata": ind.get("last_error"),
-                             "calismayan_adlar": ind.get("failed")}
-    return ohlcv, deep, ind, extra
-
-
-def _root(e):
-    """ExceptionGroup/TaskGroup sarmalını açıp asıl hatayı döndürür."""
-    while getattr(e, "exceptions", None):
-        e = e.exceptions[0]
-    return f"{type(e).__name__}: {e}"
-
-
-def run(symbol, timeframe, exchange, horizon, limit, use_deriv=True, max_feat=40, use_optuna=False, n_trials=25):
-    try:
-        ohlcv, deep, ind, extra = asyncio.run(run_async(symbol, timeframe, exchange, horizon, limit))
-        df = to_df(ohlcv)
-        dfeat = None
-        if use_deriv:
-            dfeat, df, dextra = asyncio.run(fetch_deriv_features(symbol, exchange, timeframe, df))
-            extra.update(dextra)
-        ext = indicator_features(ind, df)
-        if dfeat is not None:
-            ext = dfeat if ext is None else pd.concat([ext, dfeat], axis=1)
-        res = predict(df, int(horizon), ext=ext, max_feat=int(max_feat),
-                      use_optuna=bool(use_optuna), n_trials=int(n_trials))
-    except BaseException as e:  # noqa: BLE001
-        import traceback
-        traceback.print_exc()
-        msg = _root(e)
-        hint = ""
-        if "closed" in msg.lower():
-            hint = ("\n\nMCP süreci kapandı. Terminaldeki Tickscope/uvx hata çıktısına bakın; "
-                    "ayrıca aynı anda açık başka bir Tickscope süreci DuckDB kilidini tutuyor olabilir "
-                    "(eski `uvx tickscope-mcp` süreçlerini kapatıp tekrar deneyin).")
-        return f"**Hata:** {msg}{hint}", None, ""
-
-    p, thr, bt = res["p_up"], res["thr"], res["bt"]
-    signal = "LONG" if p > thr else "SHORT" if p < 1 - thr else "NÖTR"
-    nest, ho = res["nested"], res["holdout"]
-    checks = [
-        ("AUC > 0.52 ve p < 0.05", res["auc"] > 0.52 and res["auc_p"] < 0.05),
-        ("Train–test AUC farkı < 0.20 (aşırı uyum düşük)", res["gap"] < 0.20),
-        ("Nested net getiri > 0 ve t > 1.5 (≥30 işlem)", nest["n"] >= 30 and nest["mean"] > 0 and nest["t"] > 1.5),
-        ("Hold-out AUC > 0.50", ho is not None and ho["auc"] > 0.50),
-        ("Hold-out net getiri > 0 (≥20 işlem)", ho is not None and ho["n"] >= 20 and ho["mean"] > 0),
-    ]
-    t = res["tuned"]
-    if t is None:
-        opt_txt = "kapalı (varsayılan hiperparametreler)"
-    elif "error" in t:
-        opt_txt = t["error"]
-    else:
-        g, e = t["hp"]["hgb"], t["hp"]["et"]
-        opt_txt = (f"{t['trials']} deneme · iç skor {t['score']:.3f} · k={t['k']} · "
-                   f"HGB derinlik {g['max_depth']}, lr {g['learning_rate']:.3f} · ET derinlik {e['max_depth']} · "
-                   f"LR C={t['hp']['lr']['C']:.3f} (yalnızca ilk %40'ta ayarlandı)")
-    passed = sum(ok for _, ok in checks)
-    edge = f"✅ {passed}/5 kriter" if passed >= 4 else f"⚠️ {passed}/5 kriter — kanıtlanamadı"
-    checks_md = "**Aşırı uyum / güvenilirlik göstergesi**\n\n" + "\n".join(
-        f"- {'✅' if ok else '❌'} {name}" for name, ok in checks)
-    ho_txt = (f"AUC {ho['auc']:.3f} · {ho['n']} işlem · net {ho['mean']:.3%} (t = {ho['t']:.2f}) · {ho['bars']} bar"
-              if ho is not None else "veri yetersiz")
-    md = f"""### {symbol} · {timeframe} · {int(horizon)} bar sonrası
-| | |
-|---|---|
-| Son fiyat | **{res['price']:.4f}** |
-| Yükseliş olasılığı | **{p:.1%}** → **{signal}** (eşik {thr:.2f}) |
-| Tahmini merkez | {res['center']:.4f} |
-| Aralık (ATR·√h) | {res['low']:.4f} – {res['high']:.4f} |
-| OOS AUC / doğruluk | {res['auc']:.3f} / {res['acc']:.1%} (baseline {res['baseline']:.1%}) |
-| OOS işlem sayısı | {bt['n']} (hit {bt['hit']:.1%}, PF {bt['pf']:.2f}) |
-| Ort. net getiri / işlem | {bt['mean']:.3%} (t = {bt['t']:.2f}, ücret {res['fee']:.2%}/işlem) |
-| Özellik sayısı | {res['n_feat']} (Tickscope/türev: {res['n_ext']}) → fold başına en fazla {res['max_feat']} seçilir |
-| AUC yalnızca temel özelliklerle | {('%.3f' % res['auc_base']) if res['auc_base'] is not None else '—'} (ek veri kaynakları yardım ediyor mu?) |
-| Optuna | {opt_txt} |
-| Train–test AUC farkı (aşırı uyum) | {res['gap']:.3f} |
-| AUC anlamlılığı (tek yönlü p) | {res['auc_p']:.3f} |
-| Nested (dürüst) net getiri / işlem | {nest['mean']:.3%} (t = {nest['t']:.2f}, {nest['n']} işlem) |
-| Hold-out (dokunulmamış son %20) | {ho_txt} |
-| Model edge | {edge} |
-
-{checks_md}
-
-*Üstteki OOS/backtest satırları geliştirme kısmında (ilk %80) walk-forward ve eşik OOS'ta seçildiği için iyimserdir; güvenilir olanlar nested ve hold-out satırlarıdır. Eğitim/araştırma amaçlıdır; yatırım tavsiyesi değildir.*"""
-
-    # Grafik
-    tail = df.tail(150)
-    step = df["ts"].diff().median()
-    fx = df["ts"].iloc[-1] + step * int(horizon)
-    fig = go.Figure(go.Candlestick(x=tail["ts"], open=tail["open"], high=tail["high"],
-                                   low=tail["low"], close=tail["close"], name="Fiyat"))
-    fig.add_trace(go.Scatter(x=[fx], y=[res["center"]], mode="markers", name="Tahmin",
-                             marker=dict(size=12, symbol="diamond"),
-                             error_y=dict(type="data", symmetric=False,
-                                          array=[res["high"] - res["center"]],
-                                          arrayminus=[res["center"] - res["low"]])))
-    fig.update_layout(height=450, xaxis_rangeslider_visible=False, margin=dict(l=10, r=10, t=30, b=10))
-
-    raw = json.dumps(_strip_series({"deep_analyze": deep, "compute_indicators": ind, **extra}),
-                     indent=2, ensure_ascii=False, default=str)
-    return md, fig, raw
-
-
-with gr.Blocks(title="Tickscope Tahmin") as demo:
-    gr.Markdown("## Tickscope MCP → ML Tahmin")
-    with gr.Row():
-        symbol = gr.Textbox("BTC/USDT", label="Sembol")
-        exchange = gr.Dropdown(["binance", "bybit", "okx"], value="binance", label="Borsa")
-        timeframe = gr.Dropdown(["5m", "15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
     with gr.Row():
-        horizon = gr.Slider(1, 24, value=4, step=1, label="Tahmin ufku (bar)")
-        limit = gr.Slider(300, 20000, value=5000, step=100, label="Mum sayısı (1000 üstü sayfalanır)")
-    use_deriv = gr.Checkbox(True, label="Türev verisi (LiquidVision MCP: funding/OI) — mumları geçmişin kapsadığı aralığa kırpabilir")
-    max_feat = gr.Slider(10, 150, value=40, step=5, label="Maks. özellik (fold içinde seçilir; az = daha az aşırı uyum)")
+
+        timeframe = gr.Dropdown(
+            choices=[
+                "5m",
+                "15m",
+                "30m",
+                "1h",
+                "4h",
+                "1d"
+            ],
+            value="1h",
+            label="Timeframe"
+        )
+
+        candles = gr.Dropdown(
+            choices=[
+                1000,
+                1500,
+                2000,
+                3000,
+                4000,
+                5000
+            ],
+            value=2000,
+            label="Mum sayısı"
+        )
+
     with gr.Row():
-        use_optuna = gr.Checkbox(False, label="Optuna ile hiperparametre ayarı (OOS/hold-out'a dokunmaz; yavaş)")
-        n_trials = gr.Slider(10, 100, value=25, step=5, label="Optuna deneme sayısı")
-    btn = gr.Button("Tahmin et", variant="primary")
-    out_md = gr.Markdown()
-    out_plot = gr.Plot()
-    with gr.Accordion("Tickscope ham çıktı (deep_analyze / indicators)", open=False):
-        out_raw = gr.Code(language="json")
-    btn.click(run, [symbol, timeframe, exchange, horizon, limit, use_deriv, max_feat, use_optuna, n_trials], [out_md, out_plot, out_raw])
+
+        horizon = gr.Slider(
+            minimum=1,
+            maximum=24,
+            value=6,
+            step=1,
+            label="Tahmin horizon (mum)"
+        )
+
+        threshold = gr.Slider(
+            minimum=0.51,
+            maximum=0.80,
+            value=0.56,
+            step=0.01,
+            label="Sinyal güven eşiği"
+        )
+
+        fee = gr.Slider(
+            minimum=0,
+            maximum=0.20,
+            value=0.10,
+            step=0.01,
+            label="Komisyon (%) / taraf"
+        )
+
+    run_button = gr.Button(
+        "BTC ANALİZ ET",
+        variant="primary"
+    )
+
+    output = gr.Markdown()
+
+    run_button.click(
+        fn=analyze,
+        inputs=[
+            timeframe,
+            candles,
+            horizon,
+            threshold,
+            fee
+        ],
+        outputs=output
+    )
+
 
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()