Search-based software engineering

Step 1

import random
from typing import List, Tuple

# Define genome representation: List of operation IDs
Genome = List[int]

class RefactoringProblem:
    def __init__(self, max_ops: int):
        self.max_ops = max_ops

    def evaluate(self, genome: Genome) -> Tuple[float, float]:
        """
        Multi-objective fitness function.
        Objective 1: Minimize coupling (lower is better).
        Objective 2: Minimize cyclomatic complexity delta.
        """
        coupling_score = sum(g % 5 for g in genome) / max(len(genome), 1)
        complexity_score = sum(g % 3 for g in genome) / max(len(genome), 1)
        return (coupling_score, complexity_score)

Step 2

import numpy as np

def initialize_population(pop_size: int, genome_length: int, max_val: int) -> List[Genome]:
    return [[random.randint(0, max_val) for _ in range(genome_length)] for _ in range(pop_size)]

def mutate(genome: Genome, mutation_rate: float, max_val: int) -> Genome:
    return [g if random.random() > mutation_rate else random.randint(0, max_val) for g in genome]

def run_generational_search(pop_size: int, generations: int, genome_length: int):
    problem = RefactoringProblem(max_ops=10)
    population = initialize_population(pop_size, genome_length, max_val=9)
    
    for gen in range(generations):
        scored_pop = []
        for ind in population:
            fitness = problem.evaluate(ind)
            scored_pop.append((ind, fitness))
            
        # Simple truncation selection based on objective 1 sum
        scored_pop.sort(key=lambda x: sum(x[1]))
        parents = [ind for ind, fit in scored_pop[:pop_size // 2]]
        
        # Reproduce and mutate
        offspring = []
        while len(offspring) < pop_size:
            p = random.choice(parents)
            child = mutate(p, mutation_rate=0.1, max_val=9)
            offspring.append(child)
        population = offspring
    return population

Step 3

import subprocess

def verify_solution(genome: Genome) -> bool:
    """
    Executes regression tests against the generated software artifact.
    """
    try:
        # Apply genome transformations to codebase sandbox
        # apply_transformations(genome)
        
        result = subprocess.run(
            ["pytest", "tests/"],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=30
        )
        return result.returncode == 0
    except subprocess.TimeoutExpired:
        return False

Step 4

from functools import lru_cache
from concurrent.futures import ThreadPoolExecutor

class HardenedEvaluator:
    def __init__(self, max_workers: int = 4):
        self.executor = ThreadPoolExecutor(max_workers=max_workers)

    @lru_cache(maxsize=4096)
    def cached_evaluate(self, tuple_genome: Tuple[int, ...]) -> Tuple[float, float]:
        # Immutable tuple conversion for cache key compatibility
        return RefactoringProblem(10).evaluate(list(tuple_genome))

    def parallel_evaluate(self, population: List[Genome]) -> List[Tuple[float, float]]:
        futures = [self.executor.submit(self.cached_evaluate, tuple(ind)) for ind in population]
        return [f.result() for f in futures]