Index de l'API de bas niveau

Cette page répertorie toutes les API asynchrones de bas niveau.

Obtenir une boucle d'évènements

asyncio.get_running_loop()

La fonction préférée pour obtenir la boucle d'événements en cours d'exécution.

asyncio.get_event_loop()

Renvoie une instance de boucle d'événements (en cours d'exécution ou actuelle via la politique actuelle).

asyncio.set_event_loop()

Définit la boucle d'événements comme actuelle via la politique actuelle.

asyncio.new_event_loop()

Crée une nouvelle boucle d'événements.

Exemples

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

Voir aussi la section principale de la documentation sur les Méthodes de la boucle d'évènements.

Cycle de vie

loop.run_until_complete()

Exécute un Future/Task/awaitable jusqu'à ce qu'il soit terminé.

loop.run_forever()

Exécute la boucle d'événements pour toujours.

loop.stop()

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

loop.close()

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

loop.is_running()

Renvoie True si la boucle d'événements est en cours d'exécution.

loop.is_closed()

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

await loop.shutdown_asyncgens()

Ferme les générateurs asynchrones.

Débogage

loop.set_debug()

Active ou désactive le mode débogage.

loop.get_debug()

Renvoie le mode de débogage actuel.

Planification des rappels

loop.call_soon()

Invoque un rappel bientôt.

loop.call_soon_threadsafe()

Une variante compatible avec les programmes à fils d'exécution multiples de loop.call_soon().

loop.call_later()

Invoque un rappel après le temps imparti.

loop.call_at()

Invoque un rappel à l'heure indiquée.

Thread/Interpreter/Process Pool

await loop.run_in_executor()

Exécute une fonction utilisant beaucoup de CPU ou une autre fonction bloquante dans un exécuteur concurrent.futures.

loop.set_default_executor()

Définit l'exécuteur par défaut pour loop.run_in_executor().

Tâches et Futures

loop.create_future()

Crée un objet Future.

loop.create_task()

Planifie la coroutine en tant que Task.

loop.set_task_factory()

Définit une fabrique utilisée par loop.create_task() pour créer des Tasks.

loop.get_task_factory()

Récupère la fabrique que loop.create_task() utilise pour créer des Tasks.

DNS

await loop.getaddrinfo()

Version asynchrone de socket.getaddrinfo().

await loop.getnameinfo()

Version asynchrone de socket.getnameinfo().

Réseau et communication inter-processus

await loop.create_connection()

Ouvre une connexion TCP.

await loop.create_server()

Crée un serveur TCP.

await loop.create_unix_connection()

Ouvre une connexion socket Unix.

await loop.create_unix_server()

Crée un serveur de socket Unix.

await loop.connect_accepted_socket()

Enveloppe une socket dans une paire (transport, protocol).

await loop.create_datagram_endpoint()

Ouvre une connexion par datagramme (UDP).

await loop.sendfile()

Envoie un fichier via un transport.

await loop.start_tls()

Bascule une connexion existante vers TLS.

await loop.connect_read_pipe()

Enveloppe une extrémité de lecture d'un tube dans une paire (transport, protocol).

await loop.connect_write_pipe()

Enveloppe une extrémité d'écriture d'un tube dans une paire (transport, protocol).

Interfaces de connexion (sockets)

await loop.sock_recv()

Reçoit les données de socket.

await loop.sock_recv_into()

Reçoit les données de socket dans un tampon.

await loop.sock_recvfrom()

Reçoit un datagramme de socket.

await loop.sock_recvfrom_into()

Reçoit un datagramme de socket dans un tampon.

await loop.sock_sendall()

Envoie des données à socket.

await loop.sock_sendto()

Envoie un datagramme via socket à l'adresse indiquée.

await loop.sock_connect()

Connecte la socket.

await loop.sock_accept()

Accepte une connexion socket.

await loop.sock_sendfile()

Envoie un fichier via socket.

loop.add_reader()

Commence à observer un descripteur de fichier pour la disponibilité en lecture.

loop.remove_reader()

Arrête d'observer un descripteur de fichier pour la disponibilité en lecture.

loop.add_writer()

Commence à observer un descripteur de fichier pour la disponibilité en écriture.

loop.remove_writer()

Arrête d'observer un descripteur de fichier pour la disponibilité en écriture.

Signaux Unix

loop.add_signal_handler()

Ajoute un gestionnaire pour le signal.

loop.remove_signal_handler()

Supprime un gestionnaire pour le signal.

Sous-processus

loop.subprocess_exec()

Crée un sous-processus.

loop.subprocess_shell()

Crée un sous-processus à partir d'une commande shell.

Gestion des erreurs

loop.call_exception_handler()

Appelle le gestionnaire d'exceptions.

loop.set_exception_handler()

Définit un nouveau gestionnaire d'exceptions.

loop.get_exception_handler()

Renvoie le gestionnaire d'exceptions actuel.

loop.default_exception_handler()

Implémentation du gestionnaire d'exceptions par défaut.

Exemples

Transports

Tous les transports mettent en œuvre les méthodes suivantes :

transport.close()

Ferme le transport.

transport.is_closing()

Renvoie True si le transport se ferme ou est fermé.

transport.get_extra_info()

Demande d'informations sur le transport.

transport.set_protocol()

Change le protocole.

transport.get_protocol()

Renvoie le protocole courant.

Transports pouvant recevoir des données (connexions TCP et Unix, pipes, etc.). Renvoyé par des méthodes telles que loop.create_connection(), loop.create_unix_connection(), loop.connect_read_pipe(), etc :

Transports en lecture

transport.is_reading()

Renvoie True si le transport est en cours de réception.

transport.pause_reading()

Suspend la réception.

transport.resume_reading()

Reprend la réception.

Transports pouvant envoyer des données (connexions TCP et Unix, pipes, etc.). Renvoyé par des méthodes telles que loop.create_connection(), loop.create_unix_connection(), loop.connect_write_pipe(), etc :

Transports en écriture

transport.write()

Écrit des données dans le transport.

transport.writelines()

Écrit des tampons dans le transport.

transport.can_write_eof()

Renvoie True si le transport prend en charge l'envoi d'EOF.

transport.write_eof()

Ferme et envoie EOF après avoir vidé les données mises en mémoire tampon.

transport.abort()

Ferme immédiatement le transport.

transport.get_write_buffer_size()

Return the current size of the output buffer.

transport.get_write_buffer_limits()

Renvoie les seuils haut et bas pour le contrôle du flux d'écriture.

transport.set_write_buffer_limits()

Définit de nouvelles bornes hautes et basses pour le contrôle du flux d'écriture.

Transports renvoyés par loop.create_datagram_endpoint() :

Transports par datagrammes

transport.sendto()

Envoie des données au pair distant.

transport.abort()

Ferme immédiatement le transport.

Abstraction de transport de bas niveau sur les sous-processus. Renvoyé par loop.subprocess_exec() et loop.subprocess_shell() :

Transports vers des sous-processus

transport.get_pid()

Renvoie l'ID de processus du sous-processus.

transport.get_pipe_transport()

Renvoie le transport pour le tube de communication demandé (stdin, stdout ou stderr).

transport.get_returncode()

Renvoie le code de retour du sous-processus.

transport.kill()

Tue le sous-processus.

transport.send_signal()

Envoie un signal au sous-processus.

transport.terminate()

Termine le sous-processus.

transport.close()

Tue le sous-processus et ferme tous les tubes.

Protocoles

Les classes de protocole peuvent implémenter les méthodes de rappel suivantes :

callback connection_made()

Appelée lorsqu'une connexion est établie.

callback connection_lost()

Appelé lorsqu'une connexion est perdue ou fermée.

callback pause_writing()

Appelée lorsque la mémoire tampon du transport dépasse le seuil haut.

callback resume_writing()

Appelée lorsque la mémoire tampon du transport passe sous le seuil bas.

Protocoles de flux (TCP, Unix Sockets, Pipes)

callback data_received()

Appelée lorsque certaines données sont reçues.

callback eof_received()

Appelée lorsqu'un EOF est reçu.

Protocoles de flux tamponnés

callback get_buffer()

Appelée pour allouer un nouveau tampon de réception.

callback buffer_updated()

Appelée lorsque le tampon a été mis à jour avec les données reçues.

callback eof_received()

Appelée lorsqu'un EOF est reçu.

Protocoles par datagrammes (non-connectés)

callback datagram_received()

Appelée lorsqu'un datagramme est reçu.

callback error_received()

Appelée lorsqu'une opération d'envoi ou de réception précédente lève une OSError.

Protocoles liés aux sous-processus

callback pipe_data_received()

Appelée lorsqu'un processus enfant écrit sur sa sortie d'erreur ou sa sortie standard.

callback pipe_connection_lost()

Appelée lorsqu'un tube de communication avec un sous-processus est fermée.

callback process_exited()

Called when the child process has exited. It can be called before pipe_data_received() and pipe_connection_lost() methods.

Politiques de boucle d'événements

Les politiques sont un mécanisme de bas niveau pour modifier le comportement de fonctions telles que asyncio.get_event_loop(). Voir aussi la section principale Politiques pour plus de détails.

Accès aux politiques

asyncio.get_event_loop_policy()

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

asyncio.set_event_loop_policy()

Définit une nouvelle politique à l'échelle du processus.

AbstractEventLoopPolicy

Classe mère pour les objets de politique.