Asyncer

0.0.17 · active · verified Thu Apr 09

Asyncer is a small Python library built on top of AnyIO, focused on improving developer experience when working with `async` and `await` and mixing async with regular blocking code. It provides utility functions like `asyncify` and `syncify` to bridge asynchronous and synchronous code more conveniently, offering better editor support and type checking. It is actively maintained, with frequent minor releases.

Warnings

breaking Asyncer dropped support for Python 3.9 in version 0.0.15. Projects requiring Python 3.9 or older must use an earlier Asyncer version.
Fix: Upgrade to Python 3.10 or higher, or pin Asyncer to `<0.0.15`.
breaking Asyncer dropped support for Python 3.8 in version 0.0.12. Projects requiring Python 3.8 or older must use an earlier Asyncer version.
Fix: Upgrade to Python 3.9 or higher (preferably 3.10+), or pin Asyncer to `<0.0.12`.
deprecated The `cancellable` argument for `asyncify()` was refactored and is now `abandon_on_cancel`. Using `cancellable=True` might not have the intended effect or could lead to future breakage.
Fix: Replace `asyncify(..., cancellable=True)` with `asyncify(..., abandon_on_cancel=True)`. Refer to AnyIO documentation for precise behavior of `abandon_on_cancel`.
gotcha Asyncer functions, particularly `syncify`, expect to be called either from an existing asynchronous event loop (e.g., within an `async` function running via `anyio.run()` or `asyncio.run()`) or from a worker thread initiated by `asyncify`. Calling `syncify()` directly in a purely synchronous top-level context may implicitly start a new event loop or raise an error if `raise_sync_error` is not set to `False`.
Fix: Ensure `asyncer` functions are used within an appropriate asynchronous context (e.g., `anyio.run()`) or explicitly handle synchronous execution with `syncify(..., raise_sync_error=False)`.
gotcha The Asyncer documentation recommends pinning the exact version of the library due to its small size and potential for future changes, and always having tests for your project.
Fix: Pin the Asyncer version in your `requirements.txt` or `pyproject.toml` (e.g., `asyncer==0.0.17`) and maintain comprehensive tests to ensure compatibility when upgrading.

Install

pip install asyncer Install Asyncer

Imports

asyncify
```
from asyncer import asyncify
```
Used to call synchronous (blocking) functions from an asynchronous context without blocking the event loop.
syncify
```
from asyncer import syncify
```
Used to call asynchronous functions from a synchronous context.

Quickstart

This example demonstrates how to use `asyncer.asyncify` to call a regular blocking function (`blocking_function`) from within an asynchronous context (`main`). `asyncify` ensures the blocking operation runs in a worker thread, preventing it from blocking the main event loop. The `anyio.run(main)` call starts the AnyIO event loop to execute the asynchronous `main` function.

import anyio
from asyncer import asyncify
import time

def blocking_function(name: str) -> str:
    """A blocking function that simulates work."""
    time.sleep(0.1)  # Simulate I/O or CPU-bound work
    return f"Hello from blocking func, {name}!"

async def main():
    print("Starting async main function.")
    # Run a blocking function in a worker thread using asyncify
    message = await asyncify(blocking_function)(name="World")
    print(message)
    print("Finished async main function.")

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

view raw JSON →