fix(Ui/output): make log widget appends thread-safe to prevent GUI segfaults

Signed-off-by: Samuel Amen Ague <ague.samuel27@gmail.com>

Author: raidos23

pycompiler_ark/Ui/output.py

@@ -17,7 +17,7 @@
 
 import sys
 import re
-from typing import Optional, Any
+from typing import Optional, Any, Callable
 
 try:
     from rich.console import Console  # type: ignore
@@ -58,6 +58,16 @@
     re.UNICODE,
 )
 
+_LOG_COLORS = {
+    "info": "#00aaff",
+    "warning": "#ffaa00",
+    "error": "#ff4444",
+    "success": "#00cc66",
+}
+
+# Global widget cache
+_log_widget = None
+
 
 def strip_emojis(text: str) -> str:
     """Remove emojis from a string for cleaner terminal output."""
@@ -90,10 +100,6 @@ def plain(message: str, err: bool = False) -> None:
     _emit(message, err=err)
 
 
-# Global widget cache
-_log_widget = None
-
-
 def get_log_widget():
     global _log_widget
     if _log_widget is not None:
@@ -113,13 +119,108 @@ def get_log_widget():
     return None
 
 
+def _is_on_gui_thread() -> bool:
+    """Return True when there is no Qt app, or we are on the app's thread."""
+    try:
+        from PySide6.QtCore import QThread
+        from PySide6.QtWidgets import QApplication
+
+        app = QApplication.instance()
+        if app is None:
+            return True
+        return QThread.currentThread() == app.thread()
+    except Exception:
+        return True
+
+
+def _append_html_to_widget(widget: Any, html: str, plain_text: str) -> None:
+    """Mutate the log widget. Must only run on the Qt GUI thread."""
+    try:
+        from PySide6.QtGui import QTextCursor
+
+        widget.moveCursor(QTextCursor.MoveOperation.End)
+        widget.insertHtml(html)
+        widget.ensureCursorVisible()
+    except Exception:
+        try:
+            widget.append(plain_text)
+        except Exception:
+            pass
+
+
+def _post_to_gui_thread(fn: Callable[[], None]) -> bool:
+    """Queue *fn* on the Qt GUI thread. Returns False if posting is impossible."""
+    try:
+        from PySide6.QtCore import QTimer
+        from PySide6.QtWidgets import QApplication
+
+        app = QApplication.instance()
+        if app is None:
+            return False
+        # Context=app → functor runs on the application (GUI) thread.
+        QTimer.singleShot(0, app, fn)
+        return True
+    except Exception:
+        return False
+
+
+def _safe_append_to_widget(widget: Any, html: str, plain_text: str) -> None:
+    """Append to a Qt log widget from any thread without segfaulting."""
+    if widget is None:
+        return
+
+    # Bridge / non-QTextEdit objects expose a thread-safe append via signals.
+    try:
+        from PySide6.QtWidgets import QTextEdit
+
+        if not isinstance(widget, QTextEdit):
+            if callable(getattr(widget, "append", None)):
+                widget.append(plain_text)
+            return
+    except Exception:
+        # Qt unavailable: best-effort append
+        try:
+            if callable(getattr(widget, "append", None)):
+                widget.append(plain_text)
+        except Exception:
+            pass
+        return
+
+    if _is_on_gui_thread():
+        _append_html_to_widget(widget, html, plain_text)
+        return
+
+    # Off GUI thread: never touch QTextEdit directly (segfault).
+    posted = _post_to_gui_thread(
+        lambda w=widget, h=html, p=plain_text: _append_html_to_widget(w, h, p)
+    )
+    if not posted:
+        # No event loop / posting failed — skip widget; console _emit still runs.
+        return
+
+
+def _try_bridge_log(gui: object | None, level: str, message: str) -> bool:
+    """Route through SafeGuiBridge-style API when available (already thread-safe)."""
+    if gui is None:
+        return False
+    log_message_level = getattr(gui, "log_message_level", None)
+    if not callable(log_message_level):
+        return False
+    try:
+        # Message is already translated; pass twice for (fr, en).
+        log_message_level(level, message, message)
+        return True
+    except Exception:
+        return False
+
+
 def log(
     level: str,
     message: str | tuple | list | Any,
     err: bool | None = None,
     gui: object | None = None,
 ) -> None:
-    """Log principal avec append automatique"""
+    """Log principal avec append automatique (thread-safe pour le widget GUI)."""
 
     lvl = level.upper().strip()
 
@@ -148,43 +249,29 @@ def log(
         message = str(message)
 
     out_err = err if err is not None else lvl in ("ERROR", "WARN", "WARNING")
+    plain_line = f"{prefix} {message}"
 
-    # === Append AUTOMATIQUE dans le widget 'log' ===
-    widget = get_log_widget()
-    if widget is None and gui is not None and hasattr(gui, "log"):
-        widget = gui.log
+    # Prefer SafeGuiBridge (signals) when the caller passes one — avoids
+    # touching QTextEdit from a worker thread and prevents double-writes.
+    bridged = _try_bridge_log(gui, style, str(message))
 
-    if widget is not None:
-        try:
-            from PySide6.QtGui import QTextCursor
+    if not bridged:
+        widget = get_log_widget()
+        if widget is None and gui is not None and hasattr(gui, "log"):
+            widget = gui.log
 
-            colors = {
-                "info": "#00aaff",
-                "warning": "#ffaa00",
-                "error": "#ff4444",
-                "success": "#00cc66",
-            }
-            color = colors.get(style, "#ffffff")
-
-            html = f'<span style="color:{color};">{prefix} {message}</span><br>'
-
-            widget.moveCursor(QTextCursor.MoveOperation.End)
-            widget.insertHtml(html)
-            widget.ensureCursorVisible()
-
-        except Exception:
-            try:
-                widget.append(f"{prefix} {message}")
-            except Exception:
-                pass
+        if widget is not None:
+            color = _LOG_COLORS.get(style, "#ffffff")
+            html = f'<span style="color:{color};">{plain_line}</span><br>'
+            _safe_append_to_widget(widget, html, plain_line)
 
     # Appel sûr à _emit (sans exc_info)
     try:
-        _emit(f"{prefix} {message}", err=out_err, style=style)
+        _emit(plain_line, err=out_err, style=style)
     except TypeError:
         # Si _emit a une autre signature
         try:
-            _emit(f"{prefix} {message}", err=out_err)
+            _emit(plain_line, err=out_err)
         except Exception:
             pass  # dernier recours
 

tests/test_output_thread_safety.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Samuel Amen Ague
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Thread-safety of Ui.output log widget appends (GUI segfault guard)."""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+
+import pytest
+
+# Must be set before QApplication is created.
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+pytest.importorskip("PySide6")
+
+from PySide6.QtWidgets import QApplication, QMainWindow, QTextEdit
+
+
+@pytest.fixture(scope="module")
+def qapp():
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication(["test_output_thread_safety"])
+    return app
+
+
+def test_output_info_from_worker_thread_does_not_segfault(qapp, monkeypatch):
+    from pycompiler_ark.Ui import output
+
+    window = QMainWindow()
+    log_widget = QTextEdit()
+    window.setCentralWidget(log_widget)
+    window.log = log_widget
+    window.show()
+    qapp.processEvents()
+
+    monkeypatch.setattr(output, "_log_widget", log_widget)
+
+    errors: list[BaseException] = []
+
+    def _worker():
+        try:
+            for i in range(20):
+                output.info(f"worker-line-{i}")
+        except BaseException as exc:  # noqa: BLE001
+            errors.append(exc)
+
+    thread = threading.Thread(target=_worker)
+    thread.start()
+
+    deadline = time.time() + 3.0
+    while thread.is_alive() and time.time() < deadline:
+        qapp.processEvents()
+        time.sleep(0.01)
+
+    thread.join(timeout=2.0)
+    for _ in range(50):
+        qapp.processEvents()
+        time.sleep(0.01)
+
+    assert not thread.is_alive()
+    assert errors == []
+    text = log_widget.toPlainText()
+    assert "worker-line-0" in text
+    assert "worker-line-19" in text
+
+    window.close()
+
+
+def test_output_info_on_gui_thread_still_works(qapp, monkeypatch):
+    from pycompiler_ark.Ui import output
+
+    window = QMainWindow()
+    log_widget = QTextEdit()
+    window.setCentralWidget(log_widget)
+    window.log = log_widget
+
+    monkeypatch.setattr(output, "_log_widget", log_widget)
+
+    output.info("main-thread-line")
+    qapp.processEvents()
+
+    assert "main-thread-line" in log_widget.toPlainText()
+    window.close()
+
+
+def test_bridge_log_message_level_preferred(qapp, monkeypatch):
+    from pycompiler_ark.Ui import output
+
+    calls: list[tuple] = []
+
+    class Bridge:
+        def log_message_level(self, level, fr, en):
+            calls.append((level, fr, en))
+
+    # Even with a cached QTextEdit, bridge must win to avoid double-write.
+    fake_widget = QTextEdit()
+    monkeypatch.setattr(output, "_log_widget", fake_widget)
+
+    output.info("bridged-msg", gui=Bridge())
+    qapp.processEvents()
+
+    assert calls == [("info", "bridged-msg", "bridged-msg")]
+    assert "bridged-msg" not in fake_widget.toPlainText()