TonIO

TonIO is a multi-threaded async runtime for free-threaded Python, built in Rust on top of the mio crate, and inspired by tinyio, trio and tokio.

Warning: TonIO is currently a work in progress and in alpha state. The APIs are subtle to breaking changes.

Note: TonIO is available on free-threaded Python and Unix systems only.

TonIO supports both using yield and the more canonical async/await notations, with the latter being available as part of the tonio.colored module. Following code snippets show both the usages.

Warning: despite the fact TonIO supports async and await notations, it's not compatible with any asyncio object like futures and tasks. The TonIO-Monkey project provides patches for some popular asyncio packages.

In a nutshell

yield syntax

import tonio

def wait_and_add(x: int) -> int:
    yield tonio.sleep(1)
    return x + 1

def foo():
    four, five = yield tonio.spawn(
        wait_and_add(3), 
        wait_and_add(4)
    )
    return four, five

out = tonio.run(foo())
assert out == (4, 5)

await syntax

import tonio.colored as tonio

async def wait_and_add(x: int) -> int:
    await tonio.sleep(1)
    return x + 1

async def foo():
    four, five = await tonio.spawn(
        wait_and_add(3), 
        wait_and_add(4)
    )
    return four, five

out = tonio.run(foo())
assert out == (4, 5)

Usage

Entrypoint

Every TonIO program consist of an entrypoint, which should be passed to the run method:

yield syntax

import tonio

def main():
    yield
    print("Hello world")

tonio.run(main())

await syntax

import tonio.colored as tonio

async def main():
    await tonio.yield_now()
    print("Hellow world")

tonio.run(main())

TonIO also provides a main decorator, thus we can rewrite the previous example as:

yield syntax

import tonio

@tonio.main
def main():
    yield
    print("Hello world")

main()

await syntax

import tonio.colored as tonio

@tonio.main
async def main():
    await tonio.yield_now()
    print("Hello world")

main()

Note: as you can see the colored module provides the additional yield_now coroutine, a quick way to define a suspension point, given you cannot just yield as in the non-colored notation.

Note: both run and main can only be called once per program. To run the runtime multiple times in the same program, follow the section below.

Manually managing the runtime

TonIO also provides the runtime function, to manually manage the runtime lifecycle:

import tonio

def _run1():
    ...

async def _run2():
    ...

def main():
    runtime = tonio.runtime()
    runtime.run_until_complete(_run1())
    runtime.run_until_complete(_run2())

Runtime options

The run, main and runtime methods accept options, specifically:

option name	description	default
`context`	enable `contextvars` usage in coroutines	`False`
`signals`	list of signals to listen to
`threads`	Number of runtime threads	# of CPU cores
`blocking_threadpool_size`	Maximum number of blocking threads	128
`blocking_threadpool_idle_ttl`	Idle timeout for blocking threads (in seconds)	30

Events

The core object in TonIO is Event. It's basically a wrapper around an atomic boolean flag, initialised with False. Event provides the following methods:

is_set(): return the value of the flag
set(): set the flag to True
clear(): set the flag to False
wait(timeout=None): returns a coroutine you can yield on that unblocks when the flag is set to True or the timeout expires. Timeout is in seconds.

yield syntax

import tonio

@tonio.main
def main():
    event = tonio.Event()

    def setter():
        yield tonio.sleep(1)
        event.set()

    tonio.spawn(setter())
    yield event.wait()

await syntax

import tonio.colored as tonio

@tonio.main
async def main():
    event = tonio.Event()

    async def setter():
        await tonio.sleep(1)
        event.set()

    tonio.spawn(setter())
    await event.wait()

Spawning tasks

TonIO provides the spawn method to schedule new coroutines onto the runtime:

yield syntax

import tonio

def doubv(v):
    yield
    return v * 2

@tonio.main
def main():
    parallel = tonio.spawn(doubv(2), doubv(3))
    v3 = yield doubv(4)
    v1, v2 = yield parallel
    print([v1, v2, v3])

await syntax

import tonio.colored as tonio

async def doubv(v):
    await tonio.yield_now()
    return v * 2

@tonio.main
async def main():
    parallel = tonio.spawn(doubv(2), doubv(3))
    v3 = await doubv(4)
    v1, v2 = await parallel
    print([v1, v2, v3])

Coroutines passed to spawn get schedule onto the runtime immediately. Using yield or await on the return value of spawn just waits for the coroutines to complete and retreive the results.

Blocking tasks

TonIO provides the spawn_blocking method to schedule blocking operations onto the runtime:

yield syntax

import tonio

def read_file(path):
    with open(file, "r") as f:
        return f.read()

@tonio.main
def main():
    file_data = yield tonio.spawn_blocking(
        read_file, 
        "sometext.txt"
    )

await syntax

import tonio.colored as tonio

def read_file(path):
    with open(file, "r") as f:
        return f.read()

@tonio.main
async def main():
    file_data = await tonio.spawn_blocking(
        read_file, 
        "sometext.txt"
    )

Running tasks from synchronous contexts

TonIO provides the block_on method to spawn coroutines from a synchronous context. It works the same way of spawn, except it accepts a single coroutine and it blocks the current thread until the coroutine is completed.

Warning: using block_on from within a coroutine might produce a runtime deadlock.

Map utilities

TonIO provides the map and map_blocking utilities to spawn the same operation with an iterable of parameters:

yield syntax

import tonio

accum = []

def task(no):
    yield tonio.sleep(0.5)
    accum.append(no * 2)

@tonio.main
def main():
    yield tonio.map(task, range(4))

await syntax

import tonio.colored as tonio

accum = []

async def task(no):
    await tonio.sleep(0.5)
    accum.append(no * 2)

@tonio.main
async def main():
    await tonio.map(task, range(4))

Completion-based iterators

TonIO provides the as_completed utility to iterate over task results based on completion order:

yield syntax

import tonio

def _sleep(v):
    yield tonio.sleep(v)
    return v

@tonio.main
def main():
    vals = []
    for task in tonio.as_completed(
        _sleep(0.5),
        _sleep(0.1),
        _sleep(0.3),
    ):
        vals.append(yield task)

await syntax

import tonio.colored as tonio

async def _sleep(v):
    await tonio.sleep(v)
    return v

@tonio.main
async def main():
    vals = []
    async for val in tonio.as_completed(
        _sleep(0.5),
        _sleep(0.1),
        _sleep(0.3),
    ):
        vals.append(val)

Scopes and cancellations

TonIO provides a scope context, that lets you cancel work spawned within it:

yield syntax

import tonio

def slow_push(target, sleep):
    yield tonio.sleep(sleep)
    target.append(True)

@tonio.main
def main():
    values = []
    with tonio.scope() as scope:
        scope.spawn(_slow_push(values, 0.1))
        scope.spawn(_slow_push(values, 2))
        yield tonio.sleep(0.2)
        scope.cancel()
    yield scope()
    assert len(values) == 1

await syntax

import tonio.colored as tonio

async def slow_push(target, sleep):
    await tonio.sleep(sleep)
    target.append(True)

@tonio.main
async def main():
    values = []
    async with tonio.scope() as scope:
        scope.spawn(_slow_push(values, 0.1))
        scope.spawn(_slow_push(values, 2))
        await tonio.sleep(0.2)
        scope.cancel()
    assert len(values) == 1

When you yield on the scope, it will wait for all the spawned coroutines to end. If the scope was canceled, then all the pending coroutines will be canceled.

Note: as you can see, the colored version of scope doesn't require to be awaited, as it will yield when exiting the context.

Select first completing task

TonIO also provides a select utility to cancel remaining work on the first completing task:

yield syntax

import tonio

def slow_push(target, sleep):
    yield tonio.sleep(sleep)
    target.append(True)

@tonio.main
def main():
    values = []
    yield tonio.select(
        _slow_push(values, 0.1),
        _slow_push(values, 2)
    )
    assert len(values) == 1

await syntax

import tonio.colored as tonio

async def slow_push(target, sleep):
    await tonio.sleep(sleep)
    target.append(True)

@tonio.main
async def main():
    values = []
    await tonio.select(
        _slow_push(values, 0.1),
        _slow_push(values, 2)
    )
    assert len(values) == 1

Time-related functions

tonio.time.time(): a function returning the runtime's clock (in seconds, microsecond resolution)
tonio.time.sleep(delay): a coroutine you can yield on to sleep (delay is in seconds)
tonio.time.timeout(coro, timeout): a coroutine you can yield on returning a tuple (output, success). If the coroutine succeeds in the given time then the pair (output, True) is returned. Otherwise this will return (None, False).

Note: time.sleep is also exported to the main tonio module.

Note: all of the above functions are also present in tonio.colored.time module.

Scheduling work

TonIO provides the time.interval function to create interval objects you can yield on a scheduled basis:

yield syntax

import tonio
from tonio import time

def some_task():
    ...

def scheduler():
    interval = time.interval(1)
    while True:
        yield interval.tick()
        tonio.spawn(some_task())

@tonio.main
def main():
    tonio.spawn(scheduler())
    # do some other work

await syntax

import tonio.colored as tonio
from tonio.colored import time

async def some_task():
    ...

async def scheduler():
    interval = time.interval(1)
    while True:
        await interval.tick()
        tonio.spawn(some_task())

@tonio.main
async def main():
    tonio.spawn(scheduler())
    # do some other work

The interval method first argument is the interval in seconds resolution, and the method also accepts an optional at argument, to delay the first execution at a specific time (from the runtime's clock perspective):

from tonio import time

# tick every 500ms, with the first tick happening in 5 seconds from now
interval = time.interval(0.5, time.time() + 5)

Synchronization primitives

Synchronization primitives are exposed in the tonio.sync module.

Lock

Implements a classic mutex, or a non-reentrant, single-owner lock for coroutines:

yield syntax

import tonio
from tonio import sync

@tonio.main
def main():
    # counter can't go above 1
    counter = 0

    def _count(lock):
        nonlocal counter
        with (yield lock()):
            counter += 1
            yield
            counter -= 1
    
    lock = sync.Lock()
    yield tonio.spawn(*[
        _count(lock)
        for _ in range(10)
    ])

await syntax

import tonio.colored as tonio
from tonio.colored import sync

@tonio.main
async def main():
    # counter can't go above 1
    counter = 0

    async def _count(lock):
        nonlocal counter
        async with lock:
            counter += 1
            await tonio.yield_now()
            counter -= 1
    
    lock = sync.Lock()
    await tonio.spawn(*[
        _count(lock)
        for _ in range(10)
    ])

The Lock object also implements an or_raise method, that will immediately fail when the lock cannot be acquired:

from tonio.exceptions import WouldBlock

try:
    with lock.or_raise():
        ...
except WouldBlock:
    ...

Semaphore

A semaphore for coroutines:

yield syntax

import tonio
from tonio import sync

@tonio.main
def main():
    # counter can't go above 2
    counter = 0

    def _count(semaphore):
        nonlocal counter
        with (yield semaphore()):
            counter += 1
            yield
            counter -= 1
    
    semaphore = sync.Semaphore(2)
    yield tonio.spawn(*[
        _count(semaphore)
        for _ in range(10)
    ])

await syntax

import tonio.colored as tonio
from tonio.colored import sync

@tonio.main
async def main():
    # counter can't go above 2
    counter = 0

    async def _count(semaphore):
        nonlocal counter
        async with semaphore:
            counter += 1
            await tonio.yield_now()
            counter -= 1
    
    semaphore = sync.Semaphore(2)
    await tonio.spawn(*[
        _count(semaphore)
        for _ in range(10)
    ])

As for locks, the Semaphore object also implements an or_raise method, that will immediately fail when the lock cannot be acquired:

from tonio.exceptions import WouldBlock

try:
    with semaphore.or_raise():
        ...
except WouldBlock:
    ...

The Semaphore object also implements a tokens method, that returns the number of available tokens.

Barrier

A barrier for coroutines:

yield syntax

import tonio
from tonio import sync

@tonio.main
def main():
    barrier = sync.Barrier(3)
    count = 0

    def _start_at_3():
        nonlocal count
        count += 1
        i = yield barrier.wait()
        assert count == 3
        return i

    yield tonio.spawn(*[
        _start_at_3()
        for _ in range(3)
    ])

await syntax

import tonio.colored as tonio
from tonio.colored import sync

@tonio.main
async def main():
    barrier = sync.Barrier(3)
    count = 0

    async def _start_at_3():
        nonlocal count
        count += 1
        i = await barrier.wait()
        assert count == 3
        return i

    await tonio.spawn(*[
        _start_at_3()
        for _ in range(3)
    ])

The Barrier object also implements a value method, which returns the current value of the barrier.

Channels

Multi-producer multi-consumer channels for inter-coroutine communication.

The tonio.sync.channel module provides both a channel and an unbounded constructors.
The main difference between bounded and unbounded channels, as the names suggest, is that while the first will suspend sending messages once the specified length is reached, and it will resume accepting messages once the existing buffer is consumed, the latter will always accept new messages. That's also why, the sender part of a bounded channel is async, while in the unbounded is not.

Bounded channel

yield syntax

import tonio
from tonio import sync
from tonio.sync import channel

def producer(sender, barrier, offset):
    for i in range(20):
        message = offset + 1
        yield sender.send(message)
    yield barrier.wait()

def consumer(receiver):
    while True:
        try:
            message = yield receiver.receive()
            print(message)
        except Exception:
            break

@tonio.main
def main():
    def close(sender, barrier):
        yield barrier.wait()
        sender.close()

    sender, receiver = channel.channel(2)
    barrier = sync.Barrier(3)
    yield tonio.spawn(*[
        producer(sender, barrier, 100),
        producer(sender, barrier, 200),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        close(sender, barrier),
    ])

await syntax

import tonio.colored as tonio
from tonio.colored import sync
from tonio.colored.sync import channel

async def producer(sender, barrier, offset):
    for i in range(20):
        message = offset + 1
        await sender.send(message)
    await barrier.wait()

async def consumer(receiver):
    while True:
        try:
            message = await receiver.receive()
            print(message)
        except Exception:
            break

@tonio.main
async def main():
    async def close(sender, barrier):
        await barrier.wait()
        sender.close()

    sender, receiver = channel.channel(2)
    barrier = sync.Barrier(3)
    await tonio.spawn(*[
        producer(sender, barrier, 100),
        producer(sender, barrier, 200),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        close(sender, barrier),
    ])

Unbounded channel

yield syntax

import tonio
from tonio import sync
from tonio.sync import channel

def producer(sender, barrier, offset):
    for i in range(20):
        message = offset + 1
        sender.send(message)
    yield barrier.wait()

def consumer(receiver):
    while True:
        try:
            message = yield receiver.receive()
            print(message)
        except Exception:
            break

@tonio.main
def main():
    def close(sender, barrier):
        yield barrier.wait()
        sender.close()

    sender, receiver = channel.unbounded()
    barrier = sync.Barrier(3)
    yield tonio.spawn(*[
        producer(sender, barrier, 100),
        producer(sender, barrier, 200),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        close(sender, barrier),
    ])

await syntax

import tonio.colored as tonio
from tonio.colored import sync
from tonio.colored.sync import channel

async def producer(sender, barrier, offset):
    for i in range(20):
        message = offset + 1
        sender.send(message)
    await barrier.wait()

async def consumer(receiver):
    while True:
        try:
            message = await receiver.receive()
            print(message)
        except Exception:
            break

@tonio.main
async def main():
    async def close(sender, barrier):
        await barrier.wait()
        sender.close()

    sender, receiver = channel.unbounded()
    barrier = sync.Barrier(3)
    await tonio.spawn(*[
        producer(sender, barrier, 100),
        producer(sender, barrier, 200),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        consumer(receiver),
        close(sender, barrier),
    ])

Network module

Network primitives are exposed under the tonio.net module.

Streams

The high-level network primitives in TonIO are centered aroud the SocketStream and SocketListener objects.

The SocketListener object implements an accept coroutine which returns a SocketStream object.
The SocketStream object implements the send_all and receive_some coroutines to send and receive data.
Both objects implement a close method to shutdown the underlying socket.

You can create and interact with the above objects using some high-level helpers in the net module, specifically:

open_tcp_stream: a coroutine to open a SocketStream connected to a TCP endpoint
open_unix_socket: a coroutine to open a SocketStream connected to a Unix socket
open_tcp_listeners: a coroutine to initialise SocketListener objects
open_unix_listener: a coroutine to initialise a SocketListener on a Unix socket path
serve_listeners: a coroutine to spawn SocketListener accept loops targeting a handler
serve_tcp: a coroutine that joins open_tcp_listeners and serve_listeners in one call
serve_unix: a coroutine that joins open_unix_listener and serve_listeners in one call

yield syntax

from tonio.net import open_tcp_stream, serve_tcp

def server():
    yield serve_tcp(
        server_handle, 
        host='127.0.0.1', 
        port=8000
    )

def server_handle(stream):
    # receive some data
    data = yield stream.receive_some()

def client():
    stream = yield open_tcp_stream(
        host='127.0.0.1', 
        port=8000
    )
    # send some data
    yield stream.send_all("message")

await syntax

from tonio.colored.net import open_tcp_stream, serve_tcp

async def server():
    await serve_tcp(
        server_handle, 
        host='127.0.0.1', 
        port=8000
    )

async def server_handle(stream):
    # receive some data
    data = await stream.receive_some()

async def client():
    stream = await open_tcp_stream(
        host='127.0.0.1', 
        port=8000
    )
    # send some data
    await stream.send_all("message")

Unix domain sockets use the same objects, with serve_unix and open_unix_socket:

yield syntax

from tonio.net import open_unix_socket, serve_unix

def server():
    yield serve_unix(
        server_handle, 
        '/tmp/app.sock', 
        mode=0o600
    )

def client():
    stream = yield open_unix_socket(
        '/tmp/app.sock'
    )
    yield stream.send_all("message")

await syntax

from tonio.colored.net import open_unix_socket, serve_unix

async def server():
    await serve_unix(
        server_handle, 
        '/tmp/app.sock', 
        mode=0o600
    )

async def client():
    stream = await open_unix_socket(
        '/tmp/app.sock'
    )
    await stream.send_all("message")

TLS streams

TonIO implement TLS wrappers around the streaming APIs through primitives in the tonio.net.tls module.

TonIO provides the TLSStream and TLSListener object wrappers and the following high-level helpers:

open_tls_over_tcp_stream: a coroutine to open a TLSStream wrapping a TCP SocketStream
open_tls_over_tcp_listeners: a coroutine to initialise TLSListener objects
serve_tls_over_tcp: a coroutine that joins open_tls_over_tcp_listeners and serve_listeners in one call

Low-level sockets

The tonio.net.socket module provides TonIO's basic low-level networking API.
Generally, the API exposed by this module mirrors the standard library socket module.

TonIO socket objects are overall very similar to the standard library socket objects, with the main difference being that blocking methods become coroutines.

yield syntax

import tonio
from tonio.net import socket

def server():
    sock = socket.socket()
    with sock:
        yield sock.bind(('127.0.0.1', 8000))
        sock.listen()

        while True:
            client, _ = yield sock.accept()
            tonio.spawn(server_handle(client))

def server_handle(connection):
    with connection:
        # receive some data
        data = yield connection.recv(4096)

def client():
    sock = socket.socket()
    with sock:
        yield sock.connect(('127.0.0.1', 8000))
        yield sock.send("message")

await syntax

import tonio.colored as tonio
from tonio.colored.net import socket

async def server():
    sock = socket.socket()
    with sock:
        await sock.bind(('127.0.0.1', 8000))
        sock.listen()

        while True:
            client, _ = await sock.accept()
            tonio.spawn(server_handle(client))

async def server_handle(connection):
    with connection:
        # receive some data
        data = await connection.recv(4096)

async def client():
    sock = socket.socket()
    with sock:
        await sock.connect(('127.0.0.1', 8000))
        await sock.send("message")

Filesystem module

TonIO's fs module exposes async API for filesystem operations (that are run in the blocking thread-pool). It provides open, a Path class mirroring pathlib.Path, and wrap_file to adopt an already-open file object.

yield syntax

import tonio
import tonio.fs as fs

def main():
    f = yield fs.open('data.txt', 'w')
    yield f.write('hello')
    yield f.close()

    path = fs.Path('data.txt')
    if (yield path.exists()):
        print((yield path.read_text()))

    for entry in (yield fs.Path('.').iterdir()):
        print(entry.name)

await syntax

import tonio.colored as tonio
import tonio.colored.fs as fs

async def main():
    async with await fs.open('data.txt', 'w') as f:
        await f.write('hello')

    path = fs.Path('data.txt')
    if await path.exists():
        print(await path.read_text())

    for entry in await fs.Path('.').iterdir():
        print(entry.name)

Operations that touch the filesystem are asynchronous; everything else stays synchronous.

Note: methods returning several paths (iterdir, glob, rglob, walk) are resolved in a single hop and give back a list. Since walk is fully materialised, mutating its dirnames does not prune the traversal, unlike pathlib.Path.walk.

Reading a file line by line differs between the two flavours. The await syntax supports async for and async with, neither of which the yield syntax can express:

yield syntax

def read_lines(path):
    f = yield fs.open(path, 'r')
    try:
        while True:
            line = yield f.readline()
            if not line:
                break
            print(line)
    finally:
        yield f.close()

await syntax

async def read_lines(path):
    async with await fs.open(path, 'r') as f:
        async for line in f:
            print(line)

Subprocesses

TonIO exposes two coroutines to run child processes: run_process for the common "run it and collect the outcome" case, and open_process for interacting with a process while it runs. Both spawn the process on the blocking thread-pool.

run_process returns a subprocess.CompletedProcess and accepts:

stdin: bytes to feed to the child (defaults to b'', meaning "close stdin immediately"), or a file descriptor/subprocess constant
capture_stdout / capture_stderr: when true, the relevant stream is collected and available on the result
check: when true (the default), a non-zero exit code raises subprocess.CalledProcessError

Any other keyword argument is forwarded to subprocess.Popen.

yield syntax

import tonio

def main():
    result = yield tonio.run_process(
        ['echo', 'hello'],
        capture_stdout=True
    )
    print(result.returncode)
    print(result.stdout)

await syntax

import tonio.colored as tonio

async def main():
    result = await tonio.run_process(
        ['echo', 'hello'],
        capture_stdout=True
    )
    print(result.returncode)
    print(result.stdout)

open_process returns a Process object instead, giving access to the running child. Passing subprocess.PIPE for stdin, stdout or stderr exposes the corresponding pipe as a stream on the process object, implementing the same send_all and receive_some coroutines of network streams:

yield syntax

import subprocess
import tonio

def main():
    proc = yield tonio.open_process(
        ['cat'],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE
    )
    yield proc.stdin.send_all(b'hello')
    proc.stdin.close()
    data = yield proc.stdout.receive_some()
    code = yield proc.wait()

await syntax

import subprocess
import tonio.colored as tonio

async def main():
    proc = await tonio.open_process(
        ['cat'],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE
    )
    await proc.stdin.send_all(b'hello')
    proc.stdin.close()
    data = await proc.stdout.receive_some()
    code = await proc.wait()

The Process object exposes:

args and pid: the command and the process identifier
stdin, stdout, stderr: the piped streams, or None when not piped
stdio: a (stdin, stdout) tuple, when both are piped
returncode and poll(): the exit code, or None while the process is still running
wait: a coroutine waiting for the process to exit, returning its exit code
send_signal, terminate, kill: synchronous methods to signal the process

Note: unlike run_process, open_process does not reap the child for you: remember to wait on it — possibly after a kill — otherwise the child outlives your task.

Note: processes in TonIO only communicate over unbuffered byte streams: the universal_newlines, text, encoding, errors and bufsize options of subprocess are not supported.

Signals

TonIO provides a context manager to catch signals.

The usage of such context manager requires to first configure the runtime to listen for such signals:

yield syntax

import signal
import tonio
from tonio.time import interval

def sig_handle():
    with tonio.signal_receiver(
        signal.SIGHUP, 
        signal.SIGUSR1
    ) as sigs:
        for ev in sigs:
            sig = yield ev
            if sig == signal.SIGHUP:
                ...

@tonio.main(
    signals=[signal.SIGHUP, signal.SIGUSR1]
)
def main():
    tonio.spawn(sig_handle())
    ticker = interval(1)
    while True:
        yield ticker.tick()

await syntax

import signal
import tonio.colored as tonio
from tonio.colored.time import interval

async def sig_handle():
    with tonio.signal_receiver(
        signal.SIGHUP, 
        signal.SIGUSR1
    ) as sigs:
        async for sig in sigs:
            if sig == signal.SIGHUP:
                ...

@tonio.main(
    signals=[signal.SIGHUP, signal.SIGUSR1]
)
async def main():
    tonio.spawn(sig_handle())
    ticker = interval(1)
    while True:
        await ticker.tick()

Testing

TonIO ships with a pytest plugin, which runs tests marked with the tonio marker on the runtime:

yield syntax

import pytest
import tonio

@pytest.mark.tonio
def test_sleep():
    yield tonio.sleep(0.1)

await syntax

import pytest
import tonio.colored as tonio

@pytest.mark.tonio
async def test_sleep():
    await tonio.sleep(0.1)

The marker can also be applied at module level with pytestmark = pytest.mark.tonio, or at class level.

To avoid marking tests entirely, the plugin also provides an auto mode, in which every async test gets run on the TonIO runtime. Auto mode can be enabled with the tonio_mode option in the pytest configuration:

[tool.pytest.ini_options]
tonio_mode = 'auto'

Async fixtures

For asynchronous fixtures where setup and teardown are required, the two syntaxes differ.

`await` syntax

Async fixtures involved in TonIO tests run on the runtime. Coroutine fixtures simply return their value, while async generator fixtures can yield it and run teardown code after the yield:

import pytest
from tonio.colored.net import open_tcp_stream

@pytest.fixture
async def connection():
    stream = await open_tcp_stream(host='127.0.0.1', port=8000)
    yield stream
    stream.close()

`yield` syntax

Given non-colored TonIO coroutines are indistinguishable from standard pytest generator fixtures, the plugin never runs generator fixtures on the runtime. This is usually not a limitation: since yield syntax tests already run as coroutines, simple setup can just happen within the test itself:

import pytest
from tonio.net import open_tcp_stream

def _connect():
    stream = yield open_tcp_stream(host='127.0.0.1', port=8000)
    return stream

@pytest.mark.tonio
def test_conn():
    stream = yield _connect()
    yield stream.send_all(b'ping')

When an actual teardown is required, the plugin provides the tonio_run fixture, which runs the given coroutine on the runtime:

@pytest.fixture
def connection(tonio_run):
    stream = tonio_run(_connect())

    def _disconnect():
        yield stream.send_all(b'bye')
        stream.close()

    yield stream
    tonio_run(_disconnect())

Runtime configuration in pytest

The TonIO runtime is always initialised once per test session, with context enabled and 2 threads. Runtime options can be customized overriding the session-scoped tonio_runtime_options fixture, for example in conftest.py:

import pytest

@pytest.fixture(scope='session')
def tonio_runtime_options():
    return {'threads': 4}

The runtime object itself is available to tests and fixtures via the session-scoped tonio_runtime fixture.

Libraries built on TonIO

In addition to the patches provided by the TonIO-Monkey project, the following libraries target TonIO natively:

httpunk: a low-level async HTTP library
punkreq: a high-level async HTTP client
toncorn: a uvicorn fork built on TonIO

License

TonIO is released under the BSD License.

Metadata

Release files for tonio 0.9.17

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for tonio 0.9.17
File	Size	Uploaded
tonio-0.9.17.tar.gz	94.6 kB	Sep 14, 2026	Details

Built distributions (wheels)

Table of built distributions (wheels) for tonio 0.9.17
File	Interpreter	ABI	Platform	Reset
tonio-0.9.17-cp315-cp315t-musllinux_1_1_x86_64.whl 640.3 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux musl 1.1+ x86-64	Details
tonio-0.9.17-cp315-cp315t-musllinux_1_1_armv7l.whl 700.9 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux musl 1.1+ ARMv7l	Details
tonio-0.9.17-cp315-cp315t-musllinux_1_1_aarch64.whl 589.3 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux musl 1.1+ ARM64	Details
tonio-0.9.17-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl 426.3 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux glibc 2.17+ x86-64	Details
tonio-0.9.17-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl 423.0 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux glibc 2.17+ ARMv7l	Details
tonio-0.9.17-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl 410.5 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux glibc 2.17+ ARM64	Details
tonio-0.9.17-cp315-cp315t-manylinux_2_12_i686.manylinux2010_i686.whl 451.8 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	Linux glibc 2.12+ x86-32	Details
tonio-0.9.17-cp315-cp315t-macosx_11_0_arm64.whl 367.7 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	macOS 11.0+ ARM64	Details
tonio-0.9.17-cp315-cp315t-macosx_10_12_x86_64.whl 388.2 kB Sep 14, 2026	CPython 3.15	CPython 3.15 free-threading	macOS 10.12+ x86-64	Details
tonio-0.9.17-cp314-cp314t-musllinux_1_1_x86_64.whl 640.6 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux musl 1.1+ x86-64	Details
tonio-0.9.17-cp314-cp314t-musllinux_1_1_armv7l.whl 700.7 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux musl 1.1+ ARMv7l	Details
tonio-0.9.17-cp314-cp314t-musllinux_1_1_aarch64.whl 589.5 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux musl 1.1+ ARM64	Details
tonio-0.9.17-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl 426.5 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux glibc 2.17+ x86-64	Details
tonio-0.9.17-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl 422.8 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux glibc 2.17+ ARMv7l	Details
tonio-0.9.17-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl 410.6 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux glibc 2.17+ ARM64	Details
tonio-0.9.17-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl 451.5 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	Linux glibc 2.12+ x86-32	Details
tonio-0.9.17-cp314-cp314t-macosx_11_0_arm64.whl 367.8 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	macOS 11.0+ ARM64	Details
tonio-0.9.17-cp314-cp314t-macosx_10_12_x86_64.whl 388.3 kB Sep 14, 2026	CPython 3.14	CPython 3.14 free-threading	macOS 10.12+ x86-64	Details

Total release size: 8.9 MB

Release files / tonio-0.9.17.tar.gz

Download URL	tonio-0.9.17.tar.gz
Size	94.6 kB
Tags	Source
SHA-256 checksum How to use checksums	`0f0e498cb7a4dc7dd8423953aa9e3a49dc02f11b9901d3a28ae31ad0a1851d30`
BLAKE2b-256 checksum How to use checksums	`94c0cd64e54aaa188d32326c2c63646e47aa539b6eb03c4e964bd7dc2b4403d4`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17.tar.gz
SHA-256 checksum: 0f0e498cb7a4dc7dd8423953aa9e3a49dc02f11b9901d3a28ae31ad0a1851d30 Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-musllinux_1_1_x86_64.whl

Download URL	tonio-0.9.17-cp315-cp315t-musllinux_1_1_x86_64.whl
Size	640.3 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux musl 1.1+ x86-64
SHA-256 checksum How to use checksums	`29f8f50b33cab465e3829835facde7ec7d470dd56cf70841d793ff45f77e321c`
BLAKE2b-256 checksum How to use checksums	`20634c56244a8cbfa6cc57f27d7ca6660c901dfa88d93323d537614a99637e18`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-musllinux_1_1_x86_64.whl
SHA-256 checksum: 29f8f50b33cab465e3829835facde7ec7d470dd56cf70841d793ff45f77e321c Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-musllinux_1_1_armv7l.whl

Download URL	tonio-0.9.17-cp315-cp315t-musllinux_1_1_armv7l.whl
Size	700.9 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux musl 1.1+ ARMv7l
SHA-256 checksum How to use checksums	`74fd8966abeecacd4497ac38cb3d8ebe0b76641b29354f4ef8729589f773b44e`
BLAKE2b-256 checksum How to use checksums	`ca4a83748ba8d4f8eb8ce17fce7efd35bfeda99f8c0d1464f0d227a1863c2eef`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-musllinux_1_1_armv7l.whl
SHA-256 checksum: 74fd8966abeecacd4497ac38cb3d8ebe0b76641b29354f4ef8729589f773b44e Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-musllinux_1_1_aarch64.whl

Download URL	tonio-0.9.17-cp315-cp315t-musllinux_1_1_aarch64.whl
Size	589.3 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux musl 1.1+ ARM64
SHA-256 checksum How to use checksums	`0a9c2d74480ec537d00277f2bd8f1b5f806aac41cfb0ce91307f7dfc801e5ee2`
BLAKE2b-256 checksum How to use checksums	`330a92827b756164e33489122a5f45b021ea023ce29d59b05c33997c17e2efef`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-musllinux_1_1_aarch64.whl
SHA-256 checksum: 0a9c2d74480ec537d00277f2bd8f1b5f806aac41cfb0ce91307f7dfc801e5ee2 Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

Download URL	tonio-0.9.17-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
Size	426.3 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux glibc 2.17+ x86-64
SHA-256 checksum How to use checksums	`e5eae638198bd3f15e619cb5bfddd2f01147647475ff52cc4bb5b7cfbde7208d`
BLAKE2b-256 checksum How to use checksums	`ef72567c57f829366797b9904e78e080edba91f73cbdfc0370cfd2f2436c4208`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
SHA-256 checksum: e5eae638198bd3f15e619cb5bfddd2f01147647475ff52cc4bb5b7cfbde7208d Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl

Download URL	tonio-0.9.17-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl
Size	423.0 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux glibc 2.17+ ARMv7l
SHA-256 checksum How to use checksums	`138917a84589cc8645d0efd12484b6ad1c90cbd89362fe44f2d1bbd54a5f5222`
BLAKE2b-256 checksum How to use checksums	`c40ad6a991babd06983a249882616c774569304a43a6485bbcfad603ef0d59c4`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl
SHA-256 checksum: 138917a84589cc8645d0efd12484b6ad1c90cbd89362fe44f2d1bbd54a5f5222 Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

Download URL	tonio-0.9.17-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
Size	410.5 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux glibc 2.17+ ARM64
SHA-256 checksum How to use checksums	`5bc9c9447e9fe987ee2aa0a27248d47ef1f8c43b0a602a5eedba395d81d73d3a`
BLAKE2b-256 checksum How to use checksums	`ed5e189a02e06dcde184bb5d3529d9b99154d453235ad854bf2f7fccd6329a2b`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
SHA-256 checksum: 5bc9c9447e9fe987ee2aa0a27248d47ef1f8c43b0a602a5eedba395d81d73d3a Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-manylinux_2_12_i686.manylinux2010_i686.whl

Download URL	tonio-0.9.17-cp315-cp315t-manylinux_2_12_i686.manylinux2010_i686.whl
Size	451.8 kB
Tags	CPython 3.15 CPython 3.15 free-threading Linux glibc 2.12+ x86-32
SHA-256 checksum How to use checksums	`ad6401d54c49b44929cd435c766a934be171bc9de10b16b0ecfe226b8c60a1b5`
BLAKE2b-256 checksum How to use checksums	`7273829d878638b310c4605925adb51efef9c4043c39907a2be8106e28c0bd79`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-manylinux_2_12_i686.manylinux2010_i686.whl
SHA-256 checksum: ad6401d54c49b44929cd435c766a934be171bc9de10b16b0ecfe226b8c60a1b5 Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-macosx_11_0_arm64.whl

Download URL	tonio-0.9.17-cp315-cp315t-macosx_11_0_arm64.whl
Size	367.7 kB
Tags	CPython 3.15 CPython 3.15 free-threading macOS 11.0+ ARM64
SHA-256 checksum How to use checksums	`8d7da3480b6a1ab6bc358a6267d8fda03da2fd0c4ec80abae7723bc4d6af681b`
BLAKE2b-256 checksum How to use checksums	`96715be487e29122744a7365e53ca8c7cb1c2adafb707b38941a3df7e7ca1aa8`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-macosx_11_0_arm64.whl
SHA-256 checksum: 8d7da3480b6a1ab6bc358a6267d8fda03da2fd0c4ec80abae7723bc4d6af681b Verifying attestations

Release files / tonio-0.9.17-cp315-cp315t-macosx_10_12_x86_64.whl

Download URL	tonio-0.9.17-cp315-cp315t-macosx_10_12_x86_64.whl
Size	388.2 kB
Tags	CPython 3.15 CPython 3.15 free-threading macOS 10.12+ x86-64
SHA-256 checksum How to use checksums	`5de03dac89ff9127b9e5e25503f6659205386afd2dbb57f234d626ed5aa875d4`
BLAKE2b-256 checksum How to use checksums	`b788076cdf19f43b172e63fec978cb29108d8c9bad380c0d8099608c3c52dc3a`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp315-cp315t-macosx_10_12_x86_64.whl
SHA-256 checksum: 5de03dac89ff9127b9e5e25503f6659205386afd2dbb57f234d626ed5aa875d4 Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-musllinux_1_1_x86_64.whl

Download URL	tonio-0.9.17-cp314-cp314t-musllinux_1_1_x86_64.whl
Size	640.6 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux musl 1.1+ x86-64
SHA-256 checksum How to use checksums	`26c8f2bd1f240a15e0c6739b2175e13774f9334a8131dd44889fc6f707302c52`
BLAKE2b-256 checksum How to use checksums	`338c4aa1b090a29b61a197dc136c0d336d26e2b42f9240098c243ae4d8043395`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-musllinux_1_1_x86_64.whl
SHA-256 checksum: 26c8f2bd1f240a15e0c6739b2175e13774f9334a8131dd44889fc6f707302c52 Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-musllinux_1_1_armv7l.whl

Download URL	tonio-0.9.17-cp314-cp314t-musllinux_1_1_armv7l.whl
Size	700.7 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux musl 1.1+ ARMv7l
SHA-256 checksum How to use checksums	`9d9f85a10803cc9f20e45c40cc4dd4c3c1bab8c9497db33e0d3068a8a0f6158c`
BLAKE2b-256 checksum How to use checksums	`0b1f9c779ee55c2f584582d319dfb0b577dd443f88cd4cf70c6f370a234709c9`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-musllinux_1_1_armv7l.whl
SHA-256 checksum: 9d9f85a10803cc9f20e45c40cc4dd4c3c1bab8c9497db33e0d3068a8a0f6158c Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-musllinux_1_1_aarch64.whl

Download URL	tonio-0.9.17-cp314-cp314t-musllinux_1_1_aarch64.whl
Size	589.5 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux musl 1.1+ ARM64
SHA-256 checksum How to use checksums	`c3d6f480260270b57b2a0fdd359dd87eb92eff3a62d1e39a363d09debec4fe25`
BLAKE2b-256 checksum How to use checksums	`dea20ab5afb5ad90c331e585861cdcdcb83648e52433648642afb98428b41cba`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-musllinux_1_1_aarch64.whl
SHA-256 checksum: c3d6f480260270b57b2a0fdd359dd87eb92eff3a62d1e39a363d09debec4fe25 Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

Download URL	tonio-0.9.17-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
Size	426.5 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux glibc 2.17+ x86-64
SHA-256 checksum How to use checksums	`f552cff169001f9f632f7c8c9b68a5ca5e3ce5e264d045d0fabc72d24767117f`
BLAKE2b-256 checksum How to use checksums	`0c80502453d5ac0caf6ede153cdaaa58b5fc481ab97ee0c66fb0c1c0a49eff7e`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
SHA-256 checksum: f552cff169001f9f632f7c8c9b68a5ca5e3ce5e264d045d0fabc72d24767117f Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl

Download URL	tonio-0.9.17-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl
Size	422.8 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux glibc 2.17+ ARMv7l
SHA-256 checksum How to use checksums	`30ba40e89bfbc8ccc5d8d1d5f7c1be4c023af19a9fd776ab346b1e581c4bb88c`
BLAKE2b-256 checksum How to use checksums	`cd157252f36606f6d6d5e626997e778792fdbf495bc3f64c5e38fa662d81e197`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl
SHA-256 checksum: 30ba40e89bfbc8ccc5d8d1d5f7c1be4c023af19a9fd776ab346b1e581c4bb88c Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

Download URL	tonio-0.9.17-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
Size	410.6 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux glibc 2.17+ ARM64
SHA-256 checksum How to use checksums	`17b8b0d41b5f4a17bc8fd534820d311081635f705e542ecc91d9e6ce08f4d040`
BLAKE2b-256 checksum How to use checksums	`33aa4aad1a27b44ad6b2e618f88482f40f1beffdeee5121d6b0e26891d3aadfb`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
SHA-256 checksum: 17b8b0d41b5f4a17bc8fd534820d311081635f705e542ecc91d9e6ce08f4d040 Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl

Download URL	tonio-0.9.17-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl
Size	451.5 kB
Tags	CPython 3.14 CPython 3.14 free-threading Linux glibc 2.12+ x86-32
SHA-256 checksum How to use checksums	`db45244f1d465a4ddb1a4d95f188dfe2c9d76b1575538aec3dbeb9140d06bdb8`
BLAKE2b-256 checksum How to use checksums	`d88abea210f3e48e81b2e666b4bef6b5ac6c9b24c743d194855c48209f7b8a90`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl
SHA-256 checksum: db45244f1d465a4ddb1a4d95f188dfe2c9d76b1575538aec3dbeb9140d06bdb8 Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-macosx_11_0_arm64.whl

Download URL	tonio-0.9.17-cp314-cp314t-macosx_11_0_arm64.whl
Size	367.8 kB
Tags	CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64
SHA-256 checksum How to use checksums	`28af66178221acb257caedb3d05de61e42193353ce0d8c1795f72b94bbd16bdb`
BLAKE2b-256 checksum How to use checksums	`229de9fea1c3266e7c48bd2d19b1741387869518671e16820b508db198451bbc`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-macosx_11_0_arm64.whl
SHA-256 checksum: 28af66178221acb257caedb3d05de61e42193353ce0d8c1795f72b94bbd16bdb Verifying attestations

Release files / tonio-0.9.17-cp314-cp314t-macosx_10_12_x86_64.whl

Download URL	tonio-0.9.17-cp314-cp314t-macosx_10_12_x86_64.whl
Size	388.3 kB
Tags	CPython 3.14 CPython 3.14 free-threading macOS 10.12+ x86-64
SHA-256 checksum How to use checksums	`840bfc53e36c5a74dd228caa6520ee7fe6ae40a94b7dd6d23d794d017a5caf11`
BLAKE2b-256 checksum How to use checksums	`87786edaf61cc69965eeae59ccc21e95f41a4a4ebf499eadde2e33ae998cdee6`
Upload date	Sep 14, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/7.0.0 CPython/3.13.14`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/gi0baro/tonio
Publishing commit: github.com/gi0baro/tonio/tree/c85995eb3632691b1fd94ffcc59b02829dab0664

Workflow

Publishing configuration: github.com/gi0baro/tonio/blob/c85995eb3632691b1fd94ffcc59b02829dab0664/.github/workflows/release.yml
Publishing logs: github.com/gi0baro/tonio/actions/runs/34864653739/attempts/1

Artifact

Subject: tonio-0.9.17-cp314-cp314t-macosx_10_12_x86_64.whl
SHA-256 checksum: 840bfc53e36c5a74dd228caa6520ee7fe6ae40a94b7dd6d23d794d017a5caf11 Verifying attestations