Async Standard Library (asyncstdlib)

3.14.0 · active · verified Fri Apr 10

asyncstdlib provides async equivalents for functions and classes found in Python's standard library modules like itertools, functools, contextlib, builtins, and os. It aims to make writing asynchronous code more concise and familiar by mirroring the API of their synchronous counterparts. The current version is 3.14.0, maintaining feature parity with Python 3.14. New major versions are typically released to align with new Python releases.

Warnings

gotcha Mixing `asyncstdlib` functions with built-in or synchronous standard library functions (e.g., `itertools.map` on an async iterable) will lead to `TypeError` or incorrect behavior, as asyncstdlib functions expect and return async iterables/awaitables.
Fix: Always use the `asyncstdlib` equivalent (e.g., `asyncstdlib.itertools.map`, `asyncstdlib.builtins.anext`) when working with async generators and iterables.
breaking In `v3.13.3`, the signatures and behavior of `asyncstdlib.itertools.islice` and `asyncstdlib.itertools.accumulate` were updated to match their synchronous `itertools` counterparts more closely. This primarily affects `islice` overloads and `accumulate`'s `initial` parameter, potentially causing subtle breaking changes if your code relied on previous divergent behavior.
Fix: Review code using `islice` and `accumulate` and adjust parameter passing or expectations to align with the standard `itertools` behavior.
gotcha As of `v3.13.3`, `asyncstdlib.itertools.tee` instances now share an internal buffer for improved efficiency, mirroring `itertools.tee` in CPython. While generally a performance enhancement, this can subtly change behavior if you were relying on independent buffering or specific mutation patterns of yielded items across `tee` branches in earlier versions.
Fix: Understand that `tee` iterators consume from a shared underlying iterable and buffer. Ensure your logic handles this standard `tee` behavior, which typically implies immutable consumption.
deprecated `asyncstdlib` versions from `3.12.1` onwards no longer support Python 3.6 and 3.7. The `requires_python` specification is `~=3.8`.
Fix: Upgrade your Python environment to 3.8 or newer.

Install

pip install asyncstdlib Install latest version

Imports

map
```
from asyncstdlib.itertools import map as amap
```
Use 'amap' (or similar alias) for async iterables, not the standard 'itertools.map'.
anext
```
from asyncstdlib.builtins import anext
```
Use 'anext' for consuming async iterators, not the standard 'next'.
AsyncStandardLibrary
```
import asyncstdlib as a
```
Common practice to import the whole library under an alias 'a' for convenience.

Quickstart

This quickstart demonstrates using `asyncstdlib`'s async versions of `map`, `filter`, and `anext` with an async generator. It highlights how to apply common iteration patterns in an asynchronous context.

import asyncio
import asyncstdlib as a

async def async_counter(limit: int):
    """An async generator that yields numbers up to a limit."""
    for i in range(limit):
        await asyncio.sleep(0.01) # Simulate async work
        yield i

async def main():
    print("\nMapping values (doubling):")
    doubled_values = a.itertools.map(lambda x: x * 2, async_counter(5))
    async for item in doubled_values:
        print(item)

    print("\nFiltering values (evens only):")
    even_values = a.itertools.filter(lambda x: x % 2 == 0, async_counter(6))
    async for item in even_values:
        print(item)

    print("\nConsuming with anext:")
    it = a.builtins.aiter(async_counter(3))
    print(await a.builtins.anext(it))
    print(await a.builtins.anext(it))

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

view raw JSON →