[Fixed] runtimeerror: no running event loop

You get the runtimeerror: no running event loop error while you are accessing asynchronous programming features, such as coroutines or the asyncio module. This exists without a running event loop.

Contents

About the error

We use an event loop to manage and execute our asynchronous tasks. This ensures that the execution happens on time, i.e., it is not delayed. So, if you try to run the asyncio module or related functions without the event loop, you will obtain this error.

Reasons of error

This error exists due to a couple of reasons:

You haven’t initialized the event loop correctly.
The event loop is missing.
The libraries that you have used are incompatible with the event loop.
You have written code outside the scope of your event loop.

Methods of resolving the error

The methods given below will help you to overcome the ‘runtimeerror: no running event loop’ error.

Initialize the loop
Check the scope of your asynchronous code.
Check the compatibility of existing libraries and update if required.
Change several loops to just one event loop.

asyncio.new_event_loop() and asyncio.set_event_loop()

You can use the asyncio.new_event_loop() loop function to create a new object of the event loop. The asyncio.set_event_loop() function lets you set this newly created object.

The example given below uses the asyncio and time modules to monitor asynchronous codes and the time each task takes. The create_tasks_func function makes calls that are asynchronous in nature.

import asyncio
import time

async def func(index):
    print(f'Before task {index}')
    await asyncio.sleep(0.1)
    print(f'After task {index}')

# Create an event loop object
loop = asyncio.new_event_loop()

async def create_tasks_func():
    # Create a list of tasks
    tasks = []
    for idx in range(3):
        tasks.append(asyncio.create_task(func(idx)))

    # Wait for all tasks to complete
    await asyncio.wait(tasks)

# Run the event loop until all tasks are complete
loop.run_until_complete(create_tasks_func())

# Close the event loop
loop.close()

`asyncio.run()` function

You need to specify the coroutine first. The asyncio.run() function takes the coroutine as its argument and runs it till the time of completion.

import asyncio

async def my_coroutine():
    # Do some asynchronous work here

async def main():
    await asyncio.run(my_coroutine())

if __name__ == "__main__":
    asyncio.run(main())

Manual creation of loops

In this case, you can control the event loop yourself. Create a loop with the help of asyncio.get_event_loop() and then use the loop.run_until_complete() to schedule the coroutines. This helps to run the coroutines, too.

import asyncio

async def my_coroutine():
    # Do some asynchronous work here

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(my_coroutine())
    loop.close()

create_task() function with the loop object

If you add tasks to a stagnant loop, you’ll get this error. Use the create_task() function on the loop object and not the asyncio module. Look at the given example. Here, the create_task function is called directly with the loop object. It executes three concurrent tasks with the help of the example_func coroutine.

import asyncio
async def example_func(index):
    print(f"Current index: {index}")


async def main():
    loop = asyncio.get_event_loop()

    tasks = []
    for index in range(3):
        task = loop.create_task(example_func(index))
        tasks.append(task)

    await asyncio.wait(tasks)

    loop.close()

asyncio.run(main())

runtimeerror no running event loop discord py

You might have gotten the runtime error, no running event loop error while working on Discord bots. With asyncio, you can not curate nested loops. This is due to the fact that in case the event loop is already running, you can’t run another task at the same time. Thus, it is better to use the nest_asyncio library.

pip install nest_asyncio
import nest_asyncio
nest_asyncio.apply()

Other than this, make sure that only one event loop is attached to your Discord bot’s tasks. The task.start method should not be outside your coroutine. The given example shows how you can use it inside an async function.

async def start_tasks():
    @tasks.loop(seconds=20.0)
    async def send_cal():
        # ... your task code ...
        
    send_cal.start()

@bot.event
async def on_ready():
    await start_tasks()
    
bot.run(token)

runtimeerror no running event loop pytest

You can choose to go with any of the below-mentioned steps to resolve the runtimeerror no running event loop in pytest.

Send a task on a long sleep.
Forcibly disconnect a task from the WebSocket.
Start the event loop in an explicit manner.

asyncio.new_event_loop() #create new loop
asyncio.set_event_loop(loop) #set it as the current one
#start the loop with
loop.run_until_complete(...) or loop.run_forever()

The pytest-asyncio plugin is also quite helpful. Install it using the pip install pytest-asyncio command and then add -s to your script similar to this: “pytest -s script.py”. This will enable the asyncio plugin.

You can also escape this with the try and except block.

import asyncio

import pytest

@pytest.fixture(scope="session")
def event_loop():
    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:
        loop = asyncio.new_event_loop()
    yield loop
    loop.close()

runtimeerror no running event loop pyshark

If you encounter the runtimeerror no running event loop in by shark, use the nest_asyncio library. Its solution is similar to the one mentioned above.

pip install nest_asyncio
import nest_asyncio
nest_asyncio.apply()

You should also check whether Python 3.6 or later version exists or not. Consider reinstalling pyshark with pip install pyshark. If you are working with live captures, go for sniff() , whereas if you are supposed to read capture files, you should use capture().

runtimeerror no running event loop playwright

You need to install a few dependencies first, like a chromium-chrome driver, nest_asyncio, and playwright in your notebook. Post that, akin to the solution that has been elaborated above, import the nest_asyncio library.

!apt install chromium-chromedriver
!pip install nest_asyncio
!pip install playwright

Once you have installed the dependencies, you should import the library and then write your async code. This will surely prevent the runtime error. There is no running event loop in Playwright. This can work on your colab or jupyter notebook as well. It automates UI testing itself.

import nest_asyncio
nest_asyncio.apply()

Otherwise, you may work with the API import alternative.

from playwright.async_api import async_playwright

Other tips while working with event loops

You can go through the following tips while working with event loops. This will help you prevent the ‘runtimeerror: no running event loop’ error.

See if the event loop is running. You get the error if the event loop is not in a running position. You can explicitly create the event loop, too.
The asyncio.run() function works well with a single asynchronous function.
The get_event_loop() function of the asyncio module will help you fetch details of the currently running event loop.
You should wait for asynchronous operations to complete before proceeding to the next step. The await keyword does the same.
Go with proper exception handling to avoid errors.

FAQs

What is the difference between creating and running an event loop explicitly and using asyncio.run()?

asyncio.run() creates the event loop and handles it itself. However, if you want to schedule tasks, handle exceptions, and manage the event loop’s lifetime, you should create a loop explicitly.

Conclusion

This article focuses on the removal of the runtimeerror: no running event loop error. It discusses the primary reasons for this error and the different ways through which this error can be resolved easily.