fix linting issues

fix linting issues

Author: asamal4

lsc_eval/README.md

@@ -30,7 +30,7 @@ cd lsc_eval && pdm install
 export OPENAI_API_KEY="your-key"
 
 # Run evaluation (Create your own data)
-python runner.py --system-config config/system.yaml --eval-data config/evaluation_data.yaml
+python -m runner --system-config config/system.yaml --eval-data config/evaluation_data.yaml
 ```
 
 ## 📊 Supported Metrics

lsc_eval/pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
     "datasets>=2.0.0",
     "matplotlib>=3.5.0",
     "seaborn>=0.11.0",
-    "numpy>=1.21.0"
+    "numpy>=1.23.0"
 ]
 
 [tool.pdm.dev-dependencies]
@@ -46,6 +46,9 @@ build-backend = "pdm.backend"
 [tool.pdm]
 distribution = true
 
+[tool.pdm.build]
+includes = ["lsc_eval/config/*.yaml"]
+
 [tool.ruff]
 # always generate Python 3.11-compatible code.
 target-version = "py311"

lsc_eval/runner.py

@@ -4,7 +4,7 @@
 Simple interface that uses EvaluationEngine as the core controller.
 
 Usage:
-    python runner.py --system-config config/system.yaml --eval-data config/evaluation_data.yaml
+    python -m runner --system-config config/system.yaml --eval-data config/evaluation_data.yaml
 
 Or programmatically:
     from runner import run_evaluation
@@ -48,7 +48,9 @@ def run_evaluation(
         data_validator = DataValidator()
         evaluation_data = data_validator.load_evaluation_data(evaluation_data_path)
 
-        print(f"✅ System config: {system_config.llm_provider}/{system_config.llm_model}")
+        print(
+            f"✅ System config: {system_config.llm_provider}/{system_config.llm_model}"
+        )
         print(f"✅ Evaluation data: {len(evaluation_data)} conversation groups")
 
         # Step 2: Initialize evaluation engine (core controller)
@@ -67,7 +69,9 @@ def run_evaluation(
             system_config=system_config,
         )
 
-        output_handler.generate_reports(results, include_graphs=system_config.include_graphs)
+        output_handler.generate_reports(
+            results, include_graphs=system_config.include_graphs
+        )
 
         print("\n🎉 Evaluation Complete!")
         print(f"📊 {len(results)} evaluations completed")
@@ -81,7 +85,9 @@ def run_evaluation(
         )
 
         if summary["ERROR"] > 0:
-            print(f"⚠️ {summary['ERROR']} evaluations had errors - check detailed report")
+            print(
+                f"⚠️ {summary['ERROR']} evaluations had errors - check detailed report"
+            )
 
         return {
             "TOTAL": summary["TOTAL"],
@@ -96,7 +102,7 @@ def run_evaluation(
         return None
 
 
-def main():
+def main() -> int:
     """Command line interface."""
     parser = argparse.ArgumentParser(description="LSC Evaluation Framework / Tool")
     parser.add_argument(

lsc_eval/src/lsc_eval/__init__.py

@@ -3,14 +3,14 @@
 from .core import (
     ConfigLoader,
     DataValidator,
-    SystemConfig,
     EvaluationData,
     EvaluationResult,
+    SystemConfig,
     TurnData,
 )
 from .evaluation_engine import EvaluationEngine
 from .llm_managers.llm_manager import LLMManager
-from .output import OutputHandler
+from .output.output_handler import OutputHandler
 
 __all__ = [
     "SystemConfig",

lsc_eval/src/lsc_eval/core/__init__.py

@@ -1,6 +1,11 @@
 """Core functionality - Configuration, data validation, and models."""
 
-from .config_loader import ConfigLoader, SystemConfig, setup_environment_variables, validate_metrics
+from .config_loader import (
+    ConfigLoader,
+    SystemConfig,
+    setup_environment_variables,
+    validate_metrics,
+)
 from .data_validator import DataValidator
 from .models import EvaluationData, EvaluationResult, LLMConfig, TurnData
 

lsc_eval/src/lsc_eval/core/config_loader.py

@@ -2,11 +2,14 @@
 
 import logging
 import os
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 import yaml
 from pydantic import BaseModel, Field
 
+if TYPE_CHECKING:
+    from .models import EvaluationData
+
 # Global metric mapping sets (populated dynamically from system config)
 TURN_LEVEL_METRICS: set[str] = set()
 CONVERSATION_LEVEL_METRICS: set[str] = set()
@@ -24,7 +27,7 @@
 ]
 
 
-def setup_environment_variables(config_path: str):
+def setup_environment_variables(config_path: str) -> None:
     """Early setup of environment variables from system config. Called before any other imports."""
     try:
         with open(config_path, "r", encoding="utf-8") as f:
@@ -44,18 +47,22 @@ def setup_environment_variables(config_path: str):
         os.environ["LITELLM_LOG_LEVEL"] = "ERROR"
 
 
-def setup_logging(logging_config: Dict[str, Any]):
+def setup_logging(logging_config: Dict[str, Any]) -> logging.Logger:
     """Configure logging for application and packages."""
     # Get logging settings with new structure
     source_level = getattr(logging, logging_config.get("source_level", "INFO").upper())
-    package_level = getattr(logging, logging_config.get("package_level", "WARNING").upper())
+    package_level = getattr(
+        logging, logging_config.get("package_level", "WARNING").upper()
+    )
     log_format = logging_config.get(
         "format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
 
     # Configure root logger for our application
     logging.basicConfig(
-        level=source_level, format=log_format, force=True  # Override any existing configuration
+        level=source_level,
+        format=log_format,
+        force=True,  # Override any existing configuration
     )
 
     # Set logging levels for packages using system configuration
@@ -85,7 +92,9 @@ def setup_logging(logging_config: Dict[str, Any]):
             override_level_obj = getattr(logging, override_level.upper())
             logging.getLogger(package_name).setLevel(override_level_obj)
         except AttributeError:
-            print(f"Warning: Invalid log level '{override_level}' for package '{package_name}'")
+            print(
+                f"Warning: Invalid log level '{override_level}' for package '{package_name}'"
+            )
 
     # Get logger for our application
     logger = logging.getLogger("lsc_eval")
@@ -102,7 +111,7 @@ def setup_logging(logging_config: Dict[str, Any]):
     return logger
 
 
-def populate_metric_mappings(metrics_metadata: Dict[str, Any]):
+def populate_metric_mappings(metrics_metadata: Dict[str, Any]) -> None:
     """Populate global metric mapping sets from system config metadata."""
     TURN_LEVEL_METRICS.clear()
     CONVERSATION_LEVEL_METRICS.clear()
@@ -120,7 +129,9 @@ def populate_metric_mappings(metrics_metadata: Dict[str, Any]):
             CONVERSATION_LEVEL_METRICS.add(metric_name)
 
 
-def validate_metrics(turn_metrics: List[str], conversation_metrics: List[str]) -> List[str]:
+def validate_metrics(
+    turn_metrics: List[str], conversation_metrics: List[str]
+) -> List[str]:
     """Validate that provided metrics are recognized."""
     errors = []
 
@@ -151,7 +162,9 @@ class SystemConfig(BaseModel):
     # Logging Configuration
     logging_source_level: str = Field(default="INFO")
     logging_package_level: str = Field(default="WARNING")
-    logging_format: str = Field(default="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    logging_format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
     logging_show_timestamps: bool = Field(default=True)
     logging_package_overrides: Dict[str, str] = Field(default_factory=dict)
 
@@ -169,18 +182,22 @@ class SystemConfig(BaseModel):
     visualization_dpi: int = Field(default=300)
 
     # Default metrics metadata from system config
-    default_turn_metrics_metadata: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
-    default_conversation_metrics_metadata: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+    default_turn_metrics_metadata: Dict[str, Dict[str, Any]] = Field(
+        default_factory=dict
+    )
+    default_conversation_metrics_metadata: Dict[str, Dict[str, Any]] = Field(
+        default_factory=dict
+    )
 
 
 class ConfigLoader:
     """Configuration loader for LSC Evaluation Framework."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize Config Loader."""
-        self.system_config = None
-        self.evaluation_data = None
-        self.logger = None
+        self.system_config: Optional[SystemConfig] = None
+        self.evaluation_data: Optional[List[EvaluationData]] = None
+        self.logger: Optional[logging.Logger] = None
 
     def load_system_config(self, config_path: str) -> SystemConfig:
         """Load system configuration from YAML file."""
@@ -229,7 +246,9 @@ def load_system_config(self, config_path: str) -> SystemConfig:
             visualization_dpi=visualization_config.get("dpi", 300),
             # Default metrics metadata from system config
             default_turn_metrics_metadata=metrics_metadata.get("turn_level", {}),
-            default_conversation_metrics_metadata=metrics_metadata.get("conversation_level", {}),
+            default_conversation_metrics_metadata=metrics_metadata.get(
+                "conversation_level", {}
+            ),
         )
 
         self.logger.debug(

lsc_eval/src/lsc_eval/core/data_validator.py

@@ -1,20 +1,20 @@
 """Data validation of input data before evaluation."""
 
-from typing import List
+from typing import List, Optional
 
 import yaml
 
-from .models import EvaluationData
 from .config_loader import CONVERSATION_LEVEL_METRICS, TURN_LEVEL_METRICS
+from .models import EvaluationData
 
 
 class DataValidator:
     """Data validator for evaluation data."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize validator."""
-        self.validation_errors = []
-        self.evaluation_data = None
+        self.validation_errors: List[str] = []
+        self.evaluation_data: Optional[List[EvaluationData]] = None
 
     def load_evaluation_data(self, data_path: str) -> List[EvaluationData]:
         """Load and validate evaluation data from YAML file."""
@@ -53,7 +53,7 @@ def validate_evaluation_data(self, evaluation_data: List[EvaluationData]) -> boo
         print("✅ All data validation passed")
         return True
 
-    def _validate_metrics_availability(self, data: EvaluationData):
+    def _validate_metrics_availability(self, data: EvaluationData) -> None:
         """Validate that specified metrics are available/supported."""
         conversation_id = data.conversation_group_id
 
@@ -71,7 +71,7 @@ def _validate_metrics_availability(self, data: EvaluationData):
                     f"Conversation {conversation_id}: Unknown conversation metric '{metric}'"
                 )
 
-    def _validate_metric_requirements(self, data: EvaluationData):
+    def _validate_metric_requirements(self, data: EvaluationData) -> None:
         """Validate that required fields exist for specified metrics."""
         conversation_id = data.conversation_group_id
 

lsc_eval/src/lsc_eval/core/models.py

@@ -56,7 +56,9 @@ class EvaluationData(BaseModel):
 
     # Metric-specific configuration (threshold, weights, etc.)
     turn_metrics_metadata: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
-    conversation_metrics_metadata: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+    conversation_metrics_metadata: Dict[str, Dict[str, Any]] = Field(
+        default_factory=dict
+    )
 
     # Conversation turns
     turns: List[TurnData]
@@ -83,7 +85,9 @@ def validate_metrics(cls, v: List[str]) -> List[str]:
         """Validate metrics are properly formatted."""
         for metric in v:
             if not metric or ":" not in metric:
-                raise ValueError(f'Metric "{metric}" must be in format "framework:metric_name"')
+                raise ValueError(
+                    f'Metric "{metric}" must be in format "framework:metric_name"'
+                )
         return v
 
     def validate_metric_requirements(self) -> List[str]:
@@ -114,7 +118,10 @@ def validate_metric_requirements(self) -> List[str]:
                         f"TurnData {turn_data.turn_id}: Metric '{metric}' requires contexts"
                     )
 
-                if metric in expected_response_required_metrics and not turn_data.expected_response:
+                if (
+                    metric in expected_response_required_metrics
+                    and not turn_data.expected_response
+                ):
                     errors.append(
                         f"TurnData {turn_data.turn_id}: "
                         f"Metric '{metric}' requires expected_response"
@@ -168,10 +175,16 @@ class LLMConfig(BaseModel):
     model_name: str = Field(..., description="The model name to use")
     api_base: Optional[str] = Field(None, description="Custom API base URL")
     api_key: Optional[str] = Field(None, description="API key for the model")
-    temperature: float = Field(0.0, ge=0.0, le=2.0, description="Temperature for sampling")
-    max_tokens: Optional[int] = Field(None, ge=1, description="Maximum tokens to generate")
+    temperature: float = Field(
+        0.0, ge=0.0, le=2.0, description="Temperature for sampling"
+    )
+    max_tokens: Optional[int] = Field(
+        None, ge=1, description="Maximum tokens to generate"
+    )
     timeout: Optional[int] = Field(None, ge=1, description="Request timeout in seconds")
-    num_retries: int = Field(3, ge=0, description="Number of retries for failed requests")
+    num_retries: int = Field(
+        3, ge=0, description="Number of retries for failed requests"
+    )
 
     @field_validator("model_name")
     @classmethod