asyncio.base_events.BaseEventLoop - pydoc - phpman

Help on class BaseEventLoop in asyncio.base_events:

asyncio.base_events.BaseEventLoop = class BaseEventLoop(asyncio.events.AbstractEventLoop)
 |  Method resolution order:
 |      BaseEventLoop
 |      asyncio.events.AbstractEventLoop
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self, _warn=<built-in function warn>)
 |
 |  __init__(self)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  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)
 |      Close the event loop.
 |
 |      This clears the queues and shuts down the executor,
 |      but does not wait for the executor to finish.
 |
 |      The event loop must not be running.
 |
 |  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)
 |      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.
 |
 |  async create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=<object object at 0x7f2b70284ca0>, reuse_port=None, allow_broadcast=None, sock=None)
 |      Create datagram connection.
 |
 |  create_future(self)
 |      Create a Future object attached to the loop.
 |
 |  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)
 |      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.
 |
 |  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.
 |
 |  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)
 |      Returns True if the event loop is running.
 |
 |  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.
 |
 |  async 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.
 |
 |  async shutdown_asyncgens(self)
 |      Shutdown all active asynchronous generators.
 |
 |  async shutdown_default_executor(self)
 |      Schedule the shutdown of the default executor.
 |
 |  async sock_sendfile(self, sock, file, offset=0, count=None, *, fallback=True)
 |
 |  async 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.
 |
 |  async 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)
 |
 |  async 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.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from asyncio.events.AbstractEventLoop:
 |
 |  add_reader(self, fd, callback, *args)
 |
 |  add_signal_handler(self, sig, callback, *args)
 |
 |  add_writer(self, fd, callback, *args)
 |
 |  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.
 |
 |  remove_reader(self, fd)
 |
 |  remove_signal_handler(self, sig)
 |
 |  remove_writer(self, fd)
 |
 |  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)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from asyncio.events.AbstractEventLoop:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)