Gerenciadores de Contexto Assíncronos

9.1 Gerenciadores de Contexto

Lembra como a gente usava o operador with pra controlar o acesso a um recurso? Com ele dava pra saber exatamente quando um recurso começou a ser usado e quando esse processo terminou. A mesma coisa dá pra fazer com "recursos assíncronos".

Gerenciadores de Contexto Assíncronos (AsyncContextManager) são usados pra gerenciar recursos na programação assíncrona, garantindo que os recursos sejam abertos e fechados adequadamente em funções assíncronas. Eles funcionam de maneira semelhante aos gerenciadores de contexto normais, mas são pra usar em funções assíncronas com as palavras-chave async with.

Não vou entrar em muitos detalhes agora, já que por enquanto você não vai criar seus próprios gerenciadores de contexto assíncronos, e quando você decidir fazer isso, já terá esquecido tudo de qualquer forma. Mas quero apresentar a ideia pra você.

Criando um Gerenciador de Contexto Assíncrono

Gerenciadores de Contexto Assíncronos são definidos usando os métodos __aenter__ e __aexit__. Esses métodos são semelhantes aos métodos __enter__ e __exit__ nos gerenciadores de contexto normais, mas são assíncronos.

• __aenter__(): Método assíncrono chamado ao entrar no contexto.
• __aexit__(exc_type, exc, tb): Método assíncrono chamado ao sair do contexto. Recebe três argumentos: tipo de exceção, a própria exceção e a (traceback).

Exemplo de criação de um gerenciador de contexto assíncrono

import asyncio

class AsyncContextManager:
    async def __aenter__(self):
        print("Entrar no contexto")
        return self
        
    async def __aexit__(self, exc_type, exc, tb):
        print("Sair do contexto")
        
async def main():
    async with AsyncContextManager():
        print("Dentro do contexto")
        
asyncio.run(main())

Veja como esse código vai ser executado:

1. Funciona assíncronamente vai iniciar main()
2. A função main() começa a ser executada
3. Cria-se um objeto do tipo AsyncContextManager
4. No objeto AsyncContextManager o método __aenter__() é chamado
5. É exibido print("Entrar no contexto")
6. Executa o código print("Dentro do contexto")
7. No objeto AsyncContextManager o método __aexit__() é chamado
8. A execução da função main() termina

9.2 Exemplos de uso

No exemplo acima, não é obrigatório usar a versão assíncrona do gerenciador de contexto — o código vai funcionar mesmo se você fizer ele ser síncrono.

Mas o gerenciador assíncrono é necessário se dentro do bloco with for chamada uma função assíncrona ou for usado o operador await.

Gerenciador de Contexto Assíncrono para trabalhar com arquivos

Neste exemplo, é usada a biblioteca aiofiles para leitura e escrita assíncrona de arquivos. O gerenciador de contexto assíncrono aiofiles.open permite abrir e fechar arquivos de forma segura no contexto assíncrono.

import aiofiles
import asyncio
            
async def main():
    async with aiofiles.open('example.txt', mode='w') as file:
        await file.write('Hello, world!')
            
asyncio.run(main())

Gerenciador de Contexto Assíncrono para operações de rede

Neste exemplo, é usada a biblioteca aiohttp para realizar requisições HTTP assíncronas. Os gerenciadores de contexto assíncronos ClientSession e session.get garantem a gestão correta das conexões.

import aiohttp
import asyncio
            
async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()
            
async def main():
    html = await fetch('https://example.com')
    print(html)
            
asyncio.run(main())

Gerenciadores de contexto assíncronos garantem a gestão automática de recursos, como arquivos, conexões de rede e outros recursos que precisam ser abertos e fechados.

Os métodos __aenter__ e __aexit__ permitem realizar operações assíncronas ao entrar e sair do contexto, garantindo a execução paralela das tarefas. Usar gerenciadores de contexto assíncronos ajuda a evitar vazamentos de recursos e garante que todos os recursos sejam liberados corretamente.