Merge branch 'codelion:main' into feat/tp_add_trading_example

Author: timpara

.github/workflows/python-lint.yml

@@ -0,0 +1,121 @@
+name: Upload Python Package and Docker Image on Release
+on:
+  release:
+    types: [created]
+
+jobs:
+  pypi-publish:
+    name: Publish release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/openevolve
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build package
+        run: |
+          python -m build
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  docker-publish:
+    name: Publish Docker image
+    runs-on: ubuntu-22.04
+    needs: pypi-publish
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      
+      # Add aggressive cleanup before any Docker operations
+      - name: Free disk space
+        run: |
+          # Clean Docker
+          docker system prune -af
+          docker image prune -af
+          docker builder prune -af
+          
+          df -h
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver-opts: |
+            image=moby/buildkit:buildx-stable-1
+            network=host
+          buildkitd-flags: --debug
+      
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+            
+      # Extract metadata for Docker image
+      - name: Extract metadata for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest
+
+      # Build and push Docker image for AMD64
+      - name: Build and push Docker image AMD64
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/amd64
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha,scope=openevolve-amd64
+          cache-to: type=gha,scope=openevolve-amd64,mode=max
+          outputs: type=registry,compression=zstd,compression-level=5
+
+      # Cleanup after AMD64 build
+      - name: Cleanup after AMD64 build
+        run: |
+          docker system prune -af
+          docker builder prune -af
+          df -h
+
+      # Build and push Docker image for ARM64
+      - name: Build and push Docker image ARM64
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/arm64
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha,scope=openevolve-arm64
+          cache-to: type=gha,scope=openevolve-arm64,mode=max
+          outputs: type=registry,compression=zstd,compression-level=5
+
+      # Final cleanup
+      - name: Final cleanup
+        run: |
+          docker system prune -af
+          docker builder prune -af
+          find /tmp -type f -user $(id -u) -exec rm -f {} + 2>/dev/null || true
+          df -h

.github/workflows/release.yml

@@ -19,14 +19,6 @@ source env/bin/activate  # On Windows: env\Scripts\activate
 pip install -e ".[dev]"
 ```
 
-## Code Style
-
-We follow the [Black](https://black.readthedocs.io/) code style. Please format your code before submitting a pull request:
-
-```bash
-black openevolve tests examples
-```
-
 ## Pull Request Process
 
 1. Create a new branch for your feature or bugfix: `git checkout -b feat-your-feature-name`

CONTRIBUTING.md

@@ -16,6 +16,7 @@ help:
 	@echo "  test           - Run tests"
 	@echo "  docker-build   - Build the Docker image"
 	@echo "  docker-run     - Run the Docker container with the example"
+	@echo "  visualizer     - Run the visualization script"
 
 .PHONY: all
 all: install test

Makefile

@@ -185,7 +185,7 @@ See the [Configuration Guide](configs/default_config.yaml) for a full list of op
 
 ## Artifacts Channel
 
-OpenEvolve includes a **artifacts side-channel** that allows evaluators to capture build errors, profiling results, etc. to provide better feedback to the LLM in subsequent generations. This feature enhances the evolution process by giving the LLM context about what went wrong and how to fix it.
+OpenEvolve includes an **artifacts side-channel** that allows evaluators to capture build errors, profiling results, etc. to provide better feedback to the LLM in subsequent generations. This feature enhances the evolution process by giving the LLM context about what went wrong and how to fix it.
 
 The artifacts channel operates alongside the traditional fitness metrics.
 
@@ -205,17 +205,28 @@ return EvaluationResult(
 ```
 
 The next generation prompt will include:
-```
+```markdown
 ## Last Execution Output
 ### Stderr
-```
 SyntaxError: invalid syntax (line 15)
-```
+
 ### Traceback
-```
 ...
 ```
+
+## Example: LLM Feedback
+
+An example for an LLM artifact side channel is part of the default evaluation template, which ends with
+```markdown
+Return your evaluation as a JSON object with the following format:
+{{
+    "readability": [score],
+    "maintainability": [score],
+    "efficiency": [score],
+    "reasoning": "[brief explanation of scores]"
+}}
 ```
+The non-float values, in this case the "reasoning" key of the json response that the evaluator LLM generates, will be available within the next generation prompt.
 
 ### Configuration
 
@@ -240,7 +251,7 @@ export ENABLE_ARTIFACTS=false
 ### Benefits
 
 - **Faster convergence** - LLMs can see what went wrong and fix it directly
-- **Better error handling** - Compilation and runtime failures become learning opportunities  
+- **Better error handling** - Compilation and runtime failures become learning opportunities
 - **Rich debugging context** - Full stack traces and error messages guide improvements
 - **Zero overhead** - When disabled, no performance impact on evaluation
 

README.md

@@ -7,11 +7,10 @@ max_iterations: 1000                  # Maximum number of evolution iterations
 checkpoint_interval: 50               # Save checkpoints every N iterations
 log_level: "INFO"                     # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
 log_dir: null                         # Custom directory for logs (default: output_dir/logs)
-random_seed: null                     # Random seed for reproducibility (null = random)
+random_seed: 42                       # Random seed for reproducibility (null = random, 42 = default)
 
 # Evolution settings
 diff_based_evolution: true            # Use diff-based evolution (true) or full rewrites (false)
-allow_full_rewrites: false            # Allow occasional full rewrites even in diff-based mode
 max_code_length: 10000                # Maximum allowed code length in characters
 
 # LLM configuration
@@ -71,6 +70,7 @@ database:
   # General settings
   db_path: null                       # Path to persist database (null = in-memory only)
   in_memory: true                     # Keep database in memory for faster access
+  log_prompts: true                  # If true, log all prompts and responses into the database
 
   # Evolutionary parameters
   population_size: 1000               # Maximum number of programs to keep in memory

configs/default_config.yaml

@@ -0,0 +1,151 @@
+# EVOLVE-BLOCK-START
+"""Advanced circle packing for n=26 circles in a unit square"""
+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
+
+    # 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 :]
+        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 :]
+
+        # 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))
+                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(centers[i, 1] - radii[i])  # y >= 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
+
+    # Constraints dictionary
+    constraints = {"type": "ineq", "fun": constraint}
+
+    # Optimization using SLSQP
+    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 :]
+
+    # Ensure radii are not negative (numerical stability)
+    optimized_radii = np.maximum(optimized_radii, 0.001)
+
+    # Calculate the sum of radii
+    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.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")
+
+    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)