fix: fix lint

Author: DiogoRibeiro7

.github/workflows/security.yml

@@ -11,16 +11,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      
+
       - name: Run Bandit security scan
         run: |
           pip install bandit
           bandit -r min_ratio_cycle/
-      
+
       - name: Run Safety check
         run: |
           pip install safety
           safety check
-      
+
       - name: Dependency vulnerability scan
         uses: pypa/[email protected]

Makefile

@@ -141,7 +141,7 @@ import subprocess
 import sys
 
 try:
-    result = subprocess.run(['pytest', '--collect-only', '-q'], 
+    result = subprocess.run(['pytest', '--collect-only', '-q'],
                           capture_output=True, text=True)
     lines = result.stdout.strip().split('\n')
     for line in lines[-5:]:
@@ -165,7 +165,7 @@ print(f'  Memory: {psutil.virtual_memory().total // (1024**3)}GB')
 print()
 
 start_time = time.time()
-result = subprocess.run(['python', 'run_tests.py', '--quick'], 
+result = subprocess.run(['python', 'run_tests.py', '--quick'],
                        capture_output=True)
 elapsed = time.time() - start_time
 

docs/conf.py

@@ -1,18 +1,19 @@
 import os
 import sys
-sys.path.insert(0, os.path.abspath('..'))
 
-project = 'Min Ratio Cycle'
-author = 'Diogo Ribeiro'
-release = '0.1.0'
+sys.path.insert(0, os.path.abspath(".."))
+
+project = "Min Ratio Cycle"
+author = "Diogo Ribeiro"
+release = "0.1.0"
 
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.napoleon',
-    'sphinx.ext.viewcode',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
 ]
 
-templates_path = ['_templates']
+templates_path = ["_templates"]
 exclude_patterns = []
 
-html_theme = 'alabaster'
+html_theme = "alabaster"

min_ratio_cycle/__init__.py

@@ -4,6 +4,6 @@
 __version__ = "0.1.0"
 __author__ = "Diogo Ribeiro"
 
-from .solver import MinRatioCycleSolver, Edge
+from .solver import Edge, MinRatioCycleSolver
 
 __all__ = ["MinRatioCycleSolver", "Edge"]

min_ratio_cycle/monitoring/__init__.py

@@ -16,29 +16,27 @@
 - progress_tracker: Progress tracking context manager
 """
 
-from .metrics import SolverMetrics, MetricsCollector, PerformanceAnalyzer
+from .health import SolverHealthCheck, run_health_check
 from .logging import SolverLogger, setup_logging
+from .metrics import MetricsCollector, PerformanceAnalyzer, SolverMetrics
 from .profiler import SolverProfiler, profile_operation
-from .health import SolverHealthCheck, run_health_check
-from .progress import progress_tracker, ProgressTracker
+from .progress import ProgressTracker, progress_tracker
 
 __all__ = [
     # Core monitoring classes
-    'SolverMetrics',
-    'SolverLogger', 
-    'SolverProfiler',
-    'SolverHealthCheck',
-    
+    "SolverMetrics",
+    "SolverLogger",
+    "SolverProfiler",
+    "SolverHealthCheck",
     # Utility classes
-    'MetricsCollector',
-    'PerformanceAnalyzer',
-    'ProgressTracker',
-    
+    "MetricsCollector",
+    "PerformanceAnalyzer",
+    "ProgressTracker",
     # Convenience functions
-    'setup_logging',
-    'profile_operation',
-    'run_health_check',
-    'progress_tracker',
+    "setup_logging",
+    "profile_operation",
+    "run_health_check",
+    "progress_tracker",
 ]
 
 # Version info

min_ratio_cycle/monitoring/health.py

@@ -1,165 +1,179 @@
+import json
 import logging
 import time
-import json
+
 
 # Missing: Health check and diagnostics
 class SolverHealthCheck:
     """System health checks and diagnostics."""
-    
+
     def __init__(self):
         self.checks = []
-    
+
     def check_numpy_version(self):
         """Check NumPy version compatibility."""
         import numpy as np
+
         min_version = "1.20.0"
         current = np.__version__
-        
+
         try:
             from packaging import version
+
             is_compatible = version.parse(current) >= version.parse(min_version)
         except ImportError:
             # Fallback comparison
             is_compatible = current >= min_version
-        
+
         return {
-            'check': 'numpy_version',
-            'status': 'PASS' if is_compatible else 'FAIL',
-            'details': f'NumPy {current} (min required: {min_version})',
-            'recommendation': 'Update NumPy' if not is_compatible else None
+            "check": "numpy_version",
+            "status": "PASS" if is_compatible else "FAIL",
+            "details": f"NumPy {current} (min required: {min_version})",
+            "recommendation": "Update NumPy" if not is_compatible else None,
         }
-    
+
     def check_memory_available(self, min_memory_gb=1.0):
         """Check available system memory."""
         try:
             import psutil
+
             available_gb = psutil.virtual_memory().available / (1024**3)
             is_sufficient = available_gb >= min_memory_gb
-            
+
             return {
-                'check': 'memory_available',
-                'status': 'PASS' if is_sufficient else 'WARN',
-                'details': f'{available_gb:.1f}GB available (min: {min_memory_gb}GB)',
-                'recommendation': 'Consider smaller graphs or more memory' if not is_sufficient else None
+                "check": "memory_available",
+                "status": "PASS" if is_sufficient else "WARN",
+                "details": f"{available_gb:.1f}GB available (min: {min_memory_gb}GB)",
+                "recommendation": "Consider smaller graphs or more memory"
+                if not is_sufficient
+                else None,
             }
         except ImportError:
             return {
-                'check': 'memory_available',
-                'status': 'SKIP',
-                'details': 'psutil not available',
-                'recommendation': 'Install psutil for memory monitoring'
+                "check": "memory_available",
+                "status": "SKIP",
+                "details": "psutil not available",
+                "recommendation": "Install psutil for memory monitoring",
             }
-    
+
     def check_numerical_precision(self):
         """Check floating-point precision issues."""
         import numpy as np
-        
+
         # Test for common precision issues
         test_cases = [
             (0.1 + 0.2, 0.3),  # Classic floating-point issue
             (1e16 + 1.0 - 1e16, 1.0),  # Large number precision
         ]
-        
+
         issues = []
         for computed, expected in test_cases:
             if abs(computed - expected) > 1e-15:
                 issues.append(f"{computed} != {expected}")
-        
+
         return {
-            'check': 'numerical_precision',
-            'status': 'WARN' if issues else 'PASS',
-            'details': f'Found {len(issues)} precision issues' if issues else 'No precision issues detected',
-            'recommendation': 'Use exact mode when possible' if issues else None
+            "check": "numerical_precision",
+            "status": "WARN" if issues else "PASS",
+            "details": f"Found {len(issues)} precision issues"
+            if issues
+            else "No precision issues detected",
+            "recommendation": "Use exact mode when possible" if issues else None,
         }
-    
+
     def run_all_checks(self):
         """Run all health checks."""
         checks = [
             self.check_numpy_version(),
             self.check_memory_available(),
             self.check_numerical_precision(),
         ]
-        
+
         return {
-            'timestamp': time.time(),
-            'checks': checks,
-            'summary': {
-                'total': len(checks),
-                'passed': sum(1 for c in checks if c['status'] == 'PASS'),
-                'warnings': sum(1 for c in checks if c['status'] == 'WARN'),
-                'failures': sum(1 for c in checks if c['status'] == 'FAIL'),
-            }
+            "timestamp": time.time(),
+            "checks": checks,
+            "summary": {
+                "total": len(checks),
+                "passed": sum(1 for c in checks if c["status"] == "PASS"),
+                "warnings": sum(1 for c in checks if c["status"] == "WARN"),
+                "failures": sum(1 for c in checks if c["status"] == "FAIL"),
+            },
         }
 
+
 # Missing: Configuration management
 class SolverConfig:
     """Configuration management for solver parameters."""
-    
+
     DEFAULT_CONFIG = {
-        'numeric_mode': {
-            'max_iter': 60,
-            'tol': 1e-12,
-            'detect_cycle_slack': 1e-15,
+        "numeric_mode": {
+            "max_iter": 60,
+            "tol": 1e-12,
+            "detect_cycle_slack": 1e-15,
         },
-        'exact_mode': {
-            'max_den': None,  # Auto-determine
-            'max_steps': None,  # Auto-determine
+        "exact_mode": {
+            "max_den": None,  # Auto-determine
+            "max_steps": None,  # Auto-determine
         },
-        'performance': {
-            'enable_logging': True,
-            'enable_metrics': True,
-            'enable_profiling': False,
+        "performance": {
+            "enable_logging": True,
+            "enable_metrics": True,
+            "enable_profiling": False,
+        },
+        "validation": {
+            "validate_cycles": True,
+            "check_consistency": True,
         },
-        'validation': {
-            'validate_cycles': True,
-            'check_consistency': True,
-        }
     }
-    
+
     def __init__(self, config_dict=None, config_file=None):
         self.config = self.DEFAULT_CONFIG.copy()
-        
+
         if config_file:
             self.load_from_file(config_file)
-        
+
         if config_dict:
             self._update_config(config_dict)
-    
+
     def load_from_file(self, filename):
         """Load configuration from JSON file."""
         try:
-            with open(filename, 'r') as f:
+            with open(filename, "r") as f:
                 file_config = json.load(f)
                 self._update_config(file_config)
         except FileNotFoundError:
             logging.warning(f"Config file {filename} not found, using defaults")
         except json.JSONDecodeError as e:
             logging.error(f"Invalid JSON in config file: {e}")
-    
+
     def _update_config(self, new_config):
         """Recursively update configuration."""
+
         def deep_update(base, update):
             for key, value in update.items():
-                if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                if (
+                    key in base
+                    and isinstance(base[key], dict)
+                    and isinstance(value, dict)
+                ):
                     deep_update(base[key], value)
                 else:
                     base[key] = value
-        
+
         deep_update(self.config, new_config)
-    
+
     def get(self, path, default=None):
         """Get configuration value using dot notation."""
-        keys = path.split('.')
+        keys = path.split(".")
         value = self.config
-        
+
         try:
             for key in keys:
                 value = value[key]
             return value
         except (KeyError, TypeError):
             return default
-    
+
     def save_to_file(self, filename):
         """Save current configuration to file."""
-        with open(filename, 'w') as f:
+        with open(filename, "w") as f:
             json.dump(self.config, f, indent=2)