asyncio.selector_events

Event loop using a selector and related classes.

A selector is a "notify-when-ready" multiplexer.  For a subclass which
also includes support for signal handling, see the unix_events sub-module.

Classes

BaseSelectorEventLoop

Selector event loop.

    See events.EventLoop for API specification.

add_reader(self, fd, callback, *args)

  Add a reader callback.

add_signal_handler(self, sig, callback, *args)

add_writer(self, fd, callback, *args)

  Add a writer callback..

call_at(self, when, callback, *args, context=None)

  Like call_later(), but uses an absolute time.

          Absolute time corresponds to the event loop's time() method.

call_exception_handler(self, context)

  Call the current event loop's exception handler.

          The context argument is a dict containing the following keys:

          - 'message': Error message;
          - 'exception' (optional): Exception object;
          - 'future' (optional): Future instance;
          - 'task' (optional): Task instance;
          - 'handle' (optional): Handle instance;
          - 'protocol' (optional): Protocol instance;
          - 'transport' (optional): Transport instance;
          - 'socket' (optional): Socket instance;
          - 'asyncgen' (optional): Asynchronous generator that caused
                                   the exception.

          New keys maybe introduced in the future.

          Note: do not overload this method in an event loop subclass.
          For custom exception handling, use the
          `set_exception_handler()` method.

call_later(self, delay, callback, *args, context=None)

  Arrange for a callback to be called at a given time.

          Return a Handle: an opaque object with a cancel() method that
          can be used to cancel the call.

          The delay can be an int or float, expressed in seconds.  It is
          always relative to the current time.

          Each callback will be called exactly once.  If two callbacks
          are scheduled for exactly the same time, it undefined which
          will be called first.

          Any positional arguments after the callback will be passed to
          the callback when it is called.

call_soon(self, callback, *args, context=None)

  Arrange for a callback to be called as soon as possible.

          This operates as a FIFO queue: callbacks are called in the
          order in which they are registered.  Each callback will be
          called exactly once.

          Any positional arguments after the callback will be passed to
          the callback when it is called.

call_soon_threadsafe(self, callback, *args, context=None)

  Like call_soon(), but thread-safe.

close(self)

connect_accepted_socket(self, protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None)

connect_read_pipe(self, protocol_factory, pipe)

connect_write_pipe(self, protocol_factory, pipe)

create_connection(self, 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, happy_eyeballs_delay=None, interleave=None)

  Connect to a TCP server.

          Create a streaming transport connection to a given internet host and
          port: socket family AF_INET or socket.AF_INET6 depending on host (or
          family if specified), socket type SOCK_STREAM. protocol_factory must be
          a callable returning a protocol instance.

          This method is a coroutine which will try to establish the connection
          in the background.  When successful, the coroutine returns a
          (transport, protocol) pair.

create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=<object object at 0x7f75e3c94bd0>, reuse_port=None, allow_broadcast=None, sock=None)

  Create datagram connection.

create_future(self)

  Create a Future object attached to the loop.

create_server(self, protocol_factory, host=None, port=None, *, family=<AddressFamily.AF_UNSPEC: 0>, flags=<AddressInfo.AI_PASSIVE: 1>, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, start_serving=True)

  Create a TCP server.

          The host parameter can be a string, in that case the TCP server is
          bound to host and port.

          The host parameter can also be a sequence of strings and in that case
          the TCP server is bound to all hosts of the sequence. If a host
          appears multiple times (possibly indirectly e.g. when hostnames
          resolve to the same IP address), the server is only bound once to that
          host.

          Return a Server object which can be used to stop the service.

          This method is a coroutine.

create_task(self, coro, *, name=None)

  Schedule a coroutine object.

          Return a task object.

create_unix_connection(self, protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None)

create_unix_server(self, protocol_factory, path=None, *, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, start_serving=True)

  A coroutine which creates a UNIX Domain Socket server.

          The return value is a Server object, which can be used to stop
          the service.

          path is a str, representing a file system path to bind the
          server socket to.

          sock can optionally be specified in order to use a preexisting
          socket object.

          backlog is the maximum number of queued connections passed to
          listen() (defaults to 100).

          ssl can be set to an SSLContext to enable SSL over the
          accepted connections.

          ssl_handshake_timeout is the time in seconds that an SSL server
          will wait for the SSL handshake to complete (defaults to 60s).

          start_serving set to True (default) causes the created server
          to start accepting connections immediately.  When set to False,
          the user should await Server.start_serving() or Server.serve_forever()
          to make the server to start accepting connections.

default_exception_handler(self, context)

  Default exception handler.

          This is called when an exception occurs and no exception
          handler is set, and can be called by a custom exception
          handler that wants to defer to the default behavior.

          This default handler logs the error message and other
          context-dependent information.  In debug mode, a truncated
          stack trace is also appended showing where the given object
          (e.g. a handle or future or task) was created, if any.

          The context parameter has the same meaning as in
          `call_exception_handler()`.

get_debug(self)

get_exception_handler(self)

  Return an exception handler, or None if the default one is in use.

get_task_factory(self)

  Return a task factory, or None if the default one is in use.

getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0)

getnameinfo(self, sockaddr, flags=0)

is_closed(self)

  Returns True if the event loop was closed.

is_running(self)

  Returns True if the event loop is running.

remove_reader(self, fd)

  Remove a reader callback.

remove_signal_handler(self, sig)

remove_writer(self, fd)

  Remove a writer callback.

run_forever(self)

  Run until stop() is called.

run_in_executor(self, executor, func, *args)

run_until_complete(self, future)

  Run until the Future is done.

          If the argument is a coroutine, it is wrapped in a Task.

          WARNING: It would be disastrous to call run_until_complete()
          with the same coroutine twice -- it would wrap it in two
          different Tasks and that can't be good.

          Return the Future's result, or raise its exception.

sendfile(self, transport, file, offset=0, count=None, *, fallback=True)

  Send a file to transport.

          Return the total number of bytes which were sent.

          The method uses high-performance os.sendfile if available.

          file must be a regular file object opened in binary mode.

          offset tells from where to start reading the file. If specified,
          count is the total number of bytes to transmit as opposed to
          sending the file until EOF is reached. File position is updated on
          return or also in case of error in which case file.tell()
          can be used to figure out the number of bytes
          which were sent.

          fallback set to True makes asyncio to manually read and send
          the file when the platform does not support the sendfile syscall
          (e.g. Windows or SSL socket on Unix).

          Raise SendfileNotAvailableError if the system does not support
          sendfile syscall and fallback is False.

set_debug(self, enabled)

set_default_executor(self, executor)

set_exception_handler(self, handler)

  Set handler as the new event loop exception handler.

          If handler is None, the default exception handler will
          be set.

          If handler is a callable object, it should have a
          signature matching '(loop, context)', where 'loop'
          will be a reference to the active event loop, 'context'
          will be a dict object (see `call_exception_handler()`
          documentation for details about context).

set_task_factory(self, factory)

  Set a task factory that will be used by loop.create_task().

          If factory is None the default task factory will be set.

          If factory is a callable, it should have a signature matching
          '(loop, coro)', where 'loop' will be a reference to the active
          event loop, 'coro' will be a coroutine object.  The callable
          must return a Future.

shutdown_asyncgens(self)

  Shutdown all active asynchronous generators.

shutdown_default_executor(self)

  Schedule the shutdown of the default executor.

sock_accept(self, sock)

  Accept a connection.

          The socket must be bound to an address and listening for connections.
          The return value is a pair (conn, address) where conn is a new socket
          object usable to send and receive data on the connection, and address
          is the address bound to the socket on the other end of the connection.

sock_connect(self, sock, address)

  Connect to a remote socket at address.

          This method is a coroutine.

sock_recv(self, sock, n)

  Receive data from the socket.

          The return value is a bytes object representing the data received.
          The maximum amount of data to be received at once is specified by
          nbytes.

sock_recv_into(self, sock, buf)

  Receive data from the socket.

          The received data is written into *buf* (a writable buffer).
          The return value is the number of bytes written.

sock_sendall(self, sock, data)

  Send data to the socket.

          The socket must be connected to a remote socket. This method continues
          to send data from data until either all data has been sent or an
          error occurs. None is returned on success. On error, an exception is
          raised, and there is no way to determine how much data, if any, was
          successfully processed by the receiving end of the connection.

sock_sendfile(self, sock, file, offset=0, count=None, *, fallback=True)

start_tls(self, transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None)

  Upgrade transport to TLS.

          Return a new transport that *protocol* should start using
          immediately.

stop(self)

  Stop running the event loop.

          Every callback already scheduled will still run.  This simply informs
          run_forever to stop looping after a complete iteration.

subprocess_exec(self, protocol_factory, program, *args, stdin=-1, stdout=-1, stderr=-1, universal_newlines=False, shell=False, bufsize=0, encoding=None, errors=None, text=None, **kwargs)

subprocess_shell(self, protocol_factory, cmd, *, stdin=-1, stdout=-1, stderr=-1, universal_newlines=False, shell=True, bufsize=0, encoding=None, errors=None, text=None, **kwargs)

time(self)

  Return the time according to the event loop's clock.

          This is a float expressed in seconds since an epoch, but the
          epoch, precision, accuracy and drift are unspecified and may
          differ per event loop.

Other members

logger = <Logger asyncio (INFO)>

Modules