@provos/ironcurtain 0.11.0 → 0.13.0

package/src/workflow/workflows/evolve/scripts/evolve_core/algorithms/factory.py

@@ -0,0 +1,90 @@
+"""Factory for sampler implementations."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+from pathlib import Path
+import sys
+
+from .base import BaseSampler
+from .greedy import GreedySampler
+from .island import IslandSampler
+from .random import RandomSampler
+from .ucb1 import UCB1Sampler
+
+
+def get_sampler(algorithm: str, **kwargs) -> BaseSampler:
+    kwargs = {key: value for key, value in kwargs.items() if value is not None}
+    if algorithm == "custom":
+        custom_path = str(kwargs.pop("custom_sampler_path", "") or "").strip()
+        custom_class = str(kwargs.pop("custom_sampler_class", "") or "").strip()
+        custom_search_paths = kwargs.pop("custom_sampler_search_paths", None)
+        sampler_class = load_custom_sampler_class(
+            custom_path,
+            custom_class,
+            search_paths=custom_search_paths,
+        )
+        sampler = sampler_class(**kwargs)
+        if not callable(getattr(sampler, "sample", None)):
+            raise ValueError(
+                f"Custom sampler '{custom_class}' must define a callable sample(nodes, n) method."
+            )
+        return sampler
+
+    samplers = {
+        "greedy": GreedySampler,
+        "island": IslandSampler,
+        "random": RandomSampler,
+        "ucb1": UCB1Sampler,
+    }
+    if algorithm not in samplers:
+        raise ValueError(
+            f"Unknown sampling algorithm: {algorithm}. Available: {sorted(samplers)}"
+        )
+    return samplers[algorithm](**kwargs)
+
+
+def load_custom_sampler_class(
+    custom_path: str,
+    custom_class: str,
+    search_paths: list[str] | None = None,
+):
+    if not custom_path or not custom_class:
+        raise ValueError(
+            "Custom sampling requires both custom_sampler_path and custom_sampler_class."
+        )
+
+    path = Path(custom_path)
+    if not path.exists():
+        raise ValueError(f"Custom sampler path does not exist: {path}")
+
+    module_name = "evolve_custom_sampler_" + hashlib.sha1(str(path).encode("utf-8")).hexdigest()
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        raise ValueError(f"Unable to load custom sampler module from: {path}")
+
+    module = importlib.util.module_from_spec(spec)
+    effective_search_paths: list[str] = []
+    for candidate in [str(path.parent), *(search_paths or [])]:
+        if candidate and candidate not in effective_search_paths:
+            effective_search_paths.append(candidate)
+
+    inserted_paths: list[str] = []
+    try:
+        for candidate in reversed(effective_search_paths):
+            if candidate not in sys.path:
+                sys.path.insert(0, candidate)
+                inserted_paths.append(candidate)
+        spec.loader.exec_module(module)
+    finally:
+        for candidate in inserted_paths:
+            if candidate in sys.path:
+                sys.path.remove(candidate)
+
+    sampler_class = getattr(module, custom_class, None)
+    if sampler_class is None:
+        raise ValueError(
+            f"Custom sampler class '{custom_class}' was not found in: {path}"
+        )
+    return sampler_class

package/src/workflow/workflows/evolve/scripts/evolve_core/algorithms/greedy.py

@@ -0,0 +1,17 @@
+"""Greedy sampling strategy."""
+
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
+
+from .base import BaseSampler
+
+if TYPE_CHECKING:
+    from ..structures import Node
+
+
+class GreedySampler(BaseSampler):
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        if not nodes:
+            return []
+        return sorted(nodes, key=lambda node: node.score, reverse=True)[:n]

package/src/workflow/workflows/evolve/scripts/evolve_core/algorithms/island.py

@@ -0,0 +1,316 @@
+"""Island-based sampler with optional diversity features."""
+
+from __future__ import annotations
+
+import ast
+import random
+import time
+from typing import Any, Dict, List, Optional, Set, Tuple, TYPE_CHECKING
+
+from .base import BaseSampler
+
+if TYPE_CHECKING:
+    from ..structures import Node
+
+
+class IslandSampler(BaseSampler):
+    def __init__(
+        self,
+        num_islands: int = 5,
+        migration_interval: int = 10,
+        migration_rate: float = 0.1,
+        exploration_ratio: float = 0.2,
+        exploitation_ratio: float = 0.3,
+        c: float = 1.414,
+        feature_dimensions: Optional[List[str]] = None,
+        feature_bins: int = 10,
+    ):
+        self.num_islands = num_islands
+        self.migration_interval = migration_interval
+        self.migration_rate = migration_rate
+        self.exploration_ratio = exploration_ratio
+        self.exploitation_ratio = exploitation_ratio
+        self.c = c
+        self.feature_dimensions = feature_dimensions or []
+        self.feature_bins = feature_bins
+
+        self.islands: List[Set[int]] = [set() for _ in range(num_islands)]
+        self.island_generations: List[int] = [0] * num_islands
+        self.island_best_nodes: List[Optional[int]] = [None] * num_islands
+        self.island_feature_maps: List[Dict[Tuple[int, ...], int]] = [
+            {} for _ in range(num_islands)
+        ]
+        self.feature_stats: Dict[str, Dict[str, Any]] = {}
+        self.current_island = 0
+        self.last_migration_generation = 0
+        self.archive: Set[int] = set()
+        self.archive_size = 100
+        self.diversity_cache: Dict[int, Dict[str, float]] = {}
+        self.diversity_cache_size = 1000
+        self.diversity_reference_set: List[str] = []
+        self.diversity_reference_size = 20
+        self.all_nodes: Dict[int, "Node"] = {}
+
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        if not nodes:
+            return []
+
+        for node in nodes:
+            if node.id is not None:
+                self.all_nodes[node.id] = node
+
+        if self._should_migrate():
+            self._migrate(nodes)
+
+        island_id = self.current_island % self.num_islands
+        island_nodes = self._get_island_nodes(island_id, nodes) or nodes
+        self.island_generations[island_id] += 1
+        self.current_island = (self.current_island + 1) % self.num_islands
+
+        selected: List["Node"] = []
+        while len(selected) < min(n, len(island_nodes)):
+            roll = random.random()
+            if roll < self.exploration_ratio:
+                candidate = self._sample_random(island_nodes)
+            elif roll < self.exploration_ratio + self.exploitation_ratio:
+                candidate = self._sample_from_archive(nodes) or self._sample_weighted(
+                    island_nodes
+                )
+            else:
+                candidate = self._sample_weighted(island_nodes)
+
+            if candidate is None or candidate in selected:
+                continue
+            candidate.visit_count += 1
+            selected.append(candidate)
+
+        return selected
+
+    def on_node_added(self, node: "Node") -> None:
+        if node.id is None:
+            return
+        self.all_nodes[node.id] = node
+        island_id = node.meta_info.get("island", self.current_island) % self.num_islands
+        node.meta_info["island"] = island_id
+        self.islands[island_id].add(node.id)
+        self._update_archive(node)
+        if self.feature_dimensions:
+            feature_coords = self._calculate_feature_coords(node)
+            if feature_coords is not None:
+                self.island_feature_maps[island_id][tuple(feature_coords)] = node.id
+
+    def on_node_removed(self, node: "Node") -> None:
+        if node.id is None:
+            return
+        self.all_nodes.pop(node.id, None)
+        island_id = node.meta_info.get("island")
+        if island_id is not None and island_id < len(self.islands):
+            self.islands[island_id].discard(node.id)
+        self.archive.discard(node.id)
+
+    def get_state(self) -> Dict[str, Any]:
+        return {
+            "archive": list(self.archive),
+            "current_island": self.current_island,
+            "diversity_cache": {str(key): value for key, value in self.diversity_cache.items()},
+            "diversity_reference_set": self.diversity_reference_set,
+            "feature_stats": self.feature_stats,
+            "island_best_nodes": self.island_best_nodes,
+            "island_feature_maps": [
+                {str(key): value for key, value in feature_map.items()}
+                for feature_map in self.island_feature_maps
+            ],
+            "island_generations": self.island_generations,
+            "last_migration_generation": self.last_migration_generation,
+        }
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        self.archive = set(state.get("archive", []))
+        self.current_island = state.get("current_island", 0) % self.num_islands
+        self.diversity_cache = {
+            int(key): value for key, value in state.get("diversity_cache", {}).items()
+        }
+        self.diversity_reference_set = state.get("diversity_reference_set", [])
+        self.feature_stats = state.get("feature_stats", {})
+        self.island_best_nodes = state.get("island_best_nodes", [None] * self.num_islands)
+        self.island_generations = state.get("island_generations", [0] * self.num_islands)
+        self.last_migration_generation = state.get("last_migration_generation", 0)
+
+        feature_maps = []
+        for raw_feature_map in state.get("island_feature_maps", []):
+            feature_maps.append(
+                {ast.literal_eval(key): value for key, value in raw_feature_map.items()}
+            )
+        if feature_maps:
+            self.island_feature_maps = feature_maps
+
+    def rebuild_from_nodes(self, nodes: List["Node"]) -> None:
+        self.islands = [set() for _ in range(self.num_islands)]
+        self.all_nodes = {node.id: node for node in nodes if node.id is not None}
+        self.island_feature_maps = [{} for _ in range(self.num_islands)]
+
+        for node in nodes:
+            if node.id is None:
+                continue
+            island_id = node.meta_info.get("island", 0) % self.num_islands
+            self.islands[island_id].add(node.id)
+            if self.feature_dimensions:
+                coords = self._calculate_feature_coords(node)
+                if coords is not None:
+                    self.island_feature_maps[island_id][tuple(coords)] = node.id
+
+    def get_island_stats(self, nodes: List["Node"]) -> Dict[str, Any]:
+        populations = []
+        for island_id in range(self.num_islands):
+            island_nodes = self._get_island_nodes(island_id, nodes)
+            populations.append(
+                {
+                    "island_id": island_id,
+                    "size": len(island_nodes),
+                    "best_score": max((node.score for node in island_nodes), default=0.0),
+                }
+            )
+        return {
+            "archive_size": len(self.archive),
+            "current_island": self.current_island,
+            "island_populations": populations,
+            "num_islands": self.num_islands,
+        }
+
+    def reset(self) -> None:
+        self.islands = [set() for _ in range(self.num_islands)]
+        self.island_generations = [0] * self.num_islands
+        self.island_best_nodes = [None] * self.num_islands
+        self.island_feature_maps = [{} for _ in range(self.num_islands)]
+        self.feature_stats.clear()
+        self.current_island = 0
+        self.last_migration_generation = 0
+        self.archive.clear()
+        self.diversity_cache.clear()
+        self.diversity_reference_set = []
+
+    def _get_island_nodes(self, island_id: int, nodes: List["Node"]) -> List["Node"]:
+        return [node for node in nodes if node.id in self.islands[island_id]]
+
+    @staticmethod
+    def _sample_random(nodes: List["Node"]) -> Optional["Node"]:
+        if not nodes:
+            return None
+        return random.choice(nodes)
+
+    @staticmethod
+    def _sample_weighted(nodes: List["Node"]) -> Optional["Node"]:
+        if not nodes:
+            return None
+        weights = [max(node.score, 0.001) for node in nodes]
+        return random.choices(nodes, weights=weights, k=1)[0]
+
+    def _sample_from_archive(self, nodes: List["Node"]) -> Optional["Node"]:
+        archive_nodes = [node for node in nodes if node.id in self.archive]
+        if not archive_nodes:
+            return None
+        return random.choice(archive_nodes)
+
+    def _update_archive(self, node: "Node") -> None:
+        if node.id is None:
+            return
+        self.archive.add(node.id)
+        if len(self.archive) > self.archive_size:
+            self.archive = set(sorted(self.archive)[-self.archive_size :])
+
+    def _calculate_feature_coords(self, node: "Node") -> Optional[List[int]]:
+        if not self.feature_dimensions:
+            return None
+
+        coords: List[int] = []
+        for feature in self.feature_dimensions:
+            if feature == "complexity":
+                value = float(len(node.code))
+            elif feature == "diversity":
+                value = self._get_cached_diversity(node)
+            else:
+                raw_value = node.results.get(feature)
+                if not isinstance(raw_value, (int, float)):
+                    return None
+                value = float(raw_value)
+
+            self._update_feature_stats(feature, value)
+            scaled = self._scale_feature_value(feature, value)
+            coords.append(max(0, min(self.feature_bins - 1, int(scaled * self.feature_bins))))
+
+        return coords
+
+    def _update_feature_stats(self, feature: str, value: float) -> None:
+        stats = self.feature_stats.setdefault(feature, {"min": value, "max": value})
+        stats["min"] = min(stats["min"], value)
+        stats["max"] = max(stats["max"], value)
+
+    def _scale_feature_value(self, feature: str, value: float) -> float:
+        stats = self.feature_stats.get(feature)
+        if not stats:
+            return 0.5
+        if stats["max"] - stats["min"] < 1e-10:
+            return 0.5
+        return max(0.0, min(1.0, (value - stats["min"]) / (stats["max"] - stats["min"])))
+
+    def _get_cached_diversity(self, node: "Node") -> float:
+        if not node.code:
+            return 0.0
+
+        code_hash = hash(node.code)
+        cached = self.diversity_cache.get(code_hash)
+        if cached:
+            return cached["value"]
+
+        if (
+            not self.diversity_reference_set
+            or len(self.diversity_reference_set) < self.diversity_reference_size
+        ):
+            self._update_diversity_reference_set()
+
+        scores = [
+            self._fast_code_diversity(node.code, reference)
+            for reference in self.diversity_reference_set
+            if reference != node.code
+        ]
+        diversity = sum(scores) / max(1, len(scores)) if scores else 0.0
+
+        if len(self.diversity_cache) >= self.diversity_cache_size:
+            oldest = min(self.diversity_cache.items(), key=lambda item: item[1]["timestamp"])[0]
+            del self.diversity_cache[oldest]
+        self.diversity_cache[code_hash] = {"timestamp": time.time(), "value": diversity}
+        return diversity
+
+    def _update_diversity_reference_set(self) -> None:
+        all_programs = [node.code for node in self.all_nodes.values() if node.code]
+        self.diversity_reference_set = all_programs[: self.diversity_reference_size]
+
+    @staticmethod
+    def _fast_code_diversity(code1: str, code2: str) -> float:
+        if code1 == code2:
+            return 0.0
+        chars = len(set(code1).symmetric_difference(set(code2)))
+        return abs(len(code1) - len(code2)) * 0.1 + chars * 0.5
+
+    def _should_migrate(self) -> bool:
+        return (
+            max(self.island_generations, default=0) - self.last_migration_generation
+        ) >= self.migration_interval
+
+    def _migrate(self, nodes: List["Node"]) -> None:
+        if self.num_islands < 2:
+            return
+        self.last_migration_generation = max(self.island_generations, default=0)
+        for island_id in range(self.num_islands):
+            island_nodes = sorted(
+                self._get_island_nodes(island_id, nodes),
+                key=lambda node: node.score,
+                reverse=True,
+            )
+            if not island_nodes:
+                continue
+            count = max(1, int(len(island_nodes) * self.migration_rate))
+            for node in island_nodes[:count]:
+                if node.id is None:
+                    continue
+                self.islands[(island_id + 1) % self.num_islands].add(node.id)

package/src/workflow/workflows/evolve/scripts/evolve_core/algorithms/random.py

@@ -0,0 +1,18 @@
+"""Random sampling strategy."""
+
+from __future__ import annotations
+
+import random
+from typing import List, TYPE_CHECKING
+
+from .base import BaseSampler
+
+if TYPE_CHECKING:
+    from ..structures import Node
+
+
+class RandomSampler(BaseSampler):
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        if not nodes:
+            return []
+        return random.sample(nodes, min(n, len(nodes)))

package/src/workflow/workflows/evolve/scripts/evolve_core/algorithms/ucb1.py

@@ -0,0 +1,55 @@
+"""UCB1-based sampling strategy."""
+
+from __future__ import annotations
+
+import math
+import random
+from typing import List, TYPE_CHECKING
+
+from .base import BaseSampler
+
+if TYPE_CHECKING:
+    from ..structures import Node
+
+
+class UCB1Sampler(BaseSampler):
+    def __init__(self, c: float = 1.414):
+        self.c = c
+
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        if not nodes:
+            return []
+
+        total_visits = sum(node.visit_count for node in nodes)
+        if total_visits == 0:
+            selected = random.sample(nodes, min(n, len(nodes)))
+            for node in selected:
+                node.visit_count += 1
+            return selected
+
+        scored_nodes = [node.score for node in nodes if node.visit_count > 0]
+        if not scored_nodes:
+            selected = random.sample(nodes, min(n, len(nodes)))
+            for node in selected:
+                node.visit_count += 1
+            return selected
+
+        min_score = min(scored_nodes)
+        max_score = max(scored_nodes)
+        score_range = max(max_score - min_score, 1.0)
+
+        ucb_scores = []
+        for node in nodes:
+            if node.visit_count == 0:
+                value = float("inf")
+            else:
+                normalized = (node.score - min_score) / score_range
+                exploration = self.c * math.sqrt(math.log(total_visits) / node.visit_count)
+                value = normalized + exploration
+            ucb_scores.append((node, value))
+
+        ucb_scores.sort(key=lambda item: item[1], reverse=True)
+        selected = [node for node, _ in ucb_scores[: min(n, len(nodes))]]
+        for node in selected:
+            node.visit_count += 1
+        return selected

package/src/workflow/workflows/evolve/scripts/evolve_core/best_snapshot.py

@@ -0,0 +1,62 @@
+"""Utilities for persisting the best-scoring step outputs."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from threading import Lock
+from typing import List, Optional
+
+from .structures import Node
+
+
+class BestSnapshotManager:
+    """Maintain a `steps/best` directory with the strongest snapshots."""
+
+    def __init__(self, steps_dir: Path):
+        self.steps_dir = Path(steps_dir)
+        self.steps_dir.mkdir(parents=True, exist_ok=True)
+        self.best_dir = self.steps_dir / "best"
+        self.best_dir.mkdir(parents=True, exist_ok=True)
+        self.best_score = float("-inf")
+        self._lock = Lock()
+
+    def init_from_nodes(self, nodes: List[Node]) -> None:
+        if nodes:
+            self.best_score = max(node.score for node in nodes)
+
+    def update_if_better(
+        self,
+        node: Node,
+        step_name: str,
+        source_step_dir: Optional[Path] = None,
+    ) -> bool:
+        with self._lock:
+            if node.score <= self.best_score:
+                return False
+            self.best_score = node.score
+            self._write_snapshot(node, step_name, source_step_dir)
+            return True
+
+    def _write_snapshot(
+        self,
+        node: Node,
+        step_name: str,
+        source_step_dir: Optional[Path],
+    ) -> None:
+        best_step_dir = self.best_dir / step_name
+        best_step_dir.mkdir(parents=True, exist_ok=True)
+        (best_step_dir / "code").write_text(node.code or "", encoding="utf-8")
+
+        results_file = best_step_dir / "results.json"
+        source_results_file = source_step_dir / "results.json" if source_step_dir else None
+        if source_results_file and source_results_file.exists():
+            results_file.write_text(
+                source_results_file.read_text(encoding="utf-8"),
+                encoding="utf-8",
+            )
+        else:
+            results_file.write_text(
+                json.dumps(node.results or {}, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )