aioprocessing

What it is and what it does

aioprocessing wraps the standard library's multiprocessing module to make its blocking methods awaitable in asyncio code. Instead of reimplementing multiprocessing with async I/O, it delegates blocking calls to a ThreadPoolExecutor, allowing you to use familiar multiprocessing APIs (Queue, Lock, Process, Pool, Semaphore, Barrier, etc.) inside async coroutines without blocking the event loop.

The library adds a coroutine version of each blocking method—for example, `Lock.acquire()` becomes `AioLock.coro_acquire()`—and provides Aio-prefixed classes that drop into existing multiprocessing code. It also supports optional universal pickling via dill for cases where the standard pickle module is insufficient. This is useful when you need inter-process communication or worker pools within an asyncio application, though it introduces thread overhead and inherits the thread-fork mixing risks of the underlying multiprocessing module.

Use it for:

• Running CPU-bound worker processes from an async web framework without blocking the event loop.
• Coordinating multiple processes using asyncio-compatible locks, events, and queues in a single async application.
• Building async task queues that dispatch work to separate processes while maintaining async/await syntax.
• Mixing asyncio coroutines with multiprocessing Pool callbacks in a unified async control flow.
• Implementing inter-process synchronization primitives (Barrier, Condition) in async code.

Worth the install?

AI-flagged interpretation of the facts on this page — verify before relying

Provides asyncio-compatible wrappers around multiprocessing objects (Queue, Lock, Process, Pool, etc.) so their blocking methods can be awaited in async code without freezing the event loop.

Yes, if you need to integrate multiprocessing with asyncio and are comfortable with the abandoned maintenance status. The package is stable and has no known vulnerabilities, but you should be aware it will not receive updates for new Python versions or bug fixes. For new projects, consider whether a pure-async alternative might better suit your needs.

Install

aioprocessing on PyPI

pip install aioprocessing

uv add aioprocessing

poetry add aioprocessing

Installing aioprocessing

Before you install

Installation is straightforward with no runtime dependencies. However, the package is in abandoned maintenance status with the last commit in September 2022. It remains functional for its stated purpose but will not receive bug fixes or updates.

License in practice

Licensed under BSD (permissive), which allows free use, modification, and distribution with minimal restrictions—suitable for both open-source and commercial projects.

Quickstart

pip install aioprocessing

import asyncio
import aioprocessing

async def main():
    queue = aioprocessing.AioQueue()
    lock = aioprocessing.AioLock()
    result = await queue.coro_get()
    async with lock:
        await queue.coro_put(None)

asyncio.run(main())

Requires Python 3.5 or later. Thread-fork mixing caveats apply when combining with multiprocessing; coroutines cannot be cancelled since work in executor threads cannot be interrupted.

Verify before relying

• Whether the package is actively maintained or if there are known issues with modern Python versions.
• Performance overhead compared to native multiprocessing in typical workloads.
• Compatibility with concurrent.futures.ProcessPoolExecutor when using the dill extra.

Package facts

Evidence: aioprocessing-2.0.1-py3-none-any.whl

Keywords: asyncio, multiprocessing, coroutine

Tags

More Python Modules packages