Efficient prime k-tuple search

def sieve_of_eratosthenes(num):
    prime = [True for i in range(num+1)]
    # boolean array
    p = 2
    while (p * p <= num):

        # If prime[p] is not
        # changed, then it is a prime
        if (prime[p] == True):

            # Updating all multiples of p
            for i in range(p * p, num+1, p):
                prime[i] = False
        p += 1

    primes = []

    # Print all prime numbers
    for p in range(2, num+1):
        if prime[p]:
            primes.append(p)

    return primes

def inverses_of_eratosthenes(p_m, primes):
    inverses = []

    for p in primes:
        try:
            inverse = pow(p_m, -1, p)
        except:
            inverse = 0 # if no multiplicative inverse

        inverses.append(inverse)

    return inverses

def get_primorial(m):

    primes = sieve_of_eratosthenes(m*m+1)

    p_m = 1

    for i in range(0,m):
        p_m *= primes[i]

    return p_m

def fermat_prime_p(n):
    if n == 2:
        return True
    if not n & 1:
        return False
    if pow(2, n-1, n) == 1:
        return True
    return False

def fermat_is_valid_pow(n, constellation_pattern):
    for offset in constellation_pattern:
        if not fermat_prime_p(n+offset):
            return False
    return True

def get_eliminated_factors(primes, inverses, offset, p_m, m, t, constellation_pattern):

    eliminated_factors = {}
    k_max = 200

    i = 0
    for p in primes:
        p_m_inverse = inverses[i]

        if p_m_inverse != 0:

            for c_i in constellation_pattern:
                f_p = ((-offset - c_i) * p_m_inverse ) % p
                eliminated_factors[f_p] = True

                for k in range(0, k_max):
                        f_p+=p
                        eliminated_factors[f_p] = True

        i+=1
    return eliminated_factors

def wheel_factorization(p_m, o, t, eliminated_factors, constellation_pattern):

    t_prime = t + p_m - (t % p_m)

    f_start = int(t_prime / p_m)

    f_max = 20000000

    primality_tests = 0
    primes = 0

    for f in range(f_start, f_start+f_max):
        if f not in eliminated_factors:
            primality_tests +=1
            candidate = p_m*f + o
            if fermat_is_valid_pow(candidate, constellation_pattern):
                # print(candidate)
                primes+=1


    print("primality_tests: ", primality_tests)
    print("primes: ", primes)

if __name__ == "__main__":
    # Pick primorial number
    m = 4
    # Pick offset
    o = 97
    # Pick Difficulty
    t = 10_000_000
    # Pick Constellation Pattern
    # constellation_pattern = [0, 6, 8, 14, 18, 20, 24, 26]
    constellation_pattern = [0, 4, 6, 10, 12, 16]
    # Pick prime_table_limit
    prime_table_limit = 1_000_000

    p_m = get_primorial(m)

    print("Calculating prime table up to ", prime_table_limit)
    primes = sieve_of_eratosthenes(prime_table_limit)

    print("Calculating inverses...")
    inverses = inverses_of_eratosthenes(p_m, primes)

    print("Sieving... ")
    eliminated_factors = {}
    eliminated_factors = get_eliminated_factors(primes, inverses, o, p_m, m, t, constellation_pattern)

    print("Primality Testing candidates...")
    wheel_factorization(p_m, o, t, eliminated_factors, constellation_pattern)