quantnodes 3.0.0__py3-none-any.whl

QuantNodes/core/parallel/worker_process.py

@@ -0,0 +1,265 @@
+"""ProcessPool 工作器 — 顶层 pickle-safe 函数。
+
+设计:
+    主进程:
+        1. 序列化 config dict + context dict (DataFrames) → 临时 pickle 文件
+        2. 提交 subprocess_evaluate(candidate_dict, snapshot_path) 到 ProcessPool
+    子进程:
+        1. 从 snapshot_path 加载 config + context
+        2. 重建 DataLoader (从 context 中的 DataFrames)
+        3. 跑 Phase 2-11 (节点 2-11)
+        4. 返回结果 dict
+"""
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from QuantNodes.core.path_utils import ensure_parent
+
+
+# ============================================================================
+# 顶层 pickle-safe 函数 (子进程入口)
+# ============================================================================
+
+def subprocess_evaluate(
+    candidate_dict: dict,
+    snapshot_path: str,
+) -> dict:
+    """在子进程中执行评估, 接受候选 dict + 快照路径, 返回结果 dict。
+
+    这是顶层函数, 可被 pickle 传给 ProcessPoolExecutor。
+
+    Args:
+        candidate_dict: FactorCandidate 的 dict 形式
+        snapshot_path: 预序列化的 config+context 路径
+
+    Returns:
+        dict: {passed, metrics, feedback_dict, error}
+    """
+    try:
+        return _evaluate_in_subprocess(candidate_dict, snapshot_path)
+    except Exception as e:
+        import traceback
+        return {
+            "passed": False,
+            "metrics": {},
+            "feedback_dict": None,
+            "error": f"{type(e).__name__}: {e}\n{traceback.format_exc()[-500:]}",
+        }
+
+
+def _evaluate_in_subprocess(candidate_dict: dict, snapshot_path: str) -> dict:
+    """子进程内部实现。"""
+    import pandas as pd
+    import numpy as np
+
+    # 1. 加载快照
+    snapshot = pickle.loads(Path(snapshot_path).read_bytes())
+    config = snapshot["config"]
+    context = snapshot["context"]
+    factor_override_name = snapshot["factor_name"]
+    factor_override_expr = snapshot.get("factor_expression", "")
+
+    # 2. 重建因子数据
+    factor_path = snapshot.get("factor_path")
+    if factor_path and Path(factor_path).exists():
+        factor = pd.read_hdf(factor_path, key="data")
+    else:
+        # 从 context 中的 factor 字段
+        factor = context.get("LoadData", {}).get("factor")
+        if factor is None:
+            factor = pd.DataFrame(np.zeros((10, 10)))
+
+    # 3. 临时覆盖 factor name / expression
+    if "factor" not in config:
+        config["factor"] = {}
+    config["factor"]["name"] = factor_override_name
+    if factor_override_expr:
+        config["factor"]["expression"] = factor_override_expr
+
+    # 4. 重建 context
+    ctx = {}
+    ctx["LoadData"] = {
+        "factor": factor,
+        "price": context.get("LoadData", {}).get("price", pd.DataFrame()),
+        "id_citic1": context.get("LoadData", {}).get("id_citic1", pd.DataFrame()),
+        "mv_float": context.get("LoadData", {}).get("mv_float", pd.DataFrame()),
+        "st": context.get("LoadData", {}).get("st", pd.DataFrame()),
+        "suspend": context.get("LoadData", {}).get("suspend", pd.DataFrame()),
+        "ud_limit": context.get("LoadData", {}).get("ud_limit", pd.DataFrame()),
+        "ipo_days": context.get("LoadData", {}).get("ipo_days", pd.DataFrame()),
+        "index_cp": context.get("LoadData", {}).get("index_cp", pd.DataFrame()),
+        "stklist": context.get("LoadData", {}).get("stklist", pd.DataFrame()),
+        "trade_dt": context.get("LoadData", {}).get("trade_dt", pd.DataFrame()),
+        "_loader": context.get("LoadData", {}).get("_loader"),
+    }
+
+    # 5. 跑节点 2-11 (Phase 2-11, 跳过 LoadData 和 Report)
+    try:
+        _run_analysis_nodes(ctx, config)
+    except Exception as e:
+        return {"passed": False, "metrics": {}, "feedback_dict": None, "error": str(e)}
+
+    # 6. 提取 metrics
+    metrics = _extract_metrics(ctx)
+    passed = True
+
+    return {
+        "passed": passed,
+        "metrics": metrics,
+        "feedback_dict": {
+            "factor_id": candidate_dict.get("factor_id", ""),
+            "factor_name": candidate_dict.get("name", ""),
+            "decision": passed,
+            "summary": f"ProcessPool: sharpe={metrics.get('sharpe', 0):.2f}",
+            "metadata": metrics,
+            "channels": {},
+        },
+        "error": None,
+    }
+
+
+def _run_analysis_nodes(ctx: dict, config: dict) -> None:
+    """在子进程中跑节点 2-11 (与 PipelineRunner.run 相同逻辑)。"""
+    from QuantNodes.research.factor_test.nodes.sample_pool_filter_node import SamplePoolFilterNode
+    from QuantNodes.research.factor_test.nodes.tradability_filter_node import TradabilityFilterNode
+    from QuantNodes.research.factor_test.nodes.adjust_date_node import AdjustDateNode
+    from QuantNodes.research.factor_test.nodes.factor_preprocess_node import FactorPreprocessNode
+    from QuantNodes.research.factor_test.nodes.ic_analyzer_node import ICAnalyzerNode
+    from QuantNodes.research.factor_test.nodes.group_analyzer_node import GroupAnalyzerNode
+    from QuantNodes.research.factor_test.nodes.long_short_node import LongShortNode
+    from QuantNodes.research.factor_test.nodes.factor_score_node import FactorScoreNode
+
+    pp = config.get("preprocess", {})
+
+    # Node 2: SampleFilter
+    ctx["SamplePoolFilter"] = SamplePoolFilterNode(config={
+        "sample_index": pp.get("sample_index", "all"),
+        "sample_industry": pp.get("sample_industry", "all"),
+        "sample_index_customdir": pp.get("sample_index_customdir"),
+    }).execute(context=ctx)
+
+    # Node 3: TradabilityFilter
+    tradable = pp.get("tradable", {})
+    if isinstance(tradable, dict):
+        tradable_dict = tradable
+    elif hasattr(tradable, "model_dump"):
+        tradable_dict = tradable.model_dump()
+    else:
+        tradable_dict = {}
+    ctx["TradabilityFilter"] = TradabilityFilterNode(config={
+        "tradable": tradable_dict,
+    }).execute(context=ctx)
+
+    # Node 4: AdjustDate
+    ctx["AdjustDate"] = AdjustDateNode(config={
+        "adj_date_beg": pp.get("adj_date_beg", 20260101),
+        "adj_date_end": pp.get("adj_date_end", 20260630),
+        "adj_mode": pp.get("adj_mode", ["M", "end"]),
+    }).execute(context=ctx)
+
+    # Node 5: Preprocess
+    ctx["FactorPreprocess"] = FactorPreprocessNode(config={
+        "missing": pp.get("missing", ""),
+        "extreme": pp.get("extreme", "median"),
+        "norm": pp.get("norm", "zscore"),
+    }).execute(context=ctx)
+
+    # Node 6: Neutralize
+    ctx["FactorNeutralize"] = ctx["FactorPreprocess"]
+
+    # Node 7-10: Analysis
+    analysis = config.get("analysis", {})
+    ctx["ICAnalyzer"] = ICAnalyzerNode(config={
+        "min_group_size": analysis.get("ic", {}).get("min_group_size", 5),
+    }).execute(context=ctx)
+    ctx["GroupAnalyzer"] = GroupAnalyzerNode(config={
+        "groups": analysis.get("group", {}).get("groups", 5),
+        "factor_direction": analysis.get("group", {}).get("factor_direction", 1),
+        "floor_mode": analysis.get("group", {}).get("floor_mode", "group"),
+        "hedge": analysis.get("group", {}).get("hedge", "equal"),
+        "hedge_path": analysis.get("group", {}).get("hedge_path"),
+    }).execute(context=ctx)
+    ctx["LongShort"] = LongShortNode(config={
+        "factor_direction": analysis.get("longshort", {}).get("factor_direction", 1),
+    }).execute(context=ctx)
+    ctx["FactorScore"] = FactorScoreNode(config={
+        "enabled": analysis.get("score", {}).get("enabled", True),
+    }).execute(context=ctx)
+
+
+def _extract_metrics(ctx: dict) -> dict:
+    """从 ctx 提取指标 (与 PipelineRunner._extract_metrics_from_ctx 相同)。"""
+    metrics: dict = {}
+    ic = ctx.get("ICAnalyzer") or {}
+    ic_result = ic.get("ic_result") if isinstance(ic, dict) else None
+    if isinstance(ic_result, dict):
+        for src, dst in (("IC均值", "ic_mean"), ("Rank IC均值", "rank_ic_mean"), ("ICIR", "ic_ir")):
+            if src in ic_result and ic_result[src] is not None:
+                try:
+                    metrics[dst] = float(ic_result[src])
+                except (TypeError, ValueError):
+                    pass
+    ls = ctx.get("LongShort") or {}
+    if isinstance(ls, dict):
+        for src, dst in (("sharpe", "sharpe"), ("annualized_return", "arr"),
+                         ("max_drawdown", "mdd"), ("calmar", "calmar")):
+            if src in ls and ls[src] is not None:
+                try:
+                    metrics[dst] = float(ls[src])
+                except (TypeError, ValueError):
+                    pass
+    return metrics
+
+
+# ============================================================================
+# 序列化 / 反序列化 (主进程侧)
+# ============================================================================
+
+class RunnerSnapshot:
+    """预序列化 config + context, 供子进程读取。"""
+
+    def __init__(self, config_dict: dict, context: dict, factor_path: str | None = None):
+        self.config = config_dict
+        self.context = context
+        self.factor_name = config_dict.get("factor", {}).get("name", "")
+        self.factor_path = factor_path or ""
+
+    def save(self, path: Path) -> None:
+        """序列化到 pickle 文件。"""
+        path = Path(path)
+        ensure_parent(path)
+        snapshot = {
+            "config": self.config,
+            "context": self.context,
+            "factor_name": self.factor_name,
+            "factor_path": self.factor_path,
+        }
+        path.write_bytes(pickle.dumps(snapshot))
+
+    @staticmethod
+    def load(path: Path) -> dict:
+        """从 pickle 文件加载。"""
+        return pickle.loads(Path(path).read_bytes())
+
+
+def prepare_snapshot(
+    config,
+    context: dict,
+    factor_path: str | None = None,
+) -> RunnerSnapshot:
+    """从 PipelineRunner 准备序列化快照。
+
+    Args:
+        config: SingleFactorTestConfig (会 model_dump)
+        context: runner._context (含 DataFrames)
+        factor_path: 因子 H5 文件路径 (可选, 若 context 中有)
+
+    Returns:
+        RunnerSnapshot (可 save 到文件)
+    """
+    if hasattr(config, "model_dump"):
+        config_dict = config.model_dump()
+    else:
+        config_dict = dict(config)
+    return RunnerSnapshot(config_dict, context, factor_path)

QuantNodes/core/path_utils.py

@@ -0,0 +1,73 @@
+"""Path utilities — common pattern extraction.
+
+Consolidates:
+  1. `Path(x).expanduser()` and the env-var override variant
+  2. `Path(x).mkdir(parents=True, exist_ok=True)` (38 sites)
+  3. `path.parent.mkdir(parents=True, exist_ok=True)` (parent-for-file pattern)
+
+Used by:
+  - QuantNodes/core/trajectory/pool.py
+  - QuantNodes/core/monitoring/{collector,dashboard}.py
+  - QuantNodes/core/feedback/dataclass.py
+  - QuantNodes/core/knowledge/knowledge_base.py
+  - QuantNodes/core/visualization/report.py
+  - QuantNodes/core/parallel/worker_process.py
+  - QuantNodes/core/quality_gate/zoo.py
+  - QuantNodes/agent/tools/{file_ops,task}.py
+  - QuantNodes/agent/cli/main.py
+  - QuantNodes/agent/core/memory.py
+  - QuantNodes/agent/session/manager.py
+  - QuantNodes/cache_node/{cache_store,metadata}.py
+  - QuantNodes/monitor/{version/version_manager.py,scheduler/scheduler.py,storage/repository.py}
+  - QuantNodes/cli/_helpers.py + commands/{run,init}.py
+  - QuantNodes/backtest/config_runner.py
+  - QuantNodes/research/factor_test/{nodes,ifind_db,e2e}/...py
+
+P-1 priority is preserved: env_var > expanduser(default).
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+__all__ = ["resolve_path", "ensure_dir", "ensure_parent"]
+
+
+def resolve_path(default: str, env_var: str | None = None) -> Path:
+    """Resolve a path with priority: env_var > expanduser(default).
+
+    Args:
+        default: fallback path string (may contain ~).
+        env_var: optional environment variable name. If set and non-empty,
+            its value (after expanduser) wins.
+
+    Returns:
+        Path (always expanded, never None).
+    """
+    if env_var:
+        env_val = os.environ.get(env_var)
+        if env_val:
+            return Path(env_val).expanduser()
+    return Path(default).expanduser()
+
+
+def ensure_dir(path: str | Path) -> Path:
+    """Create directory at `path` if missing. Idempotent. Returns Path.
+
+    Replaces: `Path(x).mkdir(parents=True, exist_ok=True)`.
+    Also replaces bare `os.makedirs(x, exist_ok=True)`.
+    """
+    p = Path(path).expanduser()
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def ensure_parent(path: str | Path) -> Path:
+    """Ensure the *parent* of `path` exists (i.e. prepare to write a file).
+
+    Replaces: `Path(x).parent.mkdir(parents=True, exist_ok=True)`.
+    Returns the *original* `path` (not the parent), so callers can write to it.
+    """
+    p = Path(path).expanduser()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p

QuantNodes/core/pipeline.py

@@ -0,0 +1,328 @@
+# coding=utf-8
+"""
+Pipeline 组合原语模块
+
+本模块提供三种核心的节点组合方式：
+1. Pipeline: 线性管道，按顺序执行节点列表
+2. Parallel: 并行分叉，所有分支接收相同输入，并行执行
+3. Join: 聚合组合，接收字典输入，通过用户函数聚合为单个输出
+
+使用方式：
+    >>> from QuantNodes.core import Pipeline, Parallel, Join
+    >>>
+    >>> # 线性管道
+    >>> p = DatabaseNode() >> FactorNode() >> BacktestNode()
+    >>> result = p.execute(data)
+    >>>
+    >>> # 并行分叉
+    >>> factors = Parallel({
+    ...     'mom': MomentumFactor(),
+    ...     'vol': VolatilityFactor(),
+    ...     'value': ValueFactor(),
+    ... })
+    >>>
+    >>> # 聚合组合
+    >>> combine = Join(lambda mom, vol, value: mom * 0.5 + vol * 0.3 + value * 0.2)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Callable, Optional
+
+from QuantNodes.core.node import BaseNode, SerializationError
+from QuantNodes.core.serializable import serializable
+
+
+@serializable
+class Pipeline(BaseNode):
+    """
+    线性管道节点
+
+    按顺序执行节点列表，前一个节点的输出作为后一个节点的输入。
+    Pipeline 本身也是一个 Node，可以嵌套使用。
+
+    Examples:
+        >>> # 两种创建方式等价
+        >>> p1 = Pipeline([NodeA(), NodeB(), NodeC()])
+        >>> p2 = NodeA() >> NodeB() >> NodeC()
+        >>>
+        >>> # 嵌套使用
+        >>> nested = Pipeline([
+        ...     LoadDataNode(),
+        ...     Pipeline([CleanDataNode(), NormalizeNode()]),
+        ...     SaveResultNode(),
+        ... ])
+    """
+
+    def __init__(self, nodes: List[BaseNode], name: str = None, config: Dict[str, Any] = None):
+        """
+        Args:
+            nodes: 节点列表，按顺序执行
+            name: 管道名称，默认为 "Pipeline"
+            config: 配置字典
+        """
+        super().__init__(name=name or "Pipeline", config=config)
+        self.nodes: List[BaseNode] = list(nodes)
+        self.logger = logging.getLogger(f"node.{self.node_id}")
+
+    def _execute(self, input_data: Any = None, **kwargs) -> Any:
+        """依次执行所有节点"""
+        result = input_data
+
+        for i, node in enumerate(self.nodes):
+            self.logger.debug(f"Executing pipeline node {i+1}/{len(self.nodes)}: {node.name}")
+            result = node.execute(result, **kwargs)
+
+        return result
+
+    def __rshift__(self, other: BaseNode) -> 'Pipeline':
+        """重载 >> 运算符，支持链式扩展"""
+        if isinstance(other, Pipeline):
+            return Pipeline(self.nodes + other.nodes)
+        return Pipeline(self.nodes + [other])
+
+    def __iter__(self):
+        """迭代器支持"""
+        return iter(self.nodes)
+
+    def __len__(self) -> int:
+        """返回节点数量"""
+        return len(self.nodes)
+
+    def __getitem__(self, index: int) -> BaseNode:
+        """支持索引访问"""
+        return self.nodes[index]
+
+    def _get_serializable_fields(self) -> Dict[str, Any]:
+        """返回需要序列化的额外字段"""
+        return {"nodes": [node.serialize() for node in self.nodes]}
+
+    @classmethod
+    def _from_dict_impl(cls, data: Dict[str, Any]) -> 'Pipeline':
+        """从字典反序列化重建 Pipeline"""
+        nodes = [BaseNode.deserialize(n) for n in data["nodes"]]
+        return Pipeline(
+            nodes=nodes,
+            name=data.get("name"),
+            config=data.get("config", {})
+        )
+
+    def to_info(self) -> Dict[str, Any]:
+        """导出管道信息"""
+        result = super().to_info()
+        result['nodes'] = [node.to_info() for node in self.nodes]
+        return result
+
+
+@serializable
+class Parallel(BaseNode):
+    """
+    并行分叉节点
+
+    所有分支接收相同的输入，并行执行，返回字典格式的结果。
+    注意：当前版本为多线程实现，计算密集型任务可能不会提速。
+    后续版本会支持多进程和分布式执行。
+
+    Examples:
+        >>> p = Parallel({
+        ...     'factor_a': FactorA(),
+        ...     'factor_b': FactorB(),
+        ...     'factor_c': FactorC(),
+        ... })
+        >>> result = p.execute(data)
+        >>> # result = {'factor_a': ..., 'factor_b': ..., 'factor_c': ...}
+    """
+
+    def __init__(self, branches: Dict[str, BaseNode],
+                 name: str = None,
+                 max_workers: Optional[int] = None,
+                 parallel: bool = True,
+                 config: Dict[str, Any] = None):
+        """
+        Args:
+            branches: 分支节点字典，key 为结果字典的 key
+            name: 节点名称
+            max_workers: 最大工作线程数，None 表示自动选择
+            parallel: 是否并行执行，False 表示串行（调试用）
+            config: 配置字典
+        """
+        super().__init__(name=name or "Parallel", config=config)
+        self.branches: Dict[str, BaseNode] = branches
+        self.max_workers = max_workers
+        self.parallel = parallel
+        self.logger = logging.getLogger(f"node.{self.node_id}")
+
+    def _execute(self, input_data: Any = None, **kwargs) -> Dict[str, Any]:
+        """执行所有分支"""
+        if self.parallel:
+            return self._execute_parallel(input_data, **kwargs)
+        else:
+            return self._execute_serial(input_data, **kwargs)
+
+    def _execute_serial(self, input_data: Any = None, **kwargs) -> Dict[str, Any]:
+        """串行执行（调试用）"""
+        results = {}
+        for name, node in self.branches.items():
+            self.logger.debug(f"Executing parallel branch: {name}")
+            results[name] = node.execute(input_data, **kwargs)
+        return results
+
+    def _execute_parallel(self, input_data: Any = None, **kwargs) -> Dict[str, Any]:
+        """并行执行（使用线程池）"""
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        results = {}
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            future_to_name = {
+                executor.submit(node.execute, input_data, **kwargs): name
+                for name, node in self.branches.items()
+            }
+
+            for future in as_completed(future_to_name):
+                name = future_to_name[future]
+                try:
+                    results[name] = future.result()
+                except Exception as e:
+                    self.logger.error(f"Parallel branch '{name}' failed: {e}")
+                    raise
+
+        return results
+
+    def __or__(self, other: 'Parallel') -> 'Parallel':
+        """重载 | 运算符，支持合并 Parallel 节点"""
+        if not isinstance(other, Parallel):
+            raise TypeError(f"Can only combine Parallel with Parallel, got {type(other)}")
+        merged = {**self.branches, **other.branches}
+        return Parallel(merged)
+
+    def _get_serializable_fields(self) -> Dict[str, Any]:
+        """返回需要序列化的额外字段"""
+        return {
+            "branches": {name: node.serialize() for name, node in self.branches.items()},
+            "max_workers": self.max_workers,
+            "parallel": self.parallel,
+        }
+
+    @classmethod
+    def _from_dict_impl(cls, data: Dict[str, Any]) -> 'Parallel':
+        """从字典反序列化重建 Parallel"""
+        branches = {
+            name: BaseNode.deserialize(n)
+            for name, n in data["branches"].items()
+        }
+        return Parallel(
+            branches=branches,
+            name=data.get("name"),
+            max_workers=data.get("max_workers"),
+            parallel=data.get("parallel", True),
+            config=data.get("config", {})
+        )
+
+    def to_info(self) -> Dict[str, Any]:
+        """导出节点信息"""
+        result = super().to_info()
+        result['branches'] = {name: node.to_info() for name, node in self.branches.items()}
+        result['max_workers'] = self.max_workers
+        result['parallel'] = self.parallel
+        return result
+
+
+@serializable
+class Join(BaseNode):
+    """
+    聚合组合节点
+
+    接收字典输入，通过用户定义的函数聚合为单个输出。
+    通常与 Parallel 节点配合使用，将多个分支的结果合并。
+
+    Examples:
+        >>> # 1. 使用关键字参数函数
+        >>> Join(lambda mom, vol, value: mom * 0.5 + vol * 0.3 + value * 0.2)
+        >>>
+        >>> # 2. 使用字典参数
+        >>> Join(lambda factors: factors['mom'] + factors['vol'])
+        >>>
+        >>> # 3. 典型用法：Parallel + Join
+        >>> pipeline = (
+        ...     Parallel({
+        ...         'mom': MomentumFactor(),
+        ...         'vol': VolatilityFactor(),
+        ...     })
+        ...     >> Join(lambda mom, vol: mom / vol)
+        ... )
+    """
+
+    def __init__(self, join_func: Callable, name: str = None, config: Dict[str, Any] = None):
+        """
+        Args:
+            join_func: 聚合函数
+                - 如果接受关键字参数，会传入字典的 key-value
+                - 如果只接受一个参数，会传入整个字典
+            name: 节点名称
+            config: 配置字典
+        """
+        super().__init__(name=name or "Join", config=config)
+        self.join_func = join_func
+        self.logger = logging.getLogger(f"node.{self.node_id}")
+
+    def _execute(self, input_data: Dict[str, Any], **kwargs) -> Any:
+        """执行聚合"""
+        if not isinstance(input_data, dict):
+            raise ValueError(f"Join node requires dict input, got {type(input_data)}")
+
+        import inspect
+        sig = inspect.signature(self.join_func)
+        params = list(sig.parameters.keys())
+
+        if len(params) == 1:
+            return self.join_func(input_data)
+
+        return self.join_func(**input_data)
+
+    def _get_serializable_fields(self) -> Dict[str, Any]:
+        """返回需要序列化的额外字段"""
+        func = self.join_func
+
+        if hasattr(func, "__name__") and func.__name__ == "<lambda>":
+            raise SerializationError(
+                "Join node with anonymous lambda cannot be serialized. "
+                "Please use a named function or Expression DSL instead."
+            )
+
+        return {
+            "join_func": {
+                "type": "named_function",
+                "module": func.__module__,
+                "qualname": func.__qualname__
+            }
+        }
+
+    @classmethod
+    def _from_dict_impl(cls, data: Dict[str, Any]) -> 'Join':
+        """从字典反序列化重建 Join"""
+        import importlib
+
+        func_info = data["join_func"]
+        if func_info["type"] != "named_function":
+            raise ValueError(f"Unsupported function type: {func_info['type']}")
+
+        module = importlib.import_module(func_info["module"])
+        func = getattr(module, func_info["qualname"])
+
+        return Join(
+            join_func=func,
+            name=data.get("name"),
+            config=data.get("config", {})
+        )
+
+    def to_info(self) -> Dict[str, Any]:
+        """导出节点信息"""
+        result = super().to_info()
+        join_name = (
+            self.join_func.__name__
+            if hasattr(self.join_func, '__name__')
+            else str(self.join_func)
+        )
+        result['join_func'] = join_name
+        return result