Update app.py

app.py

@@ -1,984 +1,341 @@
-# ══════════════════════════════════════════════════════════════════════════════
-#  EUR/USD  ·  RIDGE FORECAST ENGINE  ·  Ultra-Premium Edition
-#  Model: Stacked Ridge Regression (L1+L2 optimised, polynomial features)
-#  Forecast horizon: 1 or 2 days ahead
-#  TP/SL: ATR-based risk management  ·  Signal scoring  ·  Backtest
-#  Data: Yahoo Finance (yfinance)
-# ══════════════════════════════════════════════════════════════════════════════
+"""
+EURUSD Pattern AI - yfinance + Gradio
+Candlestick pattern tespiti ve AI yorumu
+"""
 
 import gradio as gr
+import yfinance as yf
 import pandas as pd
 import numpy as np
-from datetime import datetime
-import yfinance as yf
-from sklearn.linear_model import Ridge, RidgeCV
-from sklearn.preprocessing import StandardScaler, PolynomialFeatures
-from sklearn.pipeline import Pipeline
-from sklearn.metrics import mean_absolute_error
-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.colors import LinearSegmentedColormap
-import traceback
-import warnings
-warnings.filterwarnings('ignore')
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  DESIGN TOKENS  (Obsidian / Phosphor palette)
-# ══════════════════════════════════════════════════════════════════════════════
-BG      = "#080C12"
-PANEL   = "#0C1119"
-PANEL2  = "#10161F"
-BORDER  = "#1A2233"
-BORDER2 = "#243044"
-
-ACID    = "#00FFB2"       # phosphor-green accent — signature element
-ACID2   = "#00D4FF"       # cyan secondary
-ACID3   = "#7B61FF"       # violet tertiary
-WARM    = "#FF6B35"       # orange for SHORT signals
-WARN    = "#FFB800"       # amber for warnings
-RED     = "#FF3D5A"
-GREEN   = "#00E88F"
-MUTED   = "#3A4A5E"
-TEXT    = "#E8EDF5"
-SUBTEXT = "#6B7E99"
-DIM     = "#3A4A5E"
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  DATA LAYER
-# ══════════════════════════════════════════════════════════════════════════════
-
-def get_forex_data(symbol: str = "EURUSD=X", period: str = "200d") -> pd.DataFrame | None:
-    try:
-        raw = yf.download(symbol, period=period, interval="1d", progress=False, auto_adjust=True)
-        if raw is None or len(raw) < 80:
-            return None
-        if isinstance(raw.columns, pd.MultiIndex):
-            raw.columns = raw.columns.get_level_values(0)
-        return raw
-    except Exception:
-        return None
-
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+
+# ─── PATTERN TESPİT FONKSİYONLARI ───────────────────────────────────────────
+
+def detect_patterns(df):
+    """Temel candlestick patternleri tespit eder."""
+    patterns = []
+    df = df.copy()
+
+    o = df["Open"].values
+    h = df["High"].values
+    l = df["Low"].values
+    c = df["Close"].values
+    dates = df.index
+
+    for i in range(2, len(df)):
+        found = []
+
+        body      = abs(c[i] - o[i])
+        body_prev = abs(c[i-1] - o[i-1])
+        rng       = h[i] - l[i]
+        upper_wick = h[i] - max(c[i], o[i])
+        lower_wick = min(c[i], o[i]) - l[i]
+
+        # Doji
+        if body < rng * 0.1:
+            found.append("🔵 Doji")
+
+        # Hammer
+        if (lower_wick > body * 2 and upper_wick < body * 0.5
+                and c[i-1] < o[i-1]):
+            found.append("🟢 Hammer (Bullish)")
+
+        # Shooting Star
+        if (upper_wick > body * 2 and lower_wick < body * 0.5
+                and c[i-1] > o[i-1]):
+            found.append("🔴 Shooting Star (Bearish)")
+
+        # Bullish Engulfing
+        if (c[i-1] < o[i-1] and c[i] > o[i]
+                and c[i] > o[i-1] and o[i] < c[i-1]):
+            found.append("🟢 Bullish Engulfing")
+
+        # Bearish Engulfing
+        if (c[i-1] > o[i-1] and c[i] < o[i]
+                and c[i] < o[i-1] and o[i] > c[i-1]):
+            found.append("🔴 Bearish Engulfing")
+
+        # Morning Star
+        if (i >= 2 and c[i-2] < o[i-2]
+                and body_prev < abs(c[i-2] - o[i-2]) * 0.3
+                and c[i] > o[i]
+                and c[i] > (c[i-2] + o[i-2]) / 2):
+            found.append("🟢 Morning Star")
+
+        # Evening Star
+        if (i >= 2 and c[i-2] > o[i-2]
+                and body_prev < abs(c[i-2] - o[i-2]) * 0.3
+                and c[i] < o[i]
+                and c[i] < (c[i-2] + o[i-2]) / 2):
+            found.append("🔴 Evening Star")
+
+        # Three White Soldiers
+        if (i >= 2
+                and c[i] > o[i] and c[i-1] > o[i-1] and c[i-2] > o[i-2]
+                and c[i] > c[i-1] > c[i-2]):
+            found.append("🟢 Three White Soldiers")
+
+        # Three Black Crows
+        if (i >= 2
+                and c[i] < o[i] and c[i-1] < o[i-1] and c[i-2] < o[i-2]
+                and c[i] < c[i-1] < c[i-2]):
+            found.append("🔴 Three Black Crows")
+
+        # Spinning Top
+        if (body < rng * 0.3 and upper_wick > body and lower_wick > body):
+            found.append("🔵 Spinning Top")
+
+        if found:
+            patterns.append({
+                "Tarih": dates[i].strftime("%Y-%m-%d %H:%M") if hasattr(dates[i], "hour") else str(dates[i])[:10],
+                "Pattern": ", ".join(found),
+                "Close": round(c[i], 5),
+                "Yön": "↑ Bullish" if any("Bullish" in p or "Hammer" in p or "Soldier" in p or "Morning" in p for p in found)
+                       else ("↓ Bearish" if any("Bearish" in p or "Star" in p or "Crow" in p or "Evening" in p for p in found)
+                       else "↔ Nötr"),
+            })
+
+    return patterns[-30:] if len(patterns) > 30 else patterns  # son 30 pattern
+
+
+def calculate_indicators(df):
+    """RSI, EMA, Bollinger hesaplar."""
+    df = df.copy()
+
+    # EMA
+    df["EMA20"] = df["Close"].ewm(span=20).mean()
+    df["EMA50"] = df["Close"].ewm(span=50).mean()
 
-def compute_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
-    high, low, prev_close = df['High'], df['Low'], 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()
+    # RSI
+    delta = df["Close"].diff()
+    gain  = delta.clip(lower=0).rolling(14).mean()
+    loss  = (-delta.clip(upper=0)).rolling(14).mean()
+    rs    = gain / loss
+    df["RSI"] = 100 - (100 / (1 + rs))
 
+    # Bollinger
+    df["BB_mid"]   = df["Close"].rolling(20).mean()
+    std            = df["Close"].rolling(20).std()
+    df["BB_upper"] = df["BB_mid"] + 2 * std
+    df["BB_lower"] = df["BB_mid"] - 2 * std
 
-def compute_stoch(df: pd.DataFrame, k: int = 14, d: int = 3):
-    lmin = df['Low'].rolling(k).min()
-    hmax = df['High'].rolling(k).max()
-    pct_k = 100 * (df['Close'] - lmin) / (hmax - lmin + 1e-10)
-    return pct_k, pct_k.rolling(d).mean()
+    # MACD
+    ema12        = df["Close"].ewm(span=12).mean()
+    ema26        = df["Close"].ewm(span=26).mean()
+    df["MACD"]   = ema12 - ema26
+    df["Signal"] = df["MACD"].ewm(span=9).mean()
 
+    return df
 
-def compute_cci(df: pd.DataFrame, period: int = 20) -> pd.Series:
-    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 build_chart(df, patterns):
+    """Plotly candlestick + indikatör grafiği oluşturur."""
+    fig = go.Figure()
 
-def compute_williams_r(df: pd.DataFrame, period: int = 14) -> pd.Series:
-    hmax = df['High'].rolling(period).max()
-    lmin = df['Low'].rolling(period).min()
-    return -100 * (hmax - df['Close']) / (hmax - lmin + 1e-10)
+    # Candlestick
+    fig.add_trace(go.Candlestick(
+        x=df.index, open=df["Open"], high=df["High"],
+        low=df["Low"], close=df["Close"],
+        name="EUR/USD", increasing_line_color="#26a69a",
+        decreasing_line_color="#ef5350"
+    ))
 
+    # EMA
+    fig.add_trace(go.Scatter(x=df.index, y=df["EMA20"], name="EMA 20",
+                             line=dict(color="#FFA726", width=1.2)))
+    fig.add_trace(go.Scatter(x=df.index, y=df["EMA50"], name="EMA 50",
+                             line=dict(color="#AB47BC", width=1.2)))
 
-def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
-    delta = series.diff()
-    gain = delta.where(delta > 0, 0.0).rolling(period).mean()
-    loss = (-delta.where(delta < 0, 0.0)).rolling(period).mean()
-    return 100 - (100 / (1 + gain / (loss + 1e-10)))
+    # Bollinger
+    fig.add_trace(go.Scatter(x=df.index, y=df["BB_upper"], name="BB Üst",
+                             line=dict(color="#607D8B", dash="dot", width=1)))
+    fig.add_trace(go.Scatter(x=df.index, y=df["BB_lower"], name="BB Alt",
+                             line=dict(color="#607D8B", dash="dot", width=1),
+                             fill="tonexty", fillcolor="rgba(96,125,139,0.07)"))
+
+    # Pattern işaretleri
+    for p in patterns[-10:]:
+        try:
+            dt = pd.to_datetime(p["Tarih"])
+            row = df[df.index.date == dt.date()] if hasattr(df.index[0], "date") else df[df.index == p["Tarih"]]
+            if not row.empty:
+                y_pos = row["High"].values[0] * 1.001
+                color = "#26a69a" if "↑" in p["Yön"] else ("#ef5350" if "↓" in p["Yön"] else "#FFA726")
+                fig.add_annotation(x=row.index[0], y=y_pos,
+                                   text=p["Pattern"].split(",")[0][2:],
+                                   showarrow=True, arrowhead=2,
+                                   font=dict(size=9, color=color),
+                                   arrowcolor=color)
+        except Exception:
+            pass
+
+    fig.update_layout(
+        title="EUR/USD – Candlestick + İndikatörler",
+        template="plotly_dark",
+        xaxis_rangeslider_visible=False,
+        height=550,
+        legend=dict(orientation="h", y=1.02),
+        margin=dict(l=40, r=20, t=50, b=20),
+        font=dict(family="Inter, sans-serif"),
+        paper_bgcolor="#0f1117",
+        plot_bgcolor="#0f1117",
+    )
+    return fig
 
 
-def create_features(data: pd.DataFrame) -> pd.DataFrame:
-    """
-    Premium feature set — 55+ engineered features designed to minimise MAE
-    for Ridge regression via diverse, low-noise signal construction.
-    """
-    df = data.copy()
-
-    # ── Price action ─────────────────────────────────────────────────────────
-    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']
-    df['HL_to_Close']  = df['High_Low'] / (df['Close'] + 1e-10)
-
-    # ── Moving averages & crosses ─────────────────────────────────────────────
-    for w in [3, 5, 8, 13, 21, 34, 55]:   # Fibonacci periods
-        df[f'SMA_{w}']  = df['Close'].rolling(w).mean()
-        df[f'EMA_{w}']  = df['Close'].ewm(span=w, adjust=False).mean()
-
-    df['Price_SMA3_Ratio']  = df['Close'] / (df['SMA_3']  + 1e-10)
-    df['Price_SMA8_Ratio']  = df['Close'] / (df['SMA_8']  + 1e-10)
-    df['Price_SMA21_Ratio'] = df['Close'] / (df['SMA_21'] + 1e-10)
-    df['Price_SMA55_Ratio'] = df['Close'] / (df['SMA_55'] + 1e-10)
-
-    df['SMA3_SMA21_Cross']  = df['SMA_3']  - df['SMA_21']
-    df['SMA8_SMA34_Cross']  = df['SMA_8']  - df['SMA_34']
-    df['EMA3_EMA21_Cross']  = df['EMA_3']  - df['EMA_21']
-    df['EMA8_EMA55_Cross']  = df['EMA_8']  - df['EMA_55']
-
-    # Price distance from key MA levels (mean-reversion signal)
-    df['Dist_SMA21'] = (df['Close'] - df['SMA_21']) / (df['SMA_21'] + 1e-10)
-    df['Dist_SMA55'] = (df['Close'] - df['SMA_55']) / (df['SMA_55'] + 1e-10)
-
-    # ── RSI multi-period ──────────────────────────────────────────────────────
-    for p in [7, 14, 21]:
-        df[f'RSI_{p}'] = compute_rsi(df['Close'], p)
-
-    df['RSI_Divergence'] = df['RSI_7'] - df['RSI_21']
-
-    # ── MACD variants ─────────────────────────────────────────────────────────
-    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']
-    df['MACD_Norm']   = df['MACD'] / (df['Close'] + 1e-10)   # normalised
-
-    # Short MACD (5/13/3) for faster signals
-    ema5  = df['Close'].ewm(span=5,  adjust=False).mean()
-    ema13 = df['Close'].ewm(span=13, adjust=False).mean()
-    df['MACD_Fast']     = ema5  - ema13
-    df['MACD_Fast_Sig'] = df['MACD_Fast'].ewm(span=3, adjust=False).mean()
-    df['MACD_Fast_Hist']= df['MACD_Fast'] - df['MACD_Fast_Sig']
-
-    # ── Bollinger Bands (multi-period) ────────────────────────────────────────
-    for w in [20, 10]:
-        mid = df['Close'].rolling(w).mean()
-        std = df['Close'].rolling(w).std()
-        df[f'BB_upper_{w}'] = mid + std * 2
-        df[f'BB_lower_{w}'] = mid - std * 2
-        df[f'BB_width_{w}'] = (df[f'BB_upper_{w}'] - df[f'BB_lower_{w}']) / (mid + 1e-10)
-        df[f'BB_pct_{w}']   = (df['Close'] - df[f'BB_lower_{w}']) / (
-                               df[f'BB_upper_{w}'] - df[f'BB_lower_{w}'] + 1e-10)
-
-    # ── ATR & volatility ──────────────────────────────────────────────────────
-    df['ATR']       = compute_atr(df, 14)
-    df['ATR_7']     = compute_atr(df, 7)
-    df['ATR_Pct']   = df['ATR'] / (df['Close'] + 1e-10)
-    df['ATR_Ratio'] = df['ATR_7'] / (df['ATR'] + 1e-10)   # short/long vol ratio
-
-    df['Vol_5']   = df['Returns'].rolling(5).std()
-    df['Vol_10']  = df['Returns'].rolling(10).std()
-    df['Vol_20']  = df['Returns'].rolling(20).std()
-    df['Vol_Ratio'] = df['Vol_5'] / (df['Vol_20'] + 1e-10)
-
-    # ── Stochastic + CCI + Williams ───────────────────────────────────────────
-    df['Stoch_K'], df['Stoch_D'] = compute_stoch(df, 14, 3)
-    df['Stoch_K_5'], df['Stoch_D_5'] = compute_stoch(df, 5, 3)
-    df['Stoch_Cross']  = df['Stoch_K'] - df['Stoch_D']
-    df['CCI']          = compute_cci(df, 20)
-    df['CCI_10']       = compute_cci(df, 10)
-    df['WilliamsR']    = compute_williams_r(df, 14)
-    df['WilliamsR_7']  = compute_williams_r(df, 7)
-
-    # ── Momentum (Rate of Change) ─────────────────────────────────────────────
-    for p in [3, 5, 10, 20]:
-        df[f'ROC_{p}'] = df['Close'].pct_change(p)
-
-    # ── Trend strength ────────────────────────────────────────────────────────
-    df['ADX_Proxy'] = (df['Returns'].rolling(14).std() /
-                       df['Returns'].rolling(14).mean().abs().clip(lower=1e-10))
-
-    # ── Lag features (close price) ────────────────────────────────────────────
-    for i in range(1, 11):
-        df[f'Lag_{i}'] = df['Close'].shift(i)
-
-    # ── Lag returns ───────────────────────────────────────────────────────────
-    for i in range(1, 6):
-        df[f'LagRet_{i}'] = df['Returns'].shift(i)
-
-    # ── Rolling statistics ────────────────────────────────────────────────────
-    df['Close_Min5']  = df['Close'].rolling(5).min()
-    df['Close_Max5']  = df['Close'].rolling(5).max()
-    df['Close_Min20'] = df['Close'].rolling(20).min()
-    df['Close_Max20'] = df['Close'].rolling(20).max()
-    df['Range_Pct5']  = (df['Close'] - df['Close_Min5']) / (df['Close_Max5']  - df['Close_Min5']  + 1e-10)
-    df['Range_Pct20'] = (df['Close'] - df['Close_Min20']) / (df['Close_Max20'] - df['Close_Min20'] + 1e-10)
-
-    # ── Volume ────────────────────────────────────────────────────────────────
-    if 'Volume' in df.columns and df['Volume'].sum() > 0:
-        df['Vol_MA10']    = df['Volume'].rolling(10).mean()
-        df['Volume_Ratio']= df['Volume'] / (df['Vol_MA10'] + 1e-10)
-        df['OBV']         = (np.sign(df['Returns']) * df['Volume']).cumsum()
-        df['OBV_MA']      = df['OBV'].rolling(10).mean()
-        df['OBV_Signal']  = (df['OBV'] - df['OBV_MA']) / (df['OBV_MA'].abs() + 1e-10)
+def ai_summary(df, patterns):
+    """Kural tabanlı AI yorumu üretir."""
+    if df is None or df.empty:
+        return "Veri yok."
+
+    latest   = df.iloc[-1]
+    rsi      = round(latest["RSI"], 1)
+    macd     = latest["MACD"]
+    signal   = latest["Signal"]
+    close    = round(latest["Close"], 5)
+    ema20    = round(latest["EMA20"], 5)
+    ema50    = round(latest["EMA50"], 5)
+    bb_upper = round(latest["BB_upper"], 5)
+    bb_lower = round(latest["BB_lower"], 5)
+
+    lines = [f"### 🤖 AI Pattern & İndikatör Analizi\n"]
+    lines.append(f"**Son Fiyat:** {close}  |  **RSI(14):** {rsi}")
+    lines.append(f"**EMA20:** {ema20}  |  **EMA50:** {ema50}")
+    lines.append(f"**BB Üst:** {bb_upper}  |  **BB Alt:** {bb_lower}\n")
+
+    # Trend
+    if close > ema20 > ema50:
+        lines.append("📈 **Trend:** Güçlü Yükseliş – Fiyat her iki EMA'nın üzerinde.")
+    elif close < ema20 < ema50:
+        lines.append("📉 **Trend:** Güçlü Düşüş – Fiyat her iki EMA'nın altında.")
+    elif close > ema20:
+        lines.append("↗️ **Trend:** Kısa vadeli yükseliş, ancak EMA50 henüz kırılmadı.")
     else:
-        df['Volume_Ratio'] = 1.0
-        df['OBV_Signal']   = 0.0
-
-    # ── FIX 4: Direction Composite Signal (boosts directional accuracy) ─────
-    # Encodes consensus of multiple indicators into a single direction score.
-    # Positive → bullish bias, Negative → bearish bias.
-    direction_score = pd.Series(0.0, index=df.index)
-
-    # RSI signal: oversold=bullish, overbought=bearish
-    if 'RSI_14' in df.columns:
-        direction_score += (50 - df['RSI_14']) / 50   # +1 at RSI=0, -1 at RSI=100
-
-    # MACD histogram direction
-    if 'MACD_Hist' in df.columns:
-        direction_score += np.sign(df['MACD_Hist'])
-
-    # Stoch cross: K above D = bullish
-    if 'Stoch_Cross' in df.columns:
-        direction_score += np.sign(df['Stoch_Cross'])
-
-    # Price vs SMA21
-    if 'Dist_SMA21' in df.columns:
-        direction_score += np.sign(df['Dist_SMA21'])
-
-    # EMA cross
-    if 'EMA3_EMA21_Cross' in df.columns:
-        direction_score += np.sign(df['EMA3_EMA21_Cross'])
-
-    # ROC momentum
-    if 'ROC_5' in df.columns:
-        direction_score += np.sign(df['ROC_5'])
-
-    df['Direction_Score'] = direction_score / 6.0   # normalise to [-1, +1]
-
-    # Momentum consistency: are recent returns all same sign?
-    if 'LagRet_1' in df.columns and 'LagRet_2' in df.columns and 'LagRet_3' in df.columns:
-        df['Momentum_Consistency'] = (
-            np.sign(df['LagRet_1']) +
-            np.sign(df['LagRet_2']) +
-            np.sign(df['LagRet_3'])
-        ) / 3.0
-
-    # ── Horizon-aware features (2-day dynamics) ───────────────────────────────
-    # These explicitly capture 2-day structure to boost multi-day accuracy.
-    df['LagRet_1_2sum']  = df['LagRet_1'] + df['LagRet_2']           # 2-day return sum
-    df['LagRet_1_2diff'] = df['LagRet_1'] - df['LagRet_2']           # acceleration
-    df['Vol_2']          = df['Returns'].rolling(2).std()             # 2-day volatility
-    df['ROC_2']          = df['Close'].pct_change(2)                  # 2-day ROC
-    df['SMA3_slope']     = df['SMA_3'].diff(2)                        # short MA 2-day slope
-    df['EMA3_slope']     = df['EMA_3'].diff(2)                        # short EMA 2-day slope
-    df['ATR_delta']      = df['ATR'].diff(1)                          # ATR change (vol expansion/contraction)
-    df['RSI14_delta']    = df['RSI_14'].diff(2)                       # RSI momentum 2-day
-    df['MACD_Hist_delta']= df['MACD_Hist'].diff(2)                    # MACD histogram acceleration
-    df['BB_pct20_delta'] = df['BB_pct_20'].diff(2)                    # BB position change
-
-    return df.dropna()
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  FEATURE COLUMNS
-# ══════════════════════════════════════════════════════════════════════════════
-FEATURE_COLS = [
-    # Price action
-    'Returns', 'Log_Returns', 'High_Low', 'Close_Open',
-    'Body_Ratio', 'Upper_Shadow', 'Lower_Shadow', 'HL_to_Close',
-    # Moving averages
-    'SMA_3', 'SMA_5', 'SMA_8', 'SMA_13', 'SMA_21', 'SMA_34', 'SMA_55',
-    'EMA_3', 'EMA_5', 'EMA_8', 'EMA_13', 'EMA_21', 'EMA_34', 'EMA_55',
-    'Price_SMA3_Ratio', 'Price_SMA8_Ratio', 'Price_SMA21_Ratio', 'Price_SMA55_Ratio',
-    'SMA3_SMA21_Cross', 'SMA8_SMA34_Cross', 'EMA3_EMA21_Cross', 'EMA8_EMA55_Cross',
-    'Dist_SMA21', 'Dist_SMA55',
-    # RSI
-    'RSI_7', 'RSI_14', 'RSI_21', 'RSI_Divergence',
-    # MACD
-    'MACD', 'MACD_Signal', 'MACD_Hist', 'MACD_Norm',
-    'MACD_Fast', 'MACD_Fast_Sig', 'MACD_Fast_Hist',
-    # Bollinger
-    'BB_width_20', 'BB_pct_20', 'BB_width_10', 'BB_pct_10',
-    # ATR & volatility
-    'ATR', 'ATR_7', 'ATR_Pct', 'ATR_Ratio',
-    'Vol_5', 'Vol_10', 'Vol_20', 'Vol_Ratio',
-    # Oscillators
-    'Stoch_K', 'Stoch_D', 'Stoch_K_5', 'Stoch_D_5', 'Stoch_Cross',
-    'CCI', 'CCI_10', 'WilliamsR', 'WilliamsR_7',
-    # Momentum
-    'ROC_3', 'ROC_5', 'ROC_10', 'ROC_20', 'ADX_Proxy',
-    # Lag close
-    'Lag_1', 'Lag_2', 'Lag_3', 'Lag_4', 'Lag_5',
-    'Lag_6', 'Lag_7', 'Lag_8', 'Lag_9', 'Lag_10',
-    # Lag returns
-    'LagRet_1', 'LagRet_2', 'LagRet_3', 'LagRet_4', 'LagRet_5',
-    # Range
-    'Range_Pct5', 'Range_Pct20',
-    # Volume
-    'Volume_Ratio', 'OBV_Signal',
-    # Direction composite (FIX 4)
-    'Direction_Score', 'Momentum_Consistency',
-    # Horizon-aware (2-day dynamics)
-    'LagRet_1_2sum', 'LagRet_1_2diff', 'Vol_2', 'ROC_2',
-    'SMA3_slope', 'EMA3_slope', 'ATR_delta',
-    'RSI14_delta', 'MACD_Hist_delta', 'BB_pct20_delta',
-]
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  RIDGE MODEL LAYER
-#  Strategy: stacked multi-target Ridge with optimised alpha via RidgeCV
-#  + second-order interaction features for non-linear capture
-# ══════════════════════════════════════════════════════════════════════════════
-
-def build_ridge_pipeline(alpha: float) -> Pipeline:
-    """Ridge pipeline with degree-2 interactions (no bias terms in poly)."""
-    return Pipeline([
-        ('scaler', StandardScaler()),
-        ('poly',   PolynomialFeatures(degree=2, interaction_only=True,
-                                      include_bias=False)),
-        ('scaler2', StandardScaler(with_mean=False)),   # re-scale after poly
-        ('ridge',  Ridge(alpha=alpha, fit_intercept=True)),
-    ])
-
-
-def select_best_alpha(X_tr, y_tr) -> float:
-    """
-    RidgeCV finds optimal alpha from a fine logarithmic grid.
-    FIXED: alpha is selected on poly-expanded features (same space as the
-    actual Ridge model), not on raw features. This eliminates alpha
-    scale mismatch that degraded 2-day accuracy.
-    """
-    sc1  = StandardScaler()
-    poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
-    sc2  = StandardScaler(with_mean=False)
-    Xp   = sc2.fit_transform(poly.fit_transform(sc1.fit_transform(X_tr)))
+        lines.append("↘️ **Trend:** Kısa vadeli zayıflık.")
 
-    # After poly expansion the feature count is ~n*(n-1)/2 — ridge needs
-    # higher alphas to stay regularised at that scale.
-    alphas = np.logspace(0, 6, 60)
-    rcv = RidgeCV(alphas=alphas, cv=5, scoring='neg_mean_absolute_error')
-    rcv.fit(Xp, y_tr)
-    return float(rcv.alpha_)
+    # RSI
+    if rsi > 70:
+        lines.append(f"⚠️ **RSI {rsi}** – Aşırı alım bölgesi, düzeltme riski.")
+    elif rsi < 30:
+        lines.append(f"✅ **RSI {rsi}** – Aşırı satım bölgesi, toparlanma ihtimali.")
+    else:
+        lines.append(f"🔵 **RSI {rsi}** – Nötr bölgede.")
 
+    # MACD
+    if macd > signal:
+        lines.append("✅ **MACD** Sinyal üzerinde – Momentum pozitif.")
+    else:
+        lines.append("⚠️ **MACD** Sinyal altında – Momentum negatif.")
 
-def train_ridge(df: pd.DataFrame, horizon: int = 1):
-    """
-    Trains the premium Ridge model.
-    Target: log-return over `horizon` days (direction-aware).
+    # Bollinger
+    if close > bb_upper:
+        lines.append("🔴 Fiyat **Bollinger Üst Bandı** dışında – Aşırı alım.")
+    elif close < bb_lower:
+        lines.append("🟢 Fiyat **Bollinger Alt Bandı** dışında – Aşırı satım.")
+
+    # Son patternler
+    if patterns:
+        last = patterns[-3:]
+        lines.append(f"\n**Son Tespit Edilen Patternler:**")
+        for p in reversed(last):
+            lines.append(f"- `{p['Tarih']}` → {p['Pattern']}  {p['Yön']}")
+
+    # Genel yorum
+    bull_count = sum(1 for p in patterns[-10:] if "↑" in p.get("Yön", ""))
+    bear_count = sum(1 for p in patterns[-10:] if "↓" in p.get("Yön", ""))
+    lines.append(f"\n**Son 10 Pattern:** 🟢 {bull_count} Bullish  |  🔴 {bear_count} Bearish")
+
+    if bull_count > bear_count and rsi < 65 and macd > signal:
+        lines.append("\n> 💡 **Genel Görünüm:** Birden fazla gösterge **yükseliş** yönünde hizalanmış.")
+    elif bear_count > bull_count and rsi > 40 and macd < signal:
+        lines.append("\n> 💡 **Genel Görünüm:** Birden fazla gösterge **düşüş** yönünde hizalanmış.")
+    else:
+        lines.append("\n> 💡 **Genel Görünüm:** Sinyaller karışık, dikkatli izlenebilir.")
 
-    FIXES applied:
-    - Log-return target correctly encodes h-day return (not 1-day)
-    - Residual bias correction: calibrates systematic over/under-shoot
-    - Returns pipeline, test predictions (absolute), y_test (absolute), avail_cols.
-    """
-    avail = [c for c in FEATURE_COLS if c in df.columns]
-    X     = df[avail].values
-    close = df['Close'].values
+    lines.append("\n---\n*Bu analiz yatırım tavsiyesi değildir.*")
+    return "\n".join(lines)
 
-    # h-day log-return — model learns this directly, no horizon scaling needed
-    y_logret = np.log(close[horizon:] / close[:len(close) - horizon])
 
-    X = X[:len(y_logret)]
-    close_aligned = close[:len(y_logret)]
+# ─── ANA FONKSİYON ───────────────────────────────────────────────────────────
 
-    split = -15   # 15-day test window for robust backtest
-    X_train, X_test       = X[:split],           X[split:]
-    y_train, y_logret_test = y_logret[:split],   y_logret[split:]
-    close_test            = close_aligned[split:]
+def analyze(period, interval):
+    """Veri çek, analiz et, grafik + tablo + özet döndür."""
+    try:
+        ticker = "EURUSD=X"
+        df = yf.download(ticker, period=period, interval=interval,
+                         auto_adjust=True, progress=False)
 
-    # Find best alpha on poly-expanded training data
-    best_alpha = select_best_alpha(X_train, y_train)
+        if df.empty:
+            return None, pd.DataFrame(), "⚠️ Veri alınamadı. Dönem/interval kombinasyonu geçersiz olabilir."
 
-    # Build & fit pipeline
-    pipe = build_ridge_pipeline(best_alpha)
-    pipe.fit(X_train, y_train)
+        # Çok seviyeli sütunları düzleştir
+        if isinstance(df.columns, pd.MultiIndex):
+            df.columns = df.columns.get_level_values(0)
 
-    # Test predictions → convert log-return back to absolute price
-    logret_hat = pipe.predict(X_test)
+        df = calculate_indicators(df)
+        patterns = detect_patterns(df)
+        fig = build_chart(df, patterns)
+        summary = ai_summary(df, patterns)
 
-    # Residual bias correction: remove mean systematic bias from log-return predictions
-    # This improves directional accuracy without leaking future info (computed on train residuals)
-    train_preds   = pipe.predict(X_train)
-    residual_bias = float(np.mean(y_train - train_preds))   # mean error on train set
-    logret_hat_corrected = logret_hat + residual_bias
+        pat_df = pd.DataFrame(patterns) if patterns else pd.DataFrame(
+            columns=["Tarih", "Pattern", "Close", "Yön"])
 
-    pred_abs   = close_test * np.exp(logret_hat_corrected)
-    y_test_abs = close_test * np.exp(y_logret_test)
+        return fig, pat_df, summary
 
-    mae  = mean_absolute_error(y_test_abs, pred_abs)
+    except Exception as e:
+        return None, pd.DataFrame(), f"❌ Hata: {str(e)}"
 
-    return pipe, pred_abs, y_test_abs, avail, best_alpha, mae, residual_bias
 
+# ─── GRADIO ARAYÜZÜ ──────────────────────────────────────────────────────────
 
-def predict_next_ridge(pipe, df: pd.DataFrame, avail: list,
-                       horizon: int = 1, residual_bias: float = 0.0) -> float:
-    """
-    Predict absolute close price horizon days ahead using log-return.
+PERIOD_CHOICES   = ["1d", "5d", "1mo", "3mo", "6mo", "1y"]
+INTERVAL_CHOICES = ["15m", "30m", "1h", "4h", "1d"]
 
-    FIXED: Removed `* horizon` scaling — model already learns h-day log-return.
-    Applies residual_bias correction from training set for calibrated prediction.
+with gr.Blocks(
+    title="EUR/USD Pattern AI",
+    theme=gr.themes.Base(
+        primary_hue="teal",
+        neutral_hue="slate",
+        font=[gr.themes.GoogleFont("Inter"), "sans-serif"],
+    ),
+    css="""
+    body { background: #0f1117 !important; }
+    .gradio-container { max-width: 1100px !important; }
+    #title { text-align: center; padding: 16px 0 4px; }
+    #subtitle { text-align: center; color: #94a3b8; margin-bottom: 8px; font-size: 0.9em; }
     """
-    cp = float(df['Close'].iloc[-1])
-    x  = df[avail].iloc[-1].values.reshape(1, -1)
-    logret = float(pipe.predict(x)[0]) + residual_bias
-    return cp * np.exp(logret)
+) as demo:
 
+    gr.HTML("<h1 id='title'>📊 EUR/USD Pattern AI</h1>")
+    gr.HTML("<p id='subtitle'>yfinance • Candlestick Pattern Tespiti • Teknik İndikatörler</p>")
 
-# ══════════════════════════════════════════════════════════════════════════════
-#  TP / SL  (ATR-based)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def compute_tp_sl(current_price, pred_price, atr,
-                  atr_multiplier_sl=1.5, rr_ratio=2.0) -> dict:
-    direction = "LONG" if pred_price > current_price else "SHORT"
-    sl_dist   = atr * atr_multiplier_sl
-    tp_dist   = sl_dist * rr_ratio
-    pip       = 0.0001
-
-    if direction == "LONG":
-        sl, tp = current_price - sl_dist, current_price + tp_dist
-    else:
-        sl, tp = current_price + sl_dist, current_price - tp_dist
-
-    return dict(
-        direction=direction, entry=current_price, sl=sl, tp=tp,
-        sl_pips=sl_dist/pip, tp_pips=tp_dist/pip,
-        rr=rr_ratio, risk_pct=(sl_dist/current_price)*100, atr=atr,
+    with gr.Row():
+        period_dd   = gr.Dropdown(PERIOD_CHOICES, value="1mo", label="Dönem")
+        interval_dd = gr.Dropdown(INTERVAL_CHOICES, value="1d", label="Interval")
+        run_btn     = gr.Button("🔍 Analiz Et", variant="primary", scale=1)
+
+    chart_out   = gr.Plot(label="Grafik")
+    summary_out = gr.Markdown(label="AI Yorumu")
+    table_out   = gr.Dataframe(
+        label="Tespit Edilen Patternler",
+        headers=["Tarih", "Pattern", "Close", "Yön"],
+        interactive=False,
+        wrap=True,
     )
 
-
-def signal_score(df: pd.DataFrame, direction: str) -> dict:
-    row   = df.iloc[-1]
-    score = 0
-    det   = {}
-
-    rsi = float(row.get('RSI_14', 50))
-    if direction == "LONG":
-        pts = max(0, (70 - rsi) / 70 * 25) if rsi < 70 else 0
-    else:
-        pts = max(0, (rsi - 30) / 70 * 25) if rsi > 30 else 0
-    score += pts; det['RSI-14'] = f"{rsi:.1f}  (+{pts:.0f}p)"
-
-    macd  = float(row.get('MACD', 0))
-    mhist = float(row.get('MACD_Hist', 0))
-    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; det['MACD'] = f"{macd:.5f}  hist={mhist:.5f}  (+{pts}p)"
-
-    stk = float(row.get('Stoch_K', 50))
-    std = float(row.get('Stoch_D', 50))
-    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; det['Stoch'] = f"K={stk:.1f} D={std:.1f}  (+{pts}p)"
-
-    cci = float(row.get('CCI', 0))
-    pts = 20 if (direction=="LONG" and cci > -100) or (direction=="SHORT" and cci < 100) else 5
-    score += pts; det['CCI'] = f"{cci:.1f}  (+{pts}p)"
-
-    bb = float(row.get('BB_pct_20', 0.5))
-    pts = 15 if (direction=="LONG" and bb < 0.5) or (direction=="SHORT" and bb > 0.5) else 5
-    score += pts; det['BB%'] = f"{bb:.3f}  (+{pts}p)"
-
-    label = "GÜÇLÜ ✅" if score >= 75 else ("ORTA ⚠️" if score >= 45 else "ZAYIF ❌")
-    return {'score': min(100, score), 'label': label, 'details': det}
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  CHART ENGINE  — phosphor-green terminal aesthetic
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _ax_style(ax, title="", ylabel=""):
-    ax.set_facecolor(PANEL)
-    ax.tick_params(colors=SUBTEXT, labelsize=7)
-    for spine in ax.spines.values():
-        spine.set_edgecolor(BORDER2)
-        spine.set_linewidth(0.6)
-    ax.grid(True, color=BORDER, linewidth=0.35, alpha=0.7, linestyle=':')
-    if title:
-        ax.set_title(title, fontsize=8, color=TEXT, pad=6, loc='left',
-                     fontfamily='monospace', fontweight='bold')
-    if ylabel:
-        ax.set_ylabel(ylabel, fontsize=6.5, color=SUBTEXT, fontfamily='monospace')
-
-
-def build_figure(df, pred_price, horizon, tp_sl,
-                 test_pred_abs, y_test_abs, best_alpha, mae) -> plt.Figure:
-
-    plt.rcParams.update({
-        'font.family':       'monospace',
-        'text.color':        TEXT,
-        'figure.facecolor':  BG,
-        'axes.facecolor':    PANEL,
-        'axes.edgecolor':    BORDER2,
-        'grid.color':        BORDER,
-        'grid.linewidth':    0.35,
-    })
-
-    fig = plt.figure(figsize=(17, 16))
-    gs  = GridSpec(5, 2, figure=fig,
-                   hspace=0.55, wspace=0.30,
-                   left=0.055, right=0.97, top=0.93, bottom=0.04)
-
-    ax_price  = fig.add_subplot(gs[0:2, :])   # tall price chart
-    ax_rsi    = fig.add_subplot(gs[2, 0])
-    ax_macd   = fig.add_subplot(gs[2, 1])
-    ax_stoch  = fig.add_subplot(gs[3, 0])
-    ax_cci    = fig.add_subplot(gs[3, 1])
-    ax_back   = fig.add_subplot(gs[4, :])     # backtest accuracy
-
-    tail = df.tail(60)
-    idx  = np.arange(len(tail))
-    cp   = float(df['Close'].iloc[-1])
-    last = len(idx) - 1
-
-    # ── PRICE + BB + TP/SL ───────────────────────────────────────────────────
-    _ax_style(ax_price,
-              f'EUR/USD  ·  60-Day Close  +  Ridge Forecast  (Horizon: +{horizon}D)',
-              'Price')
-
-    # BB bands (glow effect)
-    for alpha_fill, mul in [(0.04, 2.5), (0.07, 2.0), (0.10, 1.0)]:
-        mid  = tail['SMA_21'].values
-        std_ = df['Close'].rolling(20).std().tail(60).values
-        ax_price.fill_between(idx, mid - std_*mul, mid + std_*mul,
-                               alpha=alpha_fill, color=ACID2, zorder=1)
-
-    ax_price.plot(idx, tail['SMA_21'].values,  lw=0.8, color=ACID2,  alpha=0.5, ls='--', zorder=2)
-    ax_price.plot(idx, tail['SMA_55'].values,  lw=0.8, color=MUTED,  alpha=0.6, ls=':',  zorder=2)
-
-    # Candlestick-style OHLC bars
-    for i, (_, row) in enumerate(tail.iterrows()):
-        o, h, l, c = float(row['Open']), float(row['High']), float(row['Low']), float(row['Close'])
-        color = GREEN if c >= o else WARM
-        ax_price.plot([i, i], [l, h], color=color, lw=0.6, alpha=0.5, zorder=3)
-        ax_price.add_patch(mpatches.FancyBboxPatch(
-            (i - 0.25, min(o, c)), 0.5, abs(c - o) + 1e-7,
-            boxstyle="square,pad=0", linewidth=0, facecolor=color, alpha=0.75, zorder=3))
-
-    # Close line overlay (phosphor glow)
-    ax_price.plot(idx, tail['Close'].values, lw=1.6, color=ACID, zorder=5, alpha=0.9, label='Close')
-
-    # TP / SL / Entry lines
-    ax_price.axhline(tp_sl['tp'], color=GREEN, lw=1.4, ls='--', alpha=0.9, zorder=6)
-    ax_price.axhline(tp_sl['sl'], color=RED,   lw=1.4, ls='--', alpha=0.9, zorder=6)
-    ax_price.axhline(cp,          color=TEXT,  lw=0.7, ls='-',  alpha=0.35, zorder=4)
-
-    r = len(idx) * 0.018
-    for val, lbl, col in [
-        (tp_sl['tp'], f"TP {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f}p)", GREEN),
-        (tp_sl['sl'], f"SL {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f}p)", RED),
-        (cp,          f"ENTRY {cp:.5f}",                                     TEXT),
-    ]:
-        ax_price.text(last + r, val, f"  {lbl}", color=col,
-                      fontsize=7.5, va='center', fontweight='bold', zorder=7)
-
-    # Forecast arrow
-    ax_price.annotate(
-        f"▶ +{horizon}D  {pred_price:.5f}",
-        xy=(last, cp),
-        xytext=(last + len(idx)*0.05, pred_price),
-        arrowprops=dict(arrowstyle='->', color=ACID, lw=1.6,
-                        connectionstyle='arc3,rad=0.25'),
-        color=ACID, fontsize=9, fontweight='bold', zorder=8,
-        fontfamily='monospace',
+    run_btn.click(
+        fn=analyze,
+        inputs=[period_dd, interval_dd],
+        outputs=[chart_out, table_out, summary_out],
     )
 
-    ax_price.legend(fontsize=7, framealpha=0.1, labelcolor=SUBTEXT,
-                    ncol=3, loc='upper left')
-    ax_price.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
-
-    # ── RSI ──────────────────────────────────────────────────────────────────
-    _ax_style(ax_rsi, 'RSI-14  /  RSI-7', 'RSI')
-    r14 = tail['RSI_14'].values
-    r7  = tail['RSI_7'].values
-    ax_rsi.plot(idx, r14, lw=1.3, color=ACID,  label='RSI-14', zorder=4)
-    ax_rsi.plot(idx, r7,  lw=1.0, color=ACID3, label='RSI-7',  zorder=3, alpha=0.7)
-    ax_rsi.fill_between(idx, r14, 70, where=(r14 >= 70), alpha=0.18, color=RED)
-    ax_rsi.fill_between(idx, r14, 30, where=(r14 <= 30), alpha=0.18, color=GREEN)
-    for lvl, c, lbl in [(70, RED, 'OB'), (50, MUTED, '50'), (30, GREEN, 'OS')]:
-        ax_rsi.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
-        ax_rsi.text(len(idx), lvl, f' {lbl}', color=c, fontsize=6, va='center')
-    ax_rsi.set_ylim(0, 100)
-    ax_rsi.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
-
-    # ── MACD ─────────────────────────────────────────────────────────────────
-    _ax_style(ax_macd, 'MACD  ·  Fast (5/13)  +  Standard (12/26)')
-    macd_v  = tail['MACD'].values
-    sig_v   = tail['MACD_Signal'].values
-    hist_v  = macd_v - sig_v
-    hcol    = [GREEN if v >= 0 else RED for v in hist_v]
-    ax_macd.bar(idx, hist_v, color=hcol, alpha=0.45, width=0.7, label='Hist')
-    ax_macd.plot(idx, macd_v, lw=1.2, color=ACID,  label='MACD')
-    ax_macd.plot(idx, sig_v,  lw=1.0, color=WARN,  label='Signal', ls='--', alpha=0.8)
-    ax_macd.plot(idx, tail['MACD_Fast'].values, lw=0.8, color=ACID3,
-                 label='Fast', ls=':',  alpha=0.7)
-    ax_macd.axhline(0, color=MUTED, lw=0.6)
-    ax_macd.legend(fontsize=6, framealpha=0.1, labelcolor=SUBTEXT, ncol=4)
-
-    # ── STOCHASTIC ────────────────────────────────────────────────────────────
-    _ax_style(ax_stoch, 'Stochastic (14,3)  /  (5,3)', '%')
-    sk = tail['Stoch_K'].values
-    sd = tail['Stoch_D'].values
-    ax_stoch.plot(idx, sk, lw=1.2, color=ACID,  label='%K-14')
-    ax_stoch.plot(idx, sd, lw=1.0, color=WARN,  label='%D-14', ls='--', alpha=0.8)
-    ax_stoch.plot(idx, tail['Stoch_K_5'].values, lw=0.7, color=ACID3,
-                  label='%K-5', ls=':', alpha=0.7)
-    ax_stoch.fill_between(idx, sk, 80, where=(sk >= 80), alpha=0.12, color=RED)
-    ax_stoch.fill_between(idx, sk, 20, where=(sk <= 20), alpha=0.12, color=GREEN)
-    for lvl, c in [(80, RED), (20, GREEN)]:
-        ax_stoch.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
-    ax_stoch.set_ylim(-5, 105)
-    ax_stoch.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=3)
-
-    # ── CCI ───────────────────────────────────────────────────────────────────
-    _ax_style(ax_cci, 'CCI-20  /  CCI-10')
-    cci20 = tail['CCI'].values
-    cci10 = tail['CCI_10'].values
-    ax_cci.plot(idx, cci20, lw=1.2, color=ACID3,  label='CCI-20')
-    ax_cci.plot(idx, cci10, lw=0.8, color=ACID2,  label='CCI-10', alpha=0.7, ls='--')
-    ax_cci.fill_between(idx, cci20,  100, where=(cci20 >=  100), alpha=0.12, color=RED)
-    ax_cci.fill_between(idx, cci20, -100, where=(cci20 <= -100), alpha=0.12, color=GREEN)
-    for lvl, c in [(100, RED), (0, MUTED), (-100, GREEN)]:
-        ax_cci.axhline(lvl, color=c, lw=0.6, ls='--', alpha=0.5)
-    ax_cci.legend(fontsize=6.5, framealpha=0.1, labelcolor=SUBTEXT, ncol=2)
-
-    # ── BACKTEST ACCURACY ─────────────────────────────────────────────────────
-    _ax_style(ax_back, f'Ridge Backtest  ·  15-Day Window  ·  α={best_alpha:.4f}  ·  MAE={mae:.6f}', 'Price')
-    bidx = np.arange(len(y_test_abs))
-    ax_back.plot(bidx, y_test_abs,  lw=1.5, color=TEXT,   label='Actual',     zorder=5)
-    ax_back.plot(bidx, test_pred_abs, lw=1.5, color=ACID, label='Ridge Pred', zorder=5, ls='--')
-    ax_back.fill_between(bidx, y_test_abs, test_pred_abs, alpha=0.12, color=ACID2)
-    for i in range(len(bidx)):
-        err = abs(test_pred_abs[i] - y_test_abs[i])
-        ax_back.plot([i, i], [y_test_abs[i], test_pred_abs[i]],
-                     color=ACID2, lw=0.8, alpha=0.5, zorder=3)
-    ax_back.legend(fontsize=7.5, framealpha=0.12, labelcolor=SUBTEXT, ncol=2)
-    ax_back.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.4f'))
-
-    # ── Header ────────────────────────────────────────────────────────────────
-    dir_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']:.1f}"
-                 f"  ·  +{horizon}D forecast")
-    dir_color = GREEN if tp_sl['direction'] == 'LONG' else WARM
-
-    fig.text(0.055, 0.97,
-             "EUR/USD  ·  RIDGE FORECAST ENGINE  ·  ULTRA-PREMIUM",
-             fontsize=12, color=TEXT, fontweight='bold', va='top',
-             fontfamily='monospace')
-    fig.text(0.055, 0.955, dir_label,
-             fontsize=8.5, color=dir_color, va='top', fontfamily='monospace')
-    fig.text(0.97, 0.97,
-             datetime.now().strftime('%d %b %Y  %H:%M'),
-             fontsize=8, color=SUBTEXT, va='top', ha='right',
-             fontfamily='monospace')
-
-    # Acid-green scan-line signature (subtle)
-    for frac in np.linspace(0.04, 0.93, 28):
-        fig.add_artist(plt.Line2D(
-            [0, 1], [frac, frac], transform=fig.transFigure,
-            color=ACID, alpha=0.007, linewidth=0.4, zorder=0))
-
-    return fig
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  MAIN PREDICT FUNCTION
-# ══════════════════════════════════════════════════════════════════════════════
-
-def predict_eurusd(horizon: int = 1):
-    try:
-        # 1. Data
-        data = get_forex_data()
-        if data is None:
-            return "❌ Veri indirilemedi. İnternet bağlantınızı kontrol edin.", None
-
-        # 2. Feature engineering
-        df = create_features(data)
-        if len(df) < 40:
-            return "❌ Yetersiz veri (min 40 satır gerekli).", None
-
-        # 3. Train Ridge + backtest
-        pipe, test_pred_abs, y_test_abs, avail, best_alpha, mae, residual_bias = train_ridge(df, horizon)
-
-        # 4. Predict next
-        pred_price = predict_next_ridge(pipe, df, avail, horizon, residual_bias)
-
-        # 5. TP/SL
-        cp  = float(df['Close'].iloc[-1])
-        atr = float(df['ATR'].iloc[-1])
-        tp_sl = compute_tp_sl(cp, pred_price, atr,
-                               atr_multiplier_sl=1.5, rr_ratio=2.0)
-
-        # 6. Signal score
-        sig = signal_score(df, tp_sl['direction'])
-
-        # 7. Backtest metrics
-        rmse = float(np.sqrt(np.mean((test_pred_abs - y_test_abs) ** 2)))
-        # FIX 3: Correct directional accuracy — compare pred vs entry price
-        close_vals = df['Close'].values
-        n_test = len(test_pred_abs)
-        entry_prices = close_vals[len(close_vals) - n_test - horizon :
-                                  len(close_vals) - horizon]
-        if len(entry_prices) == n_test:
-            pred_dirs   = np.sign(test_pred_abs - entry_prices)
-            actual_dirs = np.sign(y_test_abs    - entry_prices)
-            hit = float(np.mean(pred_dirs == actual_dirs)) * 100
-        else:
-            hit = float(np.mean(
-                np.sign(np.diff(test_pred_abs)) == np.sign(np.diff(y_test_abs))
-            )) * 100
-
-        # 8. Indicators
-        rsi  = float(df['RSI_14'].iloc[-1])
-        macd = float(df['MACD'].iloc[-1])
-        mh   = float(df['MACD_Hist'].iloc[-1])
-        stk  = float(df['Stoch_K'].iloc[-1])
-        std  = float(df['Stoch_D'].iloc[-1])
-        cci  = float(df['CCI'].iloc[-1])
-        wr   = float(df['WilliamsR'].iloc[-1])
-        bb   = float(df['BB_pct_20'].iloc[-1])
-        vr   = float(df['Vol_20'].iloc[-1]) * 100
-        roc5 = float(df['ROC_5'].iloc[-1]) * 100
-        chg  = (pred_price - cp) / cp * 100
-
-        rsi_lbl  = "Aşırı Alım ⚠️" if rsi > 70 else ("Aşırı Satım ⚠️" if rsi < 30 else "Nötr  ✓")
-        macd_lbl = "Boğa ▲" if macd > 0 else "Ayı  ▼"
-
-        W   = 54
-        sep = "═" * W
-
-        lines = [
-            sep,
-            f"  EUR/USD  ·  RIDGE FORECAST ENGINE  ·  ULTRA-PREMIUM",
-            f"  {datetime.now().strftime('%d %b %Y  %H:%M:%S')}",
-            sep,
-            "",
-            f"  {'MEVCUT FİYAT':<24}:  {cp:.5f}",
-            f"  {f'+{horizon}G TAHMİN (RIDGE)':<24}:  {pred_price:.5f}  ({chg:+.3f}%)",
-            f"  {'YÖN':<24}:  {tp_sl['direction']}",
-            f"  {'OPTİMAL ALPHA (RidgeCV)':<24}:  {best_alpha:.6f}",
-        f"  {'BIAS DÜZELTME (log-ret)':<24}:  {residual_bias:+.7f}",
-            "",
-            f"  {'─── RİSK YÖNETİMİ (ATR × 1.5  |  R:R 1:2)':<{W-2}}",
-            f"  {'GİRİŞ':<24}:  {tp_sl['entry']:.5f}",
-            f"  {'TAKE PROFIT':<24}:  {tp_sl['tp']:.5f}  (+{tp_sl['tp_pips']:.0f} pip)",
-            f"  {'STOP LOSS':<24}:  {tp_sl['sl']:.5f}  (-{tp_sl['sl_pips']:.0f} pip)",
-            f"  {'R:R':<24}:  1 : {tp_sl['rr']:.1f}",
-            f"  {'RİSK %':<24}:  {tp_sl['risk_pct']:.3f}%",
-            f"  {'ATR-14':<24}:  {atr:.5f}",
-            "",
-            f"  {'─── SİNYAL GÜCÜ':<{W-2}}",
-            f"  {'SKOR':<24}:  {sig['score']:.0f} / 100  →  {sig['label']}",
-        ]
-        for k, v in sig['details'].items():
-            lines.append(f"    {k:<22}:  {v}")
-
-        lines += [
-            "",
-            f"  {'─── TEKNİK GÖSTERGELER':<{W-2}}",
-            f"  {'RSI-14':<24}:  {rsi:.2f}  →  {rsi_lbl}",
-            f"  {'RSI-7':<24}:  {float(df['RSI_7'].iloc[-1]):.2f}",
-            f"  {'MACD':<24}:  {macd:.5f}  →  {macd_lbl}",
-            f"  {'MACD Histogram':<24}:  {mh:.5f}",
-            f"  {'Stoch K/D':<24}:  {stk:.1f} / {std:.1f}",
-            f"  {'CCI-20':<24}:  {cci:.1f}",
-            f"  {'Williams %R':<24}:  {wr:.1f}",
-            f"  {'BB% (20)':<24}:  {bb:.3f}",
-            f"  {'ROC-5 (%)':<24}:  {roc5:.4f}%",
-            f"  {'Volatilite σ20':<24}:  {vr:.4f}%",
-            "",
-            f"  {'─── BACKTEST (Son 15 Gün)':<{W-2}}",
-            f"  {'MAE':<24}:  {mae:.7f}",
-            f"  {'RMSE':<24}:  {rmse:.7f}",
-            f"  {'Yön Doğruluğu':<24}:  {hit:.1f}%",
-            f"  {'Feature Sayısı':<24}:  {len(avail)}",
-            "",
-            sep,
-            "  ⚠  Yalnızca eğitim amaçlıdır. Finansal tavsiye değildir.",
-            sep,
-        ]
-
-        text = "\n".join(lines)
-
-        # 9. Figure
-        fig = build_figure(
-            df, pred_price, horizon, tp_sl,
-            test_pred_abs, y_test_abs, best_alpha, mae,
-        )
-
-        return text, fig
-
-    except Exception:
-        return f"❌ Hata:\n{traceback.format_exc()}", None
-
-
-def run_1d(): return predict_eurusd(horizon=1)
-def run_2d(): return predict_eurusd(horizon=2)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  CSS
-# ══════════════════════════════════════════════════════════════════════════════
-
-CSS = """
-*, *::before, *::after { box-sizing: border-box; }
-
-body, .gradio-container {
-    background: #080C12 !important;
-    font-family: 'JetBrains Mono', 'Cascadia Code', 'Fira Code', monospace !important;
-    color: #E8EDF5 !important;
-}
-
-/* Buttons */
-.btn-row button {
-    background: transparent !important;
-    border: 1px solid #1A2233 !important;
-    color: #6B7E99 !important;
-    font-family: 'JetBrains Mono', monospace !important;
-    font-size: 0.85rem !important;
-    font-weight: 600 !important;
-    letter-spacing: 0.08em !important;
-    padding: 13px 28px !important;
-    border-radius: 4px !important;
-    transition: all 0.18s ease !important;
-}
-
-.btn-1d button {
-    background: linear-gradient(135deg, #003D28 0%, #00261A 100%) !important;
-    border: 1px solid #00FFB2 !important;
-    color: #00FFB2 !important;
-    box-shadow: 0 0 18px rgba(0,255,178,0.12) !important;
-}
-.btn-1d button:hover {
-    box-shadow: 0 0 30px rgba(0,255,178,0.25) !important;
-    filter: brightness(1.1) !important;
-}
-
-.btn-2d button {
-    background: linear-gradient(135deg, #1A1040 0%, #100A30 100%) !important;
-    border: 1px solid #7B61FF !important;
-    color: #7B61FF !important;
-    box-shadow: 0 0 18px rgba(123,97,255,0.12) !important;
-}
-.btn-2d button:hover {
-    box-shadow: 0 0 30px rgba(123,97,255,0.25) !important;
-    filter: brightness(1.1) !important;
-}
-
-/* Textbox */
-.gr-textbox textarea, textarea {
-    background: #0C1119 !important;
-    color: #00FFB2 !important;
-    border: 1px solid #1A2233 !important;
-    font-family: 'JetBrains Mono', monospace !important;
-    font-size: 11.5px !important;
-    line-height: 1.85 !important;
-    border-radius: 4px !important;
-    caret-color: #00FFB2 !important;
-}
-
-label span { color: #3A4A5E !important; font-size: .75rem !important; }
-.gr-panel, .gr-box { background: #0C1119 !important; border: 1px solid #1A2233 !important; }
-footer { display: none !important; }
-
-/* Scan-line overlay on header */
-.header-wrap::after {
-    content: '';
-    position: absolute; inset: 0;
-    background: repeating-linear-gradient(
-        0deg,
-        transparent,
-        transparent 3px,
-        rgba(0,255,178,0.012) 3px,
-        rgba(0,255,178,0.012) 4px
-    );
-    pointer-events: none;
-    border-radius: 8px;
-}
-.header-wrap { position: relative; }
-"""
-
-HEADER = """
-<div class="header-wrap" style="
-    background: linear-gradient(155deg, #080C12 0%, #0C1119 50%, #080C12 100%);
-    border: 1px solid #1A2233;
-    border-top: 2px solid #00FFB2;
-    border-radius: 8px;
-    padding: 26px 32px 20px;
-    margin-bottom: 14px;
-">
-  <div style="display:flex;align-items:flex-start;gap:18px;">
-    <div style="flex-shrink:0;margin-top:3px;">
-      <svg width="40" height="40" viewBox="0 0 40 40" fill="none">
-        <rect width="40" height="40" rx="6" fill="#003D28"/>
-        <polyline points="6,28 13,18 20,22 27,12 34,16"
-                  stroke="#00FFB2" stroke-width="2.5" fill="none"
-                  stroke-linecap="round" stroke-linejoin="round"/>
-        <circle cx="27" cy="12" r="2.5" fill="#00FFB2"/>
-      </svg>
-    </div>
-    <div>
-      <h1 style="margin:0 0 4px;font-size:1.45rem;font-weight:900;
-                 color:#E8EDF5;letter-spacing:.06em;font-family:monospace;">
-        EUR/USD &nbsp;·&nbsp; RIDGE FORECAST ENGINE
-        <span style="color:#00FFB2;font-size:.85rem;margin-left:10px;
-                     vertical-align:middle;letter-spacing:.12em;">ULTRA-PREMIUM</span>
-      </h1>
-      <p style="margin:0;color:#3A4A5E;font-size:.75rem;font-family:monospace;
-                letter-spacing:.04em;">
-        STACKED RIDGE · POLYNOMIAL INTERACTIONS · RIDGECV ALPHA · 75+ FEATURES · ATR TP/SL
-      </p>
-    </div>
-  </div>
-  <div style="display:flex;gap:8px;flex-wrap:wrap;margin-top:16px;">
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      📡 Yahoo Finance 200g</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      🧬 75+ Features</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      🔬 Poly-2 Interactions</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      ⚡ RidgeCV Auto-α</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      🎯 ATR TP/SL</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      📅 1D / 2D Horizon</span>
-    <span style="background:#0C1119;border:1px solid #1A2233;border-radius:3px;
-                 padding:4px 12px;font-size:.72rem;color:#6B7E99;font-family:monospace;">
-      🧪 15-Day Backtest</span>
-  </div>
-</div>
-"""
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  GRADIO UI
-# ══════════════════════════════════════════════════════════════════════════════
-
-with gr.Blocks(css=CSS, title="EUR/USD Ridge Forecast Engine") as app:
-    gr.HTML(HEADER)
-
-    with gr.Row(elem_classes="btn-row"):
-        with gr.Column(scale=1, elem_classes="btn-1d"):
-            btn_1d = gr.Button("⟳  +1 GÜN TAHMİN", variant="primary")
-        with gr.Column(scale=1, elem_classes="btn-2d"):
-            btn_2d = gr.Button("⟳  +2 GÜN TAHMİN", variant="primary")
-        with gr.Column(scale=3):
-            pass   # spacer
-
-    with gr.Row():
-        with gr.Column(scale=1, min_width=400):
-            out_text = gr.Textbox(label="RAPOR", lines=42, interactive=False)
-        with gr.Column(scale=2):
-            out_plot = gr.Plot(label="GRAFİKLER")
-
-    btn_1d.click(fn=run_1d, inputs=[], outputs=[out_text, out_plot])
-    btn_2d.click(fn=run_2d, inputs=[], outputs=[out_text, out_plot])
+    # Sayfa yüklenince otomatik çalıştır
+    demo.load(
+        fn=analyze,
+        inputs=[period_dd, interval_dd],
+        outputs=[chart_out, table_out, summary_out],
+    )
 
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()