quantnodes 3.0.0__py3-none-any.whl

QuantNodes/agent/tools/backtest.py

@@ -0,0 +1,226 @@
+# coding=utf-8
+"""
+回测运行工具
+
+封装 QuantNodes 回测引擎，执行真实回测。
+"""
+
+from typing import Any, Dict
+import re
+
+from QuantNodes.agent.tools.base import Tool
+
+
+class BacktestTool(Tool):
+    """回测运行工具
+
+    通过 CodeSandbox 安全执行策略代码，提取节点，
+    然后运行 Strategy→Risk→Broker 回测流程。
+
+    pipeline_code 示例:
+        import pandas as pd
+        from QuantNodes.backtest.strategy_node import MAStrategyNode
+        from QuantNodes.backtest.broker_node import SimulatedBrokerNode
+
+        strategy = MAStrategyNode(config={'short_window': 5, 'long_window': 20})
+        broker = SimulatedBrokerNode(config={'cash': 100000, 'commission': 0.001})
+        quote_data = pd.read_csv('data.csv')
+    """
+
+    CODE_BLOCK_PATTERN = re.compile(r'```(?:python)?\s*(.*?)```', re.DOTALL)
+
+    def __init__(self):
+        pass
+
+    @property
+    def name(self) -> str:
+        return "backtest"
+
+    @property
+    def description(self) -> str:
+        return (
+            "运行策略回测，返回回测结果（交易次数、最终资金、手续费等）。"
+            "pipeline_code 中需创建 strategy、broker 变量和 quote_data DataFrame。"
+        )
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "pipeline_code": {
+                    "type": "string",
+                    "description": (
+                        "策略Pipeline代码，需创建 strategy、broker 变量和 quote_data DataFrame"
+                    ),
+                },
+                "start_date": {
+                    "type": "string",
+                    "description": "回测开始日期，格式YYYY-MM-DD"
+                },
+                "end_date": {
+                    "type": "string",
+                    "description": "回测结束日期，格式YYYY-MM-DD"
+                },
+                "initial_cash": {
+                    "type": "number",
+                    "description": "初始资金",
+                    "default": 100000
+                },
+                "commission": {
+                    "type": "number",
+                    "description": "手续费率",
+                    "default": 0.001
+                }
+            },
+            "required": ["pipeline_code"]
+        }
+
+    @property
+    def read_only(self) -> bool:
+        return False
+
+    @property
+    def concurrency_safe(self) -> bool:
+        return False
+
+    async def execute(
+        self,
+        pipeline_code: str,
+        start_date: str = None,
+        end_date: str = None,
+        initial_cash: float = 100000,
+        commission: float = 0.001,
+        **kwargs
+    ) -> Dict[str, Any]:
+        result = {
+            "status": "success",
+            "summary": {},
+            "config": {
+                "start_date": start_date,
+                "end_date": end_date,
+                "initial_cash": initial_cash,
+                "commission": commission,
+            }
+        }
+
+        try:
+            from QuantNodes.ai.sandbox import CodeSandbox
+            from QuantNodes.backtest.strategy_node import StrategyNode
+            from QuantNodes.backtest.broker_node import SimulatedBrokerNode
+            from QuantNodes.backtest.risk_node import RiskNode
+
+            sandbox = CodeSandbox()
+            extracted_code = self._extract_code(pipeline_code)
+
+            if not extracted_code:
+                result["status"] = "error"
+                result["errors"] = ["No valid code found in pipeline_code"]
+                return result
+
+            validation = sandbox.validate(extracted_code)
+            if not validation.is_safe:
+                result["status"] = "error"
+                result["errors"] = validation.errors
+                result["security_status"] = "unsafe"
+                return result
+
+            result["security_status"] = "safe"
+
+            import pandas as pd
+            import numpy as np
+            context = {
+                "pd": pd,
+                "np": np,
+                "QuantNodes": __import__("QuantNodes"),
+            }
+
+            namespace = sandbox.validate_and_execute(extracted_code, context)
+
+            strategy = None
+            broker = None
+            risk_nodes = []
+            quote_data = None
+
+            for name, obj in namespace.items():
+                if isinstance(obj, StrategyNode) and not isinstance(obj, RiskNode):
+                    strategy = obj
+                elif isinstance(obj, SimulatedBrokerNode):
+                    broker = obj
+                elif isinstance(obj, RiskNode):
+                    risk_nodes.append(obj)
+
+            quote_data = namespace.get("quote_data") or namespace.get("data")
+
+            if strategy is None:
+                result["status"] = "error"
+                result["errors"] = [
+                    "No StrategyNode found. Create a strategy variable in your code, e.g.:\n"
+                    "from QuantNodes.backtest.strategy_node import MAStrategyNode\n"
+                    "strategy = MAStrategyNode(config={'short_window': 5, 'long_window': 20})"
+                ]
+                return result
+
+            if quote_data is None:
+                result["status"] = "error"
+                result["errors"] = [
+                    "No quote_data found. Create a 'quote_data' DataFrame in your code, e.g.:\n"
+                    "quote_data = pd.read_csv('data.csv')"
+                ]
+                return result
+
+            if broker is None:
+                from QuantNodes.backtest.broker_node import SimulatedBrokerNode
+                broker = SimulatedBrokerNode(config={
+                    "cash": initial_cash,
+                    "commission": commission,
+                })
+
+            if start_date and end_date and "date" in quote_data.columns:
+                quote_data = quote_data[
+                    (quote_data["date"] >= start_date) &
+                    (quote_data["date"] <= end_date)
+                ]
+
+            orders_result = strategy.execute(quote_data)
+
+            filtered_orders = orders_result
+            for risk in risk_nodes:
+                risk_result = risk.execute((filtered_orders, {}))
+                from QuantNodes.backtest.strategy_node import OrdersResult
+                filtered = OrdersResult()
+                filtered.orders = risk_result.passed_orders
+                filtered.signals = orders_result.signals
+                filtered_orders = filtered
+
+            trade_result = broker.execute((filtered_orders, quote_data))
+
+            result["summary"] = {
+                "total_trades": len(trade_result.trades) if hasattr(trade_result, "trades") else 0,
+                "final_cash": trade_result.cash if hasattr(trade_result, "cash") else initial_cash,
+                "total_commission": (
+                    trade_result.commission if hasattr(trade_result, "commission") else 0
+                ),
+                "strategy": strategy.__class__.__name__,
+                "broker": broker.__class__.__name__,
+                "risk_nodes": [r.__class__.__name__ for r in risk_nodes],
+                "data_rows": len(quote_data),
+            }
+
+            result["nodes"] = {
+                "strategy": strategy.__class__.__name__,
+                "broker": broker.__class__.__name__,
+                "risk_nodes": [r.__class__.__name__ for r in risk_nodes],
+            }
+
+        except Exception as e:
+            result["status"] = "error"
+            result["errors"] = [str(e)]
+
+        return result
+
+    def _extract_code(self, code: str) -> str:
+        match = self.CODE_BLOCK_PATTERN.search(code)
+        if match:
+            return match.group(1).strip()
+        return code.strip()

QuantNodes/agent/tools/base.py

@@ -0,0 +1,133 @@
+# coding=utf-8
+"""Tool base class — inherits from HKUDS nanobot 0.2.1 ``Tool``.
+
+v3.0.0 迁移到上游后，quant 工具的父类由本地 ``Tool`` 改为
+``nanobot.agent.tools.base.Tool``。本文件保留薄包装以兼容 14 个 quant
+工具的 ``from .base import Tool`` 导入路径。
+
+**v3.0.0 Stage 5.3** 起，``nanobot-ai`` 为可选依赖。本文件在未装 extras
+时提供本地降级父类 ``Tool``，让 quant 工具可在没有 nanobot 的环境下
+独立使用（CLI、API、Wiki 等场景不需要 agent）。当用户调用 ``Agent(...)``
+或注册工具到 nanobot registry 时才会触发真正的 nanobot import。
+"""
+
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any, Dict
+
+# Note: do NOT ``from QuantNodes.agent import NANOBOT_AVAILABLE`` here — this
+# file is imported as part of ``QuantNodes.agent.__init__`` (via
+# ``nanobot_bridge.py -> tools/__init__.py -> base.py``) and a back-import
+# would create a circular dependency with partially-initialized module state.
+# Instead we probe nanobot here, independently.
+try:
+    from nanobot.agent.tools.base import Tool as _NanobotTool
+
+    _NANOBOT_AVAILABLE = True
+except ImportError:  # pragma: no cover - exercised in nanobot-less envs
+    _NanobotTool = ABC  # type: ignore[assignment,misc]
+    _NANOBOT_AVAILABLE = False
+
+
+@dataclass
+class ToolExecutionResult:
+    """工具执行结果（向后兼容）。"""
+
+    tool_name: str
+    success: bool
+    content: Any
+    error: str | None = None
+
+
+if _NANOBOT_AVAILABLE:  # pragma: no cover - exercised in [agent] installs
+    class Tool(_NanobotTool, ABC):  # type: ignore[misc]
+        """所有 quant 工具的薄包装父类 — 继承自 nanobot 的 ``Tool``。
+
+        仅补充：
+        - ``to_openai_schema`` 别名（与 ``to_schema`` 同语义，保留旧名）
+        - ``_dispatch`` 辅助方法（量化工具内部 action 分发用）
+        """
+
+        @property
+        def to_openai_schema(self) -> Any:
+            """向后兼容别名 — 调用上游 ``to_schema``。"""
+            return self.to_schema
+
+        async def _dispatch(self, action: str, registry: Dict[str, Any], **kwargs: Any) -> Any:
+            """Look up ``action`` in ``registry`` and call it with kwargs.
+
+            Replaces 4-times-repeated::
+
+                fn = dispatch.get(action)
+                if not fn: raise ValueError(...)
+                return await fn(**kwargs)
+
+            Subclasses call ``return await self._dispatch(action, {...})`` from execute().
+            """
+            fn = registry.get(action)
+            if not fn:
+                raise ValueError(f"Unknown action: {action}")
+            return await fn(**kwargs)
+else:
+
+    class Tool(ABC):  # type: ignore[no-redef]
+        """Stand-alone Tool ABC for quant-only deployments (no nanobot).
+
+        When ``nanobot-ai`` is not installed, quant tools still need a
+        concrete parent class so that ``class MyTool(Tool)`` works. This
+        is the lightest possible stand-in: just enough to allow
+        ``from .base import Tool`` and the ``_dispatch`` helper.
+
+        ``to_openai_schema`` is implemented locally by synthesising the
+        standard OpenAI function-calling schema from ``name`` /
+        ``description`` / ``parameters``. This keeps monitor/MCP tools
+        introspectable in quant-only environments (e.g. dashboard,
+        docs) where the upstream nanobot ``Tool.to_schema`` is not
+        available. Tool registration with nanobot's ``ToolRegistry`` and
+        dispatch through ``AgentLoop`` still require the [agent] extra.
+        """
+
+        name: str = ""
+        description: str = ""
+        parameters: Dict[str, Any] = {}
+
+        def to_openai_schema(self) -> Dict[str, Any]:
+            """OpenAI function-calling schema synthesised from attrs.
+
+            Mirrors the call signature of nanobot's ``Tool.to_schema``
+            (a method, not a property) so callers can do
+            ``tool.to_openai_schema()`` uniformly across both code paths.
+
+            Returns:
+                ``{"type": "function", "function": {"name": ..., "description": ..., "parameters": ...}}``
+            """
+            return {
+                "type": "function",
+                "function": {
+                    "name": self.name,
+                    "description": self.description,
+                    "parameters": self.parameters,
+                },
+            }
+
+        async def execute(self, **kwargs: Any) -> Any:  # pragma: no cover
+            raise RuntimeError(
+                "Tool.execute() requires nanobot-ai. "
+                "Install: pip install 'quantnodes[agent]'"
+            )
+
+        async def _dispatch(self, action: str, registry: Dict[str, Any], **kwargs: Any) -> Any:
+            """Look up ``action`` in ``registry`` and call it with kwargs.
+
+            Available even without nanobot, so quant tools' dispatcher
+            patterns work in pure-quant deployments.
+            """
+            fn = registry.get(action)
+            if not fn:
+                raise ValueError(f"Unknown action: {action}")
+            return await fn(**kwargs)
+
+
+__all__ = ["Tool", "ToolExecutionResult"]

QuantNodes/agent/tools/code_search.py

@@ -0,0 +1,207 @@
+# coding=utf-8
+"""
+代码搜索工具
+
+提供 grep 内容搜索、文件名查找、带上下文的代码搜索。
+路径限制在 workspace 内。
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict
+
+from .base import Tool
+from ._workspace import WorkspaceTool
+
+
+class CodeSearchTool(WorkspaceTool, Tool):
+    """代码搜索工具
+
+    在工作目录中搜索代码内容和文件名。
+    """
+
+    MAX_RESULTS = 50
+    MAX_CONTEXT_LINES = 3
+
+    def __init__(self, workspace: str | Path):
+        super().__init__(workspace)
+
+    @property
+    def name(self) -> str:
+        return "code_search"
+
+    @property
+    def description(self) -> str:
+        return "代码搜索工具：grep 内容搜索、按模式查找文件、带上下文的代码搜索"
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["grep", "find_files", "search_code"],
+                    "description": "搜索类型",
+                },
+                "pattern": {
+                    "type": "string",
+                    "description": "搜索模式（正则表达式或 glob）",
+                },
+                "path": {
+                    "type": "string",
+                    "description": "搜索目录（相对于工作目录），默认为整个工作目录",
+                },
+                "include": {
+                    "type": "string",
+                    "description": "文件名过滤模式，如 *.py 或 *.{ts,js}",
+                },
+                "context_lines": {
+                    "type": "integer",
+                    "description": "上下文行数（search_code 时使用）",
+                    "default": 3,
+                },
+            },
+            "required": ["action", "pattern"],
+        }
+
+    @property
+    def read_only(self) -> bool:
+        return True
+
+    def _safe_path(self, rel_path: str) -> Path:
+        """Resolve workspace-relative path (Phase J1: now inherited)."""
+        return WorkspaceTool._safe_path(self, rel_path)
+
+    def _match_include(self, filename: str, include: str | None) -> bool:
+        """检查文件名是否匹配 include 模式"""
+        if not include:
+            return True
+        # 支持 *.py 或 *.{ts,js} 格式
+        if "," in include:
+            patterns = [p.strip().lstrip("*") for p in include.split(",")]
+            return any(filename.endswith(p) for p in patterns)
+        ext = include.lstrip("*")
+        return filename.endswith(ext)
+
+    async def execute(self, action: str, **kwargs: Any) -> Any:
+        return await self._dispatch(action, {
+            "grep": self._grep,
+            "find_files": self._find_files,
+            "search_code": self._search_code,
+        }, **kwargs)
+
+    async def _grep(
+        self, pattern: str = "", path: str = "", include: str = "", **kw
+    ) -> Dict[str, Any]:
+        search_dir = self._safe_path(path)
+        if not search_dir.exists():
+            return {"error": f"Directory not found: {path}"}
+
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error as e:
+            return {"error": f"Invalid regex: {e}"}
+
+        results = []
+        for root, dirs, files in os.walk(search_dir):
+            # 跳过隐藏目录和 __pycache__
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d != "__pycache__"]
+
+            for fname in files:
+                if not self._match_include(fname, include):
+                    continue
+                fpath = Path(root) / fname
+                if fpath.stat().st_size > 512 * 1024:  # 跳过 > 512KB
+                    continue
+
+                try:
+                    lines = fpath.read_text(encoding="utf-8", errors="replace").splitlines()
+                    for i, line in enumerate(lines, 1):
+                        if regex.search(line):
+                            results.append({
+                                "file": str(fpath.relative_to(self.workspace)),
+                                "line": i,
+                                "content": line.rstrip()[:200],
+                            })
+                            if len(results) >= self.MAX_RESULTS:
+                                return {
+                                    "results": results,
+                                    "truncated": True,
+                                    "total": len(results),
+                                }
+                except (PermissionError, OSError):
+                    continue
+
+        return {"results": results, "truncated": False, "total": len(results)}
+
+    async def _find_files(self, pattern: str = "", path: str = "", **kw) -> Dict[str, Any]:
+        search_dir = self._safe_path(path)
+        if not search_dir.exists():
+            return {"error": f"Directory not found: {path}"}
+
+        matches = sorted(search_dir.glob(pattern))
+        results = []
+        for m in matches:
+            if m.is_file():
+                results.append({
+                    "path": str(m.relative_to(self.workspace)),
+                    "size": m.stat().st_size,
+                })
+                if len(results) >= self.MAX_RESULTS:
+                    break
+
+        return {"matches": results, "total": len(results)}
+
+    async def _search_code(
+        self, query: str = "", path: str = "", include: str = "",
+        context_lines: int = 3, **kw,
+    ) -> Dict[str, Any]:
+        search_dir = self._safe_path(path)
+        if not search_dir.exists():
+            return {"error": f"Directory not found: {path}"}
+
+        try:
+            regex = re.compile(query, re.IGNORECASE)
+        except re.error as e:
+            return {"error": f"Invalid regex: {e}"}
+
+        results = []
+        for root, dirs, files in os.walk(search_dir):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d != "__pycache__"]
+
+            for fname in files:
+                if not self._match_include(fname, include):
+                    continue
+                fpath = Path(root) / fname
+                if fpath.stat().st_size > 512 * 1024:
+                    continue
+
+                try:
+                    lines = fpath.read_text(encoding="utf-8", errors="replace").splitlines()
+                    for i, line in enumerate(lines):
+                        if regex.search(line):
+                            start = max(0, i - context_lines)
+                            end = min(len(lines), i + context_lines + 1)
+                            context = []
+                            for j in range(start, end):
+                                prefix = ">>>" if j == i else "   "
+                                context.append(f"{prefix} {j + 1}: {lines[j].rstrip()[:150]}")
+
+                            results.append({
+                                "file": str(fpath.relative_to(self.workspace)),
+                                "line": i + 1,
+                                "match": line.rstrip()[:200],
+                                "context": "\n".join(context),
+                            })
+                            if len(results) >= self.MAX_RESULTS:
+                                return {
+                                    "results": results,
+                                    "truncated": True,
+                                    "total": len(results),
+                                }
+                except (PermissionError, OSError):
+                    continue
+
+        return {"results": results, "truncated": False, "total": len(results)}