nest-asyncio Library

1.6.0 · active · verified Sat Mar 28

nest-asyncio is a Python library that patches the `asyncio` module to allow nested event loops. This addresses the `RuntimeError: This event loop is already running` issue encountered in environments like web servers, GUI applications, and Jupyter notebooks where an event loop is already active. It is currently at version 1.6.0 and maintains a stable release cadence.

Warnings

breaking Python 3.14+ breaks the `nest-asyncio` workaround. Due to significant changes in `asyncio`'s implementation, the library can no longer safely monkey-patch it, meaning automatic async-to-sync conversion often fails. Users must explicitly use `await` with async methods in environments like Jupyter notebooks.
Fix: On Python 3.14+, use `await` with async methods (e.g., `await obj.async_method()`) instead of relying on `nest-asyncio`'s patching for automatic conversion.
gotcha Using `nest-asyncio` can lead to a `ResourceWarning: unclosed event loop at exit` on Python 3.12+ if the patched `asyncio.run()` creates a new event loop and doesn't explicitly close it. This warning is often hidden by default.
Fix: While often ignorable as the loop is reused, be aware of this warning. For critical applications, ensure proper event loop management, or consider explicit loop closing if not relying on reuse (though this often defeats `nest-asyncio`'s purpose).
gotcha `nest-asyncio` is designed to patch `asyncio` event loops only. It generally does not provide compatibility or patching for alternative event loop implementations like `uvloop` or `quamash`.
Fix: Ensure you are using `asyncio`'s default event loop when `nest-asyncio` is applied. If you require other loop implementations, `nest-asyncio` may not be the solution.
gotcha Nesting `asyncio.run()` calls after applying `nest-asyncio` can potentially lead to 'starvation' of tasks scheduled outside the nested run if the inner loop occupies too much execution time. This happens because nested runs do not automatically yield time to outer tasks.
Fix: Avoid long-running or CPU-bound operations within nested `asyncio.run()` calls. If significant work is needed, consider restructuring your async code to avoid deep nesting or using thread pools for blocking operations.
gotcha Some frameworks, like Prefect, advise against using `nest-asyncio` and provide their own async utilities (e.g., `run_coro_as_sync`) to bridge async and sync code, explicitly warning that `nest-asyncio` can cause hard-to-debug issues like deadlocks, broken cancellations, and inconsistent behavior.
Fix: When working with frameworks that have their own async integration mechanisms, prefer using their recommended patterns over `nest-asyncio` to ensure compatibility and stability.

Install

pip install nest-asyncio Install with pip

Imports

apply
```
import nest_asyncio
nest_asyncio.apply()
```
The `apply()` function is typically called once at the start of your application to patch the current or specified event loop.

Quickstart

This quickstart demonstrates how to apply the `nest-asyncio` patch and then run an `asyncio` coroutine using `asyncio.run()`, even if an event loop is already running.

import asyncio
import nest_asyncio

# Apply the patch to allow nested event loops
nest_asyncio.apply()

async def my_async_function():
    await asyncio.sleep(0.1)
    return "Hello, Nested World!"

# This works even in environments with existing event loops
result = asyncio.run(my_async_function())
print(result)

view raw JSON →