WIP prime image generator

gen.py

from multiprocessing import Pool
import random
import re
from collections import defaultdict

primes = set()
best_prime = None
best_score = None
template = (
    "BBBBBBABBBBBB"
    "BBBBBBABBBBBB"
    "BBBBBAAABBBBB"
    "BBBBBAAABBBBB"
    "BBBBBBAAABBBB"
    "BBBBABAAABBBB"
    "BBBAAAAAAABBB"
    "BBBAAAAAAABBB"
    "BBAAAABAAAABB"
    "BBAAABBBAABBB"
    "BAAAABBBAAAAB"
    "BAABBBBBBBAAB"
    "AABBBBBBBBBA9"
)
template = template.replace("B", "1")

fill = ["0", "6", "8", "9"]

def log(result):
    global primes
    global best_prime
    global best_score

    output = []
    for n in result:
        if n not in primes:
            this_score = get_num_score(n)
            if this_score >= best_score:
                print("new best prime:", "\n" + pretty_prime(n), "new={} old={}".format(this_score, best_score))
                best_score = this_score
                best_prime = n
                output.append(n)
    primes.update(result)

    if output:
        print("writing {} new primes".format(len(output)))
        with open("probably_prime.txt", "a") as f:
            f.write("\n".join(output) + "\n")

def get_num_score(n, debug=False):
    counter = defaultdict(int)
    for c in str(n):
        counter[c] += 1

    score = 0
    for digit, count in counter.items():
        if debug:
            print(digit, count)
        score += count * count

    return score

def is_probably_prime(x):
    return pow(2, x-1, x) == 1

def get_num():
    num = ""
    for c in template:
        if c == "A":
            num += random.choice(fill)
        else:
            num += c

    return int(num)

def prime_finder(batch, n):
    result = set()
    #print("{}:".format(batch), "started")

    while len(result) < n:
        num = get_num()

        if is_probably_prime(num):
            result.add(str(num))

    #print("{}:".format(batch), "finished")

    return result

def pretty_prime(n):
    s = str(n)
    s = re.sub(r'(.{13})', r'\1\n', s)
    s = re.sub(r'(\d)', r'\1 ', s)
    return s

def main():
    global primes

    with open("probably_prime.txt") as f:
        for line in f:
            primes.add(int(line))
    print("loaded {} primes".format(len(primes)))

    global best_prime
    global best_score
    for this_prime in primes:
        this_score = get_num_score(this_prime)
        print(this_score, this_prime)
        if best_score is None or this_score > best_score:
            best_score = this_score
            best_prime = this_prime

    print("current best prime:", "\n" + pretty_prime(best_prime), "score={}".format(best_score))

    pool = Pool(processes=3)

    for i in range(99999):
        pool.apply_async(prime_finder, (i, 32,), callback=log, error_callback=print)

    pool.close()
    pool.join()

if __name__ == "__main__":
    main()