replacing asyncio with concurent.futures

Question

asyncio is causing issues on my spyder IDE => would like to replace it with concurent.futures library

how can I replace the below code relying only on concurent.futures library asyncio.get_event_loop().run_until_complete(api(message))

exact function looks as follows

def async_loop(api, message):
    return asyncio.get_event_loop().run_until_complete(api(message))

Answer 1

As written, you're starting up the event loop only until a particular task completes (which may or may not launch or wait on other tasks), and blocking until it completes. The only reason it's a task is because it needs to use async functions, those can only run in an event loop, and while running, they may launch other tasks or wait on other awaitables, and while waiting, the event loop can do other tasks.

In short, if not for the need to be an async task running in a non-async context, this would just be:

def async_loop(api, message):
    return api(message)

which calls api and waits for it to complete.

Really, that's it. If the things api does or calls need to run some tasks asynchronously, without blocking on them immediately, you'd have some global executor, e.g.

executor = concurrent.Futures.ThreadPoolExecutor()

which would be used to launch tasks with:

fut = executor.submit(callable, 'arg1', 'arg2', kwarg1='somevalue')

and, when the result of the task is needed, someone would call:

value = fut.result()

on it (which would block if it wasn't done yet, return the result if it completed without an exception, or raise the exception it died with if it died with an exception).

Whenever you no longer need the executor, you just call .shutdown() on it and it will wait for all outstanding tasks to complete. That's it.

---

As a side-note, the error you're experiencing is part of why they've deprecated get_event_loop() in 3.10 (and discouraged it since 3.7). In all likelihood, the simplest solution to your problem (avoiding a switch to threads, because all that means is you've got new problems) is to use the much simpler high-level API, asyncio.run (introduced in 3.7), which creates an event loop, runs the task in it to completion, does reasonable cleanup, then returns the result:

def async_loop(api, message):
    return asyncio.run(api(message))

There's also the asyncio.get_running_loop function (that is the exact replacement for get_event_loop) which you use when an event loop already exists (which you should typically be aware of; event loops don't pop into existence in given thread on their own, so you should know if you launched one; in this case you hadn't, so asyncio.run is the correct one to use).