Wheel based unbounded sieve of Eratosthenes in Python
I thought of two things that achieve a 27 % speedup and simplify wsieve a bit, at the expense of some precomputations.


Turning the wheel step by step from prime to prime seems wasteful. Instead of this code

while not cbase == p:
    cbase += wheel[ibase]
    ibase = (ibase+1) % wsize   
j = ibase  


you could do directly j = spoke_index[p % 210] having precomputed a suitable spoke_index dictionary with 48 entries. The variables cbase and ibase can be eliminated.
When a wheel is involved I find it hard to resist using itertools.cycle. Instead of this

i = 0                   
while True:
    c += wheel[i] ; i = (i+1) % wsize    


you could do this

for step in cycle(wheel):
    c += step


The other uses of the wheel are more difficult to replace because there is no direct way to start the cycle at an arbitrary position. However, we can precompute all 48 rotations of wheels and put them in a dictionary for easy lookup.


My version of full solution. Instead of the index j I put a cyclic iterator in mults. 

from itertools import cycle

CIRCUMFERENCE = 2*3*5*7
BASE_PRIMES = (2,3,5,7)
NEXT_PRIME = 11

def wheel(start):
    result = []
    i = start
    for j in range(i + 1, i + 1 + CIRCUMFERENCE):
        if all(j % k for k in BASE_PRIMES):
            result.append(j - i)
            i = j
    return result

def rotated_wheels():
    result = {}
    i = 1
    while i &lt; CIRCUMFERENCE:
        result[i] = wheel(i)
        i = i + result[i][0]
    return result

def primes(): 
    yield from BASE_PRIMES
    yield from wsieve()

def wsieve(wheels=rotated_wheels()):       
    yield NEXT_PRIME          
    mults = {}      
    ps = wsieve() 
    p = next(ps)   
    psq, c = p*p, p             
    cwheel = cycle(wheels[c])
    for step in cwheel:
        c += step
        if c in mults:
            (mwheel, pbase) = mults.pop(c)         
        elif c &lt; psq:              
            yield c 
            continue   
        else:          # (c==psq)     
            mwheel = cycle(wheels[p % CIRCUMFERENCE])
            pbase = p             
            p = next(ps) ; psq = p*p
        m = c
        for mstep in mwheel:
            m += pbase * mstep
            if m not in mults:
                break
        mults[m] = (mwheel, pbase)  




Edited to use for instead of while.