quantnodes 3.0.0__py3-none-any.whl

QuantNodes/ai/strategy_gen.py

@@ -0,0 +1,396 @@
+# coding=utf-8
+"""
+策略生成器
+
+提供从自然语言生成 QuantNodes Pipeline 的功能。
+"""
+from __future__ import annotations
+
+import re
+import logging
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+
+from QuantNodes.ai.llm.base import LLMClientBase, Message, MessageRole
+from QuantNodes.ai.prompts import PromptLibrary
+from QuantNodes.ai.sandbox import CodeSandbox, CodeValidationResult
+
+
+@dataclass
+class GenerationResult:
+    """生成结果"""
+    code: str
+    is_valid: bool
+    validation_result: Optional[CodeValidationResult] = None
+    error_message: Optional[str] = None
+    warnings: List[str] = field(default_factory=list)
+
+
+class StrategyGenerator:
+    """
+    策略生成器
+
+    将自然语言描述转换为 QuantNodes Pipeline 代码。
+
+    Examples:
+        >>> generator = StrategyGenerator(llm_client)
+        >>> result = generator.generate("Create a momentum strategy")
+        >>> print(result.code)
+    """
+
+    CODE_BLOCK_PATTERN = re.compile(r'```(?:python)?\s*(.*?)```', re.DOTALL)
+
+    def __init__(
+        self,
+        llm_client=None,
+        code_sandbox: Optional[CodeSandbox] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ):
+        """
+        初始化策略生成器
+
+        Args:
+            llm_client: LLM 客户端 (默认使用 LLMGateway)
+            code_sandbox: 代码沙箱（用于验证）
+            temperature: 生成温度
+            max_tokens: 最大 token 数
+        """
+        if llm_client is None:
+            from QuantNodes.ai.llm.gateway import get_llm_gateway
+            llm_client = get_llm_gateway()
+        self.llm = llm_client
+        self.sandbox = code_sandbox or CodeSandbox()
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.extra_config = kwargs
+        self.logger = logging.getLogger(f"strategy.{self.__class__.__name__}")
+
+    def generate(
+        self,
+        description: str,
+        validate: bool = True,
+        context: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> GenerationResult:
+        """
+        生成策略代码
+
+        Args:
+            description: 策略描述
+            validate: 是否验证代码
+            context: 额外上下文
+            **kwargs: 额外参数
+
+        Returns:
+            GenerationResult 生成结果
+        """
+        try:
+            system_prompt, user_prompt = PromptLibrary.format(
+                "strategy_generation",
+                trading_description=description
+            )
+
+            messages = [
+                Message(role=MessageRole.SYSTEM, content=system_prompt),
+                Message(role=MessageRole.USER, content=user_prompt),
+            ]
+
+            response = self.llm.chat(
+                messages=messages,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+                **kwargs
+            )
+
+            if not response:
+                return GenerationResult(
+                    code="",
+                    is_valid=False,
+                    error_message="No response from LLM"
+                )
+
+            code = self._extract_code(response.content)
+
+            if not code:
+                return GenerationResult(
+                    code="",
+                    is_valid=False,
+                    error_message="No code found in response"
+                )
+
+            validation_result = None
+            if validate:
+                validation_result = self.sandbox.validate(code)
+                if not validation_result.is_safe:
+                    return GenerationResult(
+                        code=code,
+                        is_valid=False,
+                        validation_result=validation_result,
+                        error_message=f"Code validation failed: {validation_result.errors}"
+                    )
+
+            return GenerationResult(
+                code=code,
+                is_valid=True,
+                validation_result=validation_result,
+                warnings=validation_result.warnings if validation_result else []
+            )
+
+        except Exception as e:
+            self.logger.error(f"Generation failed: {e}")
+            return GenerationResult(
+                code="",
+                is_valid=False,
+                error_message=str(e)
+            )
+
+    def _extract_code(self, content: str) -> str:
+        """从响应中提取代码"""
+        matches = self.CODE_BLOCK_PATTERN.findall(content)
+        if matches:
+            return matches[0].strip()
+
+        if '```' in content:
+            return ""
+
+        lines = content.split('\n')
+        code_lines = []
+        in_code = False
+
+        for line in lines:
+            if line.startswith('```'):
+                in_code = not in_code
+                continue
+            starts_code = (
+                line.startswith('import ') or line.startswith('from ')
+                or line.startswith('#')
+            )
+            if in_code or starts_code:
+                code_lines.append(line)
+
+        if code_lines:
+            return '\n'.join(code_lines)
+
+        return content.strip()
+
+    def generate_with_refinement(
+        self,
+        description: str,
+        max_iterations: int = 3,
+        **kwargs
+    ) -> GenerationResult:
+        """
+        带精化的生成（自动修复问题）
+
+        Args:
+            description: 策略描述
+            max_iterations: 最大迭代次数
+            **kwargs: 额外参数
+
+        Returns:
+            GenerationResult 生成结果
+        """
+        result = self.generate(description, validate=True, **kwargs)
+
+        for iteration in range(max_iterations):
+            if result.is_valid:
+                return result
+
+            if not result.validation_result:
+                break
+
+            if result.validation_result.warnings_only:
+                refinement_prompt = (
+                    f"Refine the following code to address warnings:\n\n"
+                    f"{result.code}\n\n"
+                    f"Warnings: {result.validation_result.warnings}"
+                )
+                result = self._refine_code(refinement_prompt, **kwargs)
+            else:
+                refinement_prompt = (
+                    f"Fix the following code errors:\n\n"
+                    f"{result.code}\n\n"
+                    f"Errors: {result.validation_result.errors}"
+                )
+                result = self._refine_code(refinement_prompt, **kwargs)
+
+        return result
+
+    def _refine_code(self, refinement_prompt: str, **kwargs) -> GenerationResult:
+        """精化代码"""
+        messages = [
+            Message(role=MessageRole.SYSTEM, content=PromptLibrary.get_system_prompt()),
+            Message(role=MessageRole.USER, content=refinement_prompt),
+        ]
+
+        try:
+            response = self.llm.chat(
+                messages=messages,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+                **kwargs
+            )
+
+            if not response:
+                return GenerationResult(
+                    code="",
+                    is_valid=False,
+                    error_message="No response from LLM"
+                )
+
+            code = self._extract_code(response.content)
+            validation_result = self.sandbox.validate(code)
+
+            return GenerationResult(
+                code=code,
+                is_valid=validation_result.is_safe,
+                validation_result=validation_result,
+                error_message=(
+                    None if validation_result.is_safe
+                    else f"Validation failed: {validation_result.errors}"
+                ),
+                warnings=validation_result.warnings
+            )
+
+        except Exception as e:
+            return GenerationResult(
+                code="",
+                is_valid=False,
+                error_message=str(e)
+            )
+
+    def review(
+        self,
+        code: str,
+        **kwargs
+    ) -> str:
+        """
+        审查代码
+
+        Args:
+            code: 待审查的代码
+            **kwargs: 额外参数
+
+        Returns:
+            str 审查意见
+        """
+        messages = [
+            Message(role=MessageRole.SYSTEM, content=PromptLibrary.get_system_prompt()),
+            Message(
+                role=MessageRole.USER,
+                content=f"Review the following QuantNodes code:\n\n{code}",
+            ),
+        ]
+
+        try:
+            response = self.llm.chat(
+                messages=messages,
+                temperature=0.3,
+                max_tokens=self.max_tokens,
+                **kwargs
+            )
+
+            return response.content if response else "No response"
+
+        except Exception as e:
+            self.logger.error(f"Review failed: {e}")
+            return f"Review failed: {e}"
+
+    def explain_strategy(self, code: str, **kwargs) -> str:
+        """
+        解释策略代码
+
+        Args:
+            code: 策略代码
+            **kwargs: 额外参数
+
+        Returns:
+            str 解释
+        """
+        prompt = (
+            f"Explain what this QuantNodes strategy does:\n\n{code}\n\n"
+            f"Provide a clear explanation of the pipeline and its components."
+        )
+
+        messages = [
+            Message(role=MessageRole.SYSTEM, content=PromptLibrary.get_system_prompt()),
+            Message(role=MessageRole.USER, content=prompt),
+        ]
+
+        try:
+            response = self.llm.chat(
+                messages=messages,
+                temperature=0.3,
+                max_tokens=self.max_tokens,
+                **kwargs
+            )
+
+            return response.content if response else "No response"
+
+        except Exception as e:
+            self.logger.error(f"Explanation failed: {e}")
+            return f"Explanation failed: {e}"
+
+
+class NaturalLanguageToPipeline:
+    """
+    自然语言转 Pipeline 工具
+
+    提供更高级的 Pipeline 生成接口。
+    """
+
+    def __init__(
+        self,
+        llm_client=None,
+        code_sandbox: Optional[CodeSandbox] = None,
+        **kwargs
+    ):
+        """
+        初始化转换器
+
+        Args:
+            llm_client: LLM 客户端 (默认使用 LLMGateway)
+            code_sandbox: 代码沙箱
+        """
+        if llm_client is None:
+            from QuantNodes.ai.llm.gateway import get_llm_gateway
+            llm_client = get_llm_gateway()
+        self.generator = StrategyGenerator(llm_client, code_sandbox, **kwargs)
+
+    def convert(
+        self,
+        description: str,
+        return_pipeline: bool = False,
+        **kwargs
+    ) -> Union[GenerationResult, Any]:
+        """
+        转换自然语言为 Pipeline
+
+        Args:
+            description: 策略描述
+            return_pipeline: 是否返回可执行的 Pipeline 对象
+            **kwargs: 额外参数
+
+        Returns:
+            GenerationResult 或 Pipeline 对象
+        """
+        result = self.generator.generate_with_refinement(description, **kwargs)
+
+        if return_pipeline and result.is_valid:
+            try:
+                return self._execute_code(result.code)
+            except Exception as e:
+                result.warnings.append(f"Failed to execute code: {e}")
+                return result
+
+        return result
+
+    def _execute_code(self, code: str):
+        """执行代码并返回 Pipeline"""
+        context = {
+            'QuantNodes': __import__('QuantNodes'),
+        }
+        exec_globals = self.generator.sandbox.validate_and_execute(code, context)
+        return exec_globals

QuantNodes/backtest/__init__.py

@@ -0,0 +1,64 @@
+# coding=utf-8
+"""
+Backtest module for QuantNodes.
+
+BaseNode-integrated backtest components.
+"""
+
+from QuantNodes.backtest.backtest_node import (
+    BacktestNode,
+    BacktestResult,
+    BacktestPipeline,
+)
+from QuantNodes.backtest.strategy_node import (
+    StrategyNode,
+    Order,
+    Signal,
+    OrdersResult,
+    MAStrategyNode,
+    MomentumStrategyNode,
+)
+from QuantNodes.backtest.broker_node import (
+    BrokerNode,
+    Trade,
+    TradeResult,
+    SimulatedBrokerNode,
+    ExecutionBrokerNode,
+)
+from QuantNodes.backtest.risk_node import (
+    RiskNode,
+    RiskCheck,
+    RiskResult,
+    PositionLimitRiskNode,
+    StopLossRiskNode,
+    CashRiskNode,
+    CompositeRiskNode,
+)
+from QuantNodes.backtest.config_strategy import ConfigStrategyNode
+from QuantNodes.backtest.config_runner import ConfigBacktestRunner
+
+__all__ = [
+    'BacktestNode',
+    'BacktestResult',
+    'BacktestPipeline',
+    'StrategyNode',
+    'Order',
+    'Signal',
+    'OrdersResult',
+    'MAStrategyNode',
+    'MomentumStrategyNode',
+    'BrokerNode',
+    'Trade',
+    'TradeResult',
+    'SimulatedBrokerNode',
+    'ExecutionBrokerNode',
+    'RiskNode',
+    'RiskCheck',
+    'RiskResult',
+    'PositionLimitRiskNode',
+    'StopLossRiskNode',
+    'CashRiskNode',
+    'CompositeRiskNode',
+    'ConfigStrategyNode',
+    'ConfigBacktestRunner',
+]

QuantNodes/backtest/backtest_node.py

@@ -0,0 +1,188 @@
+# coding=utf-8
+"""
+BacktestNode - 回测引擎节点基类
+
+提供回测引擎节点的基础架构，继承自 BaseNode。
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+
+import pandas as pd
+
+from QuantNodes.core.node import BaseNode
+
+
+@dataclass
+class BacktestResult:
+    """回测结果容器"""
+    positions: pd.DataFrame = field(default_factory=pd.DataFrame)
+    trades: pd.DataFrame = field(default_factory=pd.DataFrame)
+    orders: pd.DataFrame = field(default_factory=pd.DataFrame)
+    equity_curve: pd.DataFrame = field(default_factory=pd.DataFrame)
+    statistics: Dict[str, Any] = field(default_factory=dict)
+    final_cash: float = 0.0
+    final_positions: Dict[str, float] = field(default_factory=dict)
+    total_return: float = 0.0
+    sharpe_ratio: float = 0.0
+    max_drawdown: float = 0.0
+    win_rate: float = 0.0
+
+
+class BacktestNode(BaseNode[pd.DataFrame, BacktestResult], ABC):
+    """
+    回测引擎节点基类
+
+    提供统一的回测执行接口。
+
+    Subclasses must implement:
+        _run_backtest(): 执行具体回测逻辑
+
+    Examples:
+        >>> backtest = BacktestNode(config={
+        ...     'cash': 100000,
+        ...     'commission': 0.001,
+        ...     'margin': 0.1
+        ... })
+        >>> result = backtest.execute(data)
+    """
+
+    _enable_validation: bool = True
+    _enable_stats: bool = True
+
+    def __init__(self, name: str = None, config: Dict[str, Any] = None, **kwargs):
+        default_name = f"{self.__class__.__name__}"
+        super().__init__(name=name or default_name, config=config, **kwargs)
+
+        self._result: Optional[BacktestResult] = None
+        self._cash: float = self.config.get('cash', 100000)
+        self._commission: float = self.config.get('commission', 0.001)
+        self._margin: float = self.config.get('margin', 0.1)
+        self._trade_on_close: bool = self.config.get('trade_on_close', False)
+        self._hedging: bool = self.config.get('hedging', False)
+
+    @abstractmethod
+    def _run_backtest(
+        self,
+        quote_data: pd.DataFrame,
+        signals: pd.DataFrame,
+        **kwargs
+    ) -> BacktestResult:
+        """
+        执行具体回测逻辑
+
+        Args:
+            quote_data: 行情数据 DataFrame
+            signals: 交易信号 DataFrame
+            **kwargs: 额外执行参数
+
+        Returns:
+            回测结果 BacktestResult
+        """
+        pass
+
+    def _execute(
+        self,
+        input_data: Union[pd.DataFrame, tuple, None] = None,
+        **kwargs
+    ) -> BacktestResult:
+        """
+        执行回测
+
+        Args:
+            input_data: 输入数据，可以是：
+                - pd.DataFrame: 行情数据
+                - tuple: (quote_data, signals) 元组
+                - None: 使用 config 中的默认数据
+            **kwargs: 额外执行参数
+
+        Returns:
+            BacktestResult 回测结果
+        """
+        if input_data is None:
+            quote_data = kwargs.get('quote_data')
+            signals = kwargs.get('signals')
+        elif isinstance(input_data, pd.DataFrame):
+            quote_data = input_data
+            signals = kwargs.get('signals')
+        elif isinstance(input_data, tuple) and len(input_data) == 2:
+            quote_data, signals = input_data
+        else:
+            raise ValueError(
+                f"input_data must be DataFrame or (quote_data, signals) tuple, "
+                f"got {type(input_data).__name__}"
+            )
+
+        if quote_data is None:
+            raise ValueError("quote_data is required")
+
+        self._result = self._run_backtest(quote_data, signals, **kwargs)
+        return self._result
+
+    def _validate_input(self, input_data: Any) -> None:
+        """验证输入数据"""
+        if input_data is None:
+            return
+
+        if isinstance(input_data, tuple):
+            quote_data, signals = input_data
+            if not isinstance(quote_data, pd.DataFrame):
+                raise ValueError(f"quote_data must be DataFrame, got {type(quote_data).__name__}")
+        elif isinstance(input_data, pd.DataFrame):
+            pass
+        else:
+            raise ValueError(
+                f"input_data must be DataFrame or tuple, got {type(input_data).__name__}"
+            )
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """获取回测统计信息"""
+        if self._result is None:
+            return {}
+        return self._result.statistics
+
+    def get_equity_curve(self) -> pd.DataFrame:
+        """获取权益曲线"""
+        if self._result is None:
+            return pd.DataFrame()
+        return self._result.equity_curve
+
+    def reset(self) -> None:
+        """重置回测状态"""
+        super().reset()
+        self._result = None
+
+
+class BacktestPipeline:
+    """
+    回测管道
+
+    将多个回测节点组合在一起执行。
+    """
+
+    def __init__(self, nodes: List[BacktestNode]):
+        self.nodes = nodes
+
+    def execute(
+        self,
+        input_data: Any = None,
+        **kwargs
+    ) -> List[BacktestResult]:
+        """执行所有回测节点"""
+        results = []
+        current_data = input_data
+
+        for node in self.nodes:
+            result = node.execute(current_data, **kwargs)
+            results.append(result)
+            current_data = result
+
+        return results
+
+    def __rshift__(self, other: BacktestNode) -> 'BacktestPipeline':
+        """重载 >> 运算符"""
+        if isinstance(other, BacktestPipeline):
+            return BacktestPipeline(self.nodes + other.nodes)
+        return BacktestPipeline(self.nodes + [other])