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

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

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

class asyncio.BaseEventLoop

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

class asyncio.AbstractEventLoop

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

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

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

AbstractEventLoop.run_forever()

Запуск до вызова stop(). Если stop() вызывается до вызова run_forever(), это опрашивает селектор ввода-вывода один раз с таймаутом ноль, выполняет все обратные вызовы, запланированные в ответ на события ввода-вывода (и те, которые уже были запланированы), а затем завершается. Если 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()

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

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

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

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(), но потокобезопасный.

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

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

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

AbstractEventLoop.call_later(delay, callback, *args)

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

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

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

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

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

AbstractEventLoop.call_at(when, callback, *args)

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

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

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

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

AbstractEventLoop.time()

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

4. Будущие

AbstractEventLoop.create_future()

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

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

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

5. Задачи

AbstractEventLoop.create_task(coro)

Запланировать выполнение объекта корутины: обернуть его в объект Future. Возвращает объект Task.

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

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

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

AbstractEventLoop.set_task_factory(factory)

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

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

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

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

AbstractEventLoop.get_task_factory()

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

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

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)

Создать соединение транспортного потока с заданным Интернет-хостом и портом: семейство сокетов AF_INET или AF_INET6 в зависимости от хоста (или 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)

Установить соединение дейтаграм: семейство сокета 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_address сообщает ядру использовать локальный сокет в состоянии TIME_WAIT без ожидания его естественного таймаута. Если не указано, автоматически устанавливается в True на UNIX.
• reuse_port сообщает ядру разрешить этому конечной точке привязку к тому же порту, что и к другим существующим конечным точкам, если все они устанавливают этот флаг при создании. Этот параметр не поддерживается на Windows и некоторых UNIX-системах. Если константа SO_REUSEPORT не определена, эта возможность не поддерживается.
• allow_broadcast сообщает ядру разрешить этой конечной точке отправлять сообщения на адрес широковещательной рассылки.
• sock — необязательно, может быть указан для использования предварительно существующего и уже подключенного объекта socket.socket, который будет использоваться транспортом. Если указано, local_addr и remote_addr должны быть пропущены (должны быть None).

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

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

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.

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/TLS для принимаемых соединений.
• 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/TLS для принимаемых соединений.

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

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

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

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

AbstractEventLoop.add_reader(fd, callback, *args)

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

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

AbstractEventLoop.remove_reader(fd)

Остановить наблюдение за дескриптором файла на доступность для чтения.

AbstractEventLoop.add_writer(fd, callback, *args)

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

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

AbstractEventLoop.remove_writer(fd)

Остановить наблюдение за дескриптором файла на доступность для записи.

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

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().

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

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

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

coroutine AbstractEventLoop.getnameinfo(sockaddr, flags=0)

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

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 устанавливается в неблокирующий режим.

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

12. Сигналы UNIX

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

AbstractEventLoop.add_signal_handler(signum, callback, *args)

Добавление обработчика для сигнала.

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

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

AbstractEventLoop.remove_signal_handler(sig)

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

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

13. Executor

Вызовите функцию в 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().

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().

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

AbstractEventLoop.get_debug()

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

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

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

AbstractEventLoop.set_debug(enabled: bool)

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

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

16. Сервер

class asyncio.Server

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

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

close()

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

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

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

coroutine wait_closed()

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

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

sockets

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

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

class asyncio.Handle

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

cancel()

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

18. Примеры цикла событий

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.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.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.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-подобных системах.