linter

Author: codelion

examples/circle_packing/best_program.py

@@ -3,88 +3,96 @@
 import numpy as np
 from scipy.optimize import minimize
 
+
 def construct_packing():
     """
     Construct an optimized arrangement of 26 circles in a unit square
     using mathematical principles and optimization techniques.
-    
+
     Returns:
         Tuple of (centers, radii, sum_of_radii)
         centers: np.array of shape (26, 2) with (x, y) coordinates
         radii: np.array of shape (26) with radius of each circle
         sum_of_radii: Sum of all radii
     """
     n = 26
-    
+
     # Initial guess: Strategic placement with some randomness
     centers = np.zeros((n, 2))
     radii = np.zeros(n)
 
     # Heuristic placement for better initial guess: place larger circles in center
-    radii[:] = np.linspace(0.12, 0.05, n) # Linear distribution of radii
-    
+    radii[:] = np.linspace(0.12, 0.05, n)  # Linear distribution of radii
+
     # Initial placement: approximate hexagonal grid
     grid_x = int(np.sqrt(n))
     grid_y = int(n / grid_x)
-    
+
     x_coords = np.linspace(0.15, 0.85, grid_x)
     y_coords = np.linspace(0.15, 0.85, grid_y)
-    
+
     count = 0
     for i in range(grid_x):
         for j in range(grid_y):
             if count < n:
                 centers[count] = [x_coords[i] + 0.05 * (j % 2), y_coords[j]]
                 count += 1
-    
+
     # Place remaining circles randomly
     while count < n:
         centers[count] = np.random.rand(2) * 0.7 + 0.15
         count += 1
 
     # Objective function: Negative sum of radii (to maximize)
     def objective(x):
-        centers = x[:2*n].reshape(n, 2)
-        radii = x[2*n:]
+        centers = x[: 2 * n].reshape(n, 2)
+        radii = x[2 * n :]
         return -np.sum(radii)
 
     # Constraint: No overlaps and circles stay within the unit square
     def constraint(x):
-        centers = x[:2*n].reshape(n, 2)
-        radii = x[2*n:]
-        
+        centers = x[: 2 * n].reshape(n, 2)
+        radii = x[2 * n :]
+
         # Overlap constraint
         overlap_constraints = []
         for i in range(n):
             for j in range(i + 1, n):
-                dist = np.sqrt(np.sum((centers[i] - centers[j])**2))
+                dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2))
                 overlap_constraints.append(dist - (radii[i] + radii[j]))
-        
+
         # Boundary constraints
         boundary_constraints = []
         for i in range(n):
             boundary_constraints.append(centers[i, 0] - radii[i])  # x >= radius
-            boundary_constraints.append(1 - centers[i, 0] - radii[i]) # x <= 1 - radius
+            boundary_constraints.append(1 - centers[i, 0] - radii[i])  # x <= 1 - radius
             boundary_constraints.append(centers[i, 1] - radii[i])  # y >= radius
-            boundary_constraints.append(1 - centers[i, 1] - radii[i]) # y <= 1 - radius
-        
+            boundary_constraints.append(1 - centers[i, 1] - radii[i])  # y <= 1 - radius
+
         return np.array(overlap_constraints + boundary_constraints)
 
     # Initial guess vector
     x0 = np.concatenate([centers.flatten(), radii])
 
     # Bounds: Circles stay within the unit square and radii are positive
-    bounds = [(0, 1)] * (2*n) + [(0.03, 0.2)] * n # radii are positive, up to 0.2
+    bounds = [(0, 1)] * (2 * n) + [(0.03, 0.2)] * n  # radii are positive, up to 0.2
 
     # Constraints dictionary
-    constraints = {'type': 'ineq', 'fun': constraint}
+    constraints = {"type": "ineq", "fun": constraint}
 
     # Optimization using SLSQP
-    result = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints, options={'maxiter': 1000, 'ftol': 1e-8})
+    result = minimize(
+        objective,
+        x0,
+        method="SLSQP",
+        bounds=bounds,
+        constraints=constraints,
+        options={"maxiter": 1000, "ftol": 1e-8},
+    )
 
     # Extract optimized centers and radii
-    optimized_centers = result.x[:2*n].reshape(n, 2)
-    optimized_radii = result.x[2*n:]
+    optimized_centers = result.x[: 2 * n].reshape(n, 2)
+    optimized_radii = result.x[2 * n :]
 
     # Ensure radii are not negative (numerical stability)
     optimized_radii = np.maximum(optimized_radii, 0.001)
@@ -93,46 +101,51 @@ def constraint(x):
     sum_radii = np.sum(optimized_radii)
 
     return optimized_centers, optimized_radii, sum_radii
+
+
 # EVOLVE-BLOCK-END
 
+
 # This part remains fixed (not evolved)
 def run_packing():
     """Run the circle packing constructor for n=26"""
     centers, radii, sum_radii = construct_packing()
     return centers, radii, sum_radii
 
+
 def visualize(centers, radii):
     """
     Visualize the circle packing
-    
+
     Args:
         centers: np.array of shape (n, 2) with (x, y) coordinates
         radii: np.array of shape (n) with radius of each circle
     """
     import matplotlib.pyplot as plt
     from matplotlib.patches import Circle
-    
+
     fig, ax = plt.subplots(figsize=(8, 8))
-    
+
     # Draw unit square
     ax.set_xlim(0, 1)
     ax.set_ylim(0, 1)
-    ax.set_aspect('equal')
+    ax.set_aspect("equal")
     ax.grid(True)
-    
+
     # Draw circles
     for i, (center, radius) in enumerate(zip(centers, radii)):
         circle = Circle(center, radius, alpha=0.5)
         ax.add_patch(circle)
-        ax.text(center[0], center[1], str(i), ha='center', va='center')
-    
+        ax.text(center[0], center[1], str(i), ha="center", va="center")
+
     plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})")
     plt.show()
 
+
 if __name__ == "__main__":
     centers, radii, sum_radii = run_packing()
     print(f"Sum of radii: {sum_radii}")
     # AlphaEvolve improved this to 2.635
-    
+
     # Uncomment to visualize:
-    # visualize(centers, radii)
+    # visualize(centers, radii)

examples/circle_packing_with_artifacts/evaluator.py

@@ -295,9 +295,9 @@ def evaluate(program_path):
         # Add successful packing stats for good solutions
         if valid and target_ratio > 0.95:  # Near-optimal solutions
             artifacts["stdout"] = f"Excellent packing! Achieved {target_ratio:.1%} of target value"
-            artifacts[
-                "radius_stats"
-            ] = f"Min: {validation_details['min_radius']:.6f}, Max: {validation_details['max_radius']:.6f}, Avg: {validation_details['avg_radius']:.6f}"
+            artifacts["radius_stats"] = (
+                f"Min: {validation_details['min_radius']:.6f}, Max: {validation_details['max_radius']:.6f}, Avg: {validation_details['avg_radius']:.6f}"
+            )
 
         return EvaluationResult(
             metrics={
@@ -404,9 +404,9 @@ def evaluate_stage1(program_path):
 
             # Add validation issues if any
             if not valid:
-                artifacts[
-                    "stderr"
-                ] = f"Validation failed: {len(validation_details.get('boundary_violations', []))} boundary violations, {len(validation_details.get('overlaps', []))} overlaps"
+                artifacts["stderr"] = (
+                    f"Validation failed: {len(validation_details.get('boundary_violations', []))} boundary violations, {len(validation_details.get('overlaps', []))} overlaps"
+                )
                 artifacts["failure_stage"] = "stage1_geometric_validation"
                 if validation_details.get("boundary_violations"):
                     artifacts["boundary_issues"] = validation_details["boundary_violations"][

examples/mlx_metal_kernel_opt/best_program.py

@@ -7,7 +7,7 @@
 
 Target: Qwen3-0.6B with 40 query heads : 8 KV heads
 Hardware: Apple M-series GPUs with unified memory
-Baseline: Standard MLX-LM using mx.fast.scaled_dot_product_attention  
+Baseline: Standard MLX-LM using mx.fast.scaled_dot_product_attention
 Goal: 5-15% performance improvement through custom Metal kernel optimization
 
 Evolution Target: The Metal kernel source code that computes GQA attention

examples/mlx_metal_kernel_opt/evaluator.py

@@ -1082,24 +1082,24 @@ def _analyze_performance_with_safety_metrics(
         custom_memories = [r.peak_memory_gb for r in custom_results if r.peak_memory_gb > 0]
 
         aggregate_metrics = {
-            "avg_decode_speed": float(np.mean(custom_decode_speeds))
-            if custom_decode_speeds
-            else 0.0,
-            "min_decode_speed": float(np.min(custom_decode_speeds))
-            if custom_decode_speeds
-            else 0.0,
-            "max_decode_speed": float(np.max(custom_decode_speeds))
-            if custom_decode_speeds
-            else 0.0,
-            "avg_prefill_speed": float(np.mean(custom_prefill_speeds))
-            if custom_prefill_speeds
-            else 0.0,
+            "avg_decode_speed": (
+                float(np.mean(custom_decode_speeds)) if custom_decode_speeds else 0.0
+            ),
+            "min_decode_speed": (
+                float(np.min(custom_decode_speeds)) if custom_decode_speeds else 0.0
+            ),
+            "max_decode_speed": (
+                float(np.max(custom_decode_speeds)) if custom_decode_speeds else 0.0
+            ),
+            "avg_prefill_speed": (
+                float(np.mean(custom_prefill_speeds)) if custom_prefill_speeds else 0.0
+            ),
             "avg_memory_gb": float(np.mean(custom_memories)) if custom_memories else 0.0,
             "max_memory_gb": float(np.max(custom_memories)) if custom_memories else 0.0,
             "num_successful_tests": len(custom_results),
-            "decode_speed_std": float(np.std(custom_decode_speeds))
-            if len(custom_decode_speeds) > 1
-            else 0.0,
+            "decode_speed_std": (
+                float(np.std(custom_decode_speeds)) if len(custom_decode_speeds) > 1 else 0.0
+            ),
         }
 
         # Enhanced comparison summary

examples/mlx_metal_kernel_opt/initial_program.py

@@ -7,7 +7,7 @@
 
 Target: Qwen3-0.6B with 40 query heads : 8 KV heads
 Hardware: Apple M-series GPUs with unified memory
-Baseline: Standard MLX-LM using mx.fast.scaled_dot_product_attention  
+Baseline: Standard MLX-LM using mx.fast.scaled_dot_product_attention
 Goal: 5-15% performance improvement through custom Metal kernel optimization
 
 Evolution Target: The Metal kernel source code that computes GQA attention

examples/mlx_metal_kernel_opt/run_benchmarks.py

@@ -457,7 +457,9 @@ def print_comparison_summary(comparison_results):
     print(f"  ⏱️  Average Time Reduction:          {summary['avg_time_reduction_pct']:+.2f}%")
 
     print(f"\n📊 ABSOLUTE PERFORMANCE:")
-    print(f"  🔵 Standard MLX-LM:     {summary['avg_standard_decode_speed']:.1f} tokens/sec average")
+    print(
+        f"  🔵 Standard MLX-LM:     {summary['avg_standard_decode_speed']:.1f} tokens/sec average"
+    )
     print(
         f"  🟠 Metal Kernel Optimized: {summary['avg_optimized_decode_speed']:.1f} tokens/sec average"
     )

openevolve/controller.py

@@ -354,7 +354,9 @@ async def run(
 
                 # Specifically check if this is the new best program
                 if self.database.best_program_id == child_program.id:
-                    logger.info(f"🌟 New best solution found at iteration {i+1}: {child_program.id}")
+                    logger.info(
+                        f"🌟 New best solution found at iteration {i+1}: {child_program.id}"
+                    )
                     logger.info(f"Metrics: {format_metrics_safe(child_program.metrics)}")
 
                 # Save checkpoint