kele 0.0.1a1__cp314-cp314-win32.whl

kele/__init__.py

@@ -0,0 +1,38 @@
+"""支持断言逻辑的推理引擎"""
+from kele.main import EngineRunResult, InferenceEngine, QueryStructure
+from kele.config import (
+    Config,
+    RunControlConfig,
+    InferenceStrategyConfig,
+    GrounderConfig,
+    ExecutorConfig,
+    PathConfig,
+    KBConfig,
+)
+from kele.syntax.base_classes import Constant, Concept, Operator, Variable, CompoundTerm, Assertion, Formula, Rule
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = '0.0.0'
+
+__all__ = [
+    'Assertion',
+    'CompoundTerm',
+    'Concept',
+    'Config',
+    'Constant',
+    'EngineRunResult',
+    'ExecutorConfig',
+    'Formula',
+    'GrounderConfig',
+    'InferenceEngine',
+    'InferenceStrategyConfig',
+    'KBConfig',
+    'Operator',
+    'PathConfig',
+    'QueryStructure',
+    'Rule',
+    'RunControlConfig',
+    'Variable',
+]

kele/_version.py

@@ -0,0 +1 @@
+version = "0.0.1a1"

kele/config.py

@@ -0,0 +1,243 @@
+# ruff: noqa: ERA001  # Commented parameters are either not implemented yet or depend on unfinished upstream/downstream modules.
+import warnings
+from typing import Any, cast, Literal
+
+import logging
+from dataclasses import dataclass, fields, field
+from datetime import datetime, UTC
+from pathlib import Path
+import yaml
+import json
+import tyro
+from tyro.conf import OmitArgPrefixes
+import dacite
+from dacite.config import Config as daConfig
+
+RESULT_LEVEL = 25
+logging.RESULT = RESULT_LEVEL  # type: ignore[attr-defined]  # This fails mypy; setattr fails ruff.
+
+logging.addLevelName(RESULT_LEVEL, "RESULT")
+
+
+def _result(self: logging.Logger, message: str, *args: object) -> None:
+    if self.isEnabledFor(RESULT_LEVEL):
+        self._log(RESULT_LEVEL, message, args)
+
+
+logging.Logger.result = _result  # type: ignore[attr-defined]
+
+
+# Config classes inheriting all settings from the original file.
+@dataclass
+class RunControlConfig:
+    """Runtime control."""
+    iteration_limit: int = 300  # Timeout iterations (one grounder-executor cycle is one iteration).
+    # time_limit: int = 3000  # 暂未接入超时终止逻辑，保留字段占位。
+    log_level: Literal['DEBUG', 'INFO', 'RESULT', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO'  # Log level.
+    # grounding_steps: int = 4  # Per-grounding step limit. TODO: Unused; may no longer be needed.
+    trace: bool = False  # Enable inference path tracing.
+    semi_eval_with_equality: bool = True  # Consider equality axioms in semi-evaluation. Disable to reduce overhead.
+    # This only partially disables related behavior. TODO: Possibly rename to inference_with_equality.
+    interactive_query_mode: Literal["interactive", "first", "all"] = "first"  # Control interactive printing of solutions.
+    # interactive = interactive, first = print first solution only, all = print all solutions.
+    save_solutions: bool = False  # Record and return solutions; False logs only to terminal and logs.
+    include_final_facts: bool = False  # Include final facts in EngineRunResult; fact_num always reported.
+
+
+@dataclass
+class InferenceStrategyConfig:
+    """Inference strategy and model behavior."""
+    select_rules_num: int | Literal[-1] = -1  # Number of rules to select.
+    select_facts_num: int | Literal[-1] = -1  # Number of facts to select; -1 means all facts.
+    # premise_selection_strategy: Literal[''] = ''  # Premise selection algorithm. TODO: Unused.
+    grounding_rule_strategy: Literal['SequentialCyclic', 'SequentialCyclicWithPriority'] = "SequentialCyclic"  # Rule selection strategy in grounding.
+    # executing_sort_strategy: Literal[''] = ''  # Execution order strategy. TODO: Unused.
+    grounding_term_strategy: Literal['Exhausted'] = "Exhausted"  # Term selection strategy in grounding.
+    question_rule_interval: int = 1  # Insert a question rule every N rules; -1 uses total rule count as the interval.
+
+
+@dataclass
+class GrounderConfig:
+    """Grounder-related parameters."""
+    grounding_rules_num_every_step: int | Literal[-1] = -1
+    grounding_facts_num_for_each_rule: int | Literal[-1] = -1
+    allow_unify_with_nested_term: bool = True  # Allow Variables to be replaced by CompoundTerms.
+    conceptual_fuzzy_unification: bool = True  # Use strict concept constraints to accelerate inference.
+    # This depends on correct concept subsumption and full constant.belong_concepts settings; beginners should use loose matching.
+
+
+@dataclass
+class ExecutorConfig:
+    """Executor-related parameters."""
+    executing_rule_num: int | Literal[-1] = -1
+    executing_max_steps: int | Literal[-1] = -1
+    anti_join_used_facts: bool = True  # Drop facts that were already produced (default True).
+    # This records last-true results and anti-joins against current results to drop facts.
+    # It can be inefficient when duplicates are rare, but speeds up heavy duplication.
+
+
+@dataclass
+class PathConfig:
+    """Paths and resource dependencies."""
+    rule_dir: str = './'
+    fact_dir: str = './'
+    log_dir: str = './log'
+
+
+@dataclass
+class KBConfig:
+    """Knowledge-base related parameters."""
+    fact_cache_size: int | Literal[-1] = -1
+
+
+@dataclass
+class Config:
+    """Main entry point for kele hyperparameters."""
+    run: OmitArgPrefixes[RunControlConfig] = field(default_factory=RunControlConfig)
+    strategy: OmitArgPrefixes[InferenceStrategyConfig] = field(default_factory=InferenceStrategyConfig)
+    grounder: OmitArgPrefixes[GrounderConfig] = field(default_factory=GrounderConfig)
+    executor: OmitArgPrefixes[ExecutorConfig] = field(default_factory=ExecutorConfig)
+    path: OmitArgPrefixes[PathConfig] = field(default_factory=PathConfig)
+    engineering: OmitArgPrefixes[KBConfig] = field(default_factory=KBConfig)
+    config: str | None = None  # Config file path.
+
+
+def _load_config_file(path: str) -> dict[str, Any]:
+    with open(path, encoding="utf-8") as f:
+        if path.endswith(('.yaml', '.yml')):
+            data = yaml.safe_load(f)
+        elif path.endswith('.json'):
+            data = json.load(f)
+        else:
+            raise ValueError("Unsupported config file format: must be .yaml, .yml, or .json")
+
+    if not isinstance(data, dict):
+        raise TypeError(f"Config file must contain a dict, got {type(data)}")
+    return cast("dict[str, Any]", data)
+
+
+def _save_config(config: dict[str, Any], path: str) -> None:
+    with open(path, 'w', encoding='utf8') as f:
+        yaml.dump(config, f, sort_keys=False)
+
+
+def _init_logger(log_path: str | None = None,
+                 run_id: str | None = None,
+                 log_name: str = "run.log",
+                 log_level: int = logging.INFO) -> logging.Logger:  # Literal is best but too verbose here.
+    """
+    Initialize the logging system; paths come from config.log_dir.
+    Supports per-run log files by run_id.
+    """
+    if run_id is None:
+        run_id = datetime.now(UTC).astimezone().strftime("%Y%m%d_%H%M%S")
+
+    log_dir = Path(log_path) if log_path else Path("./log")
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    log_file = log_dir / f"{run_id}_{log_name}"
+
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+
+    # Get the root logger and clear old handlers (avoid duplicate output).
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    logger.handlers.clear()
+
+    # File log handler.
+    file_handler = logging.FileHandler(log_file, mode='a')
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    # Console handler.
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    logger.setLevel(log_level)
+
+    logger.info("Logger initialized at %s", log_file)
+
+    return logger
+
+
+def _init_config_cli() -> Config:
+    """Initialize config and logging."""
+    cli_config, unknown = tyro.cli(Config, return_unknown_args=True)  # Parse CLI args via tyro. HACK: may parse manually later.
+    if unknown:
+        warnings.warn(f"Unknown kele parameters ignored: {unknown}", stacklevel=2)
+
+    no_default_fields = [field.name for field in fields(Config) if field.default is field.default_factory]
+    base_config: dict[str, dict[Any, Any]] = {k: {} for k in no_default_fields}  # Avoid errors if YAML misses child configs.
+    # If child configs have new required fields, this still fails; we could recurse but treat it as unnecessary for now.
+    file_config = base_config | _load_config_file(cli_config.config) if cli_config.config else base_config
+
+    # Merge config file and CLI parameters.
+    final_config, _ = tyro.cli(Config, return_unknown_args=True, default=dacite.from_dict(Config,
+                                                                                          file_config,
+                                                                                          config=daConfig(strict=True)))
+    return final_config
+
+
+def _build_config(user_config: Config | None = None,
+                  config_file_path: str | None = None) -> Config:
+    """Build a `Config` from CLI arguments, an in-code default, or a config file.
+
+    This function provides a single entry point to construct the runtime configuration:
+    - If `user_config` is provided, parse CLI overrides on top of it.
+    - If `config_file_path` is provided, load the file config and allow CLI overrides.
+    - Otherwise, initialize purely from CLI (and its config argument).
+
+    :param user_config: A default `Config` instance to be used as the CLI default.
+            Mutually exclusive with `config_file_path` (and also incompatible with
+            `user_config.config` being set).
+    :param config_file_path: Path to a config file (e.g., YAML/JSON). Mutually
+            exclusive with `user_config`.
+    :return: The final merged `Config` instance.
+
+    :raises: ValueError: If `user_config` is used together with `config_file_path`
+            or when `user_config.config` is set.
+    """  # noqa: DOC501
+    if user_config and (user_config.config or config_file_path):
+        raise ValueError("default config instance and config file cannot be used together")
+
+    if user_config:
+        return tyro.cli(Config, default=user_config)  # Parameters passed programmatically.
+
+    if config_file_path:
+        file_config = _load_config_file(config_file_path)
+        merged_config, _ = tyro.cli(Config, return_unknown_args=True, default=dacite.from_dict(Config,
+                                                                                              file_config,
+                                                                                              config=daConfig(strict=True)))
+        return merged_config
+
+    return _init_config_cli()
+
+
+def init_config_logger(user_config: Config | None = None,
+                       config_file_path: str | None = None,
+                       *,
+                       run_id: str | None = None,
+                       log_name: str = "run.log") -> Config:
+    """Initialize configuration and logger.
+
+    This is the public entry point. It builds the final `Config` (from CLI/code/file)
+    and initializes the logger under `config.path.log_dir`, then logs the final config.
+
+    :param: user_config: A default `Config` instance to be used as the CLI default.
+            Mutually exclusive with `config_file_path`.
+    :param: config_file_path: Path to a config file. Mutually exclusive with `user_config`.
+    :param: run_id: Optional run identifier used by the logger initializer.
+    :param: log_name: Suffix of log file name ({run_id}_{log_name}). Defaults to "run.log".
+
+    :return: The final merged `Config` instance.
+    """
+    config = _build_config(user_config, config_file_path)
+
+    logger = _init_logger(config.path.log_dir,
+                          run_id=run_id, log_name=log_name,
+                          log_level=getattr(logging, config.run.log_level.upper(), logging.INFO))
+
+    logger.info("Final Config:\n%s", yaml.dump(config.__dict__, sort_keys=False, allow_unicode=True))
+
+    return config

kele/control/README_metrics.md

@@ -0,0 +1,102 @@
+本文档由GPT5撰写。
+
+# Metrics 使用说明
+
+本模块提供了推理过程中的性能指标采集与记录功能，包括 **速度**、**CPU 占用**、**内存使用** 等。  
+虽然目前速度是最主要的关注点，但也支持记录其他资源指标。
+
+## 功能概览
+- **指标类型**  
+  - `duration_seconds`：代码或函数运行耗时（秒）
+  - `cpu_percent`：CPU 占用百分比
+  - `rss_mib`：进程占用内存（MiB）
+  - 迭代次数、规则数、事实数等离散计数指标
+
+- **记录方式**
+  - **代码级**：使用 `PhaseTimer` 上下文管理器，手动分段计时
+  - **函数级**：使用 `@measure` 装饰器，自动记录函数执行时间和资源占用
+  - 可通过 `observe_counts`、`sample_process_gauges` 等函数采集自定义指标
+
+- **结果存储**  
+  默认保存在 **`metrics_logs`** 文件夹下，以 `run_id.json` 命名，包含运行元信息和事件记录。
+
+## 快速开始
+
+### 1. 初始化
+```python
+from metrics import init_metrics
+init_metrics(port=14233, job="al_inference", grouping={"env": "dev"})
+```
+
+### 2. 开始与结束一次运行
+```python
+from metrics import start_run, end_run
+
+run_id = start_run(log_dir="metrics_logs")
+# ... 推理或业务逻辑 ...
+end_run(extra_meta={"facts_final": 100, "rules_total": 50})
+```
+
+### 3. 代码级计时（阶段）
+```python
+from metrics import PhaseTimer
+
+with PhaseTimer("grounding", module="pipeline"):
+    do_grounding()
+```
+
+### 4. 函数级计时
+```python
+from metrics import measure
+
+@measure("infer_step", module="inference")
+def infer_step():
+    # 推理步骤逻辑
+    pass
+```
+
+### 5. 采集计数与进程状态
+```python
+from metrics import observe_counts, sample_process_gauges
+
+observe_counts(grounded_rules=10, facts_count=200)
+sample_process_gauges()
+```
+
+## 日志文件示例
+
+一次运行的 `metrics_logs/20230801-120000-ab12cd.json` 文件内容示例：
+
+```json
+{
+    "meta": {
+        "run_id": "20230801-120000-ab12cd",
+        "started_at": "2023-08-01T12:00:00+08:00",
+        "ended_at": "2023-08-01T12:00:10+08:00",
+        "cpu_percent_max": 85.3,
+        "cpu_percent_mean": 42.7,
+        "rss_max_mib": 512.4,
+        "phase_durations_seconds_total": [
+            {"module": "pipeline", "phase": "grounding", "duration_seconds_total": 2.53},
+            {"module": "pipeline", "phase": "execute", "duration_seconds_total": 5.42}
+        ],
+        "all_phases_duration_seconds_total": 7.95,
+        "function_durations_seconds_total": [
+            {"module": "inference", "name": "main_infer", "duration_seconds_total": 8.02}
+        ],
+        "all_functions_duration_seconds_total": 8.02,
+        "facts_final": 150,
+        "rules_total": 200
+    },
+    "events": [
+        {"timestamp": "2023-08-01T12:00:00+08:00", "event": "process_sample", "cpu_percent": 30.5, "rss_mib": 400.2},
+        {"timestamp": "2023-08-01T12:00:02+08:00", "event": "phase_timing", "module": "pipeline", "phase": "grounding", "duration_seconds": 2.53},
+        {"timestamp": "2023-08-01T12:00:07+08:00", "event": "phase_timing", "module": "pipeline", "phase": "execute", "duration_seconds": 5.42},
+        {"timestamp": "2023-08-01T12:00:10+08:00", "event": "func_timing", "module": "inference", "name": "main_infer", "duration_seconds": 8.02}
+    ]
+}
+```
+
+## 备注
+- 该模块可独立用于代码性能测试，也可集成至推理引擎或其他系统。
+- 如需推送到 Prometheus Pushgateway，可在 `init_metrics` 中配置 `pushgateway` 参数。

kele/control/__init__.py

@@ -0,0 +1,20 @@
+"""用于callbacks和推理路径的记录"""
+from .callback import HookMixin, Callback, CallbackManager
+from .status import (
+    InferenceStatus,
+    create_main_loop_manager,
+    create_executor_manager,
+)
+from .grounding_selector import GroundingRuleSelector
+from .infer_path import InferencePath
+
+__all__ = [
+    'Callback',
+    'CallbackManager',
+    'GroundingRuleSelector',
+    'HookMixin',
+    'InferencePath',
+    'InferenceStatus',
+    'create_executor_manager',
+    'create_main_loop_manager',
+]

kele/control/callback.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from kele.equality import Equivalence
+    from kele.grounder import GroundedRule
+    from kele.knowledge_bases import FactBase, RuleBase
+    from kele.syntax import Question, Rule, FACT_TYPE, Variable, Constant, CompoundTerm
+    from collections.abc import Callable
+
+
+class HookMixin:
+    """
+    提供模块自身注册hook和执行hook的 Mixin类，需要的模块可以直接继承它
+
+    :ivar _hooks: 事件名称到钩子函数列表的映射。
+    """
+    def __init__(self) -> None:
+        self._hooks: dict[str, list[Callable[..., None]]] = defaultdict(list)
+
+    def register_hook(self, event_name: str, hook_fn: Callable[..., None]) -> None:
+        """
+        为指定事件注册钩子函数。
+
+        :param event_name: 要监听的事件名称。
+        :param hook_fn: 接受任意参数的可调用钩子函数。
+        """
+        self._hooks[event_name].append(hook_fn)
+
+    def _run_hooks(self, event_name: str, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+        """
+        执行所有注册到指定事件的钩子。
+
+        :param event_name: 事件名称。
+        :param args: 传递给钩子的所有位置参数。
+        :param kwargs: 传递给钩子的所有关键字参数。
+        """
+        for hook in self._hooks.get(event_name, []):
+            hook(*args, **kwargs)
+
+
+class Callback:
+    """回调接口——在推理各阶段采集指标的Hook"""
+
+    def on_infer_start(
+        self,
+        question: Question,
+        fact_base: FactBase,
+        rule_base: RuleBase,
+    ) -> None:
+        """
+        推理开始时调用
+
+        :param question: 待推理的问题
+        :param fact_base: 事实库
+        :param rule_base: 规则库
+        """
+
+    def on_grounder_select_start(
+        self,
+        question: Question,
+        fact_base: FactBase,
+        rule_base: RuleBase,
+    ) -> None:  # HACK: 参数可能需要包括grounder的选择策略？但有点没必要感觉，毕竟策略也不一定按str分类
+        """
+        Grounder选取前调用
+
+        :param question: 待推理的问题
+        :param fact_base: 事实库
+        :param rule_base: 规则库
+        """
+
+    def on_grounder_select_end(
+        self,
+        selected_rule_terms_pair: list[tuple[Rule, list[FACT_TYPE]]],
+        candidate_rules: RuleBase,
+        fact_base: FactBase,
+        question: Question,
+    ) -> None:
+        """
+        Grounder 选取后调用。
+
+        :param selected_rule_terms_pair: 与该规则匹配的事实列表
+        :param candidate_rules: 本次 Grounder 考虑的所有候选规则列表，因为目前是直接从代码中选取，所以就约定为规则库即可
+        :param question: 待推理的问题
+        :param fact_base: 事实库列表
+        """
+
+    def on_binding_change(
+        self,
+        var_name: str,
+        var_value: Constant | CompoundTerm
+    ) -> None:
+        """
+        每次变量绑定/解绑时调用。这个函数暂且作为提示性作用，如果它在_RuleNode中起作用，日后可能会被on_rule_activation替代
+        如果在其他节点或者说_TupleTable层面就起作用，那激活频率又太高了
+
+        :param var_name: 变量名
+        :param var_value: 变量值
+        """
+
+    def on_rule_activation(
+        self,
+        rule: Rule,
+        var_dict: dict[Variable, Constant | CompoundTerm]
+    ) -> None:
+        """
+        每次 RuleNode 被激活（进入执行）时调用。
+
+        :param rule: 当前激活的规则
+        :param var_dict: 每次传递一个实例化候选元组
+        # risk: 能否思考这里计算推理深度depth: int 参数，或者与infer path联动
+        """
+
+    def on_executor_start(
+        self,
+        grounded_rules: list[GroundedRule],
+        question: Question,
+        equivalence: Equivalence,
+    ) -> None:  # HACK: 参数可能需要包括executor的选择策略？但有点没必要感觉，毕竟策略也不一定按str分类
+        """
+        Executor 执行前调用。
+
+        :param grounded_rules: 已实例化的规则列表
+        :param question: 待推理的问题
+        :param equivalence: 为规则检验提供支持的等价类
+        """
+
+    def on_executor_sorted(
+        self,
+        sorted_rules: list[GroundedRule],
+        original_rules: list[GroundedRule],
+        question: Question,
+    ) -> None:
+        """
+        Executor 排序后调用。
+
+        :param sorted_rules: 排序后的规则列表
+        :param original_rules: 排序前的规则列表
+        :param question: 待推理的问题
+        """
+
+    def on_executor_post(
+        self,
+        execution_results: Any,  # 包含一些新生成的事实，可能还有别的  # noqa: ANN401  # TODO: 细节待定
+        question: Question,
+    ) -> None:
+        """
+        Executor 执行后调用。
+
+        :param execution_results: 执行返回的原始结果（包含路径、绑定信息等）
+        :param question: 待推理的问题
+        """
+
+    def on_infer_end(
+        self,
+        final_result: Any,  # FIXME: 尚不清楚类型，同on_executor_post  # noqa: ANN401
+        question: Question,
+        metrics: Any  # noqa: ANN401  # FIXME: 细节待定
+    ) -> None:
+        """
+        推理完成时调用，汇总全流程指标并评估准确率。
+
+        :param final_result: 最终推理输出
+        :param question: 待推理的问题
+        :param metrics: 可能的各种对结果的评价等信息
+        """
+
+
+class CallbackManager:
+    """通过这个类注册实例化后的Callback"""
+    def __init__(self) -> None:
+        self._callbacks: list[Callback] = []
+
+    def register_callback(self, callback: Callback) -> None:
+        """
+        注册一个回调实例。
+        :param callback: Callback的子类实例
+        """
+        self._callbacks.append(callback)
+
+    def unregister_callback(self, callback: Callback) -> None:
+        """
+        注销一个回调实例。
+        """
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+
+    # Infer start
+    def on_infer_start(self, question: Question, fact_base: FactBase, rule_base: RuleBase) -> None:
+        """对应Callback的on_infer_start"""
+        for cb in self._callbacks:
+            cb.on_infer_start(question, fact_base, rule_base)
+
+    # Grounder selection hooks
+    def on_grounder_select_start(self, question: Question, fact_base: FactBase, rule_base: RuleBase) -> None:
+        """对应Callback的on_grounder_select_start"""
+        for cb in self._callbacks:
+            cb.on_grounder_select_start(question, fact_base, rule_base)
+
+    def on_grounder_select_end(
+        self,
+        selected_rule_terms_pair: list[tuple[Rule, list[FACT_TYPE]]],
+        candidate_rules: RuleBase,
+        fact_base: FactBase,
+        question: Question,
+    ) -> None:
+        """对应Callback的on_grounder_select_end"""
+        for cb in self._callbacks:
+            cb.on_grounder_select_end(selected_rule_terms_pair, candidate_rules, fact_base, question)
+
+    # Binding hook
+    def on_binding_change(self, var_name: str, var_value: Constant | CompoundTerm) -> None:
+        """对应Callback的on_binding_change"""
+        for cb in self._callbacks:
+            cb.on_binding_change(var_name, var_value)
+
+    # Rule activation
+    def on_rule_activation(self, rule: Rule, var_dict: dict[Variable, Constant | CompoundTerm]) -> None:
+        """对应Callback的on_rule_activation"""
+        for cb in self._callbacks:
+            cb.on_rule_activation(rule, var_dict)
+
+    # Executor hooks
+    def on_executor_start(self,
+                          grounded_rules: list[GroundedRule],
+                          question: Question,
+                          equivalence: Equivalence) -> None:
+        """对应Callback的on_executor_start"""
+        for cb in self._callbacks:
+            cb.on_executor_start(grounded_rules, question, equivalence)
+
+    def on_executor_sorted(
+        self,
+        sorted_rules: list[GroundedRule],
+        original_rules: list[GroundedRule],
+        question: Question,
+    ) -> None:
+        """对应Callback的on_executor_sorted"""
+        for cb in self._callbacks:
+            cb.on_executor_sorted(sorted_rules, original_rules, question)
+
+    def on_executor_post(self, execution_results: Any, question: Question) -> None:  # noqa: ANN401  # FIXME: 同Callback
+        """对应Callback的on_executor_post"""
+        for cb in self._callbacks:
+            cb.on_executor_post(execution_results, question)
+
+    # Infer end
+    def on_infer_end(self, final_result: Any, question: Question, metrics: Any) -> None:  # noqa: ANN401  # FIXME: 同Callback
+        """对应Callback的on_infer_end"""
+        for cb in self._callbacks:
+            cb.on_infer_end(final_result, question, metrics)

kele/control/grounding_selector/__init__.py

@@ -0,0 +1,5 @@
+"""grounding相关的选择器"""
+from .rule_selector import GroundingRuleSelector
+from .term_selector import GroundingFlatTermWithWildCardSelector
+
+__all__ = ["GroundingFlatTermWithWildCardSelector", "GroundingRuleSelector"]

kele/control/grounding_selector/_rule_strategies/README.md

@@ -0,0 +1,13 @@
+## 默认strategy
+
+### SequentialCyclic
+按顺序逐个选择规则，每次选1条。
+
+### SequentialCyclicWithPriority
+根据规则的priority排序后，按顺序逐个选择规则，每次选1条。
+
+## 创建自己的strategy
+1. 创建一个py文件，命名要求为`_<name>_strategy.py`；
+2. 继承RuleSelectionStrategy类，并至少声明此Protocol要求的函数；
+3. 使用`@register_strategy('<name>')`注册你的策略类，后续即可通过`grounding_rule_strategy`使用策略；
+4. 注意调整`grounding_rule_strategy`的类型标注（增加Literal的候选值）。