# asyncio.selector_events.BaseSelectorEventLoop - pydoc - phpman Help on class BaseSelectorEventLoop in asyncio.selector_events: asyncio.selector_events.BaseSelectorEventLoop = class BaseSelectorEventLoop(asyncio.base_events.BaseEventLoop) | asyncio.selector_events.BaseSelectorEventLoop(selector=None) | | Selector event loop. | | See events.EventLoop for API specification. | | Method resolution order: | BaseSelectorEventLoop | asyncio.base_events.BaseEventLoop | asyncio.events.AbstractEventLoop | builtins.object | | Methods defined here: | | __init__(self, selector=None) | Initialize self. See help(type(self)) for accurate signature. | | add_reader(self, fd, callback, *args) | Add a reader callback. | | add_writer(self, fd, callback, *args) | Add a writer callback.. | | 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. | | remove_reader(self, fd) | Remove a reader callback. | | remove_writer(self, fd) | Remove a writer callback. | | async 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. | | async sock_connect(self, sock, address) | Connect to a remote socket at address. | | This method is a coroutine. | | async 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. | | async 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. | | async 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. | | ---------------------------------------------------------------------- | Methods inherited from asyncio.base_events.BaseEventLoop: | | __del__(self, _warn=) | | __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. | | 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=, 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=, flags=, 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_signal_handler(self, sig, 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_signal_handler(self, sig) | | ---------------------------------------------------------------------- | Data descriptors inherited from asyncio.events.AbstractEventLoop: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined)