Pre-release

This release is a pre-release and may not be stable for production use.

mt_asyncio

mt_asyncio is a parallel asyncio runtime for free-threaded Python: one event loop that steps asyncio tasks across many OS threads, written in Rust on top of the mio crate.

pip install --pre mt-asyncio

Releases are alpha for now, so --pre is required until the first stable one. Requires a free-threaded CPython build (python3.14t or python3.15t).

import mt_asyncio.asyncio as asyncio

async def handle(n):
    await asyncio.sleep(0.1)
    return n * 2

async def main():
    return await asyncio.gather(*[handle(i) for i in range(1000)])

asyncio.run(main())

That is the whole idea: import mt_asyncio.asyncio as asyncio and your existing coroutines run on more than one core.

Experimental — expect bugs. This is an experiment in whether asyncio can be made genuinely parallel on free-threaded Python, not production software. Releases are alpha and the APIs are subject to breaking changes. More to the point: taking away the single-threaded loop invalidates assumptions that library authors were entitled to make and never had to write down, so failures here show up as races, hangs, and — where a C extension dereferences state it assumed could not change underneath it — segfaults. Several such assumptions have been found and put back (see COMPATIBILITY.md); assume more are still out there. Do not put this in front of anything that matters.

Attribution: mt_asyncio is derived from TonIO by Giovanni Barillari and keeps its Rust runtime core; TonIO's own yield- and async-flavoured APIs are not exposed here. mt_asyncio is not affiliated with or endorsed by the TonIO project. See NOTICE.

Note: free-threaded Python (3.14t+) and Unix systems only.

At a glance

An unmodified asyncpg against a real Postgres: 20 concurrent connections each fetching 50,000 rows — 1,000,000 rows a run — with a per-row Python loop over the result. Free-threaded CPython 3.14.4, Apple M5 Max (6 performance + 12 efficiency cores), median of 3 via bench/pg_asyncpg_scale.py --cpu 40:

	time	rows/s	vs stdlib
stdlib asyncio	1697 ms	589k	1.00×
mt_asyncio, 1 worker	1723 ms	580k	0.99×
mt_asyncio, 2 workers	1041 ms	961k	1.63×
mt_asyncio, 4 workers	642 ms	1,557k	2.64×
mt_asyncio, 8 workers	523 ms	1,911k	3.24×
mt_asyncio, 12 workers	497 ms	2,012k	3.41×

At one worker it is a wash, and that is the point: the runtime is not making the driver faster. The queries wait concurrently on any loop — what changes is that the row handling afterwards stops queueing up behind a single thread.

Nothing was written for this. The driver is the unmodified wheel from PyPI, the queries are ordinary, and the whole change to the program is two lines at the top:

import mt_asyncio.asyncio as asyncio
asyncio.compat.install()          # before importing anything that should see it

import asyncpg                    # unmodified, straight from PyPI

DSN = 'postgresql://postgres@127.0.0.1/bench'

# fixture, created once:
#   create table bench_scale_rows as
#       select g as id, (g * 7919)::bigint as v, 'row-' || g || '-payload' as t
#       from generate_series(1, 50000) g;
SQL = 'select id, v, t from bench_scale_rows'

def handle(rows):                 # ordinary Python work, once per row
    acc = 0
    for rid, v, t in rows:
        acc += rid + v + len(t)
    return acc

async def query(conn):
    return handle(await conn.fetch(SQL))     # 50,000 rows, then work on each

async def main():
    conns = [await asyncpg.connect(DSN) for _ in range(20)]
    # 20 queries in flight at once. The waiting overlaps on any loop; what
    # differs is the handle() loops afterwards — stdlib asyncio has one thread
    # to run all 20 on, so they queue behind each other. Here they do not.
    return await asyncio.gather(*[query(c) for c in conns])

asyncio.run(main(), threads=12)   # 20 queries, 1,000,000 rows, 12 workers

compat.install() points the asyncio namespace at mt_asyncio's implementations, so a library that does import asyncio internally gets this loop rather than CPython's. asyncpg then opens its connections through create_connection and talks to the network through transports exactly as it always has — it never learns that its callbacks and its tasks are now running on twelve threads.

The synthetic suite covers the shapes this one workload cannot: CPU work between awaits reaches 7.34× at 16 threads, while timers and cancellation are genuinely slower than stdlib. See Performance — and read its note on what the CPU kernel does and does not stand in for before planning around the high numbers. The asyncpg table above is the more representative one, because the per-row work there is ordinary object handling rather than arithmetic.

Why

CPython's asyncio loop is single-threaded by design: one thread steps every task, so an async workload cannot use more than one core no matter how many tasks it has. On free-threaded Python that limit is no longer necessary.

mt_asyncio keeps asyncio's API and semantics but replaces the scheduler: tasks are handed to a Rust work-stealing runtime and stepped in parallel on its worker threads. I/O readiness comes from an edge-triggered mio reactor, and run_in_executor from a native blocking thread-pool.

The trade-off is stated up front, because it is the one thing that changes: callbacks are no longer serialized. Stdlib asyncio gives you implicit mutual exclusion (everything runs on the loop thread); mt_asyncio does not. Shared state touched from tasks or callbacks needs a lock — the ones in mt_asyncio.asyncio are genuinely cross-thread. This is the price of using multiple cores.

Usage

Everything lives in mt_asyncio.asyncio, which mirrors the asyncio namespace:

import mt_asyncio.asyncio as asyncio

async def worker(queue):
    while True:
        item = await queue.get()
        if item is None:
            return
        await process(item)

async def main():
    queue = asyncio.Queue(maxsize=100)

    async with asyncio.TaskGroup() as tg:
        for _ in range(8):
            tg.create_task(worker(queue))

        async for item in source():
            await queue.put(item)
        for _ in range(8):
            await queue.put(None)

asyncio.run(main())

Supported: run, create_task, gather, wait, wait_for, shield, as_completed, sleep, to_thread, TaskGroup, timeout/timeout_at, Future, Task (with cancel/cancelling/uncancel), Lock, Event, Condition, Semaphore, BoundedSemaphore, Queue/LifoQueue/PriorityQueue, run_coroutine_threadsafe, wrap_future, and the loop's call_soon, call_later, call_at, run_in_executor, getaddrinfo, and sock_* methods.

Networking: add_reader/add_writer, create_connection, create_server, start_tls, open_connection/start_server and TLS.

Not implemented: datagram endpoints, subprocesses, Barrier, and loop policies. See mt_asyncio/asyncio/COMPATIBILITY.md for the full surface, the behavioural differences, and the workarounds.

Third-party libraries

There are two ways to reach a database here, and which one fits depends on the shape of your concurrency rather than on what is supported.

Async driver. psycopg's async API works under compat.install() — it waits on add_reader/add_writer, which are implemented. Its wait_async loop is covered in tests/test_netlibs.py against both backends, and concurrent queries across many connections are verified against a real server.

import mt_asyncio.asyncio as asyncio

asyncio.compat.install()   # before importing psycopg

import psycopg

async def fetch_user(conn, user_id):
    async with conn.cursor() as cur:
        await cur.execute('select name from users where id = %s', (user_id,))
        return await cur.fetchone()

async def main():
    async with await psycopg.AsyncConnection.connect('postgresql:///app') as conn:
        return await fetch_user(conn, 1)

asyncio.run(main())

No thread per query, so concurrency is bounded only by your connection pool. The cost is a reactor hop per round trip.

asyncpg works the same way and takes a different route through the loop — create_connection and transports rather than add_reader — which is why the benchmark above uses it. Two caveats. Its C protocol assumes the serialization a single-threaded loop provides; the guarantees it needs are restored per connection (COMPATIBILITY.md §1), but getting them wrong is a segfault rather than an exception, so treat asyncpg here as less proven than psycopg. And it defaults to ssl='prefer', so every connection costs an extra negotiation round trip against a server without TLS.

Sync driver behind to_thread. One pool thread per in-flight query, capped by blocking_threadpool_size (128 by default), and no event-loop work in the query path at all. This is also the only option for clients with no async API — requests, boto3, and plenty of vendor SDKs.

import mt_asyncio.asyncio as asyncio
from psycopg_pool import ConnectionPool

pool = ConnectionPool('postgresql:///app', min_size=16, max_size=16)

async def fetch_user(user_id):
    def query():
        with pool.connection() as conn:
            return conn.execute('select name from users where id = %s', (user_id,)).fetchone()

    return await asyncio.to_thread(query)

async def main():
    return await asyncio.gather(*[fetch_user(i) for i in range(1000)])

asyncio.run(main())

to_thread hands query to the runtime's native blocking pool. Note this is a better to_thread than the stdlib one rather than a fallback from it: on a free-threaded build those threads run Python concurrently, so the queries are genuinely in flight at once instead of taking turns under the GIL — and the coroutines awaiting them are stepped in parallel too. Size the connection pool, or bound it with a Semaphore, so you do not queue more work than the database can take.

The db_query benchmark measures the to_thread pattern; point MT_ASYNCIO_BENCH_DSN at a real server to run it against Postgres.

Blocking calls

Blocking directly in a coroutine is survivable here, which it is not under stdlib: it occupies one worker, and the others keep stepping tasks.

async def handler():
    time.sleep(0.05)      # occupies a worker for 50ms, not the whole loop
    return 'done'

There are two ways to make that safe, and on a free-threaded build both are legitimate — the choice is about failure modes, not speed.

Offload it. await asyncio.to_thread(...) moves the call to the blocking pool and keeps every worker free.

Or just have more workers. Blocked threads are off-CPU, so raising threads costs little. Measured with 64 concurrent 10ms blocking calls:

	8 workers	128 workers
blocking inline	102.6 ms	16.7 ms
via `to_thread`	14.9 ms	18.5 ms
CPU-bound workload	724.8 ms	362.4 ms

At 128 workers, inline blocking matches to_thread, and CPU work did not suffer from oversubscription on an 18-core machine.

What the split still buys is isolation and elasticity, not throughput:

Exhaust the blocking pool and offloads simply queue — the scheduler keeps running. Exhaust the workers and the runtime stalls, because workers are also what run task steps, timers and I/O dispatch. Raising threads moves that cliff without removing it.
Pool threads are created on demand and retire after blocking_threadpool_idle_ttl; workers are created at startup and live for the life of the process.

The cost of the split is that the two pools cannot help each other: a blocking pool thread never steps a coroutine, and a worker never picks up offloaded work.

The cliff is worth seeing, because it is silent. With 4 workers, a 50ms blocking call, and an unrelated task watching how long it is kept off the CPU:

concurrent blockers	throughput	worst stall elsewhere
3 (`threads - 1`)	unaffected	1 ms
4 (`threads`)	still unaffected	51 ms

At exactly the worker count the wall clock looks fine while everything else freezes for the full duration. The default threads is cpu_count() + 4 for this reason — headroom so ordinary blocking does not reach the edge. Use to_thread when you want that guarantee rather than a margin, and raise threads when your workload is mostly blocking and you would rather not partition your threads at all.

Sizing the runtime

run() takes a threads argument, and mt_asyncio.runtime() configures the process-wide runtime up front:

import mt_asyncio
import mt_asyncio.asyncio as asyncio

# 8 worker threads, a smaller blocking pool
mt_asyncio.runtime(threads=8, blocking_threadpool_size=32, context=True)

asyncio.run(main())

option	description	default
`threads`	runtime worker threads (scheduler and execution)	# of CPU cores + 4
`context`	propagate `contextvars` into coroutines (required by the loop)	`False`
`blocking_threadpool_size`	maximum blocking threads	128
`blocking_threadpool_idle_ttl`	idle timeout for blocking threads (seconds)	30
`signals`	signals the runtime listens for

The drop-in boundary

import mt_asyncio.asyncio as asyncio parallelizes code that uses those names. A third-party library does import asyncio internally and gets CPython's.

The C Future/Task are not the obstacle — on 3.14t the current-task slot lives in thread state and Future is internally locked. The problem is the pure-Python layer above them, which has no synchronisation at all: gather._done_callback does an unsynchronised nfinished += 1, so one lost increment means the outer future never resolves, and Lock.acquire check-then-sets _locked over a bare deque. Those failures are hangs, not wrong answers.

Compat mode points those names at mt_asyncio's own locked implementations:

import mt_asyncio.asyncio as asyncio

asyncio.compat.install()   # before importing libraries that should see it

import some_library
asyncio.run(some_library.main())

gather, wait_for, TaskGroup, Lock, Event, Queue, Future, create_task and the rest are redirected, in asyncio and in the submodules that re-export them. Install before importing anything that should see it — shadowing only rebinds module attributes, so a module that already did from asyncio import Lock keeps the original. Patching is process-global; compat.uninstall() reverses it.

Transports are implemented — add_reader/add_writer, create_connection, create_server, start_tls and streams all work, over TLS as well as plain TCP. psycopg's async API, aiohttp and websockets all drive them correctly.

The remaining boundary is one level up, and no lock can close it: a library that shares mutable state between tasks can race, because tasks step in parallel. Both aiohttp and websockets keep a registry of live connections and iterate it during server shutdown while another task mutates it, so their shutdown paths are unreliable here even though serving traffic is not. anyio (and therefore httpx) livelocks against our cooperative cancellation and is unsupported. See COMPATIBILITY.md for the measurements.

Compatibility testing

tests/test_parity.py is a differential suite: every scenario is written once and run against both stdlib asyncio and mt_asyncio.asyncio, asserting the same observable outcome. A divergence that is not listed in COMPATIBILITY.md is treated as a bug.

make test

Performance

Speedup versus stdlib asyncio on the same coroutines (free-threaded CPython 3.14.4, Apple M5 Max — 6 performance + 12 efficiency cores; median of 3 runs via bench/asyncio_bench.py, or make bench):

workload	1 thread	best
CPU work between awaits	1.21×	7.34× @16
each unit under `wait_for`	0.97×	6.59× @16
fan-out with `TaskGroup`	1.08×	5.72× @16
server handler (I/O + per-request work)	1.00×	5.28× @16
producer → queue → consumers	1.02×	3.88× @8
one shared `Lock`	0.95×	3.01× @4
pure scheduling, no per-task work	1.41×	1.60× @16
many real `sleep()` timers	0.51×	0.55× @4
create + cancel + unwind	0.62×	0.62× @1

The CPU kernel here is arithmetic on locals — x += i * i, no allocation, no shared object touched, and so the easiest work free-threaded Python can be asked to parallelize. Real handler code churns objects and refcounts things every thread shares, and pays for it: measured head to head at equal wall-clock weight, an allocating kernel scales 2.85× on twelve workers where this one scales 5.09×. Treat the high numbers below as the runtime's ceiling with contention removed, not as a forecast for application code — bench/fastapi_tax.py measures the difference, and bench/README.md §4 shows a real FastAPI handler plateauing near 2.9×.

Read that honestly. mt_asyncio is at rough parity per-thread and wins by parallelizing, so the more real work a task does between awaits, the better it does. Two things are genuinely slower: timers — each sleep() builds a Future, a TimerHandle and a helper coroutine where the runtime underneath needs only one native waiter — and cancellation, which is pure coordination and gets worse with more threads. Past 6 threads this machine is scheduling onto efficiency cores, so the 16-thread column is not 16 equal cores.

Real drivers

Synthetic workloads choose their own CPU/IO mix, so two scripts use a real Postgres instead. bench/pg_asyncpg_scale.py is the asyncpg run above; it has no upstream TonIO column because tonio-monkey ships no asyncpg patch — asyncpg never calls add_reader, it goes through transports. bench/pg_tax.py covers psycopg, where there is an upstream comparison to make; see bench/README.md.

Benchmarks must be run against a release build (make build-release); the scripts refuse to run on a debug one, which is several times slower.

License

mt_asyncio is released under the BSD-3-Clause License, the same license as TonIO, whose copyright notice it retains. Ported CPython code is additionally covered by the PSF License Agreement. See LICENSE and NOTICE.

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

mt_asyncio-0.2.0a1.tar.gz (117.1 kB view details)

Uploaded Jul 25, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

mt_asyncio-0.2.0a1-cp315-cp315t-musllinux_1_1_x86_64.whl (609.1 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmusllinux: musl 1.1+ x86-64

mt_asyncio-0.2.0a1-cp315-cp315t-musllinux_1_1_armv7l.whl (675.4 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmusllinux: musl 1.1+ ARMv7l

mt_asyncio-0.2.0a1-cp315-cp315t-musllinux_1_1_aarch64.whl (561.0 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmusllinux: musl 1.1+ ARM64

mt_asyncio-0.2.0a1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (396.2 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmanylinux: glibc 2.17+ x86-64

mt_asyncio-0.2.0a1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl (398.5 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmanylinux: glibc 2.17+ ARMv7l

mt_asyncio-0.2.0a1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (383.6 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmanylinux: glibc 2.17+ ARM64

mt_asyncio-0.2.0a1-cp315-cp315t-manylinux_2_12_i686.manylinux2010_i686.whl (423.7 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmanylinux: glibc 2.12+ i686

mt_asyncio-0.2.0a1-cp315-cp315t-macosx_11_0_arm64.whl (350.3 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmacOS 11.0+ ARM64

mt_asyncio-0.2.0a1-cp315-cp315t-macosx_10_12_x86_64.whl (367.0 kB view details)

Uploaded Jul 25, 2026 CPython 3.15tmacOS 10.12+ x86-64

mt_asyncio-0.2.0a1-cp314-cp314t-musllinux_1_1_x86_64.whl (609.3 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmusllinux: musl 1.1+ x86-64

mt_asyncio-0.2.0a1-cp314-cp314t-musllinux_1_1_armv7l.whl (675.2 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmusllinux: musl 1.1+ ARMv7l

mt_asyncio-0.2.0a1-cp314-cp314t-musllinux_1_1_aarch64.whl (561.1 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmusllinux: musl 1.1+ ARM64

mt_asyncio-0.2.0a1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (396.4 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmanylinux: glibc 2.17+ x86-64

mt_asyncio-0.2.0a1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl (398.3 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARMv7l

mt_asyncio-0.2.0a1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (383.8 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARM64

mt_asyncio-0.2.0a1-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl (423.5 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmanylinux: glibc 2.12+ i686

mt_asyncio-0.2.0a1-cp314-cp314t-macosx_11_0_arm64.whl (350.5 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmacOS 11.0+ ARM64

mt_asyncio-0.2.0a1-cp314-cp314t-macosx_10_12_x86_64.whl (367.1 kB view details)

Uploaded Jul 25, 2026 CPython 3.14tmacOS 10.12+ x86-64

File details

Details for the file mt_asyncio-0.2.0a1.tar.gz.

File metadata

Download URL: mt_asyncio-0.2.0a1.tar.gz
Upload date: Jul 25, 2026
Size: 117.1 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.14

File hashes

Hashes for mt_asyncio-0.2.0a1.tar.gz
Algorithm	Hash digest
SHA256	`5d509a3e42243cae35497e2a2f63f8a0f8f3a5c4e6c9b22d42fa5ce01fec0996`
MD5	`1e1267585388b23e5f0a064f91958bcd`
BLAKE2b-256	`db5330e010b67a765d84dc29d222abdb7391fe923e26c3cafde19b96719cfd95`

Algorithm	Hash digest
SHA256	`acd5dd9c13403077bd0b63c98616cf52f0751bd0c82188c4306dd87d8bad4f83`
MD5	`fb03fdab872be10e66371dff6eb7351f`
BLAKE2b-256	`5ff0f399a5702de42a9d9bb55ae60a31459ff52fb1554e72a31c2d0ab8ef2927`

Algorithm	Hash digest
SHA256	`8eaf691bf3fc521a7f30a1a6dfa8dccffcfddd012ed12f985955cfcd41d972dd`
MD5	`a71ff5de87ecfc6c5c3509b7651a605c`
BLAKE2b-256	`b2c95cdd18107d49c6917315bd57a06d5fbbd3ce2ca00b224a921f6ab5ef824e`

Algorithm	Hash digest
SHA256	`22be0ca65ae47c5415d7fa5acb48801aa16ba84c90cfac7a0215965cbc0b889e`
MD5	`d7e97c6682fa7619cc9ab0d28771645c`
BLAKE2b-256	`83a7283810d43c2bbb30ca93438d4b47acb1e3c33c2559834c2e69ae7540ace8`

Algorithm	Hash digest
SHA256	`3cff037d452fe989556dfc37e9d6227583993854c3f401d07c421c5c1d6deae0`
MD5	`dcccf22f4b44f6d77a6263965b4bc4d8`
BLAKE2b-256	`ed989d51ee648a3f0fd218bb712df723411e219c67451dfbbb353b8c223c1f7d`

Algorithm	Hash digest
SHA256	`d4de9f9640c2cae76a993381cc7f24ab918c11c392e1cdf15661bb375c2d40ec`
MD5	`c010f5d25ce0be4ac82b465581602d27`
BLAKE2b-256	`1a0e8f87adca87cd43a77dbe951f0581b20f1a3fb0f332a44f4a55fcde0864ed`

Algorithm	Hash digest
SHA256	`919235f63a0e459a3567e8e11584c1ad3bc5f842ad65ca0649156ee3e30534fd`
MD5	`061f52e0926124b9f651cf739f564c0a`
BLAKE2b-256	`b2400c5d4f059e71b2cf86e6ab35508a219cc041f0be7100fb8b43051290a30c`

Algorithm	Hash digest
SHA256	`fac7ac0994061708287f38fe6192ca4ee326eed53ed2886119d1ffe099e0561c`
MD5	`39f51d9334b977749733bc9f8eca1807`
BLAKE2b-256	`9f3299c5dbf6da0343bce4f8ab4f273c0fdb6e33ce08cfa580a80fedea6b2ccd`

Algorithm	Hash digest
SHA256	`a43b4955a840f4ffbc18d1a2dce170762a7d2c3befc00faf3269048096a9d1dc`
MD5	`3038f7e93577040cce246f34a279e6de`
BLAKE2b-256	`049b408352d3a4f7385fd46e136acf8af9bcd8bcb11c0cc22a9fdefca2b0955c`

Algorithm	Hash digest
SHA256	`154ae99b4eab094858c94ee80bc37834581341019cb62dc80e02da239ab9d970`
MD5	`5ea5fbe14bc49eefb143c60955bad585`
BLAKE2b-256	`dabe2f6bca85f0af24daec4c7cf26be6db70f7ea823b806ece1cb79a315df875`

Algorithm	Hash digest
SHA256	`0126d571a5df1edbc1d187cba13325b3ff193249844c1e766e92c378230f9510`
MD5	`7d3d7a178db5d095ba823661a3bbf08e`
BLAKE2b-256	`88f0638e4f77c61e05fee6b2fbfa416fcd7242208ae6bc6c896324f44c8cbf5f`

Algorithm	Hash digest
SHA256	`83d2a1889ff74581c06fb5af849dfc822621dd1da8ee8d18d9efd0572c2f21ea`
MD5	`81e122da7339239bb58a048ccec100be`
BLAKE2b-256	`644e17d97390906bbd6ab14b69fe431b19049f8dc1ed0126f961f6535c706214`

Algorithm	Hash digest
SHA256	`1b6099e45ad6179195d55582e32ea7049e43c7e617642b8e7802106e42bb1e80`
MD5	`370f58b123320291596145ea81e38c51`
BLAKE2b-256	`2a4639531a44549dce33b334c9d1880e17b423a3f76587018bc6b6da5de34d2a`

Algorithm	Hash digest
SHA256	`3d9f01f9def612579ddf944cf560beeb6846342a15f4004fdd076ee2b9feebde`
MD5	`9e0eccb9f6d0c67cc774cb4a653328f6`
BLAKE2b-256	`bdeadf5540dbfffeb0a0aafaeaefa408777ab72a276cd6b539764e60246d8fa4`

Algorithm	Hash digest
SHA256	`a2fd11f99c053a83f4895d4de51bd3ce16352427267c226c1f93e55b5269c9b0`
MD5	`90cfc383260484277c26e7359684fabd`
BLAKE2b-256	`5cdcbc4302f9fe235dc28049350788046458de51c0d99116c467000996d9a6b3`

Algorithm	Hash digest
SHA256	`cad7b708ac315c07f8b8aba7f4b65f404b419073dbdc2e1a510d4ac60e32a7bf`
MD5	`ed84ebf5686d18359bb014e839aecfcc`
BLAKE2b-256	`9d89f76597481c328f6571855cd93da6e9150591e67ac744f9aaae4c53c6c57e`

Algorithm	Hash digest
SHA256	`760ee9b33bf01b28d6ee03215d9ba1367defa9a048d3cb43998e8c3c2baaf77c`
MD5	`b7ac84f251560cbe45bc437b60c0c9f5`
BLAKE2b-256	`d4087ea8d97c5324eba85b045fe0181a5ff39f052de5e6ec2f8fabcf94a7c360`

Algorithm	Hash digest
SHA256	`68ef638e10120d8370333d422a525124ac151ee0a5d406820662a8c1ed963ad6`
MD5	`c4993e78177fbdecf080b48780c9c593`
BLAKE2b-256	`e25da451e76ff4ad0e13e6d8bbbcc1cf1e986c2b35cefcee5725c2909a6c1132`

Algorithm	Hash digest
SHA256	`ad82ce75e799a847c41cf7c2ca862556010dd6b7f43e8ea595c7e812133c870b`
MD5	`912c9366b758ac24793ecaddaa7f3160`
BLAKE2b-256	`75d7b10fc8181d98a3c418d7f8cb6549d34e135f0881ac90de9e7c51012d6c1f`

mt-asyncio 0.2.0a1

mt_asyncio

At a glance

Why

Usage

Third-party libraries

Blocking calls

Sizing the runtime

The drop-in boundary

Compatibility testing

Performance

Real drivers

License

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes