quantnodes 3.0.0__py3-none-any.whl

QuantNodes/agent/skills/factor/__init__.py

@@ -0,0 +1,14 @@
+# coding=utf-8
+"""
+Factor Skills
+"""
+
+from .ic_analysis import ICAnalysisSkill
+from .group_backtest import GroupBacktestSkill
+from .correlation import CorrelationSkill
+
+__all__ = [
+    "ICAnalysisSkill",
+    "GroupBacktestSkill",
+    "CorrelationSkill",
+]

QuantNodes/agent/skills/factor/correlation.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+"""
+Correlation Analysis Skill
+
+Phase 4.4: Factor Skills
+"""
+
+from typing import Any, Dict
+
+from ..base import Skill, SkillCategory, SkillMetadata, SkillResult
+
+
+class CorrelationSkill(Skill):
+    """Factor Correlation Analysis Skill"""
+
+    @property
+    def metadata(self) -> SkillMetadata:
+        return SkillMetadata(
+            name="correlation",
+            description="计算因子之间的相关性矩阵，分析因子独立性",
+            category=SkillCategory.FACTOR,
+            tags=["因子分析", "相关性", "多重共线性"],
+            examples=[
+                "计算多个因子的相关性矩阵",
+                "检测高相关性因子",
+            ],
+        )
+
+    async def execute(self, context: Dict[str, Any]) -> SkillResult:
+        """Execute correlation analysis"""
+        factors = context.get("factors", ["factor1", "factor2"])
+
+        code = f'''
+def correlation_analysis(data, factor_cols={factors}):
+    """
+    相关性分析
+    - 计算因子之间的Pearson相关系数矩阵
+    - 识别高相关性因子对 (|corr| > 0.8)
+
+    Parameters:
+    - data: DataFrame with factor columns
+    - factor_cols: 因子列名列表
+
+    Returns:
+    - corr_matrix: 相关性矩阵
+    - high_corr_pairs: 高相关性因子对
+    """
+    import pandas as pd
+    import numpy as np
+
+    factor_data = data[factor_cols]
+
+    corr_matrix = factor_data.corr()
+
+    high_corr_threshold = 0.8
+    high_corr_pairs = []
+    for i in range(len(factor_cols)):
+        for j in range(i + 1, len(factor_cols)):
+            corr_val = corr_matrix.iloc[i, j]
+            if abs(corr_val) > high_corr_threshold:
+                high_corr_pairs.append({{
+                    "factor1": factor_cols[i],
+                    "factor2": factor_cols[j],
+                    "correlation": corr_val,
+                }})
+
+    result = {{
+        "factors": {factors},
+        "corr_matrix": corr_matrix.to_dict(),
+        "high_corr_pairs": high_corr_pairs,
+        "mean_abs_corr": corr_matrix.abs().values[
+            np.triu_indices_from(corr_matrix.values, k=1)
+        ].mean(),
+    }}
+    return result
+'''
+        return SkillResult(
+            success=True,
+            data={
+                "skill": "correlation",
+                "factors": factors,
+                "code": code.strip(),
+                "description": f"相关性分析: {', '.join(factors)}",
+            },
+        )
+
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        """Return parameter schema"""
+        return {
+            "type": "object",
+            "properties": {
+                "factors": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "因子列表",
+                    "default": ["factor1", "factor2"],
+                },
+            },
+        }

QuantNodes/agent/skills/factor/group_backtest.py

@@ -0,0 +1,114 @@
+# coding=utf-8
+"""
+Group Backtest Skill
+
+Phase 4.4: Factor Skills
+"""
+
+from typing import Any, Dict
+
+from ..base import Skill, SkillCategory, SkillMetadata, SkillResult
+
+
+class GroupBacktestSkill(Skill):
+    """Group Backtest by Factor Quantiles"""
+
+    @property
+    def metadata(self) -> SkillMetadata:
+        return SkillMetadata(
+            name="group_backtest",
+            description="按因子分位数分组回测，计算各组收益差异",
+            category=SkillCategory.FACTOR,
+            tags=["因子分析", "分组回测", "分位数", "多空组合"],
+            examples=[
+                "按因子分5组回测",
+                "计算多空组合收益",
+            ],
+        )
+
+    async def execute(self, context: Dict[str, Any]) -> SkillResult:
+        """Execute group backtest"""
+        n_groups = context.get("n_groups", 5)
+        period = context.get("period", 20)
+
+        code = f'''
+def group_backtest(
+    data, factor_col="factor", return_col="return",
+    n_groups={n_groups}, period={period},
+):
+    """
+    分组回测
+    - 按因子值分{n_groups}组
+    - 计算每组未来{period}天收益
+    - 计算多空组合收益 (Group{n_groups} - Group1)
+
+    Parameters:
+    - data: DataFrame with factor and return columns
+    - factor_col: 因子列名
+    - return_col: 收益列名
+    - n_groups: 分组数量
+    - period: 持有周期
+
+    Returns:
+    - group_returns: 各组平均收益
+    - long_short_return: 多空组合收益
+    - turnover: 换手率
+    """
+    import pandas as pd
+    import numpy as np
+
+    data = data.copy()
+    data["group"] = pd.qcut(data[factor_col], q={n_groups}, labels=False, duplicates="drop")
+
+    future_returns = data[return_col].shift(-{period})
+    data["future_return"] = future_returns
+
+    group_returns = data.groupby("group")["future_return"].mean()
+
+    if len(group_returns) >= {n_groups}:
+        long_short_return = group_returns.iloc[-1] - group_returns.iloc[0]
+    else:
+        long_short_return = np.nan
+
+    position = data.groupby("date")["group"].shift(1)
+    turnover = (position != position.shift(1)).sum() / len(data)
+
+    result = {{
+        "n_groups": {n_groups},
+        "period": {period},
+        "group_returns": group_returns.to_dict(),
+        "long_short_return": long_short_return,
+        "turnover": turnover,
+        "top_group_return": group_returns.iloc[-1] if len(group_returns) > 0 else np.nan,
+        "bottom_group_return": group_returns.iloc[0] if len(group_returns) > 0 else np.nan,
+    }}
+    return result
+'''
+        return SkillResult(
+            success=True,
+            data={
+                "skill": "group_backtest",
+                "n_groups": n_groups,
+                "period": period,
+                "code": code.strip(),
+                "description": f"分组回测: {n_groups}组, {period}天持有期",
+            },
+        )
+
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        """Return parameter schema"""
+        return {
+            "type": "object",
+            "properties": {
+                "n_groups": {
+                    "type": "integer",
+                    "description": "分组数量",
+                    "default": 5,
+                },
+                "period": {
+                    "type": "integer",
+                    "description": "持有周期(天)",
+                    "default": 20,
+                },
+            },
+        }

QuantNodes/agent/skills/factor/ic_analysis.py

@@ -0,0 +1,106 @@
+# coding=utf-8
+"""
+IC Analysis Skill
+
+Phase 4.4: Factor Skills
+"""
+
+from typing import Any, Dict
+
+from ..base import Skill, SkillCategory, SkillMetadata, SkillResult
+
+
+class ICAnalysisSkill(Skill):
+    """IC (Information Coefficient) Analysis Skill"""
+
+    @property
+    def metadata(self) -> SkillMetadata:
+        return SkillMetadata(
+            name="ic_analysis",
+            description="计算并分析因子IC值，包括IC均值、ICIR、Rank IC等指标",
+            category=SkillCategory.FACTOR,
+            tags=["因子分析", "IC", "ICIR", "Rank IC"],
+            examples=[
+                "分析因子的IC表现",
+                "计算ICIR指标",
+            ],
+        )
+
+    async def execute(self, context: Dict[str, Any]) -> SkillResult:
+        """Execute IC analysis"""
+        factor_name = context.get("factor_name", "factor")
+        n_days = context.get("n_days", 252)
+
+        code = f'''
+def calculate_ic_analysis(data, factor_col="factor", return_col="return", n_days={n_days}):
+    """
+    IC分析
+    - 计算因子IC序列
+    - 计算IC均值、IC标准差、ICIR
+    - 计算Rank IC
+
+    Parameters:
+    - data: DataFrame with factor and return columns
+    - factor_col: 因子列名
+    - return_col: 收益列名
+    - n_days: 计算周期
+
+    Returns:
+    - ic_series: IC时间序列
+    - ic_mean: IC均值
+    - ic_std: IC标准差
+    - icir: ICIR (IC均值/IC标准差)
+    - rank_ic_mean: Rank IC均值
+    """
+    import pandas as pd
+    import numpy as np
+
+    ic_series = data[factor_col].corr(data[return_col])
+    rank_ic_series = data[factor_col].rank().corr(data[return_col].rank())
+
+    ic_mean = ic_series.mean()
+    ic_std = ic_series.std()
+    icir = ic_mean / ic_std if ic_std != 0 else 0
+
+    rank_ic_mean = rank_ic_series.mean()
+
+    result = {{
+        "factor_name": "{factor_name}",
+        "n_dates": n_days,
+        "ic_series": ic_series,
+        "ic_mean": ic_mean,
+        "ic_std": ic_std,
+        "icir": icir,
+        "rank_ic_mean": rank_ic_mean,
+        "ic_t_stat": ic_mean / (ic_std / np.sqrt(n_days)) if ic_std != 0 else 0,
+    }}
+    return result
+'''
+        return SkillResult(
+            success=True,
+            data={
+                "skill": "ic_analysis",
+                "factor_name": factor_name,
+                "n_days": n_days,
+                "code": code.strip(),
+                "description": f"IC分析: {factor_name}, {n_days}天",
+            },
+        )
+
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        """Return parameter schema"""
+        return {
+            "type": "object",
+            "properties": {
+                "factor_name": {
+                    "type": "string",
+                    "description": "因子名称",
+                    "default": "factor",
+                },
+                "n_days": {
+                    "type": "integer",
+                    "description": "分析天数",
+                    "default": 252,
+                },
+            },
+        }

QuantNodes/agent/skills/loader.py

@@ -0,0 +1,107 @@
+# coding=utf-8
+"""
+Skill Loader - Progressive Skill Loader
+
+Phase 4.1: Skill Infrastructure
+"""
+
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Any
+
+from .base import Skill, SkillCategory
+from .registry import SkillRegistry
+
+
+class SkillLoader:
+    """Progressive Skill Loader"""
+
+    def __init__(self, registry: SkillRegistry = None):
+        self.registry = registry or SkillRegistry()
+        self._loaded: Dict[str, bool] = {}
+        self._load_order: List[str] = []
+        self._failed: Dict[str, str] = {}
+
+    def discover_skills(self, skills_dir: Path) -> List[str]:
+        """Discover all skills in the skills directory"""
+        discovered = []
+        if not skills_dir.exists():
+            return discovered
+        for item in skills_dir.iterdir():
+            if item.is_dir() and not item.name.startswith("_"):
+                skill_file = item / f"{item.name}.py"
+                if skill_file.exists():
+                    discovered.append(str(item))
+        return discovered
+
+    async def load_skill(
+        self, skill_path: Path, category: SkillCategory = None
+    ) -> bool:
+        """Load a single skill from path"""
+        spec = importlib.util.spec_from_file_location("skill_module", skill_path)
+        if spec is None or spec.loader is None:
+            return False
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            self._failed[str(skill_path)] = str(e)
+            return False
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if isinstance(attr, type) and issubclass(attr, Skill) and attr != Skill:
+                skill_instance = attr()
+                if category:
+                    skill_instance._metadata.category = category
+                self.registry.register(skill_instance)
+                self._loaded[skill_instance.name] = True
+                self._load_order.append(skill_instance.name)
+                return True
+        return False
+
+    async def load_all(self, skills_dir: Path) -> Dict[str, bool]:
+        """Load all discovered skills"""
+        results = {}
+        for skill_path in self.discover_skills(skills_dir):
+            skill_name = Path(skill_path).name
+            success = await self.load_skill(
+                Path(skill_path) / f"{skill_name}.py"
+            )
+            results[skill_name] = success
+        return results
+
+    async def progressive_load(
+        self, skills_dir: Path, requested_skills: List[str]
+    ) -> Dict[str, Skill]:
+        """Progressive load: only load requested skills"""
+        loaded = {}
+        for skill_name in requested_skills:
+            skill_path = skills_dir / skill_name / f"{skill_name}.py"
+            if skill_path.exists() and skill_name not in self._loaded:
+                success = await self.load_skill(skill_path)
+                if success:
+                    skill = self.registry.get(skill_name)
+                    if skill:
+                        loaded[skill_name] = skill
+        return loaded
+
+    def get_loading_status(self) -> Dict[str, Any]:
+        """Get loading status"""
+        return {
+            "loaded": self._loaded,
+            "load_order": self._load_order,
+            "failed": self._failed,
+            "total_loaded": len(self._loaded),
+        }
+
+    def reload_skill(self, name: str) -> bool:
+        """Reload a skill"""
+        if name in self._loaded:
+            self._loaded.pop(name)
+            self._load_order.remove(name)
+            self.registry.unregister(name)
+        return True
+
+    def is_loaded(self, name: str) -> bool:
+        """Check if a skill is loaded"""
+        return name in self._loaded

QuantNodes/agent/skills/registry.py

@@ -0,0 +1,105 @@
+# coding=utf-8
+"""
+Skill Registry - Singleton Registry for Skills (Thread-Safe)
+
+Phase 4.1: Skill Infrastructure
+"""
+
+import threading
+from typing import Dict, List, Optional
+from collections import defaultdict
+
+from .base import Skill, SkillCategory
+
+
+class SkillRegistry:
+    """Skill Registry (Singleton + Thread-Safe)"""
+
+    _instance: Optional["SkillRegistry"] = None
+    _lock = threading.RLock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._skills: Dict[str, Skill] = {}
+                cls._instance._categories: Dict[
+                    SkillCategory, List[str]
+                ] = defaultdict(list)
+                cls._instance._aliases: Dict[str, str] = {}
+            return cls._instance
+
+    def register(self, skill: Skill, aliases: List[str] = None) -> None:
+        """Register a skill"""
+        name = skill.name
+        if name in self._skills:
+            raise ValueError(f"Skill '{name}' already registered")
+        self._skills[name] = skill
+        self._categories[skill.category].append(name)
+        if aliases:
+            for alias in aliases:
+                self._aliases[alias] = name
+
+    def get(self, name: str) -> Optional[Skill]:
+        """Get a skill by name or alias"""
+        resolved = self._aliases.get(name, name)
+        return self._skills.get(resolved)
+
+    def list_by_category(self, category: SkillCategory) -> List[Skill]:
+        """List all skills in a category"""
+        return [self._skills[name] for name in self._categories.get(category, [])]
+
+    def list_all(self) -> List[Skill]:
+        """List all registered skills"""
+        return list(self._skills.values())
+
+    def list_names(self) -> List[str]:
+        """List all skill names"""
+        return list(self._skills.keys())
+
+    def exists(self, name: str) -> bool:
+        """Check if a skill exists"""
+        return name in self._skills or name in self._aliases
+
+    def unregister(self, name: str) -> bool:
+        """Unregister a skill"""
+        resolved = self._aliases.pop(name, None) or name
+        if resolved not in self._skills:
+            return False
+        skill = self._skills.pop(resolved)
+        if resolved in self._categories[skill.category]:
+            self._categories[skill.category].remove(resolved)
+        return True
+
+    def clear(self) -> None:
+        """Clear all skills"""
+        self._skills.clear()
+        self._categories.clear()
+        self._aliases.clear()
+
+    def get_skill_info(self, name: str) -> Optional[Dict]:
+        """Get skill information"""
+        skill = self.get(name)
+        if not skill:
+            return None
+        return {
+            "name": skill.name,
+            "description": skill.description,
+            "category": skill.category.value,
+            "version": skill.metadata.version,
+            "tags": skill.metadata.tags,
+        }
+
+    def search(self, query: str, limit: int = 10) -> List[Dict]:
+        """Search skills by name or description"""
+        results = []
+        query_lower = query.lower()
+        for skill in self._skills.values():
+            if (
+                query_lower in skill.name.lower()
+                or query_lower in skill.description.lower()
+            ):
+                results.append(self.get_skill_info(skill.name))
+                if len(results) >= limit:
+                    break
+        return results

QuantNodes/agent/skills/strategy/__init__.py

@@ -0,0 +1,16 @@
+# coding=utf-8
+"""
+Strategy Skills
+"""
+
+from .dual_ma import DualMaSkill
+from .bollinger import BollingerSkill
+from .momentum import MomentumSkill
+from .rsi_reversal import RSIReversalSkill
+
+__all__ = [
+    "DualMaSkill",
+    "BollingerSkill",
+    "MomentumSkill",
+    "RSIReversalSkill",
+]

QuantNodes/agent/skills/strategy/bollinger.py

@@ -0,0 +1,86 @@
+# coding=utf-8
+"""
+Bollinger Bands Strategy Skill
+
+Phase 4.3: Strategy Skills
+"""
+
+from typing import Any, Dict
+
+from ..base import Skill, SkillCategory, SkillMetadata, SkillResult
+
+
+class BollingerSkill(Skill):
+    """Bollinger Bands Strategy"""
+
+    @property
+    def metadata(self) -> SkillMetadata:
+        return SkillMetadata(
+            name="bollinger_strategy",
+            description="布林带策略 - 价格触及下轨买入，触及上轨卖出",
+            category=SkillCategory.STRATEGY,
+            tags=["趋势跟踪", "布林带", "均值回归"],
+            examples=[
+                "生成布林带策略代码",
+                "布林带策略参数优化",
+            ],
+        )
+
+    async def execute(self, context: Dict[str, Any]) -> SkillResult:
+        """Execute Bollinger bands strategy generation"""
+        period = context.get("period", 20)
+        std_dev = context.get("std_dev", 2)
+
+        code = f'''
+def bollinger_strategy(data, period={period}, std_dev={std_dev}):
+    """
+    布林带策略
+    - Period: {period}日移动平均
+    - Std Dev: {std_dev}倍标准差
+    Signals:
+      - 价格触及下轨买入(1)
+      - 价格触及上轨卖出(-1)
+      - 持有(0)
+    """
+    import pandas as pd
+
+    data["mid"] = data["close"].rolling({period}).mean()
+    data["std"] = data["close"].rolling({period}).std()
+    data["upper"] = data["mid"] + {std_dev} * data["std"]
+    data["lower"] = data["mid"] - {std_dev} * data["std"]
+
+    data["signal"] = 0
+    data.loc[data["close"] <= data["lower"], "signal"] = 1
+    data.loc[data["close"] >= data["upper"], "signal"] = -1
+
+    data["position"] = data["signal"].shift(1)
+    return data
+'''
+        return SkillResult(
+            success=True,
+            data={
+                "strategy": "bollinger",
+                "period": period,
+                "std_dev": std_dev,
+                "code": code.strip(),
+                "description": f"布林带策略: {period}日周期，{std_dev}倍标准差",
+            },
+        )
+
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        """Return parameter schema"""
+        return {
+            "type": "object",
+            "properties": {
+                "period": {
+                    "type": "integer",
+                    "description": "移动平均周期",
+                    "default": 20,
+                },
+                "std_dev": {
+                    "type": "number",
+                    "description": "标准差倍数",
+                    "default": 2,
+                },
+            },
+        }