Asyncio: uma introdução

Definições

O módulo asyncio fornece um framework que gira em torno do event loop (laço de eventos). Um event loop basicamente fica aguardando algo acontecer e então reage a esse evento. Ele é responsável por lidar com I/O e eventos do sistema, entre outras coisas.

O asyncio na verdade tem várias implementações de loop disponíveis. Por padrão, o módulo escolhe a que provavelmente é mais eficiente para o sistema operacional em que está rodando; ainda assim, você pode escolher explicitamente o event loop, se quiser. Um event loop essencialmente diz “quando o evento A acontecer, reaja com a função B”.

Pense em um servidor enquanto espera alguém solicitar um recurso, como uma página web. Se o site não é muito popular, o servidor ficará ocioso por um bom tempo. Mas quando chega um acesso, o servidor precisa reagir. Essa reação é conhecida como tratamento de eventos. Quando um usuário carrega a página, o servidor verifica e chama um ou mais event handlers (manipuladores de evento). Assim que esses handlers terminam, eles precisam devolver o controle ao event loop. Para fazer isso em Python, o asyncio usa corrotinas.

Uma corrotina é uma função especial que pode devolver o controle a quem a chamou sem perder o seu estado. Uma corrotina é uma consumidora e uma evolução de um gerador. Uma grande vantagem em relação a threads é que elas consomem bem menos memória para executar. Note que, quando você chama uma função corrotina, ela não executa de imediato. Em vez disso, retorna um objeto corrotina que você pode passar ao event loop para ser executado imediatamente ou depois.

Outro termo que você provavelmente vai encontrar ao usar o módulo asyncio é future. Um future basicamente representa o resultado de um trabalho que ainda não terminou. Seu event loop pode observar objetos future e esperar que eles finalizem. Quando um future termina, ele é marcado como done. O asyncio também oferece suporte a locks e semáforos.

Por fim, vale mencionar a Task. Uma Task é um invólucro (wrapper) para uma corrotina e uma subclasse de Future. Você pode até agendar uma Task usando o event loop.

async e await

As palavras-chave async e await foram adicionadas no Python 3.5 para definir corrotinas nativas e diferenciá-las das corrotinas baseadas em geradores. Se você quiser uma descrição aprofundada de async e await, confira a PEP 492.

No Python 3.4, você criaria uma corrotina assim:

Esse decorador ainda funciona no Python 3.5, mas o módulo types recebeu uma atualização com uma função coroutine que agora diz se o que você está usando é uma corrotina nativa ou não. A partir do Python 3.5, você pode usar async def para definir sintaticamente uma função corrotina.

Assim, a função acima ficaria assim:

Ao definir uma corrotina desse jeito, você não pode usar yield dentro da função corrotina. Em vez disso, ela deve incluir uma instrução return ou await, usadas para retornar valores ao chamador. Observe que a palavra-chave await só pode ser usada dentro de uma função async def.

As palavras-chave async/await podem ser vistas como uma API para programação assíncrona. O módulo asyncio é “apenas” um framework que usa async/await para programar de forma assíncrona. Existe inclusive um projeto chamado curio que prova esse conceito, pois implementa um event loop separado que usa async/await por baixo dos panos.

Um exemplo ruim de corrotina

Embora seja útil ter bastante contexto de como tudo isso funciona, às vezes você só quer ver alguns exemplos para entender a sintaxe e como montar as peças.

Com isso em mente, vamos começar com um exemplo simples!

Uma tarefa bem comum é baixar um arquivo de algum lugar, seja um recurso interno ou um arquivo na Internet. Normalmente você vai querer baixar mais de um arquivo.

Então vamos criar um par de corrotinas para fazer isso:

import asyncio
import os
import urllib.request
 
async def download_coroutine(url):
    #"A coroutine to download the specified url"
    request = urllib.request.urlopen(url)
    filename = os.path.basename(url)
 
    with open(filename, 'wb') as file_handle:
        while True:
            chunk = request.read(1024)
            if not chunk:
                break
            file_handle.write(chunk)
    msg = 'Finished downloading {filename}'.format(filename=filename)
    return msg
 
async def main(urls):
    """
    Creates a group of coroutines and waits for them to finish
    """
    coroutines = [download_coroutine(url) for url in urls]
    completed, pending = await asyncio.wait(coroutines)
    for item in completed:
        print(item.result())
 
 
if __name__ == '__main__':
    urls = ["http://www.irs.gov/pub/irs-pdf/f1040.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"]
 
    event_loop = asyncio.get_event_loop()
    try:
        event_loop.run_until_complete(main(urls))
    finally:
        event_loop.close()

Neste código, importamos os módulos necessários e criamos nossa primeira corrotina usando a sintaxe async. Essa corrotina se chama download_coroutine e usa o urllib do Python para baixar qualquer URL passada para ela. Quando termina, retorna uma mensagem avisando.

A outra corrotina é a principal. Ela basicamente recebe uma lista com uma ou mais URLs e as enfileira. Usamos a função wait do asyncio para aguardar as corrotinas terminarem. Claro que, para realmente iniciar as corrotinas, elas precisam ser adicionadas ao event loop. Fazemos isso no final, quando obtemos um event loop e chamamos seu método run_until_complete. Observe que passamos a corrotina principal ao event loop. Isso inicia sua execução, que por sua vez enfileira a segunda corrotina e a dispara. Esse encadeamento é conhecido como chained coroutine.

O problema desse exemplo é que ele na prática não é assíncrono. O motivo é que a função download_coroutine não é assíncrona de verdade. O problema aqui é que o urllib não é assíncrono e, além disso, não estamos usando await nem yield. Uma forma melhor seria usar o pacote aiohttp. Vamos ver isso a seguir!

Um exemplo melhor de corrotina

O pacote aiohttp foi criado para clientes e servidores HTTP assíncronos. Você pode instalá-lo com pip assim:

pip install aiohttp

Depois de instalado, vamos atualizar nosso código para usar o aiohttp e baixar os arquivos:

Você vai notar que importamos dois itens novos: aiohttp e async_timeout. O segundo é, na verdade, uma dependência do aiohttp e permite criar um context manager de timeout. Vamos começar pelo final do código e ir subindo. No condicional do final, iniciamos nosso event loop assíncrono e chamamos a função principal.

Na função principal, criamos um objeto ClientSession e o passamos para nossa função corrotina de download para cada uma das URLs que queremos baixar. Na download_coroutine, criamos um context manager async_timeout.timeout() que basicamente cria um temporizador de X segundos. Quando o tempo acaba, o context manager termina (ou dá timeout). Aqui, o limite é de 10 segundos. Em seguida, chamamos o método get() da sessão, que nos dá um objeto de resposta. Agora vem a parte “mágica”: ao usar o atributo content do objeto de resposta, recebemos uma instância de aiohttp.StreamReader, que permite baixar o arquivo em blocos do tamanho que quisermos. Conforme lemos o arquivo, gravamos no disco local. Por fim, chamamos o método release() da resposta, que finaliza o processamento.

Segundo a documentação do aiohttp, como o objeto de resposta foi criado dentro de um context manager, tecnicamente o release() é chamado implicitamente. Mas, em Python, o explícito costuma ser melhor, e há uma nota na documentação indicando que não devemos contar com a conexão simplesmente sumindo. Então, neste caso, acho melhor chamar o release explicitamente.

Há uma parte que ainda é bloqueante: a gravação em disco. Enquanto escrevemos o arquivo, ainda bloqueamos. Existe outra biblioteca, a aiofiles, que poderíamos usar para tornar a escrita de arquivos assíncrona também, mas vou deixar essa melhoria para você.

Agendando chamadas

Você também pode agendar chamadas a funções “normais” usando o event loop do asyncio. O primeiro método que vamos ver é o call_soon. Ele basicamente chama seu callback ou event handler assim que possível. Ele funciona como uma fila FIFO, então, se alguns callbacks demorarem para rodar, os demais serão atrasados até que os anteriores terminem.

Vamos ver um exemplo:

A maioria das funções do asyncio não aceita argumentos nomeados, então precisamos do módulo functools se quisermos passar keywords para nosso handler. Nossa função “normal” imprime um texto no stdout sempre que é chamada. Se você definir o argumento stop como True, ela também para o event loop.

Na primeira chamada, não paramos o loop. Na segunda chamada, paramos. Fazemos isso porque usamos run_forever, que coloca o event loop em um laço infinito. Quando o loop é interrompido, podemos fechá-lo.

Ao rodar esse código, você deverá ver a seguinte saída:

starting event loop
Event handler called
Event handler called
stopping the loop
closing event loop

Existe uma função relacionada chamada call_soon_threadsafe. Como o nome indica, ela funciona como a call_soon, mas é thread-safe. Se você quiser adiar uma chamada para algum momento no futuro, pode usar a função call_later. Neste caso, poderíamos trocar a assinatura de call_soon por:

loop.call_later(1, event_handler, loop)

Isso vai atrasar a chamada do nosso event handler por um segundo, e então chamá-lo passando o loop como primeiro parâmetro. Se quiser agendar um horário específico no futuro, é melhor usar a noção de tempo do próprio loop, e não a do computador. Você pode fazer assim:

current_time = loop.time()

Com isso em mãos, basta usar a função call_at e passar o horário em que você quer que o handler seja chamado. Suponha que queremos chamá-lo daqui a cinco minutos. Ficaria assim:

loop.call_at(current_time + 300, event_handler, loop)

Neste exemplo, usamos o horário atual do loop e somamos 300 segundos (cinco minutos). Assim, adiamos a chamada do nosso event handler por cinco minutos. Legal, né?

Tasks

Tasks são uma subclasse de Future e um wrapper em torno de uma corrotina. Elas permitem que você acompanhe quando o processamento termina. Por serem um tipo de Future, outras corrotinas podem aguardar uma task, e você também pode obter o resultado de uma task quando ela terminar.

Vamos ver um exemplo simples:

Aqui criamos uma função assíncrona que recebe o número de segundos que a função vai levar para rodar. Isso simula um processo demorado. Em seguida, criamos o event loop e um objeto task chamando a função create_task do event loop. A create_task recebe a função que queremos transformar em task. Depois, pedimos ao event loop que rode até a task terminar. No final, obtemos o resultado da task, já que ela finalizou.

Tasks também podem ser canceladas facilmente com seu método cancel. É só chamá-lo quando quiser encerrar uma task. Se uma task for cancelada enquanto aguarda outra operação, ela lançará um CancelledError.

Fechando

A esta altura, você já sabe o suficiente para começar a trabalhar com a biblioteca asyncio por conta própria. Ela é bem poderosa e permite fazer muita coisa interessante. A biblioteca asyncio foi projetada para sockets de rede.

Uma ótima biblioteca que permite programação assíncrona com sockets antes do asyncio é o framework Twisted. Outro projeto interessante é o Dask, uma biblioteca flexível de computação paralela para análises. Vale explorar a documentação do módulo asyncio e deixar as ideias fluírem!