Update app.py

app.py

@@ -1,160 +1,227 @@
 import gradio as gr
-import ccxt
+import yfinance as yf
 import pandas as pd
-import pandas_ta as ta
 import numpy as np
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.preprocessing import MinMaxScaler
 import joblib
 import os
-import logging
 import sys
 import warnings
 
-# 🔧 Supress pandas-ta deprecation warnings di pandas 2.2+
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore")
 
-logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-logger = logging.getLogger("crypto_ml")
-
-SYMBOL = "ETH/USDT"
-TIMEFRAME = "4h"
+# 🔧 Config
+SYMBOL = "ETH-USD"  # Yahoo Finance format
+TIMEFRAME = "4h"    # yfinance supports: 1h, 1d, 1wk, etc. We'll use 1h & resample
 FEE = 0.0015
 WINDOW = 60
-MODEL_PATH = "rf_model.pkl"
-SCALER_PATH = "scaler.pkl"
+MODEL_PATH = "/tmp/rf_model.pkl"
+SCALER_PATH = "/tmp/scaler.pkl"
 
-def fetch_data(symbol: str, timeframe: str, limit: int = 2000) -> pd.DataFrame:
-    logger.info(f"📥 Fetching {limit} candles for {symbol} ({timeframe})...")
-    exchange = ccxt.binance({
-        "enableRateLimit": True,
-        "timeout": 30000,
-        "options": {"defaultType": "spot"}
-    })
-    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
-    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
-    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
-    logger.info(f"✅ Fetched {len(df)} rows.")
-    return df
+def log(msg):
+    print(f"[LOG] {msg}", flush=True)
 
-def prepare_dataset(df: pd.DataFrame):
-    logger.info("📊 Calculating indicators & preparing features...")
+def fetch_data(symbol: str, period: str = "60d", interval: str = "1h") -> pd.DataFrame:
+    """Fetch ETH-USD data from Yahoo Finance, resample to 4h"""
+    log(f"📥 Fetching {symbol} from Yahoo Finance...")
+    try:
+        df = yf.download(symbol, period=period, interval=interval, progress=False)
+        if df.empty:
+            raise ValueError("No data returned")
+        
+        # Resample to 4h candles (OHLCV aggregation)
+        df = df.resample("4h").agg({
+            "Open": "first", "High": "max", "Low": "min", 
+            "Close": "last", "Volume": "sum"
+        }).dropna()
+        
+        df.columns = ["open", "high", "low", "close", "volume"]
+        df.index = pd.to_datetime(df.index)
+        df = df.reset_index()
+        log(f"✅ Fetched & resampled to {len(df)} 4h candles")
+        return df
+    except Exception as e:
+        log(f"❌ Fetch error: {e}")
+        return None
+
+def calculate_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    """Manual TA calculations (pandas-ta alternative for stability)"""
     df = df.copy()
     
-    # pandas-ta bekerja di pandas 2.2+, hanya butuh warning suppression
-    df.ta.rsi(append=True)
-    df.ta.macd(append=True)
-    df.ta.bbands(append=True)
-    df.ta.cci(append=True)
-    df.dropna(inplace=True)
+    # RSI (14)
+    delta = df["close"].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+    rs = gain / loss
+    df["rsi"] = 100 - (100 / (1 + rs))
     
+    # MACD (12,26,9)
+    exp1 = df["close"].ewm(span=12, adjust=False).mean()
+    exp2 = df["close"].ewm(span=26, adjust=False).mean()
+    df["macd"] = exp1 - exp2
+    df["macd_signal"] = df["macd"].ewm(span=9, adjust=False).mean()
+    df["macd_hist"] = df["macd"] - df["macd_signal"]
+    
+    # Bollinger Bands (20,2)
+    sma = df["close"].rolling(20).mean()
+    std = df["close"].rolling(20).std()
+    df["bb_upper"] = sma + (std * 2)
+    df["bb_lower"] = sma - (std * 2)
+    
+    # CCI (20)
+    tp = (df["high"] + df["low"] + df["close"]) / 3
+    cci_ma = tp.rolling(20).mean()
+    mad = tp.rolling(20).apply(lambda x: np.fabs(x - x.mean()).mean())
+    df["cci"] = (tp - cci_ma) / (0.015 * mad)
+    
+    return df
+
+def prepare_dataset(df: pd.DataFrame):
+    log("📊 Preparing features & labels...")
+    df = calculate_indicators(df).dropna()
+    
+    # Label: 1 if next 4h close > current close * (1 + fee)
     df["next_close"] = df["close"].shift(-1)
     df["label"] = (df["next_close"] > df["close"] * (1 + FEE)).astype(int)
-    df.dropna(inplace=True)
+    df = df.dropna()
+    
+    # Sliding window features
+    feature_cols = ["open", "high", "low", "close", "volume", 
+                    "rsi", "macd", "macd_signal", "macd_hist", 
+                    "bb_upper", "bb_lower", "cci"]
     
-    X_list, y_list, idx_list = [], [], []
+    X_list, y_list = [], []
     for i in range(WINDOW, len(df)):
-        window = df.iloc[i-WINDOW:i].drop(columns=["timestamp", "next_close", "label"])
-        X_list.append(window.values.flatten())
+        window = df.iloc[i-WINDOW:i][feature_cols].values.flatten()
+        X_list.append(window)
         y_list.append(df.iloc[i]["label"])
-        idx_list.append(i)
-        
+    
     X = np.array(X_list)
     y = np.array(y_list)
+    
     scaler = MinMaxScaler()
     X_scaled = scaler.fit_transform(X)
-    logger.info(f"✅ Dataset ready: {X.shape[0]} samples, {X.shape[1]} features.")
-    return X_scaled, y, idx_list, df, scaler
+    log(f"✅ Dataset: {X_scaled.shape[0]} samples, {X_scaled.shape[1]} features")
+    return X_scaled, y, df, scaler
 
 def run_train():
     try:
         if os.path.exists(MODEL_PATH):
-            return {"status": "⚠️ Info", "message": "Model already exists. Delete .pkl files in the Files tab to retrain."}
-            
-        df = fetch_data(SYMBOL, TIMEFRAME)
-        X, y, idx, df_full, scaler = prepare_dataset(df)
+            return {"status": "⚠️ Info", "message": "Model exists. Delete /tmp/*.pkl to retrain."}
+        
+        df = fetch_data(SYMBOL)
+        if df is None:
+            return {"status": "❌ Error", "message": "Failed to fetch data"}
         
+        X, y, df_full, scaler = prepare_dataset(df)
+        
+        # Split 95/5
         split = int(len(X) * 0.95)
         X_train, X_test = X[:split], X[split:]
         y_train, y_test = y[:split], y[split:]
         
-        logger.info("🧠 Training RandomForest model...")
-        model = RandomForestClassifier(n_estimators=500, max_depth=None, random_state=42, n_jobs=-1)
+        log("🧠 Training RandomForest...")
+        model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42, n_jobs=-1)
         model.fit(X_train, y_train)
         acc = float(model.score(X_test, y_test))
         
         joblib.dump(model, MODEL_PATH)
         joblib.dump(scaler, SCALER_PATH)
         
-        test_indices = idx[split:]
-        df_test = df_full.loc[test_indices].copy()
-        df_test["pred"] = model.predict(X_test)
+        # Simple backtest on test set
+        df_test = df_full.iloc[-len(X_test)-10:].copy()
+        preds = model.predict(X_test)
         
-        pnl_list = []
-        for i in range(len(df_test) - 1):
-            if df_test.iloc[i]["pred"] == 1:
+        pnl = []
+        for i in range(len(preds) - 1):
+            if preds[i] == 1:
                 entry = df_test.iloc[i]["close"]
-                exit_ = df_test.iloc[i + 1]["close"]
-                pnl = (exit_ - entry) / entry - FEE
-                pnl_list.append(pnl)
-                
-        wins = sum(1 for p in pnl_list if p > 0)
-        losses = len(pnl_list) - wins
-        gross_profit = sum(p for p in pnl_list if p > 0)
-        gross_loss = sum(abs(p) for p in pnl_list if p <= 0)
-        profit_factor = gross_profit / gross_loss if gross_loss > 0 else float("inf")
+                exit_ = df_test.iloc[i+1]["close"]
+                pnl.append((exit_ - entry) / entry - FEE)
+        
+        wins = sum(1 for p in pnl if p > 0)
+        total = len(pnl)
+        net = sum(pnl) * 100 if pnl else 0
         
         return {
             "status": "✅ Success",
             "accuracy_test": round(acc, 4),
-            "profit_factor": round(profit_factor, 3),
-            "net_profit_pct": round(sum(pnl_list) * 100, 3),
-            "wins": wins, "losses": losses,
-            "win_rate_pct": round(wins / len(pnl_list) * 100, 2) if pnl_list else 0,
-            "message": "Model trained & backtested successfully."
+            "net_profit_pct": round(net, 3),
+            "win_rate_pct": round(wins/total*100, 2) if total else 0,
+            "message": "Model trained successfully"
         }
     except Exception as e:
-        logger.error(f"❌ Training failed: {e}")
-        return {"status": "❌ Error", "message": str(e)}
+        log(f"❌ Train error: {e}")
+        return {"status": "❌ Error", "message": str(e)[:200]}
 
 def run_predict():
     try:
         if not os.path.exists(MODEL_PATH):
-            return {"status": "❌ Error", "message": "Model not found. Train the model first."}
-            
-        df = fetch_data(SYMBOL, TIMEFRAME, limit=WINDOW + 10)
-        _, _, _, df_full, scaler = prepare_dataset(df)
-        latest_window = df_full.iloc[-WINDOW:].drop(columns=["timestamp", "next_close", "label"]).values.flatten().reshape(1, -1)
-        latest_scaled = scaler.transform(latest_window)
+            return {"status": "❌ Error", "message": "Train model first"}
+        
+        df = fetch_data(SYMBOL, period="30d")
+        if df is None:
+            return {"status": "❌ Error", "message": "Data fetch failed"}
+        
+        df = calculate_indicators(df).dropna()
+        feature_cols = ["open", "high", "low", "close", "volume", 
+                        "rsi", "macd", "macd_signal", "macd_hist", 
+                        "bb_upper", "bb_lower", "cci"]
+        
+        latest = df.iloc[-WINDOW:][feature_cols].values.flatten().reshape(1, -1)
+        scaler = joblib.load(SCALER_PATH)
+        latest_scaled = scaler.transform(latest)
         
         model = joblib.load(MODEL_PATH)
         pred = int(model.predict(latest_scaled)[0])
+        prob = float(model.predict_proba(latest_scaled)[0][1])
         
         return {
             "status": "✅ Prediction",
-            "symbol": SYMBOL,
-            "timeframe": TIMEFRAME,
+            "symbol": SYMBOL.replace("-USD", "/USDT"),
             "prediction": "BUY (Hold 4h)" if pred == 1 else "HOLD/SELL",
-            "logic": "Predicts >0.15% movement in next 4h candle"
+            "confidence_pct": round(prob * 100, 1),
+            "logic": f"Model predicts {'>' if pred==1 else '<='}0.15% move in next 4h"
         }
     except Exception as e:
-        logger.error(f"❌ Prediction failed: {e}")
-        return {"status": "❌ Error", "message": str(e)}
+        log(f"❌ Predict error: {e}")
+        return {"status": "❌ Error", "message": str(e)[:200]}
+
+# 🎨 Gradio UI + TradingView Widget
+tradingview_widget = """
+<div class="tradingview-widget-container">
+  <div id="tradingview_chart"></div>
+  <script type="text/javascript" src="https://s3.tradingview.com/tv.js"></script>
+  <script type="text/javascript">
+    new TradingView.widget({
+      "width": "100%", "height": 400, "symbol": "BINANCE:ETHUSDT", 
+      "interval": "240", "timezone": "UTC", "theme": "dark",
+      "style": "1", "locale": "en", "toolbar_bg": "#1a1a1a",
+      "enable_publishing": false, "allow_symbol_change": true,
+      "container_id": "tradingview_chart"
+    });
+  </script>
+</div>
+"""
 
-# 🎨 Gradio UI
-with gr.Blocks(title="Crypto ML Predictor", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Crypto ML Strategy", css=".tradingview-widget-container { margin: 10px 0; }") as demo:
     gr.Markdown("## 📈 Crypto ML Strategy (ETH/USDT 4h)")
-    gr.Markdown("Paper: 2105.06827v3 | Python 3.13 Ready | Gradio 6.14.0")
+    gr.Markdown("Paper: 2105.06827v3 | Data: Yahoo Finance | Chart: TradingView Widget")
+    
+    # TradingView Chart Embed
+    gr.HTML(tradingview_widget)
+    
     with gr.Row():
         train_btn = gr.Button("🔄 Train Model & Backtest", variant="primary")
-        train_out = gr.JSON(label="Training & Backtest Results")
+        train_out = gr.JSON(label="Training Results")
     with gr.Row():
         pred_btn = gr.Button("🔮 Predict Next Move", variant="secondary")
         pred_out = gr.JSON(label="Prediction Signal")
-        
+    
     train_btn.click(run_train, outputs=train_out)
     pred_btn.click(run_predict, outputs=pred_out)
-    gr.Markdown("💡 *Check `App Logs` in the Space tab for real-time debugging.*")
+    
+    gr.Markdown("💡 *Data source: Yahoo Finance (same as TradingView). Model retrains on each session.*")
 
 demo.queue(default_concurrency_limit=1)