pylints

Author: CHERRY-ui8

graphgen/models/evaluator/qa/length_evaluator.py

@@ -5,8 +5,9 @@
 
 
 class LengthEvaluator(BaseEvaluator):
-    def __init__(self):
-        self.tokenizer: Tokenizer = Tokenizer(os.environ["TOKENIZER_MODEL"] or "cl100k_base")
+    def __init__(self, tokenizer_name: str = None):
+        tokenizer_model = tokenizer_name or os.environ.get("TOKENIZER_MODEL", "cl100k_base")
+        self.tokenizer: Tokenizer = Tokenizer(tokenizer_model)
 
     def evaluate(self, pair: QAPair) -> float:
         """

graphgen/models/evaluator/qa/uni_evaluator.py

@@ -55,9 +55,9 @@ def _build_input_text(dimension: str, question: str, answer: str) -> str:
         """Construct input text for specified dimension."""
         if dimension == "naturalness":
             return f"question: Is this a natural response? </s> response: {answer}"
-        elif dimension == "coherence":
+        if dimension == "coherence":
             return f"question: Is this a coherent response? </s> response: {answer} </s> history: {question}"
-        elif dimension == "understandability":
+        if dimension == "understandability":
             return f"question: Is this an understandable response? </s> response: {answer}"
         raise NotImplementedError(f"Unsupported dimension '{dimension}'")
 

graphgen/operators/__init__.py

@@ -8,7 +8,6 @@
 from .quiz import QuizService
 from .read import read
 from .search import SearchService
-from .evaluate import EvaluateService
 
 
 operators = {

graphgen/operators/evaluate/evaluate_kg.py

@@ -28,30 +28,30 @@ def __init__(
         self.chunk_storage: BaseKVStorage = init_storage(
             backend=kv_backend, working_dir=working_dir, namespace="chunk"
         )
-        
+
         # Initialize LLM client
         self.llm_client: BaseLLMWrapper = init_llm("synthesizer")
-        
+
         # Initialize individual evaluators
         self.accuracy_evaluator = AccuracyEvaluator(
             graph_storage=self.graph_storage,
             chunk_storage=self.chunk_storage,
             llm_client=self.llm_client,
         )
-        
+
         self.consistency_evaluator = ConsistencyEvaluator(
             graph_storage=self.graph_storage,
             chunk_storage=self.chunk_storage,
             llm_client=self.llm_client,
         )
-        
+
         # Structure evaluator doesn't need chunk_storage or llm_client
         structure_params = kwargs.get("structure_params", {})
         self.structure_evaluator = StructureEvaluator(
             graph_storage=self.graph_storage,
             **structure_params
         )
-        
+
         logger.info("KG evaluators initialized")
 
 

graphgen/operators/evaluate/evaluate_service.py

@@ -32,15 +32,15 @@ def __init__(
         self.kwargs = kwargs
         self.graph_backend = graph_backend
         self.kv_backend = kv_backend
-        
+
         # Separate QA and KG metrics
         self.qa_metrics = [m for m in self.metrics if m.startswith("qa_")]
         self.kg_metrics = [m for m in self.metrics if m.startswith("kg_")]
-        
+
         # Initialize evaluators
         self.qa_evaluators = {}
         self.kg_evaluators: Optional[KGEvaluators] = None
-        
+
         self._init_evaluators()
 
     def _init_evaluators(self):
@@ -68,7 +68,7 @@ def _init_evaluators(self):
                 )
             else:
                 raise ValueError(f"Unknown QA metric: {metric}")
-        
+
         # Initialize KG evaluators if KG metrics are specified
         if self.kg_metrics:
             kg_params = self.kwargs.get("kg_params", {})
@@ -148,14 +148,14 @@ def _evaluate_kg(self) -> Dict[str, Any]:
             return {}
 
         results = {}
-        
+
         # Map metric names to evaluation functions
         kg_metric_map = {
             "kg_accuracy": evaluate_accuracy,
             "kg_consistency": evaluate_consistency,
             "kg_structure": evaluate_structure,
         }
-        
+
         # Run KG evaluations based on metrics
         for metric in self.kg_metrics:
             if metric in kg_metric_map:
@@ -168,12 +168,12 @@ def _evaluate_kg(self) -> Dict[str, Any]:
                     results[metric_key] = {"error": str(e)}
             else:
                 logger.warning("Unknown KG metric: %s, skipping", metric)
-        
+
         # If no valid metrics were found, run all evaluations
         if not results:
             logger.info("No valid KG metrics found, running all evaluations")
             results = evaluate_all(self.kg_evaluators)
-        
+
         return results
 
     def evaluate(
@@ -182,39 +182,38 @@ def evaluate(
         # Determine evaluation type
         has_qa_metrics = len(self.qa_metrics) > 0
         has_kg_metrics = len(self.kg_metrics) > 0
-        
+
         # If items provided and QA metrics exist, do QA evaluation
         if items is not None and has_qa_metrics:
             return self._evaluate_qa(items)
-        
+
         # If KG metrics exist, do KG evaluation
         if has_kg_metrics:
             return self._evaluate_kg()
-        
+
         # If no metrics specified, try to infer from context
         if items is not None:
             logger.warning("No QA metrics specified but items provided, skipping evaluation")
             return []
-        else:
-            logger.warning("No metrics specified, skipping evaluation")
-            return {}
+        logger.warning("No metrics specified, skipping evaluation")
+        return {}
 
     def process(self, batch: pd.DataFrame) -> pd.DataFrame:
         has_qa_metrics = len(self.qa_metrics) > 0
         has_kg_metrics = len(self.kg_metrics) > 0
-        
+
         # QA evaluation: process batch items
         if has_qa_metrics:
             items = batch.to_dict(orient="records")
             results = self._evaluate_qa(items)
             return pd.DataFrame(results)
-        
+
         # KG evaluation: evaluate from storage
         if has_kg_metrics:
             results = self._evaluate_kg()
             # Convert dict to DataFrame (single row)
             return pd.DataFrame([results])
-        
+
         # No metrics specified
         logger.warning("No metrics specified, returning empty DataFrame")
         return pd.DataFrame()

graphgen/templates/evaluation/kg/consistency_evaluation.py

@@ -100,4 +100,3 @@
     "en": "",
     "zh": ""
 }
-

graphgen/utils/help_nltk.py

@@ -3,16 +3,14 @@
 from typing import Dict, List, Final, Optional
 import warnings
 import nltk
+import jieba
 
 warnings.filterwarnings(
-    "ignore", 
+    "ignore",
     category=UserWarning,
-    module="jieba\._compat"
+    module=r"jieba\._compat"
 )
 
-
-import jieba
-
 class NLTKHelper:
     """
     NLTK helper class