quantnodes 3.0.0__py3-none-any.whl

QuantNodes/agent/config/loader.py

@@ -0,0 +1,427 @@
+# coding=utf-8
+"""
+配置加载器
+
+解析 YAML 配置文件为 StrategyConfig 对象。
+"""
+
+from __future__ import annotations
+
+import re
+import importlib.util
+import warnings
+from typing import Optional
+import yaml
+from pathlib import Path
+
+from .types import (
+    StrategyConfig,
+    FactorConfig,
+    OperationConfig,
+    CompositeConfig,
+    BacktestConfig,
+    ValidationConfig,
+    DataConfig,
+    OutputConfig,
+    CoverageReport,
+)
+from QuantNodes.operators.proxy import list_operators as _list_operators
+
+# executor category → registry category 映射
+_CATEGORY_MAP = {
+    "time_series": "time",
+    "section": "section",
+    "math": "point",
+    "composite": "point",
+}
+
+
+class ConfigLoader:
+    """YAML配置加载器"""
+
+    def __init__(self, working_dir: str = "."):
+        self.working_dir = Path(working_dir)
+        self._config: Optional[StrategyConfig] = None
+
+    def load(self, path: str) -> StrategyConfig:
+        """加载YAML配置文件
+
+        Args:
+            path: 配置文件路径
+
+        Returns:
+            StrategyConfig 对象
+        """
+        config_path = self.working_dir / path
+        if not config_path.exists():
+            raise FileNotFoundError(f"Config file not found: {config_path}")
+
+        with open(config_path, encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        if data is None:
+            data = {}
+
+        self._config = self._parse(data)
+        return self._config
+
+    def _parse(self, data: dict) -> StrategyConfig:
+        """解析配置字典"""
+        config = StrategyConfig(
+            version=data.get("version", "1.0"),
+            name=data.get("name", ""),
+            description=data.get("description", ""),
+        )
+
+        # 数据源配置
+        if "data" in data:
+            d = data["data"]
+            config.data = DataConfig(
+                source=d.get("source", "csv"),
+                path=d.get("path", ""),
+                columns=d.get("columns", []),
+                date_column=d.get("date_column", "date"),
+                code_column=d.get("code_column", "code"),
+                db_date_column=d.get("db_date_column", ""),
+                db_code_column=d.get("db_code_column", ""),
+                table=d.get("table", ""),
+                conn_ini=d.get("conn_ini", "conn.ini"),
+                conn_section=d.get("conn_section", "ClickHouse"),
+                column_mapping=d.get("column_mapping", {}),
+                query_filter=d.get("query_filter", ""),
+                standard_columns=d.get("standard_columns", {
+                    "open": "open",
+                    "high": "high",
+                    "low": "low",
+                    "close": "close",
+                    "volume": "volume",
+                }),
+                cache_enabled=d.get("cache_enabled", False),
+                cache_ttl_days=d.get("cache_ttl_days", 7),
+                cache_dir=d.get("cache_dir", "~/.quantnodes/cache"),
+                cache_force_refresh=d.get("cache_force_refresh", False),
+            )
+
+        # 因子定义
+        config.factors = [
+            FactorConfig(
+                name=f["name"],
+                expr=f.get("expr", ""),
+                description=f.get("description", "")
+            )
+            for f in data.get("factors", [])
+        ]
+
+        # 运算配置
+        config.operations = [
+            OperationConfig(
+                type=op["type"],
+                name=op["name"],
+                category=op["category"],
+                inputs=op.get("inputs", []),
+                params=op.get("params", {})
+            )
+            for op in data.get("operations", [])
+        ]
+
+        # 组合因子
+        config.composite = [
+            CompositeConfig(
+                name=c["name"],
+                formula=c.get("formula", ""),
+                weights=c.get("weights"),
+                normalize=c.get("normalize", False),
+                winsorize=c.get("winsorize")
+            )
+            for c in data.get("composite", [])
+        ]
+
+        # 回测配置
+        if "backtest" in data:
+            bt = data["backtest"]
+            config.backtest = BacktestConfig(
+                start_date=bt.get("start_date", ""),
+                end_date=bt.get("end_date", ""),
+                initial_cash=bt.get("initial_cash", 1000000),
+                commission=bt.get("commission", 0.001),
+                slippage=bt.get("slippage", 0.001),
+                universe=bt.get("universe", "A_stock"),
+                signals=bt.get("signals", {}),
+                positions=bt.get("positions", {}),
+            )
+
+        # 验证配置
+        if "validation" in data:
+            v = data["validation"]
+            config.validation = ValidationConfig(
+                run_tests=v.get("run_tests", True),
+                test_files=v.get("test_files", []),
+                metrics=v.get("metrics", {}),
+                custom_operators=v.get("custom_operators", []),
+            )
+
+        # 输出配置
+        if "output" in data:
+            o = data["output"]
+            config.output = OutputConfig(
+                format=o.get("format", "parquet"),
+                path=o.get("path", "outputs/result.parquet"),
+                save_signals=o.get("save_signals", True),
+                save_positions=o.get("save_positions", True),
+                save_equity_curve=o.get("save_equity_curve", True),
+            )
+
+        return config
+
+    def _preload_custom_operators(self, custom_operators: list) -> None:
+        """预加载自定义算子到 registry
+
+        在 check_coverage 之前调用，确保自定义算子被识别。
+
+        Args:
+            custom_operators: ValidationConfig.custom_operators 列表
+        """
+        if not custom_operators:
+            return
+
+        from QuantNodes.operators.proxy import register_operator
+
+        for entry in custom_operators:
+            if isinstance(entry, str):
+                source_path = entry
+                category = "point"
+                functions = None
+            else:
+                source_path = entry.get("source", "")
+                category = entry.get("category", "point")
+                functions = entry.get("functions")
+
+            if not source_path:
+                continue
+
+            try:
+                spec = importlib.util.spec_from_file_location("custom_ops", source_path)
+                if spec is None or spec.loader is None:
+                    warnings.warn(f"无法加载自定义算子文件: {source_path}")
+                    continue
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+            except Exception as e:
+                warnings.warn(f"加载自定义算子文件失败 {source_path}: {e}")
+                continue
+
+            for name in dir(module):
+                if name.startswith("_"):
+                    continue
+                if functions and name not in functions:
+                    continue
+                if not functions and not name.startswith("custom_"):
+                    continue
+
+                func = getattr(module, name)
+                if not callable(func):
+                    continue
+
+                register_operator(_CATEGORY_MAP.get(category, "point"), name=name)(func)
+
+    def check_coverage(self, config: StrategyConfig) -> CoverageReport:
+        """检查配置覆盖度
+
+        使用 factor_functions 的真实注册表检查算子是否存在。
+        会先加载 custom_operators 以确保自定义算子被识别。
+
+        Args:
+            config: 策略配置
+
+        Returns:
+            CoverageReport 对象
+        """
+        # 预加载自定义算子
+        self._preload_custom_operators(config.validation.custom_operators)
+
+        covered = []
+        unresolved = []
+
+        # 获取所有已注册的算子名称
+        all_operators = set(_list_operators())
+
+        # 已定义的列名（factors + operations 的输出）
+        defined_names = set()
+        for factor in config.factors:
+            defined_names.add(factor.name)
+        for op in config.operations:
+            defined_names.add(op.name)
+
+        # 检查因子定义
+        for factor in config.factors:
+            if factor.expr:
+                covered.append("factor:%s" % factor.name)
+            else:
+                unresolved.append("factor:%s" % factor.name)
+
+        # 检查算子 - 使用 factor_functions 真实注册表
+        for op in config.operations:
+            category = op.category
+
+            if category in all_operators:
+                covered.append("op:%s" % category)
+            else:
+                unresolved.append("op:%s" % category)
+
+        # 检查组合因子公式
+        for comp in config.composite:
+            if not comp.formula:
+                unresolved.append("composite:%s" % comp.name)
+                continue
+
+            covered.append("composite:%s" % comp.name)
+
+            # 提取公式中调用的函数名
+            func_names = re.findall(r'\b([a-zA-Z_]\w*)\s*\(', comp.formula)
+            for fn in func_names:
+                if fn not in all_operators and fn not in defined_names:
+                    unresolved.append("composite:%s:unknown_func:%s" % (comp.name, fn))
+
+            # 提取公式中引用的标识符（非函数调用的）
+            # 移除函数调用部分后，提取剩余的标识符
+            formula_no_funcs = re.sub(r'\b\w+\s*\([^)]*\)', '', comp.formula)
+            ref_names = re.findall(r'\b([a-zA-Z_]\w*)\b', formula_no_funcs)
+            for rn in ref_names:
+                # 跳过 Python 关键字和数字
+                if rn in ('true', 'false', 'null', 'and', 'or', 'not', 'None'):
+                    continue
+                if rn not in defined_names and rn not in all_operators:
+                    unresolved.append("composite:%s:unknown_ref:%s" % (comp.name, rn))
+
+        return CoverageReport(covered=covered, unresolved=unresolved)
+
+    def get_config(self) -> Optional[StrategyConfig]:
+        """获取当前配置"""
+        return self._config
+
+    def to_yaml(self, config: StrategyConfig, path: str) -> None:
+        """导出配置为YAML
+
+        Args:
+            config: 策略配置
+            path: 输出路径
+        """
+        data = {
+            "version": config.version,
+            "name": config.name,
+            "description": config.description,
+        }
+
+        if config.data:
+            data["data"] = {
+                "source": config.data.source,
+                "path": config.data.path,
+                "columns": config.data.columns,
+                "date_column": config.data.date_column,
+                "code_column": config.data.code_column,
+            }
+            if config.data.db_date_column:
+                data["data"]["db_date_column"] = config.data.db_date_column
+            if config.data.db_code_column:
+                data["data"]["db_code_column"] = config.data.db_code_column
+            if config.data.table:
+                data["data"]["table"] = config.data.table
+            if config.data.conn_ini != "conn.ini":
+                data["data"]["conn_ini"] = config.data.conn_ini
+            if config.data.conn_section != "ClickHouse":
+                data["data"]["conn_section"] = config.data.conn_section
+            if config.data.column_mapping:
+                data["data"]["column_mapping"] = config.data.column_mapping
+            if config.data.query_filter:
+                data["data"]["query_filter"] = config.data.query_filter
+            if config.data.standard_columns:
+                data["data"]["standard_columns"] = config.data.standard_columns
+            if config.data.cache_enabled:
+                data["data"]["cache_enabled"] = True
+                data["data"]["cache_ttl_days"] = config.data.cache_ttl_days
+                if config.data.cache_dir != "~/.quantnodes/cache":
+                    data["data"]["cache_dir"] = config.data.cache_dir
+                if config.data.cache_force_refresh:
+                    data["data"]["cache_force_refresh"] = True
+
+        data["factors"] = [
+            {
+                "name": f.name,
+                "expr": f.expr,
+                "description": f.description,
+            }
+            for f in config.factors
+        ]
+
+        data["operations"] = [
+            {
+                "type": op.type,
+                "name": op.name,
+                "category": op.category,
+                "inputs": op.inputs,
+                "params": op.params,
+            }
+            for op in config.operations
+        ]
+
+        data["composite"] = [
+            {
+                "name": c.name,
+                "formula": c.formula,
+                "weights": c.weights,
+                "normalize": c.normalize,
+                "winsorize": c.winsorize,
+            }
+            for c in config.composite
+        ]
+
+        if config.backtest:
+            data["backtest"] = {
+                "start_date": config.backtest.start_date,
+                "end_date": config.backtest.end_date,
+                "initial_cash": config.backtest.initial_cash,
+                "commission": config.backtest.commission,
+                "slippage": config.backtest.slippage,
+            }
+            if config.backtest.universe != "A_stock":
+                data["backtest"]["universe"] = config.backtest.universe
+            if config.backtest.signals:
+                data["backtest"]["signals"] = config.backtest.signals
+            if config.backtest.positions:
+                data["backtest"]["positions"] = config.backtest.positions
+
+        if config.validation:
+            v = config.validation
+            data["validation"] = {
+                "run_tests": v.run_tests,
+            }
+            if v.test_files:
+                data["validation"]["test_files"] = v.test_files
+            if v.metrics:
+                data["validation"]["metrics"] = v.metrics
+            if v.custom_operators:
+                data["validation"]["custom_operators"] = v.custom_operators
+
+        if config.output:
+            data["output"] = {
+                "format": config.output.format,
+                "path": config.output.path,
+                "save_signals": config.output.save_signals,
+                "save_positions": config.output.save_positions,
+                "save_equity_curve": config.output.save_equity_curve,
+            }
+
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(data, f, allow_unicode=True, sort_keys=False)
+
+def load_config(path: str) -> StrategyConfig:
+    """便捷加载函数
+
+    Args:
+        path: 配置文件路径
+
+    Returns:
+        StrategyConfig 对象
+    """
+    loader = ConfigLoader()
+    return loader.load(path)

QuantNodes/agent/config/templates/bollinger_bands.yaml

@@ -0,0 +1,84 @@
+# bollinger_bands.yaml
+# 布林带突破策略
+# 逻辑: 价格跌破下轨买入，突破上轨卖出
+
+version: "1.0"
+name: "bollinger_breakout"
+description: "布林带突破策略 - 价格跌破下轨买入，突破上轨卖出"
+
+data:
+  source: clickhouse
+  conn_ini: conn.ini
+  conn_section: ClickHouse
+  table: quote.cn_stock
+  columns: [ts_code, trade_date, open, high, low, close, vol]
+
+  db_date_column: trade_date
+  db_code_column: ts_code
+  date_column: date
+  code_column: code
+
+  column_mapping:
+    ts_code: code
+    trade_date: date
+    vol: volume
+
+  query_filter: "WHERE trade_date >= toDateTime('2023-07-01')"
+
+factors:
+  - name: close_ma
+    expr: "ts_mean(close, 20)"
+    description: "20日均线（布林带中轨）"
+
+  - name: close_std
+    expr: "ts_std(close, 20)"
+    description: "20日标准差"
+
+  - name: upper_band
+    expr: "close_ma + 2 * close_std"
+    description: "布林带上轨"
+
+  - name: lower_band
+    expr: "close_ma - 2 * close_std"
+    description: "布林带下轨"
+
+  - name: band_width
+    expr: "(upper_band - lower_band) / close_ma"
+    description: "布林带宽度"
+
+operations:
+  - type: section
+    name: band_width_rank
+    category: rank
+    inputs: [band_width]
+    description: "布林带宽度截面排名"
+
+  - type: section
+    name: close_position
+    category: rank
+    inputs: [close]
+    description: "价格截面排名"
+
+composite:
+  - name: alpha
+    formula: "-1 * band_width_rank"
+
+backtest:
+  start_date: "2023-07-01"
+  end_date: "2024-07-19"
+  initial_cash: 1000000
+  commission: 0.001
+  slippage: 0.001
+
+  signals:
+    buy_threshold: 0.6
+    sell_threshold: 0.4
+
+  positions:
+    max_positions: 10
+    rebalance_freq: "weekly"
+
+output:
+  format: parquet
+  path: "outputs/bollinger_result.parquet"
+  save_signals: true

QuantNodes/agent/config/templates/dual_ma.yaml

@@ -0,0 +1,72 @@
+# dual_ma.yaml
+# 双均线金叉死叉策略
+# 用户场景: "帮我写一个双均线策略，回测一下看看效果"
+
+version: "1.0"
+name: "dual_ma_crossover"
+description: "双均线金叉死叉策略 - 短期均线上穿长期均线买入，下穿卖出"
+
+data:
+  source: clickhouse
+  conn_ini: conn.ini
+  conn_section: ClickHouse
+  table: quote.cn_stock
+  columns: [ts_code, trade_date, open, high, low, close, vol]
+
+  db_date_column: trade_date
+  db_code_column: ts_code
+  date_column: date
+  code_column: code
+
+  column_mapping:
+    ts_code: code
+    trade_date: date
+    vol: volume
+
+  query_filter: "WHERE trade_date >= toDateTime('2023-07-01')"
+
+factors:
+  - name: short_ma
+    expr: "ts_mean(close, 5)"
+    description: "5日均线（短期）"
+
+  - name: long_ma
+    expr: "ts_mean(close, 20)"
+    description: "20日均线（长期）"
+
+  - name: ma_diff
+    expr: "short_ma - long_ma"
+    description: "均线差值"
+
+operations:
+  - type: section
+    name: ma_diff_rank
+    category: rank
+    inputs: [ma_diff]
+    description: "均线差值截面排名"
+
+composite:
+  - name: alpha
+    formula: "ma_diff_rank"
+
+backtest:
+  start_date: "2023-07-01"
+  end_date: "2024-07-19"
+  initial_cash: 1000000
+  commission: 0.001
+  slippage: 0.001
+
+  signals:
+    buy_threshold: 0.6
+    sell_threshold: 0.4
+
+  positions:
+    max_positions: 10
+    rebalance_freq: "weekly"
+
+output:
+  format: parquet
+  path: "outputs/dual_ma_result.parquet"
+  save_signals: true
+  save_positions: true
+  save_equity_curve: true

QuantNodes/agent/config/templates/empty.yaml

@@ -0,0 +1,56 @@
+# strategy.yaml
+# 策略配置文件模板
+
+version: "1.0"
+name: "my_strategy"
+description: "策略描述"
+
+# 数据源 (可选)
+# data:
+#   source: "csv"
+#   path: "data/data.csv"
+#   columns: [date, code, open, high, low, close, volume]
+#   date_column: "date"
+#   code_column: "code"
+
+# 因子定义 (可选)
+# factors:
+#   - name: factor_name
+#     expr: "close / close.shift(20) - 1"
+#     description: "因子描述"
+
+# 运算配置 (可选)
+# operations:
+#   - type: time_series  # time_series / section / math / composite
+#     name: op_name
+#     category: ts_mean  # 具体算子
+#     inputs: [factor_name]
+#     params:
+#       window: 20
+
+# 组合因子 (可选)
+# composite:
+#   - name: alpha
+#     formula: "rank(factor_name)"
+#     normalize: true
+
+# 回测配置 (可选)
+# backtest:
+#   start_date: "2023-01-01"
+#   end_date: "2024-12-31"
+#   initial_cash: 1000000
+#   commission: 0.001
+#   slippage: 0.001
+
+# 验证配置 (可选)
+# validation:
+#   run_tests: true
+#   metrics:
+#     ic_threshold: 0.02
+#     max_correlation: 0.7
+
+# 输出配置 (可选)
+# output:
+#   format: "parquet"
+#   path: "outputs/result.parquet"
+#   save_signals: true

QuantNodes/agent/config/templates/mean_reversion.yaml

@@ -0,0 +1,47 @@
+# mean_reversion.yaml
+# 均值回复策略配置
+
+version: "1.0"
+name: "mean_reversion"
+description: "均值回复策略"
+
+# 因子定义
+factors:
+  - name: close_ma
+    expr: "ts_mean(close, 20)"
+    description: "20日均线"
+
+  - name: close_std
+    expr: "ts_std(close, 20)"
+    description: "20日标准差"
+
+# 运算
+operations:
+  - type: section
+    name: zscore_value
+    category: zscore
+    inputs: [close_ma]
+
+  - type: section
+    name: alpha_rank
+    category: rank
+    inputs: [zscore_value]
+
+# 组合
+composite:
+  - name: alpha
+    formula: "-1 * alpha_rank"
+
+backtest:
+  start_date: "2023-01-01"
+  end_date: "2024-12-31"
+  initial_cash: 1000000
+
+  signals:
+    buy_threshold: 0.05
+    sell_threshold: -0.03
+
+validation:
+  run_tests: true
+  metrics:
+    ic_threshold: 0.02