Базовый цикл событий

Исходный код: Lib/asyncio/events.py

Цикл событий является центральным устройством выполнения, предоставляемым asyncio. Он предоставляет множество возможностей, включая:

• Регистрацию, выполнение и отмену отложенных вызовов (таймауты).
• Создание клиентских и серверных транспортов для различных видов коммуникации.
• Запуск дочерних процессов и связанных транспортов для связи с внешней программой.
• Делегирование дорогостоящих вызовов функций пулу потоков.

class asyncio.BaseEventLoop

Этот класс является деталью реализации. Он является подклассом AbstractEventLoop и может быть базовым классом конкретных реализаций циклов событий, найденных в asyncio. Его не следует использовать напрямую; используйте AbstractEventLoop вместо этого. BaseEventLoop не должен наследоваться сторонним кодом; внутренний интерфейс не является стабильным.

class asyncio.AbstractEventLoop

Абстрактный базовый класс циклов событий.

Этот класс не потокобезопасен.

18.5.1.1. Запуск цикла событий

AbstractEventLoop.run_forever()

Запуск до вызова stop(). Если stop() вызван до вызова run_forever(), это опросит селектор ввода-вывода один раз с таймаутом 0, выполнит все вызовы обратного вызова, запланированные в ответ на события ввода-вывода (и те, которые были уже запланированы), а затем завершит работу. Если stop() вызван, когда run_forever() выполняется, это выполнит текущую партию обратных вызовов и затем завершит работу. Обратите внимание, что вызовы обратного вызова, запланированные другими вызовами обратного вызова, не будут выполнены в этом случае; они будут выполнены в следующий раз, когда вызов run_forever() будет выполнен.

Изменено в версии 3.5.1.

AbstractEventLoop.run_until_complete(future)

Запуск до завершения Future.

Если аргумент является объектом корутины, он обертывается ensure_future().

Возвращает результат Future или вызывает его исключение.

AbstractEventLoop.is_running()

Возвращает статус выполнения цикла событий.

AbstractEventLoop.stop()

Остановка цикла событий.

Это заставит run_forever() завершиться в ближайший подходящий момент (см. там больше подробностей).

Изменено в версии 3.5.1.

AbstractEventLoop.is_closed()

Возвращает True если цикл событий был закрыт.

Добавлена в версии 3.4.2.

AbstractEventLoop.close()

Закрытие цикла событий. Цикл не должен быть запущен. Ожидаемые обратные вызовы будут потеряны.

Это очищает очереди и завершает работу исполнителя, но не ждет завершения работы исполнителя.

Это идемпотентно и необратимо. После этого вызова другие методы вызывать нельзя.

coroutine AbstractEventLoop.shutdown_asyncgens()

Планирует закрытие всех текущих открытых объектов асинхронных генераторов с помощью вызова aclose(). После вызова этого метода цикл событий будет выводить предупреждение всякий раз, когда будет итерироваться новый асинхронный генератор. Следует использовать для надежной финализации всех запланированных асинхронных генераторов. Пример:

try:
    loop.run_forever()
finally:
    loop.run_until_complete(loop.shutdown_asyncgens())
    loop.close()

Добавлена в версии 3.6.

18.5.1.2. Вызовы

Большинство функций asyncio не принимают ключевые слова. Если вы хотите передать ключевые слова в ваш обратный вызов, используйте functools.partial(). Например, loop.call_soon(functools.partial(print, "Hello", flush=True)) вызовет print("Hello", flush=True).

AbstractEventLoop.call_soon(callback, *args)

Организовать вызов обратного вызова как можно скорее. Обратный вызов вызывается после возвращения call_soon(), когда управление возвращается в цикл событий.

Работает как очередь FIFO, обратные вызовы вызываются в порядке их регистрации. Каждый обратный вызов будет вызван ровно один раз.

Любые позиционные аргументы после обратного вызова будут переданы обратному вызову при его вызове.

Возвращается экземпляр asyncio.Handle, который можно использовать для отмены обратного вызова.

Используйте functools.partial для передачи ключевых слов в обратный вызов.

AbstractEventLoop.call_soon_threadsafe(callback, *args)

Как call_soon(), но потокобезопасен.

См. раздел конкурентности и многопоточности документации.

18.5.1.3. Отложенные вызовы

Цикл событий имеет собственные внутренние часы для вычисления таймаутов. Какой используется таймер, зависит от (зависимой от платформы) реализации цикла событий; в идеале это монотонные часы. Это, как правило, будут другие часы, чем time.time().

AbstractEventLoop.call_later(delay, callback, *args)

Организовать вызов callback после заданной задержки (в секундах, целое или дробное число).

Возвращается экземпляр asyncio.Handle, который может быть использован для отмены обратного вызова.

callback будет вызван ровно один раз за вызов call_later(). Если два обратных вызова запланированы на одно и то же время, то порядок их вызова не определён.

Дополнительные позиционные args будут переданы обратному вызову при его вызове. Если вы хотите, чтобы обратный вызов был вызван с некоторыми именованными аргументами, используйте замыкание или functools.partial().

Используйте functools.partial для передачи ключевых слов в обратный вызов.

AbstractEventLoop.call_at(when, callback, *args)

Установите вызов callback в заданный абсолютный момент времени when (целое или дробное число), используя ту же систему отсчета времени, что и AbstractEventLoop.time().

Поведение этого метода такое же, как у call_later().

Возвращается экземпляр asyncio.Handle, который можно использовать для отмены обратного вызова.

Использование functools.partial для передачи ключевых аргументов обратного вызова.

AbstractEventLoop.time()

Возвращает текущее время в виде значения float по внутренним часам цикла событий.

18.5.1.4. Futures

AbstractEventLoop.create_future()

Создаёт объект asyncio.Future, привязанный к циклу.

Это предпочтительный способ создания объектов future в asyncio, так как реализации циклов событий могут предоставлять альтернативные реализации класса Future (с лучшей производительностью или инструментировкой).

New in version 3.5.2.

18.5.1.5. Задачи

AbstractEventLoop.create_task(coro)

Планирует выполнение объекта корутины: оборачивает его в future. Возвращает объект Task.

Внедренные циклы событий могут использовать свой собственный подкласс Task для межсовместимости. В этом случае, тип результата является подклассом Task.

Этот метод был добавлен в Python 3.4.2. Используйте функцию async() для поддержки также старых версий Python.

New in version 3.4.2.

AbstractEventLoop.set_task_factory(factory)

Устанавливает фабрику задач, которая будет использоваться методом AbstractEventLoop.create_task().

Если factory равно None, будет установлена по умолчанию фабрика задач.

Если factory является callable, она должна иметь сигнатуру, соответствующую (loop, coro), где loop будет ссылкой на активный цикл событий, а coro — объектом корутины. Вызываемая функция должна возвращать объект, совместимый с asyncio.Future.

New in version 3.4.4.

AbstractEventLoop.get_task_factory()

Возвращает фабрику задач или None, если используется по умолчанию.

New in version 3.4.4.

18.5.1.6. Создание подключений

coroutine AbstractEventLoop.create_connection(protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None)

Создаёт подключение потокового транспорта к заданному интернет-хосту host и порту port: семейство сокетов AF_INET или AF_INET6 в зависимости от host (или family, если указано), тип сокета SOCK_STREAM. protocol_factory должен быть вызываемой функцией, возвращающей экземпляр протокола.

Этот метод является корутиной, которая попытается установить подключение в фоновом режиме. При успехе корутина возвращает пару (transport, protocol).

Хронологический обзор подлежащей операции:

1. Подключение устанавливается, и создаётся транспорт для его представления.
2. protocol_factory вызывается без аргументов и должна вернуть экземпляр протокола.
3. Экземпляр протокола привязывается к транспорту, и вызывается его метод connection_made().
4. Корутина успешно возвращается с парой (transport, protocol).

Созданный транспорт представляет собой двунаправленный поток, реализация которого зависит от реализации.

Примечание

protocol_factory может быть любой вызываемой функцией, а не обязательно классом. Например, если вы хотите использовать предварительно созданный экземпляр протокола, вы можете передать lambda: my_protocol.

Параметры, изменяющие способ создания подключения:

• ssl: если указано и не равно false, создаётся транспорт SSL/TLS (по умолчанию создаётся обычный TCP-транспорт). Если ssl — объект ssl.SSLContext, этот контекст используется для создания транспорта; если ssl равно True, используется контекст с некоторыми неопределёнными настройками по умолчанию.

  См. также

  Учёт соображений безопасности SSL/TLS

• server_hostname, используется только вместе с ssl и устанавливает или переопределяет имя хоста, с которым будет сравниваться сертификат целевого сервера. По умолчанию используется значение аргумента host. Если host пустое, нет значения по умолчанию, и вам нужно передать значение для server_hostname. Если server_hostname является пустой строкой, сопоставление по имени хоста отключено (что представляет собой серьёзную угрозу безопасности, позволяющую атаки "человек посередине").
• family, proto, flags — необязательные семейство адреса, протокол и флаги, которые будут переданы в getaddrinfo() для разрешения host. Если указаны, они должны быть целыми числами из соответствующих констант модуля socket.
• sock, если указано, должно быть существующим, уже подключённым объектом socket.socket, который будет использоваться транспортом. Если sock указано, ни host, port, family, proto, flags и local_addr не должны быть указаны.
• local_addr, если указано, является кортежем (local_host, local_port), используемым для привязки сокета к локальному адресу. local_host и local_port находятся с помощью getaddrinfo(), аналогично host и port.

Изменено в версии 3.5: В Windows с ProactorEventLoop теперь поддерживается SSL/TLS.

См. также

Функция open_connection() может быть использована для получения пары (StreamReader, StreamWriter) вместо протокола.

coroutine AbstractEventLoop.create_datagram_endpoint(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)

Примечание

Параметр reuse_address больше не поддерживается, так как использование SO_REUSEADDR представляет собой значительную угрозу безопасности для UDP. Явное указание reuse_address=True приведет к исключению.

Когда несколько процессов с различными идентификаторами пользователей назначают сокеты одинаковому адресу UDP-соккета с SO_REUSEADDR, входящие пакеты могут случайным образом распределяться между сокетами.

На поддерживаемых платформах параметр reuse_port может использоваться как замена для аналогичной функциональности. С параметром reuse_port используется SO_REUSEPORT, что специально предотвращает назначение сокетов процессами с разными идентификаторами пользователям одному и тому же адресу сокета.

Создать соединение дейтаграммы.

Создать соединение дейтаграммы: семейство сокетов AF_INET или AF_INET6 в зависимости от host (или family, если указано), тип сокета SOCK_DGRAM. protocol_factory должен быть вызываемым объектом, возвращающим экземпляр протокола.

Этот метод является корутиной, которая будет пытаться установить соединение в фоновом режиме. При успехе корутина возвращает пару (transport, protocol).

Параметры, изменяющие способ создания соединения:

• Если указан параметр local_addr, он представляет собой кортеж (local_host, local_port), используемый для привязки сокета к локальному адресу. local_host и local_port ищутся с помощью getaddrinfo().
• Если указан параметр remote_addr, он представляет собой кортеж (remote_host, remote_port), используемый для подключения сокета к удалённому адресу. remote_host и remote_port ищутся с помощью getaddrinfo().
• family, proto, flags — необязательные семейство адреса, протокол и флаги, которые передаются в getaddrinfo() для разрешения host. Если заданы, все они должны быть целыми числами, соответствующими константам модуля socket.
• reuse_port сообщает ядру, что этот конечный пункт может быть привязан к тому же порту, что и другие существующие конечные пункты, при условии, что все они установят этот флаг при создании. Этот параметр не поддерживается в Windows и некоторых UNIX-системах. Если константа SO_REUSEPORT не определена, эта возможность не поддерживается.
• allow_broadcast сообщает ядру, что этот конечный пункт может отправлять сообщения на адрес широковещательной рассылки.
• sock может быть указан для использования существующего уже подключённого объекта socket.socket. Если указан, local_addr и remote_addr должны быть опушены (должны быть None).

В Windows с ProactorEventLoop этот метод не поддерживается.

См. примеры протокола UDP-эхо-клиента и протокола UDP-эхо-сервера.

Изменено в версии 3.4.4: Были добавлены параметры family, proto, flags, reuse_address, reuse_port, *allow_broadcast и sock.

Изменено в версии 3.6.10: Параметр reuse_address больше не поддерживается из-за проблем с безопасностью

coroutine AbstractEventLoop.create_unix_connection(protocol_factory, path, *, ssl=None, sock=None, server_hostname=None)

Создать соединение по UNIX-сокету: семейство сокетов AF_UNIX, тип сокета SOCK_STREAM. Семейство сокетов AF_UNIX используется для эффективной связи между процессами на одной машине.

Этот метод является корутиной, которая будет пытаться установить соединение в фоновом режиме. При успехе корутина возвращает пару (transport, protocol).

path — имя UNIX-соккета, и требуется, если не указан параметр sock. Поддерживаются пути к абстрактным UNIX-сокетнам, str и bytes.

См. метод AbstractEventLoop.create_connection() для параметров.

Доступность: UNIX.

18.5.1.7. Создание прослушивающих соединений

coroutine AbstractEventLoop.create_server(protocol_factory, host=None, port=None, *, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None)

Создать TCP-сервер (тип сокета SOCK_STREAM) привязанный к host и port.

Возвращает объект Server, его атрибут sockets содержит созданные сокеты. Используйте метод Server.close() для остановки сервера: закрытие прослушивающих сокетов.

Параметры:

• Параметр host может быть строкой, в этом случае TCP-сервер привязывается к host и port. Параметр host также может быть последовательностью строк, в этом случае TCP-сервер привязывается ко всем хостам из последовательности. Если host — пустая строка или None, предполагаются все интерфейсы, и будет возвращён список нескольких сокетов (вероятно, один для IPv4 и другой для IPv6).
• family может быть установлен либо в socket.AF_INET, либо в AF_INET6 для принудительного использования IPv4 или IPv6. Если не задано, оно будет определено из host (по умолчанию socket.AF_UNSPEC).
• flags — битовая маска для getaddrinfo().
• sock может быть необязательно указан для использования существующего сокета. Если указан, host и port должны быть опущены (должны быть None).
• backlog — максимальное количество подключений в очереди, передаваемое в listen() (по умолчанию 100).
• ssl может быть установлен в SSLContext для включения SSL для принимаемых соединений.
• reuse_address сообщает ядру о повторном использовании локального сокета в состоянии TIME_WAIT без ожидания его естественного таймаута. Если не указано, автоматически устанавливается в True на UNIX.
• reuse_port сообщает ядру, что этот конечный пункт может быть привязан к тому же порту, что и другие существующие конечные пункты, при условии, что все они установят этот флаг при создании. Эта опция не поддерживается в Windows.

Этот метод является корутиной.

Изменено в версии 3.5: В Windows с ProactorEventLoop теперь поддерживается SSL/TLS.

См. также

Функция start_server() создаёт пару (StreamReader, StreamWriter) и вызывает функцию с этой парой.

Изменено в версии 3.5.1: Параметр host теперь может быть последовательностью строк.

coroutine AbstractEventLoop.create_unix_server(protocol_factory, path=None, *, sock=None, backlog=100, ssl=None)

Аналогично AbstractEventLoop.create_server(), но специфично для семейства сокетов AF_UNIX.

Этот метод является корутиной.

Доступность: UNIX.

coroutine BaseEventLoop.connect_accepted_socket(protocol_factory, sock, *, ssl=None)

Обработка принятого соединения.

Используется серверами, которые принимают подключения вне asyncio, но используют asyncio для их обработки.

Параметры:

• sock — существующий объект сокета, возвращённый методом accept.
• ssl может быть установлен в SSLContext для включения SSL для принятых соединений.

Этот метод является корутиной. По завершении корутина возвращает пару (transport, protocol).

Добавлена в версии 3.5.3.

18.5.1.8. Отслеживание дескрипторов файлов

В Windows с SelectorEventLoop поддерживаются только сокеты (например, дескрипторы файлов каналов не поддерживаются).

В Windows с ProactorEventLoop эти методы не поддерживаются.

AbstractEventLoop.add_reader(fd, callback, *args)

Начинает отслеживание дескриптора файла на доступность для чтения и затем вызывает callback со заданными аргументами.

Используйте functools.partial для передачи ключевых слов в обратный вызов.

AbstractEventLoop.remove_reader(fd)

Прекращает отслеживание дескриптора файла на доступность для чтения.

AbstractEventLoop.add_writer(fd, callback, *args)

Начинает отслеживание дескриптора файла на доступность для записи и затем вызывает callback со заданными аргументами.

Используйте functools.partial для передачи ключевых слов в обратный вызов.

AbstractEventLoop.remove_writer(fd)

Прекращает отслеживание дескриптора файла на доступность для записи.

Пример отслеживания дескриптора файла на события чтения использует низкоуровневый метод AbstractEventLoop.add_reader() для регистрации дескриптора файла сокета.

18.5.1.9. Низкоуровневые операции с сокетами

coroutine AbstractEventLoop.sock_recv(sock, nbytes)

Получение данных из сокета. Моделируется по образцу блокирующего метода socket.socket.recv().

Значение возврата — объект bytes, представляющий полученные данные. Максимальное количество данных, получаемых за один раз, задаётся параметром nbytes.

С SelectorEventLoop циклом событий сокет sock должен быть неблокирующим.

Этот метод является корутиной.

coroutine AbstractEventLoop.sock_sendall(sock, data)

Отправка данных по сокету. Моделируется по образцу блокирующего метода socket.socket.sendall().

Сокет должен быть подключен к удалённому сокету. Этот метод продолжает отправлять данные из data, пока все данные не будут отправлены или не произойдёт ошибка. В случае успеха возвращается None. При ошибке генерируется исключение, и нет способа определить, сколько данных, если таковые имеются, было успешно обработано принимающей стороной соединения.

С SelectorEventLoop циклом событий сокет sock должен быть неблокирующим.

Этот метод является корутиной.

coroutine AbstractEventLoop.sock_connect(sock, address)

Подключение к удалённому сокету по адресу address. Моделируется по образцу блокирующего метода socket.socket.connect().

С SelectorEventLoop циклом событий сокет sock должен быть неблокирующим.

Этот метод является корутиной.

Изменено в версии 3.5.2: address больше не нужно разрешать. sock_connect будет пытаться проверить, уже ли разрешен адрес, вызвав socket.inet_pton(). Если нет, будет использован AbstractEventLoop.getaddrinfo() для разрешения адреса.

См. также

AbstractEventLoop.create_connection() и asyncio.open_connection().

coroutine AbstractEventLoop.sock_accept(sock)

Принятие соединения. Моделируется по образцу блокирующего метода socket.socket.accept().

Сокет должен быть привязан к адресу и ожидать подключений. Значение возврата — пара (conn, address), где conn — новый объект сокета, используемый для отправки и получения данных по соединению, а address — адрес, привязанный к сокету на другом конце соединения.

Сокет sock должен быть неблокирующим.

Этот метод является корутиной.

См. также

AbstractEventLoop.create_server() и start_server().

18.5.1.10. Разрешение имени хоста

coroutine AbstractEventLoop.getaddrinfo(host, port, *, family=0, type=0, proto=0, flags=0)

Этот метод является корутиной, похожей на функцию socket.getaddrinfo(), но неблокирующей.

coroutine AbstractEventLoop.getnameinfo(sockaddr, flags=0)

Этот метод является корутиной, похожей на функцию socket.getnameinfo(), но неблокирующей.

18.5.1.11. Подключение к каналам

В Windows с SelectorEventLoop эти методы не поддерживаются. Используйте ProactorEventLoop для поддержки каналов в Windows.

coroutine AbstractEventLoop.connect_read_pipe(protocol_factory, pipe)

Регистрация канала на чтение в цикле событий.

protocol_factory должен создавать объекты с интерфейсом Protocol. pipe — это объект типа файл. Возвращается пара (transport, protocol), где transport поддерживает интерфейс ReadTransport.

С SelectorEventLoop циклом событий pipe устанавливается в режим «неблокирующий».

Этот метод является корутиной.

coroutine AbstractEventLoop.connect_write_pipe(protocol_factory, pipe)

Регистрация канала на запись в цикле событий.

protocol_factory должен создавать объекты с интерфейсом BaseProtocol. pipe — объект типа файл. Возвращается пара (transport, protocol), где transport поддерживает интерфейс WriteTransport.

С SelectorEventLoop циклом событий pipe устанавливается в режим «неблокирующий».

Этот метод является корутиной.

18.5.1.12. Сигналы UNIX

Доступность: только UNIX.

AbstractEventLoop.add_signal_handler(signum, callback, *args)

Добавить обработчик сигнала.

Вызовите ValueError, если номер сигнала некорректен или неперехватывается. Вызовите RuntimeError, если возникла проблема при настройке обработчика.

Используйте functools.partial для передачи ключевых аргументов в обратный вызов.

AbstractEventLoop.remove_signal_handler(sig)

Удалить обработчик сигнала.

Возвращает True если обработчик сигнала был удален, False если нет.

18.5.1.13. Исполнитель

Вызов функции в Executor (пул потоков или пул процессов). По умолчанию цикл событий использует исполнитель пула потоков (ThreadPoolExecutor).

coroutine AbstractEventLoop.run_in_executor(executor, func, *args)

Организовать вызов func в указанном исполнителе.

Аргумент executor должен быть экземпляром Executor. Используется исполнитель по умолчанию, если executor равен None.

Используйте functools.partial для передачи ключевых аргументов в *func*.

Этот метод является генератором.

Изменено в версии 3.5.3: BaseEventLoop.run_in_executor() больше не настраивает max_workers исполнителя пула потоков, вместо этого оставляя это за исполнителем пула потоков (ThreadPoolExecutor) для установки значения по умолчанию.

AbstractEventLoop.set_default_executor(executor)

Установить исполнитель по умолчанию, используемый методом run_in_executor().

18.5.1.14. API обработки ошибок

Позволяет настроить обработку исключений в цикле событий.

AbstractEventLoop.set_exception_handler(handler)

Установить handler в качестве нового обработчика исключений цикла событий.

Если handler равен None, будет установлен обработчик исключений по умолчанию.

Если handler — вызываемый объект, он должен иметь соответствующую сигнатуру (loop, context), где loop будет ссылкой на активный цикл событий, context будет объектом dict (см. документацию к call_exception_handler() для подробностей о контексте).

AbstractEventLoop.get_exception_handler()

Возвращает обработчик исключений или None если используется обработчик по умолчанию.

Добавлена в версии 3.5.2.

AbstractEventLoop.default_exception_handler(context)

Обработчик исключений по умолчанию.

Вызывается при возникновении исключения, если обработчик исключений не задан, и может быть вызван пользовательским обработчиком исключений, который хочет использовать поведение по умолчанию.

Параметр context имеет то же значение, что и в call_exception_handler().

AbstractEventLoop.call_exception_handler(context)

Вызвать текущий обработчик исключений цикла событий.

context — это объект dict содержащий следующие ключи (в дальнейшем могут быть добавлены новые ключи):

• ‘message’: Сообщение об ошибке;
• ‘exception’ (необязательно): Объект исключения;
• ‘future’ (необязательно): экземпляр asyncio.Future;
• ‘handle’ (необязательно): экземпляр asyncio.Handle;
• ‘protocol’ (необязательно): экземпляр Протокол;
• ‘transport’ (необязательно): экземпляр Транспорт;
• ‘socket’ (необязательно): экземпляр socket.socket.

Примечание

Примечание: этот метод не должен перезаписываться в подклассах циклов событий. Для любой пользовательской обработки исключений используйте метод set_exception_handler().

18.5.1.15. Режим отладки

AbstractEventLoop.get_debug()

Получить режим отладки (bool) цикла событий.

Значение по умолчанию равно True если переменная среды PYTHONASYNCIODEBUG установлена в непустую строку, False в противном случае.

Добавлена в версии 3.4.2.

AbstractEventLoop.set_debug(enabled: bool)

Установить режим отладки цикла событий.

Добавлена в версии 3.4.2.

18.5.1.16. Сервер

class asyncio.Server

Сервер, прослушивающий сокеты.

Объект, созданный методом AbstractEventLoop.create_server() и функцией start_server(). Не следует создавать экземпляры класса напрямую.

close()

Остановить обслуживание: закрыть сокеты прослушивания и установить атрибут sockets в None.

Сокеты, представляющие существующие входящие подключения клиентов, остаются открытыми.

Сервер закрывается асинхронно, используйте генератор wait_closed() для ожидания закрытия сервера.

coroutine wait_closed()

Подождать завершения метода close().

Этот метод является генератором.

sockets

Список объектов socket.socket, на которых сервер прослушивает, или None если сервер закрыт.

18.5.1.17. Обработчик

class asyncio.Handle

Объект-оболочка обратного вызова, возвращаемый методами AbstractEventLoop.call_soon(), AbstractEventLoop.call_soon_threadsafe(), AbstractEventLoop.call_later() и AbstractEventLoop.call_at().

cancel()

Отменить вызов. Если обратный вызов уже отменён или выполнен, этот метод не оказывает никакого эффекта.

18.5.1.18. Примеры циклов событий

18.5.1.18.1. Привет, мир с call_soon()

Пример использования метода AbstractEventLoop.call_soon() для планирования обратного вызова. Обратный вызов отображает "Hello World" и затем останавливает цикл событий:

import asyncio

def hello_world(loop):
    print('Hello World')
    loop.stop()

loop = asyncio.get_event_loop()

# Schedule a call to hello_world()
loop.call_soon(hello_world, loop)

# Blocking call interrupted by loop.stop()
loop.run_forever()
loop.close()

18.5.1.18.2. Отображение текущей даты с помощью call_later()

Пример обратного вызова, отображающего текущую дату каждую секунду. Обратный вызов использует метод AbstractEventLoop.call_later() для повторного планирования себя через 5 секунд, а затем останавливает цикл событий:

import asyncio
import datetime

def display_date(end_time, loop):
    print(datetime.datetime.now())
    if (loop.time() + 1.0) < end_time:
        loop.call_later(1, display_date, end_time, loop)
    else:
        loop.stop()

loop = asyncio.get_event_loop()

# Schedule the first call to display_date()
end_time = loop.time() + 5.0
loop.call_soon(display_date, end_time, loop)

# Blocking call interrupted by loop.stop()
loop.run_forever()
loop.close()

18.5.1.18.3. Отслеживание события чтения файла

Ожидание, пока дескриптор файла получит данные с помощью метода AbstractEventLoop.add_reader(), а затем закрытие цикла событий:

import asyncio
try:
    from socket import socketpair
except ImportError:
    from asyncio.windows_utils import socketpair

# Create a pair of connected file descriptors
rsock, wsock = socketpair()
loop = asyncio.get_event_loop()

def reader():
    data = rsock.recv(100)
    print("Received:", data.decode())
    # We are done: unregister the file descriptor
    loop.remove_reader(rsock)
    # Stop the event loop
    loop.stop()

# Register the file descriptor for read event
loop.add_reader(rsock, reader)

# Simulate the reception of data from the network
loop.call_soon(wsock.send, 'abc'.encode())

# Run the event loop
loop.run_forever()

# We are done, close sockets and the event loop
rsock.close()
wsock.close()
loop.close()

18.5.1.18.4. Установка обработчиков сигналов для SIGINT и SIGTERM

Регистрация обработчиков для сигналов SIGINT и SIGTERM с помощью метода AbstractEventLoop.add_signal_handler():

import asyncio
import functools
import os
import signal

def ask_exit(signame):
    print("got signal %s: exit" % signame)
    loop.stop()

loop = asyncio.get_event_loop()
for signame in ('SIGINT', 'SIGTERM'):
    loop.add_signal_handler(getattr(signal, signame),
                            functools.partial(ask_exit, signame))

print("Event loop running forever, press Ctrl+C to interrupt.")
print("pid %s: send SIGINT or SIGTERM to exit." % os.getpid())
try:
    loop.run_forever()
finally:
    loop.close()

Этот пример работает только на UNIX.