Update app.py

app.py

@@ -1,7 +1,7 @@
 import os
 import time
-import logging
 import traceback
+import logging
 from datetime import datetime
 
 import gradio as gr
@@ -9,558 +9,765 @@ import yfinance as yf
 import pandas as pd
 import numpy as np
 import joblib
+import requests
 
-from sklearn.ensemble import RandomForestClassifier
 from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import TimeSeriesSplit
 
-# ============================================================
-# LOGGING
-# ============================================================
+from xgboost import XGBClassifier
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("crypto_ml")
+from ta.trend import ADXIndicator
 
 # ============================================================
+
 # CONFIG
+
 # ============================================================
 
-SYMBOL = "ETH-USD"
+SYMBOLS = [
+"BTC-USD",
+"ETH-USD",
+"SOL-USD",
+"BNB-USD",
+"XRP-USD",
+"DOGE-USD",
+"AVAX-USD",
+"LINK-USD"
+]
+
 WINDOW = 20
-FEE = 0.0015
 
-MODEL_PATH = "/tmp/model.pkl"
-SCALER_PATH = "/tmp/scaler.pkl"
+MODEL_DIR = "models"
+
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+# TELEGRAM
+
+BOT_TOKEN = "YOUR_BOT_TOKEN"
+CHAT_ID = "YOUR_CHAT_ID"
 
 # ============================================================
-# CLEAN DATA
+
+# LOGGING
+
 # ============================================================
 
-def clean_columns(df):
+logging.basicConfig(level=logging.INFO)
 
-    if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.get_level_values(0)
+logger = logging.getLogger("crypto_ai")
 
-    df.columns = [str(c).strip() for c in df.columns]
+# ============================================================
+
+# PATH
 
-    rename = {
-        "open": "Open",
-        "high": "High",
-        "low": "Low",
-        "close": "Close",
-        "adj close": "Close",
-        "volume": "Volume"
-    }
+# ============================================================
 
-    df.columns = [
-        rename.get(c.lower(), c)
-        for c in df.columns
-    ]
+def model_path(symbol):
+
+
+return os.path.join(
+    MODEL_DIR,
+    f"{symbol}_model.pkl"
+)
+
+
+def scaler_path(symbol):
+
+
+return os.path.join(
+    MODEL_DIR,
+    f"{symbol}_scaler.pkl"
+)
 
-    return df
 
 # ============================================================
-# SYNTHETIC DATA
+
+# TELEGRAM
+
 # ============================================================
 
-def synthetic_data(n=500):
+def send_telegram(message):
+
 
-    np.random.seed(42)
+try:
 
-    dates = pd.date_range(
-        end=datetime.utcnow(),
-        periods=n,
-        freq="4h"
+    if "YOUR_BOT_TOKEN" in BOT_TOKEN:
+        return
+
+    url = (
+        f"https://api.telegram.org/"
+        f"bot{BOT_TOKEN}/sendMessage"
     )
 
-    price = 3000
+    requests.post(
+        url,
+        data={
+            "chat_id": CHAT_ID,
+            "text": message
+        },
+        timeout=10
+    )
 
-    opens = []
-    highs = []
-    lows = []
-    closes = []
-    volumes = []
+except Exception as e:
+    logger.warning(e)
 
-    for _ in range(n):
 
-        ret = np.random.normal(0, 0.015)
+# ============================================================
 
-        open_p = price
-        close_p = price * (1 + ret)
+# DOWNLOAD
 
-        high_p = max(open_p, close_p) * 1.01
-        low_p = min(open_p, close_p) * 0.99
+# ============================================================
 
-        vol = np.random.randint(1000, 5000)
+def clean_columns(df):
 
-        opens.append(open_p)
-        highs.append(high_p)
-        lows.append(low_p)
-        closes.append(close_p)
-        volumes.append(vol)
 
-        price = close_p
+if isinstance(df.columns, pd.MultiIndex):
+    df.columns = df.columns.get_level_values(0)
 
-    df = pd.DataFrame({
-        "Open": opens,
-        "High": highs,
-        "Low": lows,
-        "Close": closes,
-        "Volume": volumes
-    }, index=dates)
+df.columns = [str(c).lower() for c in df.columns]
 
-    return df
+return df
 
-# ============================================================
-# DOWNLOAD DATA
-# ============================================================
 
-def safe_download():
+def safe_download(symbol):
 
-    try:
 
-        df = yf.download(
-            SYMBOL,
-            period="90d",
-            interval="1h",
-            progress=False,
-            auto_adjust=True,
-            threads=False
-        )
+try:
 
-        if df is not None and not df.empty:
+    df = yf.download(
+        symbol,
+        period="90d",
+        interval="1h",
+        progress=False,
+        auto_adjust=True,
+        threads=False
+    )
 
-            df = clean_columns(df)
+    if df is not None and not df.empty:
 
-            return df, True
+        df = clean_columns(df)
 
-    except Exception as e:
-        logger.warning(e)
+        return df, True
+
+except Exception as e:
+
+    logger.warning(e)
+
+return None, False
 
-    return synthetic_data(), False
 
 # ============================================================
+
 # FEATURE ENGINEERING
+
 # ============================================================
 
-def fetch_and_prepare():
+def fetch_and_prepare(symbol):
+
+
+df, is_real = safe_download(symbol)
+
+if df is None:
+    return None, None, None, False
 
-    df, is_real = safe_download()
+df = df.resample("4h").agg({
+    "open": "first",
+    "high": "max",
+    "low": "min",
+    "close": "last",
+    "volume": "sum"
+}).dropna()
 
-    if not isinstance(df.index, pd.DatetimeIndex):
-        df.index = pd.to_datetime(df.index)
+# RSI
 
-    df = df.resample("4h").agg({
-        "Open": "first",
-        "High": "max",
-        "Low": "min",
-        "Close": "last",
-        "Volume": "sum"
-    }).dropna()
+delta = df["close"].diff()
 
-    df.columns = [c.lower() for c in df.columns]
+gain = delta.where(
+    delta > 0,
+    0
+).rolling(14).mean()
 
-    # RSI
+loss = (-delta.where(
+    delta < 0,
+    0
+)).rolling(14).mean()
 
-    delta = df["close"].diff()
+rs = gain / loss.replace(0, np.nan)
 
-    gain = delta.where(delta > 0, 0).rolling(14).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+df["rsi"] = (
+    100 - (100 / (1 + rs))
+).fillna(50)
 
-    rs = gain / loss.replace(0, np.nan)
+# MACD
 
-    df["rsi"] = (
-        100 - (100 / (1 + rs))
-    ).fillna(50)
+ema12 = df["close"].ewm(span=12).mean()
+ema26 = df["close"].ewm(span=26).mean()
+
+df["macd"] = ema12 - ema26
+df["macd_signal"] = (
+    df["macd"]
+    .ewm(span=9)
+    .mean()
+)
+
+# EMA
+
+df["ema9"] = (
+    df["close"]
+    .ewm(span=9)
+    .mean()
+)
 
-    # MACD
+df["ema21"] = (
+    df["close"]
+    .ewm(span=21)
+    .mean()
+)
 
-    ema12 = df["close"].ewm(span=12).mean()
-    ema26 = df["close"].ewm(span=26).mean()
+df["ema50"] = (
+    df["close"]
+    .ewm(span=50)
+    .mean()
+)
 
-    df["macd"] = ema12 - ema26
-    df["macd_signal"] = df["macd"].ewm(span=9).mean()
+df["ema200"] = (
+    df["close"]
+    .ewm(span=200)
+    .mean()
+)
 
-    # Bollinger
+# BOLLINGER
 
-    sma20 = df["close"].rolling(20).mean()
-    std20 = df["close"].rolling(20).std()
+sma20 = (
+    df["close"]
+    .rolling(20)
+    .mean()
+)
 
-    df["bb_upper"] = sma20 + (2 * std20)
-    df["bb_lower"] = sma20 - (2 * std20)
+std20 = (
+    df["close"]
+    .rolling(20)
+    .std()
+)
 
-    # EMA
+df["bb_upper"] = sma20 + (2 * std20)
+df["bb_lower"] = sma20 - (2 * std20)
 
-    df["ema9"] = df["close"].ewm(span=9).mean()
-    df["ema21"] = df["close"].ewm(span=21).mean()
+# ATR
 
-    # Return
+df["atr"] = (
+    (df["high"] - df["low"])
+    .rolling(14)
+    .mean()
+)
 
-    df["return1"] = df["close"].pct_change()
-    df["return4"] = df["close"].pct_change(4)
+# VOLUME
 
-    # Label
+df["vol_sma"] = (
+    df["volume"]
+    .rolling(20)
+    .mean()
+)
 
-    df["next_close"] = df["close"].shift(-1)
+df["volume_spike"] = (
+    df["volume"]
+    >
+    df["vol_sma"] * 2
+)
 
-    df["label"] = (
-        df["next_close"] >
-        df["close"] * (1 + FEE)
-    ).astype(int)
+# ADX
 
-    df = df.replace([np.inf, -np.inf], np.nan)
-    df = df.dropna()
+adx = ADXIndicator(
+    high=df["high"],
+    low=df["low"],
+    close=df["close"]
+)
 
-    feat_cols = [
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume",
-        "rsi",
-        "macd",
-        "macd_signal",
-        "bb_upper",
-        "bb_lower",
-        "ema9",
-        "ema21",
-        "return1",
-        "return4"
-    ]
+df["adx"] = adx.adx()
 
-    X_list = []
-    y_list = []
+# TREND STRENGTH
 
-    for i in range(WINDOW, len(df)):
+df["trend_strength"] = (
+    abs(
+        df["ema50"]
+        -
+        df["ema200"]
+    )
+    /
+    df["close"]
+)
+
+# VOLATILITY
+
+df["volatility"] = (
+    df["close"]
+    .pct_change()
+    .rolling(20)
+    .std()
+)
+
+# MARKET REGIME
+
+def detect_regime(row):
+
+    if row["volatility"] < 0.01:
+        return "SIDEWAYS"
+
+    if row["ema50"] > row["ema200"]:
+        return "BULL"
+
+    return "BEAR"
+
+df["regime"] = df.apply(
+    detect_regime,
+    axis=1
+)
+
+# RETURNS
+
+df["return1"] = (
+    df["close"]
+    .pct_change()
+)
+
+df["return4"] = (
+    df["close"]
+    .pct_change(4)
+)
+
+# LABEL
+
+df["next_close"] = (
+    df["close"]
+    .shift(-1)
+)
+
+df["label"] = (
+    df["next_close"]
+    >
+    df["close"]
+).astype(int)
+
+df = df.replace(
+    [np.inf, -np.inf],
+    np.nan
+)
 
-        window = df.iloc[
-            i-WINDOW:i
-        ][feat_cols].values
+df = df.dropna()
+
+feat_cols = [
+    "open",
+    "high",
+    "low",
+    "close",
+    "volume",
+    "rsi",
+    "macd",
+    "macd_signal",
+    "ema9",
+    "ema21",
+    "ema50",
+    "ema200",
+    "bb_upper",
+    "bb_lower",
+    "atr",
+    "adx",
+    "trend_strength",
+    "return1",
+    "return4"
+]
+
+X_list = []
+y_list = []
+
+for i in range(WINDOW, len(df)):
+
+    window = df.iloc[
+        i-WINDOW:i
+    ][feat_cols].values
+
+    X_list.append(
+        window.flatten()
+    )
 
-        if np.isnan(window).any():
-            continue
+    y_list.append(
+        df.iloc[i]["label"]
+    )
 
-        X_list.append(window.flatten())
-        y_list.append(df.iloc[i]["label"])
+X = np.array(X_list)
+y = np.array(y_list)
 
-    X = np.array(X_list)
-    y = np.array(y_list)
+return X, y, df, feat_cols, is_real
 
-    return X, y, df, feat_cols, is_real
 
 # ============================================================
-# TRAIN MODEL
+
+# TRAIN
+
 # ============================================================
 
-def run_train():
+def run_train(symbol):
 
-    try:
 
-        X, y, df, feat_cols, is_real = fetch_and_prepare()
+X, y, df, feat_cols, is_real = (
+    fetch_and_prepare(symbol)
+)
+
+if X is None:
+    return
+
+scaler = MinMaxScaler()
+
+X_scaled = scaler.fit_transform(X)
+
+model = XGBClassifier(
+    n_estimators=300,
+    max_depth=6,
+    learning_rate=0.03,
+    subsample=0.8,
+    colsample_bytree=0.8,
+    eval_metric="logloss",
+    random_state=42
+)
+
+tscv = TimeSeriesSplit(
+    n_splits=5
+)
 
-        scaler = MinMaxScaler()
+for train_idx, test_idx in tscv.split(X_scaled):
 
-        X_scaled = scaler.fit_transform(X)
+    X_train = X_scaled[train_idx]
+    y_train = y[train_idx]
 
-        split = int(len(X_scaled) * 0.88)
+    model.fit(
+        X_train,
+        y_train
+    )
 
-        X_train = X_scaled[:split]
-        X_test = X_scaled[split:]
+joblib.dump(
+    model,
+    model_path(symbol)
+)
 
-        y_train = y[:split]
-        y_test = y[split:]
+joblib.dump(
+    scaler,
+    scaler_path(symbol)
+)
 
-        model = RandomForestClassifier(
-            n_estimators=100,
-            max_depth=8,
-            random_state=42,
-            class_weight="balanced"
-        )
+logger.info(
+    f"TRAINED: {symbol}"
+)
 
-        model.fit(X_train, y_train)
 
-        acc = model.score(X_test, y_test)
+# ============================================================
 
-        joblib.dump(model, MODEL_PATH)
-        joblib.dump(scaler, SCALER_PATH)
+# TRAIN ALL
 
-        return f"""
-✅ MODEL TRAINED
+# ============================================================
 
-Accuracy:
-{acc:.4f}
+def train_all():
 
-Samples:
-{len(X)}
 
-Source:
-{"LIVE DATA" if is_real else "SIMULATED"}
-"""
+for symbol in SYMBOLS:
+
+    try:
+
+        run_train(symbol)
 
     except Exception as e:
 
-        logger.error(traceback.format_exc())
+        logger.error(e)
 
-        return str(e)
 
 # ============================================================
-# TP SL FIBONACCI
+
+# TRADE LEVELS
+
 # ============================================================
 
 def trade_levels(df, signal):
 
-    close_price = float(df.iloc[-1]["close"])
 
-    recent_high = float(df["high"].tail(20).max())
-    recent_low = float(df["low"].tail(20).min())
+last = df.iloc[-1]
 
-    fib_range = recent_high - recent_low
+close_price = float(last["close"])
 
-    fib236 = recent_high - fib_range * 0.236
-    fib382 = recent_high - fib_range * 0.382
-    fib500 = recent_high - fib_range * 0.5
-    fib618 = recent_high - fib_range * 0.618
+atr = float(last["atr"])
 
-    atr = (
-        (df["high"] - df["low"])
-        .rolling(14)
-        .mean()
-        .iloc[-1]
-    )
+if signal == "BUY":
+
+    tp1 = close_price + atr
+    tp2 = close_price + atr * 2
+    tp3 = close_price + atr * 3
 
-    if signal == "BUY":
+    sl = close_price - atr * 1.5
 
-        tp1 = fib236
-        tp2 = fib382
-        tp3 = recent_high
+elif signal == "SELL":
 
-        sl = close_price - atr * 1.5
+    tp1 = close_price - atr
+    tp2 = close_price - atr * 2
+    tp3 = close_price - atr * 3
 
-    else:
+    sl = close_price + atr * 1.5
 
-        tp1 = fib618
-        tp2 = fib500
-        tp3 = recent_low
+else:
 
-        sl = close_price + atr * 1.5
+    tp1 = tp2 = tp3 = sl = close_price
+
+return {
+    "entry": close_price,
+    "tp1": tp1,
+    "tp2": tp2,
+    "tp3": tp3,
+    "sl": sl
+}
 
-    return {
-        "entry": close_price,
-        "tp1": tp1,
-        "tp2": tp2,
-        "tp3": tp3,
-        "sl": sl,
-        "fib236": fib236,
-        "fib382": fib382,
-        "fib500": fib500,
-        "fib618": fib618
-    }
 
 # ============================================================
+
 # PREDICT
+
 # ============================================================
 
-def run_predict():
+LAST_SIGNALS = {}
 
-    try:
+def run_predict(symbol):
+
+
+if not os.path.exists(
+    model_path(symbol)
+):
+
+    run_train(symbol)
+
+X, y, df, feat_cols, is_real = (
+    fetch_and_prepare(symbol)
+)
+
+scaler = joblib.load(
+    scaler_path(symbol)
+)
+
+model = joblib.load(
+    model_path(symbol)
+)
+
+latest = (
+    df.iloc[-WINDOW:][feat_cols]
+    .values
+    .flatten()
+    .reshape(1, -1)
+)
 
-        if not os.path.exists(MODEL_PATH):
-            return "⚠️ Train model terlebih dahulu"
+latest_scaled = scaler.transform(
+    latest
+)
 
-        X, y, df, feat_cols, is_real = fetch_and_prepare()
+pred = model.predict(
+    latest_scaled
+)[0]
 
-        scaler = joblib.load(SCALER_PATH)
-        model = joblib.load(MODEL_PATH)
+proba = model.predict_proba(
+    latest_scaled
+)[0]
 
-        latest = df.iloc[
-            -WINDOW:
-        ][feat_cols].values.flatten()
+confidence = float(
+    np.max(proba)
+) * 100
 
-        latest = latest.reshape(1, -1)
+last = df.iloc[-1]
 
-        latest_scaled = scaler.transform(latest)
+bull_trend = (
+    last["ema50"]
+    >
+    last["ema200"]
+)
 
-        pred = model.predict(latest_scaled)[0]
+bear_trend = (
+    last["ema50"]
+    <
+    last["ema200"]
+)
 
-        proba = model.predict_proba(
-            latest_scaled
-        )[0]
+strong_volume = (
+    last["volume"]
+    >
+    last["vol_sma"]
+)
 
-        confidence = float(np.max(proba)) * 100
+strong_adx = (
+    last["adx"] > 25
+)
 
-        signal = "BUY" if pred == 1 else "SELL"
+regime = last["regime"]
 
-        levels = trade_levels(df, signal)
+score = 0
 
-        return f"""
-═══════════════════════
-🤖 AI TRADING SIGNAL
-═══════════════════════
+if bull_trend:
+    score += 20
 
-🔮 Signal:
-{signal}
+if strong_volume:
+    score += 20
 
-📊 Confidence:
-{confidence:.2f}%
+if strong_adx:
+    score += 20
 
-💰 Entry:
-${levels['entry']:,.2f}
+if last["rsi"] > 55:
+    score += 20
 
-━━━━━━━━━━━━━━━━━━━
+if last["macd"] > last["macd_signal"]:
+    score += 20
 
-🎯 TAKE PROFIT
+signal = "NO TRADE"
 
-TP1:
-${levels['tp1']:,.2f}
+if regime == "SIDEWAYS":
 
-TP2:
-${levels['tp2']:,.2f}
+    signal = "NO TRADE"
 
-TP3:
-${levels['tp3']:,.2f}
+else:
 
-━━━━━━━━━━━━━━━━━━━
+    if pred == 1 and score >= 60:
 
-🛑 STOP LOSS
+        signal = "BUY"
 
-${levels['sl']:,.2f}
+    elif pred == 0 and score >= 60:
 
-━━━━━━━━━━━━━━━━━━━
+        signal = "SELL"
 
-📐 FIBONACCI
+levels = trade_levels(
+    df,
+    signal
+)
 
-0.236:
-${levels['fib236']:,.2f}
+# TELEGRAM
 
-0.382:
-${levels['fib382']:,.2f}
+previous = LAST_SIGNALS.get(symbol)
 
-0.500:
-${levels['fib500']:,.2f}
+if previous != signal:
 
-0.618:
-${levels['fib618']:,.2f}
+    LAST_SIGNALS[symbol] = signal
 
-━━━━━━━━━━━━━━━━━━━
+    send_telegram(
+        f"""
 
-📈 INDICATORS
 
-RSI:
-{df.iloc[-1]['rsi']:.2f}
+🚨 NEW SIGNAL
 
-MACD:
-{df.iloc[-1]['macd']:.2f}
+PAIR: {symbol}
 
-━━━━━━━━━━━━━━━━━━━
+SIGNAL: {signal}
 
-📡 SOURCE:
-{"LIVE DATA" if is_real else "SIMULATED"}
+CONFIDENCE: {confidence:.2f}%
 """
+)
 
-    except Exception as e:
 
-        logger.error(traceback.format_exc())
+return {
+    "Pair": symbol,
+    "Signal": signal,
+    "Confidence": round(confidence, 2),
+    "Score": score,
+    "Entry": round(levels["entry"], 2),
+    "TP1": round(levels["tp1"], 2),
+    "TP2": round(levels["tp2"], 2),
+    "TP3": round(levels["tp3"], 2),
+    "SL": round(levels["sl"], 2),
+    "RSI": round(last["rsi"], 2),
+    "ADX": round(last["adx"], 2),
+    "Regime": regime
+}
 
-        return str(e)
 
 # ============================================================
-# MARKET INFO
+
+# SCAN ALL
+
 # ============================================================
 
-def get_market_info():
+LAST_RETRAIN = 0
 
-    try:
+def realtime_scan():
 
-        df, is_real = safe_download()
 
-        price = float(df["Close"].iloc[-1])
+global LAST_RETRAIN
 
-        high = float(df["High"].tail(24).max())
-        low = float(df["Low"].tail(24).min())
+now = time.time()
 
-        return f"""
-💰 ETH PRICE:
-${price:,.2f}
+# AUTO RETRAIN
 
-📈 24H HIGH:
-${high:,.2f}
+if now - LAST_RETRAIN > 21600:
 
-📉 24H LOW:
-${low:,.2f}
+    logger.info(
+        "AUTO RETRAIN..."
+    )
 
-📡 SOURCE:
-{"LIVE DATA" if is_real else "SIMULATED"}
-"""
+    train_all()
+
+    LAST_RETRAIN = now
+
+rows = []
+
+for symbol in SYMBOLS:
+
+    try:
+
+        result = run_predict(symbol)
+
+        rows.append(result)
 
     except Exception as e:
-        return str(e)
 
-# ============================================================
-# TRADINGVIEW
-# ============================================================
+        logger.error(traceback.format_exc())
+
+df = pd.DataFrame(rows)
+
+if len(df) > 0:
+
+    df = df.sort_values(
+        by="Score",
+        ascending=False
+    )
+
+return df
 
-TRADINGVIEW_HTML = """
-<div style="width:100%;height:600px;">
-<iframe
-src="https://s.tradingview.com/widgetembed/?symbol=BINANCE:ETHUSDT&interval=240&theme=dark&style=1"
-style="width:100%;height:100%;border:none;">
-</iframe>
-</div>
-"""
 
 # ============================================================
+
 # UI
+
 # ============================================================
 
-with gr.Blocks(title="CryptoML PRO") as demo:
+with gr.Blocks(
+title="Crypto AI Scanner"
+) as demo:
 
-    gr.Markdown("# 🚀 CryptoML PRO")
 
-    gr.HTML(TRADINGVIEW_HTML)
+gr.Markdown(
+    "# 🤖 Crypto AI Scanner PRO"
+)
 
-    market_box = gr.Textbox(
-        label="Market Info",
-        value=get_market_info(),
-        lines=8
-    )
+table = gr.Dataframe(
+    interactive=False
+)
 
-    with gr.Row():
+timer = gr.Timer(20)
 
-        train_btn = gr.Button(
-            "⚡ Train Model"
-        )
+timer.tick(
+    fn=realtime_scan,
+    outputs=table
+)
 
-        predict_btn = gr.Button(
-            "🔮 Predict Signal"
-        )
 
-        refresh_btn = gr.Button(
-            "🔄 Refresh"
-        )
+# ============================================================
 
-    train_output = gr.Textbox(
-        label="Training Result",
-        lines=10
-    )
+# START
 
-    predict_output = gr.Textbox(
-        label="Prediction",
-        lines=30
-    )
+# ============================================================
 
-    train_btn.click(
-        fn=run_train,
-        outputs=train_output
-    )
+if **name** == "**main**":
 
-    predict_btn.click(
-        fn=run_predict,
-        outputs=predict_output
-    )
 
-    refresh_btn.click(
-        fn=get_market_info,
-        outputs=market_box
-    )
+train_all()
 
 demo.queue()