Merge branch 'master' into sync

Author: hosaka

README.md

@@ -46,17 +46,15 @@ class MainWindow(QWidget):
 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())
+    # for 3.11 or older use qasync.run instead of asyncio.run
+    # qasync.run(app_close_event.wait())
+    asyncio.run(app_close_event.wait(), loop_factory=QEventLoop)
 ```
 
 More detailed examples can be found [here](https://github.com/CabbageDevelopment/qasync/tree/master/examples).

examples/aiohttp_fetch.py

@@ -13,6 +13,7 @@
     QVBoxLayout,
     QWidget,
 )
+
 from qasync import QEventLoop, asyncClose, asyncSlot
 
 
@@ -68,15 +69,16 @@ async def on_btn_fetch_clicked(self):
 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()
 
-    event_loop.create_task(main_window.boot())
-    event_loop.run_until_complete(app_close_event.wait())
-    event_loop.close()
+    async def async_main():
+        asyncio.create_task(main_window.boot())
+        await app_close_event.wait()
+
+    # for 3.11 or older use qasync.run instead of asyncio.run
+    # qasync.run(async_main())
+    asyncio.run(async_main(), loop_factory=QEventLoop)

examples/executor_example.py

@@ -1,10 +1,11 @@
-import functools
 import asyncio
-import time
+import functools
 import sys
+import time
 
 # from PyQt6.QtWidgets import
 from PySide6.QtWidgets import QApplication, QProgressBar
+
 from qasync import QEventLoop, QThreadExecutor
 
 
@@ -34,8 +35,6 @@ def last_50(progress, loop):
 if __name__ == "__main__":
     app = QApplication(sys.argv)
 
-    event_loop = QEventLoop(app)
-    asyncio.set_event_loop(event_loop)
-
-    event_loop.run_until_complete(master())
-    event_loop.close()
+    # for 3.11 or older use qasync.run instead of asyncio.run
+    # qasync.run(master())
+    asyncio.run(master(), loop_factory=QEventLoop)

qasync/__init__.py

@@ -78,24 +78,28 @@
     from PyQt5.QtCore import pyqtSlot as Slot
 
     QApplication = QtWidgets.QApplication
+    AllEvents = QtCore.QEventLoop.ProcessEventsFlags(0x00)
 
 elif QtModuleName == "PyQt6":
     from PyQt6 import QtWidgets
     from PyQt6.QtCore import pyqtSlot as Slot
 
     QApplication = QtWidgets.QApplication
+    AllEvents = QtCore.QEventLoop.ProcessEventsFlag(0x00)
 
 elif QtModuleName == "PySide2":
     from PySide2 import QtWidgets
     from PySide2.QtCore import Slot
 
     QApplication = QtWidgets.QApplication
+    AllEvents = QtCore.QEventLoop.ProcessEventsFlags(0x00)
 
 elif QtModuleName == "PySide6":
     from PySide6 import QtWidgets
     from PySide6.QtCore import Slot
 
     QApplication = QtWidgets.QApplication
+    AllEvents = QtCore.QEventLoop.ProcessEventsFlags(0x00)
 
 from ._common import with_logger  # noqa
 
@@ -142,9 +146,15 @@ def run(self):
                 else:
                     self._logger.debug("Setting Future result: %s", r)
                     future.set_result(r)
+                finally:
+                    # Release potential reference
+                    r = None  # noqa
             else:
                 self._logger.debug("Future was canceled")
 
+            # Delete references
+            del command, future, callback, args, kwargs
+
         self._logger.debug("Thread #%s stopped", self.__num)
 
     def wait(self):
@@ -228,7 +238,7 @@ def __exit__(self, *args):
 
 def _format_handle(handle: asyncio.Handle):
     cb = getattr(handle, "_callback", None)
-    if isinstance(getattr(cb, '__self__', None), asyncio.tasks.Task):
+    if isinstance(getattr(cb, "__self__", None), asyncio.tasks.Task):
         return repr(cb.__self__)
     return str(handle)
 
@@ -286,7 +296,11 @@ def timerEvent(self, event):  # noqa: N802
                             handle._run()
                             dt = time.time() - t0
                             if dt >= loop.slow_callback_duration:
-                                self._logger.warning('Executing %s took %.3f seconds', _format_handle(handle), dt)
+                                self._logger.warning(
+                                    "Executing %s took %.3f seconds",
+                                    _format_handle(handle),
+                                    dt,
+                                )
                         finally:
                             loop._current_handle = None
                     else:
@@ -331,10 +345,7 @@ class _QEventLoop:
     ...     assert x + y == 4
     ...     await asyncio.sleep(.1)
     >>>
-    >>> loop = QEventLoop(app)
-    >>> asyncio.set_event_loop(loop)
-    >>> with loop:
-    ...     loop.run_until_complete(xplusy(2, 2))
+    >>> asyncio.run(xplusy(2, 2), loop_factory=lambda:QEventLoop(app))
 
     If the event loop shall be used with an existing and already running QApplication
     it must be specified in the constructor via already_running=True
@@ -417,7 +428,9 @@ def stop(*args):
             self.run_forever()
         finally:
             future.remove_done_callback(stop)
-        self.__app.processEvents()  # run loop one last time to process all the events
+        self.__app.eventDispatcher().processEvents(
+            AllEvents
+        )  # run loop one last time to process all the events
         if not future.done():
             raise RuntimeError("Event loop stopped before Future completed.")
 
@@ -801,6 +814,8 @@ def _error_handler(task):
             task.result()
         except Exception:
             sys.excepthook(*sys.exc_info())
+        except asyncio.CancelledError:
+            pass
 
     def outer_decorator(fn):
         @Slot(*args, **kwargs)
@@ -871,28 +886,34 @@ def helper():
     QtCore.QTimer.singleShot(0, helper)
     return await future
 
-class QEventLoopPolicyMixin:
-    def new_event_loop(self):
-        return QEventLoop(QApplication.instance() or QApplication(sys.argv))
 
+def _get_qevent_loop():
+    return QEventLoop(QApplication.instance() or QApplication(sys.argv))
 
-class DefaultQEventLoopPolicy(
-    QEventLoopPolicyMixin,
-    asyncio.DefaultEventLoopPolicy,
-):
-    pass
 
+if sys.version_info >= (3, 12):
 
-@contextlib.contextmanager
-def _set_event_loop_policy(policy):
-    old_policy = asyncio.get_event_loop_policy()
-    asyncio.set_event_loop_policy(policy)
-    try:
-        yield
-    finally:
-        asyncio.set_event_loop_policy(old_policy)
-
+    def run(*args, **kwargs):
+        return asyncio.run(
+            *args,
+            **kwargs,
+            loop_factory=_get_qevent_loop,
+        )
+else:
+    # backwards compatibility with event loop policies
+    class DefaultQEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+        def new_event_loop(self):
+            return _get_qevent_loop()
+
+    @contextlib.contextmanager
+    def _set_event_loop_policy(policy):
+        old_policy = asyncio.get_event_loop_policy()
+        asyncio.set_event_loop_policy(policy)
+        try:
+            yield
+        finally:
+            asyncio.set_event_loop_policy(old_policy)
 
-def run(*args, **kwargs):
-    with _set_event_loop_policy(DefaultQEventLoopPolicy()):
-        return asyncio.run(*args, **kwargs)
+    def run(*args, **kwargs):
+        with _set_event_loop_policy(DefaultQEventLoopPolicy()):
+            return asyncio.run(*args, **kwargs)

tests/conftest.py

@@ -1,12 +1,15 @@
-# © 2018 Gerard Marull-Paretas <gerard@teslabs.com>
-# © 2014 Mark Harviston <mark.harviston@gmail.com>
-# © 2014 Arve Knudsen <arve.knudsen@gmail.com>
-# BSD License
+"""
+Copyright (c) 2018 Gerard Marull-Paretas <gerard@teslabs.com>
+Copyright (c) 2014 Mark Harviston <mark.harviston@gmail.com>
+Copyright (c) 2014 Arve Knudsen <arve.knudsen@gmail.com>
+
+BSD License
+"""
 
-import os
 import logging
-from pytest import fixture
+import os
 
+from pytest import fixture
 
 logging.basicConfig(
     level=logging.DEBUG, format="%(levelname)s\t%(filename)s:%(lineno)s %(message)s"

tests/test_qeventloop.py

@@ -11,6 +11,7 @@
 import socket
 import subprocess
 import sys
+import threading
 import time
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 
@@ -104,7 +105,7 @@ def test_can_handle_exception_in_executor(self, loop, executor):
             loop.run_until_complete(
                 asyncio.wait_for(
                     loop.run_in_executor(executor, self.blocking_failure),
-                    timeout=3.0,
+                    timeout=10.0,
                 )
             )
 
@@ -125,7 +126,7 @@ def blocking_func(self, was_invoked):
     async def blocking_task(self, loop, executor, was_invoked):
         logging.debug("start blocking task()")
         fut = loop.run_in_executor(executor, self.blocking_func, was_invoked)
-        await asyncio.wait_for(fut, timeout=5.0)
+        await asyncio.wait_for(fut, timeout=10.0)
         logging.debug("start blocking task()")
 
 
@@ -139,7 +140,7 @@ async def mycoro():
         await process.wait()
         assert process.returncode == 5
 
-    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=3))
+    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=10.0))
 
 
 def test_can_read_subprocess(loop):
@@ -159,7 +160,7 @@ async def mycoro():
         assert process.returncode == 0
         assert received_stdout.strip() == b"Hello async world!"
 
-    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=3))
+    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=10.0))
 
 
 def test_can_communicate_subprocess(loop):
@@ -180,7 +181,7 @@ async def mycoro():
         assert process.returncode == 0
         assert received_stdout.strip() == b"Hello async world!"
 
-    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=3))
+    loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=10.0))
 
 
 def test_can_terminate_subprocess(loop):
@@ -857,6 +858,61 @@ async def mycoro():
     assert "seconds" in msg
 
 
+def test_run_until_complete_returns_future_result(loop):
+    async def coro():
+        await asyncio.sleep(0)
+        return 42
+
+    assert loop.run_until_complete(asyncio.wait_for(coro(), timeout=1)) == 42
+
+
+def test_run_forever_custom_exit_code(loop, application):
+    if hasattr(application, "exec"):
+        orig_exec = application.exec
+        application.exec = lambda: 42
+        try:
+            assert loop.run_forever() == 42
+        finally:
+            application.exec = orig_exec
+    else:
+        orig_exec = application.exec_
+        application.exec_ = lambda: 42
+        try:
+            assert loop.run_forever() == 42
+        finally:
+            application.exec_ = orig_exec
+
+
+def test_qeventloop_in_qthread():
+    class CoroutineExecutorThread(qasync.QtCore.QThread):
+        def __init__(self, coro):
+            super().__init__()
+            self.coro = coro
+            self.loop = None
+
+        def run(self):
+            self.loop = qasync.QEventLoop(self)
+            asyncio.set_event_loop(self.loop)
+            asyncio.run(self.coro)
+
+        def join(self):
+            self.loop.stop()
+            self.loop.close()
+            self.wait()
+
+    event = threading.Event()
+
+    async def coro():
+        await asyncio.sleep(0.1)
+        event.set()
+
+    thread = CoroutineExecutorThread(coro())
+    thread.start()
+
+    assert event.wait(timeout=1), "Coroutine did not execute successfully"
+
+    thread.join()  # Ensure thread cleanup
+
 def teardown_module(module):
     """
     Remove handlers from all loggers