Update app.py

app.py

@@ -1,3 +1,9 @@
+# ══════════════════════════════════════════════════════════════════════════════
+#  EUR/USD  ·  ENSEMBLE FORECAST ENGINE  ·  Premium Edition
+#  5 Model: Random Forest · Gradient Boosting · AdaBoost · Ridge · SVR
+#  TP/SL hesaplama · ATR tabanlı risk yönetimi · Backtest analizi
+# ══════════════════════════════════════════════════════════════════════════════
+
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -7,373 +13,784 @@ from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, A
 from sklearn.linear_model import Ridge
 from sklearn.svm import SVR
 from sklearn.preprocessing import StandardScaler
+import matplotlib
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 import matplotlib.patches as mpatches
 from matplotlib.gridspec import GridSpec
 import matplotlib.ticker as mticker
+from matplotlib.lines import Line2D
+import traceback
 import warnings
 warnings.filterwarnings('ignore')
 
-# ─── Stil sabitleri ───────────────────────────────────────────────────────────
-BG       = "#0A0E17"
-PANEL    = "#111827"
-BORDER   = "#1E293B"
-ACCENT   = "#3B82F6"
-GREEN    = "#10B981"
-RED      = "#EF4444"
-AMBER    = "#F59E0B"
-MUTED    = "#64748B"
-TEXT     = "#F1F5F9"
-SUBTEXT  = "#94A3B8"
-
-MODEL_COLORS = ["#3B82F6", "#8B5CF6", "#10B981", "#F59E0B", "#EC4899"]
-
-# ─── Veri & feature mühendisliği ─────────────────────────────────────────────
-def get_forex_data(symbol="EURUSD=X", period="90d"):
+# ══════════════════════════════════════════════════════════════════════════════
+#  RENK PALETİ
+# ══════════════════════════════════════════════════════════════════════════════
+BG      = "#0A0E17"
+PANEL   = "#0F1623"
+PANEL2  = "#111827"
+BORDER  = "#1E293B"
+ACCENT  = "#3B82F6"
+ACCENT2 = "#6366F1"
+GREEN   = "#10B981"
+RED     = "#EF4444"
+AMBER   = "#F59E0B"
+PURPLE  = "#8B5CF6"
+PINK    = "#EC4899"
+MUTED   = "#64748B"
+TEXT    = "#F1F5F9"
+SUBTEXT = "#94A3B8"
+
+MODEL_COLORS = [ACCENT, PURPLE, GREEN, AMBER, PINK]
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  VERİ KATMANI
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_forex_data(symbol: str = "EURUSD=X", period: str = "120d") -> pd.DataFrame | None:
+    """
+    Yahoo Finance'ten günlük OHLCV verisi indirir.
+    120 günlük pencere — SMA-50 ve lag-7 için yeterli.
+    """
     try:
-        data = yf.download(symbol, period=period, interval="1d", progress=False)
-        if data is None or len(data) < 40:
+        raw = yf.download(symbol, period=period, interval="1d", progress=False, auto_adjust=True)
+        if raw is None or len(raw) < 60:
             return None
-        return data
+        # MultiIndex sütunlarını düzelt
+        if isinstance(raw.columns, pd.MultiIndex):
+            raw.columns = raw.columns.get_level_values(0)
+        return raw
     except Exception:
         return None
 
-def create_features(data):
+
+def compute_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
+    """True Range tabanlı ATR hesabı."""
+    high = df['High']
+    low  = df['Low']
+    prev_close = df['Close'].shift(1)
+    tr = pd.concat([
+        high - low,
+        (high - prev_close).abs(),
+        (low  - prev_close).abs(),
+    ], axis=1).max(axis=1)
+    return tr.rolling(period).mean()
+
+
+def compute_stoch(df: pd.DataFrame, k: int = 14, d: int = 3):
+    """Stochastic Oscillator %K ve %D."""
+    low_min  = df['Low'].rolling(k).min()
+    high_max = df['High'].rolling(k).max()
+    pct_k = 100 * (df['Close'] - low_min) / (high_max - low_min + 1e-10)
+    pct_d = pct_k.rolling(d).mean()
+    return pct_k, pct_d
+
+
+def compute_cci(df: pd.DataFrame, period: int = 20) -> pd.Series:
+    """Commodity Channel Index."""
+    tp  = (df['High'] + df['Low'] + df['Close']) / 3
+    sma = tp.rolling(period).mean()
+    mad = tp.rolling(period).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
+    return (tp - sma) / (0.015 * mad + 1e-10)
+
+
+def compute_williams_r(df: pd.DataFrame, period: int = 14) -> pd.Series:
+    """Williams %R."""
+    high_max = df['High'].rolling(period).max()
+    low_min  = df['Low'].rolling(period).min()
+    return -100 * (high_max - df['Close']) / (high_max - low_min + 1e-10)
+
+
+def create_features(data: pd.DataFrame) -> pd.DataFrame:
+    """
+    22 teknik gösterge + 7 lag feature üretir.
+    Toplam: 29 input feature.
+    """
     df = data.copy()
-    df['Returns']    = df['Close'].pct_change()
-    df['High_Low']   = df['High'] - df['Low']
-    df['Close_Open'] = df['Close'] - df['Open']
 
-    for w in [5, 10, 20, 50]:
-        df[f'SMA_{w}'] = df['Close'].rolling(window=w).mean()
+    # ── Temel getiri & mum özellikleri ───────────────────────────────────────
+    df['Returns']       = df['Close'].pct_change()
+    df['Log_Returns']   = np.log(df['Close'] / df['Close'].shift(1))
+    df['High_Low']      = df['High'] - df['Low']
+    df['Close_Open']    = df['Close'] - df['Open']
+    df['Body_Ratio']    = df['Close_Open'].abs() / (df['High_Low'] + 1e-10)
+    df['Upper_Shadow']  = df['High'] - df[['Close', 'Open']].max(axis=1)
+    df['Lower_Shadow']  = df[['Close', 'Open']].min(axis=1) - df['Low']
 
-    delta = df['Close'].diff()
-    gain  = (delta.where(delta > 0, 0)).rolling(14).mean()
-    loss  = (-delta.where(delta < 0, 0)).rolling(14).mean()
-    df['RSI'] = 100 - (100 / (1 + gain / loss))
+    # ── Hareketli ortalamalar ─────────────────────────────────────────────────
+    for w in [5, 10, 20, 50]:
+        df[f'SMA_{w}']  = df['Close'].rolling(w).mean()
+        df[f'EMA_{w}']  = df['Close'].ewm(span=w, adjust=False).mean()
 
-    exp1 = df['Close'].ewm(span=12, adjust=False).mean()
-    exp2 = df['Close'].ewm(span=26, adjust=False).mean()
-    df['MACD']   = exp1 - exp2
-    df['Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
+    # SMA mesafe oranları
+    df['Price_SMA5_Ratio']  = df['Close'] / df['SMA_5']
+    df['Price_SMA20_Ratio'] = df['Close'] / df['SMA_20']
+    df['SMA5_SMA20_Cross']  = df['SMA_5'] - df['SMA_20']
 
+    # ── RSI ───────────────────────────────────────────────────────────────────
+    delta = df['Close'].diff()
+    gain  = delta.where(delta > 0, 0.0).rolling(14).mean()
+    loss  = (-delta.where(delta < 0, 0.0)).rolling(14).mean()
+    rs    = gain / (loss + 1e-10)
+    df['RSI'] = 100 - (100 / (1 + rs))
+
+    # ── MACD ──────────────────────────────────────────────────────────────────
+    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']
+
+    # ── Bollinger Bantları ────────────────────────────────────────────────────
     df['BB_middle'] = df['Close'].rolling(20).mean()
     df['BB_std']    = df['Close'].rolling(20).std()
     df['BB_upper']  = df['BB_middle'] + df['BB_std'] * 2
     df['BB_lower']  = df['BB_middle'] - df['BB_std'] * 2
-    df['BB_width']  = (df['BB_upper'] - df['BB_lower']) / df['BB_middle']
+    df['BB_width']  = (df['BB_upper'] - df['BB_lower']) / (df['BB_middle'] + 1e-10)
+    df['BB_pct']    = (df['Close'] - df['BB_lower']) / (df['BB_upper'] - df['BB_lower'] + 1e-10)
+
+    # ── ATR ───────────────────────────────────────────────────────────────────
+    df['ATR']     = compute_atr(df, 14)
+    df['ATR_Pct'] = df['ATR'] / df['Close']
+
+    # ── Stochastic ────────────────────────────────────────────────────────────
+    df['Stoch_K'], df['Stoch_D'] = compute_stoch(df)
+
+    # ── CCI ───────────────────────────────────────────────────────────────────
+    df['CCI'] = compute_cci(df, 20)
+
+    # ── Williams %R ───────────────────────────────────────────────────────────
+    df['WilliamsR'] = compute_williams_r(df, 14)
 
-    df['ATR'] = (df['High'] - df['Low']).rolling(14).mean()
+    # ── Volatilite ────────────────────────────────────────────────────────────
+    df['Volatility_5']  = df['Returns'].rolling(5).std()
+    df['Volatility_20'] = df['Returns'].rolling(20).std()
 
+    # ── Volume (varsa) ────────────────────────────────────────────────────────
+    if 'Volume' in df.columns:
+        df['Volume_MA']    = df['Volume'].rolling(10).mean()
+        df['Volume_Ratio'] = df['Volume'] / (df['Volume_MA'] + 1e-10)
+    else:
+        df['Volume_MA']    = 0.0
+        df['Volume_Ratio'] = 1.0
+
+    # ── Lag features ──────────────────────────────────────────────────────────
     for i in range(1, 8):
         df[f'Lag_{i}'] = df['Close'].shift(i)
 
     return df.dropna()
 
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  FEATURE KOLONLARI
+# ══════════════════════════════════════════════════════════════════════════════
 FEATURE_COLS = [
-    'Returns','High_Low','Close_Open',
-    'SMA_5','SMA_10','SMA_20','SMA_50',
-    'RSI','MACD','Signal',
-    'BB_middle','BB_upper','BB_lower','BB_width',
-    'ATR',
-    'Lag_1','Lag_2','Lag_3','Lag_4','Lag_5','Lag_6','Lag_7'
+    # Temel
+    'Returns', 'Log_Returns', 'High_Low', 'Close_Open',
+    'Body_Ratio', 'Upper_Shadow', 'Lower_Shadow',
+    # SMA / EMA
+    'SMA_5', 'SMA_10', 'SMA_20', 'SMA_50',
+    'EMA_5', 'EMA_10', 'EMA_20',
+    'Price_SMA5_Ratio', 'Price_SMA20_Ratio', 'SMA5_SMA20_Cross',
+    # Momentum
+    'RSI', 'MACD', 'MACD_Signal', 'MACD_Hist',
+    'Stoch_K', 'Stoch_D', 'CCI', 'WilliamsR',
+    # Volatilite / BB
+    'BB_middle', 'BB_upper', 'BB_lower', 'BB_width', 'BB_pct',
+    'ATR', 'ATR_Pct',
+    'Volatility_5', 'Volatility_20',
+    # Volume
+    'Volume_Ratio',
+    # Lag
+    'Lag_1', 'Lag_2', 'Lag_3', 'Lag_4', 'Lag_5', 'Lag_6', 'Lag_7',
 ]
 
-# ─── Model katmanı ────────────────────────────────────────────────────────────
-MODELS_DEF = {
-    'Random Forest':     RandomForestRegressor(n_estimators=200, random_state=42, n_jobs=-1),
-    'Gradient Boosting': GradientBoostingRegressor(n_estimators=200, learning_rate=0.05, random_state=42),
-    'AdaBoost':          AdaBoostRegressor(n_estimators=150, random_state=42),
-    'Ridge':             Ridge(alpha=0.5),
-    'SVR':               SVR(kernel='rbf', C=200, gamma=0.05, epsilon=0.0001),
-}
-
-def train_and_evaluate(df):
-    X = df[FEATURE_COLS].values
+# ══════════════════════════════════════════════════════════════════════════════
+#  MODEL KATMANI
+# ══════════════════════════════════════════════════════════════════════════════
+
+def build_models() -> dict:
+    """Her çağrıda taze model örnekleri döndürür (paralel eğitim güvenliği)."""
+    return {
+        'Random Forest':     RandomForestRegressor(
+                                 n_estimators=300, max_depth=12,
+                                 min_samples_leaf=3, random_state=42, n_jobs=-1),
+        'Gradient Boosting': GradientBoostingRegressor(
+                                 n_estimators=300, learning_rate=0.04,
+                                 max_depth=5, subsample=0.8, random_state=42),
+        'AdaBoost':          AdaBoostRegressor(
+                                 n_estimators=200, learning_rate=0.08, random_state=42),
+        'Ridge':             Ridge(alpha=0.3),
+        'SVR':               SVR(kernel='rbf', C=500, gamma='scale', epsilon=0.00005),
+    }
+
+
+def train_and_evaluate(df: pd.DataFrame):
+    """
+    Modelleri eğitir; son 10 günü test seti olarak kullanır.
+    Dönüş: trained_models, scaler, test_preds (dict), y_test
+    """
+    avail = [c for c in FEATURE_COLS if c in df.columns]
+    X = df[avail].values
     y = df['Close'].values
-    split = -10
 
+    split = -10
     X_train, X_test = X[:split], X[split:]
     y_train, y_test = y[:split], y[split:]
 
-    scaler = StandardScaler()
-    Xtr = scaler.fit_transform(X_train)
-    Xte = scaler.transform(X_test)
+    scaler  = StandardScaler()
+    X_tr_sc = scaler.fit_transform(X_train)
+    X_te_sc = scaler.transform(X_test)
+
+    models    = build_models()
+    trained   = {}
+    test_preds = {}
 
-    trained, test_preds = {}, {}
-    for name, m in MODELS_DEF.items():
-        m.fit(Xtr, y_train)
-        test_preds[name] = m.predict(Xte)
+    for name, m in models.items():
+        m.fit(X_tr_sc, y_train)
+        test_preds[name] = m.predict(X_te_sc)
         trained[name] = m
 
-    return trained, scaler, test_preds, y_test
+    return trained, scaler, test_preds, y_test, avail
 
-def predict_next(trained, scaler, df):
-    x = df[FEATURE_COLS].iloc[-1].values.reshape(1, -1)
+
+def predict_next(trained: dict, scaler, df: pd.DataFrame, avail: list):
+    """Son satırın feature'larından ertesi gün tahmini üretir."""
+    x  = df[avail].iloc[-1].values.reshape(1, -1)
     xs = scaler.transform(x)
-    preds = {n: float(m.predict(xs)[0]) for n, m in trained.items()}
+    preds    = {n: float(m.predict(xs)[0]) for n, m in trained.items()}
     ensemble = float(np.mean(list(preds.values())))
     return preds, ensemble
 
-# ─── Grafik ───────────────────────────────────────────────────────────────────
-def build_figure(df, next_preds, ensemble_pred, test_preds, y_test):
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  TP / SL HESAPLAMA  (ATR tabanlı risk yönetimi)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def compute_tp_sl(
+    current_price: float,
+    ensemble_pred: float,
+    atr: float,
+    atr_multiplier_sl: float = 1.5,
+    rr_ratio: float = 2.0,
+) -> dict:
+    """
+    ATR tabanlı TP / SL hesaplar.
+
+    Yön:  ensemble > current → LONG  |  ensemble < current → SHORT
+
+    SL = current ± (ATR × atr_multiplier_sl)
+    TP = current ± (|SL mesafesi| × rr_ratio)
+
+    Dönüş: direction, entry, sl, tp, sl_pips, tp_pips, rr, risk_pct
+    """
+    direction  = "LONG" if ensemble_pred > current_price else "SHORT"
+    sl_dist    = atr * atr_multiplier_sl
+    tp_dist    = sl_dist * rr_ratio
+
+    if direction == "LONG":
+        sl = current_price - sl_dist
+        tp = current_price + tp_dist
+    else:
+        sl = current_price + sl_dist
+        tp = current_price - tp_dist
+
+    pip_size  = 0.0001          # EUR/USD standart pip
+    sl_pips   = sl_dist / pip_size
+    tp_pips   = tp_dist / pip_size
+    risk_pct  = (sl_dist / current_price) * 100
+
+    return {
+        'direction' : direction,
+        'entry'     : current_price,
+        'sl'        : sl,
+        'tp'        : tp,
+        'sl_pips'   : sl_pips,
+        'tp_pips'   : tp_pips,
+        'rr'        : rr_ratio,
+        'risk_pct'  : risk_pct,
+        'atr'       : atr,
+    }
+
+
+def compute_signal_score(df: pd.DataFrame, direction: str) -> dict:
+    """
+    RSI · MACD · Stoch · CCI · BB pozisyonuna bakarak
+    sinyal gücünü 0–100 arasında puanlar.
+    """
+    row     = df.iloc[-1]
+    score   = 0
+    details = {}
+
+    rsi = float(row['RSI'])
+    if direction == "LONG":
+        if rsi < 70:
+            pts = max(0, (70 - rsi) / 70 * 25)
+            score += pts
+            details['RSI'] = f"{rsi:.1f} — boğa bölgesi  (+{pts:.0f}p)"
+        else:
+            details['RSI'] = f"{rsi:.1f} — aşırı alım  (0p)"
+    else:
+        if rsi > 30:
+            pts = max(0, (rsi - 30) / 70 * 25)
+            score += pts
+            details['RSI'] = f"{rsi:.1f} — ayı bölgesi  (+{pts:.0f}p)"
+        else:
+            details['RSI'] = f"{rsi:.1f} — aşırı satım  (0p)"
+
+    macd = float(row['MACD'])
+    mhist = float(row['MACD_Hist'])
+    if direction == "LONG":
+        pts = 20 if (macd > 0 and mhist > 0) else (10 if macd > 0 else 0)
+    else:
+        pts = 20 if (macd < 0 and mhist < 0) else (10 if macd < 0 else 0)
+    score += pts
+    details['MACD'] = f"macd={macd:.5f}  hist={mhist:.5f}  (+{pts}p)"
+
+    stk = float(row['Stoch_K'])
+    std = float(row['Stoch_D'])
+    if direction == "LONG":
+        pts = 20 if (stk < 80 and stk > std) else (10 if stk < 80 else 0)
+    else:
+        pts = 20 if (stk > 20 and stk < std) else (10 if stk > 20 else 0)
+    score += pts
+    details['Stoch'] = f"K={stk:.1f}  D={std:.1f}  (+{pts}p)"
+
+    cci = float(row['CCI'])
+    if direction == "LONG":
+        pts = 20 if cci > -100 else 5
+    else:
+        pts = 20 if cci < 100 else 5
+    score += pts
+    details['CCI'] = f"{cci:.1f}  (+{pts}p)"
+
+    bb_pct = float(row['BB_pct'])
+    if direction == "LONG":
+        pts = 15 if bb_pct < 0.5 else 5
+    else:
+        pts = 15 if bb_pct > 0.5 else 5
+    score += pts
+    details['BB%'] = f"{bb_pct:.2f}  (+{pts}p)"
+
+    label = ("GÜÇLÜ ✅" if score >= 75
+             else "ORTA ⚠" if score >= 45
+             else "ZAYIF ❌")
+
+    return {'score': min(100, score), 'label': label, 'details': details}
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  GRAFİK MOTORU
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _set_ax_style(ax, title: str = "", ylabel: str = ""):
+    ax.set_facecolor(PANEL)
+    ax.tick_params(colors=SUBTEXT, labelsize=7)
+    for spine in ax.spines.values():
+        spine.set_edgecolor(BORDER)
+    ax.grid(True, color=BORDER, linewidth=0.4, alpha=0.6)
+    if title:
+        ax.set_title(title, fontsize=8.5, color=TEXT, pad=7, loc='left', fontweight='bold')
+    if ylabel:
+        ax.set_ylabel(ylabel, fontsize=7, color=SUBTEXT)
+
+
+def build_figure(
+    df: pd.DataFrame,
+    next_preds: dict,
+    ensemble_pred: float,
+    test_preds: dict,
+    y_test: np.ndarray,
+    tp_sl: dict,
+) -> plt.Figure:
+
     plt.rcParams.update({
-        'font.family': 'monospace',
-        'text.color': TEXT,
-        'axes.labelcolor': SUBTEXT,
-        'xtick.color': SUBTEXT,
-        'ytick.color': SUBTEXT,
+        'font.family' : 'monospace',
+        'text.color'  : TEXT,
         'figure.facecolor': BG,
-        'axes.facecolor': PANEL,
-        'axes.edgecolor': BORDER,
-        'grid.color': BORDER,
-        'grid.linewidth': 0.5,
+        'axes.facecolor'  : PANEL,
+        'axes.edgecolor'  : BORDER,
+        'grid.color'      : BORDER,
+        'grid.linewidth'  : 0.4,
     })
 
-    fig = plt.figure(figsize=(14, 12))
-    gs = GridSpec(3, 2, figure=fig, hspace=0.45, wspace=0.35)
+    fig = plt.figure(figsize=(16, 15))
+    gs  = GridSpec(4, 2, figure=fig, hspace=0.52, wspace=0.32,
+                   left=0.06, right=0.97, top=0.94, bottom=0.04)
 
-    ax1 = fig.add_subplot(gs[0, :])   # Fiyat + BB
-    ax2 = fig.add_subplot(gs[1, 0])   # RSI
-    ax3 = fig.add_subplot(gs[1, 1])   # MACD
-    ax4 = fig.add_subplot(gs[2, :])   # Model tahminleri + hata
+    ax_price  = fig.add_subplot(gs[0, :])    # Fiyat + BB + TP/SL
+    ax_rsi    = fig.add_subplot(gs[1, 0])    # RSI
+    ax_macd   = fig.add_subplot(gs[1, 1])    # MACD
+    ax_stoch  = fig.add_subplot(gs[2, 0])    # Stochastic
+    ax_cci    = fig.add_subplot(gs[2, 1])    # CCI
+    ax_models = fig.add_subplot(gs[3, :])    # Model karşılaştırması
 
-    tail = df.tail(45)
+    tail = df.tail(50)
     idx  = np.arange(len(tail))
     cp   = float(df['Close'].iloc[-1])
 
-    # ── Panel 1: Fiyat ──────────────────────────────────────────────
-    ax1.fill_between(idx, tail['BB_lower'].values, tail['BB_upper'].values,
-                     alpha=0.08, color=ACCENT, label='Bollinger Bandı')
-    ax1.plot(idx, tail['BB_upper'].values, lw=0.5, color=ACCENT, alpha=0.4)
-    ax1.plot(idx, tail['BB_lower'].values, lw=0.5, color=ACCENT, alpha=0.4)
-    ax1.plot(idx, tail['Close'].values,    lw=1.8, color=TEXT,   label='Kapanış')
-    ax1.plot(idx, tail['SMA_20'].values,   lw=1.1, color=AMBER,  alpha=0.8, label='SMA 20', ls='--')
-    ax1.plot(idx, tail['SMA_50'].values,   lw=1.1, color=MUTED,  alpha=0.8, label='SMA 50', ls=':')
-
-    # Ensemble tahmini noktası
-    arrow_x = len(idx) + 0.5
-    ax1.annotate(
-        f'▶ {ensemble_pred:.5f}',
-        xy=(len(idx) - 1, cp),
-        xytext=(len(idx) + 1, ensemble_pred),
-        arrowprops=dict(arrowstyle='->', color=GREEN, lw=1.5),
-        color=GREEN, fontsize=9, fontweight='bold',
+    # ── PANEL 1: Fiyat + BB + TP/SL ─────────────────────────────────────────
+    _set_ax_style(ax_price, 'EUR/USD  ·  Son 50 Gün  +  Sonraki Gün Tahmini  (TP/SL)', 'Fiyat')
+    ax_price.fill_between(idx,
+        tail['BB_lower'].values, tail['BB_upper'].values,
+        alpha=0.07, color=ACCENT)
+    ax_price.plot(idx, tail['BB_upper'].values, lw=0.6, color=ACCENT, alpha=0.35, ls='--')
+    ax_price.plot(idx, tail['BB_lower'].values, lw=0.6, color=ACCENT, alpha=0.35, ls='--')
+    ax_price.plot(idx, tail['BB_middle'].values, lw=0.7, color=ACCENT, alpha=0.5, ls=':')
+    ax_price.plot(idx, tail['Close'].values,  lw=1.8, color=TEXT,  label='Kapanış', zorder=5)
+    ax_price.plot(idx, tail['SMA_20'].values, lw=1.0, color=AMBER, alpha=0.8, label='SMA 20', ls='--')
+    ax_price.plot(idx, tail['SMA_50'].values, lw=1.0, color=MUTED, alpha=0.7, label='SMA 50', ls=':')
+
+    # TP / SL yatay çizgiler
+    last_x = len(idx) - 1
+    ax_price.axhline(y=tp_sl['tp'], color=GREEN, lw=1.3, ls='--', alpha=0.9, zorder=4)
+    ax_price.axhline(y=tp_sl['sl'], color=RED,   lw=1.3, ls='--', alpha=0.9, zorder=4)
+    ax_price.axhline(y=cp,          color=TEXT,  lw=0.7, ls='-',  alpha=0.4, zorder=3)
+
+    r_margin = len(idx) * 0.02
+    ax_price.text(last_x + r_margin, tp_sl['tp'],
+                  f" TP {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f}p)",
+                  color=GREEN, fontsize=7.5, va='center', fontweight='bold')
+    ax_price.text(last_x + r_margin, tp_sl['sl'],
+                  f" SL {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f}p)",
+                  color=RED, fontsize=7.5, va='center', fontweight='bold')
+    ax_price.text(last_x + r_margin, cp,
+                  f" GİRİŞ {cp:.5f}",
+                  color=TEXT, fontsize=7.5, va='center')
+
+    # Ensemble ok
+    ax_price.annotate(
+        f"► ENS {ensemble_pred:.5f}",
+        xy=(last_x, cp),
+        xytext=(last_x + len(idx) * 0.04, ensemble_pred),
+        arrowprops=dict(arrowstyle='->', color=ACCENT2, lw=1.4, connectionstyle='arc3,rad=0.2'),
+        color=ACCENT2, fontsize=8, fontweight='bold', zorder=6,
     )
-    ax1.axhline(y=cp, color=MUTED, lw=0.8, ls='--', alpha=0.5)
-
-    ax1.set_title('EUR/USD  ·  Son 45 Gün  +  Sonraki Gün Tahmini',
-                  fontsize=11, color=TEXT, pad=10, loc='left', fontweight='bold')
-    ax1.legend(fontsize=7, framealpha=0.15, labelcolor=SUBTEXT, ncol=4)
-    ax1.set_ylabel('Fiyat', fontsize=8)
-    ax1.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
-
-    # ── Panel 2: RSI ─────────────────────────────────────────────────
-    rsi_tail = tail['RSI'].values
-    ax2.plot(idx, rsi_tail, lw=1.4, color=ACCENT)
-    ax2.fill_between(idx, rsi_tail, 50, where=(rsi_tail >= 50), alpha=0.15, color=GREEN)
-    ax2.fill_between(idx, rsi_tail, 50, where=(rsi_tail < 50),  alpha=0.15, color=RED)
-    ax2.axhline(70, color=RED,   lw=0.8, ls='--', alpha=0.6)
-    ax2.axhline(30, color=GREEN, lw=0.8, ls='--', alpha=0.6)
-    ax2.set_ylim(0, 100)
-    ax2.set_title('RSI (14)', fontsize=9, color=TEXT, pad=6, loc='left')
-    ax2.set_ylabel('RSI', fontsize=8)
-    for level, lbl in [(70, 'OB'), (30, 'OS')]:
-        ax2.text(len(idx), level, lbl, color=SUBTEXT, fontsize=7, va='center')
-
-    # ── Panel 3: MACD ────────────────────────────────────────────────
-    macd   = tail['MACD'].values
-    signal = tail['Signal'].values
-    hist   = macd - signal
-    colors_hist = [GREEN if v >= 0 else RED for v in hist]
-    ax3.bar(idx, hist, color=colors_hist, alpha=0.5, width=0.8, label='Histogram')
-    ax3.plot(idx, macd,   lw=1.3, color=ACCENT, label='MACD')
-    ax3.plot(idx, signal, lw=1.1, color=AMBER,  label='Signal', ls='--')
-    ax3.axhline(0, color=MUTED, lw=0.7)
-    ax3.set_title('MACD (12/26/9)', fontsize=9, color=TEXT, pad=6, loc='left')
-    ax3.legend(fontsize=7, framealpha=0.1, labelcolor=SUBTEXT)
-
-    # ── Panel 4: Model karşılaştırması ───────────────────────────────
+
+    ax_price.legend(fontsize=7, framealpha=0.15, labelcolor=SUBTEXT, ncol=5, loc='upper left')
+    ax_price.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
+
+    # ── PANEL 2: RSI ─────────────────────────────────────────────────────────
+    _set_ax_style(ax_rsi, 'RSI (14)', 'RSI')
+    rsi_v = tail['RSI'].values
+    ax_rsi.plot(idx, rsi_v, lw=1.4, color=ACCENT)
+    ax_rsi.fill_between(idx, rsi_v, 70, where=(rsi_v >= 70), alpha=0.18, color=RED)
+    ax_rsi.fill_between(idx, rsi_v, 30, where=(rsi_v <= 30), alpha=0.18, color=GREEN)
+    ax_rsi.fill_between(idx, rsi_v, 50, where=((rsi_v > 50) & (rsi_v < 70)), alpha=0.07, color=GREEN)
+    ax_rsi.fill_between(idx, rsi_v, 50, where=((rsi_v < 50) & (rsi_v > 30)), alpha=0.07, color=RED)
+    for lvl, lbl, c in [(70, 'OB', RED), (50, '50', MUTED), (30, 'OS', GREEN)]:
+        ax_rsi.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
+        ax_rsi.text(len(idx), lvl, f' {lbl}', color=c, fontsize=6.5, va='center')
+    ax_rsi.set_ylim(0, 100)
+
+    # ── PANEL 3: MACD ─────────────────────────────────────────────────────────
+    _set_ax_style(ax_macd, 'MACD (12 / 26 / 9)')
+    macd_v  = tail['MACD'].values
+    sig_v   = tail['MACD_Signal'].values
+    hist_v  = macd_v - sig_v
+    hcolors = [GREEN if v >= 0 else RED for v in hist_v]
+    ax_macd.bar(idx, hist_v, color=hcolors, alpha=0.45, width=0.75, label='Histogram')
+    ax_macd.plot(idx, macd_v, lw=1.3, color=ACCENT, label='MACD')
+    ax_macd.plot(idx, sig_v,  lw=1.1, color=AMBER,  label='Signal', ls='--')
+    ax_macd.axhline(0, color=MUTED, lw=0.7)
+    ax_macd.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=3)
+
+    # ── PANEL 4: Stochastic ───────────────────────────────────────────────────
+    _set_ax_style(ax_stoch, 'Stochastic (14,3)', '%')
+    stk_v = tail['Stoch_K'].values
+    std_v = tail['Stoch_D'].values
+    ax_stoch.plot(idx, stk_v, lw=1.3, color=ACCENT, label='%K')
+    ax_stoch.plot(idx, std_v, lw=1.0, color=AMBER,  label='%D', ls='--')
+    ax_stoch.fill_between(idx, stk_v, 80, where=(stk_v >= 80), alpha=0.12, color=RED)
+    ax_stoch.fill_between(idx, stk_v, 20, where=(stk_v <= 20), alpha=0.12, color=GREEN)
+    for lvl, c in [(80, RED), (20, GREEN)]:
+        ax_stoch.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
+    ax_stoch.set_ylim(-5, 105)
+    ax_stoch.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
+
+    # ── PANEL 5: CCI ──────────────────────────────────────────────────────────
+    _set_ax_style(ax_cci, 'CCI (20)')
+    cci_v = tail['CCI'].values
+    ax_cci.plot(idx, cci_v, lw=1.3, color=PURPLE)
+    ax_cci.fill_between(idx, cci_v, 100,  where=(cci_v >= 100),  alpha=0.12, color=RED)
+    ax_cci.fill_between(idx, cci_v, -100, where=(cci_v <= -100), alpha=0.12, color=GREEN)
+    for lvl, c in [(100, RED), (0, MUTED), (-100, GREEN)]:
+        ax_cci.axhline(lvl, color=c, lw=0.7, ls='--', alpha=0.5)
+
+    # ── PANEL 6: Model karşılaştırması ────────────────────────────────────────
+    _set_ax_style(ax_models, '5 Model Tahmini  vs  Giriş Fiyatı  ·  (ATR TP/SL dahil)', 'Fiyat')
     names  = list(next_preds.keys())
     values = [next_preds[n] for n in names]
     maes   = [float(np.mean(np.abs(test_preds[n] - y_test))) for n in names]
+    x_pos  = np.arange(len(names))
 
-    x_pos = np.arange(len(names))
-    bar_colors = [GREEN if v > cp else RED for v in values]
+    bcolors = [GREEN if v > cp else RED for v in values]
+    bars = ax_models.bar(x_pos, values, color=bcolors, alpha=0.70,
+                         width=0.55, zorder=3, edgecolor=BORDER, linewidth=0.5)
 
-    bars = ax4.bar(x_pos, values, color=bar_colors, alpha=0.75, width=0.55, zorder=3)
-    ax4.axhline(y=cp, color=TEXT, lw=1.2, ls='--', alpha=0.7, label=f'Mevcut {cp:.5f}', zorder=4)
-    ax4.axhline(y=ensemble_pred, color=ACCENT, lw=1.5, ls='-', alpha=0.9,
-                label=f'Ensemble {ensemble_pred:.5f}', zorder=4)
+    ax_models.axhline(y=cp,           color=TEXT,  lw=1.4, ls='--', alpha=0.7,
+                      label=f'Giriş {cp:.5f}', zorder=4)
+    ax_models.axhline(y=ensemble_pred, color=ACCENT2, lw=1.6, ls='-', alpha=0.9,
+                      label=f'Ensemble {ensemble_pred:.5f}', zorder=4)
+    ax_models.axhline(y=tp_sl['tp'],  color=GREEN, lw=1.0, ls=':', alpha=0.7,
+                      label=f"TP {tp_sl['tp']:.5f}", zorder=3)
+    ax_models.axhline(y=tp_sl['sl'],  color=RED,   lw=1.0, ls=':', alpha=0.7,
+                      label=f"SL {tp_sl['sl']:.5f}", zorder=3)
 
     for bar, val, mae in zip(bars, values, maes):
-        pct = (val - cp) / cp * 100
-        sign = '+' if pct >= 0 else ''
-        ax4.text(bar.get_x() + bar.get_width()/2, val + 0.00003,
-                 f'{sign}{pct:.3f}%\nMAE {mae:.5f}',
-                 ha='center', va='bottom', fontsize=7.5, color=TEXT, fontweight='bold')
+        pct   = (val - cp) / cp * 100
+        sign  = '+' if pct >= 0 else ''
+        label = f"{sign}{pct:.3f}%\nMAE {mae:.5f}"
+        y_off = 0.00003 if val >= cp else -0.00006
+        va    = 'bottom' if val >= cp else 'top'
+        ax_models.text(bar.get_x() + bar.get_width() / 2,
+                       val + y_off, label,
+                       ha='center', va=va, fontsize=7, color=TEXT, fontweight='bold')
+
+    ax_models.set_xticks(x_pos)
+    ax_models.set_xticklabels(names, fontsize=8.5, color=TEXT)
+    ax_models.legend(fontsize=7.5, framealpha=0.15, labelcolor=SUBTEXT, ncol=4)
+    ax_models.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
+
+    # ── Ana başlık ────────────────────────────────────────────────────────────
+    direction_label = f"{'▲ LONG' if tp_sl['direction'] == 'LONG' else '▼ SHORT'}  ·  " \
+                      f"TP +{tp_sl['tp_pips']:.0f}p  ·  SL -{tp_sl['sl_pips']:.0f}p  ·  " \
+                      f"R:R 1:{tp_sl['rr']}"
+    dir_color = GREEN if tp_sl['direction'] == 'LONG' else RED
+
+    fig.text(0.06, 0.97, "EUR/USD  ·  ENSEMBLE FORECAST ENGINE",
+             fontsize=13, color=TEXT, fontweight='bold', va='top')
+    fig.text(0.06, 0.955, direction_label,
+             fontsize=9, color=dir_color, va='top')
+    fig.text(0.97, 0.97, datetime.now().strftime('%d %b %Y  %H:%M'),
+             fontsize=8, color=SUBTEXT, va='top', ha='right')
 
-    ax4.set_xticks(x_pos)
-    ax4.set_xticklabels(names, fontsize=9)
-    ax4.set_title('5 Model Tahmini  vs  Mevcut Fiyat', fontsize=9, color=TEXT, pad=6, loc='left')
-    ax4.legend(fontsize=8, framealpha=0.15, labelcolor=SUBTEXT)
-    ax4.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
+    return fig
 
-    fig.suptitle('EUR/USD  ·  ENSEMBLE TAHMİN SİSTEMİ',
-                 fontsize=13, color=TEXT, fontweight='bold', y=0.98)
 
-    return fig
+# ══════════════════════════════════════════════════════════════════════════════
+#  ANA TAHMİN FONKSİYONU
+# ══════════════════════════════════════════════════════════════════════════════
 
-# ─── Ana tahmin fonksiyonu ───────────────────────────────────────────────────
 def predict_eurusd():
-    import traceback
     try:
+        # 1. Veri
         data = get_forex_data()
         if data is None:
-            return "❌ Veri indirilemedi.", None
-
-        df      = create_features(data)
-        trained, scaler, test_preds, y_test = train_and_evaluate(df)
-        next_preds, ensemble = predict_next(trained, scaler, df)
-
-        cp = float(df['Close'].iloc[-1])
-        ens_chg = (ensemble - cp) / cp * 100
-        direction = "YUKARI ▲" if ens_chg > 0 else "AŞAĞI ▼"
-        dir_color = "📈" if ens_chg > 0 else "📉"
-
-        rsi_val  = float(df['RSI'].iloc[-1])
-        macd_val = float(df['MACD'].iloc[-1])
-        sig_val  = float(df['Signal'].iloc[-1])
-        rsi_status = "Aşırı Alım" if rsi_val > 70 else ("Aşırı Satım" if rsi_val < 30 else "Nötr")
-        macd_cross = "Boğa" if macd_val > sig_val else "Ayı"
+            return "❌ Veri indirilemedi. İnternet bağlantınızı kontrol edin.", None
+
+        # 2. Feature mühendisliği
+        df = create_features(data)
+        if len(df) < 20:
+            return "❌ Yeterli veri yok (min 20 satır gerekli).", None
+
+        # 3. Eğitim & backtest
+        trained, scaler, test_preds, y_test, avail = train_and_evaluate(df)
+
+        # 4. Tahmin
+        next_preds, ensemble = predict_next(trained, scaler, df, avail)
+
+        # 5. TP / SL
+        cp  = float(df['Close'].iloc[-1])
+        atr = float(df['ATR'].iloc[-1])
+        tp_sl = compute_tp_sl(
+            current_price      = cp,
+            ensemble_pred      = ensemble,
+            atr                = atr,
+            atr_multiplier_sl  = 1.5,
+            rr_ratio           = 2.0,
+        )
+
+        # 6. Sinyal gücü
+        sig = compute_signal_score(df, tp_sl['direction'])
+
+        # 7. Backtest metrikleri
+        ens_test  = np.mean([test_preds[n] for n in test_preds], axis=0)
+        ens_mae   = float(np.mean(np.abs(ens_test - y_test)))
+        ens_rmse  = float(np.sqrt(np.mean((ens_test - y_test) ** 2)))
+        hit_arr   = np.sign(np.diff(np.append([y_test[0]], ens_test))) == np.sign(np.diff(y_test))
+        hit_rate  = float(np.mean(hit_arr)) * 100
+
+        # 8. Teknik durum
+        rsi_val    = float(df['RSI'].iloc[-1])
+        macd_val   = float(df['MACD'].iloc[-1])
+        mhist_val  = float(df['MACD_Hist'].iloc[-1])
+        stk_val    = float(df['Stoch_K'].iloc[-1])
+        std_val    = float(df['Stoch_D'].iloc[-1])
+        cci_val    = float(df['CCI'].iloc[-1])
+        wr_val     = float(df['WilliamsR'].iloc[-1])
+        bb_pct_val = float(df['BB_pct'].iloc[-1])
+        vol20_val  = float(df['Volatility_20'].iloc[-1]) * 100
+        atr_pct    = float(df['ATR_Pct'].iloc[-1]) * 100
+
+        rsi_lbl  = "Aşırı Alım ⚠" if rsi_val > 70 else ("Aşırı Satım ⚠" if rsi_val < 30 else "Nötr  ✓")
+        macd_lbl = "Boğa ▲" if macd_val > 0 else "Ayı  ▼"
+        stk_lbl  = "%K > %D  ▲" if stk_val > std_val else "%K < %D  ▼"
+        ens_chg  = (ensemble - cp) / cp * 100
+
+        # ── Rapor metni ───────────────────────────────────────────────────────
+        W = 52   # satır genişliği
+        sep  = "━" * W
+        sep2 = "─" * W
 
         lines = [
-            f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
-            f"  EUR/USD  ·  ENSEMBLE TAHMİN RAPORU",
+            sep,
+            f"  EUR/USD  ·  ENSEMBLE FORECAST ENGINE",
             f"  {datetime.now().strftime('%d %b %Y  %H:%M:%S')}",
-            f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
-            f"",
-            f"  MEVCUT FİYAT   :  {cp:.5f}",
-            f"  ENSEMBLE       :  {ensemble:.5f}  ({ens_chg:+.3f}%)  {dir_color} {direction}",
-            f"",
-            f"  ─── TEKNİK DURUM ───────────────────────────",
-            f"  RSI (14)       :  {rsi_val:.1f}  →  {rsi_status}",
-            f"  MACD Sinyali   :  {macd_cross} kesişimi",
-            f"  BB Pozisyonu   :  {float(df['BB_lower'].iloc[-1]):.5f}  ↔  {float(df['BB_upper'].iloc[-1]):.5f}",
-            f"",
-            f"  ─── MODEL TAHMİNLERİ ───────────────────────",
+            sep,
+            "",
+            f"  {'MEVCUT FİYAT':<22}:  {cp:.5f}",
+            f"  {'ENSEMBLE TAHMİN':<22}:  {ensemble:.5f}  ({ens_chg:+.3f}%)",
+            f"  {'YÖN':<22}:  {tp_sl['direction']}",
+            "",
+            f"  {'─── RİSK YÖNETİMİ (ATR × 1.5 / R:R 1:2)':<{W-2}}",
+            f"  {'GİRİŞ':<22}:  {tp_sl['entry']:.5f}",
+            f"  {'TAKE PROFIT (TP)':<22}:  {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f} pip)",
+            f"  {'STOP LOSS (SL)':<22}:  {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f} pip)",
+            f"  {'R:R ORANI':<22}:  1 : {tp_sl['rr']:.1f}",
+            f"  {'RISK (%)':<22}:  {tp_sl['risk_pct']:.3f}%",
+            f"  {'ATR (14)':<22}:  {atr:.5f}  ({atr_pct:.3f}%)",
+            "",
+            f"  {'─── SİNYAL GÜCÜ':<{W-2}}",
+            f"  {'SKOR':<22}:  {sig['score']:.0f} / 100  →  {sig['label']}",
         ]
 
-        for name, val in next_preds.items():
-            chg = (val - cp) / cp * 100
-            mae = float(np.mean(np.abs(test_preds[name] - y_test)))
-            arrow = "▲" if chg > 0 else "▼"
-            lines.append(f"  {name:<20s}:  {val:.5f}  ({chg:+.3f}%)  {arrow}  MAE={mae:.5f}")
+        for ind, detail in sig['details'].items():
+            lines.append(f"    {ind:<20}:  {detail}")
 
         lines += [
-            f"",
-            f"  ─── BACKTEST (Son 10 Gün) ──────────────────",
+            "",
+            f"  {'─── TEKNİK GÖSTERGELER':<{W-2}}",
+            f"  {'RSI (14)':<22}:  {rsi_val:.2f}  →  {rsi_lbl}",
+            f"  {'MACD':<22}:  {macd_val:.5f}  →  {macd_lbl}",
+            f"  {'MACD Histogram':<22}:  {mhist_val:.5f}",
+            f"  {'Stochastic K/D':<22}:  {stk_val:.1f} / {std_val:.1f}  →  {stk_lbl}",
+            f"  {'CCI (20)':<22}:  {cci_val:.1f}",
+            f"  {'Williams %R':<22}:  {wr_val:.1f}",
+            f"  {'BB Pozisyonu (%)':<22}:  {bb_pct_val:.3f}",
+            f"  {'Volatilite (20g σ)':<22}:  {vol20_val:.4f}%",
+            "",
+            f"  {'─── MODEL TAHMİNLERİ':<{W-2}}",
         ]
 
-        ens_test = np.mean([test_preds[n] for n in test_preds], axis=0)
-        ens_mae  = float(np.mean(np.abs(ens_test - y_test)))
-        ens_rmse = float(np.sqrt(np.mean((ens_test - y_test) ** 2)))
-        hit_rate = float(np.mean(np.sign(np.diff(np.append([y_test[0]], ens_test))) ==
-                                  np.sign(np.diff(y_test)))) * 100
+        for name, val in next_preds.items():
+            chg  = (val - cp) / cp * 100
+            mae  = float(np.mean(np.abs(test_preds[name] - y_test)))
+            rmse = float(np.sqrt(np.mean((test_preds[name] - y_test) ** 2)))
+            ar   = "▲" if chg > 0 else "▼"
+            lines.append(
+                f"  {name:<22}:  {val:.5f}  ({chg:+.3f}%)  {ar}"
+                f"  MAE={mae:.5f}  RMSE={rmse:.5f}"
+            )
 
         lines += [
-            f"  Ensemble MAE   :  {ens_mae:.6f}",
-            f"  Ensemble RMSE  :  {ens_rmse:.6f}",
-            f"  Yön Doğruluğu  :  {hit_rate:.1f}%",
-            f"",
-            f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+            "",
+            f"  {'─── BACKTEST (Son 10 Gün)':<{W-2}}",
+            f"  {'Ensemble MAE':<22}:  {ens_mae:.6f}",
+            f"  {'Ensemble RMSE':<22}:  {ens_rmse:.6f}",
+            f"  {'Yön Doğruluğu':<22}:  {hit_rate:.1f}%",
+            "",
+            sep,
             f"  ⚠  Yalnızca eğitim amaçlıdır. Finansal tavsiye değildir.",
-            f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+            sep,
         ]
 
         output_text = "\n".join(lines)
-        fig = build_figure(df, next_preds, ensemble, test_preds, y_test)
+
+        # 9. Grafik
+        fig = build_figure(df, next_preds, ensemble, test_preds, y_test, tp_sl)
 
         return output_text, fig
 
-    except Exception as e:
+    except Exception:
         return f"❌ Hata:\n{traceback.format_exc()}", None
 
-# ─── CSS ─────────────────────────────────────────────────────────────────────
+
+# ════════════════���═════════════════════════════════════════════════════════════
+#  CSS & HTML
+# ══════════════════════════════════════════════════════════════════════════════
+
 CSS = """
+* { box-sizing: border-box; }
 body, .gradio-container {
     background: #0A0E17 !important;
-    font-family: 'JetBrains Mono', 'Fira Code', monospace !important;
+    font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace !important;
     color: #F1F5F9 !important;
 }
-.gr-button-primary {
-    background: linear-gradient(135deg, #1D4ED8, #3B82F6) !important;
+button.lg.primary {
+    background: linear-gradient(135deg, #1D4ED8 0%, #4F46E5 100%) !important;
     border: none !important;
     color: #fff !important;
     font-weight: 700 !important;
-    letter-spacing: 0.05em !important;
-    padding: 12px 28px !important;
+    letter-spacing: .06em !important;
+    padding: 14px 36px !important;
     border-radius: 6px !important;
-    transition: opacity .2s !important;
+    font-size: 1rem !important;
+    transition: filter .2s !important;
 }
-.gr-button-primary:hover { opacity: 0.85 !important; }
-.gr-textbox textarea {
-    background: #111827 !important;
+button.lg.primary:hover { filter: brightness(1.15) !important; }
+.gr-textbox textarea, textarea {
+    background: #0F1623 !important;
     color: #94A3B8 !important;
     border: 1px solid #1E293B !important;
     font-family: 'JetBrains Mono', monospace !important;
-    font-size: 12.5px !important;
-    line-height: 1.7 !important;
-}
-.gr-box, .gr-panel {
-    background: #111827 !important;
-    border: 1px solid #1E293B !important;
+    font-size: 12px !important;
+    line-height: 1.8 !important;
+    border-radius: 6px !important;
 }
+label span { color: #64748B !important; font-size: .78rem !important; }
+.gr-panel, .gr-box { background: #111827 !important; border: 1px solid #1E293B !important; }
 footer { display: none !important; }
 """
 
-HEADER_HTML = """
+HEADER = """
 <div style="
-    background: linear-gradient(135deg, #0A0E17 0%, #111827 100%);
+    background: linear-gradient(160deg,#0A0E17 0%,#0F1623 60%,#111827 100%);
     border: 1px solid #1E293B;
     border-radius: 10px;
-    padding: 28px 32px 20px;
-    margin-bottom: 8px;
+    padding: 28px 32px 22px;
+    margin-bottom: 12px;
 ">
-  <div style="display:flex; align-items:center; gap:14px; margin-bottom:10px;">
-    <span style="font-size:2rem;">💹</span>
+  <div style="display:flex;align-items:center;gap:16px;margin-bottom:12px;">
+    <span style="font-size:2.4rem;line-height:1;">💹</span>
     <div>
-      <h1 style="margin:0; font-size:1.5rem; font-weight:800; color:#F1F5F9; letter-spacing:.04em;">
-        EUR/USD  ·  ENSEMBLE FORECAST ENGINE
+      <h1 style="margin:0;font-size:1.6rem;font-weight:900;color:#F1F5F9;letter-spacing:.05em;">
+        EUR/USD &nbsp;·&nbsp; ENSEMBLE FORECAST ENGINE
       </h1>
-      <p style="margin:4px 0 0; color:#64748B; font-size:.82rem; font-family:monospace;">
-        Random Forest  ·  Gradient Boosting  ·  AdaBoost  ·  Ridge  ·  SVR
+      <p style="margin:5px 0 0;color:#64748B;font-size:.8rem;font-family:monospace;">
+        Random Forest &nbsp;·&nbsp; Gradient Boosting &nbsp;·&nbsp;
+        AdaBoost &nbsp;·&nbsp; Ridge &nbsp;·&nbsp; SVR
       </p>
     </div>
   </div>
-  <div style="display:flex; gap:20px; flex-wrap:wrap; margin-top:14px;">
-    <span style="background:#1E293B; border-radius:4px; padding:4px 12px; font-size:.78rem; color:#94A3B8;">📡 Yahoo Finance — 90g</span>
-    <span style="background:#1E293B; border-radius:4px; padding:4px 12px; font-size:.78rem; color:#94A3B8;">📐 22 Teknik Gösterge</span>
-    <span style="background:#1E293B; border-radius:4px; padding:4px 12px; font-size:.78rem; color:#94A3B8;">🧪 10-Gün Backtest</span>
-    <span style="background:#1E293B; border-radius:4px; padding:4px 12px; font-size:.78rem; color:#94A3B8;">⚡ Tek Tıkla Güncelle</span>
+  <div style="display:flex;gap:10px;flex-wrap:wrap;margin-top:4px;">
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📡 Yahoo Finance 120g</span>
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📐 42 Feature</span>
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">🧪 10-Gün Backtest</span>
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">🎯 ATR TP/SL</span>
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">📊 5 Teknik Osilatör</span>
+    <span style="background:#1E293B;border-radius:4px;padding:5px 14px;font-size:.76rem;color:#94A3B8;">⚡ Tek Tıkla Güncelle</span>
   </div>
 </div>
 """
 
-# ─── Gradio arayüzü ──────────────────────────────────────────────────────────
-with gr.Blocks(css=CSS, title="EUR/USD Ensemble Forecast") as app:
-    gr.HTML(HEADER_HTML)
+# ══════════════════════════════════════════════════════════════════════════════
+#  GRADIO ARAYÜZÜ
+# ══════════════════════════════════════════════════════════════════════════════
+
+with gr.Blocks(css=CSS, title="EUR/USD Ensemble Forecast Engine") as app:
+    gr.HTML(HEADER)
 
     with gr.Row():
         predict_btn = gr.Button("⟳  TAHMİN YAP / YENİLE", variant="primary", scale=1)
 
     with gr.Row():
-        with gr.Column(scale=1):
+        with gr.Column(scale=1, min_width=380):
             output_text = gr.Textbox(
                 label="RAPOR",
-                lines=30,
+                lines=38,
                 interactive=False,
-                show_copy_button=True,
             )
         with gr.Column(scale=2):
             output_plot = gr.Plot(label="GRAFİKLER")