quantnodes 3.0.0__py3-none-any.whl

QuantNodes/prompts/strategy/__init__.py

@@ -0,0 +1,18 @@
+# coding=utf-8
+"""
+Strategy Prompts
+"""
+
+from .momentum import MOMENTUM_PROMPT
+from .mean_reversion import MEAN_REVERSION_PROMPT
+from .trend_following import TREND_FOLLOWING_PROMPT
+from .pairs_trading import PAIRS_TRADING_PROMPT
+from .market_neutral import MARKET_NEUTRAL_PROMPT
+
+__all__ = [
+    "MOMENTUM_PROMPT",
+    "MEAN_REVERSION_PROMPT",
+    "TREND_FOLLOWING_PROMPT",
+    "PAIRS_TRADING_PROMPT",
+    "MARKET_NEUTRAL_PROMPT",
+]

QuantNodes/prompts/strategy/market_neutral.py

@@ -0,0 +1,96 @@
+# coding=utf-8
+"""
+Market Neutral Strategy Prompt
+
+Complete prompt for generating market neutral strategies with reference code.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class StrategyPrompt:
+    version: str = "1.0.0"
+    name: str = "market_neutral"
+    description: str = "市场中性策略生成"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化策略专家，专注于市场中性策略。
+
+## 策略逻辑
+市场中性策略旨在消除市场系统性风险，获取alpha收益。
+核心思想：
+1. 同时持有多头和空头仓位
+2. 确保投资组合对市场涨跌的暴露为0
+3. 通过选股能力获取超额收益
+
+## 参数说明
+- `symbols`: 标的列表
+- `lookback`: 计算因子和风险的回看窗口
+- `long_short_ratio`: 多空仓比例 (如 0.5 表示一半多头一半空头)
+- `risk_factor`: 对冲用的风险因子 (如 "market")
+
+## 输出要求
+生成完整的 Python 代码"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["symbols", "lookback", "long_short_ratio"]
+
+    @property
+    def output_format(self) -> str:
+        return "python_code"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 700,
+            "allowed_imports": ["numpy", "pandas", "talib"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["strategy", "quote_data"],
+            "required_classes": ["StrategyNode"]
+        }
+
+    @property
+    def example_code(self) -> str:
+        return '''import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class MarketNeutralStrategyNode(StrategyNode):
+    """市场中性策略节点
+
+    通过多空对冲消除市场风险
+    """
+    def __init__(self, config: dict = None):
+        self.lookback = config.get('lookback', 20) if config else 20
+        self.long_short_ratio = config.get('long_short_ratio', 0.5) if config else 0.5
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        returns = data.pct_change()
+
+        signal = pd.Series(0, index=data.index)
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = []
+        return result
+
+
+strategy = MarketNeutralStrategyNode(config={
+    'lookback': 20,
+    'long_short_ratio': 0.5
+})
+
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close': np.random.randn(100).cumsum() + 100
+})
+'''
+
+
+MARKET_NEUTRAL_PROMPT = StrategyPrompt()

QuantNodes/prompts/strategy/mean_reversion.py

@@ -0,0 +1,107 @@
+# coding=utf-8
+"""
+Mean Reversion Strategy Prompt
+
+Complete prompt for generating mean reversion strategies with reference code.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class StrategyPrompt:
+    version: str = "1.0.0"
+    name: str = "mean_reversion"
+    description: str = "均值回归策略生成"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化策略专家，专注于均值回归策略。
+
+## 策略逻辑
+均值回归策略基于"价格围绕价值波动"的假设，当价格偏离均值时迟早会回归。
+核心思想：
+1. 计算移动平均线作为均值
+2. 当价格偏离均值超过阈值时做相反方向的交易
+3. 预期价格会回归到均值
+
+## 参数说明
+- `symbol`: 交易标的代码
+- `window`: 计算均值的窗口大小
+- `std_threshold`: 标准差阈值 (如 2.0 表示2个标准差)
+
+## 输出要求
+生成完整的 Python 代码，包含：
+1. 导入必要的库
+2. 定义均值回归策略类继承 StrategyNode
+3. 返回交易信号
+
+## 约束
+- 代码必须安全，不能包含危险操作
+- 必须创建名为 `strategy` 的 StrategyNode 变量
+- 必须创建名为 `quote_data` 的 DataFrame 变量
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["symbol", "window", "std_threshold"]
+
+    @property
+    def output_format(self) -> str:
+        return "python_code"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 500,
+            "allowed_imports": ["numpy", "pandas", "talib"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["strategy", "quote_data"],
+            "required_classes": ["StrategyNode"]
+        }
+
+    @property
+    def example_code(self) -> str:
+        return '''import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class MeanReversionStrategyNode(StrategyNode):
+    """均值回归策略节点
+
+    当价格偏离均值超过阈值时反向交易
+    """
+    def __init__(self, config: dict = None):
+        self.window = config.get('window', 20) if config else 20
+        self.std_threshold = config.get('std_threshold', 2.0) if config else 2.0
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        close = data['close']
+        ma = close.rolling(window=self.window).mean()
+        std = close.rolling(window=self.window).std()
+
+        z_score = (close - ma) / (std + 1e-8)
+
+        signal = pd.Series(0, index=data.index)
+        signal[z_score < -self.std_threshold] = 1
+        signal[z_score > self.std_threshold] = -1
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = []
+        return result
+
+
+strategy = MeanReversionStrategyNode(config={'window': 20, 'std_threshold': 2.0})
+
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close': np.random.randn(100).cumsum() + 100
+})
+'''
+
+
+MEAN_REVERSION_PROMPT = StrategyPrompt()

QuantNodes/prompts/strategy/momentum.py

@@ -0,0 +1,160 @@
+# coding=utf-8
+"""
+Momentum Strategy Prompt
+
+Complete prompt for generating momentum strategies with reference code.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class StrategyPrompt:
+    version: str = "1.0.0"
+    name: str = "momentum"
+    description: str = "动量策略生成"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化策略专家，专注于动量策略。
+
+## 策略逻辑
+动量策略基于"强者恒强"的假设，过去表现良好的资产未来继续表现良好。
+核心思想：
+1. 计算一定时间窗口的收益率
+2. 买入收益率最高的资产
+3. 持有一定时间后重新平衡
+
+## 参数说明
+- `symbol`: 交易标的代码 (如 "BTC", "ETH", "AAPL")
+- `window`: 计算动量的回看窗口 (如 20 表示过去20天)
+- `threshold`: 触发交易的阈值 (如 0.05 表示5%)
+
+## 输出要求
+生成完整的 Python 代码，包含：
+1. 导入必要的库 (pandas, numpy)
+2. 定义策略函数 `momentum_strategy(data, window, threshold)`
+3. 返回交易信号 (1=买入, -1=卖出, 0=持有)
+4. 包含完整的 docstring
+
+## 约束
+- 代码必须安全，不能包含 os, subprocess, eval 等危险操作
+- 必须创建名为 `strategy` 的 StrategyNode 变量
+- 必须创建名为 `quote_data` 的 DataFrame 变量
+- 使用 QuantNodes 回测框架
+
+## 参考代码框架
+```python
+import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class MomentumStrategyNode(StrategyNode):
+    def __init__(self, config: dict = None):
+        self.window = config.get('window', 20)
+        self.threshold = config.get('threshold', 0.05)
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        close = data['close']
+        returns = close.pct_change(self.window)
+        signal = (returns > self.threshold).astype(int)
+        signal[returns < -self.threshold] = -1
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = []
+        return result
+
+# 创建策略实例
+strategy = MomentumStrategyNode(config={
+    'window': 20,
+    'threshold': 0.05
+})
+
+# 示例数据
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close': np.random.randn(100).cumsum() + 100
+})
+```
+"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["symbol", "window", "threshold"]
+
+    @property
+    def output_format(self) -> str:
+        return "python_code"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 500,
+            "allowed_imports": ["numpy", "pandas", "talib"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec", "open("],
+            "required_variables": ["strategy", "quote_data"],
+            "required_classes": ["StrategyNode"]
+        }
+
+    @property
+    def example_code(self) -> str:
+        return '''import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class MomentumStrategyNode(StrategyNode):
+    """动量策略节点
+
+    基于过去N天收益率计算动量信号
+    """
+    def __init__(self, config: dict = None):
+        self.window = config.get('window', 20) if config else 20
+        self.threshold = config.get('threshold', 0.05) if config else 0.05
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        close = data['close']
+        returns = close.pct_change(self.window)
+
+        signal = pd.Series(0, index=data.index)
+        signal[returns > self.threshold] = 1
+        signal[returns < -self.threshold] = -1
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = self._signals_to_orders(signal, data)
+        return result
+
+    def _signals_to_orders(self, signals, data):
+        orders = []
+        position = 0
+        for i, (idx, row) in enumerate(data.iterrows()):
+            sig = signals.iloc[i]
+            if sig != position:
+                if sig == 1:
+                    orders.append({
+                        'date': idx, 'symbol': 'BTC',
+                        'action': 'buy', 'price': row['close'],
+                    })
+                elif sig == -1:
+                    orders.append({
+                        'date': idx, 'symbol': 'BTC',
+                        'action': 'sell', 'price': row['close'],
+                    })
+                position = sig
+        return orders
+
+
+strategy = MomentumStrategyNode(config={'window': 20, 'threshold': 0.05})
+
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close': np.random.randn(100).cumsum() + 100
+})
+'''
+
+
+MOMENTUM_PROMPT = StrategyPrompt()

QuantNodes/prompts/strategy/pairs_trading.py

@@ -0,0 +1,107 @@
+# coding=utf-8
+"""
+Pairs Trading Strategy Prompt
+
+Complete prompt for generating pairs trading strategies with reference code.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class StrategyPrompt:
+    version: str = "1.0.0"
+    name: str = "pairs_trading"
+    description: str = "配对交易策略生成"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化策略专家，专注于配对交易策略。
+
+## 策略逻辑
+配对交易基于两只相关证券之间的价差会回归均值的假设。
+核心思想：
+1. 选择一对高度相关的证券
+2. 当价差偏离均值时，做空高估的、做多低估的
+3. 价差回归时平仓获利
+
+## 参数说明
+- `symbol1`: 第一个标的代码
+- `symbol2`: 第二个标的代码
+- `lookback`: 计算价差均值和标准差的回看窗口
+- `entry_threshold`: 入场阈值 (标准差倍数)
+- `exit_threshold`: 出场阈值
+
+## 输出要求
+生成完整的 Python 代码"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["symbol1", "symbol2", "lookback", "entry_threshold"]
+
+    @property
+    def output_format(self) -> str:
+        return "python_code"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 600,
+            "allowed_imports": ["numpy", "pandas", "talib"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["strategy", "quote_data"],
+            "required_classes": ["StrategyNode"]
+        }
+
+    @property
+    def example_code(self) -> str:
+        return '''import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class PairsTradingStrategyNode(StrategyNode):
+    """配对交易策略节点
+
+    当两只股票的价差偏离均值时进行配对交易
+    """
+    def __init__(self, config: dict = None):
+        self.lookback = config.get('lookback', 20) if config else 20
+        self.entry_threshold = config.get('entry_threshold', 2.0) if config else 2.0
+        self.exit_threshold = config.get('exit_threshold', 0.5) if config else 0.5
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        spread = data['close1'] - data['close2']
+        ma = spread.rolling(window=self.lookback).mean()
+        std = spread.rolling(window=self.lookback).std()
+
+        z_score = (spread - ma) / (std + 1e-8)
+
+        signal = pd.Series(0, index=data.index)
+        signal[z_score > self.entry_threshold] = -1
+        signal[z_score < -self.entry_threshold] = 1
+        signal[abs(z_score) < self.exit_threshold] = 0
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = []
+        return result
+
+
+strategy = PairsTradingStrategyNode(config={
+    'lookback': 20,
+    'entry_threshold': 2.0,
+    'exit_threshold': 0.5
+})
+
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close1': np.random.randn(100).cumsum() + 100,
+    'close2': np.random.randn(100).cumsum() + 100
+})
+'''
+
+
+PAIRS_TRADING_PROMPT = StrategyPrompt()

QuantNodes/prompts/strategy/trend_following.py

@@ -0,0 +1,96 @@
+# coding=utf-8
+"""
+Trend Following Strategy Prompt
+
+Complete prompt for generating trend following strategies with reference code.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class StrategyPrompt:
+    version: str = "1.0.0"
+    name: str = "trend_following"
+    description: str = "趋势跟踪策略生成"
+    created_at: str = "2025-05-14"
+    updated_at: str = "2025-05-14"
+
+    @property
+    def prompt(self) -> str:
+        return """你是一个量化策略专家，专注于趋势跟踪策略。
+
+## 策略逻辑
+趋势跟踪策略旨在捕捉大趋势，一旦趋势形成就持仓直到趋势反转。
+核心思想：
+1. 使用移动平均线判断趋势方向
+2. 当短期均线上穿长期均线时买入 (金叉)
+3. 当短期均线下穿长期均线时卖出 (死叉)
+
+## 参数说明
+- `symbol`: 交易标的代码
+- `short_window`: 短期均线窗口
+- `long_window`: 长期均线窗口
+
+## 输出要求
+生成完整的 Python 代码"""
+
+    @property
+    def required_params(self) -> List[str]:
+        return ["symbol", "short_window", "long_window"]
+
+    @property
+    def output_format(self) -> str:
+        return "python_code"
+
+    @property
+    def validation_rules(self) -> Dict[str, Any]:
+        return {
+            "max_lines": 500,
+            "allowed_imports": ["numpy", "pandas", "talib"],
+            "forbidden_patterns": ["os.", "subprocess", "eval", "exec"],
+            "required_variables": ["strategy", "quote_data"],
+            "required_classes": ["StrategyNode"]
+        }
+
+    @property
+    def example_code(self) -> str:
+        return '''import pandas as pd
+import numpy as np
+from QuantNodes.backtest.strategy_node import StrategyNode, OrdersResult
+
+class TrendFollowingStrategyNode(StrategyNode):
+    """趋势跟踪策略节点
+
+    使用双均线交叉判断趋势
+    """
+    def __init__(self, config: dict = None):
+        self.short_window = config.get('short_window', 10) if config else 10
+        self.long_window = config.get('long_window', 30) if config else 30
+
+    def execute(self, data: pd.DataFrame) -> OrdersResult:
+        close = data['close']
+        short_ma = close.rolling(window=self.short_window).mean()
+        long_ma = close.rolling(window=self.long_window).mean()
+
+        signal = pd.Series(0, index=data.index)
+        signal[(short_ma > long_ma) & (short_ma.shift(1) <= long_ma.shift(1))] = 1
+        signal[(short_ma < long_ma) & (short_ma.shift(1) >= long_ma.shift(1))] = -1
+
+        result = OrdersResult()
+        result.signals = signal
+        result.orders = []
+        return result
+
+
+strategy = TrendFollowingStrategyNode(config={'short_window': 10, 'long_window': 30})
+
+quote_data = pd.DataFrame({
+    'date': pd.date_range('2020-01-01', periods=100),
+    'close': np.random.randn(100).cumsum() + 100
+})
+'''
+
+
+TREND_FOLLOWING_PROMPT = StrategyPrompt()

QuantNodes/research/README.md

@@ -0,0 +1,106 @@
+# QuantNodes.research
+
+Wiki 因子库代理层 + 自动因子研究 + 研报复现。
+
+- **功能3A**: WikiFactorProxy — 因子库基础设施
+- **功能3B**: ResearchReportReproducer — 研报复现 (PDF→逻辑提取→验证)
+- **功能3C**: AutoResearcher — 自动因子挖掘 (模板枚举 + MCTS + 6维度评估)
+
+## 快速开始
+
+### 自动因子挖掘
+
+```python
+from QuantNodes.research import AutoResearcher, EvalConfig
+import polars as pl
+
+data = pl.read_parquet("market_data.parquet")
+researcher = AutoResearcher(wiki_path="/path/to/wiki")
+
+# 模板枚举 + 6维度评估
+result = researcher.run(data=data, max_factors=100)
+
+# MCTS 搜索
+result = researcher.run(data=data, use_mcts=True, mcts_iterations=50)
+
+# 验证单个因子
+result = researcher.mine_single_factor(
+    formula="rank(close / ts_lag(close, 20) - 1)",
+    data=data,
+)
+print(result.report_markdown)
+```
+
+### 6维度评估
+
+| 维度 | 指标 | 阈值 |
+|------|------|------|
+| 收益 | IC, IC_IR | \|IC\| > 0.03, IC_IR > 0.5 |
+| 稳定性 | 滚动IC | > 0.6 |
+| 分散度 | 因子间相关 | < 0.7 |
+| 换手率 | 排名变化 | < 0.5 |
+| 单调性 | 分组收益 | > 0.7 |
+| 覆盖率 | 非空比例 | > 0.8 |
+
+## 研报复现 (功能3B)
+
+```python
+from QuantNodes.research import ResearchReportReproducer
+import polars as pl
+
+data = pl.read_parquet("market_data.parquet")
+reproducer = ResearchReportReproducer(
+    wiki_path="/path/to/wiki",
+    llm_client=llm_client,  # 可选, 不传则用规则匹配
+)
+
+# 处理研报PDF
+report = reproducer.process(
+    pdf_path="research_report.pdf",
+    data=data,
+    store_to_wiki=True,
+)
+print(report.report_markdown)
+# verified: 因子类逻辑通过IC/IR验证
+# pending: 非因子类逻辑存入WikiLogic待人工验证
+```
+
+## Wiki 因子库 (功能3A)
+
+### 初始化
+
+```python
+from QuantNodes.research import init_factor_wiki, WikiFactorProxy
+
+init_factor_wiki("/path/to/wiki")
+proxy = WikiFactorProxy("/path/to/wiki")
+```
+
+### 存储/读取因子
+
+```python
+from QuantNodes.research import WikiFactor, FactorSource, FactorCategory
+
+factor = WikiFactor(
+    name="momentum_20d",
+    formula="close / delay(close, 20) - 1",
+    source=FactorSource.RESEARCH_REPORT,
+    category=FactorCategory.MOMENTUM,
+    ic_mean=0.05, icir=0.5,
+)
+proxy.store_factor(factor)
+factor = proxy.get_factor("momentum_20d")
+```
+
+### 关系管理
+
+```python
+proxy.add_relation("Logic/report_001", "Factor/momentum_20d", "derived_from")
+neighbors = proxy.get_neighbors("Factor/momentum_20d")
+```
+
+## 测试
+
+```bash
+python3 -m pytest tests/research/ -v
+```