feat: RuleQuanliangFieldValidation.eval去掉classmethod

dingo/exec/local.py

@@ -180,6 +180,11 @@ def evaluate_single_data(self, dingo_id: str, eval_fields: dict, eval_type: str,
                 model_cls = Model.rule_name_map.get(e_c_i.name)
                 model = model_cls()  # 实例化类为对象，避免多线程配置覆盖
                 Model.set_config_rule(model, e_c_i.config)
+                # Backward compatibility: most rules still use @classmethod eval,
+                # which reads class-level dynamic_config instead of instance-level.
+                eval_self = getattr(model.eval, "__self__", None)
+                if eval_self is model_cls:
+                    Model.set_config_rule(model_cls, e_c_i.config)
             elif eval_type == 'llm':
                 model_cls = Model.llm_name_map.get(e_c_i.name)
                 model = model_cls()

dingo/exec/spark.py

@@ -236,8 +236,13 @@ def evaluate_item(self, eval_fields: dict, eval_type: str, map_data: dict, eval_
 
         for e_c_i in eval_list:
             if eval_type == 'rule':
-                model = Model.rule_name_map.get(e_c_i.name)
+                model_cls = Model.rule_name_map.get(e_c_i.name)
+                model = model_cls()
                 Model.set_config_rule(model, e_c_i.config)
+                # Backward compatibility for classmethod-based rules.
+                eval_self = getattr(model.eval, "__self__", None)
+                if eval_self is model_cls:
+                    Model.set_config_rule(model_cls, e_c_i.config)
             elif eval_type == 'llm':
                 model = Model.llm_name_map.get(e_c_i.name)
                 Model.set_config_llm(model, e_c_i.config)

dingo/model/rule/scibase/rule_quanliang.py

@@ -750,11 +750,10 @@ class RuleQuanliangFieldValidation(BaseRule):
     _required_fields = []
     dynamic_config = EvaluatorRuleArgs(key_list=list(FIELD_VALIDATORS.keys()))
 
-    @classmethod
-    def eval(cls, input_data: Data) -> EvalDetail:
-        res = EvalDetail(metric=cls.__name__)
+    def eval(self, input_data: Data) -> EvalDetail:
+        res = EvalDetail(metric=self.__class__.__name__)
         normalized = normalize_record(input_data.to_dict())
-        selected_fields = cls.dynamic_config.key_list or []
+        selected_fields = self.dynamic_config.key_list or []
         bad_fields: List[str] = []
         reasons: List[str] = []
         for field in selected_fields:

test/scripts/exec/test_local.py

@@ -7,6 +7,43 @@
 
 
 class TestLocal:
+    def test_rule_runtime_config_key_list_applies_in_local_executor(self):
+        input_data = {
+            "evaluator": [],
+        }
+        input_args = InputArgs(**input_data)
+        executor = LocalExecutor(input_args)
+
+        eval_list = [
+            InputArgs(
+                evaluator=[
+                    {
+                        "fields": {},
+                        "evals": [
+                            {
+                                "name": "RuleQuanliangFieldValidation",
+                                "config": {
+                                    "key_list": ["doi", "references", "related_works", "citations"]
+                                },
+                            }
+                        ],
+                    }
+                ]
+            ).evaluator[0].evals[0]
+        ]
+
+        result = executor.evaluate_single_data(
+            dingo_id="1",
+            eval_fields={},
+            eval_type="rule",
+            map_data={},
+            eval_list=eval_list,
+        )
+
+        details = result.eval_details["default"][0]
+        assert details.metric == "RuleQuanliangFieldValidation"
+        assert details.label == ["doi", "references", "related_works", "citations"]
+
     def test_write_single_data_limit_per_file(self, tmp_path):
         input_data = {
             "executor": {

test/scripts/model/rule/test_rule_scibase.py

@@ -20,8 +20,10 @@ def test_rule_quanliang_cases_from_jsonl(self):
                     if not line:
                         continue
                     row = json.loads(line)
-                    RuleQuanliangFieldValidation.dynamic_config.key_list = row["key_list"]
-                    result = RuleQuanliangFieldValidation.eval(Data(**row["input"]))
+                    model = RuleQuanliangFieldValidation()
+                    model.dynamic_config = model.dynamic_config.model_copy(deep=True)
+                    model.dynamic_config.key_list = row["key_list"]
+                    result = model.eval(Data(**row["input"]))
 
                     assert result.metric == "RuleQuanliangFieldValidation"
                     assert result.status is row["expected_status"], row["case"]