"""
Dashboard estatico del wrapper de arbitraje.
Cada 60s consulta SQLite y regenera dashboard.html con:
- Resumen general
- Distribucion por categoria
- Top 10 oportunidades activas
- Posiciones paper abiertas/cerradas
- PnL post-mortem
"""
import sqlite3
import time
import signal
import sys
from datetime import datetime, timedelta
from pathlib import Path
DB_PATH = "/root/arbitrage_data/data/opportunities.db"
HTML_PATH = "/root/arbitrage_data/dashboard/dashboard.html"
REFRESH_SECONDS = 60
START_TIME = datetime.utcnow()
_running = True
def q(conn, sql, params=()):
"""Helper para queries que devuelven filas como lista de tuples."""
cursor = conn.cursor()
cursor.execute(sql, params)
return cursor.fetchall()
def q_one(conn, sql, params=()):
"""Helper para una unica fila."""
rows = q(conn, sql, params)
return rows[0] if rows else None
def fmt_pct(v, decimals=2):
"""Format pct con signo y color HTML."""
if v is None:
return "—"
try:
v = float(v)
except (ValueError, TypeError):
return str(v)
color = "#16a34a" if v > 0.01 else ("#dc2626" if v < -0.01 else "#6b7280")
return f'{v:+.{decimals}f}%'
def fmt_usd(v, decimals=4):
"""Format USD con color."""
if v is None:
return "—"
try:
v = float(v)
except (ValueError, TypeError):
return str(v)
color = "#16a34a" if v > 0.001 else ("#dc2626" if v < -0.001 else "#6b7280")
return f'{v:+.{decimals}f}'
def fmt_dur(minutes):
"""Format duracion en formato humano."""
if minutes is None:
return "—"
minutes = float(minutes)
if minutes < 60:
return f"{minutes:.0f}m"
hours = minutes / 60
if hours < 24:
return f"{hours:.1f}h"
return f"{hours/24:.1f}d"
def fmt_uptime():
"""Format uptime desde el arranque del generador."""
delta = datetime.utcnow() - START_TIME
total_sec = delta.total_seconds()
if total_sec < 3600:
return f"{int(total_sec/60)}m"
if total_sec < 86400:
return f"{int(total_sec/3600)}h{int((total_sec%3600)/60)}m"
return f"{int(total_sec/86400)}d{int((total_sec%86400)/3600)}h"
HTML_TEMPLATE = """
Polymarket Arb Dashboard
Polymarket Arbitrage Dashboard
Generated {generated_at} UTC · Dashboard uptime {uptime} · Auto-refresh 60s
Summary
{summary_metrics}
Distribution by Category (Active Opportunities)
{categories_table}
Top 10 Active Opportunities (by edge after fees)
{top_opps_table}
Paper Trader — Open Positions
{open_positions_table}
Paper Trader — Last 20 Closed Positions
{closed_positions_table}
PnL Post-mortem (Vanished opportunities)
{pnl_outcome_table}
"""
def render_metric(label, value):
return f''
def render_category_tag(cat):
if not cat:
return '—'
cls = f"tag-{cat.lower()}"
return f'{cat}'
def build_html(conn):
"""Construye el HTML completo del dashboard."""
# --- Summary metrics ---
n_scans = q_one(conn, "SELECT COUNT(*) FROM scans")[0]
n_active = q_one(conn, "SELECT COUNT(*) FROM opportunities WHERE status='active'")[0]
n_vanished = q_one(conn, "SELECT COUNT(*) FROM opportunities WHERE status='vanished'")[0]
n_paper_open = q_one(conn, "SELECT COUNT(*) FROM paper_positions WHERE status='open'")[0]
n_paper_closed = q_one(conn, "SELECT COUNT(*) FROM paper_positions WHERE status='closed'")[0]
paper_pnl_row = q_one(conn, "SELECT SUM(pnl_usd) FROM paper_positions WHERE status='closed'")
paper_pnl = paper_pnl_row[0] if paper_pnl_row and paper_pnl_row[0] else 0
last_scan = q_one(conn, "SELECT scan_time FROM scans ORDER BY id DESC LIMIT 1")
last_scan_str = last_scan[0][:19] if last_scan else "—"
metrics = (
render_metric("Total scans", n_scans) +
render_metric("Active opps", n_active) +
render_metric("Vanished opps", n_vanished) +
render_metric("Paper open", n_paper_open) +
render_metric("Paper closed", n_paper_closed) +
render_metric("Paper PnL (USD)", fmt_usd(paper_pnl, 2)) +
render_metric("Last scan", last_scan_str)
)
# --- Categories table ---
cat_rows = q(conn, """
SELECT COALESCE(category, '—') as cat, COUNT(*) as n,
ROUND(AVG(last_edge_after_fees_pct), 2) as avg_edge,
ROUND(MAX(last_edge_after_fees_pct), 2) as max_edge,
ROUND(AVG(last_min_liquidity), 0) as avg_liq
FROM opportunities WHERE status='active'
GROUP BY cat ORDER BY n DESC
""")
cat_html = '| Category | Count | Avg edge | Max edge | Avg liq USD |
|---|
'
for cat, n, avg_e, max_e, avg_l in cat_rows:
cat_html += f'| {render_category_tag(cat)} | {n} | {avg_e}% | {max_e}% | ${avg_l:.0f} |
'
cat_html += '
'
# --- Top 10 active opps ---
top_rows = q(conn, """
SELECT description, category, last_edge_after_fees_pct, last_min_liquidity,
scans_count, high_fee_zone
FROM opportunities WHERE status='active'
ORDER BY last_edge_after_fees_pct DESC LIMIT 10
""")
top_html = '| Description | Cat | Edge | Liq | Scans | HFZ |
|---|
'
for desc, cat, edge, liq, scans, hfz in top_rows:
hfz_txt = "⚠️" if hfz else ""
desc_short = (desc or "")[:65]
top_html += f'| {desc_short} | {render_category_tag(cat)} | {edge:.2f}% | ${liq:.0f} | {scans} | {hfz_txt} |
'
top_html += '
' if top_rows else 'No active opportunities.
'
# --- Open paper positions ---
open_rows = q(conn, """
SELECT position_id, description, category, entry_time, entry_edge_pct,
entry_total_cost, entry_size_usd
FROM paper_positions WHERE status='open' ORDER BY entry_time DESC LIMIT 20
""")
open_html = '| ID | Description | Cat | Entry time | Entry edge | Size USD |
|---|
'
for pid, desc, cat, entry_t, edge, cost, size in open_rows:
open_html += f'| {pid} | {(desc or "")[:55]} | {render_category_tag(cat)} | {entry_t[:19]} | {edge:.2f}% | ${size:.0f} |
'
open_html += '
' if open_rows else 'No open positions.
'
# --- Closed paper positions ---
closed_rows = q(conn, """
SELECT position_id, description, category, entry_time, exit_time,
exit_reason, pnl_usd, pnl_pct, entry_size_usd
FROM paper_positions WHERE status='closed' ORDER BY exit_time DESC LIMIT 20
""")
closed_html = '| ID | Description | Cat | Reason | PnL USD | PnL % |
|---|
'
for pid, desc, cat, ent, ext, reason, pnl_u, pnl_p, size in closed_rows:
closed_html += f'| {pid} | {(desc or "")[:55]} | {render_category_tag(cat)} | {reason} | {fmt_usd(pnl_u)} | {fmt_pct(pnl_p)} |
'
closed_html += '
' if closed_rows else 'No closed positions yet.
'
# --- Pnl outcomes ---
pnl_rows = q(conn, """
SELECT outcome, COUNT(*) as n,
ROUND(AVG(pnl_pct_on_cost), 3) as avg_pnl,
ROUND(AVG(duration_minutes), 1) as avg_dur,
ROUND(AVG(initial_edge_pct), 2) as avg_init_edge
FROM pnl_simulations GROUP BY outcome ORDER BY n DESC
""")
pnl_html = '| Outcome | Count | Avg PnL% | Avg duration | Avg initial edge |
|---|
'
for outcome, n, avg_pnl, avg_dur, avg_init in pnl_rows:
pnl_html += f'| {outcome} | {n} | {fmt_pct(avg_pnl, 3)} | {fmt_dur(avg_dur)} | {avg_init}% |
'
pnl_html += '
' if pnl_rows else 'No vanished opps processed yet.
'
return HTML_TEMPLATE.format(
generated_at=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
uptime=fmt_uptime(),
summary_metrics=metrics,
categories_table=cat_html,
top_opps_table=top_html,
open_positions_table=open_html,
closed_positions_table=closed_html,
pnl_outcome_table=pnl_html,
)
def shutdown(signum, frame):
global _running
print(f"[shutdown] Senal {signum}", flush=True)
_running = False
def main():
"""Loop infinito: regenera HTML cada REFRESH_SECONDS."""
signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)
Path(HTML_PATH).parent.mkdir(parents=True, exist_ok=True)
print(f"Dashboard generator iniciado. Salida: {HTML_PATH}", flush=True)
cycle = 0
while _running:
cycle += 1
try:
conn = sqlite3.connect(DB_PATH)
html = build_html(conn)
conn.close()
tmp_path = HTML_PATH + ".tmp"
with open(tmp_path, "w") as f:
f.write(html)
# Rename atomico para que el servidor nunca lea un HTML a medias
Path(tmp_path).replace(HTML_PATH)
print(f"[cycle {cycle}] {datetime.utcnow().isoformat()} dashboard regenerated",
flush=True)
except Exception as e:
print(f"[cycle {cycle}] ERROR: {e}", flush=True)
import traceback
traceback.print_exc()
# Sleep responsivo a senales
slept = 0
while slept < REFRESH_SECONDS and _running:
time.sleep(min(5, REFRESH_SECONDS - slept))
slept += 5
print("Dashboard generator detenido", flush=True)
if __name__ == "__main__":
main()