Корутины и задачи¶Coroutines and Tasks

Корутины¶Coroutines

Корутины, объявленные с помощью синтаксиса async/await, являются предпочтительным способом написания приложений asyncio. Например, следующий фрагмент кода выводит «hello», ждёт 1 секунду, а затем выводит «world»:

>>> import asyncio

>>> async def main():
...     print('hello')
...     await asyncio.sleep(1)
...     print('world')

>>> asyncio.run(main())
hello
world

Обратите внимание, что простой вызов корутины не запланирует её выполнение:

>>> main()
<coroutine object main at 0x1053bb7c8>

Для фактического запуска корутины asyncio предоставляет три основных механизма:

• Функция asyncio.run() для запуска точки входа верхнего уровня – функции «main()» (см. пример выше.)

• Ожидание корутины. Следующий фрагмент кода выведет «hello» после ожидания в 1 секунду, а затем выведет «world» после ожидания ещё 2 секунд:

  import asyncio
  import time
  
  async def say_after(delay, what):
      await asyncio.sleep(delay)
      print(what)
  
  async def main():
      print(f"started at {time.strftime('%X')}")
  
      await say_after(1, 'hello')
      await say_after(2, 'world')
  
      print(f"finished at {time.strftime('%X')}")
  
  asyncio.run(main())
  

  Ожидаемый вывод:

  started at 17:13:52
  hello
  world
  finished at 17:13:55
  

• Функция asyncio.create_task() для параллельного запуска корутин в качестве asyncio Tasks.

  Давайте изменим пример выше и запустим две say_after корутины параллельно:

  async def main():
      task1 = asyncio.create_task(
          say_after(1, 'hello'))
  
      task2 = asyncio.create_task(
          say_after(2, 'world'))
  
      print(f"started at {time.strftime('%X')}")
  
      # Ожидать завершения обеих задач (должно занять
      # около 2 секунд).
      await task1
      await task2
  
      print(f"finished at {time.strftime('%X')}")
  

  Обратите внимание, что ожидаемый вывод теперь показывает, что фрагмент выполняется на 1 секунду быстрее, чем раньше:

  started at 17:14:32
  hello
  world
  finished at 17:14:34
  

Ожидаемые объекты¶Awaitables

Говорят, что объект является ожидаемым объектом, если его можно использовать в выражении await. Многие API asyncio предназначены для принятия ожидаемых объектов.

Существует три основных типа ожидаемых объектов: корутины, задачи и future.

Корутины

Корутины Python являются ожидаемыми объектами, а значит, их можно ожидать из других корутин:

import asyncio

async def nested():
    return 42

async def main():
    # Если просто вызвать "nested()", ничего не произойдет.
    # Создается объект корутины, но он не ожидается,
    # поэтому он *вообще не выполнится*.
    nested()

    # Давайте поступим иначе и теперь ожидаем его:
    print(await nested())  # выведет "42".

asyncio.run(main())

asyncio также поддерживает устаревшие корутины на основе генераторов.

Задачи

Задачи используются для планирования корутин параллельно.

Когда корутина обёрнута в задачу с помощью таких функций, как asyncio.create_task(), корутина автоматически планируется к скорому выполнению:

import asyncio

async def nested():
    return 42

async def main():
    # Запланировать выполнение nested() вскоре конкурентно
    # с "main()".
    task = asyncio.create_task(nested())

    # "задача" теперь можно использовать для отмены "nested()" или
    # можно просто применить await, чтобы дождаться завершения:
    await task

asyncio.run(main())

Future

Future – это специальный низкоуровневый ожидаемый объект, который представляет конечный результат асинхронной операции.

Когда объект Future ожидается, это означает, что корутина будет ожидать, пока Future не будет разрешён в каком-то другом месте.

Объекты Future в asyncio необходимы для того, чтобы код, основанный на колбэках, мог использоваться с async/await.

Обычно нет необходимости создавать объекты Future в коде уровня приложения.

Объекты Future, иногда предоставляемые библиотеками и некоторыми API asyncio, можно ожидать (await):

async def main():
    await function_that_returns_a_future_object()

    # это также допустимо:
    await asyncio.gather(
        function_that_returns_a_future_object(),
        some_python_coroutine()
    )

Хороший пример низкоуровневой функции, возвращающей объект Future – loop.run_in_executor().

Запуск программы asyncio¶Running an asyncio Program

asyncio.run(coro, *, debug=False)¶

Выполняет корутину coro и возвращает результат.

Эта функция выполняет переданную корутину, беря на себя управление циклом событий asyncio, завершение асинхронных генераторов и закрытие пула потоков.

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

Если debug равно True, цикл событий будет запущен в режиме отладки.

Эта функция всегда создаёт новый цикл событий и закрывает его в конце. Её следует использовать в качестве главной точки входа для программ asyncio, и в идеале она должна вызываться только один раз.

Пример:

async def main():
    await asyncio.sleep(1)
    print('hello')

asyncio.run(main())

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

Изменено в версии 3.9: Обновлено для использования loop.shutdown_default_executor().

Примечание

Исходный код asyncio.run() можно найти в\nLib/asyncio/runners.py.

Создание задач¶Creating Tasks

asyncio.create_task(coro, *, name=None)¶

Wrap the coro coroutine into a Task and schedule its execution. Return the Task object.

Если name не равен None, он устанавливается как имя задачи с помощью Task.set_name().

Задача выполняется в цикле, возвращаемом get_running_loop(); RuntimeError возбуждается, если в текущем потоке нет запущенного цикла.

Важно

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

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

Изменено в версии 3.8: Добавлен параметр name.

Ожидание¶Sleeping

coroutine asyncio.sleep(delay, result=None, *, loop=None)¶

Приостанавливает выполнение на delay секунд.

Если result указан, он возвращается вызывающей стороне после завершения корутины.

sleep() всегда приостанавливает текущую задачу, позволяя выполняться другим задачам.

Установка задержки в 0 обеспечивает оптимизированный путь, позволяющий выполняться другим задачам. Это может использоваться длительными функциями, чтобы избежать блокировки цикла событий на всё время вызова функции.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Пример корутины, выводящей текущую дату каждую секунду в течение 5 секунд:

import asyncio
import datetime

async def display_date():
    loop = asyncio.get_running_loop()
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        await asyncio.sleep(1)

asyncio.run(display_date())

Одновременный запуск задач¶Running Tasks Concurrently

awaitable asyncio.gather(*aws, loop=None, return_exceptions=False)¶

Выполняет ожидаемые объекты из последовательности aws одновременно.

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

Если все ожидаемые объекты завершены успешно, результатом является сводный список возвращённых значений. Порядок значений результата соответствует порядку ожидаемых объектов в aws.

Если return_exceptions равно False (по умолчанию), первое возбуждённое исключение немедленно распространяется на задачу, ожидающую gather(). Остальные ожидаемые объекты в последовательности aws не будут отменены и продолжат выполнение.

Если return_exceptions равно True, исключения обрабатываются так же, как успешные результаты, и объединяются в списке результатов.

Если gather() отменён, все переданные ожидаемые объекты (которые ещё не завершились) также отменяются.

Если любая задача или Future из последовательности aws отменена, это рассматривается так, как если бы она возбудила CancelledError – вызов gather() в этом случае не отменяется. Это сделано для предотвращения ситуации, когда отмена одной переданной задачи или Future приводит к отмене других задач или Future.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Пример:

import asyncio

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({number}), currently i={i}...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")
    return f

async def main():
    # Запланировать три вызова *конкурентно*:
    L = await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )
    print(L)

asyncio.run(main())

# Ожидаемый вывод:
#
#     Задача A: вычисление factorial(2), сейчас i=2...
#     Задача B: вычисление factorial(3), сейчас i=2...
#     Задача C: вычисление factorial(4), сейчас i=2...
#     Задача A: factorial(2) = 2
#     Задача B: вычисление factorial(3), сейчас i=3...
#     Задача C: вычисление factorial(4), сейчас i=3...
#     Задача B: factorial(3) = 6
#     Задача C: вычисление factorial(4), сейчас i=4...
#     Задача C: factorial(4) = 24
#     [2, 6, 24]

Примечание

Если return_exceptions равно False, отмена gather() после того, как он был помечен как завершённый, не отменит ни один из переданных ожидаемых объектов. Например, gather может быть помечен как завершённый после распространения исключения вызывающему коду; следовательно, вызов gather.cancel() после перехвата исключения (возбуждённого одним из ожидаемых объектов) из gather не отменит другие ожидаемые объекты.

Изменено в версии 3.7: Если сам gather отменён, отмена распространяется независимо от return_exceptions.

Защита от отмены¶Shielding From Cancellation

awaitable asyncio.shield(aw, *, loop=None)¶

Защищает ожидаемый объект от cancelled.

Если aw является корутиной, она автоматически планируется как задача.

Выражение:

res = await shield(something())

эквивалентно:

res = await something()

За исключением того, что если содержащая его корутина отменяется, задача, выполняющаяся в something(), не отменяется. С точки зрения something() отмена не произошла. Хотя её вызывающий код всё ещё отменён, поэтому выражение «await» по-прежнему возбуждает CancelledError.

Если something() отменяется другими средствами (т.е. изнутри самой себя), это также отменит shield().

Если требуется полностью игнорировать отмену (не рекомендуется), функцию shield() следует комбинировать с конструкцией try/except следующим образом:

try:
    res = await shield(something())
except CancelledError:
    res = None

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Тайм-ауты¶Timeouts

coroutine asyncio.wait_for(aw, timeout, *, loop=None)¶

Ожидает завершения aw ожидаемого объекта с таймаутом.

Если aw является корутиной, она автоматически планируется как задача.

timeout может быть либо None, либо числом с плавающей запятой или целым числом секунд ожидания. Если timeout равно None, блокирует выполнение до завершения future.

Если происходит таймаут, он отменяет задачу и возбуждает asyncio.TimeoutError.

Чтобы избежать задачи cancellation, оберните её в shield().

Функция будет ждать, пока future не будет фактически отменена, поэтому общее время ожидания может превысить timeout. Если во время отмены произойдёт исключение, оно будет распространено.

Если ожидание отменяется, future aw также отменяется.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Пример:

async def eternity():
    # Спать в течение часа
    await asyncio.sleep(3600)
    print('yay!')

async def main():
    # Ждать не более 1 секунды
    try:
        await asyncio.wait_for(eternity(), timeout=1.0)
    except asyncio.TimeoutError:
        print('timeout!')

asyncio.run(main())

# Ожидаемый вывод:
#
#     тайм-аут!

Изменено в версии 3.7: Когда aw отменяется из-за таймаута, wait_for ожидает отмены aw. Ранее оно немедленно вызывало asyncio.TimeoutError.

Примитивы ожидания¶Waiting Primitives

coroutine asyncio.wait(aws, *, loop=None, timeout=None, return_when=ALL_COMPLETED)¶

Запускает ожидаемые объекты в aws\nитерируемом объекте конкурентно и блокируется до выполнения условия, заданного\nreturn_when.

Итерируемый объект aws не должен быть пустым.

Возвращает два набора задач/future: (done, pending).

Использование:

done, pending = await asyncio.wait(aws)

timeout (число с плавающей точкой или целое) позволяет указать максимальное время ожидания в секундах перед возвратом результата.

Обратите внимание, что эта функция не вызывает asyncio.TimeoutError. Объекты Future или задачи, не завершённые к моменту таймаута, просто возвращаются во втором наборе.

return_when указывает, когда эта функция должна вернуть результат. Это должна быть одна из следующих констант:

Константа	Описание
FIRST_COMPLETED	Функция вернёт результат, когда любой future завершится или будет отменён.
FIRST_EXCEPTION	Функция вернёт результат, когда любой future завершится, возбудив исключение. Если ни один future не возбудит исключение, это эквивалентно ALL_COMPLETED.
ALL_COMPLETED	Функция вернёт результат, когда все future завершатся или будут отменены.

В отличие от wait_for(), wait() не отменяет futures при возникновении таймаута.

Устарело с версии 3.8: Если любой ожидаемый объект в aws является корутиной, она автоматически\nпланируется как задача. Передача объектов-корутин непосредственно в\nwait() устарела, поскольку это приводит к\nзапутанному поведению.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Примечание

wait() автоматически планирует корутины как задачи и затем возвращает эти неявно созданные объекты задач в (done, pending) наборах. Поэтому следующий код не будет работать, как ожидается:

async def foo():
    return 42

coro = foo()
done, pending = await asyncio.wait({coro})

if coro in done:
    # Эта ветка никогда не будет выполнена!

Вот как можно исправить приведённый выше фрагмент:

async def foo():
    return 42

task = asyncio.create_task(foo())
done, pending = await asyncio.wait({task})

if task in done:
    # Теперь всё будет работать как ожидается.

Устарело с версии 3.8, будет удалено в версии 3.11: Передача объектов-корутин непосредственно в wait()\nустарела.

asyncio.as_completed(aws, *, loop=None, timeout=None)¶

Запускает ожидаемые объекты из итерируемого aws одновременно. Возвращает итератор корутин. Каждую возвращённую корутину можно ожидать, чтобы получить следующий по порядку результат из итерируемого набора оставшихся ожидаемых объектов.

Вызывает asyncio.TimeoutError, если время ожидания истекает до того, как все Future будут завершены.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

Пример:

for coro in as_completed(aws):
    earliest_result = await coro
    # ...

Запуск в потоках¶Running in Threads

coroutine asyncio.to_thread(func, /, *args, **kwargs)¶

Асинхронно запускает функцию func в отдельном потоке.

Любые *args и **kwargs, переданные в эту функцию, напрямую передаются в func. Также распространяется текущий contextvars.Context, что позволяет обращаться к контекстным переменным из потока цикла событий в отдельном потоке.

Возвращает корутину, которую можно ожидать для получения конечного результата func.

Эта корутинная функция в первую очередь предназначена для выполнения\nфункций/методов, связанных с вводом-выводом, которые в противном случае блокировали бы цикл событий, если\nбы они выполнялись в основном потоке. Например:

def blocking_io():
    print(f"start blocking_io at {time.strftime('%X')}")
    # Обратите внимание, что time.sleep() можно заменить любой блокирующей
    # операцией ввода-вывода, например файловыми операциями.
    time.sleep(1)
    print(f"blocking_io complete at {time.strftime('%X')}")

async def main():
    print(f"started main at {time.strftime('%X')}")

    await asyncio.gather(
        asyncio.to_thread(blocking_io),
        asyncio.sleep(1))

    print(f"finished main at {time.strftime('%X')}")


asyncio.run(main())

# Ожидаемый вывод:
#
# запущен main в 19:50:53
# запуск blocking_io в 19:50:53
# blocking_io завершён в 19:50:54
# main завершён в 19:50:54

Прямой вызов blocking_io() в любой корутине заблокирует цикл событий на время своего выполнения, что приведет к дополнительной секунде времени выполнения. Вместо этого, используя asyncio.to_thread(), можно запустить её в отдельном потоке, не блокируя цикл событий.

Примечание

Из-за GIL, asyncio.to_thread() обычно может использоваться только dля того, чтобы сделать функции, связанные с вводом-выводом, неблокирующими. Однако для модулей расширения, которые освобождают GIL, или альтернативных реализаций Python, которые не имеют его, asyncio.to_thread() также можно использовать для функций, связанных с процессором.

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

Планирование из других потоков¶Scheduling From Other Threads

asyncio.run_coroutine_threadsafe(coro, loop)¶

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

Возвращает concurrent.futures.Future для ожидания результата из другого потока операционной системы.

Эта функция предназначена для вызова из другого потока операционной системы, отличного от того, в котором работает цикл событий. Пример:

# Создать корутину
coro = asyncio.sleep(1, result=3)

# Отправить корутину в заданный цикл
future = asyncio.run_coroutine_threadsafe(coro, loop)

# Ожидать результат с необязательным аргументом таймаута
assert future.result(timeout) == 3

Если в корутине возникло исключение, возвращаемый объект Future получит уведомление. Его также можно использовать для отмены задачи в цикле событий:

try:
    result = future.result(timeout)
except asyncio.TimeoutError:
    print('The coroutine took too long, cancelling the task...')
    future.cancel()
except Exception as exc:
    print(f'The coroutine raised an exception: {exc!r}')
else:
    print(f'The coroutine returned: {result!r}')

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

В отличие от других функций asyncio, эта функция требует явной передачи аргумента loop .

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

Интроспекция¶Introspection

asyncio.current_task(loop=None)¶

Возвращает экземпляр текущей выполняющейся Task или None, если нет выполняющейся задачи.

Если loop равен None, используется get_running_loop() для получения текущего цикла.

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

asyncio.all_tasks(loop=None)¶

Возвращает набор ещё не завершённых объектов Task, выполняемых циклом.

Если loop равен None, get_running_loop() используется для получения текущего цикла.

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

Объект Задачи¶Task Object

class asyncio.Task(coro, *, loop=None, name=None)¶

Объект Future-like, выполняющий корутину Python корутину. Непотокобезопасный.

Задачи используются для выполнения корутин в циклах событий. Если корутина ожидает Future, задача приостанавливает выполнение корутины и ждёт завершения Future. Когда Future завершён, выполнение обёрнутой корутины возобновляется.

Циклы событий используют кооперативное планирование: цикл событий выполняет по одной задаче за раз. Пока задача ожидает завершения Future, цикл событий выполняет другие задачи, колбэки или производит операции ввода-вывода.

Используйте высокоуровневую функцию asyncio.create_task() для создания задач или низкоуровневые функции loop.create_task() или ensure_future(). Ручное создание экземпляров задач не рекомендуется.

Чтобы отменить выполняющуюся задачу, используйте метод cancel(). Его вызов приведёт к тому, что задача возбудит исключение CancelledError в обёрнутой корутине. Если во время отмены корутина ожидает объект Future, этот объект Future будет отменён.

cancelled() можно использовать для проверки, была ли задача отменена. Метод возвращает True, если обёрнутая корутина не подавила исключение CancelledError и была действительно отменена.

asyncio.Task наследует от Future все свои API, за исключением Future.set_result() и Future.set_exception().

Задачи поддерживают модуль contextvars. Когда создаётся задача,\nона копирует текущий контекст и затем выполняет свою\nкорутину в скопированном контексте.

Изменено в версии 3.7: Добавлена поддержка модуля contextvars.

Изменено в версии 3.8: Добавлен параметр name.

Устарело с версии 3.8, будет удалено в версии 3.10: Параметр loop.

cancel(msg=None)¶

Запрашивает отмену задачи.

Обеспечивает выброс исключения CancelledError в обёрнутую корутину на следующем цикле событийного цикла.

Затем корутина имеет возможность очистить ресурсы или даже отклонить\nзапрос, подавив исключение с помощью блока try …\n… except CancelledError … finally.\nПоэтому, в отличие от Future.cancel(), Task.cancel() не\nгарантирует, что задача будет отменена, хотя полное подавление отмены\nне является распространённой практикой и активно не рекомендуется.

Изменено в версии 3.9: Добавлен параметр msg.

Следующий пример показывает, как корутины могут перехватить запрос отмены:

async def cancel_me():
    print('cancel_me(): before sleep')

    try:
        # Ждать 1 час
        await asyncio.sleep(3600)
    except asyncio.CancelledError:
        print('cancel_me(): cancel sleep')
        raise
    finally:
        print('cancel_me(): after sleep')

async def main():
    # Создать задачу "cancel_me"
    task = asyncio.create_task(cancel_me())

    # Ждать 1 секунду
    await asyncio.sleep(1)

    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("main(): cancel_me is cancelled now")

asyncio.run(main())

# Ожидаемый вывод:
#
#     cancel_me(): перед сном
#     cancel_me(): отмена сна
#     cancel_me(): после сна
#     main(): cancel_me теперь отменён

cancelled()¶

Return True if the Task is cancelled.

The Task is cancelled when the cancellation was requested with cancel() and the wrapped coroutine propagated the CancelledError exception thrown into it.

done()¶

Возвращает True, если задача завершена.

Задача завершена, когда обёрнутая корутина вернула значение, возбудила исключение или задача была отменена.

result()¶

Возвращает результат задачи.

Если задача завершена, возвращается результат обёрнутой корутины (или, если корутина возбудила исключение, это исключение возбуждается повторно).

Если задача была отменена, этот метод возбуждает исключение CancelledError.

Если результат задачи ещё не доступен, этот метод возбуждает исключение InvalidStateError.

exception()¶

Возвращает исключение задачи.

Если обёрнутая корутина возбудила исключение, возвращается это исключение. Если корутина завершилась нормально, этот метод возвращает None.

Если задача была отменена, этот метод возбуждает исключение CancelledError.

Если задача ещё не завершена, этот метод возбуждает исключение InvalidStateError.

add_done_callback(callback, *, context=None)¶

Добавляет колбэк, который будет выполнен, когда задача завершена.

Этот метод следует использовать только в низкоуровневом коде, основанном на колбэках.

Подробнее см. в документации Future.add_done_callback().

remove_done_callback(callback)¶

Удаляет колбэк из списка колбэков.

Этот метод следует использовать только в низкоуровневом коде, основанном на колбэках.

Подробнее см. в документации Future.remove_done_callback().

get_stack(*, limit=None)¶

Возвращает список кадров стека для этой задачи.

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

Кадры всегда упорядочены от старых к новым.

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

Необязательный аргумент limit задаёт максимальное количество возвращаемых кадров; по умолчанию возвращаются все доступные кадры. Порядок возвращаемого списка различается в зависимости от того, возвращается стек или трассировка: возвращаются новейшие кадры стека, но старейшие кадры трассировки. (Это соответствует поведению модуля traceback.)

print_stack(*, limit=None, file=None)¶

Печатает стек или трассировку для этой задачи.

Результат аналогичен выводу модуля traceback для кадров, полученных с помощью get_stack().

Аргумент limit передаётся непосредственно в get_stack().

Аргумент file – это поток ввода-вывода, в который записывается вывод; по умолчанию вывод записывается в sys.stderr.

get_coro()¶

Возвращает объект корутины, обёрнутый Task.

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

get_name()¶

Возвращает имя задачи.

Если задаче не было явно присвоено имя, стандартная реализация задач asyncio генерирует имя по умолчанию при создании.

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

set_name(value)¶

Устанавливает имя задачи.

Аргумент value может быть любым объектом, который затем преобразуется в строку.

В стандартной реализации задач имя будет видно в repr()-выводе объекта задачи.

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

Корутины на основе генераторов¶Generator-based Coroutines

Корутины на основе генераторов предшествуют синтаксису async/await. Они представляют собой генераторы Python, использующие выражения yield from для ожидания Future и других корутин.

Корутины на основе генераторов следует декорировать с помощью @asyncio.coroutine, хотя это не требуется.

@asyncio.coroutine¶

Декоратор для пометки корутин на основе генераторов.

Этот декоратор позволяет старым корутинам на основе генераторов быть совместимыми с кодом async/await:

@asyncio.coroutine
def old_style_coroutine():
    yield from asyncio.sleep(1)

async def main():
    await old_style_coroutine()

Этот декоратор не следует использовать для async def корутин.

Устарело с версии 3.8, будет удалено в версии 3.11: Вместо этого используйте async def.

asyncio.iscoroutine(obj)¶

Возвращает True, если obj является объектом корутины.

Этот метод отличается от inspect.iscoroutine() тем, что возвращает True для корутин на основе генераторов.

asyncio.iscoroutinefunction(func)¶

Возвращает True, если func является корутинной функцией.

Этот метод отличается от inspect.iscoroutinefunction() тем, что возвращает True для корутинных функций на основе генераторов, декорированных с помощью @coroutine.