149 lines
5.2 KiB
Python
149 lines
5.2 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Clean Trading Dashboard Runner with Enhanced Stability and Error Handling
|
|
"""
|
|
|
|
# Ensure we run with the project's virtual environment Python
|
|
try:
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
import platform
|
|
|
|
def _ensure_project_venv():
|
|
try:
|
|
project_root = Path(__file__).resolve().parent
|
|
if platform.system().lower().startswith('win'):
|
|
venv_python = project_root / 'venv' / 'Scripts' / 'python.exe'
|
|
else:
|
|
venv_python = project_root / 'venv' / 'bin' / 'python'
|
|
|
|
if venv_python.exists():
|
|
current = Path(sys.executable).resolve()
|
|
target = venv_python.resolve()
|
|
if current != target:
|
|
os.execv(str(target), [str(target), *sys.argv])
|
|
except Exception:
|
|
# If anything goes wrong, continue with current interpreter
|
|
pass
|
|
|
|
_ensure_project_venv()
|
|
except Exception:
|
|
pass
|
|
|
|
import sys
|
|
import logging
|
|
import traceback
|
|
import gc
|
|
import time
|
|
import psutil
|
|
import torch
|
|
from pathlib import Path
|
|
|
|
# Setup logging
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
|
|
logger = logging.getLogger(__name__)
|
|
|
|
def clear_gpu_memory():
|
|
"""Clear GPU memory cache"""
|
|
if torch.cuda.is_available():
|
|
torch.cuda.empty_cache()
|
|
torch.cuda.synchronize()
|
|
|
|
def check_system_resources():
|
|
"""Check if system has enough resources"""
|
|
available_ram = psutil.virtual_memory().available / 1024**3
|
|
if available_ram < 2.0: # Less than 2GB available
|
|
logger.warning(f"Low RAM: {available_ram:.1f} GB available")
|
|
gc.collect()
|
|
clear_gpu_memory()
|
|
return False
|
|
return True
|
|
|
|
def run_dashboard_with_recovery():
|
|
"""Run dashboard with automatic error recovery"""
|
|
max_retries = 3
|
|
retry_count = 0
|
|
|
|
while retry_count < max_retries:
|
|
try:
|
|
logger.info(f"Starting Clean Trading Dashboard (attempt {retry_count + 1}/{max_retries})")
|
|
|
|
# Check system resources
|
|
if not check_system_resources():
|
|
logger.warning("System resources low, waiting 30 seconds...")
|
|
time.sleep(30)
|
|
continue
|
|
|
|
# Import here to avoid memory issues on restart
|
|
from core.data_provider import DataProvider
|
|
from core.orchestrator import TradingOrchestrator
|
|
from core.trading_executor import TradingExecutor
|
|
from web.clean_dashboard import create_clean_dashboard
|
|
|
|
logger.info("Creating data provider...")
|
|
data_provider = DataProvider()
|
|
|
|
logger.info("Creating trading orchestrator...")
|
|
orchestrator = TradingOrchestrator(
|
|
data_provider=data_provider,
|
|
enhanced_rl_training=True
|
|
)
|
|
|
|
logger.info("Creating trading executor...")
|
|
trading_executor = TradingExecutor()
|
|
|
|
logger.info("Creating clean dashboard...")
|
|
dashboard = create_clean_dashboard(data_provider, orchestrator, trading_executor)
|
|
|
|
logger.info("Dashboard created successfully")
|
|
logger.info("=== Clean Trading Dashboard Status ===")
|
|
logger.info("- Data Provider: Active")
|
|
logger.info("- Trading Orchestrator: Active")
|
|
logger.info("- Trading Executor: Active")
|
|
logger.info("- Enhanced Training: Active")
|
|
logger.info("- Dashboard: Ready")
|
|
logger.info("=======================================")
|
|
|
|
# Start the dashboard server with error handling
|
|
try:
|
|
logger.info("Starting dashboard server on http://127.0.0.1:8050")
|
|
dashboard.run_server(host='127.0.0.1', port=8050, debug=False)
|
|
except KeyboardInterrupt:
|
|
logger.info("Dashboard stopped by user")
|
|
break
|
|
except Exception as e:
|
|
logger.error(f"Dashboard server error: {e}")
|
|
logger.error(traceback.format_exc())
|
|
raise
|
|
|
|
except Exception as e:
|
|
logger.error(f"Critical error in dashboard: {e}")
|
|
logger.error(traceback.format_exc())
|
|
|
|
retry_count += 1
|
|
if retry_count < max_retries:
|
|
logger.info(f"Attempting recovery... ({retry_count}/{max_retries})")
|
|
|
|
# Cleanup
|
|
gc.collect()
|
|
clear_gpu_memory()
|
|
|
|
# Wait before retry
|
|
wait_time = 30 * retry_count # Exponential backoff
|
|
logger.info(f"Waiting {wait_time} seconds before retry...")
|
|
time.sleep(wait_time)
|
|
else:
|
|
logger.error("Max retries reached. Exiting.")
|
|
sys.exit(1)
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
run_dashboard_with_recovery()
|
|
except KeyboardInterrupt:
|
|
logger.info("Application stopped by user")
|
|
sys.exit(0)
|
|
except Exception as e:
|
|
logger.error(f"Fatal error: {e}")
|
|
logger.error(traceback.format_exc())
|
|
sys.exit(1) |