quantnodes 3.0.0__py3-none-any.whl

QuantNodes/monitor/agent_tools/monitor_tool.py

@@ -0,0 +1,98 @@
+# coding=utf-8
+"""监控查询Agent工具"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from QuantNodes.agent.tools.base import Tool
+from ..storage.repository import DatabaseManager
+from ..monitor.dashboard import MonitorDashboard
+
+
+class MonitorTool(Tool):
+    """策略监控查询工具"""
+
+    def __init__(self, db_path: str = "~/.quantnodes/monitor.db"):
+        self._db_path = db_path
+        self._dashboard = None
+
+    def _get_dashboard(self) -> MonitorDashboard:
+        if self._dashboard is None:
+            db = DatabaseManager(self._db_path)
+            db.connect()
+            from ..storage.repository import (
+                StrategyRunRepository, PerformanceRepository, DriftAlertRepository,
+            )
+            self._dashboard = MonitorDashboard(
+                StrategyRunRepository(db),
+                PerformanceRepository(db),
+                DriftAlertRepository(db),
+            )
+        return self._dashboard
+
+    @property
+    def name(self) -> str:
+        return "strategy_monitor"
+
+    @property
+    def description(self) -> str:
+        return "查询策略监控状态，包括绩效指标、漂移告警、历史记录等"
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["status", "history", "alerts", "compare"],
+                    "description": "操作类型",
+                },
+                "strategy_name": {
+                    "type": "string",
+                    "description": "策略名称",
+                },
+                "days": {
+                    "type": "integer",
+                    "description": "查询天数 (默认30)",
+                    "default": 30,
+                },
+                "strategy_names": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "对比的策略名称列表 (仅compare操作)",
+                },
+            },
+            "required": ["action"],
+        }
+
+    @property
+    def read_only(self) -> bool:
+        return True
+
+    async def execute(self, action: str, strategy_name: str = None,
+                      days: int = 30, strategy_names: list = None, **kwargs) -> Any:
+        dashboard = self._get_dashboard()
+
+        if action == "status":
+            if not strategy_name:
+                return {"error": "strategy_name required for status"}
+            return dashboard.get_strategy_summary(strategy_name)
+
+        elif action == "history":
+            if not strategy_name:
+                return {"error": "strategy_name required for history"}
+            return dashboard.get_performance_history(strategy_name, days)
+
+        elif action == "alerts":
+            if not strategy_name:
+                return {"error": "strategy_name required for alerts"}
+            return dashboard.get_alert_history(strategy_name, days)
+
+        elif action == "compare":
+            if not strategy_names:
+                return {"error": "strategy_names required for compare"}
+            return dashboard.get_comparison(strategy_names)
+
+        return {"error": f"Unknown action: {action}"}

QuantNodes/monitor/agent_tools/schedule_tool.py

@@ -0,0 +1,98 @@
+# coding=utf-8
+"""调度管理Agent工具"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from QuantNodes.agent.tools.base import Tool
+from ..scheduler.scheduler import StrategyScheduler
+
+
+class ScheduleTool(Tool):
+    """策略调度管理工具"""
+
+    def __init__(self, db_path: str = "~/.quantnodes/monitor.db"):
+        self._db_path = db_path
+        self._scheduler = None
+
+    def _get_scheduler(self) -> StrategyScheduler:
+        if self._scheduler is None:
+            self._scheduler = StrategyScheduler(self._db_path)
+            self._scheduler.start()
+        return self._scheduler
+
+    @property
+    def name(self) -> str:
+        return "strategy_schedule"
+
+    @property
+    def description(self) -> str:
+        return "管理策略调度任务，支持添加、移除、暂停、恢复定时执行"
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["add", "remove", "list", "pause", "resume"],
+                    "description": "操作类型",
+                },
+                "strategy_name": {
+                    "type": "string",
+                    "description": "策略名称",
+                },
+                "cron": {
+                    "type": "string",
+                    "description": "cron表达式 (如 '0 18 * * 1-5')",
+                },
+                "interval_minutes": {
+                    "type": "integer",
+                    "description": "间隔分钟数",
+                },
+                "config_path": {
+                    "type": "string",
+                    "description": "YAML配置文件路径",
+                },
+            },
+            "required": ["action", "strategy_name"],
+        }
+
+    @property
+    def read_only(self) -> bool:
+        return False
+
+    async def execute(self, action: str, strategy_name: str,
+                      cron: str = None, interval_minutes: int = None,
+                      config_path: str = None, **kwargs) -> Any:
+        scheduler = self._get_scheduler()
+
+        if action == "add":
+            if not config_path:
+                return {"error": "config_path required for add"}
+            if cron:
+                job_id = scheduler.add_cron_job(strategy_name, cron, config_path)
+            elif interval_minutes:
+                job_id = scheduler.add_interval_job(strategy_name, interval_minutes, config_path)
+            else:
+                return {"error": "cron or interval_minutes required"}
+            return {"status": "added", "job_id": job_id}
+
+        elif action == "remove":
+            success = scheduler.remove_job(strategy_name)
+            return {"status": "removed" if success else "not_found"}
+
+        elif action == "list":
+            return {"jobs": scheduler.get_jobs()}
+
+        elif action == "pause":
+            success = scheduler.pause_job(strategy_name)
+            return {"status": "paused" if success else "not_found"}
+
+        elif action == "resume":
+            success = scheduler.resume_job(strategy_name)
+            return {"status": "resumed" if success else "not_found"}
+
+        return {"error": f"Unknown action: {action}"}

QuantNodes/monitor/agent_tools/version_tool.py

@@ -0,0 +1,133 @@
+# coding=utf-8
+"""版本管理Agent工具"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from QuantNodes.agent.tools.base import Tool
+from ..storage.repository import DatabaseManager, VersionRepository
+from ..version.version_manager import VersionManager
+
+
+class VersionTool(Tool):
+    """策略版本管理工具"""
+
+    def __init__(self, db_path: str = "~/.quantnodes/monitor.db"):
+        self._db_path = db_path
+        self._version_manager = None
+
+    def _get_version_manager(self) -> VersionManager:
+        if self._version_manager is None:
+            db = DatabaseManager(self._db_path)
+            db.connect()
+            self._version_manager = VersionManager(VersionRepository(db))
+        return self._version_manager
+
+    @property
+    def name(self) -> str:
+        return "strategy_version"
+
+    @property
+    def description(self) -> str:
+        return "管理策略版本，支持保存、查看历史、对比差异、回滚"
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["save", "list", "diff", "rollback", "current"],
+                    "description": "操作类型",
+                },
+                "strategy_name": {
+                    "type": "string",
+                    "description": "策略名称",
+                },
+                "version": {
+                    "type": "string",
+                    "description": "版本号 (如 'v1', 'v2')",
+                },
+                "config_path": {
+                    "type": "string",
+                    "description": "YAML配置文件路径 (save操作)",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "版本描述 (save操作)",
+                },
+            },
+            "required": ["action", "strategy_name"],
+        }
+
+    @property
+    def read_only(self) -> bool:
+        return False
+
+    async def execute(self, action: str, strategy_name: str,
+                      version: str = None, config_path: str = None,
+                      description: str = "", **kwargs) -> Any:
+        vm = self._get_version_manager()
+
+        if action == "save":
+            if not config_path:
+                return {"error": "config_path required for save"}
+            sv = vm.save_version(strategy_name, config_path, description)
+            return {
+                "status": "saved",
+                "version": sv.version,
+                "commit_hash": sv.commit_hash,
+            }
+
+        elif action == "list":
+            versions = vm.list_versions(strategy_name)
+            return {
+                "versions": [
+                    {
+                        "version": v.version,
+                        "commit_hash": v.commit_hash,
+                        "description": v.description,
+                        "created_at": str(v.created_at) if v.created_at else None,
+                    }
+                    for v in versions
+                ]
+            }
+
+        elif action == "diff":
+            if not version:
+                return {"error": "version required for diff (compare with previous)"}
+            versions = vm.list_versions(strategy_name)
+            if len(versions) < 2:
+                return {"error": "need at least 2 versions to diff"}
+            # 找到目标版本的前一个版本
+            target_idx = next(
+                (i for i, v in enumerate(versions) if v.version == version), None
+            )
+            if target_idx is None:
+                return {"error": f"version {version} not found"}
+            if target_idx >= len(versions) - 1:
+                prev_version = versions[target_idx + 1].version
+            else:
+                prev_version = versions[0].version
+            diff_text = vm.diff_versions(strategy_name, version, prev_version)
+            return {"diff": diff_text}
+
+        elif action == "rollback":
+            if not version:
+                return {"error": "version required for rollback"}
+            sv = vm.rollback(strategy_name, version)
+            if sv:
+                return {
+                    "status": "rolled_back",
+                    "new_version": sv.version,
+                    "commit_hash": sv.commit_hash,
+                }
+            return {"error": f"version {version} not found"}
+
+        elif action == "current":
+            ver = vm.get_current_version(strategy_name)
+            return {"current_version": ver}
+
+        return {"error": f"Unknown action: {action}"}

QuantNodes/monitor/monitor/__init__.py

@@ -0,0 +1,6 @@
+from .collector import MetricsCollector
+from .drift import DriftDetector
+from .alerter import Alerter
+from .dashboard import MonitorDashboard
+
+__all__ = ["MetricsCollector", "DriftDetector", "Alerter", "MonitorDashboard"]

QuantNodes/monitor/monitor/alerter.py

@@ -0,0 +1,60 @@
+# coding=utf-8
+"""告警生成器"""
+
+from __future__ import annotations
+
+from typing import List
+
+from ..storage.models import DriftAlert
+from ..storage.repository import DriftAlertRepository
+
+
+class Alerter:
+    """告警生成器 - 创建、查询、确认告警"""
+
+    def __init__(self, alert_repo: DriftAlertRepository):
+        self.repo = alert_repo
+
+    def create_alert(self, alert: DriftAlert) -> int:
+        """创建告警记录"""
+        return self.repo.create_alert(alert)
+
+    def get_pending_alerts(self, strategy_name: str = None) -> List[DriftAlert]:
+        """获取未确认的告警"""
+        return self.repo.get_pending(strategy_name)
+
+    def acknowledge_alert(self, alert_id: int) -> None:
+        """确认告警"""
+        self.repo.acknowledge(alert_id)
+
+    def get_alert_history(
+        self, strategy_name: str, days: int = 30
+    ) -> List[DriftAlert]:
+        """获取告警历史"""
+        return self.repo.get_history(strategy_name, days)
+
+    def format_alert_message(self, alert: DriftAlert) -> str:
+        """格式化告警消息"""
+        severity_icon = "🔴" if alert.severity == "critical" else "🟡"
+        return (
+            f"{severity_icon} [{alert.severity.upper()}] {alert.strategy_name}\n"
+            f"   类型: {alert.alert_type}\n"
+            f"   指标: {alert.metric_name}\n"
+            f"   当前值: {alert.current_value}\n"
+            f"   基线值: {alert.baseline_value}\n"
+            f"   消息: {alert.message}"
+        )
+
+    def get_pending_summary(self, strategy_name: str = None) -> dict:
+        """获取未确认告警摘要"""
+        pending = self.get_pending_alerts(strategy_name)
+        return {
+            "total": len(pending),
+            "critical": sum(1 for a in pending if a.severity == "critical"),
+            "warning": sum(1 for a in pending if a.severity == "warning"),
+            "by_type": {
+                "ks_test": sum(1 for a in pending if a.alert_type == "ks_test"),
+                "sharpe_drop": sum(1 for a in pending if a.alert_type == "sharpe_drop"),
+                "drawdown_breach": sum(1 for a in pending if a.alert_type == "drawdown_breach"),
+            },
+        }

QuantNodes/monitor/monitor/collector.py

@@ -0,0 +1,164 @@
+# coding=utf-8
+"""绩效指标采集器"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from typing import Optional, Dict, Any, List
+
+import polars as pl
+
+from ..storage.models import PerformanceSnapshot
+from ..storage.repository import PerformanceRepository
+
+
+class MetricsCollector:
+    """绩效指标采集器 - 从回测结果或实盘数据采集绩效指标"""
+
+    def __init__(self, performance_repo: PerformanceRepository):
+        self.repo = performance_repo
+
+    def collect_from_backtest(
+        self,
+        strategy_name: str,
+        statistics: Dict[str, Any],
+        daily_returns: Optional[List[float]] = None,
+    ) -> PerformanceSnapshot:
+        """从回测统计结果采集绩效指标
+
+        Args:
+            strategy_name: 策略名称
+            statistics: ConfigBacktestRunner._compute_statistics() 的输出
+            daily_returns: 日收益率序列 (可选)
+
+        Returns:
+            PerformanceSnapshot 对象
+        """
+        returns_json = json.dumps(daily_returns) if daily_returns else None
+
+        snapshot = PerformanceSnapshot(
+            strategy_name=strategy_name,
+            snapshot_date=date.today(),
+            sharpe_ratio=statistics.get("sharpe_ratio"),
+            sortino_ratio=statistics.get("sortino_ratio"),
+            max_drawdown=statistics.get("max_drawdown"),
+            annualized_return=statistics.get("annualized_return"),
+            annualized_volatility=statistics.get("annualized_volatility"),
+            win_rate=statistics.get("win_rate"),
+            profit_factor=statistics.get("profit_factor"),
+            total_trades=statistics.get("total_trades"),
+            daily_returns=returns_json,
+        )
+
+        self.repo.save_snapshot(snapshot)
+        return snapshot
+
+    def collect_from_lazyframe(
+        self,
+        strategy_name: str,
+        equity_curve: pl.LazyFrame,
+    ) -> PerformanceSnapshot:
+        """从权益曲线LazyFrame采集绩效指标
+
+        Args:
+            strategy_name: 策略名称
+            equity_curve: 包含 date, equity 列的 LazyFrame
+
+        Returns:
+            PerformanceSnapshot 对象
+        """
+        df = equity_curve.collect()
+
+        if "equity" not in df.columns or len(df) < 2:
+            snapshot = PerformanceSnapshot(
+                strategy_name=strategy_name,
+                snapshot_date=date.today(),
+            )
+            self.repo.save_snapshot(snapshot)
+            return snapshot
+
+        equity = df["equity"].to_list()
+        daily_returns = self._compute_daily_returns(equity)
+        stats = self._compute_statistics(daily_returns)
+
+        snapshot = PerformanceSnapshot(
+            strategy_name=strategy_name,
+            snapshot_date=date.today(),
+            sharpe_ratio=stats.get("sharpe_ratio"),
+            sortino_ratio=stats.get("sortino_ratio"),
+            max_drawdown=stats.get("max_drawdown"),
+            annualized_return=stats.get("annualized_return"),
+            annualized_volatility=stats.get("annualized_volatility"),
+            daily_returns=json.dumps(daily_returns),
+        )
+
+        self.repo.save_snapshot(snapshot)
+        return snapshot
+
+    def get_baseline_metrics(
+        self, strategy_name: str, baseline_days: int = 252
+    ) -> Optional[PerformanceSnapshot]:
+        """获取基线指标 (用于漂移检测对比)"""
+        return self.repo.get_baseline(strategy_name, baseline_days)
+
+    @staticmethod
+    def _compute_daily_returns(equity: List[float]) -> List[float]:
+        """计算日收益率"""
+        returns = []
+        for i in range(1, len(equity)):
+            if equity[i - 1] != 0:
+                returns.append(equity[i] / equity[i - 1] - 1)
+            else:
+                returns.append(0.0)
+        return returns
+
+    @staticmethod
+    def _compute_statistics(daily_returns: List[float]) -> Dict[str, Any]:
+        """从日收益率计算统计指标"""
+        import math
+
+        if not daily_returns:
+            return {}
+
+        n = len(daily_returns)
+        mean_r = sum(daily_returns) / n
+        var_r = sum((r - mean_r) ** 2 for r in daily_returns) / max(n - 1, 1)
+        std_r = math.sqrt(var_r)
+
+        # 夏普比率 (rf=3%)
+        rf_daily = 0.03 / 252
+        sharpe = (mean_r - rf_daily) / std_r * math.sqrt(252) if std_r > 0 else 0.0
+
+        # 索提诺比率
+        downside = [r for r in daily_returns if r < rf_daily]
+        downside_var = sum((r - rf_daily) ** 2 for r in downside) / max(len(downside), 1)
+        downside_std = math.sqrt(downside_var)
+        sortino = (mean_r - rf_daily) / downside_std * math.sqrt(252) if downside_std > 0 else 0.0
+
+        # 最大回撤
+        max_dd = 0.0
+        cum = 1.0
+        peak = 1.0
+        for r in daily_returns:
+            cum *= (1 + r)
+            if cum > peak:
+                peak = cum
+            dd = (cum - peak) / peak
+            if dd < max_dd:
+                max_dd = dd
+
+        # 年化收益
+        total_return = 1.0
+        for r in daily_returns:
+            total_return *= (1 + r)
+        n_years = n / 252
+        ann_return = total_return ** (1 / max(n_years, 0.01)) - 1 if total_return > 0 else -1.0
+
+        return {
+            "sharpe_ratio": round(sharpe, 4),
+            "sortino_ratio": round(sortino, 4),
+            "max_drawdown": round(max_dd, 4),
+            "annualized_return": round(ann_return, 4),
+            "annualized_volatility": round(std_r * math.sqrt(252), 4),
+        }

QuantNodes/monitor/monitor/dashboard.py

@@ -0,0 +1,115 @@
+# coding=utf-8
+"""监控数据查询接口"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any
+
+from ..storage.repository import (
+    StrategyRunRepository,
+    PerformanceRepository,
+    DriftAlertRepository,
+)
+
+
+class MonitorDashboard:
+    """监控数据查询接口"""
+
+    def __init__(
+        self,
+        run_repo: StrategyRunRepository,
+        perf_repo: PerformanceRepository,
+        alert_repo: DriftAlertRepository,
+    ):
+        self.run_repo = run_repo
+        self.perf_repo = perf_repo
+        self.alert_repo = alert_repo
+
+    def get_strategy_summary(self, strategy_name: str) -> Dict[str, Any]:
+        """获取策略概览"""
+        latest_run = None
+        runs = self.run_repo.get_by_strategy(strategy_name, limit=1)
+        if runs:
+            latest_run = {
+                "status": runs[0].status,
+                "start_time": str(runs[0].start_time) if runs[0].start_time else None,
+                "end_time": str(runs[0].end_time) if runs[0].end_time else None,
+            }
+
+        perf = self.perf_repo.get_latest(strategy_name)
+        perf_dict = None
+        if perf:
+            perf_dict = {
+                "sharpe_ratio": perf.sharpe_ratio,
+                "sortino_ratio": perf.sortino_ratio,
+                "max_drawdown": perf.max_drawdown,
+                "annualized_return": perf.annualized_return,
+                "win_rate": perf.win_rate,
+                "snapshot_date": str(perf.snapshot_date) if perf.snapshot_date else None,
+            }
+
+        pending_alerts = self.alert_repo.get_pending(strategy_name)
+
+        return {
+            "strategy_name": strategy_name,
+            "latest_run": latest_run,
+            "performance": perf_dict,
+            "pending_alerts": len(pending_alerts),
+        }
+
+    def get_performance_history(
+        self, strategy_name: str, days: int = 30
+    ) -> List[Dict[str, Any]]:
+        """获取绩效历史"""
+        snapshots = self.perf_repo.get_history(strategy_name, days)
+        return [
+            {
+                "date": str(s.snapshot_date),
+                "sharpe_ratio": s.sharpe_ratio,
+                "max_drawdown": s.max_drawdown,
+                "annualized_return": s.annualized_return,
+                "win_rate": s.win_rate,
+            }
+            for s in snapshots
+        ]
+
+    def get_alert_history(
+        self, strategy_name: str, days: int = 30
+    ) -> List[Dict[str, Any]]:
+        """获取告警历史"""
+        alerts = self.alert_repo.get_history(strategy_name, days)
+        return [
+            {
+                "id": a.id,
+                "type": a.alert_type,
+                "severity": a.severity,
+                "metric": a.metric_name,
+                "message": a.message,
+                "acknowledged": a.acknowledged,
+                "created_at": str(a.created_at) if a.created_at else None,
+            }
+            for a in alerts
+        ]
+
+    def get_comparison(self, strategy_names: List[str]) -> Dict[str, Any]:
+        """多策略对比"""
+        result = {}
+        for name in strategy_names:
+            perf = self.perf_repo.get_latest(name)
+            if perf:
+                result[name] = {
+                    "sharpe_ratio": perf.sharpe_ratio,
+                    "max_drawdown": perf.max_drawdown,
+                    "annualized_return": perf.annualized_return,
+                    "win_rate": perf.win_rate,
+                }
+            else:
+                result[name] = None
+        return result
+
+    def get_all_strategies(self) -> List[str]:
+        """获取所有策略名称"""
+        rows = self.run_repo.db.conn.execute(
+            "SELECT DISTINCT strategy_name FROM strategy_runs"
+        ).fetchall()
+        return [r["strategy_name"] for r in rows]