Miscellaneous

• close(). Closes the event loop, releasing any resources it may hold, such as the file descriptor used by epoll() or kqueue(). This should not be called while the event loop is running. After it has been called the event loop may not be used again. It may be called multiple times; subsequent calls are no-ops.
• time(). Returns the current time according to the event loop's clock. This may be time.time() or time.monotonic() or some other system-specific clock, but it must return a float expressing the time in units of approximately one second since some epoch. (No clock is perfect -- see PEP 418.)

Starting and Stopping

An (unclosed) event loop can be in one of two states: running or stopped. These methods deal with starting and stopping an event loop:

• run_forever(). Runs the event loop until stop() is called. This cannot be called when the event loop is already running. (This has a long name in part to avoid confusion with earlier versions of this PEP, where run() had different behavior, in part because there are already too many APIs that have a method named run(), and in part because there shouldn't be many places where this is called anyway.)
• run_until_complete(future). Runs the event loop until the Future is done. If the Future is done, its result is returned, or its exception is raised. This cannot be called when the event loop is already running.
• stop(). Stops the event loop as soon as it is convenient. It is fine to restart the loop with run_forever() or run_until_complete() subsequently; no scheduled callbacks will be lost if this is done. Note: stop() returns normally and the current callback is allowed to continue. How soon after this point the event loop stops is up to the implementation, but the intention is to stop short of polling for I/O, and not to run any callbacks scheduled in the future; the major freedom an implementation has is how much of the "ready queue" (callbacks already scheduled with call_soon()) it processes before stopping.
• is_running(). Returns True if the event loop is currently running, False if it is stopped. (TBD: Do we need another inquiry method to tell whether the loop is in the process of stopping?)

Basic Callbacks

Callbacks associated with the same event loop are strictly serialized: one callback must finish before the next one will be called. This is an important guarantee: when two or more callbacks use or modify shared state, each callback is guaranteed that while is running, the shared state isn't changed by another callback.

• call_soon(callback, *args). This schedules a callback to be called as soon as possible. Returns a Handle representing the callback, whose cancel() method can be used to cancel the callback. It guarantees that callbacks are called in the order in which they were scheduled.
• call_later(delay, callback, *args). Arrange for callback(*args) to be called approximately delay seconds in the future, once, unless cancelled. Returns a Handle representing the callback, whose cancel() method can be used to cancel the callback. Callbacks scheduled in the past or at exactly the same time will be called in an undefined order.
• call_at(when, callback, *args). This is like call_later(), but the time is expressed as an absolute time. Returns a similar Handle. There is a simple equivalency: loop.call_later(delay, callback, *args) is the same as loop.call_at(loop.time() + delay, callback, *args).

Note: A previous version of this PEP defined a method named call_repeatedly(), which promised to call a callback at regular intervals. This has been withdrawn because the design of such a function is overspecified. On the one hand, a simple timer loop can easily be emulated using a callback that reschedules itself using call_later(); it is also easy to write coroutine containing a loop and a sleep() call (a toplevel function in the module, see below). On the other hand, due to the complexities of accurate timekeeping there are many traps and pitfalls here for the unaware (see PEP 418), and different use cases require different behavior in edge cases. It is impossible to offer an API for this purpose that is bullet-proof in all cases, so it is deemed better to let application designers decide for themselves what kind of timer loop to implement.

Thread interaction

• call_soon_threadsafe(callback, *args). Like call_soon(callback, *args), but when called from another thread while the event loop is blocked waiting for I/O, unblocks the event loop. This is the only method that is safe to call from another thread. (To schedule a callback for a later time in a threadsafe manner, you can use loop.call_soon_threadsafe(loop.call_later, when, callback, *args).) Note: this is not safe to call from a signal handler (since it may use locks). In fact, no API is signal-safe; if you want to handle signals, use add_signal_handler() described below.
• run_in_executor(executor, callback, *args). Arrange to call callback(*args) in an executor (see PEP 3148). Returns a Future whose result on success is the return value of that call. This is equivalent to wrap_future(executor.submit(callback, *args)). If executor is None, the default executor set by set_default_executor() is used. If no default executor has been set yet, a ThreadPoolExecutor with 5 threads is created and set as the default executor.
• set_default_executor(executor). Set the default executor used by run_in_executor(). The argument must be a PEP 3148 Executor instance or None, in order to reset the default executor.

See also the wrap_future() function described in the section about Futures.

Internet name lookups

These methods are useful if you want to connect or bind a socket to an address without the risk of blocking for the name lookup. They are usually called implicitly by create_connection(), start_serving() or create_datagram_endpoint().

• getaddrinfo(host, port, family=0, type=0, proto=0, flags=0). Similar to the socket.getaddrinfo() function but returns a Future. The Future's result on success will be a list of the same format as returned by socket.getaddrinfo(), i.e. a list of (address_family, socket_type, socket_protocol, canonical_name, address) where address is a 2-tuple (ipv4_address, port) for IPv4 addresses and a 4-tuple (ipv4_address, port, flow_info, scope_id) for IPv6 addresses. If the family argument is zero or unspecified, the list returned may contain a mixture of IPv4 and IPv6 addresses; otherwise the addresses returned are constrained by the family value (similar for proto and flags). The default implementation calls socket.getaddrinfo() using run_in_executor(), but other implementations may choose to implement their own DNS lookup. The optional arguments must be specified as keyword arguments.

  Note: implementations are allowed to implement a subset of the full socket.getaddrinfo() interface; e.g. they may not support symbolic port names, or they may ignore or incompletely implement the type, proto and flags arguments. However, if type and proto are ignored, the argument values passed in should be copied unchanged into the return tuples' socket_type and socket_protocol elements. (You can't ignore family, since IPv4 and IPv6 addresses must be looked up differently. The only permissible values for family are socket.AF_UNSPEC (0), socket.AF_INET and socket.AF_INET6, and the latter only if it is defined by the platform.)

• getnameinfo(sockaddr, flags=0). Similar to socket.getnameinfo() but returns a Future. The Future's result on success will be a tuple (host, port). Same implementation remarks as for getaddrinfo().

Internet connections

These are the high-level interfaces for managing internet connections. Their use is recommended over the corresponding lower-level interfaces because they abstract away the differences between selector-based and proactor-based event loops.

Note that the client and server side of stream connections use the same transport and protocol interface. However, datagram endpoints use a different transport and protocol interface.

• create_connection(protocol_factory, host, port, **kwargs). Creates a stream connection to a given internet host and port. This is a task that is typically called from the client side of the connection. It creates an implementation-dependent (bidirectional stream) Transport to represent the connection, then calls protocol_factory() to instantiate (or retrieve) the user's Protocol implementation, and finally ties the two together. (See below for the definitions of Transport and Protocol.) The user's Protocol implementation is created or retrieved by calling protocol_factory() without arguments(*). The coroutine's result on success is the (transport, protocol) pair; if a failure prevents the creation of a successful connection, an appropriate exception will be raised. Note that when the coroutine completes, the protocol's connection_made() method has not yet been called; that will happen when the connection handshake is complete.

  (*) There is no requirement that protocol_factory is a class. If your protocol class needs to have specific arguments passed to its constructor, you can use lambda or functools.partial(). You can also pass a trivial lambda that returns a previously constructed Protocol instance.

  Optional keyword arguments:

  • ssl: Pass True to create an SSL transport (by default a plain TCP transport is created). Or pass an ssl.SSLContext object to override the default SSL context object to be used.
  • family, proto, flags: Address family, protocol and flags to be passed through to getaddrinfo(). These all default to 0, which means "not specified". (The socket type is always SOCK_STREAM.) If any of these values are not specified, the getaddrinfo() method will choose appropriate values. Note: proto has nothing to do with the high-level Protocol concept or the protocol_factory argument.
  • sock: An optional socket to be used instead of using the host, port, family, proto, and flags arguments. If this is given, host and port must be omitted; otherwise, host and port are required.
  • local_addr: If given, a (host, port) tuple used to bind the socket to locally. This is rarely needed but on multi-homed servers you occasionally need to force a connection to come from a specific address. This is how you would do that. The host and port are looked up using getaddrinfo().

• start_serving(protocol_factory, host, port, **kwds). Enters a serving loop that accepts connections. This is a coroutine that completes once the serving loop is set up to serve. The return value is a list of one or more sockets in listening mode. (Multiple sockets may be returned if the specified address allows both IPv4 and IPv6 connections.) You can use stop_serving() to stop the serving loop. Each time a connection is accepted, protocol_factory is called without arguments(*) to create a Protocol, a (bidirectional stream) Transport is created to represent the network side of the connection, and the two are tied together by calling protocol.connection_made(transport).

  (*) See footnote above for create_connection(). However, since protocol_factory() is called once for each new incoming connection, it should return a new Protocol object each time it is called.

  Optional keyword arguments:

  • ssl: Pass an ssl.SSLContext object to override the default SSL context object to be used. (Unlike create_connection(), passing True does not make sense -- the SSLContext object is required to specify the certificate and key.)

  • backlog: Backlog value to be passed to the listen() call. Defaults to 100.

  • reuse_address: Whether to set the SO_REUSEADDR option on the socket. The default is True on UNIX, False on Windows.

  • family, flags: Address family and flags to be passed

    through to getaddrinfo(). The family defaults to AF_UNSPEC; the flags default to AI_PASSIVE. (The socket type is always SOCK_STREAM; the socket protocol always set to 0, to let getaddrinfo() choose.)

  • sock: An optional socket to be used instead of using the host, port, family, and flags arguments. If this is given, host and port must be omitted; otherwise, host and port are required. The return value will be the one-element list [sock].

• stop_serving(sock). The argument should be a socket from the list returned by start_serving(). The serving loop associated with that socket will be stopped. Connections that have already been accepted will not be affected. (TBD: What if start_serving() doesn't use sockets? Then it should probably return a list of opaque objects that can be passed to stop_serving().)

• create_datagram_endpoint(protocol_factory, local_addr, remote_addr, **kwds). Creates an endpoint for sending and receiving datagrams (typically UDP packets). Because of the nature of datagram traffic, there are no separate calls to set up client and server side, since usually a single endpoint acts as both client and server. This is a coroutine that returns a (transport, protocol) pair on success, or raises an exception on failure. If the coroutine returns successfully, the transport will call callbacks on the protocol whenever a datagram is received or the socket is closed; it is up to the protocol to call methods on the protocol to send datagrams. Note that the transport and protocol interfaces used here are different than those for stream connections.

  Arguments:

  • protocol_factory: A class or factory function that will be called, without arguments, to construct the protocol object to be returned. The interface between datagram transport and protocol is described below.
  • local_addr: An optional tuple indicating the address to which the socket will be bound. If given this must be a (host, port) pair. It will be passed to getaddrinfo() to be resolved and the result will be passed to the bind() method of the socket created. If getaddrinfo() returns more than one address, they will be tried in turn. If omitted, no bind() call will be made.
  • remote_addr: An optional tuple indicating the address to which the socket will be "connected". (Since there is no such thing as a datagram connection, this just specifies a default value for the destination address of outgoing datagrams.) If given this must be a (host, port) pair. It will be passed to getaddrinfo() to be resolved and the result will be passed to sock_connect() together with the socket created. If getaddrinfo() returns more than one address, they will be tried in turn. If omitted, no sock_connect() will be made.
  • family, proto, flags: Address family, protocol and flags to be passed through to getaddrinfo(). These all default to 0, which means "not specified". (The socket type is always SOCK_DGRAM.) If any of these values are not specified, the getaddrinfo() method will choose appropriate values.

  Note that if both local_addr and remote_addr are present, all combinations of local and remote addresses with matching address family will be tried.

Wrapped Socket Methods

The following methods for doing async I/O on sockets are not for general use. They are primarily meant for transport implementations working with IOCP through the ProactorEventLoop class. However, they are easily implementable for other event loop types, so there is no reason not to require them. The socket argument has to be a non-blocking socket.

• sock_recv(sock, n). Receive up to n bytes from socket sock. Returns a Future whose result on success will be a bytes object.
• sock_sendall(sock, data). Send bytes data to socket sock. Returns a Future whose result on success will be None. Note: the name uses sendall instead of send, to reflect that the semantics and signature of this method echo those of the standard library socket method sendall() rather than send(). (TBD: but maybe it would be better to emulate send() after all? That would be better for datagram sockets.)
• sock_connect(sock, address). Connect to the given address. Returns a Future whose result on success will be None.
• sock_accept(sock). Accept a connection from a socket. The socket must be in listening mode and bound to an address. Returns a Future whose result on success will be a tuple (conn, peer) where conn is a connected non-blocking socket and peer is the peer address.

I/O Callbacks

These methods are primarily meant for transport implementations working with a selector. They are implemented by SelectorEventLoop but not by ProactorEventLoop. Custom event loop implementations may or may not implement them.

The fd arguments below may be integer file descriptors, or "file-like" objects with a fileno() method that wrap integer file descriptors. Not all file-like objects or file descriptors are acceptable. Sockets (and socket file descriptors) are always accepted. On Windows no other types are supported. On UNIX, pipes and possibly tty devices are also supported, but disk files are not. Exactly which special file types are supported may vary by platform and per selector implementation. (Experimentally, there is at least one kind of pseudo-tty on OSX that is supported by select and poll but not by kqueue: it is used by Emacs shell windows.)

• add_reader(fd, callback, *args). Arrange for callback(*args) to be called whenever file descriptor fd is deemed ready for reading. Calling add_reader() again for the same file descriptor implies a call to remove_reader() for the same file descriptor.
• add_writer(fd, callback, *args). Like add_reader(), but registers the callback for writing instead of for reading.
• remove_reader(fd). Cancels the current read callback for file descriptor fd, if one is set. If no callback is currently set for the file descriptor, this is a no-op and returns False. Otherwise, it removes the callback arrangement and returns True.
• remove_writer(fd). This is to add_writer() as remove_reader() is to add_reader().

Pipes and Subprocesses

TBD: Should these really take stream objects? The stream objects are not useful for reading or writing because they would cause blocking I/O. This section of the API is clearly not yet ready for review.

• connect_read_pipe(protocol_factory, pipe): Create a unidrectional stream connection from a file-like object wrapping the read end of a UNIX pipe. The protocol/transport interface is the read half of the bidirectional stream interface.
• connect_write_pipe(protocol_factory, pipe): Create a unidrectional stream connection from a file-like object wrapping the write end of a UNIX pipe. The protocol/transport interface is the write half of the bidirectional stream interface.
• TBD: A way to run a subprocess with stdin, stdout and stderr connected to pipe transports. (This is being designed but not yet ready.)

TBD: offer the same interface on Windows for e.g. named pipes. (This should be possible given that the standard library subprocess module is supported on Windows.)

Signal callbacks

• add_signal_handler(sig, callback, *args). Whenever signal sig is received, arrange for callback(*args) to be called. Specifying another callback for the same signal replaces the previous handler (only one handler can be active per signal). The sig must be a valid sigal number defined in the signal module. If the signal cannot be handled this raises an exception: ValueError if it is not a valid signal or if it is an uncatchable signal (e.g. SIGKILL), RuntimeError if this particular event loop instance cannot handle signals (since signals are global per process, only an event loop associated with the main thread can handle signals).
• remove_signal_handler(sig). Removes the handler for signal sig, if one is set. Raises the same exceptions as add_signal_handler() (except that it may return False instead raising RuntimeError for uncatchable signals). Returns True if a handler was removed successfully, False if no handler was set.

Note: If these methods are statically known to be unsupported, they may return NotImplementedError instead of RuntimeError.

Methods For All Transports

• get_extra_info(name, default=None). This is a catch-all method that returns implementation-specific information about a transport. The first argument is the name of the extra field to be retrieved. The optional second argument is a default value to be returned. Consult the implementation documentation to find out the supported extra field names. For an unsupported name, the default is always returned.

Bidirectional Stream Transports

A bidrectional stream transport is an abstraction on top of a socket or something similar (for example, a pair of UNIX pipes or an SSL connection).

Most connections have an asymmetric nature: the client and server usually have very different roles and behaviors. Hence, the interface between transport and protocol is also asymmetric. From the protocol's point of view, writing data is done by calling the write() method on the transport object; this buffers the data and returns immediately. However, the transport takes a more active role in reading data: whenever some data is read from the socket (or other data source), the transport calls the protocol's data_received() method.

Nevertheless, the interface between transport and protocol used by bidirectional streams is the same for clients as it is for servers, since the connection between a client and a server is essentially a pair of streams, one in each direction.

Bidirectional stream transports have the following public methods:

• write(data). Write some bytes. The argument must be a bytes object. Returns None. The transport is free to buffer the bytes, but it must eventually cause the bytes to be transferred to the entity at the other end, and it must maintain stream behavior. That is, t.write(b'abc'); t.write(b'def') is equivalent to t.write(b'abcdef'), as well as to:

  t.write(b'a')
  t.write(b'b')
  t.write(b'c')
  t.write(b'd')
  t.write(b'e')
  t.write(b'f')
  

• writelines(iterable). Equivalent to:

  for data in iterable:
      self.write(data)
  

• write_eof(). Close the writing end of the connection. Subsequent calls to write() are not allowed. Once all buffered data is transferred, the transport signals to the other end that no more data will be received. Some protocols don't support this operation; in that case, calling write_eof() will raise an exception. (Note: This used to be called half_close(), but unless you already know what it is for, that name doesn't indicate which end is closed.)

• can_write_eof(). Return True if the protocol supports write_eof(), False if it does not. (This method typically returns a fixed value that depends only on the specific Transport class, not on the state of the Transport object. It is needed because some protocols need to change their behavior when write_eof() is unavailable. For example, in HTTP, to send data whose size is not known ahead of time, the end of the data is typically indicated using write_eof(); however, SSL does not support this, and an HTTP protocol implementation would have to use the "chunked" transfer encoding in this case. But if the data size is known ahead of time, the best approach in both cases is to use the Content-Length header.)

• pause(). Suspend delivery of data to the protocol until a subsequent resume() call. Between pause() and resume(), the protocol's data_received() method will not be called. This has no effect on write().

• resume(). Restart delivery of data to the protocol via data_received().

• close(). Sever the connection with the entity at the other end. Any data buffered by write() will (eventually) be transferred before the connection is actually closed. The protocol's data_received() method will not be called again. Once all buffered data has been flushed, the protocol's connection_lost() method will be called with None as the argument. Note that this method does not wait for all that to happen.

• abort(). Immediately sever the connection. Any data still buffered by the transport is thrown away. Soon, the protocol's connection_lost() method will be called with None as argument. (TBD: Distinguish in the connection_lost() argument between close(), abort() or a close initated by the other end? Or add a transport method to inquire about this? Glyph's proposal was to pass different exceptions for this purpose.)

TBD: Provide flow control the other way -- the transport may need to suspend the protocol if the amount of data buffered becomes a burden. Proposal: let the transport call protocol.pause() and protocol.resume() if they exist; if they don't exist, the protocol doesn't support flow control. (Perhaps different names to avoid confusion between protocols and transports?)

Unidirectional Stream Transports

A writing stream transport supports the write(), writelines(), write_eof(), can_write_eof(), close() and abort() methods described for bidrectional stream transports.

A reading stream transport supports the pause(), resume() and close() methods described for bidrectional stream transports.

A writing stream transport calls only connection_made() and connection_lost() on its associated protocol.

A reading stream transport can call all protocol methods specified in the Protocols section below (i.e., the previous two plus data_received() and eof_received()).

Datagram Transports

Datagram transports have these methods:

• sendto(data, addr=None). Sends a datagram (a bytes object). The optional second argument is the destination address. If omitted, remote_addr must have been specified in the create_datagram_endpoint() call that created this transport. If present, and remote_addr was specified, they must match. The (data, addr) pair may be sent immediately or buffered. The return value is None.
• abort(). Immediately close the transport. Buffered data will be discarded.
• close(). Close the transport. Buffered data will be transmitted asynchronously.

Datagram transports call the following methods on the associated protocol object: connection_made(), connection_lost(), connection_refused(), and datagram_received(). ("Connection" in these method names is a slight misnomer, but the concepts still exist: connection_made() means the transport representing the endpoint has been created, and connection_lost() means the transport is closed. The connection_refused() method is called before connection_lost() when remote_addr was given and an explicit negative acknowledgement was received (this is a UDP feature). (TBD: Do we need the latter? It seems easy enough to implement this in the protocol if it needs to make the distinction.)

Stream Protocols

A (bidirectional) stream protocol must implement the following methods, which will be called by the transport. Think of these as callbacks that are always called by the event loop in the right context. (See the "Context" section way above.)

• connection_made(transport). Indicates that the transport is ready and connected to the entity at the other end. The protocol should probably save the transport reference as an instance variable (so it can call its write() and other methods later), and may write an initial greeting or request at this point.

• data_received(data). The transport has read some bytes from the connection. The argument is always a non-empty bytes object. There are no guarantees about the minimum or maximum size of the data passed along this way. p.data_received(b'abcdef') should be treated exactly equivalent to:

  p.data_received(b'abc')
  p.data_received(b'def')
  

• eof_received(). This is called when the other end called write_eof() (or something equivalent). The default implementation calls close() on the transport, which causes connection_lost() to be called (eventually) on the protocol.

• connection_lost(exc). The transport has been closed or aborted, has detected that the other end has closed the connection cleanly, or has encountered an unexpected error. In the first three cases the argument is None; for an unexpected error, the argument is the exception that caused the transport to give up. (TBD: Do we need to distinguish between the first three cases?)

Here is a chart indicating the order and multiplicity of calls:

1. connection_made() -- exactly once
2. data_received() -- zero or more times
3. eof_received() -- at most once
4. connection_lost() -- exactly once

TBD: Discuss whether user code needs to do anything to make sure that protocol and transport aren't garbage-collected prematurely.

Datagram Protocols

Datagram protocols have connection_made() and connection_lost() methods with the same signatures as stream protocols. (As explained in the section about datagram transports, we prefer the slightly odd nomenclature over defining different method names to indicating the opening and closing of the socket.)

In addition, they have the following methods:

• datagram_received(data, addr). Indicates that a datagram data (a bytes objects) was received from remote address addr (an IPv4 2-tuple or an IPv6 4-tuple).
• connection_refused(exc). Indicates that a send or receive operation raised a ConnectionRefused exception. This typically indicates that a negative acknowledgment was received for a previously sent datagram (not for the datagram that was being sent, if the exception was raised by a send operation). Immediately after this the socket will be closed and connection_lost() will be called with the same exception argument.

Here is a chart indicating the order and multiplicity of calls:

1. connection_made() -- exactly once
2. datagram_received() -- zero or more times
3. connection_refused() -- at most once
4. connection_lost() -- exactly once