Delete app.py

app.py

@@ -1,778 +0,0 @@
-# ==============================================================================
-# 🚀 app.py (V28.4 - GEM-Architect: The Original Heavyweight + Live Logs)
-# Architecture: Staged Filtering -> Top 10 Deep Dive -> Oracle -> Sniper -> Hydra.
-# Features:
-# 1. Full original logic preserved (Timers, Charts, Logic).
-# 2. Added LogRedirector to visualize "Raw vs Calib" prints in UI.
-# 3. Dynamic Scoring for Whales, News, and Advanced MC included.
-# ==============================================================================
-
-import os
-import sys
-import traceback
-import asyncio
-import gc
-import time
-import json
-import logging 
-from collections import deque # For Log Buffer
-from datetime import datetime, timedelta
-from contextlib import asynccontextmanager, redirect_stdout, redirect_stderr
-from io import StringIO
-from typing import List, Dict, Any, Optional
-
-# المكتبات الخارجية للواجهة والخادم
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-import gradio as gr
-import pandas as pd
-import plotly.graph_objects as go 
-
-# ==============================================================================
-# 📝 إعداد نظام السجلات الحي (Live Terminal Logging)
-# ==============================================================================
-# نحتفظ بآخر 500 سطر لضمان عدم فقدان السياق
-LOG_BUFFER = deque(maxlen=500)
-
-class LogRedirector:
-    """
-    يقوم بالتقاط كل ما يطبعه النظام (print) ويرسله إلى الواجهة
-    مع الاحتفاظ بنسخة في الـ Console الخلفية.
-    """
-    def __init__(self, original_stream):
-        self.original_stream = original_stream
-
-    def write(self, message):
-        self.original_stream.write(message)
-        self.original_stream.flush()
-        if message and message.strip():
-            LOG_BUFFER.append(message.rstrip())
-
-    def flush(self):
-        self.original_stream.flush()
-
-# تفعيل التحويل
-sys.stdout = LogRedirector(sys.stdout)
-sys.stderr = LogRedirector(sys.stderr)
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(levelname)s] %(message)s", 
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-logger = logging.getLogger("TitanCore")
-
-# ==============================================================================
-# 📥 استيراد الوحدات الأساسية (Module Imports)
-# ==============================================================================
-try:
-    # Core Data & ML Modules
-    from r2 import R2Service
-    from ml_engine.data_manager import DataManager
-    from ml_engine.processor import MLProcessor
-    
-    # Whale & Network Analysis Modules
-    from whale_monitor.core import EnhancedWhaleMonitor
-    from whale_monitor.rpc_manager import AdaptiveRpcManager
-    
-    # Sentiment & News Modules
-    from sentiment_news import NewsFetcher
-    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-    
-    # Learning & Trading Execution Modules
-    from learning_hub.hub_manager import LearningHubManager
-    from trade_manager import TradeManager
-except ImportError as e:
-    logger.critical(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
-    traceback.print_exc()
-    # sys.exit(1) # Disabled to allow UI to show error
-
-# ==============================================================================
-# 🌐 المتغيرات العامة (Global Context & Singletons)
-# ==============================================================================
-r2: R2Service = None
-data_manager: DataManager = None
-ml_processor: MLProcessor = None
-hub_manager: LearningHubManager = None 
-trade_manager: TradeManager = None
-whale_monitor: EnhancedWhaleMonitor = None
-news_fetcher: NewsFetcher = None
-senti_analyzer: SentimentIntensityAnalyzer = None
-sys_state: 'SystemState' = None
-
-# ==============================================================================
-# 🔄 حالة النظام (State Management System)
-# ==============================================================================
-class SystemState:
-    """
-    Holds the runtime state of the application.
-    Manages cycle flags, errors, status messages, and timestamps.
-    """
-    def __init__(self):
-        self.ready = False
-        self.cycle_running = False
-        self.training_running = False 
-        self.auto_pilot = True 
-        
-        # Timestamps & Logs
-        self.last_cycle_time: datetime = None
-        self.last_cycle_error = None
-        self.app_start_time = datetime.now()
-        
-        # Status Messages for UI
-        self.last_cycle_logs = "System Initializing..."
-        self.training_status_msg = "Waiting for data..." 
-        
-        # Configuration
-        self.scan_interval = 60 # Seconds (5 mins default)
-
-    def set_ready(self): 
-        """Mark system as fully initialized and ready."""
-        self.ready = True
-        self.last_cycle_logs = "✅ System Ready. Auto-Pilot ON."
-        logger.info("✅ System State set to READY.")
-    
-    def set_cycle_start(self): 
-        """Mark the start of a scanning cycle."""
-        self.cycle_running = True
-        self.last_cycle_logs = "🌀 [Cycle START] Scanning Markets..."
-        logger.info("🌀 Cycle STARTED.")
-
-    def set_cycle_end(self, error=None, logs=None):
-        """Mark the end of a scanning cycle and store results."""
-        self.cycle_running = False
-        self.last_cycle_time = datetime.now()
-        self.last_cycle_error = str(error) if error else None
-        
-        if logs: 
-            self.last_cycle_logs = logs
-        elif error:
-            self.last_cycle_logs = f"❌ [Cycle ERROR] {error}"
-            logger.error(f"Cycle Error: {error}")
-        else:
-            self.last_cycle_logs = f"✅ [Cycle END] Finished successfully."
-            logger.info("✅ Cycle ENDED.")
-
-# Initialize State Instance
-sys_state = SystemState()
-
-# ==============================================================================
-# 🛠️ دوال مساعدة (Utilities & Formatting)
-# ==============================================================================
-def format_crypto_price(price):
-    """Format price string nicely for UI (removing trailing zeros)."""
-    if price is None: return "0.0"
-    try:
-        p = float(price)
-        if p == 0: return "0.0"
-        return "{:.8f}".format(p).rstrip('0').rstrip('.')
-    except: return str(price)
-
-def calculate_duration_str(timestamp_str):
-    """Calculate duration string (Days/Hours/Mins) from a timestamp."""
-    if not timestamp_str: return "--:--:--"
-    try:
-        if isinstance(timestamp_str, str):
-            start_time = datetime.fromisoformat(timestamp_str)
-        else: start_time = timestamp_str
-        
-        diff = datetime.now() - start_time
-        total_seconds = int(diff.total_seconds())
-        
-        days = total_seconds // 86400
-        hours = (total_seconds % 86400) // 3600
-        minutes = (total_seconds % 3600) // 60
-        seconds = total_seconds % 60
-        
-        if days > 0: return f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
-        return f"{hours:02}:{minutes:02}:{seconds:02}"
-    except: return "--:--:--"
-
-# ==============================================================================
-# 🤖 Auto-Pilot Daemon (Background Service)
-# ==============================================================================
-async def auto_pilot_loop():
-    """
-    Background task that manages scanning AND monitoring.
-    """
-    logger.info("🤖 [Auto-Pilot] Daemon started (Monitoring Mode Enabled).")
-    while True:
-        try:
-            await asyncio.sleep(5) # Check every 5 seconds (Faster response)
-            
-            if not sys_state.ready: continue
-            
-            # 1. حالة التدريب
-            if hub_manager and int(time.time()) % 60 == 0:
-                is_ready, msg = await hub_manager.check_training_readiness()
-                sys_state.training_status_msg = msg
-
-            # 2. فحص حالة الصفقات المفتوحة (Watchdog Check)
-            if trade_manager and len(trade_manager.open_positions) > 0:
-                # التأكد من عمل الحلقات الخلفية
-                wd_status = await trade_manager.ensure_active_guardians()
-                # LogRedirector handles logging
-                continue 
-
-            # 3. Trigger Cycle (فقط إذا لم تكن هناك صفقات)
-            if sys_state.auto_pilot and not sys_state.cycle_running and not sys_state.training_running:
-                # Check time since last cycle
-                if sys_state.last_cycle_time:
-                    elapsed = (datetime.now() - sys_state.last_cycle_time).total_seconds()
-                    if elapsed < sys_state.scan_interval: 
-                        continue
-
-                logger.info("🤖 [Auto-Pilot] Triggering scan...")
-                asyncio.create_task(run_unified_cycle())
-                await asyncio.sleep(5) 
-                    
-        except Exception as e:
-            logger.error(f"⚠️ [Auto-Pilot Error] {e}")
-            await asyncio.sleep(30)
-
-# ==============================================================================
-# 🚀 Lifespan (Server Startup/Shutdown & Injection)
-# ==============================================================================
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """
-    Application Lifecycle Manager.
-    Initializes all services, injects dependencies, and handles shutdown.
-    """
-    global r2, data_manager, ml_processor, hub_manager, trade_manager, whale_monitor, news_fetcher, senti_analyzer, sys_state
-    
-    logger.info("\n🚀 [System] Startup Sequence (Titan V28.4)...")
-    try:
-        # 1. Initialize R2 & Data Manager
-        logger.info("   [1/7] Initializing R2 & Data Services...")
-        r2 = R2Service()
-        data_manager = DataManager(contracts_db={}, whale_monitor=None, r2_service=r2)
-        await data_manager.initialize() 
-        await data_manager.load_contracts_from_r2()
-        
-        # 2. Initialize Auxiliary Services (Whale & News)
-        logger.info("   [2/7] Starting Auxiliary Services (Whale & News)...")
-        whale_monitor = EnhancedWhaleMonitor(contracts_db=data_manager.get_contracts_db(), r2_service=r2)
-        rpc_mgr = AdaptiveRpcManager(data_manager.http_client)
-        whale_monitor.set_rpc_manager(rpc_mgr)
-        logger.info("   ✅ [System] RPC Manager injected into Whale Monitor.")
-        
-        news_fetcher = NewsFetcher()
-        senti_analyzer = SentimentIntensityAnalyzer()
-        data_manager.whale_monitor = whale_monitor
-        
-        # 3. Initialize Learning Hub
-        logger.info("   [3/7] Initializing Learning Hub...")
-        hub_manager = LearningHubManager(r2_service=r2, data_manager=data_manager)
-        await hub_manager.initialize()
-
-        # 4. Initialize ML Processor (Oracle V4 Integration)
-        logger.info("   [4/7] Initializing Central ML Processor...")
-        ml_processor = MLProcessor(data_manager=data_manager)
-        await ml_processor.initialize()
-        ml_processor.hub_manager = hub_manager 
-        
-        # 5. Initialize Trade Manager (The Hand)
-        logger.info("   [5/7] Initializing Trade Manager...")
-        trade_manager = TradeManager(r2_service=r2, data_manager=data_manager, processor=ml_processor)
-        trade_manager.learning_hub = hub_manager 
-        await trade_manager.initialize_sentry_exchanges()
-        
-        # 6. Start Background Loops
-        logger.info("   [6/7] Restarting Active Sentries...")
-        await trade_manager.start_sentry_loops()
-        
-        # 7. Finalize Startup
-        logger.info("   [7/7] Launching Auto-Pilot...")
-        sys_state.set_ready()
-        asyncio.create_task(auto_pilot_loop())
-        logger.info("✅ [System READY] All modules operational.")
-        yield
-        
-    except Exception as e:
-        logger.critical(f"❌ [FATAL STARTUP ERROR] {e}")
-        traceback.print_exc()
-    finally:
-        logger.info("\n🛑 [System] Shutdown Sequence...")
-        sys_state.ready = False
-        
-        if hub_manager: await hub_manager.shutdown()
-        if trade_manager: await trade_manager.stop_sentry_loops()
-        if data_manager: await data_manager.close()
-        
-        if whale_monitor and whale_monitor.rpc_manager:
-            await whale_monitor.rpc_manager.close()
-            
-        logger.info("✅ [System] Shutdown Complete.")
-
-# ==============================================================================
-# 🧠 Helper Tasks (Layer 2 Calculation)
-# ==============================================================================
-async def _analyze_symbol_task(symbol: str) -> Dict[str, Any]:
-    """
-    Task to analyze a single symbol.
-    """
-    try:
-        required_tfs = ["5m", "15m", "1h", "4h"]
-        
-        # Fetch 300 candles to satisfy Pattern Engine's 200 candle requirement
-        data_tasks = [data_manager.get_latest_ohlcv(symbol, tf, limit=300) for tf in required_tfs]
-        all_data = await asyncio.gather(*data_tasks)
-        
-        ohlcv_data = {}
-        for tf, data in zip(required_tfs, all_data):
-            if data and len(data) > 0: ohlcv_data[tf] = data
-            
-        if '1h' not in ohlcv_data or '5m' not in ohlcv_data: 
-            return None
-        
-        current_price = await data_manager.get_latest_price_async(symbol)
-        raw_data = {'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': current_price, 'timestamp': time.time()}
-        
-        # Run Processor
-        res = await ml_processor.process_compound_signal(raw_data)
-        if not res: return None
-
-        titan_s = res.get('titan_score', res.get('components', {}).get('titan_score', 0.5))
-        pattern_s = res.get('patterns_score', res.get('components', {}).get('patterns_score', 0.5))
-        mc_light_s = res.get('mc_score', res.get('components', {}).get('mc_score', 0.5))
-
-        l2_base_score = (titan_s * 0.50) + (pattern_s * 0.40) + (mc_light_s * 0.10)
-        
-        res['enhanced_final_score'] = l2_base_score
-        res['l2_base_score'] = l2_base_score
-        res['titan_score'] = titan_s 
-        res['patterns_score'] = pattern_s
-        res['mc_score'] = mc_light_s
-        
-        return res
-        
-    except Exception: return None
-
-# ==============================================================================
-# 🚀 Unified Smart Cycle (Oracle V4 Logic + Deep Dive Top 10)
-# ==============================================================================
-async def run_unified_cycle():
-    """
-    Full Analysis Cycle with Strict Scoring & Re-Ranking.
-    """
-    if sys_state.cycle_running or sys_state.training_running: return
-    if not sys_state.ready: return
-
-    sys_state.set_cycle_start()
-    
-    try:
-        # --- LAYER 0: Guardian ---
-        await trade_manager.sync_internal_state_with_r2()
-        if len(trade_manager.open_positions) > 0:
-            symbol = list(trade_manager.open_positions.keys())[0]
-            trade = trade_manager.open_positions[symbol]
-            logger.info(f"🔒 [Guardian] Monitoring active trade: {symbol}")
-            curr_p = await data_manager.get_latest_price_async(symbol)
-            entry_p = float(trade.get('entry_price', 0))
-            if entry_p > 0:
-                pnl = ((curr_p - entry_p) / entry_p) * 100
-                logger.info(f"   📊 PnL: {pnl:+.2f}% | TP: {trade.get('tp_price')} | SL: {trade.get('sl_price')}")
-            sys_state.set_cycle_end()
-            return 
-
-        # --- LAYER 1: Screening ---
-        logger.info("   [1/5] 🔍 L1 Screening (Liquidity & Volume)...")
-        candidates = await data_manager.layer1_rapid_screening()
-        if not candidates:
-            logger.info("⚠️ No L1 candidates found.")
-            sys_state.set_cycle_end()
-            return
-            
-        # --- LAYER 2: Deep Analysis ---
-        logger.info(f"   [2/5] 🧠 L2 Deep Analysis ({len(candidates)} items)...")
-        tasks = [_analyze_symbol_task(c['symbol']) for c in candidates]
-        results = await asyncio.gather(*tasks)
-        valid_l2 = [res for res in results if res is not None]
-        
-        semi_finalists = sorted(valid_l2, key=lambda x: x.get('l2_base_score', 0.0), reverse=True)[:10]
-        
-        if not semi_finalists:
-            logger.info("⚠️ No valid L2 candidates.")
-            sys_state.set_cycle_end()
-            return
-
-        # --- LAYER 3: Deep Dive ---
-        logger.info(f"   [3/5] 📡 L3 Deep Dive (Dynamic Scoring) for TOP {len(semi_finalists)}...")
-        
-        final_candidates = []
-
-        for sig in semi_finalists:
-            symbol = sig['symbol']
-            l2_score = sig.get('l2_base_score', 0.0)
-            
-            # A. Whale Analysis
-            whale_points = 0.0
-            try:
-                if whale_monitor:
-                    w_data = await whale_monitor.get_symbol_whale_activity(symbol, known_price=sig.get('current_price', 0))
-                    if w_data and w_data.get('data_available', False) and 'trading_signal' in w_data:
-                        signal = w_data['trading_signal']
-                        action = signal.get('action', 'HOLD')
-                        confidence = float(signal.get('confidence', 0.5))
-                        dynamic_impact = 0.10 * confidence 
-                        
-                        if action == 'BUY': whale_points = dynamic_impact 
-                        elif action == 'SELL': whale_points = -dynamic_impact
-            except Exception: pass
-
-            # B. News Analysis
-            news_points = 0.0
-            try:
-                if news_fetcher and senti_analyzer:
-                    n_data = await news_fetcher.get_news(symbol)
-                    summary_text = n_data.get('summary', '')
-                    if "No specific news" not in summary_text:
-                        sent = senti_analyzer.polarity_scores(summary_text)
-                        news_points = sent['compound'] * 0.05
-            except Exception: pass
-
-            # C. Advanced Monte Carlo
-            mc_a_points = 0.0
-            try:
-                mc_a_points = await ml_processor.run_advanced_monte_carlo(symbol, '1h')
-            except Exception: pass
-
-            final_score = l2_score + whale_points + news_points + mc_a_points
-            
-            sig['whale_score'] = whale_points
-            sig['news_score'] = news_points
-            sig['mc_advanced_score'] = mc_a_points
-            sig['final_total_score'] = final_score 
-            
-            final_candidates.append(sig)
-
-        # --- RE-RANKING ---
-        final_candidates.sort(key=lambda x: x['final_total_score'], reverse=True)
-
-        approved_signals = []
-        
-        header = (f"{'SYM':<9} | {'TITAN':<5} | {'MC(L)':<5} | {'PATT':<5} | "
-                  f"{'WHALE':<6} | {'NEWS':<6} | {'MC(A)':<6} | {'FINAL':<6} | {'ORACLE':<6} | {'STATUS'}")
-        logger.info("-" * 110)
-        logger.info(header)
-        logger.info("-" * 110)
-        
-        for sig in final_candidates:
-            symbol = sig['symbol']
-            decision = await ml_processor.consult_oracle(sig)
-            
-            action = decision.get('action', 'WAIT')
-            oracle_conf = decision.get('confidence', 0.0)
-            target_class = decision.get('target_class', '')
-            
-            status_str = "WAIT 🔴"
-            if action == 'WATCH' or action == 'BUY':
-                status_str = f"✅ {target_class}"
-                sig.update(decision)
-                approved_signals.append(sig)
-
-            logger.info(
-                f"{symbol:<9} | "
-                f"{sig.get('titan_score',0):.2f}  | "
-                f"{sig.get('mc_score',0):.2f}  | "
-                f"{sig.get('patterns_score',0):.2f}  | "
-                f"{sig.get('whale_score',0):+.2f}  | " 
-                f"{sig.get('news_score',0):+.2f}  | " 
-                f"{sig.get('mc_advanced_score',0):+.2f}  | " 
-                f"{sig.get('final_total_score',0):.2f}   | " 
-                f"{oracle_conf:.2f}   | "
-                f"{status_str}"
-            )
-
-        # --- LAYER 4: Sniper Execution ---
-        if approved_signals:
-            logger.info("-" * 110)
-            logger.info(f"   [4/5] 🎯 L4 Sniper Execution ({len(approved_signals)} candidates)...")
-            await trade_manager.select_and_execute_best_signal(approved_signals)
-        else:
-            logger.info("   -> 🛑 No candidates approved by Oracle for Sniper check.")
-
-        gc.collect()
-        sys_state.set_cycle_end()
-
-    except Exception as e:
-        logger.error(f"❌ [Cycle ERROR] {e}")
-        traceback.print_exc()
-        sys_state.set_cycle_end(error=e)
-
-# ==============================================================================
-# 🎓 Training & Helper Logic
-# ==============================================================================
-async def trigger_training_cycle():
-    if sys_state.cycle_running or len(trade_manager.open_positions) > 0: return "⚠️ Busy."
-    sys_state.training_running = True
-    asyncio.create_task(_run_training_bg())
-    return "⏳ Training Started..."
-
-async def _run_training_bg():
-    try:
-        if hub_manager:
-            msg = await hub_manager.execute_training_session()
-            sys_state.last_cycle_logs = f"🎓 Report: {msg}"
-    except Exception: pass
-    finally: sys_state.training_running = False
-
-async def manual_close_current_trade():
-    if not trade_manager.open_positions: return "⚠️ No trade."
-    symbol = list(trade_manager.open_positions.keys())[0]
-    await trade_manager.force_exit_by_manager(symbol, reason="MANUAL_UI")
-    return f"✅ Closed {symbol}."
-
-async def reset_stats_handler():
-    if trade_manager.open_positions: return "⚠️ Close trade first."
-    await r2.reset_all_stats_async()
-    return "✅ Reset Done."
-
-async def toggle_auto_pilot(enable):
-    sys_state.auto_pilot = enable
-    return f"Auto-Pilot: {enable}"
-
-async def run_cycle_from_gradio():
-    if sys_state.cycle_running: return "Busy."
-    asyncio.create_task(run_unified_cycle())
-    return "🚀 Launched."
-
-# ==============================================================================
-# 📊 UI Updates & Charting
-# ==============================================================================
-async def check_live_pnl_and_status(selected_view="Guardian Hydra (Total)"):
-    """
-    Periodic update function for Gradio UI.
-    Updated to pull from LOG_BUFFER directly.
-    """
-    empty_chart = go.Figure()
-    empty_chart.update_layout(template="plotly_dark", paper_bgcolor="#0b0f19", plot_bgcolor="#0b0f19", xaxis={'visible':False}, yaxis={'visible':False})
-    wl_df_empty = pd.DataFrame(columns=["Coin", "Score"])
-    
-    # 1. Get Logs
-    live_logs_text = "\n".join(list(LOG_BUFFER))
-
-    if not sys_state.ready:
-        return live_logs_text, "Initializing...", empty_chart, "0.0", "0.0", "0.0", "0.0", "0.0%", wl_df_empty, "Loading...", "Loading...", "Checking..."
-
-    try:
-        # 1. Portfolio Data
-        portfolio = await r2.get_portfolio_state_async()
-        curr_cap = portfolio.get('current_capital_usd', 100.0)
-        first_ts = portfolio.get('first_trade_timestamp')
-        uptime_str = calculate_duration_str(first_ts)
-        
-        total_t = portfolio.get('total_trades', 0)
-        wins = portfolio.get('winning_trades', 0)
-        losses = portfolio.get('losing_trades', 0)
-        if losses == 0 and total_t > 0: losses = total_t - wins
-        tot_prof = portfolio.get('total_profit_usd', 0.0)
-        tot_loss = portfolio.get('total_loss_usd', 0.0)
-        net_prof = tot_prof - tot_loss
-        win_rate = (wins / total_t * 100) if total_t > 0 else 0.0
-
-        # 2. Active Trade Data
-        symbol = None; entry_p = 0.0; tp_p = 0.0; sl_p = 0.0; curr_p = 0.0; pnl_pct = 0.0; pnl_val = 0.0
-        trade_dur_str = "--:--:--"
-        oracle_str = "N/A"
-        
-        if trade_manager.open_positions:
-            symbol = list(trade_manager.open_positions.keys())[0]
-            trade = trade_manager.open_positions[symbol]
-            entry_p = float(trade.get('entry_price', 0.0))
-            tp_p = float(trade.get('tp_price', 0.0))
-            sl_p = float(trade.get('sl_price', 0.0))
-            
-            trade_dur_str = calculate_duration_str(trade.get('entry_time'))
-            
-            strength = trade.get('initial_oracle_strength', 0.0)
-            target_cls = trade.get('initial_oracle_class', 'N/A')
-            oracle_str = f"Str: {strength:.2f} | {target_cls}"
-            
-            curr_p = await data_manager.get_latest_price_async(symbol)
-            if curr_p > 0 and entry_p > 0:
-                pnl_pct = ((curr_p - entry_p) / entry_p) * 100
-                pnl_val = curr_cap * (pnl_pct / 100)
-
-        final_bal = curr_cap + pnl_val
-        color = "#00ff00" if pnl_val >= 0 else "#ff0000"
-
-        # 3. HTML Construction
-        active_trade_row = ""
-        if symbol:
-             active_trade_row = f"""
-             <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>⏱️ Trade:</span> <span style='color: #ffff00;'>{trade_dur_str}</span>
-             </div>"""
-
-        wallet_md = f"""
-        <div style='background-color: #1a1a1a; padding: 15px; border-radius: 8px; border: 1px solid #333; text-align:center;'>
-            <h3 style='margin:0; color:#888; font-size:14px;'>💰 Live Wallet</h3>
-            <div style='font-size: 26px; font-weight: bold; color: white; margin: 5px 0;'>${final_bal:,.2f}</div>
-            <div style='font-size: 14px; color: {color};'>({pnl_val:+,.2f} USD)</div>
-            <hr style='border-color:#444; margin: 10px 0;'>
-            
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc;'>
-                <span>⏳ System:</span> <span style='color: white;'>{uptime_str}</span>
-            </div>
-            {active_trade_row}
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>🔮 Oracle:</span> <span style='color: #00e5ff;'>{oracle_str}</span>
-            </div>
-        </div>
-        """
-
-        key_map = {
-            "Guardian Hydra (Total)": "hybrid", 
-            "Head: Crash (Panic)": "crash", 
-            "Head: Giveback (Profit)": "giveback",
-            "Head: Stagnation (Time)": "stagnation"
-        }
-        target_key = key_map.get(selected_view, "hybrid")
-        stats_data = trade_manager.ai_stats.get(target_key, {"total":0, "good":0, "saved":0.0, "missed":0.0})
-        
-        tot_ds = stats_data['total']
-        ds_acc = (stats_data['good'] / tot_ds * 100) if tot_ds > 0 else 0.0
-        
-        history_md = f"""
-        <div style='background-color: #1a1a1a; padding: 10px; border-radius: 8px; border: 1px solid #333; font-size: 12px;'>
-            <h3 style='margin:0 0 5px 0; color:#888; font-size:14px;'>📊 Performance</h3>
-            <table style='width:100%; color:white;'>
-                <tr><td>Trades:</td><td style='text-align:right;'>{total_t}</td></tr>
-                <tr><td>Win Rate:</td><td style='text-align:right; color:{"#00ff00" if win_rate>=50 else "#ff0000"};'>{win_rate:.1f}%</td></tr>
-                <tr><td>Wins:</td><td style='text-align:right; color:#00ff00;'>{wins} (+${tot_prof:,.2f})</td></tr>
-                <tr><td>Losses:</td><td style='text-align:right; color:#ff0000;'>{losses} (-${tot_loss:,.2f})</td></tr>
-                <tr><td style='border-top:1px solid #444;'>Net:</td><td style='border-top:1px solid #444; text-align:right; color:{"#00ff00" if net_prof>=0 else "#ff0000"};'>${net_prof:,.2f}</td></tr>
-            </table>
-            <hr style='border-color:#444; margin: 8px 0;'>
-            <h3 style='margin:0 0 5px 0; color: #00e5ff; font-size:14px;'>🐲 Hydra IQ ({target_key})</h3>
-            <table style='width:100%; color:white;'>
-                <tr><td>Interventions:</td><td style='text-align:right;'>{tot_ds}</td></tr>
-                <tr><td>Accuracy:</td><td style='text-align:right; color:#00e5ff;'>{ds_acc:.1f}%</td></tr>
-                <tr><td>Saved:</td><td style='text-align:right; color:#00ff00;'>${stats_data['saved']:.2f}</td></tr>
-                <tr><td>Missed:</td><td style='text-align:right; color:#ff0000;'>${stats_data['missed']:.2f}</td></tr>
-            </table>
-        </div>
-        """
-
-        wl_data = [[k, f"{v.get('final_total_score',0):.2f}"] for k, v in trade_manager.watchlist.items()]
-        wl_df = pd.DataFrame(wl_data, columns=["Coin", "Score"])
-
-        status_line = f"Cycle: {'RUNNING' if sys_state.cycle_running else 'IDLE'} | Auto-Pilot: {'ON' if sys_state.auto_pilot else 'OFF'}"
-        
-        # 5. Full Chart
-        fig = empty_chart
-        if symbol and curr_p > 0:
-            ohlcv = await data_manager.get_latest_ohlcv(symbol, '5m', 120)
-            if ohlcv:
-                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-                df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
-                
-                fig = go.Figure(data=[go.Candlestick(
-                    x=df['datetime'], open=df['open'], high=df['high'], low=df['low'], close=df['close'],
-                    increasing_line_color='#00ff00', decreasing_line_color='#ff0000', name=symbol
-                )])
-                
-                if entry_p > 0:
-                    fig.add_hline(y=entry_p, line_dash="dash", line_color="white", annotation_text="ENTRY", annotation_position="top left")
-                if tp_p > 0:
-                    fig.add_hline(y=tp_p, line_color="#00ff00", line_width=2, annotation_text="TARGET (TP)", annotation_position="top left")
-                if sl_p > 0:
-                    fig.add_hline(y=sl_p, line_color="#ff0000", line_width=2, annotation_text="STOP LOSS", annotation_position="bottom left")
-
-                fig.update_layout(
-                    template="plotly_dark", 
-                    paper_bgcolor="#0b0f19", 
-                    plot_bgcolor="#0b0f19",
-                    margin=dict(l=0, r=40, t=30, b=0), 
-                    height=400, 
-                    xaxis_rangeslider_visible=False,
-                    title=dict(text=f"{symbol} (Spot Long) | PnL: {pnl_pct:+.2f}%", font=dict(color="white"))
-                )
-
-        train_status = sys_state.training_status_msg
-        if sys_state.training_running: train_status = "🏋️‍♂️ Training..."
-
-        return (live_logs_text, status_line, fig, f"{curr_p:.6f}", f"{entry_p:.6f}", f"{tp_p:.6f}", f"{sl_p:.6f}",
-                f"{pnl_pct:+.2f}%", wl_df, wallet_md, history_md, train_status)
-
-    except Exception:
-        return live_logs_text, "Error", empty_chart, "0", "0", "0", "0", "0%", wl_df_empty, "Err", "Err", "Err"
-
-# ==============================================================================
-# 🎨 Gradio UI (Crash-Proof & Full Feature)
-# ==============================================================================
-def create_gradio_ui():
-    """
-    Creates the Gradio Interface.
-    """
-    custom_css = ".gradio-container {background:#0b0f19} .dataframe {background:#1a1a1a!important} .html-box {min-height:180px} .log-box textarea {font-family: 'Consolas', monospace; font-size: 12px; background-color: #111; color: #0f0;}"
-    
-    with gr.Blocks(title="Titan V28.4 (Live Terminal)") as demo:
-        gr.HTML(f"<style>{custom_css}</style>")
-        
-        gr.Markdown("# 🚀 Titan V28.4 (Guardian Hydra)")
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                live_chart = gr.Plot(label="Chart")
-                with gr.Row():
-                    t_price = gr.Textbox(label="Price", interactive=False)
-                    t_pnl = gr.Textbox(label="PnL %", interactive=False)
-                with gr.Row():
-                    t_entry = gr.Textbox(label="Entry", interactive=False)
-                    t_tp = gr.Textbox(label="TP", interactive=False)
-                    t_sl = gr.Textbox(label="SL", interactive=False)
-
-            with gr.Column(scale=1):
-                wallet_out = gr.HTML(label="Wallet", elem_classes="html-box")
-                stats_dd = gr.Dropdown([
-                    "Guardian Hydra (Total)", 
-                    "Head: Crash (Panic)", 
-                    "Head: Giveback (Profit)", 
-                    "Head: Stagnation (Time)"
-                ], value="Guardian Hydra (Total)", label="View AI Stats")
-                history_out = gr.HTML(label="Stats", elem_classes="html-box")
-                watchlist_out = gr.DataFrame(label="Watchlist")
-
-        gr.HTML("<hr style='border-color:#333'>")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                auto_pilot = gr.Checkbox(label="✈️ Auto-Pilot", value=True)
-                with gr.Row():
-                    btn_run = gr.Button("🚀 Scan", variant="primary")
-                    btn_close = gr.Button("🚨 Close", variant="stop")
-                with gr.Row():
-                    btn_train = gr.Button("🎓 Train", variant="secondary")
-                    btn_reset = gr.Button("🗑️ Reset")
-                status = gr.Markdown("Init...")
-                train_status = gr.Textbox(label="Learning", interactive=False, value="Checking...")
-                alert = gr.Textbox(label="Alerts", interactive=False)
-            
-            with gr.Column(scale=3):
-                # Live Terminal Box
-                logs = gr.Textbox(label="Live Terminal", lines=14, autoscroll=True, elem_classes="log-box", type="text")
-
-        # Event Listeners
-        btn_run.click(fn=run_cycle_from_gradio, outputs=alert)
-        btn_close.click(fn=manual_close_current_trade, outputs=alert)
-        btn_reset.click(fn=reset_stats_handler, outputs=alert)
-        btn_train.click(fn=trigger_training_cycle, outputs=alert)
-        auto_pilot.change(fn=toggle_auto_pilot, inputs=auto_pilot, outputs=alert)
-        
-        # Periodic Update (1s)
-        gr.Timer(1).tick(fn=check_live_pnl_and_status, inputs=stats_dd, 
-                         outputs=[logs, status, live_chart, t_price, t_entry, t_tp, t_sl, t_pnl, watchlist_out, wallet_out, history_out, train_status])
-    return demo
-
-# ==============================================================================
-# 🏁 Server Launch
-# ==============================================================================
-fast_api_server = FastAPI(lifespan=lifespan)
-gradio_dashboard = create_gradio_ui()
-app = gr.mount_gradio_app(app=fast_api_server, blocks=gradio_dashboard, path="/")
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)