Low-level API Index

This page lists all low-level asyncio APIs.

Obtaining the Event Loop

`asyncio.get_running_loop()`	The preferred function to get the running event loop.
`asyncio.get_event_loop()`	Get an event loop instance (current or via the policy).
`asyncio.set_event_loop()`	Set the event loop as current via the current policy.
`asyncio.new_event_loop()`	Create a new event loop.

Examples

Using asyncio.get_running_loop().

Event Loop Methods

See also the main documentation section about the event loop methods.

Lifecycle

`loop.run_until_complete()`	Run a Future/Task/awaitable until complete.
`loop.run_forever()`	Run the event loop forever.
`loop.stop()`	Stop the event loop.
`loop.close()`	Close the event loop.
`loop.is_running()`	Return `True` if the event loop is running.
`loop.is_closed()`	Return `True` if the event loop is closed.
`await` `loop.shutdown_asyncgens()`	Close asynchronous generators.

Debugging

`loop.set_debug()`	Enable or disable the debug mode.
`loop.get_debug()`	Get the current debug mode.

Scheduling Callbacks

`loop.call_soon()`	Invoke a callback soon.
`loop.call_soon_threadsafe()`	A thread-safe variant of `loop.call_soon()`.
`loop.call_later()`	Invoke a callback after the given time.
`loop.call_at()`	Invoke a callback at the given time.

Thread/Process Pool

`await` `loop.run_in_executor()`	Run a CPU-bound or other blocking function in a `concurrent.futures` executor.
`loop.set_default_executor()`	Set the default executor for `loop.run_in_executor()`.

Tasks and Futures

`loop.create_future()`	Create a `Future` object.
`loop.create_task()`	Schedule coroutine as a `Task`.
`loop.set_task_factory()`	Set a factory used by `loop.create_task()` to create `Tasks`.
`loop.get_task_factory()`	Get the factory `loop.create_task()` uses to create `Tasks`.

DNS

`await` `loop.getaddrinfo()`	Asynchronous version of `socket.getaddrinfo()`.
`await` `loop.getnameinfo()`	Asynchronous version of `socket.getnameinfo()`.

Networking and IPC

`await` `loop.create_connection()`	Open a TCP connection.
`await` `loop.create_server()`	Create a TCP server.
`await` `loop.create_unix_connection()`	Open a Unix socket connection.
`await` `loop.create_unix_server()`	Create a Unix socket server.
`await` `loop.connect_accepted_socket()`	Wrap a `socket` into a `(transport, protocol)` pair.
`await` `loop.create_datagram_endpoint()`	Open a datagram (UDP) connection.
`await` `loop.sendfile()`	Send a file over a transport.
`await` `loop.start_tls()`	Upgrade an existing connection to TLS.
`await` `loop.connect_read_pipe()`	Wrap a read end of a pipe into a `(transport, protocol)` pair.
`await` `loop.connect_write_pipe()`	Wrap a write end of a pipe into a `(transport, protocol)` pair.

Sockets

`await` `loop.sock_recv()`	Receive data from the `socket`.
`await` `loop.sock_recv_into()`	Receive data from the `socket` into a buffer.
`await` `loop.sock_sendall()`	Send data to the `socket`.
`await` `loop.sock_connect()`	Connect the `socket`.
`await` `loop.sock_accept()`	Accept a `socket` connection.
`await` `loop.sock_sendfile()`	Send a file over the `socket`.
`loop.add_reader()`	Start watching a file descriptor for read availability.
`loop.remove_reader()`	Stop watching a file descriptor for read availability.
`loop.add_writer()`	Start watching a file descriptor for write availability.
`loop.remove_writer()`	Stop watching a file descriptor for write availability.

Unix Signals

`loop.add_signal_handler()`	Add a handler for a `signal`.
`loop.remove_signal_handler()`	Remove a handler for a `signal`.

Subprocesses

`loop.subprocess_exec()`	Spawn a subprocess.
`loop.subprocess_shell()`	Spawn a subprocess from a shell command.

Error Handling

`loop.call_exception_handler()`	Call the exception handler.
`loop.set_exception_handler()`	Set a new exception handler.
`loop.get_exception_handler()`	Get the current exception handler.
`loop.default_exception_handler()`	The default exception handler implementation.

Examples

Using asyncio.get_event_loop() and loop.run_forever().
Using loop.call_later().
Using loop.create_connection() to implement an echo-client.
Using loop.create_connection() to connect a socket.
Using add_reader() to watch an FD for read events.
Using loop.add_signal_handler().
Using loop.subprocess_exec().

Transports

All transports implement the following methods:

`transport.close()`	Close the transport.
`transport.is_closing()`	Return `True` if the transport is closing or is closed.
`transport.get_extra_info()`	Request for information about the transport.
`transport.set_protocol()`	Set a new protocol.
`transport.get_protocol()`	Return the current protocol.

Transports that can receive data (TCP and Unix connections, pipes, etc). Returned from methods like loop.create_connection(), loop.create_unix_connection(), loop.connect_read_pipe(), etc:

Read Transports

`transport.is_reading()`	Return `True` if the transport is receiving.
`transport.pause_reading()`	Pause receiving.
`transport.resume_reading()`	Resume receiving.

Transports that can Send data (TCP and Unix connections, pipes, etc). Returned from methods like loop.create_connection(), loop.create_unix_connection(), loop.connect_write_pipe(), etc:

Write Transports

`transport.write()`	Write data to the transport.
`transport.writelines()`	Write buffers to the transport.
`transport.can_write_eof()`	Return `True` if the transport supports sending EOF.
`transport.write_eof()`	Close and send EOF after flushing buffered data.
`transport.abort()`	Close the transport immediately.
`transport.get_write_buffer_size()`	Return high and low water marks for write flow control.
`transport.set_write_buffer_limits()`	Set new high and low water marks for write flow control.

Transports returned by loop.create_datagram_endpoint():

Datagram Transports

`transport.sendto()`	Send data to the remote peer.
`transport.abort()`	Close the transport immediately.

Low-level transport abstraction over subprocesses. Returned by loop.subprocess_exec() and loop.subprocess_shell():

Subprocess Transports

`transport.get_pid()`	Return the subprocess process id.
`transport.get_pipe_transport()`	Return the transport for the requested communication pipe (stdin, stdout, or stderr).
`transport.get_returncode()`	Return the subprocess return code.
`transport.kill()`	Kill the subprocess.
`transport.send_signal()`	Send a signal to the subprocess.
`transport.terminate()`	Stop the subprocess.
`transport.close()`	Kill the subprocess and close all pipes.

Protocols

Protocol classes can implement the following callback methods:

`callback` `connection_made()`	Called when a connection is made.
`callback` `connection_lost()`	Called when the connection is lost or closed.
`callback` `pause_writing()`	Called when the transport’s buffer goes over the high water mark.
`callback` `resume_writing()`	Called when the transport’s buffer drains below the low water mark.

Streaming Protocols (TCP, Unix Sockets, Pipes)

`callback` `data_received()`	Called when some data is received.
`callback` `eof_received()`	Called when an EOF is received.

Buffered Streaming Protocols

`callback` `get_buffer()`	Called to allocate a new receive buffer.
`callback` `buffer_updated()`	Called when the buffer was updated with the received data.
`callback` `eof_received()`	Called when an EOF is received.

Datagram Protocols

`callback` `datagram_received()`	Called when a datagram is received.
`callback` `error_received()`	Called when a previous send or receive operation raises an `OSError`.

Subprocess Protocols

`callback` `pipe_data_received()`	Called when the child process writes data into its stdout or stderr pipe.
`callback` `pipe_connection_lost()`	Called when one of the pipes communicating with the child process is closed.
`callback` `process_exited()`	Called when the child process has exited.

Event Loop Policies

Policies is a low-level mechanism to alter the behavior of functions like asyncio.get_event_loop(). See also the main policies section for more details.

Accessing Policies

`asyncio.get_event_loop_policy()`	Return the current process-wide policy.
`asyncio.set_event_loop_policy()`	Set a new process-wide policy.
`AbstractEventLoopPolicy`	Base class for policy objects.