Update app.py

app.py

@@ -3,7 +3,8 @@ import os
 import logging
 import traceback
 import time
-from datetime import datetime
+import random
+from datetime import datetime, timedelta
 
 logging.basicConfig(
     stream=sys.stdout, level=logging.INFO,
@@ -20,6 +21,7 @@ try:
     from sklearn.ensemble import RandomForestClassifier
     from sklearn.preprocessing import MinMaxScaler
     import joblib
+    import requests
     logger.info("✅ All dependencies imported successfully")
 except Exception as e:
     logger.error(f"❌ Import failed: {e}")
@@ -33,139 +35,234 @@ SCALER_PATH = "/tmp/scaler.pkl"
 
 
 # ============================================================
-# SAFE DATA FETCHING — Fixed MultiIndex handling
+# ROBUST DATA FETCHING — Multiple methods
 # ============================================================
 
-def safe_download(symbol, period="90d", interval="1h"):
-    """Download with retry and ROBUST column handling."""
-    for attempt in range(3):
+def _clean_columns(df):
+    """Universal column cleaner — handles any yfinance format."""
+    if df is None or df.empty:
+        return df
+
+    # Step 1: Handle MultiIndex
+    if isinstance(df.columns, pd.MultiIndex):
+        logger.info(f"🔧 MultiIndex detected, levels: {[list(l) for l in df.levels]}")
+        # Try droplevel(0) — removes ticker name level
         try:
-            logger.info(f"📥 Download attempt {attempt+1}/3: {symbol} {period} {interval}")
-            df = yf.download(symbol, period=period, interval=interval, progress=False, threads=False)
-
-            if df is None or df.empty:
-                logger.warning(f"⚠️ Empty dataframe on attempt {attempt+1}")
-                time.sleep(3)
-                continue
-
-            logger.info(f"📊 Raw shape: {df.shape}, Raw columns type: {type(df.columns)}")
-            logger.info(f"📊 Raw columns: {df.columns.tolist()}")
-
-            # ━━━ FIX: Handle MultiIndex columns properly ━━━
-            if isinstance(df.columns, pd.MultiIndex):
-                logger.info("🔧 Detected MultiIndex columns — using droplevel(0)...")
-                # Level 0 = ticker name (e.g. "ETH-USD"), Level 1 = metric (e.g. "Open")
-                # We need Level 1 (the metric names)
-                df.columns = df.columns.droplevel(0)
-                logger.info(f"🔧 After droplevel: {df.columns.tolist()}")
-
-            # Remove any duplicate columns
-            df = df.loc[:, ~df.columns.duplicated()]
-
-            # Strip whitespace and standardize to Title Case
-            df.columns = [str(c).strip().title() for c in df.columns]
-            logger.info(f"🔧 After title case: {df.columns.tolist()}")
-
-            # Validate required columns
-            required = ["Open", "High", "Low", "Close", "Volume"]
-            missing = [c for c in required if c not in df.columns]
-            if missing:
-                logger.error(f"❌ Missing columns: {missing}. Available: {df.columns.tolist()}")
-                # Try alternate: maybe columns are lowercase
-                alt_map = {c.lower(): c for c in df.columns}
-                found_all = True
-                for req in missing:
-                    if req.lower() in alt_map:
-                        df.rename(columns={alt_map[req.lower()]: req}, inplace=True)
-                    else:
-                        found_all = False
-                
-                if not found_all:
-                    still_missing = [c for c in required if c not in df.columns]
-                    logger.error(f"❌ Still missing after alternate: {still_missing}")
-                    time.sleep(3)
-                    continue
-
-            # Drop rows with NaN in required columns
-            df = df.dropna(subset=required)
-
-            # Ensure numeric types
-            for col in required:
-                df[col] = pd.to_numeric(df[col], errors="coerce")
-
-            df = df.dropna(subset=required)
-
-            if len(df) < 20:
-                logger.warning(f"⚠️ Too few rows: {len(df)}")
-                time.sleep(3)
-                continue
-
-            logger.info(f"✅ Data fetched successfully: {len(df)} rows, columns: {df.columns.tolist()}")
+            df.columns = df.columns.droplevel(0)
+            logger.info(f"🔧 After droplevel(0): {df.columns.tolist()}")
+        except Exception:
+            # Fallback: take last level
+            try:
+                df.columns = df.columns.get_level_values(-1)
+                logger.info(f"🔧 After get_level_values(-1): {df.columns.tolist()}")
+            except Exception:
+                logger.error("❌ Cannot fix MultiIndex columns")
+
+    # Step 2: Remove duplicates
+    df = df.loc[:, ~df.columns.duplicated()]
+
+    # Step 3: Standardize names
+    new_cols = []
+    for c in df.columns:
+        name = str(c).strip()
+        # Map common variations
+        name_map = {
+            "open": "Open", "high": "High", "low": "Low",
+            "close": "Close", "volume": "Volume",
+            "adj close": "Close", "adj_close": "Close",
+        }
+        name = name_map.get(name.lower(), name)
+        new_cols.append(name)
+    df.columns = new_cols
+
+    # Step 4: Ensure numeric
+    for col in df.columns:
+        if col in ["Open", "High", "Low", "Close", "Volume"]:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+
+    # Step 5: Drop NaN in OHLCV
+    required = ["Open", "High", "Low", "Close", "Volume"]
+    available = [c for c in required if c in df.columns]
+    if available:
+        df = df.dropna(subset=available)
+
+    logger.info(f"🔧 Cleaned columns: {df.columns.tolist()}, shape: {df.shape}")
+    return df
+
+
+def fetch_method_ticker_history(symbol, period="90d", interval="1h"):
+    """Method 1: yf.Ticker().history() — most reliable on cloud."""
+    try:
+        logger.info(f"📥 Method 1: Ticker.history({symbol}, {period}, {interval})")
+        ticker = yf.Ticker(symbol)
+        df = ticker.history(period=period, interval=interval, auto_adjust=True)
+        if df is not None and not df.empty:
+            logger.info(f"✅ Method 1 success: {len(df)} rows")
             return df
+    except Exception as e:
+        logger.warning(f"⚠️ Method 1 failed: {e}")
+    return pd.DataFrame()
 
-        except Exception as e:
-            logger.error(f"❌ Download attempt {attempt+1} failed: {e}")
-            logger.error(traceback.format_exc())
-            time.sleep(3)
 
-    # Fallback: try different interval
-    logger.warning("⚠️ Trying fallback: 15m interval...")
+def fetch_method_download(symbol, period="90d", interval="1h"):
+    """Method 2: yf.download() with session."""
     try:
-        df = yf.download(symbol, period="60d", interval="15m", progress=False, threads=False)
+        logger.info(f"📥 Method 2: yf.download({symbol}, {period}, {interval})")
+        session = requests.Session()
+        session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        df = yf.download(
+            symbol, period=period, interval=interval,
+            progress=False, threads=False,
+            session=session
+        )
         if df is not None and not df.empty:
-            if isinstance(df.columns, pd.MultiIndex):
-                df.columns = df.columns.droplevel(0)
-            df.columns = [str(c).strip().title() for c in df.columns]
-            df = df.loc[:, ~df.columns.duplicated()]
-            df = df.dropna(subset=["Open", "High", "Low", "Close", "Volume"])
-            for col in ["Open", "High", "Low", "Close", "Volume"]:
-                df[col] = pd.to_numeric(df[col], errors="coerce")
-            df = df.dropna(subset=["Open", "High", "Low", "Close", "Volume"])
-            if len(df) >= 20:
-                logger.info(f"✅ Fallback data: {len(df)} rows")
+            logger.info(f"✅ Method 2 success: {len(df)} rows")
+            return df
+    except Exception as e:
+        logger.warning(f"⚠️ Method 2 failed: {e}")
+    return pd.DataFrame()
+
+
+def fetch_method_alt_symbol(period="90d", interval="1h"):
+    """Method 3: Try alternate symbol formats."""
+    alt_symbols = ["ETH-USD", "ETHUSD=X", "ETHUSDT=X", "ETH-USD"]
+    for sym in alt_symbols:
+        try:
+            logger.info(f"📥 Method 3: Trying symbol '{sym}'")
+            ticker = yf.Ticker(sym)
+            df = ticker.history(period=period, interval=interval, auto_adjust=True)
+            if df is not None and not df.empty and len(df) > 20:
+                logger.info(f"✅ Method 3 success with '{sym}': {len(df)} rows")
                 return df
-    except Exception as e2:
-        logger.error(f"❌ Fallback also failed: {e2}")
+        except Exception as e:
+            logger.warning(f"⚠️ Method 3 symbol '{sym}' failed: {e}")
+        time.sleep(1)
+    return pd.DataFrame()
 
-    logger.error("❌ All download attempts failed")
+
+def fetch_method_shorter_period(symbol):
+    """Method 4: Try shorter periods and intervals."""
+    configs = [
+        ("60d", "1h"),
+        ("30d", "1h"),
+        ("7d", "15m"),
+        ("60d", "1d"),
+        ("5d", "5m"),
+    ]
+    for period, interval in configs:
+        try:
+            logger.info(f"📥 Method 4: Ticker.history({symbol}, {period}, {interval})")
+            ticker = yf.Ticker(symbol)
+            df = ticker.history(period=period, interval=interval, auto_adjust=True)
+            if df is not None and not df.empty and len(df) > 20:
+                logger.info(f"✅ Method 4 success ({period}/{interval}): {len(df)} rows")
+                return df
+        except Exception as e:
+            logger.warning(f"⚠️ Method 4 ({period}/{interval}) failed: {e}")
+        time.sleep(1)
     return pd.DataFrame()
 
 
+def generate_synthetic_data(n_bars=500):
+    """Method 5: Fallback synthetic data so the app ALWAYS works."""
+    logger.info("🎲 Generating synthetic ETH price data as fallback...")
+    random.seed(42)
+    np.random.seed(42)
+
+    end = datetime.utcnow()
+    start = end - timedelta(hours=n_bars * 4)
+    dates = pd.date_range(start=start, end=end, freq="4h")[:n_bars]
+
+    # Simulate realistic ETH price movement
+    price = 3000.0
+    opens, highs, lows, closes, volumes = [], [], [], [], []
+
+    for _ in range(n_bars):
+        ret = np.random.normal(0.0005, 0.015)
+        open_p = price
+        close_p = price * (1 + ret)
+        high_p = max(open_p, close_p) * (1 + abs(np.random.normal(0, 0.005)))
+        low_p = min(open_p, close_p) * (1 - abs(np.random.normal(0, 0.005)))
+        vol = np.random.lognormal(15, 1.5)
+
+        opens.append(open_p)
+        highs.append(high_p)
+        lows.append(low_p)
+        closes.append(close_p)
+        volumes.append(vol)
+        price = close_p
+
+    df = pd.DataFrame({
+        "Open": opens, "High": highs, "Low": lows,
+        "Close": closes, "Volume": volumes
+    }, index=dates[:len(opens)])
+
+    df.index.name = "Datetime"
+    logger.info(f"✅ Synthetic data: {len(df)} rows, price range ${df['Close'].min():.0f}-${df['Close'].max():.0f}")
+    return df
+
+
+def safe_download(symbol=SYMBOL, period="90d", interval="1h"):
+    """Try all methods, fall back to synthetic data."""
+    # Try real data methods in order
+    methods = [
+        lambda: fetch_method_ticker_history(symbol, period, interval),
+        lambda: fetch_method_download(symbol, period, interval),
+        lambda: fetch_method_alt_symbol(period, interval),
+        lambda: fetch_method_shorter_period(symbol),
+    ]
+
+    for i, method in enumerate(methods):
+        try:
+            df = method()
+            if df is not None and not df.empty and len(df) > 20:
+                df = _clean_columns(df)
+                if "Close" in df.columns and len(df) > 20:
+                    return df, True  # True = real data
+        except Exception as e:
+            logger.warning(f"⚠️ Method {i+1} exception: {e}")
+        time.sleep(1)
+
+    # All real methods failed — use synthetic
+    logger.warning("⚠️ All real data methods failed. Using synthetic data.")
+    df = generate_synthetic_data(500)
+    df = _clean_columns(df)
+    return df, False  # False = synthetic data
+
+
+# ============================================================
+# DATA PREPARATION
+# ============================================================
+
 def fetch_and_prepare():
     """Fetch OHLCV data, compute indicators, build windowed features."""
-    df = safe_download(SYMBOL, period="90d", interval="1h")
+    df, is_real = safe_download()
 
     if df.empty:
-        raise ValueError(
-            "Gagal mengambil data dari Yahoo Finance. "
-            "Kemungkinan koneksi bermasalah atau rate-limited. Tunggu beberapa menit lalu coba lagi."
-        )
+        raise ValueError("Data kosong setelah semua percobaan. Coba lagi nanti.")
 
-    # Resample to 4h
-    logger.info(f"📊 Before resample: {len(df)} rows")
-    df = df.resample("4h").agg({
-        "Open": "first", "High": "max", "Low": "min",
-        "Close": "last", "Volume": "sum"
-    }).dropna()
+    data_source = "🔴 LIVE DATA" if is_real else "🟡 SYNTHETIC DATA (Yahoo Finance tidak tersedia)"
+    logger.info(f"📊 Data source: {data_source}")
+
+    # Resample to 4h if data has enough rows and isn't already 4h
+    if len(df) > 50:
+        try:
+            df = df.resample("4h").agg({
+                "Open": "first", "High": "max", "Low": "min",
+                "Close": "last", "Volume": "sum"
+            }).dropna()
+            logger.info(f"📊 After 4h resample: {len(df)} rows")
+        except Exception as e:
+            logger.warning(f"⚠️ Resample failed: {e}, using raw data")
 
     if len(df) < 30:
-        logger.warning(f"⚠️ Only {len(df)} rows after 4h resample, trying 1h resample...")
-        df = safe_download(SYMBOL, period="90d", interval="1h")
-        if not df.empty:
-            # Use 1h data directly
-            df.columns = [c.lower() for c in df.columns]
-            df.index.name = "timestamp"
-            df = df.reset_index()
-            logger.info(f"📊 Using 1h data: {len(df)} rows")
-            # Skip resample, continue with 1h
-        else:
-            raise ValueError(f"Data terlalu sedikit setelah resample: {len(df)} baris.")
-    else:
-        df.columns = [c.lower() for c in df.columns]
-        df.index.name = "timestamp"
-        df = df.reset_index()
+        raise ValueError(f"Data terlalu sedikit setelah resample: {len(df)} baris.")
 
-    logger.info(f"📊 After resample: {len(df)} rows")
+    df.columns = [c.lower() for c in df.columns]
+    df.index.name = "timestamp"
+    df = df.reset_index()
 
     # ── RSI 14 ──
     delta = df["close"].diff()
@@ -209,8 +306,7 @@ def fetch_and_prepare():
     if len(df) < WINDOW + 5:
         raise ValueError(
             f"Data tidak cukup setelah preprocessing: {len(df)} baris. "
-            f"Butuh minimal {WINDOW + 5} baris. "
-            f"WINDOW={WINDOW}. Coba lagi nanti saat data lebih tersedia."
+            f"Butuh minimal {WINDOW + 5}."
         )
 
     feat_cols = [
@@ -220,10 +316,9 @@ def fetch_and_prepare():
         "ema_9", "ema_21", "vol_change", "return_1", "return_4"
     ]
 
-    # Validate all feature columns exist
     missing_feats = [f for f in feat_cols if f not in df.columns]
     if missing_feats:
-        raise ValueError(f"Missing feature columns: {missing_feats}. Available: {df.columns.tolist()}")
+        raise ValueError(f"Missing feature columns: {missing_feats}")
 
     X_list, y_list = [], []
     for i in range(WINDOW, len(df)):
@@ -233,10 +328,7 @@ def fetch_and_prepare():
             y_list.append(int(df.iloc[i]["label"]))
 
     if len(X_list) < 10:
-        raise ValueError(
-            f"Tidak cukup sampel valid setelah windowing: {len(X_list)}. "
-            f"Butuh minimal 10. Total rows={len(df)}, WINDOW={WINDOW}"
-        )
+        raise ValueError(f"Tidak cukup sampel valid: {len(X_list)}.")
 
     X = np.array(X_list, dtype=np.float64)
     y = np.array(y_list, dtype=np.int32)
@@ -244,16 +336,16 @@ def fetch_and_prepare():
 
     n_buy = int(np.sum(y == 1))
     n_sell = int(np.sum(y == 0))
-    logger.info(f"✅ Features ready: X={X.shape}, y={y.shape}, BUY={n_buy}, SELL={n_sell}")
-    return X, y, df, feat_cols
+    logger.info(f"✅ Features ready: X={X.shape}, BUY={n_buy}, SELL={n_sell}, source={data_source}")
+    return X, y, df, feat_cols, is_real
 
 
 def get_market_info():
     """Quick snapshot for price header."""
     try:
-        df = safe_download(SYMBOL, period="5d", interval="1h")
+        df, is_real = safe_download(SYMBOL, period="5d", interval="1h")
         if df.empty or len(df) < 2:
-            return {"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0}
+            return {"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0, "is_real": False}
 
         cur = float(df["Close"].iloc[-1])
         prev = float(df["Close"].iloc[0])
@@ -264,10 +356,11 @@ def get_market_info():
             "high_24h": float(df["High"].tail(tail_n).max()),
             "low_24h": float(df["Low"].tail(tail_n).min()),
             "volume": float(df["Volume"].tail(tail_n).sum()),
+            "is_real": is_real,
         }
     except Exception as e:
         logger.error(f"Market info error: {e}")
-        return {"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0}
+        return {"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0, "is_real": False}
 
 
 # ── Training ──
@@ -275,12 +368,12 @@ def get_market_info():
 def run_train():
     try:
         logger.info("🧠 Starting training...")
-        X, y, df_full, feat_cols = fetch_and_prepare()
+        X, y, df_full, feat_cols, is_real = fetch_and_prepare()
 
         n_buy = int(np.sum(y == 1))
         n_sell = int(np.sum(y == 0))
         if n_buy < 3 or n_sell < 3:
-            raise ValueError(f"Kelas tidak seimbang: BUY={n_buy}, SELL={n_sell}. Butuh minimal 3 tiap kelas.")
+            raise ValueError(f"Kelas tidak seimbang: BUY={n_buy}, SELL={n_sell}.")
 
         scaler = MinMaxScaler()
         X_scaled = scaler.fit_transform(X)
@@ -292,8 +385,6 @@ def run_train():
         X_train, X_test = X_scaled[:split], X_scaled[split:]
         y_train, y_test = y[:split], y[split:]
 
-        logger.info(f"📊 Train: {len(X_train)}, Test: {len(X_test)}")
-
         model = RandomForestClassifier(
             n_estimators=100, max_depth=8,
             min_samples_split=5, min_samples_leaf=2,
@@ -310,14 +401,12 @@ def run_train():
         wins = int(np.sum((y_pred == 1) & (y_test == 1)))
         win_rate = (wins / max(buy_sig, 1)) * 100
 
-        # Simulated PnL using df_full close prices
-        # X_test corresponds to df_full rows [split+WINDOW : split+WINDOW+len(y_test)]
+        # PnL
         start_idx = split + WINDOW
         end_idx = start_idx + len(y_test)
         if end_idx <= len(df_full):
             test_closes = df_full.iloc[start_idx:end_idx]["close"].values
         else:
-            # Fallback: use last len(y_test) rows
             test_closes = df_full.iloc[-(len(y_test) + 1):]["close"].values
 
         pnl = 0.0
@@ -325,7 +414,6 @@ def run_train():
             if y_pred[i] == 1:
                 ret = (test_closes[i + 1] - test_closes[i]) / test_closes[i] - FEE
                 pnl += ret
-
         pnl_pct = pnl * 100
 
         importances = model.feature_importances_
@@ -336,9 +424,9 @@ def run_train():
         joblib.dump(model, MODEL_PATH)
         joblib.dump(scaler, SCALER_PATH)
 
-        logger.info(f"✅ Training done — acc={acc:.4f}  win_rate={win_rate:.1f}%")
+        logger.info(f"✅ Training done — acc={acc:.4f}")
         return _html_train(acc, win_rate, pnl_pct, len(X_train),
-                           len(X_test), buy_sig, sell_sig, top5, df_full)
+                           len(X_test), buy_sig, sell_sig, top5, df_full, is_real)
     except Exception as e:
         tb = traceback.format_exc()
         logger.error(f"❌ Train failed: {e}")
@@ -353,7 +441,7 @@ def run_predict():
         if not os.path.exists(MODEL_PATH):
             return _html_warn("Model belum di-training. Klik <b>⚡ Train Model</b> terlebih dahulu.")
 
-        X, y, df_full, feat_cols = fetch_and_prepare()
+        X, y, df_full, feat_cols, is_real = fetch_and_prepare()
         scaler = joblib.load(SCALER_PATH)
         model = joblib.load(MODEL_PATH)
 
@@ -375,8 +463,8 @@ def run_predict():
         bb_pct = float(row.get("bb_pct", 0.5))
 
         signal = "BUY" if pred == 1 else "SELL"
-        logger.info(f"🔮 {signal}  conf={confidence:.1f}%")
-        return _html_signal(signal, confidence, price, rsi, macd_val, bb_pct)
+        logger.info(f"🔮 {signal} conf={confidence:.1f}%")
+        return _html_signal(signal, confidence, price, rsi, macd_val, bb_pct, is_real)
     except Exception as e:
         tb = traceback.format_exc()
         logger.error(f"❌ Predict failed: {e}")
@@ -392,19 +480,30 @@ def refresh_price():
 # HTML BUILDERS
 # ============================================================
 
+def _html_data_badge(is_real):
+    if is_real:
+        return '<span style="background:rgba(14,203,129,.15);color:#0ECB81;font-size:9px;padding:2px 8px;border-radius:10px;font-weight:600;">🔴 LIVE</span>'
+    else:
+        return '<span style="background:rgba(240,185,11,.15);color:#F0B90B;font-size:9px;padding:2px 8px;border-radius:10px;font-weight:600;">🟡 SIMULATED</span>'
+
+
 def _html_price_header(info):
-    p = info["price"]
-    chg = info["change_pct"]
-    hi, lo = info["high_24h"], info["low_24h"]
-    vol = info["volume"]
+    p = info.get("price", 0)
+    chg = info.get("change_pct", 0)
+    hi, lo = info.get("high_24h", 0), info.get("low_24h", 0)
+    vol = info.get("volume", 0)
+    is_real = info.get("is_real", False)
+
+    badge = _html_data_badge(is_real)
 
     if p == 0:
-        return """
+        return f"""
         <div style="display:flex;align-items:center;gap:28px;padding:14px 24px;
                     background:#1E2329;border-bottom:1px solid #2B3139;
                     font-family:'Inter',sans-serif;">
           <span style="color:#F0B90B;font-size:17px;font-weight:800;">ETH / USDT</span>
           <span style="color:#5E6673;font-size:13px;">⏳ Loading price data...</span>
+          {badge}
         </div>"""
 
     cc = "#0ECB81" if chg >= 0 else "#F6465D"
@@ -417,6 +516,7 @@ def _html_price_header(info):
       <div style="display:flex;align-items:baseline;gap:8px;">
         <span style="color:#F0B90B;font-size:17px;font-weight:800;">ETH / USDT</span>
         <span style="color:#5E6673;font-size:11px;">Perpetual</span>
+        {badge}
       </div>
       <div style="display:flex;align-items:baseline;gap:8px;">
         <span style="color:{cc};font-size:26px;font-weight:800;">${p:,.2f}</span>
@@ -433,7 +533,7 @@ def _html_price_header(info):
     </div>"""
 
 
-def _html_signal(signal, confidence, price, rsi, macd_val, bb_pct):
+def _html_signal(signal, confidence, price, rsi, macd_val, bb_pct, is_real=True):
     buy = signal == "BUY"
     sc = "#0ECB81" if buy else "#F6465D"
     sbg = "rgba(14,203,129,.12)" if buy else "rgba(246,70,93,.12)"
@@ -451,6 +551,8 @@ def _html_signal(signal, confidence, price, rsi, macd_val, bb_pct):
     bs = "Upper" if bb_pct > .8 else ("Lower" if bb_pct < .2 else "Mid")
     ts = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
 
+    badge = _html_data_badge(is_real)
+
     return f"""
     <div style="background:#1E2329;border-radius:8px;border:1px solid {sbd};overflow:hidden;
                 font-family:'Inter',sans-serif;">
@@ -484,17 +586,21 @@ def _html_signal(signal, confidence, price, rsi, macd_val, bb_pct):
       </div>
       <div style="padding:10px 20px;display:flex;justify-content:space-between;align-items:center;">
         <span style="color:#5E6673;font-size:10px;">⏰ {ts}</span>
-        <span style="color:#5E6673;font-size:10px;">Entry ≈ ${price:,.2f}</span>
+        <div style="display:flex;align-items:center;gap:8px;">
+          {badge}
+          <span style="color:#5E6673;font-size:10px;">Entry ≈ ${price:,.2f}</span>
+        </div>
       </div>
     </div>"""
 
 
-def _html_train(acc, win_rate, pnl_pct, n_tr, n_te, buys, sells, top5, df_full):
+def _html_train(acc, win_rate, pnl_pct, n_tr, n_te, buys, sells, top5, df_full, is_real=True):
     ac = "#0ECB81" if acc >= .58 else ("#F0B90B" if acc >= .50 else "#F6465D")
     wc = "#0ECB81" if win_rate >= 55 else ("#F0B90B" if win_rate >= 45 else "#F6465D")
     pc = "#0ECB81" if pnl_pct >= 0 else "#F6465D"
     ps = "+" if pnl_pct >= 0 else ""
     ts = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
+    badge = _html_data_badge(is_real)
 
     fi = ""
     for name, imp in top5:
@@ -524,14 +630,28 @@ def _html_train(acc, win_rate, pnl_pct, n_tr, n_te, buys, sells, top5, df_full):
           <td style="color:{ch2};font-size:10px;padding:5px 6px;text-align:right;">{ch:+.2f}%</td>
           <td style="color:#848E9C;font-size:10px;padding:5px 6px;text-align:right;">{rv:.1f}</td></tr>"""
 
+    data_notice = ""
+    if not is_real:
+        data_notice = """
+        <div style="background:rgba(240,185,11,.08);border:1px solid rgba(240,185,11,.25);
+                    border-radius:4px;padding:8px 12px;margin:8px 18px;font-size:11px;">
+          <span style="color:#F0B90B;font-weight:600;">⚠️ Yahoo Finance tidak tersedia.</span>
+          <span style="color:#848E9C;"> Model dilatih menggunakan data simulasi. 
+          Sinyal mungkin tidak akurat untuk trading real.</span>
+        </div>"""
+
     return f"""
     <div style="background:#1E2329;border-radius:8px;border:1px solid #2B3139;overflow:hidden;
                 font-family:'Inter',sans-serif;">
       <div style="padding:14px 20px;border-bottom:1px solid #2B3139;display:flex;
                   justify-content:space-between;align-items:center;">
-        <span style="color:#F0B90B;font-size:13px;font-weight:700;">✅ MODEL TRAINED</span>
+        <div style="display:flex;align-items:center;gap:8px;">
+          <span style="color:#F0B90B;font-size:13px;font-weight:700;">✅ MODEL TRAINED</span>
+          {badge}
+        </div>
         <span style="color:#5E6673;font-size:10px;">{ts}</span>
       </div>
+      {data_notice}
       <div style="display:grid;grid-template-columns:1fr 1fr 1fr 1fr;border-bottom:1px solid #2B3139;">
         <div style="padding:10px 14px;border-right:1px solid #2B3139;text-align:center;">
           <div style="color:#5E6673;font-size:9px;text-transform:uppercase;margin-bottom:2px;">Test Acc</div>
@@ -574,7 +694,6 @@ def _html_train(acc, win_rate, pnl_pct, n_tr, n_te, buys, sells, top5, df_full):
 
 
 def _html_error(msg, tb=""):
-    # Show first 3 lines of traceback for debugging
     tb_lines = tb.strip().split("\n")[-6:] if tb else []
     tb_html = ""
     if tb_lines:
@@ -602,7 +721,7 @@ def _html_warn(msg):
 
 
 # ============================================================
-# TRADINGVIEW WIDGET
+# TRADINGVIEW & CSS
 # ============================================================
 
 TRADINGVIEW_HTML = """
@@ -613,10 +732,6 @@ TRADINGVIEW_HTML = """
 </div>
 """
 
-# ============================================================
-# CSS
-# ============================================================
-
 BINANCE_CSS = """
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&display=swap');
 
@@ -730,7 +845,7 @@ with gr.Blocks(
     </div>""")
 
     price_header = gr.HTML(
-        value=_html_price_header({"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0})
+        value=_html_price_header({"price": 0, "change_pct": 0, "high_24h": 0, "low_24h": 0, "volume": 0, "is_real": False})
     )
 
     gr.HTML(TRADINGVIEW_HTML)