Add bot orchestrator

polymarket_bot/bot.py

@@ -0,0 +1,285 @@
+"""
+Bot principal: orchestre les stratégies, l'exécution et le monitoring.
+"""
+import asyncio
+import logging
+import signal
+import sys
+import time
+from datetime import datetime
+from typing import Optional
+
+from .config import BotConfig
+from .data import GammaClient, CLOBDataClient, Market
+from .execution import ExecutionEngine
+from .strategies import ArbitrageStrategy, ValueBetStrategy, LeaderFollowerStrategy, Signal
+from .monitor import BotMonitor, MetricSnapshot
+
+logger = logging.getLogger("polybot")
+
+
+class PolymarketBot:
+    """
+    Bot de trading Polymarket ultra efficace.
+
+    Stratégies:
+    1. Arbitrage intra-marché (sans risque, YES+NO < $1)
+    2. Value Bet (signaux de marché + Kelly sizing)
+    3. Leader-Follower sémantique (marchés corrélés)
+
+    Fonctionnalités:
+    - Gestion des risques multi-niveaux
+    - Mode dry-run / live
+    - Monitoring temps réel avec alertes
+    - Filtrage intelligent des marchés
+    """
+
+    def __init__(self, config: Optional[BotConfig] = None):
+        self.config = config or BotConfig()
+        self._setup_logging()
+
+        # Composants
+        self.gamma = GammaClient()
+        self.clob = CLOBDataClient()
+        self.engine = ExecutionEngine(self.config)
+        self.monitor = BotMonitor()
+
+        # Stratégies
+        self.strategies = {}
+        if "arbitrage" in self.config.strategies:
+            self.strategies["arbitrage"] = ArbitrageStrategy(self.config, self.clob)
+        if "value_bet" in self.config.strategies:
+            self.strategies["value_bet"] = ValueBetStrategy(self.config, self.clob)
+        if "leader_follower" in self.config.strategies:
+            self.strategies["leader_follower"] = LeaderFollowerStrategy(self.config, self.clob)
+
+        # State
+        self._markets: list[Market] = []
+        self._running = False
+        self._last_market_refresh = 0
+        self._cycle_count = 0
+
+        logger.info(f"Bot initialized | Mode: {'DRY RUN' if self.config.dry_run else 'LIVE'}")
+        logger.info(f"Strategies: {list(self.strategies.keys())}")
+        logger.info(f"Max exposure: ${self.config.max_total_exposure_usd:,.2f}")
+
+    def _setup_logging(self):
+        """Configure le logging."""
+        log_level = getattr(logging, self.config.log_level, logging.INFO)
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s | %(name)-20s | %(levelname)-5s | %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+    # ── Market Management ────────────────────────────────────────
+    async def refresh_markets(self):
+        """Rafraîchit la liste des marchés depuis Gamma API."""
+        logger.info("🔄 Refreshing markets...")
+        all_markets = await self.gamma.get_all_active_markets()
+
+        # Filtrer selon la config
+        filtered = []
+        for m in all_markets:
+            if m.volume < self.config.min_market_volume:
+                continue
+            if any(tag in self.config.excluded_tags for tag in m.tags):
+                continue
+            if m.closed or not m.active:
+                continue
+            if not m.yes_token or not m.no_token:
+                continue
+            filtered.append(m)
+
+        self._markets = filtered
+        self._last_market_refresh = time.time()
+        logger.info(f"✅ {len(filtered)} markets loaded (from {len(all_markets)} total)")
+
+        if len(filtered) < 10:
+            self.monitor.alert(
+                "WARN",
+                "Low Market Count",
+                f"Only {len(filtered)} markets pass filters. Consider relaxing min_market_volume.",
+            )
+
+    def _should_refresh_markets(self) -> bool:
+        return (time.time() - self._last_market_refresh) > self.config.market_refresh_interval_seconds
+
+    # ── Core Trading Loop ────────────────────────────────────────
+    async def _trading_cycle(self):
+        """Un cycle complet de trading: scan → signal → risque → exécution."""
+        self._cycle_count += 1
+
+        if self._should_refresh_markets():
+            await self.refresh_markets()
+
+        if not self._markets:
+            logger.warning("No markets available, skipping cycle")
+            return
+
+        all_signals: list[Signal] = []
+
+        # Scanner toutes les stratégies en parallèle
+        scan_tasks = []
+        for name, strategy in self.strategies.items():
+            scan_tasks.append(strategy.scan(self._markets))
+
+        results = await asyncio.gather(*scan_tasks, return_exceptions=True)
+
+        for i, (name, _) in enumerate(self.strategies.items()):
+            if isinstance(results[i], Exception):
+                logger.error(f"Strategy {name} scan failed: {results[i]}")
+                self.monitor.alert("ERROR", f"{name} Scan Failed", str(results[i]), strategy=name)
+            elif results[i]:
+                all_signals.extend(results[i])
+
+        if not all_signals:
+            if self._cycle_count % 30 == 0:
+                logger.debug(f"Cycle {self._cycle_count}: no signals (scanning {len(self._markets)} markets)")
+            return
+
+        # Trier les signaux par profit attendu * confiance
+        all_signals.sort(key=lambda s: s.expected_profit * s.confidence, reverse=True)
+
+        # Exécuter les meilleurs signaux
+        executed = 0
+        for signal in all_signals[:5]:
+            strategy = self.strategies.get(signal.strategy)
+            if not strategy:
+                continue
+
+            try:
+                trade = await strategy.execute(signal, self.engine)
+                if trade:
+                    executed += 1
+                    self.monitor.alert(
+                        "INFO",
+                        f"Trade Executed ({signal.strategy})",
+                        f"{signal.action} | Confidence: {signal.confidence:.2f} | "
+                        f"Expected profit: ${signal.expected_profit:.2f} | "
+                        f"Size: ${signal.size_usd:.2f}",
+                        strategy=signal.strategy,
+                        metadata=signal.metadata or {},
+                    )
+            except Exception as e:
+                logger.error(f"Execution failed for signal: {e}")
+                self.monitor.alert("ERROR", "Execution Failed", str(e), strategy=signal.strategy)
+
+        if executed > 0:
+            logger.info(f"✅ Cycle {self._cycle_count}: {executed}/{len(all_signals)} signals executed")
+
+    async def _monitor_cycle(self):
+        """Cycle de monitoring: métriques, alertes, dashboard."""
+        summary = self.engine.get_portfolio_summary()
+
+        snapshot = MetricSnapshot(
+            timestamp=time.time(),
+            balance_usd=summary["balance_usd"],
+            total_exposure=summary["total_exposure"],
+            total_pnl=summary["total_pnl"],
+            daily_pnl=summary["daily_pnl"],
+            num_positions=summary["num_positions"],
+            num_trades=summary["num_trades"],
+            max_drawdown=float(summary["max_drawdown"].replace("%", "")) / 100,
+        )
+        self.monitor.record_metrics(snapshot)
+        self.monitor.check_risk_alerts(summary, self.config)
+
+    # ── Main Loop ────────────────────────────────────────────────
+    async def run(self, max_cycles: int = None, duration_seconds: int = None):
+        """
+        Lance le bot.
+
+        Args:
+            max_cycles: Nombre max de cycles (None = infini)
+            duration_seconds: Durée max en secondes (None = infini)
+        """
+        self._running = True
+        start_time = time.time()
+
+        banner = f"""
+╔══════════════════════════════════════════════════════════════╗
+║            🤖 POLYMARKET ULTRA BOT — STARTED 🤖             ║
+╠══════════════════════════════════════════════════════════════╣
+║ Mode:          {'DRY RUN (Paper Trading)' if self.config.dry_run else 'LIVE TRADING ⚠️'}
+║ Strategies:    {', '.join(self.strategies.keys())}
+║ Max Exposure:  ${self.config.max_total_exposure_usd:,.2f}
+║ Poll Interval: {self.config.poll_interval_seconds}s
+║ Capital:       ${self.engine.portfolio.balance_usd:,.2f}
+║ Started at:    {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+╚══════════════════════════════════════════════════════════════╝"""
+        logger.info(banner)
+
+        await self.refresh_markets()
+
+        cycle = 0
+        monitor_interval = 30
+
+        try:
+            while self._running:
+                cycle += 1
+
+                if max_cycles and cycle > max_cycles:
+                    logger.info(f"Max cycles reached ({max_cycles})")
+                    break
+
+                if duration_seconds and (time.time() - start_time) > duration_seconds:
+                    logger.info(f"Duration limit reached ({duration_seconds}s)")
+                    break
+
+                try:
+                    await self._trading_cycle()
+                except Exception as e:
+                    logger.error(f"Trading cycle error: {e}")
+                    self.monitor.alert("ERROR", "Cycle Error", str(e))
+
+                if cycle % monitor_interval == 0:
+                    await self._monitor_cycle()
+                    self.monitor.print_dashboard()
+
+                await asyncio.sleep(self.config.poll_interval_seconds)
+
+        except KeyboardInterrupt:
+            logger.info("Bot stopped by user (Ctrl+C)")
+        except Exception as e:
+            logger.error(f"Fatal error: {e}")
+            self.monitor.alert("ERROR", "Fatal Error", str(e))
+        finally:
+            await self.shutdown()
+
+    async def shutdown(self):
+        """Arrêt propre du bot."""
+        logger.info("Shutting down bot...")
+        self._running = False
+
+        await self._monitor_cycle()
+        self.monitor.print_dashboard()
+        self.monitor.export_metrics("bot_metrics.json")
+
+        report = self.monitor.get_performance_report()
+        logger.info(f"""
+╔══════════════════════════════════════════════════════════════╗
+║            📈 FINAL PERFORMANCE REPORT 📈                    ║
+╠══════════════════════════════════════════════════════════════╣
+║ Runtime:       {report.get('uptime_hours', 0):.2f} hours
+║ Final Balance: ${report.get('current_balance', 0):,.2f}
+║ Total PnL:     ${report.get('total_pnl', 0):+,.2f} ({report.get('return_pct', 0):+.2f}%)
+║ Max Drawdown:  {report.get('max_drawdown_pct', 0):.2f}%
+║ Total Trades:  {report.get('total_trades', 0)}
+║ PnL/Hour:      ${report.get('pnl_per_hour', 0):+,.2f}
+║ Alerts:        {report.get('total_alerts', 0)} (⚠️{report.get('warn_alerts', 0)} ❌{report.get('error_alerts', 0)})
+╚══════════════════════════════════════════════════════════════╝""")
+
+        await self.gamma.close()
+        await self.clob.close()
+
+        logger.info("Bot shutdown complete ✅")
+
+    # ── Quick Start ──────────────────────────────────────────────
+    @classmethod
+    async def quick_start(cls, dry_run: bool = True, duration: int = 3600):
+        """Démarrage rapide du bot."""
+        config = BotConfig(dry_run=dry_run)
+        bot = cls(config)
+        await bot.run(duration_seconds=duration)
+        return bot