Asynchronous context managers aren't cleaned up

[gworkman]

I have a class Foo that is an asynchronous context manager, ie it implements async def __aenter__(self) and async def __aexit__(self, exc_type, exc, tb), and I use it like:

async with Foo() as f:
    await f.bar()

Before adding pyqtgraph to the project and just using regular asyncio, it worked completely fine, but now when I use the qasync event loop, it doesn't clean up via the __aexit__ method. Specifically, I expect it to clean up when I close the Qt window. My main function look something like this:

app = QtWidgets.QApplication(sys.argv)
loop = QEventLoop(app)
asyncio.set_event_loop(loop)
graph = MyGraph(app)
loop.create_task(main(graph))
loop.run_forever()

Edit: adding versions

PyQt5==5.15.4
pyqtgraph==0.12.1
qasync==0.15.0

Running on MacOS Catalina 10.15.7

[graingert]

@gworkman does it work with qasync.run?

[emdee-is]

Is this fixed by PR #58 and if so, is there a reason the PR hasn't merged?

[hosaka]

I'm going to assume what your code looks like. When you call loop.run_forever() it will execute until QApplication.exec() returns (for example, closing a Qt window), any pending tasks that were created with loop.create_task() need to be handled after the run_forever(). If you're want to use this approach, as opposed to run_until_complete, you could keep track of your task and tidy them up after the Qt window was closed. These will in turn call __aexit__ on your context managers. What about something like:

import sys
import qasync
import asyncio
from PySide6 import QtWidgets

class Widget(QtWidgets.QWidget):
    def __init__(self):
        QtWidgets.QWidget.__init__(self)
        self._label = QtWidgets.QLabel()
        box = QtWidgets.QHBoxLayout()
        self.setLayout(box)
        box.addWidget(self._label)

    def update(self, text):
        self._label.setText(text)

class ContextManager:
    def __init__(self) -> None:
        self._seconds = 0
    async def __aenter__(self):
        print("ContextManager enter")
        return self
    async def __aexit__(self, *args):
        print("ContextManager exit")
    async def tick(self):
        await asyncio.sleep(1)
        self._seconds += 1
        return self._seconds

async def main(widget):
    print("Task started")
    try:
        async with ContextManager() as ctx:
            while True:
                seconds = await ctx.tick()
                widget.update(str(seconds))
    except asyncio.CancelledError as ex:
        print("Task cancelled")


app = QtWidgets.QApplication(sys.argv)
graph = Widget()
graph.show()

loop = qasync.QEventLoop(app)
asyncio.set_event_loop(loop)

# run until app.exec() is finished (Qt window is closed)
task = loop.create_task(main(graph))
loop.run_forever()

# cancel remaining tasks and wait for them to complete
task.cancel()
tasks = asyncio.all_tasks()
loop.run_until_complete(asyncio.gather(*tasks))

[emdee-is]

That's great code Alex: I used it for a phantomjs replacement in PyQt where I just wanted to use QtWebkitPage.load without a GUI and to interact async with the callbacks. Your code works with Widget/graph=None and no blocking app.exec() call.

Could I suggest that you drop that into examples/ with your discussion as a module docstring - there's no documentation for qasync which really hurts people like me who don't know asyncio, but know they need it.

Do you use IRC? Is there an IRC host you use? I'd like to chat about a few details of the version of your code I did, but am not ready to put on github - let me know a good time if so.

[hosaka]

Yeah, putting this into examples/ is a good idea. In general, the documentation can really do with some love and care.

I'm sorry I don't use IRC. If it is something related to qasync, feel free to post your question/suggestion in the issues here on github.