aiomoqt 0.3.2

Python asyncio implementation of the MoQT protocol

aiomoqt - Media over QUIC Transport (MoQT)

aiomoqt is an implementaion of the MoQT protocol, based on asyncio and aioquic.

Overview

This package implements the MoQT Specification (currently draft-10). It is desinged for general use as an MoQT client and server library, supporting both 'publish' and 'subscribe' roles.

The architecture follows the asyncio.Protocol design pattern, and extends the aioquic.asyncio.protocol.QuicConnectionProtocol protocol.

Featurtes

• Provides 'Async Context Manager' support for session connection management.
• Supports asynchronous and awaitable synchronous calls via an optional flag.
• High-level API for control messages with default and custom response handlers.
• Low-level API for control and data message serialization and deserialization.

🚀 Status: Alpha

Installation

Install using pip:

pip install aiomoqt

Or using uv:

uv pip install aiomoqt

Usage

Basic Client Example

import asyncio
from aiomoqt.client import MOQTClientSession

    client = MOQTClientSession(host=127.0.0.1, port=443, endpoint='wt-endpoint')

    async with client.connect() as session:
        try:
            await session.client_session_init():
            response = await session.subscribe(
                'namespace', 
                'track_name',
                wait_response=True
            )
            # wait for session close, process data and control messages
            await session.async_closed()
        except MOQTException as e:
            session.close(e.error_code, e.reason_phrase)

asyncio.run(main())

The high-level control message API is used for sending MoQT control messages to a server, providing typical default values for most arguments, and flexible type handling for input arguments. Those messages which expect a response, support the blocking asyncio await call construct via an optional flag (wait_response=True). The synchronous call will return a response message object. Asynchronous calls will return the request message object, and will return immediately. Some response handling is provided by the default handler.

The message serialization/deserialization classes provide <moqt-msg-obj>.serialize() which returns an 'aioquic' Buffer with the entire message serialized in buf.data and buf.tell() at the end of the buffer. The buffer data may be passed directly to session.send_control_message(). The <moqt-msg-class>.deserialize() call returns an instance of the given class populated from the deserialized data. MoQT messages that start with a type and length, will already have had the type and length parsed/pulled provided 'aioquic' buffer.

see aiomoqt-python/aiomoqt/examples for additional examples

Development

To set up a development environment:

git clone https://github.com/gmarzot/aiomoqt-python.git
cd aiomoqt-python
./bootstrap_python.sh
source .venv/bin/activate

Installation

uv pip install .

TODO

• Direct QUIC connection
• Flesh out more message sending and handling API's
• Support for completion call back to replace or augment default handling
• Move track data read/write API to aiomoqt.messages.track
• Support file I/O MOQT File Format
• Simple relay (?)
• More tests

Contributing

Contributions are welcome! If you'd like to contribute, please:

• Fork the repository on GitHub.
• Create a new branch for your feature or bug fix.
• Submit a pull request with a clear description of your changes.

For major changes, please open an issue first to discuss your proposal.

Resources

• MoQT Specification
• Media Over QUIC Working Group
• aiomoqt GitHub Repository

---

Acknowledgements

This project takes inspiration from, and has benefited from the great work done by the Meta/moxygen team, and the continued efforts of the MOQ IETF WG.