fix linter

Author: codelion

examples/function_minimization/evaluator.py

@@ -275,9 +275,7 @@ def evaluate_stage1(program_path):
                     )
                     return {"runs_successfully": 0.0, "error": "Invalid result format"}
             else:
-                print(
-                    f"Stage 1: Invalid result format, expected tuple but got {type(result)}"
-                )
+                print(f"Stage 1: Invalid result format, expected tuple but got {type(result)}")
                 return {"runs_successfully": 0.0, "error": "Invalid result format"}
 
             # Ensure all values are float

openevolve/controller.py

@@ -308,9 +308,7 @@ async def run(
                     logger.info(
                         f"🌟 New best solution found at iteration {i+1}: {child_program.id}"
                     )
-                    logger.info(
-                        f"Metrics: {format_metrics_safe(child_program.metrics)}"
-                    )
+                    logger.info(f"Metrics: {format_metrics_safe(child_program.metrics)}")
 
                 # Save checkpoint
                 if (i + 1) % self.config.checkpoint_interval == 0:

openevolve/database.py

@@ -508,9 +508,7 @@ def _update_archive(self, program: Program) -> None:
 
         # Otherwise, find worst program in archive
         archive_programs = [self.programs[pid] for pid in self.archive]
-        worst_program = min(
-            archive_programs, key=lambda p: safe_numeric_average(p.metrics)
-        )
+        worst_program = min(archive_programs, key=lambda p: safe_numeric_average(p.metrics))
 
         # Replace if new program is better
         if self._is_better(program, worst_program):
@@ -812,9 +810,7 @@ def migrate_programs(self) -> None:
 
             # Sort by fitness (using combined_score or average metrics)
             island_programs.sort(
-                key=lambda p: p.metrics.get(
-                    "combined_score", safe_numeric_average(p.metrics)
-                ),
+                key=lambda p: p.metrics.get("combined_score", safe_numeric_average(p.metrics)),
                 reverse=True,
             )
 
@@ -859,9 +855,7 @@ def get_island_stats(self) -> List[dict]:
 
             if island_programs:
                 scores = [
-                    p.metrics.get(
-                        "combined_score", safe_numeric_average(p.metrics)
-                    )
+                    p.metrics.get("combined_score", safe_numeric_average(p.metrics))
                     for p in island_programs
                 ]
 

openevolve/prompt/sampler.py

@@ -246,27 +246,27 @@ def _format_evolution_history(
 
             # Safely compare only numeric metrics
             program_metrics = program.get("metrics", {})
-            
+
             # Check if all numeric metrics improved
             numeric_comparisons_improved = []
             numeric_comparisons_regressed = []
-            
+
             for m in program_metrics:
                 prog_value = program_metrics.get(m, 0)
                 parent_value = parent_metrics.get(m, 0)
-                
+
                 # Only compare if both values are numeric
                 if isinstance(prog_value, (int, float)) and isinstance(parent_value, (int, float)):
                     if prog_value >= parent_value:
                         numeric_comparisons_improved.append(True)
                     else:
                         numeric_comparisons_improved.append(False)
-                        
+
                     if prog_value <= parent_value:
                         numeric_comparisons_regressed.append(True)
                     else:
                         numeric_comparisons_regressed.append(False)
-            
+
             # Determine outcome based on numeric comparisons
             if numeric_comparisons_improved and all(numeric_comparisons_improved):
                 outcome = "Improvement in all metrics"

openevolve/utils/format_utils.py

@@ -8,16 +8,16 @@
 def format_metrics_safe(metrics: Dict[str, Any]) -> str:
     """
     Safely format metrics dictionary for logging, handling both numeric and string values.
-    
+
     Args:
         metrics: Dictionary of metric names to values
-        
+
     Returns:
         Formatted string representation of metrics
     """
     if not metrics:
         return ""
-    
+
     formatted_parts = []
     for name, value in metrics.items():
         # Check if value is numeric (int, float)
@@ -31,24 +31,24 @@ def format_metrics_safe(metrics: Dict[str, Any]) -> str:
         else:
             # For non-numeric values (strings, etc.), just convert to string
             formatted_parts.append(f"{name}={value}")
-    
+
     return ", ".join(formatted_parts)
 
 
 def format_improvement_safe(parent_metrics: Dict[str, Any], child_metrics: Dict[str, Any]) -> str:
     """
     Safely format improvement metrics for logging.
-    
+
     Args:
         parent_metrics: Parent program metrics
         child_metrics: Child program metrics
-        
+
     Returns:
         Formatted string representation of improvements
     """
     if not parent_metrics or not child_metrics:
         return ""
-    
+
     improvement_parts = []
     for metric, child_value in child_metrics.items():
         if metric in parent_metrics:
@@ -61,5 +61,5 @@ def format_improvement_safe(parent_metrics: Dict[str, Any], child_metrics: Dict[
                 except (ValueError, TypeError):
                     # Skip non-numeric comparisons
                     continue
-    
+
     return ", ".join(improvement_parts)

openevolve/utils/metrics_utils.py

@@ -9,16 +9,16 @@ def safe_numeric_average(metrics: Dict[str, Any]) -> float:
     """
     Calculate the average of numeric values in a metrics dictionary,
     safely ignoring non-numeric values like strings.
-    
+
     Args:
         metrics: Dictionary of metric names to values
-        
+
     Returns:
         Average of numeric values, or 0.0 if no numeric values found
     """
     if not metrics:
         return 0.0
-    
+
     numeric_values = []
     for value in metrics.values():
         if isinstance(value, (int, float)):
@@ -30,27 +30,27 @@ def safe_numeric_average(metrics: Dict[str, Any]) -> float:
             except (ValueError, TypeError, OverflowError):
                 # Skip invalid numeric values
                 continue
-    
+
     if not numeric_values:
         return 0.0
-    
+
     return sum(numeric_values) / len(numeric_values)
 
 
 def safe_numeric_sum(metrics: Dict[str, Any]) -> float:
     """
     Calculate the sum of numeric values in a metrics dictionary,
     safely ignoring non-numeric values like strings.
-    
+
     Args:
         metrics: Dictionary of metric names to values
-        
+
     Returns:
         Sum of numeric values, or 0.0 if no numeric values found
     """
     if not metrics:
         return 0.0
-    
+
     numeric_sum = 0.0
     for value in metrics.values():
         if isinstance(value, (int, float)):
@@ -62,5 +62,5 @@ def safe_numeric_sum(metrics: Dict[str, Any]) -> float:
             except (ValueError, TypeError, OverflowError):
                 # Skip invalid numeric values
                 continue
-    
+
     return numeric_sum