unit 0.26.2

A self-replicating software nanobot — minimal Forth interpreter that is also a networked mesh agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

"""Challenge/solution protocol for the Python organism."""

import logging
import threading

import sexp
import evolve

log = logging.getLogger(__name__)


class Challenge:
    def __init__(self, id, name, target_output, reward=50, seeds=None):
        self.id = id
        self.name = name
        self.target_output = target_output
        self.reward = reward
        self.seeds = seeds or []
        self.solved = False
        self.solution = ''
        self.solver = ''


class ChallengeStore:
    def __init__(self):
        self._challenges = {}
        self._lock = threading.Lock()

    def on_challenge(self, parsed):
        id = sexp.get_keyword(parsed, 'id')
        if not isinstance(id, int):
            return
        name = sexp.get_keyword(parsed, 'name') or ''
        target = sexp.get_keyword(parsed, 'target') or ''
        reward = sexp.get_keyword(parsed, 'reward') or 50
        seeds = sexp.get_keyword(parsed, 'seeds') or []
        if isinstance(seeds, list):
            seeds = [s for s in seeds if isinstance(s, str)]

        with self._lock:
            if id not in self._challenges:
                self._challenges[id] = Challenge(id, name, target, reward, seeds)
                log.info(f"received challenge #{id}: {name} (reward: {reward})")

    def on_solution(self, parsed):
        ch_id = sexp.get_keyword(parsed, 'challenge-id')
        if not isinstance(ch_id, int):
            return
        program = sexp.get_keyword(parsed, 'program') or ''
        solver = sexp.get_keyword(parsed, 'solver') or ''

        with self._lock:
            ch = self._challenges.get(ch_id)
            if ch and not ch.solved:
                ch.solved = True
                ch.solution = program
                ch.solver = solver
                log.info(f"solution received for #{ch_id} from {solver}")

    def get_unsolved(self):
        with self._lock:
            out = [c for c in self._challenges.values() if not c.solved]
            out.sort(key=lambda c: c.reward, reverse=True)
            return out

    def get(self, id):
        with self._lock:
            return self._challenges.get(id)

    def add(self, ch):
        with self._lock:
            self._challenges[ch.id] = ch

    def count(self):
        with self._lock:
            total = len(self._challenges)
            solved = sum(1 for c in self._challenges.values() if c.solved)
            return total, solved


def try_evolve_solution(ch, seed=42):
    """Attempt to evolve a solution using the Python GP engine."""
    target_val, ok = evolve.parse_target(ch.target_output)
    if not ok:
        return '', False
    expr, found = evolve.run_evolution(target_val, max_gens=200, seed=seed)
    return evolve.format_program(expr), found


def format_solution(challenge_id, program, solver_id):
    return f'(solution :challenge-id {challenge_id} :program "{program}" :solver "{solver_id}")'