Politiques
**********

Avertissement:

  Policies are deprecated and will be removed in Python 3.16. Users
  are encouraged to use the "asyncio.run()" function or the
  "asyncio.Runner" with *loop_factory* to use the desired loop
  implementation.

Une politique de boucle d'événements est un objet global utilisé pour
obtenir et définir la boucle d'événements actuelle, ainsi que créer de
nouvelles boucles d'événements. La politique par défaut peut être
remplacée par des alternatives intégrées afin d'utiliser d'autres
implémentations de boucles d'événements, ou remplacée par une
politique personnalisée qui peut remplacer ces comportements.

Un objet politique définit la notion de *contexte* et gère une boucle
d'événement distincte par contexte. Ceci est valable fil par fil
d'exécution par défaut, bien que les politiques personnalisées
puissent définir le *contexte* différemment.

En utilisant une politique de boucle d'événement personnalisée, le
comportement des fonctions "get_event_loop()", "set_event_loop()" et
"new_event_loop()" peut être personnalisé.

Les objets politiques doivent implémenter les API définies dans la
classe mère abstraite "AbstractEventLoopPolicy".


Obtenir et définir la politique
===============================

Les fonctions suivantes peuvent être utilisées pour obtenir et définir
la politique du processus en cours :

asyncio.get_event_loop_policy()

   Renvoie la politique actuelle à l'échelle du processus.

   Obsolète depuis la version 3.14: The "get_event_loop_policy()"
   function is deprecated and will be removed in Python 3.16.

asyncio.set_event_loop_policy(policy)

   Définit la politique actuelle sur l'ensemble du processus sur
   *policy*.

   Si *policy* est définie sur "None", la politique par défaut est
   restaurée.

   Obsolète depuis la version 3.14: The "set_event_loop_policy()"
   function is deprecated and will be removed in Python 3.16.


Objets politiques
=================

La classe mère abstraite de la politique de boucle d'événements est
définie comme suit :

class asyncio.AbstractEventLoopPolicy

   Une classe de base abstraite pour les politiques *asyncio*.

   get_event_loop()

      Récupère la boucle d'évènements pour le contexte actuel.

      Renvoie un objet de boucle d'événements en implémentant
      l'interface "AbstractEventLoop".

      Cette méthode ne devrait jamais renvoyer "None".

      Modifié dans la version 3.6.

   set_event_loop(loop)

      Définit la boucle d'événements du contexte actuel sur *loop*.

   new_event_loop()

      Crée et renvoie un nouvel objet de boucle d'événements.

      Cette méthode ne devrait jamais renvoyer "None".

   Obsolète depuis la version 3.14: The "AbstractEventLoopPolicy"
   class is deprecated and will be removed in Python 3.16.

*asyncio* est livré avec les politiques intégrées suivantes :

class asyncio.DefaultEventLoopPolicy

   La politique *asyncio* par défaut. Utilise "SelectorEventLoop" sur
   les plates-formes Unix et "ProactorEventLoop" sur Windows.

   Il n'est pas nécessaire d'installer la politique par défaut
   manuellement. *asyncio* est configuré pour utiliser automatiquement
   la politique par défaut.

   Modifié dans la version 3.8: Sous Windows, "ProactorEventLoop" est
   désormais utilisée par défaut.

   Modifié dans la version 3.14: The "get_event_loop()" method of the
   default asyncio policy now raises a "RuntimeError" if there is no
   set event loop.

   Obsolète depuis la version 3.14: The "DefaultEventLoopPolicy" class
   is deprecated and will be removed in Python 3.16.

class asyncio.WindowsSelectorEventLoopPolicy

   Politique de boucle d'événements alternative utilisant
   l'implémentation de la boucle d'événements "ProactorEventLoop".

   Disponibilité: Windows.

   Obsolète depuis la version 3.14: The
   "WindowsSelectorEventLoopPolicy" class is deprecated and will be
   removed in Python 3.16.

class asyncio.WindowsProactorEventLoopPolicy

   Politique de boucle d'événements alternative utilisant
   l'implémentation de la boucle d'événements "ProactorEventLoop".

   Disponibilité: Windows.

   Obsolète depuis la version 3.14: The
   "WindowsProactorEventLoopPolicy" class is deprecated and will be
   removed in Python 3.16.


Politiques personnalisées
=========================

Pour implémenter une nouvelle politique de boucle d’événements, il est
recommandé de sous-classer "DefaultEventLoopPolicy" et de
réimplémenter les méthodes pour lesquelles un comportement
personnalisé est souhaité, par exemple :

   class MyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):

       def get_event_loop(self):
           """Get the event loop.

           This may be None or an instance of EventLoop.
           """
           loop = super().get_event_loop()
           # Do something with loop ...
           return loop

   asyncio.set_event_loop_policy(MyEventLoopPolicy())
