asyncio.AbstractEventLoop.set_task_factory()

AbstractEventLoop.set_task_factory(factory) Set a task factory that will be used by AbstractEventLoop.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 an asyncio.Future compatible object. New in version 3.4.4.

asyncio.AbstractEventLoop.set_exception_handler()

AbstractEventLoop.set_exception_handler(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 matching signature to (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).

asyncio.AbstractEventLoop.set_default_executor()

AbstractEventLoop.set_default_executor(executor) Set the default executor used by run_in_executor().

asyncio.AbstractEventLoop.set_debug()

AbstractEventLoop.set_debug(enabled: bool) Set the debug mode of the event loop. New in version 3.4.2.

asyncio.AbstractEventLoop.run_until_complete()

AbstractEventLoop.run_until_complete(future) Run until the Future is done. If the argument is a coroutine object, it is wrapped by ensure_future(). Return the Future’s result, or raise its exception.

asyncio.AbstractEventLoop.run_in_executor()

coroutine AbstractEventLoop.run_in_executor(executor, func, *args) Arrange for a func to be called in the specified executor. The executor argument should be an Executor instance. The default executor is used if executor is None. Use functools.partial to pass keywords to the *func*. This method is a coroutine.

asyncio.AbstractEventLoop.run_forever()

AbstractEventLoop.run_forever() Run until stop() is called. If stop() is called before run_forever() is called, this polls the I/O selector once with a timeout of zero, runs all callbacks scheduled in response to I/O events (and those that were already scheduled), and then exits. If stop() is called while run_forever() is running, this will run the current batch of callbacks and then exit. Note that callbacks scheduled by callbacks will not run in that case; they will run the next time run_f

asyncio.AbstractEventLoop.remove_writer()

AbstractEventLoop.remove_writer(fd) Stop watching the file descriptor for write availability.

asyncio.AbstractEventLoop.remove_signal_handler()

AbstractEventLoop.remove_signal_handler(sig) Remove a handler for a signal. Return True if a signal handler was removed, False if not.

asyncio.AbstractEventLoop.remove_reader()

AbstractEventLoop.remove_reader(fd) Stop watching the file descriptor for read availability.