生成器作为回调

Question

I am looking for a way to get stuff from a callback into a generator,
or the generator to inherit the callback.

When the callback is called, the generator should run, yield ing the data.

def my_callback(some_data):
    my_generator.execute(some_data)  # what to do?

def my_generator():
    while True:
        yield some_data  # from my_callback

 # main program
 for x in my_generator:
     print(x)

# This is pseudo python code.

While I normally would use a queue and a thread to run and get that callback, in this case I am running inside a python extension of an cli which calls my_callback(data) .
As a result, I can't use threading , as python will only execute that callback. Afterwards the C part of the cli will do stuff again, and python is not executed.

Edit : I could register a 'poll' function, which will get called periodically. Putting a wait in there give at least the thread-queue construction some time to execute. But that feels to dirty for actual code.

Answer 1

The callback can send data to a coroutine which can send it along again if needed. Not sure if this is what you are looking for but your question made me think of coroutines.

def my_callback(some_data):
    cr.send(some_data)  # what to do?

def my_coroutine(target):
    n = 0
    while True:
        data = (yield)  # from my_callback
        print 'my_callback sent: {}'.format(data)
        target.send(data)  # to my_printer

def my_printer(prefix):
    while True:
        s = (yield) # from my_coroutine
        print prefix + s

mp = my_printer('\t\t\t')
mp.next()   # advance to the first yield
cr = my_coroutine(mp)
cr.next()   # advance to the first yield

my_callback('foo')
for n in xrange(3):
    my_callback('foo' + str(n))

cr.close()
mp.close()

>>> 
my_callback sent: foo
            foo
my_callback sent: foo0
            foo0
my_callback sent: foo1
            foo1
my_callback sent: foo2
            foo2
>>> 

If the callback execution is asynchronous, I'm not sure what would happen if the coroutine wasn't back to the first yield and the callback tries to send it something, it might throw a ValueError: generator already executing exception.