Extension
*********

La direction principale pour l'extension d'"asyncio" est l'écriture de
classes *event loop* personnalisées. *Asyncio* a des assistants qui
peuvent être utilisés pour simplifier cette tâche.

Note:

  la réutilisation du code asynchrone existant doit se faire avec
  prudence, une nouvelle version de Python est libre de rompre la
  compatibilité descendante dans la partie *interne* de l'API.


Écriture d'une boucle d'événements personnalisée
================================================

"asyncio.AbstractEventLoop" déclare de très nombreuses méthodes. Les
mettre en œuvre à partir de zéro est un travail fastidieux.

Une boucle d'événements peut obtenir gratuitement l'implémentation de
nombreuses méthodes courantes en héritant de "asyncio.BaseEventLoop".

Le successeur doit, pour ce qui le concerne, implémenter un ensemble
de méthodes *privées* déclarées mais non implémentées dans
"asyncio.BaseEventLoop".

Par exemple, "loop.create_connection()" vérifie les arguments, résout
les adresses DNS et appelle "loop._make_socket_transport()" qui doit
être implémentée par la classe héritée. La méthode
"_make_socket_transport()" n'est pas documentée et est considérée
comme une API *interne*.


Constructeurs privés *Future* et *Task*
=======================================

"asyncio.Future" et "asyncio.Task" ne doivent jamais être créées
directement, veuillez utiliser les correspondances
"loop.create_future()" et "loop.create_task()", ou les fabriques
"asyncio.create_task()" à la place.

Cependant, les *boucles d'événements* tierces peuvent *réutiliser* les
implémentations de *Future* et de *Task* intégrées dans le but
d'obtenir gratuitement un code complexe et hautement optimisé.

À cette fin, les constructeurs *privés* suivants sont répertoriés :

Future.__init__(*, loop=None)

   Crée une instance de la *future* native.

   *loop* est une instance de boucle d'événements facultative.

Task.__init__(coro, *, loop=None, name=None, context=None)

   Crée une instance de la *Task* native.

   *loop* est une instance de boucle d'événements facultative. Le
   reste des arguments est décrit dans la description de
   "loop.create_task()".

   Modifié dans la version 3.11: l'argument *contexte* a été ajouté.


Prise en charge de la durée de vie des tâches
=============================================

A third party task implementation should call the following functions
to keep a task visible by "asyncio.all_tasks()" and
"asyncio.current_task()":

asyncio._register_task(task)

   Enregistre une nouvelle *tâche* comme gérée par *asyncio*.

   Appelez la fonction à partir d'un constructeur de tâche.

asyncio._unregister_task(task)

   Désinscrit une *tâche* des structures internes *asyncio*.

   La fonction doit être appelée lorsqu'une tâche est sur le point de
   se terminer.

asyncio._enter_task(loop, task)

   Bascule la tâche en cours vers l'argument *task*.

   Appelez la fonction juste avant d'exécuter une partie de la
   *coroutine* intégrée ("coroutine.send()" ou "coroutine.throw()").

asyncio._leave_task(loop, task)

   Rebascule la tâche en cours de *task* à "None".

   Appelez la fonction juste après l'exécution de "coroutine.send()"
   ou "coroutine.throw()".
