Update app.py

app.py

@@ -1,758 +1,261 @@
-import os
-import time
-import logging
-import traceback
-
+# -*- coding: utf-8 -*-
+"""
+HUGGING FACE SPACE: BINANCE SPOT TRADING SIMULATOR
+Gradio Dashboard | No API Key Required | Rule-Based Virtual Execution
+"""
+import os, time, json, threading, logging, requests, pandas as pd
+from datetime import datetime, timezone
+from pathlib import Path
 import gradio as gr
-import pandas as pd
-import numpy as np
-import requests
-import joblib
-
-from sklearn.preprocessing import MinMaxScaler
-from sklearn.model_selection import TimeSeriesSplit
-
-from xgboost import XGBClassifier
-
-from ta.trend import ADXIndicator
-
-
-# ============================================================
-# CONFIG
-# ============================================================
-
-SYMBOLS = [
-    "BTCUSDT",
-    "ETHUSDT",
-    "SOLUSDT",
-    "BNBUSDT",
-    "XRPUSDT",
-    "DOGEUSDT",
-]
-
-WINDOW = 20
-
-MODEL_DIR = "models"
-DATA_DIR = "data"
-
-os.makedirs(MODEL_DIR, exist_ok=True)
-os.makedirs(DATA_DIR, exist_ok=True)
-
-CACHE_SECONDS = 60
-
-LAST_DOWNLOAD = {}
-LAST_RETRAIN = 0
-
-
-# ============================================================
-# LOGGING
-# ============================================================
-
-logging.basicConfig(level=logging.INFO)
-
-logger = logging.getLogger("crypto_ai")
-
-
-# ============================================================
-# PATHS
-# ============================================================
-
-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"
-    )
-
-
-def data_path(symbol):
-
-    return os.path.join(
-        DATA_DIR,
-        f"{symbol}.csv"
-    )
-
-
-# ============================================================
-# DOWNLOAD BINANCE DATA
-# ============================================================
-
-def safe_download(symbol):
-
-    try:
-
-        now = time.time()
-
-        csv_file = data_path(symbol)
-
-        # ============================================
-        # CACHE
-        # ============================================
-
-        if os.path.exists(csv_file):
-
-            last_time = LAST_DOWNLOAD.get(symbol, 0)
-
-            if now - last_time < CACHE_SECONDS:
-
-                df = pd.read_csv(
-                    csv_file,
-                    index_col=0
-                )
-
-                df.index = pd.to_datetime(df.index)
-
-                return df
-
-        # ============================================
-        # BINANCE API
-        # ============================================
-
-        url = (
-            "https://api.binance.com/api/v3/klines"
-        )
-
-        params = {
-            "symbol": symbol,
-            "interval": "1h",
-            "limit": 1000
-        }
-
-        response = requests.get(
-            url,
-            params=params,
-            timeout=20
-        )
-
-        # ============================================
-        # VALIDATE RESPONSE
-        # ============================================
-
-        if response.status_code != 200:
-
-            logger.warning(
-                f"{symbol} API ERROR: "
-                f"{response.status_code}"
-            )
-
-            return None
-
-        data = response.json()
-
-        # BINANCE ERROR RESPONSE
-
-        if not isinstance(data, list):
-
-            logger.warning(
-                f"{symbol} INVALID RESPONSE: {data}"
-            )
-
-            return None
-
-        if len(data) == 0:
-
-            logger.warning(
-                f"{symbol} EMPTY DATA"
-            )
-
-            return None
-
-        rows = []
-
-        for k in data:
-
-            # VALIDATE CANDLE
-
-            if not isinstance(k, list):
-
-                continue
-
-            if len(k) < 6:
-
-                continue
-
-            rows.append({
-                "time": pd.to_datetime(
-                    int(k[0]),
-                    unit="ms"
-                ),
-                "open": float(k[1]),
-                "high": float(k[2]),
-                "low": float(k[3]),
-                "close": float(k[4]),
-                "volume": float(k[5]),
-            })
-
-        if len(rows) == 0:
-
-            logger.warning(
-                f"{symbol} NO VALID ROWS"
-            )
-
-            return None
-
-        df = pd.DataFrame(rows)
-
-        df = df.set_index("time")
-
-        df.to_csv(csv_file)
-
-        LAST_DOWNLOAD[symbol] = now
-
-        return df
-
-    except Exception as e:
-
-        logger.warning(
-            f"{symbol} DOWNLOAD ERROR: {e}"
-        )
-
-    # ============================================
-    # FALLBACK CACHE
-    # ============================================
-
-    try:
-
-        if os.path.exists(csv_file):
-
-            logger.info(
-                f"Using cache: {symbol}"
-            )
-
-            df = pd.read_csv(
-                csv_file,
-                index_col=0
-            )
-
-            df.index = pd.to_datetime(df.index)
-
-            return df
-
-    except Exception as e:
-
-        logger.warning(e)
-
-    return None
-
-
-# ============================================================
-# FEATURE ENGINEERING
-# ============================================================
-
-def fetch_and_prepare(symbol):
-
-    df = safe_download(symbol)
-
-    if df is None:
-
-        return None, None, None, None
-
-    df.index = pd.to_datetime(df.index)
-
-    df = df.resample("4h").agg({
-        "open": "first",
-        "high": "max",
-        "low": "min",
-        "close": "last",
-        "volume": "sum"
-    }).dropna()
-
-    # RSI
-
-    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.replace(0, np.nan)
-
-    df["rsi"] = (
-        100 - (100 / (1 + rs))
-    ).fillna(50)
-
-    # MACD
-
-    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()
-    )
-
-    df["ema21"] = (
-        df["close"]
-        .ewm(span=21)
-        .mean()
-    )
-
-    df["ema50"] = (
-        df["close"]
-        .ewm(span=50)
-        .mean()
-    )
-
-    df["ema200"] = (
-        df["close"]
-        .ewm(span=200)
-        .mean()
-    )
-
-    # BOLLINGER
-
-    sma20 = (
-        df["close"]
-        .rolling(20)
-        .mean()
-    )
-
-    std20 = (
-        df["close"]
-        .rolling(20)
-        .std()
-    )
-
-    df["bb_upper"] = sma20 + (2 * std20)
-
-    df["bb_lower"] = sma20 - (2 * std20)
-
-    # ATR
-
-    df["atr"] = (
-        (df["high"] - df["low"])
-        .rolling(14)
-        .mean()
-    )
-
-    # VOLUME
-
-    df["vol_sma"] = (
-        df["volume"]
-        .rolling(20)
-        .mean()
-    )
-
-    # ADX
-
-    adx = ADXIndicator(
-        high=df["high"],
-        low=df["low"],
-        close=df["close"]
-    )
-
-    df["adx"] = adx.adx()
-
-    # VOLATILITY
-
-    df["volatility"] = (
-        df["close"]
-        .pct_change()
-        .rolling(20)
-        .std()
-    )
-
-    # 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
-    )
-
-    df = df.dropna()
-
-    feat_cols = [
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume",
-        "rsi",
-        "macd",
-        "macd_signal",
-        "ema9",
-        "ema21",
-        "ema50",
-        "ema200",
-        "bb_upper",
-        "bb_lower",
-        "atr",
-        "adx",
-        "return1",
-        "return4"
-    ]
-
-    X_list = []
-    y_list = []
-
-    for i in range(WINDOW, len(df)):
-
-        window = df.iloc[
-            i-WINDOW:i
-        ][feat_cols].values
-
-        if np.isnan(window).any():
-            continue
-
-        X_list.append(
-            window.flatten()
-        )
-
-        y_list.append(
-            df.iloc[i]["label"]
-        )
-
-    X = np.array(X_list)
-
-    y = np.array(y_list)
-
-    return X, y, df, feat_cols
-
-
-# ============================================================
-# TRAIN
-# ============================================================
-
-def run_train(symbol):
-
-    try:
-
-        result = fetch_and_prepare(symbol)
-
-        if result is None:
-            return False
-
-        X, y, df, feat_cols = result
-
-        if X is None:
-            return False
-
-        if len(X) < 50:
-            return False
-
-        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
-        )
-
-        model.fit(X_scaled, y)
-
-        joblib.dump(
-            model,
-            model_path(symbol)
-        )
-
-        joblib.dump(
-            scaler,
-            scaler_path(symbol)
-        )
-
-        logger.info(
-            f"TRAINED: {symbol}"
-        )
-
-        return True
-
-    except Exception as e:
-
-        logger.error(
-            f"TRAIN ERROR {symbol}: {e}"
-        )
-
-        return False
-
-
-# ============================================================
-# TRAIN ALL
-# ============================================================
-
-def train_all():
-
-    for symbol in SYMBOLS:
-
-        try:
-
-            run_train(symbol)
-
-            time.sleep(1)
-
-        except Exception as e:
-
-            logger.error(e)
-
-
-# ============================================================
-# TRADE LEVELS
-# ============================================================
-
-def trade_levels(df, signal):
-
-    last = df.iloc[-1]
-
-    close_price = float(
-        last["close"]
-    )
-
-    atr = float(
-        last["atr"]
-    )
-
-    if signal == "BUY":
-
-        tp1 = close_price + atr
-        tp2 = close_price + atr * 2
-        tp3 = close_price + atr * 3
-
-        sl = close_price - atr * 1.5
-
-    elif signal == "SELL":
-
-        tp1 = close_price - atr
-        tp2 = close_price - atr * 2
-        tp3 = close_price - atr * 3
-
-        sl = close_price + atr * 1.5
-
-    else:
-
-        tp1 = close_price
-        tp2 = close_price
-        tp3 = close_price
-
-        sl = close_price
 
+# ==========================================
+# KONFIGURASI
+# ==========================================
+CONFIG = {
+    "WATCHLIST": ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT", "LINKUSDT"],
+    "INTERVAL": "1h",
+    "RISK_PCT": 0.01,
+    "MAX_DAILY_TRADES": 2,
+    "DAILY_LOSS_LIMIT": -0.03,
+    "DAILY_PROFIT_LOCK": 0.05,
+    "AI_THRESHOLD": 70,
+    "TP1": 0.03, "TP1_SHARE": 0.3,
+    "TP2": 0.05, "TP2_SHARE": 0.3,
+    "TP3_SHARE": 0.4,
+    "TRAIL_PCT": 0.02,
+    "TELEGRAM_TOKEN": os.getenv("TELEGRAM_TOKEN", ""),
+    "TELEGRAM_CHAT_ID": os.getenv("TELEGRAM_CHAT_ID", "")
+}
+
+STATE_FILE = "sim_state.json"
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+# ==========================================
+# STATE MANAGEMENT
+# ==========================================
+def load_state():
+    if os.path.exists(STATE_FILE):
+        with open(STATE_FILE) as f: return json.load(f)
     return {
-        "entry": round(close_price, 2),
-        "tp1": round(tp1, 2),
-        "tp2": round(tp2, 2),
-        "tp3": round(tp3, 2),
-        "sl": round(sl, 2)
+        "date": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
+        "balance": 1000.0, "trades": 0, "daily_pnl": 0.0,
+        "positions": [], "logs": []
     }
 
+def save_state(s):
+    with open(STATE_FILE, "w") as f: json.dump(s, f, indent=2)
 
-# ============================================================
-# PREDICT
-# ============================================================
-
-def run_predict(symbol):
-
-    # ============================================
-    # AUTO TRAIN
-    # ============================================
-
-    if not os.path.exists(
-        model_path(symbol)
-    ):
-
-        ok = run_train(symbol)
-
-        if not ok:
-
-            return {
-                "Pair": symbol,
-                "Signal": "ERROR",
-                "Confidence": 0,
-                "Score": 0,
-                "Entry": 0,
-                "TP1": 0,
-                "TP2": 0,
-                "TP3": 0,
-                "SL": 0,
-                "RSI": 0,
-                "ADX": 0,
-                "Regime": "ERROR"
-            }
-
-    if not os.path.exists(
-        scaler_path(symbol)
-    ):
-
-        return {
-            "Pair": symbol,
-            "Signal": "NO MODEL",
-            "Confidence": 0,
-            "Score": 0,
-            "Entry": 0,
-            "TP1": 0,
-            "TP2": 0,
-            "TP3": 0,
-            "SL": 0,
-            "RSI": 0,
-            "ADX": 0,
-            "Regime": "ERROR"
-        }
-
-
-# ============================================================
-# REALTIME SCAN
-# ============================================================
-
-def realtime_scan():
-
-    global LAST_RETRAIN
-
-    now = time.time()
-
-    # AUTO RETRAIN EVERY 6 HOURS
-
-    if now - LAST_RETRAIN > 21600:
-
-        logger.info(
-            "AUTO RETRAIN..."
-        )
-
-        train_all()
-
-        LAST_RETRAIN = now
-
-    rows = []
-
-    for symbol in SYMBOLS:
-
-        try:
-
-            time.sleep(0.5)
-
-            result = run_predict(symbol)
-
-            rows.append(result)
-
-        except Exception:
-
-            logger.error(
-                traceback.format_exc()
-            )
-
-    df = pd.DataFrame(rows)
-
-    if len(df) > 0:
-
-        df = df.sort_values(
-            by="Score",
-            ascending=False
-        )
+# ==========================================
+# PUBLIC BINANCE FETCHER (NO API KEY)
+# ==========================================
+def fetch_klines(sym, interval="1h", limit=100):
+    try:
+        r = requests.get("https://api.binance.com/api/v3/klines",
+                         params={"symbol": sym, "interval": interval, "limit": limit}, timeout=10)
+        r.raise_for_status()
+        d = r.json()
+        df = pd.DataFrame(d, columns=["ts","o","h","l","c","v"] + ["_"]*6)
+        df["ts"] = pd.to_datetime(df["ts"], unit="ms")
+        for c in "o h l c v".split(): df[c] = df[c].astype(float)
+        return df[["ts","o","h","l","c","v"]]
+    except Exception as e:
+        return pd.DataFrame()
 
+# ==========================================
+# INDIKATOR & AI SCORE
+# ==========================================
+def add_ema(df, periods=[20, 50]):
+    for p in periods: df[f"ema_{p}"] = df["c"].ewm(span=p, adjust=False).mean()
     return df
 
-
-# ============================================================
-# UI
-# ============================================================
-
-with gr.Blocks(
-    title="Crypto AI Scanner"
-) as demo:
-
-    gr.Markdown(
-        "# 🤖 Crypto AI Scanner PRO"
-    )
-
-    table = gr.Dataframe(
-        interactive=False
-    )
-
-    timer = gr.Timer(30)
-
-    timer.tick(
-        fn=realtime_scan,
-        outputs=table
-    )
-
-
-# ============================================================
-# START
-# ============================================================
+def calc_ai_score(df):
+    if len(df) < 50: return 0
+    trend = 30 if df["ema_20"].iloc[-1] > df["ema_50"].iloc[-1] else 0
+    vol_ma = df["v"].rolling(20).mean().iloc[-1]
+    vol_ratio = df["v"].iloc[-1] / max(vol_ma, 1e-9)
+    vol = min(vol_ratio * 10, 40) if vol_ratio > 1 else 0
+    mom = min((df["c"].iloc[-1] / df["c"].iloc[-5] - 1) * 1000, 30)
+    return max(0, min(100, trend + vol + mom))
+
+# ==========================================
+# TELEGRAM ALERT
+# ==========================================
+def tg_send(txt):
+    if not CONFIG["TELEGRAM_TOKEN"] or not CONFIG["TELEGRAM_CHAT_ID"]: return
+    try:
+        requests.post(f"https://api.telegram.org/bot{CONFIG['TELEGRAM_TOKEN']}/sendMessage",
+                      json={"chat_id": CONFIG["TELEGRAM_CHAT_ID"], "text": txt, "parse_mode": "HTML"}, timeout=5)
+    except: pass
+
+def tg_fmt(emoji, title, msg):
+    return f"{emoji} <b>{title}</b>\n{msg}\n⏰ {datetime.now(timezone.utc).strftime('%H:%M UTC')}"
+
+# ==========================================
+# SIMULATION ENGINE
+# ==========================================
+class SimEngine:
+    def __init__(self):
+        self.state = load_state()
+        self._lock = threading.Lock()
+        self._running = False
+        self._stop = threading.Event()
+        self._thread = None
+
+    def start(self):
+        if self._running: return "⚠️ Sudah berjalan"
+        self._running = True
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+        return "✅ Simulator Started"
+
+    def stop(self):
+        self._stop.set()
+        self._running = False
+        return "⏹ Simulator Stopped"
+
+    def _reset_daily(self):
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        if self.state["date"] != today:
+            with self._lock:
+                self.state.update({"date": today, "trades": 0, "daily_pnl": 0.0, "positions": []})
+                save_state(self.state)
+
+    def _can_trade(self):
+        with self._lock:
+            if self.state["trades"] >= CONFIG["MAX_DAILY_TRADES"]: return False, "Max 2 trade/hari"
+            if self.state["daily_pnl"] <= CONFIG["DAILY_LOSS_LIMIT"]: return False, "Daily Loss Limit -3%"
+            if self.state["daily_pnl"] >= CONFIG["DAILY_PROFIT_LOCK"]: return False, "Profit Lock +5%"
+            return True, "OK"
+
+    def _check_positions(self):
+        with self._lock:
+            for p in self.state["positions"][:]:
+                sym = p["symbol"]
+                df = fetch_klines(sym, CONFIG["INTERVAL"], limit=1)
+                if df.empty: continue
+                price = df["c"].iloc[-1]
+                pnl = (price - p["entry"]) / p["entry"]
+                if price > p["trail_h"]: p["trail_h"] = price
+
+                if pnl >= CONFIG["TP1"] and not p["tp1"]:
+                    p["tp1"] = True
+                    self._add_log(f"💰 TP1 {sym} +3% (30% closed)")
+                    tg_send(tg_fmt("💰", f"TP1 {sym}", f"+3% | 30% closed | Virtual"))
+                if pnl >= CONFIG["TP2"] and not p["tp2"]:
+                    p["tp2"] = True
+                    self._add_log(f"💰 TP2 {sym} +5% (30% closed)")
+                    tg_send(tg_fmt("💰", f"TP2 {sym}", f"+5% | 30% closed | Virtual"))
+
+                trail_sl = p["trail_h"] * (1 - CONFIG["TRAIL_PCT"])
+                exit_price = price
+                if price <= max(trail_sl, p["sl"]):
+                    close_share = CONFIG["TP3_SHARE"] if p["tp2"] else 1.0
+                    pnl_real = pnl * close_share
+                    self.state["daily_pnl"] += pnl_real
+                    self.state["balance"] *= (1 + pnl_real)
+                    self._add_log(f"📉 EXIT {sym} | PnL: {pnl:.2%} | Balance: ${self.state['balance']:.2f}")
+                    tg_send(tg_fmt("📉", f"EXIT {sym}", f"PnL: {pnl:.2%} | Virtual"))
+                    self.state["positions"].remove(p)
+                    save_state(self.state)
+                elif price <= p["sl"]:
+                    pnl_real = pnl
+                    self.state["daily_pnl"] += pnl_real
+                    self.state["balance"] *= (1 + pnl_real)
+                    self._add_log(f"⛔ SL {sym} -2% | Balance: ${self.state['balance']:.2f}")
+                    tg_send(tg_fmt("⛔", f"SL {sym}", f"Loss: -2% | Virtual"))
+                    self.state["positions"].remove(p)
+                    save_state(self.state)
+
+    def _loop(self):
+        tg_send(tg_fmt("🚀", "System Started", "Simulator Mode (No API Key)"))
+        while not self._stop.is_set():
+            try:
+                self._reset_daily()
+                ok, reason = self._can_trade()
+                if not ok:
+                    time.sleep(60); continue
+
+                # BTC Filter
+                btc = add_ema(fetch_klines("BTCUSDT", CONFIG["INTERVAL"]))
+                if btc.empty or btc["ema_20"].iloc[-1] <= btc["ema_50"].iloc[-1]:
+                    time.sleep(60); continue
+
+                # Scan Watchlist
+                for sym in CONFIG["WATCHLIST"]:
+                    if sym == "BTCUSDT" or self._stop.is_set(): continue
+                    df = add_ema(fetch_klines(sym, CONFIG["INTERVAL"]))
+                    if df.empty: continue
+                    score = calc_ai_score(df)
+                    vol_ma = df["v"].rolling(20).mean().iloc[-1]
+                    vol_r = df["v"].iloc[-1] / max(vol_ma, 1e-9)
+                    if not (df["ema_20"].iloc[-1] > df["ema_50"].iloc[-1] and vol_r > 1.2 and score > CONFIG["AI_THRESHOLD"]):
+                        continue
+
+                    price = df["c"].iloc[-1]
+                    sl = price * 0.98
+                    risk_usd = self.state["balance"] * CONFIG["RISK_PCT"]
+                    qty = (risk_usd / (price - sl)) / price if price > sl else 0
+
+                    with self._lock:
+                        self.state["positions"].append({
+                            "symbol": sym, "entry": price, "qty": qty, "sl": sl,
+                            "tp1": False, "tp2": False, "trail_h": price
+                        })
+                        self.state["trades"] += 1
+                        save_state(self.state)
+                    self._add_log(f"📥 ENTRY {sym} @ {price:.2f} | Risk: 1% | SL: {sl:.2f}")
+                    tg_send(tg_fmt("📥", f"ENTRY {sym}", f"Price: {price:.2f} | Qty: {qty:.4f} | Virtual"))
+                    break  # Anti overtrading
+
+                self._check_positions()
+                time.sleep(300)
+            except Exception as e:
+                self._add_log(f"⚠️ {str(e)}")
+                time.sleep(60)
+        self._add_log("🛑 System Stopped")
+
+    def _add_log(self, msg):
+        ts = datetime.now().strftime("%H:%M:%S")
+        with self._lock:
+            self.state["logs"].append(f"[{ts}] {msg}")
+            if len(self.state["logs"]) > 150: self.state["logs"] = self.state["logs"][-50:]
+
+    def get_state(self):
+        with self._lock:
+            return json.loads(json.dumps(self.state))  # Deep copy
+
+engine = SimEngine()
+
+# ==========================================
+# GRADIO DASHBOARD
+# ==========================================
+def ui_update():
+    s = engine.get_state()
+    logs = "\n".join(s["logs"][-20:])
+    pos = [[p["symbol"], f"${p['entry']:.2f}", f"{p['qty']:.4f}", f"${p['sl']:.2f}", 
+            "WAIT" if not p["tp1"] else "TP1" if not p["tp2"] else "TP2"] for p in s["positions"]]
+    return (f"Balance: ${s['balance']:.2f}", 
+            f"Trades: {s['trades']}/{CONFIG['MAX_DAILY_TRADES']}",
+            f"Daily PnL: {s['daily_pnl']:.2%}", 
+            pos, logs)
+
+with gr.Blocks(title="Binance Spot Simulator") as demo:
+    gr.Markdown("# 📊 System Trading + Profit Management (SIMULATOR)")
+    gr.Markdown("*✅ Tanpa API Key | ✅ Data Publik Binance | ✅ Semua Rule Aktif | ✅ Telegram Ready*")
+    with gr.Row():
+        btn_start = gr.Button("▶ START SIMULATOR", variant="primary")
+        btn_stop = gr.Button("⏹ STOP")
+    with gr.Row():
+        bal = gr.Textbox(label="💰 Balance", value="Balance: $1000.00", interactive=False)
+        trades = gr.Textbox(label="📈 Trades Hari Ini", value="Trades: 0/2", interactive=False)
+        pnl = gr.Textbox(label="📊 Daily PnL", value="Daily PnL: 0.00%", interactive=False)
+    pos_table = gr.Dataframe(headers=["Pair", "Entry", "Qty", "SL", "Status"], value=[], interactive=False, label="📍 Open Positions")
+    log_box = gr.Textbox(label="📝 System Log", value="", lines=10, interactive=False)
+
+    btn_start.click(lambda: engine.start(), outputs=None)
+    btn_stop.click(lambda: engine.stop(), outputs=None)
+    demo.load(ui_update, inputs=None, outputs=[bal, trades, pnl, pos_table, log_box], every=5)
 
 if __name__ == "__main__":
-
-    train_all()
-
-    demo.queue()
-
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)