Error "RuntimeError: This event loop is already running" in Python

I got the issue resolved by using the nest_async

pip install nest-asyncio

And by adding the below lines in my file.

# The __import__ line is not needed. I am leaving it just
# so that the comments make sense
# __import__('IPython').embed()
import nest_asyncio

nest_asyncio.apply()

The event loop running is an entry point of your async program. It manages the running of all coroutines, tasks, and callbacks. Running the loop while it's running doesn't make any sense: in some sort, it's like trying to run a job executor from the same already-running job executor.

Since you have this question, I guess you may misunderstand a way how asyncio works. Please, read this article; it's not big and gives a good introduction.

There absolutely isn't any problem in adding multiple things to be run by the event loop while this loop is already running. You can do it just by awaiting for it:

await coro()  # Add coro() to be run by the event loop, blocking the flow here until coro() is finished

Or creating a task:

# Python 3.7+
asyncio.create_task(coro())  # Add coro() to be run by the event loop without blocking the flow here

# This works in all Python versions, but it is less readable
asyncio.ensure_future(coro())

As you can see, you don't need call the event loop's methods to make something being run by it.

The event loop's method, such as run_forever or run_until_complete, are just ways to start the event loop in general.

run_until_complete(foo()) means: "add foo() to be run by the event loop and run the event loop itself until foo() isn't done".

Just add this bunch of code in the beginning

!pip install nest_asyncio
import nest_asyncio
nest_asyncio.apply()

I'm writing this down not to patronize, but to explain how we can handle the situation where simply queueing async functions and awaiting their results synchronously while the event loop is running, doesn't work.

run_until_complete is not for running any number of arbitrary async functions synchronously, it is for running the main entry point of your entire async program. This constraint is not immediately apparent from the documentation.

Since libraries like aiohttp will queue its own entry point to run as a server and block the loop's synchronous operations using run_until_complete or run_forever, the event loop will already be running and you won't be able to run independent synchronous operations on that event loop and wait for its result within that thread.

That being said, if you have to queue an async operation into a running event loop from within a sync context and get its result like a regular function, that may not be possible. One way is to pass in a synchronous callback to be called once the async operation finishes. That will of course slow down your event loop. Another way is to put the result in a queue and wait for it in a synchronous loop, emulating the event loop.

Another way of handling the situation is to execute your code within startup and cleanup callbacks of the async http library you're using. Here's a sample of how you may accomplish this.

Using nest_asyncio didn't work for me, because then aiohttp started complaining with

• RuntimeError: Timeout context manager should be used inside a task

Instead, I decided to replace all calls to asyncio.run with calls to this asyncio_run:

def asyncio_run(future, as_task=True):
    """
    A better implementation of `asyncio.run`.

    :param future: A future or task or call of an async method.
    :param as_task: Forces the future to be scheduled as task (needed for e.g. aiohttp).
    """

    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:  # No event loop running:
        loop = asyncio.new_event_loop()
        return loop.run_until_complete(_to_task(future, as_task, loop))
    else:
        nest_asyncio.apply(loop)
        return asyncio.run(_to_task(future, as_task, loop))


def _to_task(future, as_task, loop):
    if not as_task or isinstance(future, asyncio.Task):
        return future
    return loop.create_task(future)

A secondary goal was to be able to think of asyncio.run as promise.resolve from the JavaScript world, or Task.Wait from the .NET world.

In our product, we removed this code in favor of this other answer in a related question.

I had the same problem and I fixed this issue using nest_async or asyncio

Solution #1

Simply install the package:

pip install nest-asyncio

Then add these lines:

import nest_asyncio
nest_asyncio.apply()

Solution #2

If it's not working with nest_asyncio, then try asyncio:

import asyncio
asyncio.set_event_loop(asyncio.new_event_loop())

Here is a general async-to-sync context manager I came up with based on this answer:

await def async_func():
   ...

def sync_func():
    with sync_await() as await_:
       x = await_(async_func())

It can actually be useful even in async context, e.g. for converting an async iterable to a regular (sync) iterable:

await def async_func(coroutines):
   with sync_await() as await_:
        # TypeError: 'async_generator' object is not iterable
        # x = any(await c for c in coroutines)
        x = any(map(await_, coroutines))

This might not solve the same problem but a similar one. If the error is not produced by any of your custom files but by packages you install using pip, proceed to read below because that was how I fixed mine.

I realized this error was due to package versions and compatibility. So you might want to look at the stack trace and determine which libraries are involved and try upgrading or downgrading them, keeping in mind their compatibility. If you are lucky enough pip install might inform you of any incompatibilities.

Once again, in my case, I had to upgrade to

PyMySQL==1.1.0
aiomysql==0.2.0

I found that changing this: filtered_cap = pyshark.FileCapture( <FILE_NAME>.pcap)

To this: with pyshark.FileCapture( <FILE_NAME>.pcap) as filtered_cap:

Resolves the Cannot run the event loop while another loop is running Error

Sometimes the event loop is there and is running. In that case we don't need to run it again; we just need to create a task using create_task.

Try this:

try:
    loop = asyncio.get_event_loop()
except RuntimeError:
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

task = loop.create_task(user_insert_events(target))
if not loop.is_running():
    loop.run_until_complete(task)