Allow passing of custom qtparent to QEventLoop. Adjust tests.

Author: kristjanvalur

src/qasync/__init__.py

@@ -354,7 +354,9 @@ class _QEventLoop:
     The set_running_loop parameter is there for backwards compatibility and does nothing.
     """
 
-    def __init__(self, app=None, set_running_loop=False, already_running=False):
+    def __init__(
+        self, app=None, set_running_loop=False, already_running=False, qtparent=None
+    ):
         self.__app = app or QApplication.instance()
         assert self.__app is not None, "No QApplication has been instantiated"
         self.__is_running = False
@@ -364,11 +366,9 @@ def __init__(self, app=None, set_running_loop=False, already_running=False):
         self._read_notifiers = {}
         self._write_notifiers = {}
         self._timer = _SimpleTimer()
+        self.qtparent = qtparent or self.__app
 
         self.__call_soon_signaller = signaller = _make_signaller(QtCore, object, tuple)
-        # Parent helper QObjects to the application for safe lifetime management
-        self._timer.setParent(self.__app)
-        signaller.setParent(self.__app)
 
         self.__call_soon_signal = signaller.signal
         self.__call_soon_signal.connect(
@@ -378,6 +378,16 @@ def __init__(self, app=None, set_running_loop=False, already_running=False):
         assert self.__app is not None
         super().__init__()
 
+        # Parent helper objects, such as timers, to this Qt parent for safe
+        # lifetime management.
+        if (
+            self.qtparent is not None
+            and self.qtparent.thread() is not QtCore.QThread.currentThread()
+        ):
+            raise RuntimeError("qt_parent must belong to the same QThread as the event loop")
+        self._timer.setParent(self.qtparent)
+        signaller.setParent(self.qtparent)
+
         # We have to set __is_running to True after calling
         # super().__init__() because of a bug in BaseEventLoop.
         if already_running:
@@ -391,8 +401,8 @@ def __init__(self, app=None, set_running_loop=False, already_running=False):
             # for asyncio to recognize the already running loop
             asyncio.events._set_running_loop(self)
 
-    def get_app(self):
-        return self.__app
+    def get_qtparent(self):
+        return self.qtparent
 
     def run_forever(self):
         """Run eventloop forever."""
@@ -491,11 +501,18 @@ def close(self):
             self.__call_soon_signal.disconnect()
         except Exception:
             pass  # pragma: no cover
-        self.__call_soon_signaller.deleteLater()
+        try:
+            # may raise if already deleted
+            self.__call_soon_signaller.deleteLater()
+        except Exception:
+            pass  # pragma: no cover
 
         # Stop timers first to avoid late invocations during teardown
         self._timer.stop()
-        self._timer.deleteLater()
+        try:
+            self._timer.deleteLater()
+        except Exception:
+            pass  # pragma: no cover
 
         # Disable and disconnect any remaining notifiers before closing
         for notifier in itertools.chain(
@@ -668,7 +685,10 @@ def _delete_notifier(notifier):
             notifier.activated["int"].disconnect()
         except Exception:
             pass  # pragma: no cover
-        notifier.deleteLater()
+        try:
+            notifier.deleteLater()
+        except Exception:
+            pass  # pragma: no cover
 
     # Methods for interacting with threads.
 

src/qasync/_unix.py

@@ -188,18 +188,21 @@ def _delete_notifier(notifier):
             notifier.activated["int"].disconnect()
         except Exception:
             pass  # pragma: no cover
-        notifier.deleteLater()
+        try:
+            notifier.deleteLater()
+        except Exception:
+            pass  # pragma: no cover
 
 
 class _SelectorEventLoop(asyncio.SelectorEventLoop):
     def __init__(self):
         self._signal_safe_callbacks = []
 
         try:
-            app = self.get_app()
+            qtparent = self.get_qtparent()
         except AttributeError:
-            app = None  # pragma: no cover
-        self._qtselector = _Selector(self, qtparent=app)
+            qtparent = None  # pragma: no cover
+        self._qtselector = _Selector(self, qtparent=qtparent)
         asyncio.SelectorEventLoop.__init__(self, self._qtselector)
 
     def close(self):

tests/test_qeventloop.py

@@ -19,6 +19,34 @@
 
 import qasync
 
+from qasync import QtCore
+import traceback, logging
+
+_orig_setParent = QtCore.QObject.setParent
+
+
+def _dbg_setParent(self, parent):
+    if parent is not None:
+        try:
+            same = parent.thread() is self.thread()
+        except Exception:
+            same = False
+        if not same:
+            logging.error(
+                "QObject.setParent across threads: obj=%r obj.thread=%r parent=%r parent.thread=%r",
+                self,
+                self.thread(),
+                parent,
+                getattr(parent, "thread", lambda: None)(),
+            )
+            traceback.print_stack()  # prints Python stack where setParent was called
+            # Optionally raise so test fails and you can inspect the stack in the debugger:
+            # raise RuntimeError("setParent called from wrong thread")
+    return _orig_setParent(self, parent)
+
+
+QtCore.QObject.setParent = _dbg_setParent
+
 
 @pytest.fixture
 def loop(request, application):
@@ -931,21 +959,33 @@ def test_run_forever_custom_exit_code(loop, application):
             application.exec_ = orig_exec
 
 
-def test_qeventloop_in_qthread():
+@pytest.mark.parametrize("qtparent", [False, True])
+def test_qeventloop_in_qthread(qtparent):
     class CoroutineExecutorThread(qasync.QtCore.QThread):
         def __init__(self, coro):
             super().__init__()
             self.coro = coro
             self.loop = None
+            self.owner = None
 
         def run(self):
-            self.loop = qasync.QEventLoop(self)
+            # provide a parent object for temporary objects that belongs
+            # to the thread
+            self.owner = QtCore.QObject()
+            parent = self.owner if qtparent else None
+            if not qtparent:
+                with pytest.raises(RuntimeError):
+                    self.loop = qasync.QEventLoop(self, qtparent=parent)
+                return
+            else:
+                self.loop = qasync.QEventLoop(self, qtparent=parent)
             asyncio.set_event_loop(self.loop)
             asyncio.run(self.coro)
 
         def join(self):
-            self.loop.stop()
-            self.loop.close()
+            if self.loop:
+                self.loop.stop()
+                self.loop.close()
             self.wait()
 
     event = threading.Event()
@@ -957,7 +997,8 @@ async def coro():
     thread = CoroutineExecutorThread(coro())
     thread.start()
 
-    assert event.wait(timeout=1), "Coroutine did not execute successfully"
+    if qtparent:
+        assert event.wait(timeout=1), "Coroutine did not execute successfully"
 
     thread.join()  # Ensure thread cleanup