Gestionnaires de contexte asynchrones

9.1 Gestionnaires de contexte

Tu te souviens comment on utilisait l'opérateur with pour contrôler l'accès à une ressource ? Grâce à lui, on pouvait suivre exactement quand une ressource était utilisée, et quand ce processus se terminait. On peut faire pareil pour les « ressources asynchrones ».

Les gestionnaires de contexte asynchrones (AsyncContextManager) sont utilisés pour gérer les ressources dans la programmation asynchrone, assurant une bonne ouverture et fermeture des ressources dans les fonctions asynchrones. Ils fonctionnent de manière similaire aux gestionnaires de contexte classiques, mais sont destinés à être utilisés dans des fonctions asynchrones avec les mots-clés async with.

Je ne vais pas en parler en détail, car dans un proche avenir, tu ne vas certainement pas créer tes propres gestionnaires de contexte asynchrones, et au moment où tu décideras de le faire, tu auras probablement tout oublié. Mais je veux te familiariser avec le concept.

Création d'un gestionnaire de contexte asynchrone

Les gestionnaires de contexte asynchrones sont définis en utilisant les méthodes __aenter__ et __aexit__. Ces méthodes sont similaires aux méthodes __enter__ et __exit__ dans les gestionnaires de contexte classiques, mais elles sont asynchrones.

• __aenter__(): Méthode asynchrone, appelée à l'entrée du contexte.
• __aexit__(exc_type, exc, tb): Méthode asynchrone, appelée à la sortie du contexte. Reçoit trois arguments : le type d'exception, l'exception elle-même et la trace (traceback).

Exemple de création d'un gestionnaire de contexte asynchrone

import asyncio

class AsyncContextManager:
    async def __aenter__(self):
        print("Entrée dans le contexte")
        return self
        
    async def __aexit__(self, exc_type, exc, tb):
        print("Sortie du contexte")
        
async def main():
    async with AsyncContextManager():
        print("À l'intérieur du contexte")
        
asyncio.run(main())

Voici comment ce code va être exécuté :

1. La fonction main() sera lancée de manière asynchrone
2. La fonction main() commencera à s'exécuter
3. Un objet de type AsyncContextManager sera créé
4. La méthode __aenter__() de l'objet AsyncContextManager sera appelée
5. Le code print("Entrée dans le contexte") sera exécuté
6. Le code print("À l'intérieur du contexte") sera exécuté
7. La méthode __aexit__() de l'objet AsyncContextManager sera appelée
8. L'exécution de la fonction main() se terminera

9.2 Exemples d'utilisation

Dans l'exemple ci-dessus, il n'est pas obligatoire d'utiliser la version asynchrone du gestionnaire de contexte — le code fonctionnera même si tu le rends synchrone.

Mais le gestionnaire asynchrone est nécessaire si à l'intérieur du bloc with une fonction asynchrone est appelée ou l'opérateur await est utilisé.

Gestionnaire de contexte asynchrone pour travailler avec des fichiers

Dans cet exemple, on utilise la bibliothèque aiofiles pour la lecture et l'écriture de fichiers de manière asynchrone. Le gestionnaire de contexte asynchrone aiofiles.open permet d'ouvrir et de fermer les fichiers en toute sécurité dans un contexte asynchrone.

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())

Gestionnaire de contexte asynchrone pour les opérations réseau

Dans cet exemple, on utilise la bibliothèque aiohttp pour effectuer des requêtes HTTP de manière asynchrone. Les gestionnaires de contexte asynchrones ClientSession et session.get assurent une gestion correcte des connexions.

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())

Les gestionnaires de contexte asynchrones assurent une gestion automatique des ressources, telles que les fichiers, les connexions réseau et d'autres ressources, qui doivent être ouvertes et fermées.

Les méthodes __aenter__ et __aexit__ permettent d'effectuer des opérations asynchrones lors de l'entrée et la sortie du contexte, assurant une exécution parallèle des tâches. L'utilisation de gestionnaires de contexte asynchrones aide à éviter les fuites de ressources et garantit que toutes les ressources seront correctement libérées.