使用 zmq 和 asyncio 的 2 个 Python 脚本之间的非阻塞通信

Question

我正在尝试同时运行 2 个单独的 python 脚本，其中一个是服务器，另一个是客户端。 服务器脚本 example_1a.py 从 API 获取并打印一个快速的 stream 加密价格，永远运行。 客户端脚本 example_1b.py 每秒向服务器请求最新价格。

我的问题是我希望服务器不受客户端阻碍地继续流式传输和打印其加密价格，仅在请求时才暂停发送信息。 实际发生的是，服务器停止一切并等待，直到它收到来自客户端的请求，这大大减慢了它的速度。

我试图合并 Asyncio 以实现异步性，但我不能正确应用它。 有人对我可以做些什么来向服务器发出非阻塞客户端请求有任何想法吗？ 谢谢。

这是我的客户端脚本example_1b.py ：

# Sends request to example_1a.py (server) via zmq.asyncio every 1 second
# Receives and prints reply

import zmq.asyncio
import asyncio
import sys

if sys.platform:
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())     # this line prevents a RuntimeWarning

ctx = zmq.asyncio.Context()

async def main():

    counting = 0

    port = 5555

    async def send_and_wait():
        sock = ctx.socket(zmq.REQ)
        sock.connect('tcp://localhost:%d' % port)
        await sock.send_string('Hello from the Client!')
        reply = await sock.recv_string()
        print(reply)
        sock.close()
    
    while counting < 10:
        print(f'\n{counting}. Message from the server:')
        await asyncio.sleep(1)
        await send_and_wait()
        counting += 1

if __name__ == '__main__':
    asyncio.run(main())

这是我的服务器脚本example_1a.py ：

# Streams latest crypto prices from Polygon.io API using websocket
# Prints the data (prices, timestamps, volumes, etc)
# Calculates and prints lag time
# Receives requests from example_1b.py (client) via zmq.asyncio, prints message, and sends back reply

import zmq.asyncio
import asyncio
import polygon
import sys
from ex_codes import POLYGON_API_KEY
from datetime import datetime
from polygon.enums import StreamCluster

if sys.platform:
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())     # this line prevents a RuntimeWarning

txn_price = 'prices to come...'

ctx = zmq.asyncio.Context()

async def main():

    port = 5555

    myCryptoPair = ['BTC-USD']
    api_key = POLYGON_API_KEY
    stream_client = polygon.AsyncStreamClient(api_key, StreamCluster.CRYPTO)

    async def polySubscribe():
        print('Subscribing to crypto_trades...')
        await stream_client.subscribe_crypto_trades(myCryptoPair, crypto_trades_handler)

    async def polyHandleMessages():
        await stream_client.handle_messages()

    async def crypto_trades_handler(msg):
        global txn_price
        if msg.get('ev') == 'XT':
            txn_price = str(msg.get('p'))
            polygon_time_stamp = msg.get('r')
            current_time = int(datetime.timestamp(datetime.now())*1000)
            lag = (current_time - polygon_time_stamp)/1000
            print(f'\nPolygon timestamp: {polygon_time_stamp}')
            print(f'Current timestamp: {current_time}')
            print(f'{lag} sec lag')
        print(f'Message received: {msg}')
    
    async def recv_and_process(my_txn_price):
        sock = ctx.socket(zmq.REP)
        sock.bind('tcp://*:%d' % port)
        clientMsg = await sock.recv_string()
        await sock.send_string(my_txn_price)
        print(f'Client Message: {clientMsg}')
        sock.close()

    await polySubscribe()

    while True:
        await polyHandleMessages()

        try:
            await recv_and_process(txn_price)
        except:
            continue

if __name__ == '__main__':
    asyncio.run(main())