zhutoutoutousan
644 lines
28 KiB
Python
644 lines
28 KiB
Python
"""Simplified dashboard that definitely works"""
|
|
from flask import Flask, render_template, jsonify, request
|
|
from flask_socketio import SocketIO, emit
|
|
import sys
|
|
from pathlib import Path
|
|
from datetime import datetime, timedelta
|
|
import threading
|
|
import time
|
|
import numpy as np
|
|
import os
|
|
from dotenv import load_dotenv
|
|
|
|
# Load environment variables
|
|
load_dotenv()
|
|
|
|
# Setup paths
|
|
project_root = Path(__file__).parent.parent.parent
|
|
sys.path.insert(0, str(project_root))
|
|
|
|
# Import Polymarket API clients
|
|
try:
|
|
from polymarket.api import GammaClient, ClobClient, DataClient
|
|
gamma_client = GammaClient()
|
|
clob_client = ClobClient()
|
|
data_client = DataClient(api_key=os.getenv('POLYMARKET_API_KEY'))
|
|
USE_REAL_API = True
|
|
print("[OK] Connected to real Polymarket API")
|
|
except Exception as e:
|
|
print(f"[WARNING] Could not initialize API clients: {e}")
|
|
print("Falling back to mock data")
|
|
USE_REAL_API = False
|
|
gamma_client = None
|
|
clob_client = None
|
|
data_client = None
|
|
|
|
app = Flask(__name__,
|
|
template_folder='templates',
|
|
static_folder='static')
|
|
socketio = SocketIO(app, cors_allowed_origins="*")
|
|
|
|
# Mock state
|
|
is_trading = False
|
|
strategy_balance = 1000.0
|
|
strategy_equity = 1000.0
|
|
strategy_positions = 0
|
|
strategy_trades = 0
|
|
|
|
# Backtesting state
|
|
backtest_running = False
|
|
backtest_results = None
|
|
|
|
@app.route('/')
|
|
def index():
|
|
"""Main dashboard"""
|
|
return render_template('dashboard.html')
|
|
|
|
@app.route('/api/markets')
|
|
def get_markets():
|
|
"""Get markets from real Polymarket API"""
|
|
if not USE_REAL_API:
|
|
# Fallback to mock data
|
|
return jsonify({
|
|
'markets': [
|
|
{
|
|
'id': '1',
|
|
'question': 'Will Bitcoin reach $100k by 2025?',
|
|
'event': 'Crypto Markets',
|
|
'yes_price': 0.65,
|
|
'no_price': 0.35,
|
|
'bid': 0.64,
|
|
'ask': 0.66,
|
|
'spread': 0.02,
|
|
'token_id': 'token123'
|
|
}
|
|
]
|
|
})
|
|
|
|
try:
|
|
# Fetch events from Gamma API
|
|
events_data = gamma_client.get_events(active=True, closed=False, limit=50)
|
|
|
|
# Handle different response formats
|
|
if isinstance(events_data, dict):
|
|
events = events_data.get('data', events_data.get('events', []))
|
|
else:
|
|
events = events_data if isinstance(events_data, list) else []
|
|
|
|
print(f"[DEBUG] Fetched {len(events)} events from API")
|
|
|
|
markets = []
|
|
for event in events:
|
|
event_markets = event.get('markets', [])
|
|
if not event_markets:
|
|
# Some events might have markets directly in the event object
|
|
if 'question' in event or 'clobTokenIds' in event:
|
|
event_markets = [event]
|
|
else:
|
|
continue
|
|
|
|
for market in event_markets:
|
|
try:
|
|
# Get clobTokenIds from market (per official docs)
|
|
# https://docs.polymarket.com/quickstart/fetching-data
|
|
clob_token_ids = market.get('clobTokenIds', [])
|
|
if len(clob_token_ids) < 2:
|
|
continue
|
|
|
|
yes_token = clob_token_ids[0]
|
|
no_token = clob_token_ids[1]
|
|
|
|
# Parse outcomes and prices from market (per docs format)
|
|
import json
|
|
outcomes = json.loads(market.get('outcomes', '["Yes", "No"]'))
|
|
outcome_prices = json.loads(market.get('outcomePrices', '[0.5, 0.5]'))
|
|
|
|
# Use prices directly from market data first (faster)
|
|
yes_price = float(outcome_prices[0]) if len(outcome_prices) > 0 else 0.5
|
|
no_price = float(outcome_prices[1]) if len(outcome_prices) > 1 else 0.5
|
|
|
|
# Try to get better prices from orderbook (optional enhancement)
|
|
try:
|
|
yes_book = clob_client.get_orderbook(yes_token)
|
|
yes_bids = yes_book.get('bids', [])
|
|
yes_asks = yes_book.get('asks', [])
|
|
|
|
if yes_bids and yes_asks:
|
|
yes_bid = float(yes_bids[0].get('price', yes_price))
|
|
yes_ask = float(yes_asks[0].get('price', yes_price))
|
|
yes_price = (yes_bid + yes_ask) / 2
|
|
except Exception as e:
|
|
print(f"Warning: Could not get orderbook for YES token: {e}")
|
|
# Use price from market data as fallback
|
|
|
|
# Calculate spread from orderbook if available
|
|
spread = abs(yes_price - no_price)
|
|
try:
|
|
yes_book = clob_client.get_orderbook(yes_token)
|
|
yes_bids = yes_book.get('bids', [])
|
|
yes_asks = yes_book.get('asks', [])
|
|
if yes_bids and yes_asks:
|
|
best_bid = float(yes_bids[0].get('price', yes_price))
|
|
best_ask = float(yes_asks[0].get('price', yes_price))
|
|
spread = best_ask - best_bid
|
|
except:
|
|
pass
|
|
|
|
markets.append({
|
|
'id': market.get('id', ''),
|
|
'question': market.get('question', 'Unknown Market'),
|
|
'event': event.get('title', 'Unknown Event'),
|
|
'yes_price': yes_price,
|
|
'no_price': no_price,
|
|
'bid': yes_price - 0.01 if yes_price > 0.01 else 0.0,
|
|
'ask': yes_price + 0.01 if yes_price < 0.99 else 1.0,
|
|
'spread': abs(yes_price - no_price),
|
|
'token_id': yes_token,
|
|
'volume': market.get('volume', 0)
|
|
})
|
|
except Exception as e:
|
|
print(f"Error processing market: {e}")
|
|
continue
|
|
|
|
print(f"[DEBUG] Returning {len(markets)} markets to frontend")
|
|
return jsonify({'markets': markets})
|
|
except Exception as e:
|
|
import traceback
|
|
print(f"Error fetching markets: {e}")
|
|
print(traceback.format_exc())
|
|
return jsonify({'markets': [], 'error': str(e)})
|
|
|
|
@app.route('/api/strategy/status')
|
|
def get_strategy_status():
|
|
"""Get strategy status from real API"""
|
|
if not USE_REAL_API:
|
|
return jsonify({
|
|
'active': is_trading,
|
|
'balance': strategy_balance,
|
|
'equity': strategy_equity,
|
|
'positions': strategy_positions,
|
|
'trades': strategy_trades,
|
|
'win_rate': 0,
|
|
'profit': 0,
|
|
'drawdown': 0
|
|
})
|
|
|
|
try:
|
|
# Get portfolio data (requires user address)
|
|
# For now, return basic status
|
|
return jsonify({
|
|
'active': is_trading,
|
|
'balance': strategy_balance,
|
|
'equity': strategy_equity,
|
|
'positions': strategy_positions,
|
|
'trades': strategy_trades,
|
|
'win_rate': 0,
|
|
'profit': 0,
|
|
'drawdown': 0
|
|
})
|
|
except Exception as e:
|
|
print(f"Error getting strategy status: {e}")
|
|
return jsonify({
|
|
'active': is_trading,
|
|
'balance': 0.0,
|
|
'equity': 0.0,
|
|
'positions': 0,
|
|
'trades': 0,
|
|
'win_rate': 0,
|
|
'profit': 0,
|
|
'drawdown': 0
|
|
})
|
|
|
|
@app.route('/api/strategy/positions')
|
|
def get_positions():
|
|
"""Get positions from real API"""
|
|
if not USE_REAL_API:
|
|
return jsonify({'positions': []})
|
|
|
|
try:
|
|
# Get positions (requires user address - would need to be configured)
|
|
# For now, return empty
|
|
return jsonify({'positions': []})
|
|
except Exception as e:
|
|
print(f"Error fetching positions: {e}")
|
|
return jsonify({'positions': []})
|
|
|
|
@app.route('/api/strategy/start', methods=['POST'])
|
|
def start_strategy():
|
|
"""Start trading strategy"""
|
|
global is_trading
|
|
is_trading = True
|
|
return jsonify({'status': 'started'})
|
|
|
|
@app.route('/api/strategy/stop', methods=['POST'])
|
|
def stop_strategy():
|
|
"""Stop trading strategy"""
|
|
global is_trading
|
|
is_trading = False
|
|
return jsonify({'status': 'stopped'})
|
|
|
|
@app.route('/api/market/<market_id>')
|
|
def get_market_details(market_id):
|
|
"""Get market details from real API"""
|
|
if not USE_REAL_API:
|
|
return jsonify({
|
|
'orderbook': {'bids': [], 'asks': []},
|
|
'best_bid_ask': {'bid': 0.5, 'ask': 0.5, 'spread': 0.0},
|
|
'depth': {'bid_depth': 0, 'ask_depth': 0}
|
|
})
|
|
|
|
try:
|
|
# Get market by ID or slug
|
|
# Try to get orderbook for the token
|
|
book = clob_client.get_orderbook(market_id)
|
|
|
|
bids = book.get('bids', [])
|
|
asks = book.get('asks', [])
|
|
|
|
best_bid = float(bids[0].get('price', 0.5)) if bids else 0.5
|
|
best_ask = float(asks[0].get('price', 0.5)) if asks else 0.5
|
|
|
|
bid_depth = sum(float(bid.get('size', 0)) for bid in bids)
|
|
ask_depth = sum(float(ask.get('size', 0)) for ask in asks)
|
|
|
|
return jsonify({
|
|
'orderbook': {
|
|
'bids': bids[:10], # Top 10 bids
|
|
'asks': asks[:10] # Top 10 asks
|
|
},
|
|
'best_bid_ask': {
|
|
'bid': best_bid,
|
|
'ask': best_ask,
|
|
'spread': best_ask - best_bid,
|
|
'mid': (best_bid + best_ask) / 2
|
|
},
|
|
'depth': {
|
|
'bid_depth': bid_depth,
|
|
'ask_depth': ask_depth,
|
|
'total_depth': bid_depth + ask_depth
|
|
}
|
|
})
|
|
except Exception as e:
|
|
print(f"Error fetching market details: {e}")
|
|
return jsonify({
|
|
'orderbook': {'bids': [], 'asks': []},
|
|
'best_bid_ask': {'bid': 0.5, 'ask': 0.5, 'spread': 0.0},
|
|
'depth': {'bid_depth': 0, 'ask_depth': 0},
|
|
'error': str(e)
|
|
})
|
|
|
|
@app.route('/api/backtest/run', methods=['POST'])
|
|
def run_backtest():
|
|
"""Run backtest"""
|
|
global backtest_running, backtest_results
|
|
|
|
if backtest_running:
|
|
return jsonify({'error': 'Backtest already running'}), 400
|
|
|
|
try:
|
|
data = request.json
|
|
start_date = data.get('start_date')
|
|
end_date = data.get('end_date')
|
|
initial_balance = float(data.get('initial_balance', 1000.0))
|
|
threshold = float(data.get('threshold', 0.15))
|
|
min_confidence = float(data.get('min_confidence', 0.7))
|
|
|
|
# Parse dates
|
|
start = datetime.strptime(start_date, '%Y-%m-%d')
|
|
end = datetime.strptime(end_date, '%Y-%m-%d')
|
|
|
|
# Run backtest in background thread
|
|
def run_backtest_thread():
|
|
global backtest_running, backtest_results
|
|
backtest_running = True
|
|
|
|
def log_message(msg, msg_type='info'):
|
|
"""Emit log message via WebSocket"""
|
|
socketio.emit('backtest_log', {
|
|
'message': msg,
|
|
'type': msg_type,
|
|
'timestamp': datetime.now().strftime('%H:%M:%S')
|
|
})
|
|
time.sleep(0.01) # Small delay to prevent flooding
|
|
|
|
try:
|
|
log_message(f"Starting backtest from {start.date()} to {end.date()}", 'info')
|
|
log_message(f"Initial Balance: ${initial_balance:.2f}", 'info')
|
|
log_message(f"Strategy Parameters: threshold={threshold}, confidence={min_confidence}", 'info')
|
|
|
|
# Import backtesting engine
|
|
from polymarket.backtesting.engine import BacktestEngine
|
|
from polymarket.strategies.examples import SimpleProbabilityStrategy
|
|
import traceback
|
|
|
|
# Create strategy
|
|
strategy = SimpleProbabilityStrategy(
|
|
initial_balance=initial_balance,
|
|
threshold=threshold,
|
|
min_confidence=min_confidence
|
|
)
|
|
|
|
log_message("Strategy initialized: SimpleProbabilityStrategy", 'success')
|
|
|
|
# Create engine
|
|
engine = BacktestEngine(strategy, start, end, initial_balance)
|
|
|
|
# Custom run with logging
|
|
log_message("Fetching markets...", 'info')
|
|
markets = engine.fetch_historical_markets()
|
|
|
|
if not markets:
|
|
log_message("ERROR: No markets found", 'error')
|
|
raise ValueError("No markets found for backtesting")
|
|
|
|
log_message(f"Found {len(markets)} markets to backtest", 'success')
|
|
|
|
# Run backtest with progress updates
|
|
current_date = start
|
|
day_count = 0
|
|
total_days = (end - start).days + 1
|
|
|
|
while current_date <= end:
|
|
# Process markets
|
|
for market_snapshot in markets:
|
|
market = market_snapshot['market']
|
|
import json
|
|
outcomes = json.loads(market.get('outcomes', '["Yes", "No"]'))
|
|
prices = json.loads(market.get('outcomePrices', '[0.5, 0.5]'))
|
|
|
|
market_data = {
|
|
'event': market_snapshot['event'],
|
|
'market': market,
|
|
'timestamp': current_date,
|
|
'prices': {
|
|
outcome: float(price)
|
|
for outcome, price in zip(outcomes, prices)
|
|
}
|
|
}
|
|
|
|
# Log market data periodically (only once per day, not per market)
|
|
if day_count % 5 == 0 and len(markets) > 0 and market_snapshot == markets[0]:
|
|
yes_price = market_data['prices'].get('Yes', 0.5)
|
|
equity = strategy.calculate_equity()
|
|
log_message(
|
|
f"[MARKET] {current_date.date()} | Yes: {yes_price:.2%} | "
|
|
f"Balance: ${strategy.current_balance:.2f} | Equity: ${equity:.2f} | "
|
|
f"Positions: {len(strategy.positions)} | Trades: {strategy.total_trades}",
|
|
'market'
|
|
)
|
|
|
|
# Get strategy signal
|
|
signal = strategy.analyze_market(market_data)
|
|
|
|
if signal:
|
|
if signal.confidence >= strategy.min_confidence:
|
|
result = engine.execute_signal(signal, market_data, current_date)
|
|
if result:
|
|
# Calculate PnL for this trade
|
|
trade_pnl = 0.0
|
|
if signal.action == 'SELL':
|
|
# PnL already calculated in execute_signal
|
|
# Get from closed positions
|
|
if strategy.closed_positions:
|
|
last_closed = strategy.closed_positions[-1]
|
|
if hasattr(last_closed, 'realized_pnl'):
|
|
trade_pnl = last_closed.realized_pnl if np.isfinite(last_closed.realized_pnl) else 0.0
|
|
|
|
equity = strategy.calculate_equity()
|
|
unrealized_pnl = sum(
|
|
pos.unrealized_pnl if np.isfinite(pos.unrealized_pnl) else 0.0
|
|
for pos in strategy.positions.values()
|
|
)
|
|
|
|
log_message(
|
|
f"[TRADE] {signal.action} | Size: ${result['size']:.2f} | "
|
|
f"Price: {result['price']:.4f} | Balance: ${strategy.current_balance:.2f} | "
|
|
f"Positions: {len(strategy.positions)}",
|
|
'trade'
|
|
)
|
|
|
|
# Emit real-time trade update
|
|
socketio.emit('backtest_trade', {
|
|
'action': signal.action,
|
|
'price': float(result['price']),
|
|
'size': float(result['size']),
|
|
'timestamp': current_date.isoformat(),
|
|
'balance': float(strategy.current_balance) if np.isfinite(strategy.current_balance) else 0.0,
|
|
'equity': float(equity) if np.isfinite(equity) else 0.0,
|
|
'unrealized_pnl': float(unrealized_pnl) if np.isfinite(unrealized_pnl) else 0.0,
|
|
'trade_pnl': float(trade_pnl),
|
|
'positions': len(strategy.positions),
|
|
'total_trades': strategy.total_trades,
|
|
'winning_trades': strategy.winning_trades,
|
|
'losing_trades': strategy.losing_trades
|
|
})
|
|
# Don't log skipped signals to reduce noise
|
|
|
|
# Update positions
|
|
for token_id, position in strategy.positions.items():
|
|
price_change = np.random.normal(0, 0.02)
|
|
new_price = max(0.01, min(0.99, position.current_price + price_change))
|
|
strategy.update_position(token_id, new_price)
|
|
|
|
# Update equity curve
|
|
strategy.update_drawdown()
|
|
equity = strategy.calculate_equity()
|
|
unrealized_pnl = sum(
|
|
pos.unrealized_pnl if np.isfinite(pos.unrealized_pnl) else 0.0
|
|
for pos in strategy.positions.values()
|
|
)
|
|
|
|
equity_point = {
|
|
'date': current_date,
|
|
'equity': equity if np.isfinite(equity) else strategy.current_balance,
|
|
'balance': strategy.current_balance if np.isfinite(strategy.current_balance) else 0.0,
|
|
'unrealized_pnl': unrealized_pnl if np.isfinite(unrealized_pnl) else 0.0
|
|
}
|
|
engine.equity_curve.append(equity_point)
|
|
|
|
# Emit real-time equity update (every day)
|
|
socketio.emit('backtest_equity', {
|
|
'date': current_date.isoformat(),
|
|
'equity': float(equity_point['equity']),
|
|
'balance': float(equity_point['balance']),
|
|
'unrealized_pnl': float(equity_point['unrealized_pnl']),
|
|
'total_trades': strategy.total_trades,
|
|
'positions': len(strategy.positions)
|
|
})
|
|
|
|
# Calculate daily return
|
|
if len(engine.equity_curve) > 1:
|
|
prev_equity = engine.equity_curve[-2]['equity']
|
|
daily_return = (equity - prev_equity) / prev_equity if prev_equity > 0 else 0.0
|
|
engine.daily_returns.append(daily_return)
|
|
|
|
# Progress update (less frequent)
|
|
if day_count % 10 == 0 or day_count == total_days - 1:
|
|
progress = (day_count / total_days * 100) if total_days > 0 else 0
|
|
log_message(
|
|
f"[PROGRESS] Day {day_count}/{total_days} ({progress:.1f}%) | "
|
|
f"Equity: ${equity:.2f} | Trades: {strategy.total_trades} | "
|
|
f"Positions: {len(strategy.positions)} | Win Rate: "
|
|
f"{(strategy.winning_trades / strategy.total_trades * 100) if strategy.total_trades > 0 else 0:.1f}%",
|
|
'info'
|
|
)
|
|
|
|
current_date += timedelta(days=1)
|
|
day_count += 1
|
|
|
|
# Small delay for visibility
|
|
time.sleep(0.05)
|
|
|
|
# Close positions
|
|
log_message("Closing all positions...", 'info')
|
|
final_equity = strategy.calculate_equity()
|
|
for token_id, position in list(strategy.positions.items()):
|
|
if position.size > 0 and position.current_price > 0:
|
|
exit_value = position.size * position.current_price
|
|
entry_cost = position.size * position.entry_price
|
|
pnl = exit_value - entry_cost
|
|
strategy.current_balance += exit_value
|
|
strategy.total_trades += 1
|
|
|
|
if pnl > 0:
|
|
strategy.winning_trades += 1
|
|
strategy.total_profit += pnl
|
|
else:
|
|
strategy.losing_trades += 1
|
|
strategy.total_loss += abs(pnl)
|
|
|
|
log_message(
|
|
f"[CLOSE] PnL: ${pnl:.2f} | Entry: {position.entry_price:.4f} | Exit: {position.current_price:.4f}",
|
|
'trade' if pnl > 0 else 'warning'
|
|
)
|
|
|
|
del strategy.positions[token_id]
|
|
|
|
# Calculate final metrics
|
|
if engine.initial_balance > 0:
|
|
total_return = (final_equity - engine.initial_balance) / engine.initial_balance * 100
|
|
else:
|
|
total_return = 0.0
|
|
|
|
sharpe_ratio = engine._calculate_sharpe_ratio()
|
|
|
|
if strategy.total_trades > 0:
|
|
win_rate = (strategy.winning_trades / strategy.total_trades * 100)
|
|
else:
|
|
win_rate = 0.0
|
|
|
|
if abs(strategy.total_loss) > 1e-10:
|
|
profit_factor = abs(strategy.total_profit / strategy.total_loss)
|
|
else:
|
|
profit_factor = 0.0
|
|
|
|
results = {
|
|
'strategy': strategy.name,
|
|
'start_date': engine.start_date,
|
|
'end_date': engine.end_date,
|
|
'initial_balance': engine.initial_balance,
|
|
'final_balance': strategy.current_balance,
|
|
'final_equity': final_equity,
|
|
'total_return': total_return if np.isfinite(total_return) else 0.0,
|
|
'total_trades': strategy.total_trades,
|
|
'winning_trades': strategy.winning_trades,
|
|
'losing_trades': strategy.losing_trades,
|
|
'win_rate': win_rate if np.isfinite(win_rate) else 0.0,
|
|
'total_profit': strategy.total_profit,
|
|
'total_loss': strategy.total_loss,
|
|
'net_profit': strategy.total_profit + strategy.total_loss,
|
|
'profit_factor': profit_factor if np.isfinite(profit_factor) else 0.0,
|
|
'max_drawdown': strategy.max_drawdown * 100 if np.isfinite(strategy.max_drawdown) else 0.0,
|
|
'sharpe_ratio': sharpe_ratio if np.isfinite(sharpe_ratio) else 0.0,
|
|
'trades': engine.trades,
|
|
'equity_curve': engine.equity_curve
|
|
}
|
|
|
|
log_message("=" * 50, 'info')
|
|
log_message("BACKTEST COMPLETE", 'success')
|
|
log_message(f"Total Return: {total_return:.2f}%", 'success')
|
|
log_message(f"Total Trades: {strategy.total_trades}", 'info')
|
|
log_message(f"Win Rate: {win_rate:.2f}%", 'info')
|
|
log_message(f"Final Equity: ${final_equity:.2f}", 'success')
|
|
|
|
# Prepare results for frontend
|
|
equity_curve = results.get('equity_curve', [])
|
|
if not equity_curve:
|
|
equity_curve = [
|
|
{'date': start, 'equity': initial_balance},
|
|
{'date': end, 'equity': results.get('final_equity', initial_balance)}
|
|
]
|
|
|
|
def safe_float(value, default=0.0):
|
|
try:
|
|
val = float(value)
|
|
return val if (val == 0 or (val != float('inf') and val != float('-inf') and not (val != val))) else default
|
|
except (ValueError, TypeError):
|
|
return default
|
|
|
|
backtest_results = {
|
|
'total_return': safe_float(results.get('total_return', 0)),
|
|
'total_trades': int(results.get('total_trades', 0)),
|
|
'winning_trades': int(results.get('winning_trades', 0)),
|
|
'losing_trades': int(results.get('losing_trades', 0)),
|
|
'win_rate': safe_float(results.get('win_rate', 0)),
|
|
'sharpe_ratio': safe_float(results.get('sharpe_ratio', 0)),
|
|
'max_drawdown': safe_float(results.get('max_drawdown', 0)),
|
|
'final_equity': safe_float(results.get('final_equity', initial_balance), initial_balance),
|
|
'equity_curve': [
|
|
{
|
|
'date': str(point.get('date', '')),
|
|
'equity': safe_float(point.get('equity', initial_balance), initial_balance)
|
|
}
|
|
for point in equity_curve
|
|
],
|
|
'net_profit': safe_float(results.get('net_profit', 0))
|
|
}
|
|
|
|
# Emit results via WebSocket
|
|
socketio.emit('backtest_complete', backtest_results)
|
|
|
|
except Exception as e:
|
|
import traceback
|
|
error_msg = f"{str(e)}\n{traceback.format_exc()}"
|
|
print(f"Backtest error: {error_msg}")
|
|
socketio.emit('backtest_error', {'error': str(e)})
|
|
finally:
|
|
backtest_running = False
|
|
|
|
thread = threading.Thread(target=run_backtest_thread, daemon=True)
|
|
thread.start()
|
|
|
|
return jsonify({'status': 'started', 'message': 'Backtest running...'})
|
|
|
|
except Exception as e:
|
|
return jsonify({'error': str(e)}), 500
|
|
|
|
@app.route('/api/backtest/status')
|
|
def get_backtest_status():
|
|
"""Get backtest status"""
|
|
return jsonify({
|
|
'running': backtest_running,
|
|
'results': backtest_results
|
|
})
|
|
|
|
# WebSocket handlers
|
|
@socketio.on('connect')
|
|
def handle_connect():
|
|
"""Handle WebSocket connection"""
|
|
emit('status', {'message': 'Connected to Cyberpunk Dashboard'})
|
|
|
|
@socketio.on('disconnect')
|
|
def handle_disconnect():
|
|
"""Handle WebSocket disconnection"""
|
|
pass
|
|
|
|
if __name__ == '__main__':
|
|
print("=" * 60)
|
|
print("CYBERPUNK POLYMARKET DASHBOARD")
|
|
print("=" * 60)
|
|
print("Starting server on http://localhost:5000")
|
|
print("Press Ctrl+C to stop")
|
|
print("=" * 60)
|
|
socketio.run(app, host='0.0.0.0', port=5000, debug=True)
|