将协调生成器管道作为协同程序的最佳方法是什么？

Question

考虑以下代码：

#!/usr/bin/env python
# coding=utf-8
from string import letters


def filter_upper(letters):
    for letter in letters:
        if letter.isupper():
            yield letter

def filter_selected(letters, selected):
    selected = set(map(str.lower, selected))
    for letter in letters:
        if letter.lower() in selected:
            yield letter


def main():
    stuff = filter_selected(filter_upper(letters), ['a', 'b', 'c'])
    print(list(stuff))

main()

这是从发电机构建的管道的图示。我经常在实践中使用这种模式来构建数据处理流程。这就像UNIX管道。

将生成器重构为每个yield暂停执行的协同程序的最优雅方法是什么？

更新

我的第一次尝试是这样的：

#!/usr/bin/env python
# coding=utf-8

import asyncio

@asyncio.coroutine
def coro():
    for e in ['a', 'b', 'c']:
        future = asyncio.Future()
        future.set_result(e)
        yield from future


@asyncio.coroutine
def coro2():
    a = yield from coro()
    print(a)


loop = asyncio.get_event_loop()
loop.run_until_complete(coro2())

但由于某些原因它无效 - 变量a变为None。

更新＃1

我最近想出的是：

服务器

#!/usr/bin/env python
# coding=utf-8
"""Server that accepts a client and send it strings from user input."""


import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = ''
port = 5555

s.bind((host, port))
s.listen(1)

print('Listening...')

conn, addr = s.accept()

print('Client ({}) connected.'.format(addr))

while True:
    conn.send(raw_input('Enter data to send: '))

客户：

#!/usr/bin/env python
# coding=utf-8
"""Client that demonstrates processing pipeline."""

import trollius as asyncio
from trollius import From


@asyncio.coroutine
def upper(input, output):
    while True:
        char = yield From(input.get())
        print('Got char: ', char)
        yield From(output.put(char.upper()))


@asyncio.coroutine
def glue(input, output):
    chunk = []
    while True:
        e = yield From(input.get())
        chunk.append(e)
        print('Current chunk: ', chunk)
        if len(chunk) == 3:
            yield From(output.put(chunk))
            chunk = []


@asyncio.coroutine
def tcp_echo_client(loop):
    reader, writer = yield From(asyncio.open_connection('127.0.0.1', 5555,
                                                        loop=loop))
    q1 = asyncio.Queue()
    q2 = asyncio.Queue()
    q3 = asyncio.Queue()

    @asyncio.coroutine
    def printer():
        while True:
            print('Pipeline ouput: ', (yield From(q3.get())))

    asyncio.async(upper(q1, q2))
    asyncio.async(glue(q2, q3))
    asyncio.async(printer())

    while True:
        data = yield From(reader.read(100))
        print('Data: ', data)

        for byte in data:
            yield From(q1.put(byte))

    print('Close the socket')
    writer.close()


@asyncio.coroutine
def background_stuff():
    while True:
        yield From(asyncio.sleep(3))
        print('Other background stuff...')


loop = asyncio.get_event_loop()
asyncio.async(background_stuff())
loop.run_until_complete(tcp_echo_client(loop))
loop.close()

优于"David Beazley's coroutines"的优势在于，您可以在asyncio和input个队列的处理单元中使用所有output内容。
这里的缺点 - 连接管道单元需要很多队列实例。可以使用比asyncio.Queue更先进的数据结构来修复它 另一个缺点是这种处理单元不会将它们的异常传播到父堆栈帧，因为它们是“后台任务”，而“David Beazley的协同程序”确实传播。

更新＃2

这与我的出现有关：
https://gist.github.com/AndrewPashkin/04c287def6d165fc2832

Answer 1

我认为这里的答案是＆＃34;你不是＆＃34;。我猜你从David Beazley的famous coroutine/generator tutorial那里得到了这个想法。在他的教程中，他使用协同程序基本上是一个反向的生成器管道。通过迭代生成器而不是通过管道拉动数据，而是使用gen_object.send()通过管道推送数据。使用协同程序的概念，你的第一个例子看起来像这样：

from string import letters

def coroutine(func):
    def start(*args,**kwargs):
        cr = func(*args,**kwargs)
        cr.next()
        return cr
    return start

@coroutine
def filter_upper(target):
    while True:
        letter = yield
        if letter.isupper():
            target.send(letter)

@coroutine
def filter_selected(selected):
    selected = set(map(str.lower, selected))
    out = []
    try:
        while True:
            letter = yield
            if letter.lower() in selected:
                out.append(letter)
    except GeneratorExit:
        print out

def main():
    filt = filter_upper(filter_selected(['a', 'b', 'c']))
    for letter in letters:
        filt.send(letter)
    filt.close()

if __name__ == "__main__":
    main()

现在，asyncio中的协同程序是相似的，因为它们是可暂停的生成器对象，可以将数据发送到它们中，但它们实际上并不意味着数据流水线用例在所有。当您执行阻塞I / O操作时，它们意味着用于启用并发。 {I}发生后，yield from暂停点允许控制返回事件循环，事件循环将在协程完成时重新启动协程，将I / O调用返回的数据发送到协程。在这种用例中尝试使用它们真的没有实际的理由，因为根本没有阻塞I / O.

此外，您尝试使用asyncio的问题是a = yield from coro()正在为coro的返回值分配一个。但是你实际上并没有从coro返回任何内容。您在将coro视为实际协程和生成器之间的某个地方陷入了困境。看起来您希望yield from future将future的内容从coro发送到coro2，但这不是协同程序的工作方式。 yield from用于从协程/ Future / Task中提取数据，return用于实际将对象发送回调用方。因此，要让coro实际将某些内容返回coro2，您需要执行此操作：

@asyncio.coroutine
def coro():
    for e in ['a', 'b', 'c']:
        future = asyncio.Future()
        future.set_result(e)
        return future

但是，只有'a'返回coro2才会结束。我想要获得你期望的输出，你需要这样做：

@asyncio.coroutine
def coro():
    future = asyncio.Future()
    future.set_result(['a', 'b', 'c'])
    return future

这也许可以说明为什么asyncio协程不是你想要的。

修改

好的，考虑到除了实际使用异步I / O之外你还想使用流水线操作的情况，我认为你在更新中使用的方法是好的。正如您所建议的那样，通过创建数据结构来帮助自动化队列管理，可以使其更简单：

class Pipeline(object):
    def __init__(self, *nodes):
        if len(nodes) < 2:
            raise Exception("Need at least two nodes in the pipeline")
        self.start = asyncio.Queue()
        in_ = self.start
        for node in nodes:
            out = asyncio.Queue()
            asyncio.async(node(in_, out))
            in_ = out

    @asyncio.coroutine
    def put(self, val):
        yield from self.start.put(val)

# ... (most code is unchanged)

@asyncio.coroutine
def printer(input_, output): 
    # For simplicity, I have the sink taking an output queue. Its not being used,
    # but you could make the final output queue accessible from the Pipeline object
    # and then add a get() method to the `Pipeline` itself.
    while True:
        print('Pipeline ouput: ', (yield from input_.get()))


@asyncio.coroutine
def tcp_echo_client(loop):
    reader, writer = yield from asyncio.open_connection('127.0.0.1', 5555,
                                                        loop=loop)
    pipe = Pipeline(upper, glue, printer)

    while True:
        data = yield from reader.read(100)
        if not data:
            break
        print('Data: ', data)

        for byte in data.decode('utf-8'):
            yield from pipe.put(byte)  # Add to the pipe

    print('Close the socket')
    writer.close()

这简化了Queue管理，但没有解决异常处理问题。我不确定是否可以做很多事情......