quantnodes 3.0.0__py3-none-any.whl

QuantNodes/operators/templates.py

@@ -0,0 +1,95 @@
+# coding=utf-8
+"""
+operators.templates - 算子模板工厂
+
+基于现有算子创建固定参数变体。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from polars import Expr
+
+
+class OperatorTemplate:
+    """基于现有算子创建变体的模板"""
+
+    def __init__(
+        self,
+        name: str,
+        category: str,
+        template: str,
+        defaults: Optional[Dict[str, Any]] = None,
+    ):
+        """初始化模板
+
+        Args:
+            name: 新算子名称
+            category: 算子分类 (point, time, section, multi_section, talib)
+            template: 模板算子名称
+            defaults: 默认参数字典
+        """
+        self._name = name
+        self._category = category
+        self._template = template
+        self._defaults = defaults or {}
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def category(self) -> str:
+        return self._category
+
+    @property
+    def template(self) -> str:
+        return self._template
+
+    @property
+    def defaults(self) -> Dict[str, Any]:
+        return self._defaults.copy()
+
+    def __call__(self, f: Union[Expr, str], **kwargs) -> Expr:
+        """调用时执行模板算子，自动注入默认值"""
+        from QuantNodes.factor_node.factor_functions import get_operator
+
+        template_func = get_operator(self._template, self._category)
+        if template_func is None:
+            raise ValueError(
+                f"Template operator '{self._template}' not found in category '{self._category}'"
+            )
+
+        merged_kwargs = {**self._defaults, **kwargs}
+        return template_func(f, **merged_kwargs)
+
+    def register(self) -> "OperatorTemplate":
+        """将模板注册为新的命名算子"""
+        from QuantNodes.operators.registry import _CustomOperatorRegistry
+
+        def _template_wrapper(f: Union[Expr, str], **kwargs) -> Expr:
+            return self(f, **kwargs)
+
+        _template_wrapper.__name__ = self._name
+        _template_wrapper.__qualname__ = f"OperatorTemplate.{self._name}"
+        _template_wrapper.__doc__ = (
+            f"基于 {self._template} 的模板算子，默认参数: {self._defaults}"
+        )
+
+        _CustomOperatorRegistry.register(
+            self._category,
+            self._name,
+            _template_wrapper,
+            doc=_template_wrapper.__doc__,
+            params={"template": self._template, "defaults": self._defaults},
+        )
+
+        return self
+
+    def __repr__(self) -> str:
+        return (
+            f"OperatorTemplate(name={self._name!r}, "
+            f"template={self._template!r}, "
+            f"defaults={self._defaults})"
+        )

QuantNodes/operators/time_series.py

@@ -0,0 +1,136 @@
+# coding=utf-8
+"""
+时间序列算子（代理层）
+
+基于 factor_functions/time_ops.py 的实现，提供统一的类接口。
+
+Available Operators:
+    - ts_mean: 滚动均值
+    - ts_std: 滚动标准差
+    - ts_max: 滚动最大值
+    - ts_min: 滚动最小值
+    - ts_sum: 滚动求和
+    - ts_median: 滚动中位数
+    - ts_corr: 滚动相关系数
+    - ts_cov: 滚动协方差
+    - ts_rank: 滚动排名
+    - ts_delta: 差分
+    - ts_pct_change: 百分比变化
+    - ts_lag: 滞后
+    - ts_shift: 前向移动
+    - ts_lead: 后向移动
+    - ts_prod: 滚动求积
+    - ewm_mean: 指数加权移动平均
+    - ewm_std: 指数加权移动标准差
+    - ewm_corr: 指数加权相关系数
+
+Usage:
+    >>> ts.ts_mean(pl.col("close"), 20)
+    >>> ts.ts_std(pl.col("close"), 20)
+    >>> ts.ts_corr(pl.col("close"), pl.col("volume"), 20)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union, Optional
+
+from polars import Expr
+
+if TYPE_CHECKING:
+    pass
+
+from QuantNodes.factor_node.factor_functions.time_ops import (
+    ts_mean as _ts_mean,
+    ts_std as _ts_std,
+    ts_max as _ts_max,
+    ts_min as _ts_min,
+    ts_sum as _ts_sum,
+    rolling_prod as _ts_prod,
+    ts_median as _ts_median,
+    ts_corr as _ts_corr,
+    ts_cov as _ts_cov,
+    ts_rank as _ts_rank,
+    ts_delta as _ts_delta,
+    ts_pct_change as _ts_pct_change,
+    ts_lag as _ts_lag,
+    ts_lead as _ts_lead,
+    ewm_mean as _ewm_mean,
+    ewm_std as _ewm_std,
+    ewm_corr as _ewm_corr,
+)
+
+
+class TimeSeriesOperators:
+    """时间序列算子（代理层）"""
+
+    @staticmethod
+    def ts_mean(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_mean(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_std(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None, ddof: int = 1) -> Expr:
+        return _ts_std(expr, window=window, min_periods=min_periods, ddof=ddof)
+
+    @staticmethod
+    def ts_max(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_max(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_min(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_min(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_sum(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_sum(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_prod(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_prod(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_median(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_median(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_corr(expr_a: Union[Expr, str], expr_b: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_corr(expr_a, expr_b, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_cov(expr_a: Union[Expr, str], expr_b: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_cov(expr_a, expr_b, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_rank(expr: Union[Expr, str], window: int = 20, min_periods: Optional[int] = None) -> Expr:
+        return _ts_rank(expr, window=window, min_periods=min_periods)
+
+    @staticmethod
+    def ts_delta(expr: Union[Expr, str], periods: int = 1) -> Expr:
+        return _ts_delta(expr, periods=periods)
+
+    @staticmethod
+    def ts_pct_change(expr: Union[Expr, str], periods: int = 1) -> Expr:
+        return _ts_pct_change(expr, periods=periods)
+
+    @staticmethod
+    def ts_lag(expr: Union[Expr, str], periods: int = 1) -> Expr:
+        return _ts_lag(expr, periods=periods)
+
+    @staticmethod
+    def ts_shift(expr: Union[Expr, str], periods: int = 1) -> Expr:
+        return _ts_lag(expr, periods=periods)
+
+    @staticmethod
+    def ts_lead(expr: Union[Expr, str], periods: int = 1) -> Expr:
+        return _ts_lead(expr, periods=periods)
+
+    @staticmethod
+    def ewm_mean(expr: Union[Expr, str], alpha: float = 0.5, adjust: bool = True) -> Expr:
+        return _ewm_mean(expr, alpha=alpha, adjust=adjust)
+
+    @staticmethod
+    def ewm_std(expr: Union[Expr, str], alpha: float = 0.5, adjust: bool = True) -> Expr:
+        return _ewm_std(expr, alpha=alpha, adjust=adjust)
+
+    @staticmethod
+    def ewm_corr(expr_a: Union[Expr, str], expr_b: Union[Expr, str], alpha: float = 0.5) -> Expr:
+        return _ewm_corr(expr_a, expr_b, alpha=alpha)

QuantNodes/prompts/__init__.py

@@ -0,0 +1,20 @@
+# coding=utf-8
+"""
+QuantNodes Prompts Package
+
+Complete prompts for external agents with reference code.
+"""
+
+from .strategy.momentum import MOMENTUM_PROMPT
+from .strategy.mean_reversion import MEAN_REVERSION_PROMPT
+from .strategy.trend_following import TREND_FOLLOWING_PROMPT
+from .strategy.pairs_trading import PAIRS_TRADING_PROMPT
+from .strategy.market_neutral import MARKET_NEUTRAL_PROMPT
+
+__all__ = [
+    "MOMENTUM_PROMPT",
+    "MEAN_REVERSION_PROMPT",
+    "TREND_FOLLOWING_PROMPT",
+    "PAIRS_TRADING_PROMPT",
+    "MARKET_NEUTRAL_PROMPT",
+]

QuantNodes/prompts/backtest/__init__.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+"""
+Backtest Prompts
+"""
+
+from .standard import STANDARD_BACKTEST_PROMPT
+from .factor_based import FACTOR_BACKTEST_PROMPT
+
+__all__ = [
+    "STANDARD_BACKTEST_PROMPT",
+    "FACTOR_BACKTEST_PROMPT",
+]

QuantNodes/prompts/backtest/factor_based.py

@@ -0,0 +1,86 @@
+# coding=utf-8
+"""
+Factor-Based Backtest Prompt
+
+Complete prompt for running factor-based backtests.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class BacktestPrompt:
+    version: str = "1.0.0"
+    name: str = "factor_based"
+    description: str = "因子回测"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化回测专家，擅长运行因子回测。
+
+## 因子回测流程
+1. 计算因子值
+2. 根据因子值排序分组
+3. 计算各组收益率
+4. 分析因子有效性
+
+## 参数说明
+- `factor_code`: 计算因子的代码，必须将结果赋给 result 变量
+- `start_date`: 回测开始日期
+- `end_date`: 回测结束日期
+- `num_groups`: 分组数量 (默认5组)
+
+## result 数据格式
+result 必须是 DataFrame (Polars 或 Pandas 均可)，包含：
+- date: 日期
+- code: 标的代码
+- factor_value: 因子值
+- forward_return: 未来收益
+
+## 参考代码 (Polars)
+```python
+import polars as pl
+
+result = pl.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+
+## 参考代码 (Pandas)
+```python
+import pandas as pd
+
+result = pd.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["factor_code", "start_date", "end_date", "num_groups"]
+
+    @property
+    def output_format(self) -> str:
+        return "factor_backtest_result"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 300,
+            "allowed_imports": ["polars", "numpy", "pandas"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["result"]
+        }
+
+
+FACTOR_BACKTEST_PROMPT = BacktestPrompt()

QuantNodes/prompts/backtest/standard.py

@@ -0,0 +1,73 @@
+# coding=utf-8
+"""
+Standard Backtest Prompt
+
+Complete prompt for running standard backtests.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class BacktestPrompt:
+    version: str = "1.0.0"
+    name: str = "standard"
+    description: str = "标准回测"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化回测专家，擅长运行标准回测。
+
+## 回测流程
+1. 准备历史价格数据
+2. 创建策略实例
+3. 创建经纪商实例
+4. 运行回测获取结果
+
+## 参数说明
+- `start_date`: 回测开始日期 (YYYY-MM-DD)
+- `end_date`: 回测结束日期 (YYYY-MM-DD)
+- `initial_cash`: 初始资金 (默认 100000)
+- `commission`: 手续费率 (默认 0.001)
+
+## 约束
+- 策略代码必须安全，使用 CodeSandbox 验证
+- 必须创建 strategy, broker, quote_data 变量
+- quote_data 必须包含 date, close 列
+
+## 参考代码框架
+```python
+import pandas as pd
+import numpy as np
+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': 1000000, 'commission': 0.001})
+
+quote_data = pd.read_csv('data.csv')
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["pipeline_code", "start_date", "end_date"]
+
+    @property
+    def output_format(self) -> str:
+        return "backtest_result"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 300,
+            "allowed_imports": ["numpy", "pandas"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["strategy", "broker", "quote_data"]
+        }
+
+
+STANDARD_BACKTEST_PROMPT = BacktestPrompt()

QuantNodes/prompts/factor/__init__.py

@@ -0,0 +1,14 @@
+# coding=utf-8
+"""
+Factor Prompts
+"""
+
+from .ic_analysis import IC_ANALYSIS_PROMPT
+from .group_backtest import GROUP_BACKTEST_PROMPT
+from .correlation import CORRELATION_PROMPT
+
+__all__ = [
+    "IC_ANALYSIS_PROMPT",
+    "GROUP_BACKTEST_PROMPT",
+    "CORRELATION_PROMPT",
+]

QuantNodes/prompts/factor/correlation.py

@@ -0,0 +1,77 @@
+# coding=utf-8
+"""
+Correlation Analysis Prompt
+
+Complete prompt for factor correlation analysis.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class FactorPrompt:
+    version: str = "1.0.0"
+    name: str = "correlation"
+    description: str = "相关性分析"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个因子分析专家，擅长相关性分析。
+
+## 相关性分析说明
+分析因子之间的相关性，避免高度相关的因子同时使用。
+- 因子相关性高：冗余，增加风险
+- 因子相关性低：互补，分散风险
+
+## 参数说明
+- `factor_code`: 计算因子的代码
+- `correlation_threshold`: 相关性阈值 (默认0.8)
+
+## result 数据格式
+result 必须是 DataFrame (Polars 或 Pandas 均可)，包含多列因子值
+
+## 参考代码 (Polars)
+```python
+import polars as pl
+
+result = pl.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02"],
+    "factor_a": [0.1, 0.2, 0.3],
+    "factor_b": [0.15, 0.25, 0.35],
+})
+```
+
+## 参考代码 (Pandas)
+```python
+import pandas as pd
+
+result = pd.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02"],
+    "factor_a": [0.1, 0.2, 0.3],
+    "factor_b": [0.15, 0.25, 0.35],
+})
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["factor_code", "correlation_threshold"]
+
+    @property
+    def output_format(self) -> str:
+        return "correlation_result"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 200,
+            "allowed_imports": ["polars", "numpy", "pandas"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["result"]
+        }
+
+
+CORRELATION_PROMPT = FactorPrompt()

QuantNodes/prompts/factor/group_backtest.py

@@ -0,0 +1,86 @@
+# coding=utf-8
+"""
+Group Backtest Prompt
+
+Complete prompt for group-based backtest analysis.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class FactorPrompt:
+    version: str = "1.0.0"
+    name: str = "group_backtest"
+    description: str = "分组回测"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个因子分析专家，擅长分组回测。
+
+## 分组回测说明
+分组回测是检验因子有效性的经典方法：
+1. 按因子值将股票分成N组
+2. 持有各组一定时间
+3. 计算各组收益率差异
+
+## 参数说明
+- `factor_code`: 计算因子的代码
+- `num_groups`: 分组数量 (通常5组)
+- `start_date`: 回测开始日期
+- `end_date`: 回测结束日期
+
+## result 数据格式
+result 必须是 DataFrame (Polars 或 Pandas 均可)，包含：
+- date: 日期
+- code: 标的代码
+- factor_value: 因子值
+- forward_return: 未来收益
+
+## 参考代码 (Polars)
+```python
+import polars as pl
+
+result = pl.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+
+## 参考代码 (Pandas)
+```python
+import pandas as pd
+
+result = pd.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["factor_code", "num_groups", "start_date", "end_date"]
+
+    @property
+    def output_format(self) -> str:
+        return "group_backtest_result"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 200,
+            "allowed_imports": ["polars", "numpy", "pandas"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["result"]
+        }
+
+
+GROUP_BACKTEST_PROMPT = FactorPrompt()

QuantNodes/prompts/factor/ic_analysis.py

@@ -0,0 +1,91 @@
+# coding=utf-8
+"""
+IC Analysis Prompt
+
+Complete prompt for IC (Information Coefficient) analysis.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class FactorPrompt:
+    version: str = "1.0.0"
+    name: str = "ic_analysis"
+    description: str = "IC分析"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个因子分析专家，擅长IC分析。
+
+## IC分析说明
+IC (Information Coefficient) 衡量因子预测能力。
+- IC > 0 表示因子与收益正相关
+- IC < 0 表示因子与收益负相关
+- |IC| 越大表示预测能力越强
+
+## IC指标
+- IC Mean: IC时间序列均值
+- IC Std: IC时间序列标准差
+- ICIR: IC Mean / IC Std (信息比)
+- Rank IC Mean: 秩相关系数均值
+
+## 参数说明
+- `factor_code`: 计算因子的代码，必须将结果赋给 result 变量
+- `start_date`: 分析开始日期
+- `end_date`: 分析结束日期
+
+## result 数据格式
+result 必须是 DataFrame (Polars 或 Pandas 均可)，包含：
+- date: 日期
+- code: 标的代码
+- factor_value: 因子值
+- forward_return: 未来收益
+
+## 参考代码 (Polars)
+```python
+import polars as pl
+
+result = pl.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+
+## 参考代码 (Pandas)
+```python
+import pandas as pd
+
+result = pd.DataFrame({
+    "date": ["2024-01-01", "2024-01-01", "2024-01-02", "2024-01-02"],
+    "code": ["A", "B", "A", "B"],
+    "factor_value": [0.1, 0.2, 0.3, 0.4],
+    "forward_return": [0.05, 0.03, 0.02, 0.01],
+})
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["factor_code", "start_date", "end_date"]
+
+    @property
+    def output_format(self) -> str:
+        return "ic_analysis_result"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 200,
+            "allowed_imports": ["polars", "numpy", "pandas"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["result"]
+        }
+
+
+IC_ANALYSIS_PROMPT = FactorPrompt()