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

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

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

• Регистрация, выполнение и отмена отложенных вызовов (тайм-аутов).

• Создание клиентских и серверных транспортов для различных видов взаимодействия.

• Запуск подпроцессов и связанных транспортов для взаимодействия с внешней программой.

• Делегирование дорогостоящих вызовов функций пулу потоков.

classasyncio.BaseEventLoop¶

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

classasyncio.AbstractEventLoop¶

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

Этот класс является не потокобезопасным.

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

AbstractEventLoop.run_forever()¶

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

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

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

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

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

Примечание

functools.partial() лучше, чем функции lambda, потому что asyncio может инспектировать объект functools.partial() для отображения параметров в режиме отладки, в то время как функции lambda имеют плохое представление.

AbstractEventLoop.call_soon(колбэк, *args)¶

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

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

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

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

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

AbstractEventLoop.call_soon_threadsafe(колбэк, *args)¶

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

Смотрите раздел concurrency and multithreading документации.

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

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

Примечание

Таймауты (относительная задержка или абсолютное время) не должны превышать одного дня.

AbstractEventLoop.call_later(delay, колбэк, *args)¶

Организует вызов колбэка через указанное количество секунд задержки (целое число или число с плавающей запятой).

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

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

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

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

AbstractEventLoop.call_at(when, колбэк, *args)¶

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

Поведение этого метода аналогично call_later().

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

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

AbstractEventLoop.time()¶

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

Смотрите также

Функция asyncio.sleep().

18.5.1.4. Future

AbstractEventLoop.create_future()¶

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

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

Новое в версии 3.5.2.

18.5.1.5. Задачи

AbstractEventLoop.create_task(coro)¶

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

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

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

Новое в версии 3.4.2.

AbstractEventLoop.set_task_factory(фабрика)¶

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

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

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

Новое в версии 3.4.4.

AbstractEventLoop.get_task_factory()¶

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

Новое в версии 3.4.4.

18.5.1.6. Создание соединений

coroutineAbstractEventLoop.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) вместо протокола.

coroutineAbstractEventLoop.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 вызовет исключение.

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

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

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

Создаёт датаграммное соединение: семейство сокетов AF_INET или AF_INET6 в зависимости от хоста (или 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 больше не поддерживается из соображений безопасности.

coroutineAbstractEventLoop.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. Создание прослушивающих соединений

coroutineAbstractEventLoop.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), привязанный к хосту и порту.

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

Параметры:

• Параметр host может быть строкой, в этом случае TCP-сервер привязывается к хосту и порту. Параметр host также может быть последовательностью строк, и в этом случае TCP-сервер привязывается ко всем хостам из последовательности. Если host – пустая строка или None, предполагаются все интерфейсы, и будет возвращён список из нескольких сокетов (скорее всего, один для IPv4 и другой для IPv6).

• family может быть установлен в socket.AF_INET или AF_INET6, чтобы принудительно использовать IPv4 или IPv6. Если не установлен, он определяется из хоста (по умолчанию 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 теперь может быть последовательностью строк.

coroutineAbstractEventLoop.create_unix_server(protocol_factory, path=None, *, sock=None, backlog=100, ssl=None)¶

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

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

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

coroutineBaseEventLoop.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, колбэк, *args)¶

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

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

AbstractEventLoop.remove_reader(fd)¶

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

AbstractEventLoop.add_writer(fd, колбэк, *args)¶

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

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

AbstractEventLoop.remove_writer(fd)¶

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

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

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

coroutineAbstractEventLoop.sock_recv(sock, nbytes)¶

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

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

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

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

coroutineAbstractEventLoop.sock_sendall(sock, data)¶

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

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

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

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

coroutineAbstractEventLoop.sock_connect(sock, address)¶

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

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

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

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

Смотрите также

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

coroutineAbstractEventLoop.sock_accept(sock)¶

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

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

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

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

Смотрите также

AbstractEventLoop.create_server() и start_server().

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

coroutineAbstractEventLoop.getaddrinfo(host, port, *, family=0, type=0, proto=0, flags=0)¶

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

coroutineAbstractEventLoop.getnameinfo(sockaddr, flags=0)¶

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

18.5.1.11. Подключить каналы

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

coroutineAbstractEventLoop.connect_read_pipe(protocol_factory, pipe)¶

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

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

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

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

coroutineAbstractEventLoop.connect_write_pipe(protocol_factory, pipe)¶

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

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

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

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

Смотрите также

Методы AbstractEventLoop.subprocess_exec() и AbstractEventLoop.subprocess_shell().

18.5.1.12. Сигналы UNIX

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

AbstractEventLoop.add_signal_handler(signum, колбэк, *args)¶

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

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

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

AbstractEventLoop.remove_signal_handler(sig)¶

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

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

Смотрите также

Модуль signal.

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

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

coroutineAbstractEventLoop.run_in_executor(исполнитель, func, *args)¶

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

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

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

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

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

AbstractEventLoop.set_default_executor(исполнитель)¶

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

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

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

AbstractEventLoop.set_exception_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 имеет то же значение, что и в call_exception_handler().

AbstractEventLoop.call_exception_handler(контекст)¶

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

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

• ‘message’: сообщение об ошибке;

• 'исключение' (опционально): объект исключения;

• ‘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.

Смотрите также

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

18.5.1.16. Сервер

classasyncio.Server¶

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

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

close()¶

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

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

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

coroutinewait_closed()¶

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

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

sockets¶

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

18.5.1.17. Handle

classasyncio.Handle¶

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

cancel()¶

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

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

18.5.1.18.1. Hello World с помощью call_soon()

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

import asyncio

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

loop = asyncio.get_event_loop()

# Запланировать вызов hello_world()
loop.call_soon(hello_world, loop)

# Блокирующий вызов, прерванный loop.stop()
loop.run_forever()
loop.close()

Смотрите также

Пример корутины Hello World использует корутину.

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

# Запланировать первый вызов display_date()
end_time = loop.time() + 5.0
loop.call_soon(display_date, end_time, loop)

# Блокирующий вызов, прерванный 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

# Создать пару связанных файловых дескрипторов
rsock, wsock = socketpair()
loop = asyncio.get_event_loop()

def reader():
    data = rsock.recv(100)
    print("Received:", data.decode())
    # Мы закончили: отменить регистрацию файлового дескриптора
    loop.remove_reader(rsock)
    # Остановить цикл событий
    loop.stop()

# Зарегистрировать файловый дескриптор для события чтения
loop.add_reader(rsock, reader)

# Симулировать приём данных из сети
loop.call_soon(wsock.send, 'abc'.encode())

# Запустить цикл событий
loop.run_forever()

# Мы закончили, закрываем сокеты и цикл событий
rsock.close()
wsock.close()
loop.close()

Смотрите также

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

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

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.