Introdução ao Async python para API da Binance

 

Com a versão v1.0.0 do python-binance para Binance , veio a opção de funcionalidade assíncrona para o cliente REST, além de migrar os fluxos de websocket e implementações de cache de profundidade para assíncrono.

A vantagem do processamento assíncrono é que não precisamos bloquear a E/S, que é toda ação que fazemos quando interagimos com os servidores da Binance.

Ao não bloquear a execução, podemos continuar processando os dados enquanto aguardamos respostas ou novos dados dos websockets.

Exemplo assíncrono simples

 

import asyncio

from binance import AsyncClient


async def main():

    client = await AsyncClient.create()
    exchange_info = await client.get_exchange_info()
    tickers = await client.get_all_tickers()

if __name__ == "__main__":

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

o asyncio roda com um event loop, chamamos run_until_completeno início da nossa função main. Este é um padrão geral para programas assíncronos. Isso terminará quando a função principal terminar, e podemos controlar isso especialmente se estivermos ouvindo websockets.

A palavra-chave async na frente da função a define como uma corrotina. Se você chamar uma corrotina diretamente, a função não será executada, você apenas obterá a corrotina de volta.

Para realmente executar a corrotina, usamos a palavra-chave await, como fizemos com as funções get_exchange_infoe get_all_tickersdo cliente Binance.

Agora, se executarmos isso, obteremos as informações da troca e todos os tickers, no entanto, não aproveitamos nenhuma vantagem do assíncrono aqui. Cada solicitação será executada uma após a outra.

Então, como podemos melhorar isso? Usamos asyncio.gather , vamos atualizar nossa função principal para o seguinte

async def main():

    client = await AsyncClient.create()
    res = await asyncio.gather(
        client.get_exchange_info()
        client.get_all_tickers()
    )

Como isso ajuda?

O que estamos fazendo aqui é coletar as corrotinas que queremos que sejam executadas e depois passá-las juntas ao asyncio para executar "simultaneamente".

resserá uma lista de respostas, ordenadas da mesma forma que as corrotinas que passamos para coletar.

Adicionando Websockets

 Fazer solicitações é ótimo, mas agir com base em informações em tempo real é a base de qualquer estratégia de bot.

Então, como ouviríamos os dados do websocket em tempo real enquanto também fazíamos solicitações de API?

from binance import AsyncClient, BinanceSocketManager


async def kline_listener(client):
    bm = BinanceSocketManager(client)
    async with bm.kline_socket(symbol='BNBBTC') as stream:
        while True:
            res = await stream.recv()
            print(res)

async def main():

    client = await AsyncClient.create()
    await kline_listener(client)

Aqui importamos o BinanceSocketManager e adicionamos uma corrotina para ouvir a stream kline BNBBTC de 1 minuto.

Você pode estar familiarizado com with python e gerenciadores de contexto, então aqui estamos interagindo com um gerenciador de contexto assíncrono.

Atualizamos a função main para chamar essa corrotina.

Quando executamos isso, vemos que ele não sai após a primeira mensagem, mas continua. Conseguimos isso usando while True:o gerenciador de contexto assíncrono, garantindo que ele não saísse.

Agora, passamos de solicitações de API para escuta de websocket, então vamos adicionar uma solicitação de API.

from binance import AsyncClient, BinanceSocketManager


async def kline_listener(client):
    bm = BinanceSocketManager(client)
    symbol = 'BNBBTC'
    res_count = 0
    async with bm.kline_socket(symbol=symbol) as stream:
        while True:
            res = await stream.recv()
            res_count += 1
            print(res)
            if res_count == 5:
                res_count = 0
                order_book = await client.get_order_book(symbol=symbol)
                print(order_book)

Após cada 5ª resposta do websocket, buscamos e exibimos o livro de pedidos. Este pedido pode ser um pedido, mas para os nossos propósitos o resultado é o mesmo.

Agora, isso pode parecer que terminamos, mas o que está realmente acontecendo aqui é semelhante ao nosso primeiro exemplo. Quando buscamos o livro de pedidos, na verdade estamos bloqueando a função websocket recvde ser chamada.

Então, o que podemos fazer aqui para remover esse bloqueio? Podemos aproveitar o asyncio.call_soon que agenda uma corrotina para ser executada no próximo intervalo de loop. O que se traduz o mais rápido possível e nos tira desse loop atual para evitar o bloqueio.

from binance import AsyncClient, BinanceSocketManager

async def order_book(client, symbol):
    order_book = await client.get_order_book(symbol=symbol)
    print(order_book)


async def kline_listener(client):
    bm = BinanceSocketManager(client)
    symbol = 'BNBBTC'
    res_count = 0
    async with bm.kline_socket(symbol=symbol) as stream:
        while True:
            res = await stream.recv()
            res_count += 1
            print(res)
            if res_count == 5:
                res_count = 0
                loop.call_soon(asyncio.create_task, order_book(client, symbol))

Agora podemos ouvir o websocket, reagir a eventos e chamar solicitações de API sem bloqueio.

Próximos passos

Eu recomendaria ler os documentos do python asyncio para saber mais.

 

Traduzido de  https://sammchardy.github.io/async-binance-basics/