To help you get started, we've collected the most common ways that qasync is being used within popular public projects.

almarklein / wgpu-py / visvis2 / _figure.py View on Github

def paintEngine(self):
        # https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum  WA_PaintOnScreen
        return None


app = QtWidgets.QApplication([])


# %% Integrate QT with asyncio


if False:
    # The qasync way, probably the best way, but needs a new event loop, so
    # does not integrate so well (yet) with IDE's.
    loop = qasync.QEventLoop(app)
    asyncio.set_event_loop(loop)

    # An experimental Pyzo thing I hacked together to switch loops
    if hasattr(asyncio, "integrate_with_ide"):
        asyncio.integrate_with_ide(loop, run=False)
else:
    # The quick-n-dirty way, simple and effective, but this limits the
    # rate in which qt can process events. If we could get an event
    # when qt has pending events, this might actually be effective.
    async def _keep_qt_alive():
        while True:
            await asyncio.sleep(0.01)
            app.flush()
            app.processEvents()

    asyncio.get_event_loop().create_task(_keep_qt_alive())

View more ways to use qasync

qasync

Introduction

qasync allows coroutines to be used in PyQt/PySide applications by providing an implementation of the PEP 3156 event loop.

With qasync, you can use asyncio functionalities directly inside Qt app's event loop, in the main thread. Using async functions for Python tasks can be much easier and cleaner than using threading.Thread or QThread.

If you need some CPU-intensive tasks to be executed in parallel, qasync also got that covered, providing QEventLoop.run_in_executor which is functionally identical to that of asyncio.

Basic Example

import sys
import asyncio

from qasync import QEventLoop, QApplication
from PySide6.QtWidgets import QWidget, QVBoxLayout

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()

        self.setLayout(QVBoxLayout())
        self.lbl_status = QLabel("Idle", self)
        self.layout().addWidget(self.lbl_status)

    @asyncClose
    async def closeEvent(self, event):
        pass

    @asyncSlot()
    async def onMyEvent(self):
        pass


if __name__ == "__main__":
    app = QApplication(sys.argv)

    event_loop = QEventLoop(app)
    asyncio.set_event_loop(event_loop)

    app_close_event = asyncio.Event()
    app.aboutToQuit.connect(app_close_event.set)

    main_window = MainWindow()
    main_window.show()

    with event_loop:
        event_loop.run_until_complete(app_close_event.wait())

More detailed examples can be found here.

The Future of qasync

qasync is a fork of asyncqt, which is a fork of quamash. qasync was created because those are no longer maintained. May it live longer than its predecessors.

qasync will continue to be maintained, and will still be accepting pull requests.

Requirements

• Python >= 3.8
• PyQt5/PyQt6 or PySide2/PySide6

qasync is tested on Ubuntu, Windows and MacOS.

If you need Python 3.6 or 3.7 support, use the v0.25.0 tag/release.

Installation

To install qasync, use pip:

pip install qasync

License

You may use, modify and redistribute this software under the terms of the BSD License. See LICENSE.