goldbach.py

def weak_goldbach(number):
    if is_pair(number):
        raise InvalidNumberError(number + "is pair")
    if number <= 5:
        raise InvalidNumberError(number + "is equal or less than 5")
    primes = find_primes_before_number(number)
    return three_primes_sum(number, primes)

def is_pair(number):
    if number % 2 == 0:
        return True
    return False

def find_primes_before_number(number):
    result = []
    for i in range(2, number):
        if is_prime(i):
            result.append(i)
    return tuple(result)

def is_prime(number):
    for i in range(2, number):
        if number % i == 0:
            return False
    return True

def three_primes_sum(number, primes):
    for prime in primes:
        delta = number - prime
        if is_pair(delta) and delta != 2:
            try:
                delta_primes = find_primes_before_number(delta)
                two_primes = two_primes_sum(delta, delta_primes)
                break
            except InvalidNumberError:
                continue
    return two_primes + (prime,)

def two_primes_sum(number, primes):
    for prime in primes:
        for prime2 in primes:
            if prime + prime2 == number:
                return (prime, prime2)
    raise InvalidNumberError("Number can't be sumed")

class InvalidNumberError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

goldbach_test.py

import unittest
from goldbach import weak_goldbach, find_primes_before_number, is_prime, two_primes_sum

class GoldbachTest(unittest.TestCase):
    def test_weak_goldbach(self):
        self.assertTrue(self.is_valid_output(199, weak_goldbach(199)))
        self.assertTrue(self.is_valid_output(11, weak_goldbach(11)))
        self.assertTrue(self.is_valid_output(35, weak_goldbach(35)))
        self.assertTrue(self.is_valid_output(111, weak_goldbach(111)))
        self.assertTrue(self.is_valid_output(17, weak_goldbach(17)))
        self.assertTrue(self.is_valid_output(287, weak_goldbach(287)))
        self.assertTrue(self.is_valid_output(53, weak_goldbach(53)))

    def is_valid_output(self, input, output):
        for number in output:
            if not is_prime(number):
                return False
            input -= number
        if input != 0:
            return False
        return True

    def test_find_primes_before_number(self):
        self.assertEqual((2,3,5,7), find_primes_before_number(9))
        self.assertEqual((2,3), find_primes_before_number(4))
    
    def test_is_prime(self):
        self.assertEqual(True, is_prime(5))
        self.assertEqual(True, is_prime(2))
        self.assertEqual(False, is_prime(4))
    
    def two_primes_sum(self):
        self.assertEqual((3,3), two_primes_sum(6, find_primes_before_number(6)))
        self.assertEqual((3,5), two_primes_sum(8, find_primes_before_number(8)))
        self.assertEqual((7,3), two_primes_sum(10, find_primes_before_number(10)))