linter errors

Author: codelion

openevolve/database.py

@@ -557,7 +557,7 @@ def _sample_parent(self) -> Program:
         """
         # Use exploration_ratio and exploitation_ratio to decide sampling strategy
         rand_val = random.random()
-        
+
         if rand_val < self.config.exploration_ratio:
             # EXPLORATION: Sample from current island (diverse sampling)
             return self._sample_exploration_parent()
@@ -590,15 +590,15 @@ def _sample_exploration_parent(self) -> Program:
         # Sample from current island
         parent_id = random.choice(list(current_island_programs))
         return self.programs[parent_id]
-    
+
     def _sample_exploitation_parent(self) -> Program:
         """
         Sample a parent for exploitation (from archive/elite programs)
         """
         if not self.archive:
             # Fallback to exploration if no archive
             return self._sample_exploration_parent()
-            
+
         # Prefer programs from current island in archive
         archive_programs_in_island = [
             pid
@@ -614,14 +614,14 @@ def _sample_exploitation_parent(self) -> Program:
             # Fall back to any archive program if current island has none
             parent_id = random.choice(list(self.archive))
             return self.programs[parent_id]
-    
+
     def _sample_random_parent(self) -> Program:
         """
         Sample a completely random parent from all programs
         """
         if not self.programs:
             raise ValueError("No programs available for sampling")
-        
+
         # Sample randomly from all programs
         program_id = random.choice(list(self.programs.keys()))
         return self.programs[program_id]
@@ -656,7 +656,7 @@ def _sample_inspirations(self, parent: Program, n: int = 5) -> List[Program]:
         if len(self.programs) > n and len(inspirations) < n:
             # Calculate how many diverse programs to add (up to remaining slots)
             remaining_slots = n - len(inspirations)
-            
+
             # Sample from different feature cells for diversity
             feature_coords = self._calculate_feature_coords(parent)
 
@@ -705,18 +705,20 @@ def _enforce_population_limit(self) -> None:
 
         # Calculate how many programs to remove
         num_to_remove = len(self.programs) - self.config.population_size
-        
-        logger.info(f"Population size ({len(self.programs)}) exceeds limit ({self.config.population_size}), removing {num_to_remove} programs")
+
+        logger.info(
+            f"Population size ({len(self.programs)}) exceeds limit ({self.config.population_size}), removing {num_to_remove} programs"
+        )
 
         # Get programs sorted by fitness (worst first)
         all_programs = list(self.programs.values())
-        
+
         # Sort by average metric (worst first)
         sorted_programs = sorted(
             all_programs,
-            key=lambda p: sum(p.metrics.values()) / max(1, len(p.metrics)) if p.metrics else 0.0
+            key=lambda p: sum(p.metrics.values()) / max(1, len(p.metrics)) if p.metrics else 0.0,
         )
-        
+
         # Remove worst programs, but never remove the best program
         programs_to_remove = []
         for program in sorted_programs:
@@ -725,39 +727,43 @@ def _enforce_population_limit(self) -> None:
             # Don't remove the best program
             if program.id != self.best_program_id:
                 programs_to_remove.append(program)
-                
+
         # If we still need to remove more and only have the best program protected,
         # remove from the remaining programs anyway (but keep the absolute best)
         if len(programs_to_remove) < num_to_remove:
-            remaining_programs = [p for p in sorted_programs if p not in programs_to_remove and p.id != self.best_program_id]
-            additional_removals = remaining_programs[:num_to_remove - len(programs_to_remove)]
+            remaining_programs = [
+                p
+                for p in sorted_programs
+                if p not in programs_to_remove and p.id != self.best_program_id
+            ]
+            additional_removals = remaining_programs[: num_to_remove - len(programs_to_remove)]
             programs_to_remove.extend(additional_removals)
-        
+
         # Remove the selected programs
         for program in programs_to_remove:
             program_id = program.id
-            
+
             # Remove from main programs dict
             if program_id in self.programs:
                 del self.programs[program_id]
-            
+
             # Remove from feature map
             keys_to_remove = []
             for key, pid in self.feature_map.items():
                 if pid == program_id:
                     keys_to_remove.append(key)
             for key in keys_to_remove:
                 del self.feature_map[key]
-            
+
             # Remove from islands
             for island in self.islands:
                 island.discard(program_id)
-            
+
             # Remove from archive
             self.archive.discard(program_id)
-            
+
             logger.debug(f"Removed program {program_id} due to population limit")
-        
+
         logger.info(f"Population size after cleanup: {len(self.programs)}")
 
     # Island management methods

openevolve/evaluator.py

@@ -90,7 +90,7 @@ async def evaluate_program(
         """
         start_time = time.time()
         program_id_str = f" {program_id}" if program_id else ""
-        
+
         # Retry logic for evaluation
         last_exception = None
         for attempt in range(self.config.max_retries + 1):
@@ -126,19 +126,23 @@ async def evaluate_program(
 
             except Exception as e:
                 last_exception = e
-                logger.warning(f"Evaluation attempt {attempt + 1}/{self.config.max_retries + 1} failed for program{program_id_str}: {str(e)}")
-                
+                logger.warning(
+                    f"Evaluation attempt {attempt + 1}/{self.config.max_retries + 1} failed for program{program_id_str}: {str(e)}"
+                )
+
                 # If this is not the last attempt, wait a bit before retrying
                 if attempt < self.config.max_retries:
                     await asyncio.sleep(1.0)  # Wait 1 second before retry
-                    
+
             finally:
                 # Clean up temporary file
                 if os.path.exists(temp_file_path):
                     os.unlink(temp_file_path)
-        
+
         # All retries failed
-        logger.error(f"All evaluation attempts failed for program{program_id_str}. Last error: {str(last_exception)}")
+        logger.error(
+            f"All evaluation attempts failed for program{program_id_str}. Last error: {str(last_exception)}"
+        )
         return {"error": 0.0}
 
     @run_in_executor

openevolve/prompt/sampler.py

@@ -275,21 +275,24 @@ def _format_evolution_history(
                 )
                 + "\n\n"
             )
-        
+
         # Format diverse programs using num_diverse_programs config
         diverse_programs_str = ""
-        if self.config.num_diverse_programs > 0 and len(top_programs) > self.config.num_top_programs:
+        if (
+            self.config.num_diverse_programs > 0
+            and len(top_programs) > self.config.num_top_programs
+        ):
             # Skip the top programs we already included
-            remaining_programs = top_programs[self.config.num_top_programs:]
-            
+            remaining_programs = top_programs[self.config.num_top_programs :]
+
             # Sample diverse programs from the remaining
             num_diverse = min(self.config.num_diverse_programs, len(remaining_programs))
             if num_diverse > 0:
                 # Use random sampling to get diverse programs
                 diverse_programs = random.sample(remaining_programs, num_diverse)
-                
+
                 diverse_programs_str += "\n\n## Diverse Programs\n\n"
-                
+
                 for i, program in enumerate(diverse_programs):
                     # Extract a snippet (first 5 lines for diversity)
                     program_code = program.get("code", "")
@@ -307,7 +310,9 @@ def _format_evolution_history(
                     if not key_features:
                         key_features = [
                             f"Alternative approach to {name}"
-                            for name in list(program.get("metrics", {}).keys())[:2]  # Just first 2 metrics
+                            for name in list(program.get("metrics", {}).keys())[
+                                :2
+                            ]  # Just first 2 metrics
                         ]
 
                     key_features_str = ", ".join(key_features)
@@ -322,7 +327,7 @@ def _format_evolution_history(
                         )
                         + "\n\n"
                     )
-        
+
         # Combine top and diverse programs
         combined_programs_str = top_programs_str + diverse_programs_str