fix liner

Author: codelion

openevolve/controller.py

@@ -292,9 +292,7 @@ async def run(
                     logger.info(
                         f"🌟 New best solution found at iteration {i+1}: {child_program.id}"
                     )
-                    logger.info(
-                        f"Metrics: {_format_metrics(child_program.metrics)}"
-                    )
+                    logger.info(f"Metrics: {_format_metrics(child_program.metrics)}")
 
                 # Save checkpoint
                 if (i + 1) % self.config.checkpoint_interval == 0:
@@ -303,11 +301,17 @@ async def run(
                 # Check if target score reached
                 if target_score is not None:
                     # Only consider numeric metrics for target score calculation
-                    numeric_metrics = [v for v in child_metrics.values() if isinstance(v, (int, float)) and not isinstance(v, bool)]
+                    numeric_metrics = [
+                        v
+                        for v in child_metrics.values()
+                        if isinstance(v, (int, float)) and not isinstance(v, bool)
+                    ]
                     if numeric_metrics:
                         avg_score = sum(numeric_metrics) / len(numeric_metrics)
                         if avg_score >= target_score:
-                            logger.info(f"Target score {target_score} reached after {i+1} iterations")
+                            logger.info(
+                                f"Target score {target_score} reached after {i+1} iterations"
+                            )
                             break
 
             except Exception as e:
@@ -382,7 +386,12 @@ def _log_iteration(
         for metric, value in child.metrics.items():
             if metric in parent.metrics:
                 # Only calculate diff for numeric values
-                if isinstance(value, (int, float)) and isinstance(parent.metrics[metric], (int, float)) and not isinstance(value, bool) and not isinstance(parent.metrics[metric], bool):
+                if (
+                    isinstance(value, (int, float))
+                    and isinstance(parent.metrics[metric], (int, float))
+                    and not isinstance(value, bool)
+                    and not isinstance(parent.metrics[metric], bool)
+                ):
                     try:
                         diff = value - parent.metrics[metric]
                         improvement[metric] = diff

openevolve/database.py

@@ -21,13 +21,17 @@
 
 def _safe_sum_metrics(metrics: Dict[str, Any]) -> float:
     """Safely sum only numeric metric values, ignoring strings and other types"""
-    numeric_values = [v for v in metrics.values() if isinstance(v, (int, float)) and not isinstance(v, bool)]
+    numeric_values = [
+        v for v in metrics.values() if isinstance(v, (int, float)) and not isinstance(v, bool)
+    ]
     return sum(numeric_values) if numeric_values else 0.0
 
 
 def _safe_avg_metrics(metrics: Dict[str, Any]) -> float:
     """Safely calculate average of only numeric metric values"""
-    numeric_values = [v for v in metrics.values() if isinstance(v, (int, float)) and not isinstance(v, bool)]
+    numeric_values = [
+        v for v in metrics.values() if isinstance(v, (int, float)) and not isinstance(v, bool)
+    ]
     return sum(numeric_values) / max(1, len(numeric_values)) if numeric_values else 0.0
 
 
@@ -483,9 +487,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_avg_metrics(p.metrics)
-        )
+        worst_program = min(archive_programs, key=lambda p: _safe_avg_metrics(p.metrics))
 
         # Replace if new program is better
         if self._is_better(program, worst_program):

openevolve/evaluator.py

@@ -114,18 +114,17 @@ async def evaluate_program(
 
             elapsed = time.time() - start_time
             program_id_str = f" {program_id}" if program_id else ""
-            
+
             # Format metrics properly, handling both numeric and string values
             metric_strs = []
             for name, value in metrics.items():
                 if isinstance(value, (int, float)):
-                    metric_strs.append(f'{name}={value:.4f}')
+                    metric_strs.append(f"{name}={value:.4f}")
                 else:
-                    metric_strs.append(f'{name}={value}')
-            
+                    metric_strs.append(f"{name}={value}")
+
             logger.info(
-                f"Evaluated program{program_id_str} in {elapsed:.2f}s: "
-                f"{', '.join(metric_strs)}"
+                f"Evaluated program{program_id_str} in {elapsed:.2f}s: " f"{', '.join(metric_strs)}"
             )
 
             return metrics

openevolve/prompt/sampler.py

@@ -164,16 +164,18 @@ def _identify_improvement_areas(
                 # Only compare numeric metrics
                 if not isinstance(value, (int, float)) or isinstance(value, bool):
                     continue
-                    
+
                 improved = True
                 regressed = True
 
                 for attempt in recent_attempts:
                     attempt_value = attempt["metrics"].get(metric, 0)
                     # Skip comparison if attempt value is not numeric
-                    if not isinstance(attempt_value, (int, float)) or isinstance(attempt_value, bool):
+                    if not isinstance(attempt_value, (int, float)) or isinstance(
+                        attempt_value, bool
+                    ):
                         continue
-                        
+
                     if attempt_value <= value:
                         regressed = False
                     if attempt_value >= value:
@@ -240,18 +242,22 @@ def _format_evolution_history(
 
             # Get only numeric metrics for comparison
             current_numeric_metrics = {
-                m: v for m, v in program.get("metrics", {}).items() 
+                m: v
+                for m, v in program.get("metrics", {}).items()
                 if isinstance(v, (int, float)) and not isinstance(v, bool)
             }
             parent_numeric_metrics = {
-                m: v for m, v in parent_metrics.items()
+                m: v
+                for m, v in parent_metrics.items()
                 if isinstance(v, (int, float)) and not isinstance(v, bool)
             }
 
             if current_numeric_metrics and parent_numeric_metrics:
                 # Only compare metrics that exist in both
-                common_metrics = set(current_numeric_metrics.keys()) & set(parent_numeric_metrics.keys())
-                
+                common_metrics = set(current_numeric_metrics.keys()) & set(
+                    parent_numeric_metrics.keys()
+                )
+
                 if common_metrics:
                     if all(
                         current_numeric_metrics.get(m, 0) >= parent_numeric_metrics.get(m, 0)
@@ -287,7 +293,11 @@ def _format_evolution_history(
 
             # Calculate a composite score from only numeric metrics
             metrics_dict = program.get("metrics", {})
-            numeric_values = [v for v in metrics_dict.values() if isinstance(v, (int, float)) and not isinstance(v, bool)]
+            numeric_values = [
+                v
+                for v in metrics_dict.values()
+                if isinstance(v, (int, float)) and not isinstance(v, bool)
+            ]
             score = sum(numeric_values) / max(1, len(numeric_values)) if numeric_values else 0.0
 
             # Extract key features (this could be more sophisticated)