Module « asyncio » Python 3.11.3

Classe « BaseEventLoop »

Informations générales

Héritage

builtins.object
    AbstractEventLoop
        BaseEventLoop

Définition

class BaseEventLoop(AbstractEventLoop):

Constructeur(s)

Signature du constructeur	Description
__init__(self)

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__del__(self, _warn=<built-in function warn>)
__repr__(self)
call_at(self, when, callback, *args, context=None)	Like call_later(), but uses an absolute time. _{[extrait de call_at.__doc__]}
call_exception_handler(self, context)	Call the current event loop's exception handler. _{[extrait de call_exception_handler.__doc__]}
call_later(self, delay, callback, *args, context=None)	Arrange for a callback to be called at a given time. _{[extrait de call_later.__doc__]}
call_soon(self, callback, *args, context=None)	Arrange for a callback to be called as soon as possible. _{[extrait de call_soon.__doc__]}
call_soon_threadsafe(self, callback, *args, context=None)	Like call_soon(), but thread-safe. _{[extrait de call_soon_threadsafe.__doc__]}
close(self)	Close the event loop. _{[extrait de close.__doc__]}
connect_accepted_socket(self, protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None, ssl_shutdown_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, ssl_shutdown_timeout=None, happy_eyeballs_delay=None, interleave=None)	Connect to a TCP server. _{[extrait de create_connection.__doc__]}
create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_port=None, allow_broadcast=None, sock=None)	Create datagram connection. _{[extrait de create_datagram_endpoint.__doc__]}
create_future(self)	Create a Future object attached to the loop. _{[extrait de create_future.__doc__]}
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, ssl_shutdown_timeout=None, start_serving=True)	Create a TCP server. _{[extrait de create_server.__doc__]}
create_task(self, coro, *, name=None, context=None)	Schedule a coroutine object. _{[extrait de create_task.__doc__]}
default_exception_handler(self, context)	Default exception handler. _{[extrait de default_exception_handler.__doc__]}
get_debug(self)
get_exception_handler(self)	Return an exception handler, or None if the default one is in use. _{[extrait de get_exception_handler.__doc__]}
get_task_factory(self)	Return a task factory, or None if the default one is in use. _{[extrait de get_task_factory.__doc__]}
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. _{[extrait de is_closed.__doc__]}
is_running(self)	Returns True if the event loop is running. _{[extrait de is_running.__doc__]}
run_forever(self)	Run until stop() is called. _{[extrait de run_forever.__doc__]}
run_in_executor(self, executor, func, *args)
run_until_complete(self, future)	Run until the Future is done. _{[extrait de run_until_complete.__doc__]}
sendfile(self, transport, file, offset=0, count=None, *, fallback=True)	Send a file to transport. _{[extrait de sendfile.__doc__]}
set_debug(self, enabled)
set_default_executor(self, executor)
set_exception_handler(self, handler)	Set handler as the new event loop exception handler. _{[extrait de set_exception_handler.__doc__]}
set_task_factory(self, factory)	Set a task factory that will be used by loop.create_task(). _{[extrait de set_task_factory.__doc__]}
shutdown_asyncgens(self)	Shutdown all active asynchronous generators. _{[extrait de shutdown_asyncgens.__doc__]}
shutdown_default_executor(self)	Schedule the shutdown of the default executor. _{[extrait de shutdown_default_executor.__doc__]}
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, ssl_shutdown_timeout=None)	Upgrade transport to TLS. _{[extrait de start_tls.__doc__]}
stop(self)	Stop running the event loop. _{[extrait de stop.__doc__]}
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. _{[extrait de time.__doc__]}

Méthodes héritées de la classe AbstractEventLoop

__init_subclass__, __subclasshook__, add_reader, add_signal_handler, add_writer, create_unix_connection, create_unix_server, remove_reader, remove_signal_handler, remove_writer, sock_accept, sock_connect, sock_recv, sock_recv_into, sock_recvfrom, sock_recvfrom_into, sock_sendall, sock_sendto