fix: Remove unused variables and convert dict comprehensions

- Remove unused 'model' variable assignments in test files
- Remove unused 'original_threshold' variable assignment
- Convert dict comprehensions to dict() calls as required by newer Ruff rules
- Follow C416 rule: {x: y for x, y in zip(...)} -> dict(zip(...))
- Fix trailing whitespace issues

These fixes address specific Ruff linting errors from GitHub CI

Author: RuiFSP

src/automation/deployment_trigger.py

@@ -9,15 +9,15 @@
 import logging
 import subprocess
 import sys
-from typing import Any, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
 
 class DeploymentTrigger:
     """Simple deployment trigger using subprocess calls."""
 
-    def __init__(self, config_path: Optional[str] = None):
+    def __init__(self, config_path: str | None = None):
         """Initialize the deployment trigger.
 
         Args:
@@ -28,7 +28,7 @@ def __init__(self, config_path: Optional[str] = None):
     def trigger_deployment(
         self,
         deployment_name: str,
-        parameters: Optional[dict[str, Any]] = None,
+        parameters: dict[str, Any] | None = None,
         wait_for_completion: bool = False,
         timeout_seconds: int = 300,
     ) -> bool:
@@ -156,11 +156,11 @@ async def trigger_deployment():
     def trigger_retraining(
         self,
         deployment_name: str = "simulation-triggered-retraining",
-        week: Optional[int] = None,
-        performance_drop: Optional[float] = None,
-        baseline_score: Optional[float] = None,
-        current_score: Optional[float] = None,
-        training_data_path: Optional[str] = None,
+        week: int | None = None,
+        performance_drop: float | None = None,
+        baseline_score: float | None = None,
+        current_score: float | None = None,
+        training_data_path: str | None = None,
         wait_for_completion: bool = True,
         timeout_seconds: int = 300,
     ) -> bool:

src/automation/prefect_client.py

@@ -96,7 +96,7 @@ async def trigger_deployment_run(
                     deployments = await client.read_deployments()
                     available = [d.name for d in deployments]
                     logger.info(f"Available deployments: {available}")
-                except:
+                except Exception:
                     pass
                 raise ValueError(f"Deployment '{deployment_name}' not found")
 

src/automation/retraining_flow.py

@@ -10,7 +10,7 @@
 import sys
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pandas as pd
 from prefect import flow, task
@@ -79,7 +79,7 @@ def backup_current_model(
 @task(name="prepare-retraining-data")
 def prepare_retraining_data(
     original_data_path: str,
-    new_data_path: Optional[str] = None,
+    new_data_path: str | None = None,
     data_window_days: int = 365,
 ) -> tuple[pd.DataFrame, pd.DataFrame, dict]:
     """Prepare data for retraining with new observations."""
@@ -159,7 +159,7 @@ def train_new_model(
     train_data: pd.DataFrame,
     val_data: pd.DataFrame,
     model_type: str = "random_forest",
-    hyperparameters: Optional[dict] = None,
+    hyperparameters: dict | None = None,
 ) -> tuple[str, dict]:
     """Train a new model with the prepared data."""
     logger = get_run_logger()
@@ -324,7 +324,7 @@ def deploy_new_model(
     model_file_path: str,
     model_path: str,
     validation_results: dict,
-    deployment_metadata: Optional[dict] = None,
+    deployment_metadata: dict | None = None,
 ) -> dict:
     """Deploy the new model if validation passed."""
     logger = get_run_logger()
@@ -467,12 +467,12 @@ def automated_retraining_flow(
     triggers: list[str],
     model_path: str = "models/model.pkl",
     training_data_path: str = "data/real_data/premier_league_matches.parquet",
-    new_data_path: Optional[str] = None,
+    new_data_path: str | None = None,
     backup_dir: str = "models/backups",
     model_type: str = "random_forest",
     min_accuracy_threshold: float = 0.45,
     improvement_threshold: float = 0.01,
-    hyperparameters: Optional[dict] = None,
+    hyperparameters: dict | None = None,
 ) -> dict[str, Any]:
     """
     Main automated retraining flow.

src/automation/retraining_scheduler.py

@@ -12,7 +12,7 @@
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import yaml
 
@@ -84,8 +84,8 @@ class AutomatedRetrainingScheduler:
 
     def __init__(
         self,
-        config: Optional[RetrainingConfig] = None,
-        config_path: Optional[str] = None,
+        config: RetrainingConfig | None = None,
+        config_path: str | None = None,
     ):
         """
         Initialize the automated retraining scheduler.
@@ -123,9 +123,9 @@ def __init__(
 
         # State management
         self.is_running = False
-        self.scheduler_thread: Optional[threading.Thread] = None
-        self.last_check_time: Optional[datetime] = None
-        self.last_retraining_time: Optional[datetime] = None
+        self.scheduler_thread: threading.Thread | None = None
+        self.last_check_time: datetime | None = None
+        self.last_retraining_time: datetime | None = None
         self.retraining_in_progress = False
         self.retraining_lock = threading.Lock()
 
@@ -437,7 +437,7 @@ def _get_recent_performance_metrics(self) -> list[dict]:
             logger.error(f"Error getting performance metrics: {str(e)}")
             return []
 
-    def _get_baseline_accuracy(self) -> Optional[float]:
+    def _get_baseline_accuracy(self) -> float | None:
         """Get baseline accuracy for comparison."""
         # This could be from initial model evaluation, target accuracy, etc.
         return self.retraining_orchestrator.baseline_performance or 0.55  # 55% baseline
@@ -520,7 +520,7 @@ def make_serializable(obj: Any) -> Any:
                     for k, v in obj.__dict__.items()
                     if not k.startswith("_")
                 }
-            elif isinstance(obj, (list, tuple)):
+            elif isinstance(obj, list | tuple):
                 return [make_serializable(item) for item in obj]
             elif isinstance(obj, dict):
                 return {k: make_serializable(v) for k, v in obj.items()}

src/config/__init__.py

@@ -7,22 +7,21 @@
 
 import os
 from pathlib import Path
-from typing import Optional
 
 
-def load_environment(env_file: Optional[str] = None) -> bool:
+def load_environment(env_file: str | None = None) -> bool:
     """
     Load environment variables from .env file.
-    
+
     Args:
         env_file: Path to .env file. If None, looks for .env in project root.
-        
+
     Returns:
         bool: True if .env file was loaded successfully, False otherwise.
     """
     try:
         from dotenv import load_dotenv
-        
+
         if env_file is None:
             # Find project root (look for pyproject.toml)
             current_path = Path(__file__).parent
@@ -36,37 +35,37 @@ def load_environment(env_file: Optional[str] = None) -> bool:
                 env_path = Path(".env")
         else:
             env_path = Path(env_file)
-        
+
         if env_path.exists():
             load_dotenv(env_path)
             return True
         else:
             return False
-            
+
     except ImportError:
         return False
 
 
-def get_env_var(key: str, default: Optional[str] = None, required: bool = False) -> str:
+def get_env_var(key: str, default: str | None = None, required: bool = False) -> str:
     """
     Get environment variable with proper error handling.
-    
+
     Args:
         key: Environment variable name
         default: Default value if not found
         required: Whether the variable is required
-        
+
     Returns:
         str: Environment variable value
-        
+
     Raises:
         ValueError: If required variable is not found
     """
     value = os.environ.get(key, default)
-    
+
     if required and value is None:
         raise ValueError(f"Required environment variable '{key}' not found")
-    
+
     return value or ""
 
 

src/simulation/retraining_orchestrator.py

@@ -9,7 +9,7 @@
 import os
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import joblib
 import pandas as pd
@@ -69,7 +69,7 @@ def __init__(
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
         # Initialize deployment trigger if using Prefect
-        self.deployment_trigger: Optional[Any] = None
+        self.deployment_trigger: Any | None = None
         if self.use_prefect:
             try:
                 # Set Prefect API URL to connect to the main server

tests/e2e/test_enhanced_model.py

@@ -65,7 +65,7 @@ def main():
     print("\n" + "=" * 60)
     print("🧠 Training improved model...")
     trainer = ModelTrainer(model_type="random_forest")
-    model = trainer.train(train_data, val_data)
+    trainer.train(train_data, val_data)
 
     # Evaluate model
     print("\n" + "=" * 60)
@@ -116,7 +116,7 @@ def main():
     print(f"📈 Probabilities: {probabilities[0]}")
 
     # Create probability mapping
-    prob_mapping = {cls: prob for cls, prob in zip(class_order, probabilities[0], strict=False)}
+    prob_mapping = dict(zip(class_order, probabilities[0], strict=False))
     print("\n📊 Model probability breakdown:")
     for cls, prob in prob_mapping.items():
         result_name = {"H": "Home Win", "D": "Draw", "A": "Away Win"}[cls]

tests/integration/test_automated_retraining_integration.py

@@ -224,8 +224,6 @@ def test_configuration_persistence_and_updates(self, temp_workspace):
         # Load scheduler with file-based config
         scheduler = AutomatedRetrainingScheduler(config_path=str(config_path))
 
-        original_threshold = scheduler.config.performance_threshold
-
         # Update configuration at runtime
         new_config = RetrainingConfig(
             performance_threshold=0.08,  # Different from original

tests/integration/test_enhanced_model_integration.py

@@ -62,7 +62,7 @@ def main():
     print("\n" + "=" * 60)
     print("🧠 Training improved model...")
     trainer = ModelTrainer(model_type="random_forest")
-    model = trainer.train(train_data, val_data)
+    trainer.train(train_data, val_data)
 
     # Evaluate model
     print("\n" + "=" * 60)
@@ -113,7 +113,7 @@ def main():
     print(f"📈 Probabilities: {probabilities[0]}")
 
     # Create probability mapping
-    prob_mapping = {cls: prob for cls, prob in zip(class_order, probabilities[0], strict=False)}
+    prob_mapping = dict(zip(class_order, probabilities[0], strict=False))
     print("\n📊 Model probability breakdown:")
     for cls, prob in prob_mapping.items():
         result_name = {"H": "Home Win", "D": "Draw", "A": "Away Win"}[cls]