Update app.py

app.py

@@ -1,73 +1,48 @@
-import sys
 import os
+import time
 import logging
 import traceback
-import time
-import random
-from datetime import datetime, timedelta
+from datetime import datetime
 
-logging.basicConfig(
-    stream=sys.stdout,
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s"
-)
+import gradio as gr
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import joblib
 
-logger = logging.getLogger("crypto_ml")
-logger.info("🚀 Starting HF Space container...")
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import MinMaxScaler
 
 # ============================================================
-# IMPORTS
+# LOGGING
 # ============================================================
 
-try:
-    import gradio as gr
-    import yfinance as yf
-    import pandas as pd
-    import numpy as np
-
-    from sklearn.ensemble import RandomForestClassifier
-    from sklearn.preprocessing import MinMaxScaler
-
-    import joblib
-
-    logger.info("✅ All dependencies imported successfully")
-
-except Exception as e:
-    logger.error(f"❌ Import failed: {e}")
-    sys.exit(1)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("crypto_ml")
 
 # ============================================================
 # CONFIG
 # ============================================================
 
 SYMBOL = "ETH-USD"
-FEE = 0.0015
 WINDOW = 20
+FEE = 0.0015
 
-MODEL_PATH = "/tmp/rf_model.pkl"
+MODEL_PATH = "/tmp/model.pkl"
 SCALER_PATH = "/tmp/scaler.pkl"
 
 # ============================================================
-# CLEAN COLUMNS
+# CLEAN DATA
 # ============================================================
 
-def _clean_columns(df):
-
-    if df is None or df.empty:
-        return df
+def clean_columns(df):
 
     if isinstance(df.columns, pd.MultiIndex):
-        try:
-            df.columns = df.columns.get_level_values(0)
-        except:
-            df.columns = [
-                c[0] if isinstance(c, tuple) else c
-                for c in df.columns
-            ]
+        df.columns = df.columns.get_level_values(0)
 
     df.columns = [str(c).strip() for c in df.columns]
 
-    rename_map = {
+    rename = {
         "open": "Open",
         "high": "High",
         "low": "Low",
@@ -77,36 +52,23 @@ def _clean_columns(df):
     }
 
     df.columns = [
-        rename_map.get(c.lower(), c)
+        rename.get(c.lower(), c)
         for c in df.columns
     ]
 
-    df = df.loc[:, ~df.columns.duplicated()]
-
-    for col in ["Open", "High", "Low", "Close", "Volume"]:
-        if col in df.columns:
-            df[col] = pd.to_numeric(df[col], errors="coerce")
-
-    df = df.dropna()
-
-    logger.info(f"✅ Cleaned columns: {df.columns.tolist()}")
-
     return df
 
 # ============================================================
 # SYNTHETIC DATA
 # ============================================================
 
-def generate_synthetic_data(n_bars=500):
-
-    logger.warning("⚠️ Using synthetic data")
+def synthetic_data(n=500):
 
     np.random.seed(42)
 
-    end = datetime.utcnow()
     dates = pd.date_range(
-        end=end,
-        periods=n_bars,
+        end=datetime.utcnow(),
+        periods=n,
         freq="4h"
     )
 
@@ -118,22 +80,17 @@ def generate_synthetic_data(n_bars=500):
     closes = []
     volumes = []
 
-    for _ in range(n_bars):
+    for _ in range(n):
 
-        ret = np.random.normal(0.0005, 0.015)
+        ret = np.random.normal(0, 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))
-        )
+        high_p = max(open_p, close_p) * 1.01
+        low_p = min(open_p, close_p) * 0.99
 
-        vol = np.random.lognormal(15, 1)
+        vol = np.random.randint(1000, 5000)
 
         opens.append(open_p)
         highs.append(high_p)
@@ -157,56 +114,29 @@ def generate_synthetic_data(n_bars=500):
 # DOWNLOAD DATA
 # ============================================================
 
-def safe_download(
-    symbol=SYMBOL,
-    period="90d",
-    interval="1h"
-):
-
-    methods = [
-        ("Ticker.history", lambda:
-            yf.Ticker(symbol).history(
-                period=period,
-                interval=interval,
-                auto_adjust=True
-            )
-        ),
-
-        ("yf.download", lambda:
-            yf.download(
-                tickers=symbol,
-                period=period,
-                interval=interval,
-                progress=False,
-                auto_adjust=True,
-                threads=False,
-                group_by="column"
-            )
-        )
-    ]
-
-    for name, method in methods:
-
-        try:
+def safe_download():
 
-            logger.info(f"📥 Trying {name}")
-
-            df = method()
+    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:
 
-                if len(df) > 30:
-                    logger.info(f"✅ {name} success")
-                    return df, True
+            df = clean_columns(df)
 
-        except Exception as e:
-            logger.warning(f"⚠️ {name} failed: {e}")
+            return df, True
 
-        time.sleep(1)
+    except Exception as e:
+        logger.warning(e)
 
-    return generate_synthetic_data(), False
+    return synthetic_data(), False
 
 # ============================================================
 # FEATURE ENGINEERING
@@ -216,33 +146,20 @@ def fetch_and_prepare():
 
     df, is_real = safe_download()
 
-    if df.empty:
-        raise ValueError("Data kosong")
-
     if not isinstance(df.index, pd.DatetimeIndex):
         df.index = pd.to_datetime(df.index)
 
-    try:
-
-        df = df.resample("4h").agg({
-            "Open": "first",
-            "High": "max",
-            "Low": "min",
-            "Close": "last",
-            "Volume": "sum"
-        }).dropna()
-
-    except Exception as e:
-        logger.warning(f"Resample failed: {e}")
-
-    if len(df) < 50:
-        raise ValueError("Data terlalu sedikit")
+    df = df.resample("4h").agg({
+        "Open": "first",
+        "High": "max",
+        "Low": "min",
+        "Close": "last",
+        "Volume": "sum"
+    }).dropna()
 
     df.columns = [c.lower() for c in df.columns]
 
-    # ========================================================
     # RSI
-    # ========================================================
 
     delta = df["close"].diff()
 
@@ -255,63 +172,33 @@ def fetch_and_prepare():
         100 - (100 / (1 + rs))
     ).fillna(50)
 
-    # ========================================================
-    # 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
-
-    bb_width = (
-        df["bb_upper"] - df["bb_lower"]
-    ).replace(0, np.nan)
-
-    df["bb_pct"] = (
-        (df["close"] - df["bb_lower"]) / bb_width
-    ).fillna(0.5)
-
-    # ========================================================
     # 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()
-    df["macd_hist"] = (
-        df["macd"] - df["macd_signal"]
-    )
 
-    # ========================================================
-    # EMA
-    # ========================================================
+    # Bollinger
 
-    df["ema_9"] = df["close"].ewm(span=9).mean()
-    df["ema_21"] = df["close"].ewm(span=21).mean()
+    sma20 = df["close"].rolling(20).mean()
+    std20 = df["close"].rolling(20).std()
 
-    # ========================================================
-    # RETURNS
-    # ========================================================
+    df["bb_upper"] = sma20 + (2 * std20)
+    df["bb_lower"] = sma20 - (2 * std20)
 
-    df["vol_change"] = (
-        df["volume"].pct_change()
-    )
+    # EMA
 
-    df["return_1"] = (
-        df["close"].pct_change(1)
-    )
+    df["ema9"] = df["close"].ewm(span=9).mean()
+    df["ema21"] = df["close"].ewm(span=21).mean()
 
-    df["return_4"] = (
-        df["close"].pct_change(4)
-    )
+    # Return
+
+    df["return1"] = df["close"].pct_change()
+    df["return4"] = df["close"].pct_change(4)
 
-    # ========================================================
-    # LABEL
-    # ========================================================
+    # Label
 
     df["next_close"] = df["close"].shift(-1)
 
@@ -320,10 +207,6 @@ def fetch_and_prepare():
         df["close"] * (1 + FEE)
     ).astype(int)
 
-    # ========================================================
-    # CLEANUP
-    # ========================================================
-
     df = df.replace([np.inf, -np.inf], np.nan)
     df = df.dropna()
 
@@ -334,17 +217,14 @@ def fetch_and_prepare():
         "close",
         "volume",
         "rsi",
-        "bb_upper",
-        "bb_lower",
-        "bb_pct",
         "macd",
         "macd_signal",
-        "macd_hist",
-        "ema_9",
-        "ema_21",
-        "vol_change",
-        "return_1",
-        "return_4"
+        "bb_upper",
+        "bb_lower",
+        "ema9",
+        "ema21",
+        "return1",
+        "return4"
     ]
 
     X_list = []
@@ -352,25 +232,23 @@ def fetch_and_prepare():
 
     for i in range(WINDOW, len(df)):
 
-        window_data = df.iloc[
+        window = df.iloc[
             i-WINDOW:i
         ][feat_cols].values
 
-        if np.isnan(window_data).any():
+        if np.isnan(window).any():
             continue
 
-        X_list.append(window_data.flatten())
+        X_list.append(window.flatten())
         y_list.append(df.iloc[i]["label"])
 
-    X = np.array(X_list, dtype=np.float32)
+    X = np.array(X_list)
     y = np.array(y_list)
 
-    X = np.nan_to_num(X)
-
     return X, y, df, feat_cols, is_real
 
 # ============================================================
-# TRAIN
+# TRAIN MODEL
 # ============================================================
 
 def run_train():
@@ -395,79 +273,52 @@ def run_train():
             n_estimators=100,
             max_depth=8,
             random_state=42,
-            class_weight="balanced",
-            n_jobs=1
+            class_weight="balanced"
         )
 
         model.fit(X_train, y_train)
 
         acc = model.score(X_test, y_test)
 
-        # ====================================================
-        # FIX FEATURE IMPORTANCE
-        # ====================================================
-
-        importances = model.feature_importances_
-
-        imp_matrix = importances.reshape(
-            WINDOW,
-            len(feat_cols)
-        )
-
-        mean_importance = imp_matrix.mean(axis=0)
-
-        top_idx = np.argsort(mean_importance)[-5:][::-1]
-
-        top_features = [
-            (
-                feat_cols[i],
-                float(mean_importance[i])
-            )
-            for i in top_idx
-        ]
-
         joblib.dump(model, MODEL_PATH)
         joblib.dump(scaler, SCALER_PATH)
 
-        txt = f"""
+        return f"""
 ✅ MODEL TRAINED
 
-Accuracy: {acc:.4f}
+Accuracy:
+{acc:.4f}
 
-Top Features:
+Samples:
+{len(X)}
 
+Source:
+{"LIVE DATA" if is_real else "SIMULATED"}
 """
 
-        for name, score in top_features:
-            txt += f"\n{name}: {score:.4f}"
-
-        return txt
-
     except Exception as e:
 
         logger.error(traceback.format_exc())
 
-        return f"❌ ERROR:\n\n{e}"
+        return str(e)
 
 # ============================================================
-# ADD THIS AFTER run_predict()
+# TP SL FIBONACCI
 # ============================================================
 
-def calculate_trade_levels(df, signal):
-
-    latest = df.iloc[-1]
+def trade_levels(df, signal):
 
-    close_price = float(latest["close"])
+    close_price = float(df.iloc[-1]["close"])
 
     recent_high = float(df["high"].tail(20).max())
     recent_low = float(df["low"].tail(20).min())
 
     fib_range = recent_high - recent_low
 
-    fib_236 = recent_high - fib_range * 0.236
-    fib_382 = recent_high - fib_range * 0.382
-    fib_500 = recent_high - fib_range * 0.5
-    fib_618 = recent_high - fib_range * 0.618
+    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 = (
         (df["high"] - df["low"])
@@ -478,39 +329,34 @@ def calculate_trade_levels(df, signal):
 
     if signal == "BUY":
 
-        entry = close_price
-
-        tp1 = fib_236
-        tp2 = fib_382
+        tp1 = fib236
+        tp2 = fib382
         tp3 = recent_high
 
-        sl = close_price - (atr * 1.5)
+        sl = close_price - atr * 1.5
 
     else:
 
-        entry = close_price
-
-        tp1 = fib_618
-        tp2 = fib_500
+        tp1 = fib618
+        tp2 = fib500
         tp3 = recent_low
 
-        sl = close_price + (atr * 1.5)
+        sl = close_price + atr * 1.5
 
     return {
-        "entry": entry,
+        "entry": close_price,
         "tp1": tp1,
         "tp2": tp2,
         "tp3": tp3,
         "sl": sl,
-        "fib_236": fib_236,
-        "fib_382": fib_382,
-        "fib_500": fib_500,
-        "fib_618": fib_618
+        "fib236": fib236,
+        "fib382": fib382,
+        "fib500": fib500,
+        "fib618": fib618
     }
 
-
 # ============================================================
-# REPLACE run_predict()
+# PREDICT
 # ============================================================
 
 def run_predict():
@@ -531,8 +377,6 @@ def run_predict():
 
         latest = latest.reshape(1, -1)
 
-        latest = np.nan_to_num(latest)
-
         latest_scaled = scaler.transform(latest)
 
         pred = model.predict(latest_scaled)[0]
@@ -545,198 +389,78 @@ def run_predict():
 
         signal = "BUY" if pred == 1 else "SELL"
 
-        levels = calculate_trade_levels(df, signal)
-
-        price = float(df.iloc[-1]["close"])
-
-        rsi = float(df.iloc[-1]["rsi"])
-        macd = float(df.iloc[-1]["macd"])
+        levels = trade_levels(df, signal)
 
         return f"""
-╔══════════════════════════╗
-        AI SIGNAL
-╚══════════════════════════╝
-
-🔮 Signal   : {signal}
-📊 Confidence : {confidence:.2f}%
-
-💰 Current Price : ${price:,.2f}
-
-━━━━━━━━━━━━━━━━━━
-📌 ENTRY / TP / SL
-━━━━━━━━━━━━━━━━━━
-
-🎯 Entry : ${levels['entry']:,.2f}
-
-✅ TP1 : ${levels['tp1']:,.2f}
-✅ TP2 : ${levels['tp2']:,.2f}
-✅ TP3 : ${levels['tp3']:,.2f}
-
-🛑 Stop Loss : ${levels['sl']:,.2f}
-
-━━━━━━━━━━━━━━━━━━
-📐 Fibonacci Levels
-━━━━━━━━━━━━━━━━━━
-
-Fib 0.236 : ${levels['fib_236']:,.2f}
-Fib 0.382 : ${levels['fib_382']:,.2f}
-Fib 0.500 : ${levels['fib_500']:,.2f}
-Fib 0.618 : ${levels['fib_618']:,.2f}
-
-━━━━━━━━━━━━━━━━━━
-📈 Indicators
-━━━━━━━━━━━━━━━━━━
-
-RSI  : {rsi:.2f}
-MACD : {macd:.2f}
-
-📡 Source:
-{"LIVE DATA" if is_real else "SIMULATED"}
-"""
-
-    except Exception as e:
-
-        logger.error(traceback.format_exc())
-
-        return f"❌ ERROR:\n\n{e}"
-
-
-# ============================================================
-# ADD THIS BEFORE UI
-# ============================================================
-
-TRADINGVIEW_HTML = """
-<div style="width:100%;height:600px;border-radius:12px;overflow:hidden;
-            border:1px solid #2B3139;background:#181A20;">
-
-<iframe
-src="https://s.tradingview.com/widgetembed/?symbol=BINANCE:ETHUSDT&interval=240&theme=dark&style=1&toolbarbg=%23181A20&hide_top_toolbar=0&saveimage=1&studies=%5B%22RSI%40tv-basicstudies%22,%22MACD%40tv-basicstudies%22,%22BB%40tv-basicstudies%22%5D"
-style="width:100%;height:100%;border:none;"
-allowfullscreen>
-</iframe>
-
-</div>
-"""
-
-
-# ============================================================
-# REPLACE UI SECTION
-# ============================================================
-
-with gr.Blocks(
-    title="CryptoML PRO"
-) as demo:
-
-    gr.Markdown("""
-# 🚀 CryptoML PRO Terminal
-
-### ETH/USDT AI Trading System
-""")
-
-    gr.HTML(TRADINGVIEW_HTML)
-
-    market_box = gr.Textbox(
-        label="Market Info",
-        value=get_market_info(),
-        lines=5
-    )
-
-    with gr.Row():
+═══════════════════════
+🤖 AI TRADING SIGNAL
+═══════════════════════
 
-        train_btn = gr.Button(
-            "⚡ Train AI Model",
-            variant="primary"
-        )
+🔮 Signal:
+{signal}
 
-        predict_btn = gr.Button(
-            "🔮 Generate Signal",
-            variant="secondary"
-        )
-
-        refresh_btn = gr.Button(
-            "🔄 Refresh Market",
-            variant="secondary"
-        )
+📊 Confidence:
+{confidence:.2f}%
 
-    train_output = gr.Textbox(
-        label="AI Training Result",
-        lines=15
-    )
-
-    predict_output = gr.Textbox(
-        label="AI Trading Signal",
-        lines=30
-    )
+💰 Entry:
+${levels['entry']:,.2f}
 
-    train_btn.click(
-        fn=run_train,
-        outputs=train_output
-    )
-
-    predict_btn.click(
-        fn=run_predict,
-        outputs=predict_output
-    )
-
-    refresh_btn.click(
-        fn=get_market_info,
-        outputs=market_box
-    )
+━━━━━━━━━━━━━━━━━━━
 
-# ============================================================
-# PREDICT
-# ============================================================
+🎯 TAKE PROFIT
 
-def run_predict():
+TP1:
+${levels['tp1']:,.2f}
 
-    try:
+TP2:
+${levels['tp2']:,.2f}
 
-        if not os.path.exists(MODEL_PATH):
-            return "⚠️ Train model terlebih dahulu"
+TP3:
+${levels['tp3']:,.2f}
 
-        X, y, df, feat_cols, is_real = fetch_and_prepare()
+━━━━━━━━━━━━━━━━━━━
 
-        scaler = joblib.load(SCALER_PATH)
-        model = joblib.load(MODEL_PATH)
+🛑 STOP LOSS
 
-        latest = df.iloc[
-            -WINDOW:
-        ][feat_cols].values.flatten()
+${levels['sl']:,.2f}
 
-        latest = latest.reshape(1, -1)
+━━━━━━━━━━━━━━━━━━━
 
-        latest = np.nan_to_num(latest)
+📐 FIBONACCI
 
-        latest_scaled = scaler.transform(latest)
+0.236:
+${levels['fib236']:,.2f}
 
-        pred = model.predict(latest_scaled)[0]
+0.382:
+${levels['fib382']:,.2f}
 
-        proba = model.predict_proba(
-            latest_scaled
-        )[0]
+0.500:
+${levels['fib500']:,.2f}
 
-        confidence = float(np.max(proba)) * 100
+0.618:
+${levels['fib618']:,.2f}
 
-        signal = "BUY" if pred == 1 else "SELL"
+━━━━━━━━━━━━━━━━━━━
 
-        price = float(df.iloc[-1]["close"])
+📈 INDICATORS
 
-        return f"""
-🔮 SIGNAL: {signal}
+RSI:
+{df.iloc[-1]['rsi']:.2f}
 
-Confidence: {confidence:.2f}%
+MACD:
+{df.iloc[-1]['macd']:.2f}
 
-Price: ${price:,.2f}
+━━━━━━━━━━━━━━━━━━━
 
-RSI: {df.iloc[-1]['rsi']:.2f}
-MACD: {df.iloc[-1]['macd']:.2f}
+📡 SOURCE:
+{"LIVE DATA" if is_real else "SIMULATED"}
 """
 
     except Exception as e:
 
         logger.error(traceback.format_exc())
 
-        return f"❌ ERROR:\n\n{e}"
+        return str(e)
 
 # ============================================================
 # MARKET INFO
@@ -746,38 +470,57 @@ def get_market_info():
 
     try:
 
-        df, is_real = safe_download(
-            SYMBOL,
-            period="5d",
-            interval="1h"
-        )
+        df, is_real = safe_download()
 
         price = float(df["Close"].iloc[-1])
 
-        return f"""
-ETH PRICE
+        high = float(df["High"].tail(24).max())
+        low = float(df["Low"].tail(24).min())
 
+        return f"""
+💰 ETH PRICE:
 ${price:,.2f}
 
-Source:
+📈 24H HIGH:
+${high:,.2f}
+
+📉 24H LOW:
+${low:,.2f}
+
+📡 SOURCE:
 {"LIVE DATA" if is_real else "SIMULATED"}
 """
 
     except Exception as e:
         return str(e)
 
+# ============================================================
+# TRADINGVIEW
+# ============================================================
+
+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") as demo:
+with gr.Blocks(title="CryptoML PRO") as demo:
+
+    gr.Markdown("# 🚀 CryptoML PRO")
 
-    gr.Markdown("# 🚀 CryptoML ETH/USDT")
+    gr.HTML(TRADINGVIEW_HTML)
 
     market_box = gr.Textbox(
-        label="Market",
+        label="Market Info",
         value=get_market_info(),
-        lines=5
+        lines=8
     )
 
     with gr.Row():
@@ -787,7 +530,7 @@ with gr.Blocks(title="CryptoML") as demo:
         )
 
         predict_btn = gr.Button(
-            "🔮 Predict"
+            "🔮 Predict Signal"
         )
 
         refresh_btn = gr.Button(
@@ -796,12 +539,12 @@ with gr.Blocks(title="CryptoML") as demo:
 
     train_output = gr.Textbox(
         label="Training Result",
-        lines=15
+        lines=10
     )
 
     predict_output = gr.Textbox(
         label="Prediction",
-        lines=10
+        lines=30
     )
 
     train_btn.click(
@@ -819,11 +562,10 @@ with gr.Blocks(title="CryptoML") as demo:
         outputs=market_box
     )
 
-demo.queue(default_concurrency_limit=1)
-
-logger.info("✅ App ready")
+demo.queue()
 
 demo.launch(
     server_name="0.0.0.0",
     server_port=7860
 )
+