asyncio.events.AbstractEventLoop - pydoc - phpman

Help on class AbstractEventLoop in asyncio.events:

asyncio.events.AbstractEventLoop = class AbstractEventLoop(builtins.object)
 |  Abstract event loop.
 |
 |  Methods defined here:
 |
 |  add_reader(self, fd, callback, *args)
 |
 |  add_signal_handler(self, sig, callback, *args)
 |
 |  add_writer(self, fd, callback, *args)
 |
 |  call_at(self, when, callback, *args, context=None)
 |
 |  call_exception_handler(self, context)
 |
 |  call_later(self, delay, callback, *args, context=None)
 |
 |  call_soon(self, callback, *args, context=None)
 |
 |  call_soon_threadsafe(self, callback, *args, context=None)
 |
 |  close(self)
 |      Close the loop.
 |
 |      The loop should not be running.
 |
 |      This is idempotent and irreversible.
 |
 |      No other methods should be called after this one.
 |
 |  async connect_accepted_socket(self, protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None)
 |      Handle an accepted connection.
 |
 |      This is used by servers that accept connections outside of
 |      asyncio, but use asyncio to handle connections.
 |
 |      This method is a coroutine.  When completed, the coroutine
 |      returns a (transport, protocol) pair.
 |
 |  async connect_read_pipe(self, protocol_factory, pipe)
 |      Register read pipe in event loop. Set the pipe to non-blocking mode.
 |
 |      protocol_factory should instantiate object with Protocol interface.
 |      pipe is a file-like object.
 |      Return pair (transport, protocol), where transport supports the
 |      ReadTransport interface.
 |
 |  async connect_write_pipe(self, protocol_factory, pipe)
 |      Register write pipe in event loop.
 |
 |      protocol_factory should instantiate object with BaseProtocol interface.
 |      Pipe is file-like object already switched to nonblocking.
 |      Return pair (transport, protocol), where transport support
 |      WriteTransport interface.
 |
 |  async 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)
 |
 |  async create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=None, reuse_port=None, allow_broadcast=None, sock=None)
 |      A coroutine which creates a datagram endpoint.
 |
 |      This method will try to establish the endpoint in the background.
 |      When successful, the coroutine returns a (transport, protocol) pair.
 |
 |      protocol_factory must be a callable returning a protocol instance.
 |
 |      socket family AF_INET, socket.AF_INET6 or socket.AF_UNIX depending on
 |      host (or family if specified), socket type SOCK_DGRAM.
 |
 |      reuse_address tells the kernel to reuse a local socket in
 |      TIME_WAIT state, without waiting for its natural timeout to
 |      expire. If not specified it will automatically be set to True on
 |      UNIX.
 |
 |      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 UNIX's. If the
 |      :py:data:`~socket.SO_REUSEPORT` constant is not defined then this
 |      capability is unsupported.
 |
 |      allow_broadcast tells the kernel to allow this endpoint to send
 |      messages to the broadcast address.
 |
 |      sock can optionally be specified in order to use a preexisting
 |      socket object.
 |
 |  create_future(self)
 |
 |  async 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)
 |      A coroutine which creates a TCP server bound to host and port.
 |
 |      The return value is a Server object which can be used to stop
 |      the service.
 |
 |      If host is an empty string or None all interfaces are assumed
 |      and a list of multiple sockets will be returned (most likely
 |      one for IPv4 and another one for IPv6). The host parameter can also be
 |      a sequence (e.g. list) of hosts to bind to.
 |
 |      family can be set to either AF_INET or AF_INET6 to force the
 |      socket to use IPv4 or IPv6. If not set it will be determined
 |      from host (defaults to AF_UNSPEC).
 |
 |      flags is a bitmask for getaddrinfo().
 |
 |      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.
 |
 |      reuse_address tells the kernel to reuse a local socket in
 |      TIME_WAIT state, without waiting for its natural timeout to
 |      expire. If not specified will automatically be set to True on
 |      UNIX.
 |
 |      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.
 |
 |      ssl_handshake_timeout is the time in seconds that an SSL server
 |      will wait for completion of the SSL handshake before aborting the
 |      connection. Default is 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.
 |
 |  create_task(self, coro, *, name=None)
 |
 |  async create_unix_connection(self, protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None)
 |
 |  async 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)
 |
 |  get_debug(self)
 |
 |  get_exception_handler(self)
 |
 |  get_task_factory(self)
 |
 |  async getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0)
 |
 |  async getnameinfo(self, sockaddr, flags=0)
 |
 |  is_closed(self)
 |      Returns True if the event loop was closed.
 |
 |  is_running(self)
 |      Return whether the event loop is currently running.
 |
 |  remove_reader(self, fd)
 |
 |  remove_signal_handler(self, sig)
 |
 |  remove_writer(self, fd)
 |
 |  run_forever(self)
 |      Run the event loop until stop() is called.
 |
 |  run_in_executor(self, executor, func, *args)
 |
 |  run_until_complete(self, future)
 |      Run the event loop until a Future is done.
 |
 |      Return the Future's result, or raise its exception.
 |
 |  async sendfile(self, transport, file, offset=0, count=None, *, fallback=True)
 |      Send a file through a transport.
 |
 |      Return an amount of sent bytes.
 |
 |  set_debug(self, enabled)
 |
 |  set_default_executor(self, executor)
 |
 |  set_exception_handler(self, handler)
 |
 |  set_task_factory(self, factory)
 |
 |  async shutdown_asyncgens(self)
 |      Shutdown all active asynchronous generators.
 |
 |  async shutdown_default_executor(self)
 |      Schedule the shutdown of the default executor.
 |
 |  async sock_accept(self, sock)
 |
 |  async sock_connect(self, sock, address)
 |
 |  async sock_recv(self, sock, nbytes)
 |
 |  async sock_recv_into(self, sock, buf)
 |
 |  async sock_sendall(self, sock, data)
 |
 |  async sock_sendfile(self, sock, file, offset=0, count=None, *, fallback=None)
 |
 |  async start_tls(self, transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None)
 |      Upgrade a transport to TLS.
 |
 |      Return a new transport that *protocol* should start using
 |      immediately.
 |
 |  stop(self)
 |      Stop the event loop as soon as reasonable.
 |
 |      Exactly how soon that is may depend on the implementation, but
 |      no more I/O callbacks should be scheduled.
 |
 |  async subprocess_exec(self, protocol_factory, *args, stdin=-1, stdout=-1, stderr=-1, **kwargs)
 |
 |  async subprocess_shell(self, protocol_factory, cmd, *, stdin=-1, stdout=-1, stderr=-1, **kwargs)
 |
 |  time(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)