Boucle d'évènements
*******************

**Code source :** Lib/asyncio/events.py, Lib/asyncio/base_events.py

======================================================================

-[ Préface ]-

La boucle d'événements est au cœur de chaque application *asyncio*.
Les boucles d'événements exécutent des tâches et des rappels
asynchrones, effectuent des opérations d'entrée-sorite réseau et
exécutent des sous-processus.

Les développeurs d'applications doivent généralement utiliser les
fonctions *asyncio* de haut niveau, telles que "asyncio.run()", et ne
doivent que rarement référencer l'objet boucle ou appeler ses
méthodes. Cette section est principalement destinée aux auteurs de
code, de bibliothèques et de cadriciels de bas niveau, qui ont besoin
d'un contrôle plus précis sur le comportement de la boucle
d'événements.

-[ Obtention d'une boucle d'évènements ]-

Les fonctions de bas niveau suivantes peuvent être utilisées pour
obtenir, définir ou créer une boucle d'événements :

asyncio.get_running_loop()

   Renvoie la boucle d'événements en cours d'exécution dans le fil
   actuel du système d'exploitation.

   Lève une "RuntimeError" s'il n'y a pas de boucle d'événements en
   cours d'exécution.

   Cette fonction ne peut être appelée qu'à partir d'une coroutine ou
   d'une fonction de rappel.

   Nouveau dans la version 3.7.

asyncio.get_event_loop()

   Arrête l'exécution de la boucle d'évènements.

   Lorsqu'elle est appelée depuis une coroutine ou une fonction de
   rappel (par exemple planifiée avec *call_soon* ou une API
   similaire), cette fonction renvoie toujours la boucle d'événement
   en cours.

   S'il n'y a pas de boucle d'événement en cours d'exécution, la
   fonction renvoie le résultat de l'appel
   "get_event_loop_policy().get_event_loop()".

   Étant donné que cette fonction a un comportement plutôt complexe
   (en particulier lorsque des politiques de boucle d'événements
   personnalisées sont utilisées), l'utilisation de la fonction
   "get_running_loop()" est préférable à "get_event_loop()" dans les
   coroutines et les fonctions de rappel.

   Comme indiqué ci-dessus, envisagez d'utiliser la fonction de haut
   niveau "asyncio.run()", au lieu d'utiliser ces fonctions de bas
   niveau pour créer et fermer manuellement une boucle d'événements.

   Note:

     dans les versions Python 3.10.0–3.10.8 et 3.11.0, cette fonction
     (et d'autres fonctions qui l'utilisent implicitement) levait un
     "DeprecationWarning" s'il n'y avait pas de boucle d'événements en
     cours d'exécution, même si la boucle actuelle était définie dans
     la politique. Dans les versions Python 3.10.9, 3.11.1 et 3.12,
     elles lèvent un "DeprecationWarning" s'il n'y a pas de boucle
     d'événements en cours et qu'aucune boucle actuelle n'est définie.
     Dans une future version de Python, cela deviendra une erreur.

asyncio.set_event_loop(loop)

   Définit *loop* comme boucle d'événements actuelle pour le fil
   d'exécution actuel du système d'exploitation.

asyncio.new_event_loop()

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

Notez que le comportement des fonctions "get_event_loop()",
"set_event_loop()" et "new_event_loop()" peut être modifié en
définissant une politique de boucle d'événement personnalisée.

-[ Sommaire ]-

Cette page de documentation contient les sections suivantes :

* la section Event Loop Methods est la documentation de référence des
  API de boucle d'événements ;

* la section Callback Handles documente les instances "Handle" et
  "TimerHandle" qui sont renvoyées par les méthodes de planification
  telles que "loop.call_soon()" et "loop.call_later()" ;

* la section Server Objects documente les types renvoyés par les
  méthodes de boucle d'événements comme "loop.create_server()" ;

* la section Event Loop Implementations documente les classes
  "SelectorEventLoop" et "ProactorEventLoop" ;

* la section Exemples montre comment travailler avec certaines API de
  boucle d'événements.


Méthodes de la boucle d'évènements
==================================

Les boucles d'événements ont des API **de bas niveau** pour les
éléments suivants :

* Démarrer et arrêter une boucle d'évènements

* Planification des fonctions de rappel

* Planification des rappels différés

* Création de *Futures* et des tâches

* Création de connexions

* Création de serveurs

* Transfert de fichiers

* Passage du flux en TLS

* Surveillance de descripteur de fichier

* Travail direct avec des objets *socket*

* DNS

* Travail avec des tubes (*pipes*)

* Signaux Unix

* Exécution de code dans des pools de threads ou de processus

* API de gestion d'erreur

* Activation du mode débogage

* Exécution de sous-processus


Démarrer et arrêter une boucle d'évènements
-------------------------------------------

loop.run_until_complete(future)

   Lance la boucle jusqu'à ce que *future* (une instance de "Future")
   soit terminée.

   Si l'argument est un objet coroutine, il est implicitement
   programmé pour s'exécuter en tant que "asyncio.Task".

   Renvoie le résultat du *Future* ou lève son exception.

loop.run_forever()

   Exécute la boucle d'événement jusqu'à ce que "stop()" soit appelée.

   Si "stop()" est appelée avant que "run_forever()" ne soit appelée,
   la boucle interroge le sélecteur d'entrée-sortie une fois avec un
   délai d'attente de zéro, exécute tous les rappels programmés en
   réponse aux événements d'entrée-sortie (et ceux qui étaient déjà
   programmés), puis quitte.

   Si "stop()" est appelée pendant que "run_forever()" est en cours
   d'exécution, la boucle exécute le lot actuel de rappels puis se
   termine. Notez que les nouveaux rappels programmés par fonctions de
   rappel ne s'exécuteront pas dans ce cas ; à la place, ils
   s'exécuteront la prochaine fois que "run_forever()" ou
   "run_until_complete()" sera appelée.

loop.stop()

   Arrête l'exécution de la boucle d'évènements.

loop.is_running()

   Renvoie "True" si la boucle d'évènements est démarrée.

loop.is_closed()

   Renvoie "True" si la boucle d'évènements est arrêtée.

loop.close()

   Arrête la boucle d'évènements.

   La boucle ne doit pas être en cours d'exécution lorsque cette
   fonction est appelée. Tous les rappels en attente seront ignorés.

   Cette méthode efface toutes les files d'attente et arrête
   l'exécuteur, mais n'attend pas que l'exécuteur se termine.

   Cette méthode est idempotente et irréversible. Aucune autre méthode
   ne doit être appelée après la fermeture de la boucle d'événements.

coroutine loop.shutdown_asyncgens()

   Planifie la fermeture de tous les objets *générateurs asynchrones*
   actuellement ouverts avec un appel "aclose()". Après avoir appelé
   cette méthode, la boucle d'événements émet un avertissement si un
   nouveau générateur asynchrone est itéré. Elle doit être utilisée
   pour finaliser de manière fiable tous les générateurs asynchrones
   planifiés.

   Notez qu'il n'est pas nécessaire d'appeler cette fonction lorsque
   "asyncio.run()" est utilisée.

   Exemple :

      try:
          loop.run_forever()
      finally:
          loop.run_until_complete(loop.shutdown_asyncgens())
          loop.close()

   Nouveau dans la version 3.6.

coroutine loop.shutdown_default_executor()

   Planifie la fermeture de l'exécuteur par défaut et attend que tous
   les fils se rejoignent dans le "ThreadPoolExecutor". Une fois cette
   méthode appelée, l'utilisation de l'exécuteur par défaut avec
   "loop.run_in_executor()" lève une "RuntimeError".

   Note:

     n'appelez pas cette méthode lorsque vous utilisez
     "asyncio.run()", car cette dernière gère automatiquement l'arrêt
     de l'exécuteur par défaut.

   Nouveau dans la version 3.9.


Planification des fonctions de rappel
-------------------------------------

loop.call_soon(callback, *args, context=None)

   Définit la *fonction de rappel* *callback* à appeler avec les
   arguments *args* à la prochaine itération de la boucle
   d'événements.

   Renvoie une instance de "asyncio.Handle", qui pourra être utilisée
   ultérieurement pour annuler le rappel.

   Les fonctions de rappels sont appelées dans l'ordre dans lequel
   elles sont enregistrées. Chaque fonction de rappel sera appelée
   exactement une fois.

   L'argument facultatif nommé uniquement *context* spécifie un
   "contextvars.Context" personnalisé pour le *callback* à exécuter.
   Les rappels utilisent le contexte actuel lorsqu'aucun *context*
   n'est fourni.

   Contrairement à "call_soon_threadsafe()", cette méthode n'est pas
   compatible avec les programmes à fils d'exécution multiples.

loop.call_soon_threadsafe(callback, *args, context=None)

   Une variante compatible avec les programmes à fils d'exécution
   multiples de "call_soon()". Lors de la planification de rappels à
   partir d'un autre fil d'exécution, cette fonction *doit* être
   utilisée, puisque "call_soon()" n'est pas thread-safe.

   Lève "RuntimeError" si elle est appelée sur une boucle qui a été
   fermée. Cela peut se produire sur un fil secondaire lorsque
   l'application principale se ferme.

   Voir la section exécution concurrente et multi-fils d'exécution de
   la documentation.

   Modifié dans la version 3.7: le paramètre nommé uniquement
   *context* a été ajouté. Voir **PEP 567** pour plus de détails.

Note:

  la plupart des fonctions d'ordonnancement "asyncio" n'autorisent pas
  le passage d'arguments nommés. Pour le faire, utilisez
  "functools.partial()"

     # will schedule "print("Hello", flush=True)"
     loop.call_soon(
         functools.partial(print, "Hello", flush=True))

  L'utilisation d'objets partiels est généralement plus pratique que
  l'utilisation de lambdas, car *asyncio* peut mieux rendre les objets
  partiels dans les messages de débogage et d'erreur.


Planification des rappels différés
----------------------------------

La boucle d'événements fournit des mécanismes pour programmer les
fonctions de rappel à appeler à un moment donné dans le futur. La
boucle d'événements utilise des horloges monotones pour suivre le
temps.

loop.call_later(delay, callback, *args, context=None)

   Planifie le rappel *callback* à appeler après *delay* secondes
   (peut être un entier ou un flottant).

   Une instance de "asyncio.TimerHandle" est renvoyée et peut être
   utilisée pour annuler le rappel.

   *callback* sera appelé exactement une fois. Si deux rappels sont
   programmés exactement à la même heure, l'ordre dans lequel ils sont
   appelés n'est pas défini.

   L'argument positionnel facultatif *args* sera transmis au rappel
   lorsqu'il sera appelé. Si vous voulez que le rappel soit appelé
   avec des arguments nommés, utilisez "functools.partial()".

   Un argument facultatif *context* nommé uniquement permet de
   spécifier un "contextvars.Context" personnalisé pour le *callback*
   à exécuter. Le contexte actuel est utilisé lorsqu'aucun *context*
   n'est fourni.

   Modifié dans la version 3.7: le paramètre nommé uniquement
   *context* a été ajouté. Voir **PEP 567** pour plus de détails.

   Modifié dans la version 3.8: dans Python 3.7 et versions
   antérieures avec l'implémentation de la boucle d'événements par
   défaut, le *delay* ne pouvait pas dépasser un jour. Cela a été
   corrigé dans Python 3.8.

loop.call_at(when, callback, *args, context=None)

   Planifie l'appel de *callback* à l'horodatage absolu donné *when*
   (un *int* ou un *float*), en utilisant la même référence de temps
   que "loop.time()".

   Le comportement de cette méthode est le même que "call_later()".

   Une instance de "asyncio.TimerHandle" est renvoyée et peut être
   utilisée pour annuler le rappel.

   Modifié dans la version 3.7: le paramètre nommé uniquement
   *context* a été ajouté. Voir **PEP 567** pour plus de détails.

   Modifié dans la version 3.8: dans Python 3.7 et versions
   antérieures avec l'implémentation de la boucle d'événements par
   défaut, la différence entre *when* et l'heure actuelle ne pouvait
   pas dépasser un jour. Cela a été corrigé dans Python 3.8.

loop.time()

   Renvoie l'heure actuelle, sous la forme d'une valeur "float", selon
   l'horloge monotone interne de la boucle d'événements.

Note:

  Modifié dans la version 3.8: dans Python 3.7 et les versions
  antérieures, les délais d'expiration (relatif *delay* ou absolu
  *when*) ne doivent pas dépasser un jour. Cela a été corrigé dans
  Python 3.8.

Voir aussi: la fonction "asyncio.sleep()".


Création de *Futures* et des tâches
-----------------------------------

loop.create_future()

   Crée un objet "asyncio.Future" attaché à la boucle d'événements.

   C'est la méthode préférée pour créer des *Futures* avec *asyncio*.
   Cela permet aux boucles d'événements tierces de fournir des
   implémentations alternatives de l'objet *Future* (avec de
   meilleures performances ou instrumentation).

   Nouveau dans la version 3.5.2.

loop.create_task(coro, *, name=None, context=None)

   Planifie l'exécution de coroutine *coro*. Renvoie un objet "Task".

   Les boucles d'événements tierces peuvent utiliser leur propre sous-
   classe de "Task" pour l'interopérabilité. Dans ce cas, le type de
   résultat est une sous-classe de "Task".

   Si l'argument *name* est fourni et non "None", il est défini comme
   le nom de la tâche en utilisant "Task.set_name()".

   Argument facultatif *context* nommé uniquement qui permet de
   spécifier un "contextvars.Context" personnalisé pour la *coro* à
   exécuter. La copie de contexte actuel est créée lorsqu'aucun
   *context* n'est fourni.

   Modifié dans la version 3.8: ajout du paramètre "name".

   Modifié dans la version 3.11: ajout du paramètre "context".

loop.set_task_factory(factory)

   Définit une fabrique de tâches qui sera utilisée par
   "loop.create_task()".

   Si *factory* est "None", la fabrique de tâches par défaut sera
   définie. Sinon, *factory* doit être un *appelable* avec la
   signature correspondant à "(loop, coro, context=None)", où *loop*
   est une référence à la boucle d'événements active et *coro* est un
   objet coroutine . L'appelable doit renvoyer un objet compatible
   avec "asyncio.Future".

loop.get_task_factory()

   Renvoie une fabrique de tâches ou "None" si celle par défaut est
   utilisée.


Création de connexions
----------------------

coroutine loop.create_connection(protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, happy_eyeballs_delay=None, interleave=None)

   Ouvre un flux de transport connecté à l'adresse spécifiée par
   *host* et *port*.

   The socket family can be either "AF_INET" or "AF_INET6" depending
   on *host* (or the *family* argument, if provided).

   The socket type will be "SOCK_STREAM".

   *protocol_factory* doit être un appelable renvoyant un protocole
   gérant le protocole asyncio.

   Cette méthode tente d'établir la connexion en arrière-plan. En cas
   de succès, elle renvoie une paire "(transport, protocol)".

   Le synopsis chronologique de l'opération sous-jacente est le
   suivant :

   1. La connexion est établie et un transport asyncio est créé pour
      cela.

   2. *protocol_factory* est appelée sans arguments et doit renvoyer
      une instance de protocol asyncio.

   3. L'instance de protocole est couplée au transport en appelant sa
      méthode "connection_made()".

   4. Un *n*-uplet "(transport, protocol)" est renvoyé en cas de
      succès.

   Le transport créé est un flux bidirectionnel dépendant de
   l'implémentation.

   Autres arguments :

   * *ssl* : s'il est donné et non faux, un transport SSL/TLS est créé
     (par défaut un transport TCP simple est créé). Si *ssl* est un
     objet "ssl.SSLContext", ce contexte est utilisé pour créer le
     transport ; si *ssl* est "True", un contexte par défaut renvoyé
     par "ssl.create_default_context()" est utilisé.

     Voir aussi: Considérations sur la sécurité SSL/TLS

   * *server_hostname* définit ou remplace le nom d'hôte auquel le
     certificat du serveur cible sera comparé. Ne doit être passé que
     si *ssl* n'est pas "None". Par défaut, la valeur de l'argument
     *host* est utilisée. Si *host* est vide, il n'y a pas de valeur
     par défaut et vous devez transmettre une valeur pour
     *server_hostname*. Si *server_hostname* est une chaîne vide, la
     correspondance du nom d'hôte est désactivée (ce qui constitue un
     risque de sécurité sérieux, permettant des attaques potentielles
     de type « homme du milieu »).

   * *family*, *proto*, *flags* sont facultatifs et sont la famille
     d'adresse, le protocole et les drapeaux à transmettre à
     *getaddrinfo()* pour la résolution de *host*. S'ils sont fournis,
     ils doivent tous être des entiers provenant des constantes du
     module "socket".

   * *happy_eyeballs_delay*, s'il est fourni, active Happy Eyeballs
     pour cette connexion. Il doit s'agir d'un nombre à virgule
     flottante représentant le temps d'attente en secondes pour qu'une
     tentative de connexion se termine, avant de démarrer la prochaine
     tentative en parallèle. Il s'agit du « délai de tentative de
     connexion » tel que défini dans la **RFC 8305**. Une valeur par
     défaut raisonnable recommandée par la RFC est "0.25" (250
     millisecondes).

   * *interleave* contrôle la réorganisation des adresses lorsqu'un
     nom d'hôte se résout en plusieurs adresses IP. S'il vaut "0" ou
     n'est pas spécifié, aucune réorganisation n'est effectuée et les
     adresses sont essayées dans l'ordre renvoyé par "getaddrinfo()".
     Si un entier positif est spécifié, les adresses sont entrelacées
     par famille d'adresses et l'entier donné est interprété comme
     "First Address Family Count" tel que défini dans la **RFC 8305**.
     La valeur par défaut est "0" si *happy_eyeballs_delay* n'est pas
     spécifié, et "1" si c'est le cas.

   * *sock*, s'il est fourni, doit être un objet "socket.socket"
     existant et déjà connecté à utiliser par le transport. Si *sock*
     est donné, aucun des *host*, *port*, *family*, *proto*, *flags*,
     *happy_eyeballs_delay*, *interleave* et *local_addr* ne doit être
     spécifié.

     Note:

       l'argument *sock* transfère la propriété du connecteur au
       transport créé. Pour fermer le connecteur, appelez la méthode
       "close()" du transport.

   * *local_addr*, s'il est fourni, est un *n*-uplet "(local_host,
     local_port)" utilisé pour lier le connecteur localement.
     *local_host* et *local_port* sont recherchés en utilisant
     "getaddrinfo()", de la même manière que *host* et *port*.

   * *ssl_handshake_timeout* est (pour une connexion TLS) le temps en
     secondes à attendre que la poignée de main TLS se termine avant
     d'abandonner la connexion. "60.0" secondes si "None" (par
     défaut).

   * *ssl_shutdown_timeout* est le temps en secondes à attendre que
     l'arrêt SSL se termine avant d'abandonner la connexion. "30.0"
     secondes si "None" (par défaut).

   Modifié dans la version 3.5: ajout de la prise en charge de SSL/TLS
   dans "ProactorEventLoop".

   Modifié dans la version 3.6: The socket option socket.TCP_NODELAY
   is set by default for all TCP connections.

   Modifié dans la version 3.7: ajout du paramètre *ssl handshake
   timeout*

   Modifié dans la version 3.8: ajout des paramètres
   *happy_eyeballs_delay* et *interleave*.Algorithme Happy Eyeballs :
   « succès avec les hôtes à double pile ». Lorsque le chemin et le
   protocole IPv4 d'un serveur fonctionnent, mais que le chemin et le
   protocole IPv6 du serveur ne fonctionnent pas, une application
   cliente à double pile subit un retard de connexion important par
   rapport à un client IPv4 uniquement. Ceci n'est pas souhaitable car
   cela entraîne une moins bonne expérience utilisateur pour le client
   à double pile. Ce document spécifie les exigences pour les
   algorithmes qui réduisent ce délai visible par l'utilisateur et
   fournit un algorithme correspondant.For more information:
   https://datatracker.ietf.org/doc/html/rfc6555

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*

   Voir aussi:

     la fonction "open_connection()" est une API alternative de haut
     niveau. Elle renvoie une paire de ("StreamReader",
     "StreamWriter") qui peut être utilisée directement dans le code
     *async/wait*.

coroutine loop.create_datagram_endpoint(protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_port=None, allow_broadcast=None, sock=None)

   Création d'une connexion par datagramme

   The socket family can be either "AF_INET", "AF_INET6", or
   "AF_UNIX", depending on *host* (or the *family* argument, if
   provided).

   The socket type will be "SOCK_DGRAM".

   *protocol_factory* doit être un appelable gérant le protocole
   asyncio.

   Un *n*-uplet "(transport, protocol)" est renvoyé en cas de succès.

   Autres arguments :

   * *local_addr*, s'il est fourni, est un *n*-uplet "(local_host,
     local_port)" utilisé pour lier le connecteur localement. Le
     *local_host* et le *local_port* sont recherchés en utilisant
     "getaddrinfo()".

   * *remote_addr*, s'il est fourni, est un *n*-uplet "(remote_host,
     remote_port)" utilisé pour se connecter à une adresse distante.
     Le *remote_host* et le *remote_port* sont recherchés en utilisant
     "getaddrinfo()".

   * *family*, *proto*, *flags* sont facultatifs et représentent la
     famille d'adresse, le protocole et les drapeaux à transmettre à
     "getaddrinfo()" pour la résolution *host*. S'ils sont fournis,
     ils doivent tous être des entiers provenant des constantes du
     module "socket".

   * *reuse_port* tells the kernel to allow this endpoint to be bound
     to the same port as other existing endpoints are bound to, so
     long as they all set this flag when being created. This option is
     not supported on Windows and some Unixes. If the
     socket.SO_REUSEPORT constant is not defined then this capability
     is unsupported.

   * *allow_broadcast* indique au noyau d'autoriser ce point de
     terminaison à envoyer des messages à l'adresse de *broadcast*.

   * *sock* peut éventuellement être spécifié afin d'utiliser un objet
     "socket.socket" préexistant, déjà connecté, à utiliser par le
     transport. Si spécifié, *local_addr* et *remote_addr* doivent
     être omis (doit être "None").

     Note:

       l'argument *sock* transfère la propriété du connecteur au
       transport créé. Pour fermer le connecteur, appelez la méthode
       "close()" du transport.

   Voir les exemples Client écho en UDP et Serveur écho en UDP.

   Modifié dans la version 3.4.4: les paramètres *family*, *proto*,
   *flags*, *reuse_address*, *reuse_port*, *allow_broadcast* et *sock*
   ont été ajoutés.

   Modifié dans la version 3.8: prise en charge sur Windows.

   Modifié dans la version 3.8.1: The *reuse_address* parameter is no
   longer supported, as using socket.SO_REUSEADDR poses a significant
   security concern for UDP. Explicitly passing "reuse_address=True"
   will raise an exception.Lorsque plusieurs processus avec des UID
   différents attribuent des connecteurs à une adresse de connecteur
   UDP identique avec "SO_REUSEADDR", les paquets entrants peuvent
   être distribués de manière aléatoire entre les connecteurs.For
   supported platforms, *reuse_port* can be used as a replacement for
   similar functionality. With *reuse_port*, socket.SO_REUSEPORT is
   used instead, which specifically prevents processes with differing
   UIDs from assigning sockets to the same socket address.

   Modifié dans la version 3.11: The *reuse_address* parameter,
   disabled since Python 3.8.1, 3.7.6 and 3.6.10, has been entirely
   removed.

coroutine loop.create_unix_connection(protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)

   Crée une connexion Unix

   The socket family will be "AF_UNIX"; socket type will be
   "SOCK_STREAM".

   Un *n*-uplet "(transport, protocol)" est renvoyé en cas de succès.

   *path* est le nom d'un connecteur de domaine Unix et est
   obligatoire, sauf si un paramètre *sock* est spécifié. Les
   connecteurs Unix abstraits, les chemins "str", "bytes" et "Path"
   sont pris en charge.

   Voir la documentation de la méthode "loop.create_connection()" pour
   plus d'informations sur les arguments de cette méthode.

   Disponibilité : Unix.

   Modifié dans la version 3.7: ajout du paramètre
   *ssl_handshake_timeout*. Le paramètre *chemin* peut désormais être
   un *objet simili-chemin*.

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*


Création de serveurs
--------------------

coroutine loop.create_server(protocol_factory, host=None, port=None, *, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)

   Create a TCP server (socket type "SOCK_STREAM") listening on *port*
   of the *host* address.

   Renvoie un objet "Server".

   Arguments :

   * *protocol_factory* doit être un appelable gérant le protocole
     asyncio.

   * Le paramètre *host* peut être défini sur plusieurs types qui
     déterminent où le serveur écoute :

     * Si *host* est une chaîne, le serveur TCP est lié à une seule
       interface réseau spécifiée par *host*.

     * Si *host* est une séquence de chaînes, le serveur TCP est lié à
       toutes les interfaces réseau spécifiées par la séquence.

     * Si *host* est une chaîne vide ou "None", toutes les interfaces
       sont prises en compte et une liste de plusieurs connecteurs est
       renvoyée (probablement une pour IPv4 et une autre pour IPv6).

   * Le paramètre *port* peut être défini pour spécifier sur quel port
     le serveur doit écouter. Si "0" ou "None" (la valeur par défaut),
     un port inutilisé aléatoire est sélectionné (notez que si *host*
     se résout en plusieurs interfaces réseau, un port aléatoire
     différent est sélectionné pour chaque interface).

   * *family* can be set to either "socket.AF_INET" or "AF_INET6" to
     force the socket to use IPv4 or IPv6. If not set, the *family*
     will be determined from host name (defaults to "AF_UNSPEC").

   * *flags* est un masque de bits pour "getaddrinfo()".

   * *sock* peut éventuellement être spécifié afin d'utiliser un objet
     connecteur préexistant. S'il est spécifié, *host* et *port* ne
     doivent pas être spécifiés.

     Note:

       l'argument *sock* transfère la propriété du connecteur au
       serveur créé. Pour fermer le connecteur, appelez la méthode
       "close()" du serveur.

   * *backlog* est le nombre maximum de connexions en file d'attente
     passées à "listen()" (par défaut à 100).

   * *ssl* peut être défini sur une instance "SSLContext" pour activer
     TLS sur les connexions acceptées.

   * *reuse_address* indique au noyau de réutiliser un connecteur
     local dans l'état "TIME_WAIT", sans attendre l'expiration de son
     délai d'attente naturel. S'il n'est pas spécifié, il est
     automatiquement défini sur "True" sous Unix.

   * *reuse_port* indique au noyau d'autoriser ce point de terminaison
     à être lié au même port que les autres points de terminaison
     existants, tant qu'ils définissent tous cet indicateur lors de
     leur création. Cette option n'est pas prise en charge sous
     Windows.

   * *ssl_handshake_timeout* est (pour un serveur TLS) le temps en
     secondes à attendre que la poignée de main TLS se termine avant
     d'abandonner la connexion. "60.0" secondes si "None" (par
     défaut).

   * *ssl_shutdown_timeout* est le temps en secondes à attendre que
     l'arrêt SSL se termine avant d'abandonner la connexion. "30.0"
     secondes si "None" (par défaut).

   * *start_serving* défini à "True" (valeur par défaut) fait que le
     serveur créé commence immédiatement à accepter les connexions.
     Lorsqu'il est défini sur "False", l'utilisateur doit attendre sur
     "Server.start_serving()" ou "Server.serve_forever()" pour que le
     serveur commence à accepter les connexions.

   Modifié dans la version 3.5: ajout de la prise en charge de SSL/TLS
   dans "ProactorEventLoop".

   Modifié dans la version 3.5.1: le paramètre *host* peut être une
   séquence de chaînes.

   Modifié dans la version 3.6: Added *ssl_handshake_timeout* and
   *start_serving* parameters. The socket option socket.TCP_NODELAY is
   set by default for all TCP connections.

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*

   Voir aussi:

     la fonction "start_server()" est une API alternative de niveau
     supérieur qui renvoie une paire de "StreamReader" et
     "StreamWriter" qui peut être utilisée dans un code *async/wait*.

coroutine loop.create_unix_server(protocol_factory, path=None, *, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None, start_serving=True)

   Similar to "loop.create_server()" but works with the "AF_UNIX"
   socket family.

   *path* est le nom d'un connecteur de domaine Unix et est
   obligatoire, sauf si un argument *sock* est fourni. Les connecteurs
   Unix abstraits, les chemins "str", "bytes" et "Path" sont pris en
   charge.

   Voir la documentation de la méthode "loop.create_server()" pour
   plus d'informations sur les arguments de cette méthode.

   Disponibilité : Unix.

   Modifié dans la version 3.7: ajout des paramètres
   *ssl_handshake_timeout* et *start_serving*. Le paramètre *path*
   peut maintenant être un objet "Path".

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*

coroutine loop.connect_accepted_socket(protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)

   Enveloppe une connexion déjà acceptée dans une paire
   transport/protocole.

   Cette méthode peut être utilisée par les serveurs qui acceptent les
   connexions en dehors d'*asyncio* mais qui utilisent *asyncio* pour
   les gérer.

   Paramètres :

   * *protocol_factory* doit être un appelable gérant le protocole
     asyncio.

   * *sock* est un objet connecteur préexistant renvoyé par
     "socket.accept".

     Note:

       l'argument *sock* transfère la propriété du connecteur au
       transport créé. Pour fermer le connecteur, appelez la méthode
       "close()" du transport.

   * *ssl* peut être défini sur une "SSLContext" pour activer SSL sur
     les connexions acceptées.

   * *ssl_handshake_timeout* est (pour une connexion SSL) le temps en
     secondes à attendre que la poignée de main SSL se termine avant
     d'abandonner la connexion. "60.0" secondes si "None" (par
     défaut).

   * *ssl_shutdown_timeout* est le temps en secondes à attendre que
     l'arrêt SSL se termine avant d'abandonner la connexion. "30.0"
     secondes si "None" (par défaut).

   Renvoie une paire "(transport, protocole)".

   Nouveau dans la version 3.5.3.

   Modifié dans la version 3.7: ajout du paramètre *ssl handshake
   timeout*

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*


Transfert de fichiers
---------------------

coroutine loop.sendfile(transport, file, offset=0, count=None, *, fallback=True)

   Envoie *file* via *transport*. Renvoie le nombre total d'octets
   envoyés.

   La méthode utilise "os.sendfile()" (hautes performances) si elle
   est disponible.

   *file* doit être un objet fichier normal ouvert en mode binaire.

   *offset* indique où commencer la lecture du fichier. Si spécifié,
   *count* est le nombre total d'octets à transmettre, par opposition
   à l'envoi du fichier jusqu'à ce que EOF soit atteint. La position
   du fichier est toujours mise à jour, même lorsque cette méthode
   génère une erreur. "file.tell()" peut être utilisée pour obtenir le
   nombre d'octets réellement envoyés.

   *fallback* défini sur "True" permet à *asyncio* de lire et
   d'envoyer manuellement le fichier lorsque la plateforme ne prend
   pas en charge l'appel système *sendfile* (par exemple, Windows ou
   connecteur SSL sous Unix).

   Lève "SendfileNotAvailableError" si le système ne prend pas en
   charge l'appel système *sendfile* et que *fallback* est "False".

   Nouveau dans la version 3.7.


Passage du flux en TLS
----------------------

coroutine loop.start_tls(transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None, ssl_shutdown_timeout=None)

   Convertit une connexion existante en connexion TLS.

   Crée une instance de codeur-décodeur TLS et l'insère entre le
   *transport* et le *protocol*. Le codeur-décodeur implémente à la
   fois le protocole vers le *transport* et le transport vers le
   *protocol*.

   Renvoie l'instance à deux interfaces créée. Après *await*, le
   *protocol* doit cesser d'utiliser le *transport* d'origine et
   communiquer avec l'objet renvoyé uniquement parce que le codeur met
   en cache les données côté *protocol* et échange sporadiquement des
   paquets de session TLS supplémentaires avec *transport*.

   In some situations (e.g. when the passed transport is already
   closing) this may return "None".

   Paramètres :

   * *transport* et *protocol* que des méthodes comme
     "create_server()" et "create_connection()" renvoient.

   * *sslcontext* : une instance configurée de "SSLContext".

   * *server_side* passe à "True" lorsqu'une connexion côté serveur
     est mise à jour (comme celle créée par "create_server()").

   * *server_hostname* : définit ou remplace le nom d'hôte auquel le
     certificat du serveur cible est comparé.

   * *ssl_handshake_timeout* est (pour une connexion TLS) le temps en
     secondes à attendre que la poignée de main TLS se termine avant
     d'abandonner la connexion. "60.0" secondes si "None" (par
     défaut).

   * *ssl_shutdown_timeout* est le temps en secondes à attendre que
     l'arrêt SSL se termine avant d'abandonner la connexion. "30.0"
     secondes si "None" (par défaut).

   Nouveau dans la version 3.7.

   Modifié dans la version 3.11: ajout du paramètre *ssl shutdown
   timeout*


Surveillance de descripteur de fichier
--------------------------------------

loop.add_reader(fd, callback, *args)

   Commence à surveiller la disponibilité en lecture du descripteur de
   fichier *fd* et appelle *callback* avec les arguments spécifiés une
   fois que *fd* est disponible en lecture.

loop.remove_reader(fd)

   Arrête de surveiller le descripteur de fichier *fd* pour la
   disponibilité en lecture. Renvoie "True" si *fd* était précédemment
   surveillé pour les lectures.

loop.add_writer(fd, callback, *args)

   Commence à surveiller le descripteur de fichier *fd* pour la
   disponibilité en écriture et appelle *callback* avec les arguments
   spécifiés une fois que *fd* est disponible en écriture.

   Utilisez "functools.partial()" pour passer des arguments nommés à
   *callback*.

loop.remove_writer(fd)

   Arrête de surveiller le descripteur de fichier *fd* pour la
   disponibilité en écriture. Renvoie "True" si *fd* était
   précédemment surveillé pour les écritures.

Voir aussi la section Prise en charge de la plate-forme pour certaines
limitations de ces méthodes.


Travail direct avec des objets *socket*
---------------------------------------

En général, les implémentations de protocole qui utilisent des API
basées sur le transport telles que "loop.create_connection()" et
"loop.create_server()" sont plus rapides que les implémentations qui
fonctionnent directement avec les *sockets*. Cependant, il existe des
cas d'utilisation où les performances ne sont pas critiques, et
travailler directement avec les objets "socket" est plus pratique.

coroutine loop.sock_recv(sock, nbytes)

   Reçoit jusqu'à *nbytes* de *sock*. Version asynchrone de
   "socket.recv()".

   Renvoie les données reçues sous la forme d'un objet bytes.

   Le connecteur *sock* ne doit pas être bloquant.

   Modifié dans la version 3.7: même si cette méthode a toujours été
   documentée en tant que méthode coroutine, les versions antérieures
   à Python 3.7 renvoyaient un "Future". Depuis Python 3.7, il s'agit
   d'une méthode "async def".

coroutine loop.sock_recv_into(sock, buf)

   Reçoit les données de *sock* dans le tampon *buf*. Basée sur le
   modèle de la méthode bloquante "socket.recv_into()".

   Renvoie le nombre d'octets écrits dans le tampon.

   Le connecteur *sock* ne doit pas être bloquant.

   Nouveau dans la version 3.7.

coroutine loop.sock_recvfrom(sock, bufsize)

   Reçoit un datagramme jusqu'à *bufsize* de *sock*. Version
   asynchrone de "socket.recvfrom()".

   Renvoie un *n*-uplet (données reçues, adresse distante).

   Le connecteur *sock* ne doit pas être bloquant.

   Nouveau dans la version 3.11.

coroutine loop.sock_recvfrom_into(sock, buf, nbytes=0)

   Reçoit un datagramme jusqu'à *nbytes* de *sock* vers *buf*. Version
   asynchrone de "socket.recvfrom_into()".

   Renvoie un *n*-uplet (nombre d'octets reçus, adresse distante).

   Le connecteur *sock* ne doit pas être bloquant.

   Nouveau dans la version 3.11.

coroutine loop.sock_sendall(sock, data)

   Envoie les données *data* au connecteur *sock*. Version asynchrone
   de "socket.sendall()".

   Cette méthode continue d'envoyer des données au connecteur jusqu'à
   ce que toutes les *data* aient été envoyées ou qu'une erreur se
   produise. "None" est renvoyé en cas de succès. En cas d'erreur, une
   exception est levée. De plus, il n'existe aucun moyen de déterminer
   la quantité de données, le cas échéant, qui a été traitée avec
   succès par l'extrémité réceptrice de la connexion.

   Le connecteur *sock* ne doit pas être bloquant.

   Modifié dans la version 3.7: même si la méthode a toujours été
   documentée en tant que méthode coroutine, avant Python 3.7, elle
   renvoyait un "Future". Depuis Python 3.7, il s'agit d'une méthode
   "async def".

coroutine loop.sock_sendto(sock, data, address)

   Envoie un datagramme de *sock* à *address*. Version asynchrone de
   "socket.sendto()".

   Renvoie le nombre d'octets envoyés.

   Le connecteur *sock* ne doit pas être bloquant.

   Nouveau dans la version 3.11.

coroutine loop.sock_connect(sock, address)

   Connecte *sock* à un connecteur distant situé à *address*.

   Version asynchrone de "socket.connect()".

   Le connecteur *sock* ne doit pas être bloquant.

   Modifié dans la version 3.5.2: "address" n'a plus besoin d'être
   résolu. "sock_connect" essaie de vérifier si *address* est déjà
   résolue en appelant "socket.inet_pton()". Sinon,
   "loop.getaddrinfo()" est utilisé pour résoudre *address*.

   Voir aussi:

     "loop.create_connection()" et "asyncio.open_connection()".

coroutine loop.sock_accept(sock)

   Accepte une connexion. Basée sur le modèle de la méthode bloquante
   "socket.accept()".

   Le connecteur doit être lié à une adresse et écouter les
   connexions. La valeur de retour est une paire "(conn, adresse)" où
   *conn* est un *nouvel* objet socket utilisable pour envoyer et
   recevoir des données sur la connexion, et *adresse* est l'adresse
   liée au connecteur de l'autre côté de la connexion.

   Le connecteur *sock* ne doit pas être bloquant.

   Modifié dans la version 3.7: même si la méthode a toujours été
   documentée en tant que méthode coroutine, avant Python 3.7, elle
   renvoyait un "Future". Depuis Python 3.7, il s'agit d'une méthode
   "async def".

   Voir aussi: "loop.create_server()" et "start_server()".

coroutine loop.sock_sendfile(sock, file, offset=0, count=None, *, fallback=True)

   Envoie le fichier en utilisant "os.sendfile" (haute performance) si
   possible. Renvoie le nombre total d'octets envoyés.

   Version asynchrone de "socket.sendfile()".

   *sock* doit être un "socket.SOCK_STREAM" "socket" non bloquant.

   *file* doit être un objet fichier normal ouvert en mode binaire.

   *offset* indique où commencer la lecture du fichier. Si spécifié,
   *count* est le nombre total d'octets à transmettre, par opposition
   à l'envoi du fichier jusqu'à ce que EOF soit atteint. La position
   du fichier est toujours mise à jour, même lorsque cette méthode
   génère une erreur. "file.tell()" peut être utilisée pour obtenir le
   nombre d'octets réellement envoyés.

   *fallback*, lorsqu'il est défini à "True", permet à *asyncio* de
   lire et d'envoyer manuellement le fichier lorsque la plateforme ne
   prend pas en charge l'appel système *sendfile* (par exemple,
   Windows ou connecteur SSL sous Unix).

   Lève une "SendfileNotAvailableError" si le système ne prend pas en
   charge l'appel système *sendfile* et que *fallback* est "False".

   Le connecteur *sock* ne doit pas être bloquant.

   Nouveau dans la version 3.7.


DNS
---

coroutine loop.getaddrinfo(host, port, *, family=0, type=0, proto=0, flags=0)

   Version asynchrone de "socket.getaddrinfo()".

coroutine loop.getnameinfo(sockaddr, flags=0)

   Version asynchrone de "socket.getnameinfo()".

Modifié dans la version 3.7: les méthodes *getaddrinfo* et
*getnameinfo* ont toujours été documentées pour renvoyer une
coroutine, mais avant Python 3.7, elles renvoyaient en fait des objets
"asyncio.Future". À partir de Python 3.7, les deux méthodes sont des
coroutines.


Travail avec des tubes (*pipes*)
--------------------------------

coroutine loop.connect_read_pipe(protocol_factory, pipe)

   Branche l'extrémité en lecture du tube *pipe* à la boucle
   d'évènements.

   *protocol_factory* doit être un appelable renvoyant un protocole
   gérant le protocole asyncio.

   *pipe* est un *simili-fichier*.

   Renvoie la paire "(transport, protocol)", où *transport* prend en
   charge l'interface "ReadTransport" et *protocol* est un objet
   instancié par *protocol_factory*.

   Avec la boucle d'événements "SelectorEventLoop", le *pipe* est mis
   en mode non bloquant.

coroutine loop.connect_write_pipe(protocol_factory, pipe)

   Branche l'extrémité en écriture de *pipe* à la boucle d'évènements.

   *protocol_factory* doit être un appelable renvoyant un protocole
   gérant le protocole asyncio.

   *pipe* est un *simili-fichier*.

   Renvoie la paire "(transport, protocol)", où *transport* prend en
   charge l'interface "WriteTransport" et *protocol* est un objet
   instancié par *protocol_factory*.

   Avec la boucle d'événements "SelectorEventLoop", le *pipe* est mis
   en mode non bloquant.

Note:

  "SelectorEventLoop" ne prend pas en charge les méthodes ci-dessus
  sous Windows. Utilisez "ProactorEventLoop" à la place pour Windows.

Voir aussi:

  les méthodes "loop.subprocess_exec()" et "loop.subprocess_shell()".


Signaux Unix
------------

loop.add_signal_handler(signum, callback, *args)

   Définit *callback* comme gestionnaire du signal *signum*.

   La fonction de rappel sera appelée par *loop*, avec d'autres
   rappels en file d'attente et des coroutines exécutables de cette
   boucle d'événements. Contrairement aux gestionnaires de signaux
   enregistrés à l'aide de "signal.signal()", un rappel enregistré
   avec cette fonction est autorisé à interagir avec la boucle
   d'événements.

   Lève une "ValueError" si le numéro de signal est invalide ou non
   attrapable. Lève une "RuntimeError" s'il y a un problème lors de la
   configuration du gestionnaire.

   Utilisez "functools.partial()" pour passer des arguments nommés à
   *callback*.

   Comme "signal.signal()", cette fonction doit être invoquée dans le
   fil d'exécution principal.

loop.remove_signal_handler(sig)

   Supprime le gestionnaire du signal *sig*.

   Renvoie "True" si le gestionnaire de signal a été supprimé, ou
   "False" si aucun gestionnaire n'a été défini pour le signal donné.

   Disponibilité : Unix.

Voir aussi: le module "signal".


Exécution de code dans des pools de threads ou de processus
-----------------------------------------------------------

awaitable loop.run_in_executor(executor, func, *args)

   Fait en sorte que *func* soit appelée dans l'exécuteur spécifié.

   L'argument *executor* doit être une instance
   "concurrent.futures.Executor". L'exécuteur par défaut est utilisé
   si *executor* vaut "None".

   Exemple :

      import asyncio
      import concurrent.futures

      def blocking_io():
          # File operations (such as logging) can block the
          # event loop: run them in a thread pool.
          with open('/dev/urandom', 'rb') as f:
              return f.read(100)

      def cpu_bound():
          # CPU-bound operations will block the event loop:
          # in general it is preferable to run them in a
          # process pool.
          return sum(i * i for i in range(10 ** 7))

      async def main():
          loop = asyncio.get_running_loop()

          ## Options:

          # 1. Run in the default loop's executor:
          result = await loop.run_in_executor(
              None, blocking_io)
          print('default thread pool', result)

          # 2. Run in a custom thread pool:
          with concurrent.futures.ThreadPoolExecutor() as pool:
              result = await loop.run_in_executor(
                  pool, blocking_io)
              print('custom thread pool', result)

          # 3. Run in a custom process pool:
          with concurrent.futures.ProcessPoolExecutor() as pool:
              result = await loop.run_in_executor(
                  pool, cpu_bound)
              print('custom process pool', result)

      if __name__ == '__main__':
          asyncio.run(main())

   Notez que la garde du point d'entrée ("if __name__ == '__main__'")
   est requis pour l'option 3 en raison des particularités de
   "multiprocessing", qui est utilisé par "ProcessPoolExecutor". Voir
   Importation sécurisée du module principal.

   Cette méthode renvoie un objet "asyncio.Future".

   Utilisez "functools.partial()" pour passer des arguments nommés à
   *func*.

   Modifié dans la version 3.5.3: "loop.run_in_executor()" ne
   configure plus le "max_workers" de l'exécuteur de pool de threads
   qu'il crée, laissant à la place à l'exécuteur de pool de threads
   ("ThreadPoolExecutor") le soin de définir le défaut.

loop.set_default_executor(executor)

   Définit *executor* comme exécuteur par défaut utilisé par
   "run_in_executor()". *executor* doit être une instance de
   "ThreadPoolExecutor".

   Modifié dans la version 3.11: *executor* doit être une instance de
   "ThreadPoolExecutor".


API de gestion d'erreur
-----------------------

Permet de personnaliser la façon dont les exceptions sont gérées dans
la boucle d'événements.

loop.set_exception_handler(handler)

   Définit *handler* comme nouveau gestionnaire d'exceptions de boucle
   d'événements.

   Si *handler* est "None", le gestionnaire d'exceptions par défaut
   est activé. Sinon, *handler* doit être un appelable avec la
   signature correspondant à "(loop, context)", où "loop" est une
   référence à la boucle d'événements active et "context" est un
   "dict" contenant les détails de l'exception (voir la documentation
   "call_exception_handler()" pour plus de détails sur le contexte).

loop.get_exception_handler()

   Renvoie le gestionnaire d'exceptions actuel ou "None" si aucun
   gestionnaire d'exceptions personnalisé n'a été défini.

   Nouveau dans la version 3.5.2.

loop.default_exception_handler(context)

   Gestionnaire d'exception par défaut.

   Appelée lorsqu'une exception se produit et qu'aucun gestionnaire
   d'exception n'est défini. Elle peut être appelée par un
   gestionnaire d'exceptions personnalisé qui souhaite s'en remettre
   au comportement du gestionnaire par défaut.

   Le paramètre *context* a la même signification que dans
   "call_exception_handler()".

loop.call_exception_handler(context)

   Appelle le gestionnaire d'exception de la boucle d'évènements
   actuelle.

   *context* est un objet "dict" contenant les clés suivantes (de
   nouvelles clés pourront être introduites dans les futures versions
   de Python) :

   * 'message' : message d'erreur ;

   * 'exception' (facultatif) : objet exception ;

   * 'future' (facultatif) : instance de "asyncio.Future" ;

   * 'task' (facultatif) : instance de "asyncio.Task" ;

   * *'handle'* (facultatif) : instance de "asyncio.Handle" ;

   * *'protocol'* (facultatif) : instance de protocole asyncio ;

   * 'transport' (facultatif) : instance de transport asyncio ;

   * 'socket' (facultatif) : instance de "socket.socket" ;

   * *'asyncgen'* (facultatif) : générateur asynchrone qui a causé
        l'exception

   Note:

     cette méthode ne doit pas être surchargée dans les boucles
     d'événements sous-classées. Pour la gestion personnalisée des
     exceptions, utilisez la méthode "set_exception_handler()".


Activation du mode débogage
---------------------------

loop.get_debug()

   Obtient le mode de débogage ("bool") de la boucle d'événements.

   La valeur par défaut est "True" si la variable d'environnement
   "PYTHONASYNCIODEBUG" est définie sur une chaîne non vide, "False"
   sinon.

loop.set_debug(enabled: bool)

   Active le mode débogage pour la boucle d'évènements.

   Modifié dans la version 3.7: le nouveau mode de développement
   Python peut désormais également être utilisé pour activer le mode
   de débogage.

loop.slow_callback_duration

   This attribute can be used to set the minimum execution duration in
   seconds that is considered "slow". When debug mode is enabled,
   "slow" callbacks are logged.

   Default value is 100 milliseconds.

Voir aussi: le mode debogage d'asyncio.


Exécution de sous-processus
---------------------------

Les méthodes décrites dans ces sous-sections sont de bas niveau. Dans
le code *async/await* normal, pensez à utiliser les fonctions de
commodité de haut niveau "asyncio.create_subprocess_shell()" et
"asyncio.create_subprocess_exec()" à la place.

Note:

  sous Windows, la boucle d'événements par défaut "ProactorEventLoop"
  prend en charge les sous-processus, contrairement à
  "SelectorEventLoop". Voir Prise en charge des sous-processus sous
  Windows pour plus de détails.

coroutine loop.subprocess_exec(protocol_factory, *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

   Crée un sous-processus à partir d'un ou plusieurs arguments de
   chaîne spécifiés par *args*.

   *args* doit être une liste de chaînes représentée par :

   * "str" ;

   * ou "bytes", encodés selon l'encodage du système de fichiers.

   La première chaîne spécifie l'exécutable du programme et les
   chaînes restantes spécifient les arguments. Ensemble, les arguments
   de chaîne forment le "argv" du programme.

   C'est similaire à la classe standard de la bibliothèque
   "subprocess.Popen" appelée avec "shell=False" et la liste des
   chaînes passées en premier argument ; cependant, où "Popen" prend
   un seul argument qui est une liste de chaînes, *subprocess_exec*
   prend plusieurs arguments de chaînes.

   Le *protocol_factory* doit être un appelable renvoyant une sous-
   classe de la classe "asyncio.SubprocessProtocol".

   Autres paramètres :

   * *stdin* peut être l'un de ces éléments :

     * un objet de type fichier représentant un tube à connecter au
       flux d'entrée standard du sous-processus en utilisant
       "connect_write_pipe()",

     * la constante "subprocess.PIPE" (par défaut) qui va créer un
       nouveau tube et le connecter,

     * la valeur "None" qui fera que le sous-processus héritera du
       descripteur de fichier de ce processus,

     * la constante "subprocess.DEVNULL" qui indique que le fichier
       spécial "os.devnull" sera utilisé.

   * *stdout* peut être l'un de ces éléments :

     * un objet de type fichier représentant un tube à connecter au
       flux de sortie standard du sous-processus en utilisant
       "connect_write_pipe()",

     * la constante "subprocess.PIPE" (par défaut) qui va créer un
       nouveau tube et le connecter,

     * la valeur "None" qui fera que le sous-processus héritera du
       descripteur de fichier de ce processus,

     * la constante "subprocess.DEVNULL" qui indique que le fichier
       spécial "os.devnull" sera utilisé.

   * *stderr* peut être l'un de ces éléments :

     * un objet de type fichier représentant un tube à connecter au
       flux d'erreurs standard du sous-processus en utilisant
       "connect_write_pipe()",

     * la constante "subprocess.PIPE" (par défaut) qui va créer un
       nouveau tube et le connecter,

     * la valeur "None" qui fera que le sous-processus héritera du
       descripteur de fichier de ce processus,

     * la constante "subprocess.DEVNULL" qui indique que le fichier
       spécial "os.devnull" sera utilisé.

     * la constante "subprocess.STDOUT" qui connectera le flux
       d'erreur standard au flux de sortie standard du processus.

   * Tous les autres arguments nommés sont passés à "subprocess.Popen"
     sans interprétation, à l'exception de *bufsize*,
     *universal_newlines*, *shell*, *text*, *encoding* et *errors*,
     qui ne doivent pas être spécifiés du tout.

     L'API de sous-processus "asyncio" ne prend pas en charge le
     décodage des flux sous forme de texte. "bytes.decode()" peut être
     utilisée pour convertir les octets renvoyés par le flux en texte.

   Voir le constructeur de la classe "subprocess.Popen" pour la
   documentation sur les autres arguments.

   Renvoie une paire "(transport, protocol)", où *transport* est
   conforme à la classe de base "asyncio.SubprocessTransport" et
   *protocol* est un objet instancié par *protocol_factory*.

coroutine loop.subprocess_shell(protocol_factory, cmd, *, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

   Crée un sous-processus à partir de *cmd*, qui peut être une chaîne
   "str" ou une chaîne "bytes" encodée avec l'encodage du système de
   fichiers, en utilisant la syntaxe "shell" de la plate-forme.

   C'est similaire à la classe standard de la bibliothèque
   "subprocess.Popen" appelée avec "shell=True".

   Le *protocol_factory* doit être un appelable renvoyant une sous-
   classe de la classe "SubprocessProtocol".

   Voir "subprocess_exec()" pour plus de détails sur les arguments
   restants.

   Renvoie une paire "(transport, protocol)", où *transport* est
   conforme à la classe de base "SubprocessTransport" et *protocol*
   est un objet instancié par *protocol_factory*.

Note:

  il est de la responsabilité de l'application de s'assurer que tous
  les espaces blancs et les caractères spéciaux sont correctement
  échappés pour éviter les vulnérabilités d'injection de shell. La
  fonction "shlex.quote()" peut être utilisée pour échapper
  correctement les espaces blancs et les caractères spéciaux dans les
  chaînes qui seront utilisées pour construire des commandes shell.


Fonctions de rappel sur des descripteurs
========================================

class asyncio.Handle

   Objet encapsulant une fonction de rappel renvoyé par
   "loop.call_soon()", "loop.call_soon_threadsafe()".

   cancel()

      Annule le rappel. Si le rappel a déjà été annulé ou exécuté,
      cette méthode n'a aucun effet.

   cancelled()

      Renvoie "True" si la fonction de rappel a été annulée.

      Nouveau dans la version 3.7.

class asyncio.TimerHandle

   Objet encapsulant la fonction de rappel renvoyé par
   "loop.call_later()" et "loop.call_at()".

   Cette classe est une sous-classe de "Handle".

   when()

      Renvoie une heure de rappel planifiée sous forme de "float"
      secondes.

      L'heure est un horodatage absolu, utilisant la même référence de
      temps que "loop.time()".

      Nouveau dans la version 3.7.


Objets Serveur
==============

Les objets serveur sont créés par les fonctions
"loop.create_server()", "loop.create_unix_server()", "start_server()"
et "start_unix_server()".

Do not instantiate the "Server" class directly.

class asyncio.Server

   Les objets *Server* sont des gestionnaires de contexte asynchrones.
   Lorsqu'il est utilisé dans une instruction "async with", il est
   garanti que l'objet Serveur est fermé et n'accepte pas de nouvelle
   connexion lorsque l'instruction "async with" est terminée :

      srv = await loop.create_server(...)

      async with srv:
          # some code

      # At this point, srv is closed and no longer accepts new connections.

   Modifié dans la version 3.7: l'objet serveur est un gestionnaire de
   contexte asynchrone depuis Python 3.7.

   Modifié dans la version 3.11: This class was exposed publicly as
   "asyncio.Server" in Python 3.9.11, 3.10.3 and 3.11.

   close()

      Arrête le serveur : ferme les connecteurs d'écoute et définit
      l'attribut "sockets" à "None".

      Les connecteurs qui représentent les connexions client entrantes
      existantes restent ouvertes.

      Le serveur est fermé de manière asynchrone, utilisez la
      coroutine "wait_closed()" pour attendre que le serveur soit
      fermé.

   get_loop()

      Renvoie la boucle d'événement associée à l'objet serveur.

      Nouveau dans la version 3.7.

   coroutine start_serving()

      Commence à accepter les connexions.

      Cette méthode est idempotente, elle peut donc être appelée
      lorsque le serveur est déjà en service.

      Le paramètre nommé *start_serving* de "loop.create_server()" et
      "asyncio.start_server()" permet de créer un objet *Server* qui
      n'accepte pas les connexions initialement. Dans ce cas,
      "Server.start_serving()" ou "Server.serve_forever()" peut être
      utilisée pour que le serveur commence à accepter les connexions.

      Nouveau dans la version 3.7.

   coroutine serve_forever()

      Commence à accepter les connexions jusqu'à ce que la coroutine
      soit annulée. L'annulation de la tâche "serve_forever" provoque
      la fermeture du serveur.

      Cette méthode peut être appelée si le serveur accepte déjà les
      connexions. Une seule tâche "serve_forever" peut exister par
      objet *Server*.

      Exemple :

         async def client_connected(reader, writer):
             # Communicate with the client with
             # reader/writer streams.  For example:
             await reader.readline()

         async def main(host, port):
             srv = await asyncio.start_server(
                 client_connected, host, port)
             await srv.serve_forever()

         asyncio.run(main('127.0.0.1', 0))

      Nouveau dans la version 3.7.

   is_serving()

      Renvoie "True" si le serveur accepte de nouvelles connexions.

      Nouveau dans la version 3.7.

   coroutine wait_closed()

      Attend que la méthode "close()" se termine.

   sockets

      List of socket-like objects, "asyncio.trsock.TransportSocket",
      which the server is listening on.

      Modifié dans la version 3.7: avant Python 3.7, "Server.sockets"
      renvoyait directement une liste interne de sockets de serveur.
      En 3.7, une copie de cette liste est renvoyée.


Implémentations de boucle d'évènements
======================================

*asyncio* est livré avec deux implémentations de boucles d'événements
différentes : "SelectorEventLoop" et "ProactorEventLoop".

Par défaut, *asyncio* est configuré pour utiliser "SelectorEventLoop"
sous Unix et "ProactorEventLoop" sous Windows.

class asyncio.SelectorEventLoop

   Boucle d'événements basée sur le module "selectors".

   Utilise le *sélecteur* le plus efficace disponible pour la plate-
   forme donnée. Il est également possible de configurer manuellement
   l'implémentation exacte du sélecteur à utiliser :

      import asyncio
      import selectors

      class MyPolicy(asyncio.DefaultEventLoopPolicy):
         def new_event_loop(self):
            selector = selectors.SelectSelector()
            return asyncio.SelectorEventLoop(selector)

      asyncio.set_event_loop_policy(MyPolicy())

   Disponibilité : Unix, Windows.

class asyncio.ProactorEventLoop

   Boucle d'événements pour Windows qui utilise des "I/O Completion
   Ports" (IOCP).

   Disponibilité : Windows.

   Voir aussi:

     Documentation MSDN sur les ports de saisie semi-automatique
     d’E/S.

class asyncio.AbstractEventLoop

   Classe mère abstraite pour les boucles d'événements conforme à
   *asyncio*.

   La section Méthodes de la boucle d'évènements liste toutes les
   méthodes qu'une implémentation alternative de "AbstractEventLoop"
   doit définir.


Exemples
========

Notez que tous les exemples de cette section montrent **à dessein**
comment utiliser les API de boucle d'événement de bas niveau, telles
que "loop.run_forever()" et "loop.call_soon()". Les applications
*asyncio* modernes ont rarement besoin d'être écrites de cette façon ;
pensez à utiliser les fonctions de haut niveau comme "asyncio.run()".


"Hello World" avec "call_soon()"
--------------------------------

Un exemple utilisant la méthode "loop.call_soon()" pour programmer un
rappel. Le rappel affiche ""Hello World"" puis arrête la boucle
d'événements :

   import asyncio

   def hello_world(loop):
       """A callback to print 'Hello World' and stop the event loop"""
       print('Hello World')
       loop.stop()

   loop = asyncio.new_event_loop()

   # Schedule a call to hello_world()
   loop.call_soon(hello_world, loop)

   # Blocking call interrupted by loop.stop()
   try:
       loop.run_forever()
   finally:
       loop.close()

Voir aussi:

  un exemple similaire de Hello World créé avec une coroutine et la
  fonction "run()".


Affichage de la date actuelle avec "call_later()"
-------------------------------------------------

Un exemple de rappel affichant la date actuelle toutes les secondes.
Le rappel utilise la méthode "loop.call_later()" pour se re-planifier
après 5 secondes, puis arrête la boucle d'événements :

   import asyncio
   import datetime

   def display_date(end_time, loop):
       print(datetime.datetime.now())
       if (loop.time() + 1.0) < end_time:
           loop.call_later(1, display_date, end_time, loop)
       else:
           loop.stop()

   loop = asyncio.new_event_loop()

   # Schedule the first call to display_date()
   end_time = loop.time() + 5.0
   loop.call_soon(display_date, end_time, loop)

   # Blocking call interrupted by loop.stop()
   try:
       loop.run_forever()
   finally:
       loop.close()

Voir aussi:

  un exemple similaire de date actuelle créé avec une coroutine et la
  fonction "run()".


Surveillance des événements de lecture pour un descripteur de fichier
---------------------------------------------------------------------

Attend qu'un descripteur de fichier reçoive des données en utilisant
la méthode "loop.add_reader()" puis ferme la boucle d'événements :

   import asyncio
   from socket import socketpair

   # Create a pair of connected file descriptors
   rsock, wsock = socketpair()

   loop = asyncio.new_event_loop()

   def reader():
       data = rsock.recv(100)
       print("Received:", data.decode())

       # We are done: unregister the file descriptor
       loop.remove_reader(rsock)

       # Stop the event loop
       loop.stop()

   # Register the file descriptor for read event
   loop.add_reader(rsock, reader)

   # Simulate the reception of data from the network
   loop.call_soon(wsock.send, 'abc'.encode())

   try:
       # Run the event loop
       loop.run_forever()
   finally:
       # We are done. Close sockets and the event loop.
       rsock.close()
       wsock.close()
       loop.close()

Voir aussi:

  * un exemple similaire utilisant les transports, les protocoles et
    la méthode "loop.create_connection()",

  * un autre exemple utilisant la fonction et les flux de haut niveau
    "asyncio.open_connection()".


Gestion des signaux *SIGINT* et *SIGTERM*
-----------------------------------------

(Cet exemple ne fonctionne que sur Unix.)

Register handlers for signals "SIGINT" and "SIGTERM" using the
"loop.add_signal_handler()" method:

   import asyncio
   import functools
   import os
   import signal

   def ask_exit(signame, loop):
       print("got signal %s: exit" % signame)
       loop.stop()

   async def main():
       loop = asyncio.get_running_loop()

       for signame in {'SIGINT', 'SIGTERM'}:
           loop.add_signal_handler(
               getattr(signal, signame),
               functools.partial(ask_exit, signame, loop))

       await asyncio.sleep(3600)

   print("Event loop running for 1 hour, press Ctrl+C to interrupt.")
   print(f"pid {os.getpid()}: send SIGINT or SIGTERM to exit.")

   asyncio.run(main())
