pygpt-net 2.6.20__py3-none-any.whl → 2.6.22__py3-none-any.whl

pygpt_net/ui/widget/textarea/input.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.22 15:00:00                  #
+# Updated Date: 2025.08.24 23:00:00                  #
 # ================================================== #
 
 from PySide6 import QtCore
@@ -15,17 +15,20 @@ from PySide6.QtGui import QAction, QIcon, QImage
 from PySide6.QtWidgets import QTextEdit, QApplication
 
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
-
 
 class ChatInput(QTextEdit):
+
+    ICON_PASTE = QIcon(":/icons/paste.svg")
+    ICON_VOLUME = QIcon(":/icons/volume.svg")
+    ICON_SAVE = QIcon(":/icons/save.svg")
+
     def __init__(self, window=None):
         """
         Chat input
 
         :param window: main window
         """
-        super(ChatInput, self).__init__(window)
+        super().__init__(window)
         self.window = window
         self.setAcceptRichText(False)
         self.setFocus()
@@ -63,7 +66,8 @@ class ChatInput(QTextEdit):
                     self.window.controller.attachment.from_clipboard_url(local_path)
         elif source.hasText():
             text = source.text()
-            self.window.controller.attachment.from_clipboard_text(text)
+            if text:
+                self.window.controller.attachment.from_clipboard_text(text)
 
     def contextMenuEvent(self, event):
         """
@@ -72,51 +76,45 @@ class ChatInput(QTextEdit):
         :param event: event
         """
         menu = self.createStandardContextMenu()
-
-        # paste attachment
-        if self.window.controller.attachment.clipboard_has_attachment():
-            action = QAction(QIcon(":/icons/paste.svg"), trans("action.use.attachment"), self)
-            action.triggered.connect(self.action_from_clipboard)
-            menu.addAction(action)
-
-        selected_text = self.textCursor().selectedText()
-        if selected_text:
-            # plain text
-            plain_text = self.textCursor().selection().toPlainText()
-
-            # audio read
-            action = QAction(QIcon(":/icons/volume.svg"), trans('text.context_menu.audio.read'), self)
-            action.triggered.connect(self.audio_read_selection)
-            menu.addAction(action)
-
-            # copy to
-            copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(self, selected_text, excluded=["input"])
-            menu.addMenu(copy_to_menu)
-
-            # save as (selected)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_selection_as'), self)
-            action.triggered.connect(
-                lambda: self.window.controller.chat.common.save_text(plain_text))
-            menu.addAction(action)
-        else:
-            # save as (all)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_as'), self)
-            action.triggered.connect(
-                lambda: self.window.controller.chat.common.save_text(self.toPlainText()))
-            menu.addAction(action)
-
         try:
-            self.window.core.prompt.template.to_menu_options(menu, "input")
-            self.window.core.prompt.custom.to_menu_options(menu, "input")
-        except Exception as e:
-            self.window.core.debug.log(e)
-
-        # save current prompt
-        action = QAction(QIcon(":/icons/save.svg"), trans('preset.prompt.save_custom'), self)
-        action.triggered.connect(self.window.controller.presets.save_prompt)
-        menu.addAction(action)
+            if self.window.controller.attachment.clipboard_has_attachment():
+                action = QAction(self.ICON_PASTE, trans("action.use.attachment"), menu)
+                action.triggered.connect(self.action_from_clipboard)
+                menu.addAction(action)
+
+            cursor = self.textCursor()
+            selected_text = cursor.selectedText()
+            if selected_text:
+                plain_text = cursor.selection().toPlainText()
+
+                action = QAction(self.ICON_VOLUME, trans('text.context_menu.audio.read'), menu)
+                action.triggered.connect(self.audio_read_selection)
+                menu.addAction(action)
+
+                copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(menu, selected_text, excluded=["input"])
+                menu.addMenu(copy_to_menu)
+
+                action = QAction(self.ICON_SAVE, trans('action.save_selection_as'), menu)
+                action.triggered.connect(lambda: self.window.controller.chat.common.save_text(plain_text))
+                menu.addAction(action)
+            else:
+                action = QAction(self.ICON_SAVE, trans('action.save_as'), menu)
+                action.triggered.connect(lambda: self.window.controller.chat.common.save_text(self.toPlainText()))
+                menu.addAction(action)
+
+            try:
+                self.window.core.prompt.template.to_menu_options(menu, "input")
+                self.window.core.prompt.custom.to_menu_options(menu, "input")
+            except Exception as e:
+                self.window.core.debug.log(e)
+
+            action = QAction(self.ICON_SAVE, trans('preset.prompt.save_custom'), menu)
+            action.triggered.connect(self.window.controller.presets.save_prompt)
+            menu.addAction(action)
 
-        menu.exec_(event.globalPos())
+            menu.exec(event.globalPos())
+        finally:
+            menu.deleteLater()
 
     def action_from_clipboard(self):
         """
@@ -137,28 +135,26 @@ class ChatInput(QTextEdit):
         :param event: key event
         """
         handled = False
-        if event.key() in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
+        key = event.key()
+        if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
             mode = self.window.core.config.get('send_mode')
-            if mode > 0:  # Enter or Shift + Enter
-                if mode == 2:  # Shift + Enter
-                    modifiers = QApplication.keyboardModifiers()
+            if mode > 0:
+                modifiers = event.modifiers()
+                if mode == 2:
                     if modifiers == QtCore.Qt.ShiftModifier or modifiers == QtCore.Qt.ControlModifier:
                         self.window.controller.chat.input.send_input()
                         handled = True
-                else:  # Enter
-                    modifiers = QApplication.keyboardModifiers()
+                else:
                     if modifiers != QtCore.Qt.ShiftModifier and modifiers != QtCore.Qt.ControlModifier:
                         self.window.controller.chat.input.send_input()
                         handled = True
                 self.setFocus()
-
-        # cancel edit
-        elif event.key() == Qt.Key_Escape and self.window.controller.ctx.extra.is_editing():
+        elif key == Qt.Key_Escape and self.window.controller.ctx.extra.is_editing():
             self.window.controller.ctx.extra.edit_cancel()
             handled = True
 
         if not handled:
-            super(ChatInput, self).keyPressEvent(event)
+            super().keyPressEvent(event)
 
     def wheelEvent(self, event):
         """
@@ -167,16 +163,19 @@ class ChatInput(QTextEdit):
         :param event: Event
         """
         if event.modifiers() & Qt.ControlModifier:
-            if event.angleDelta().y() > 0:
+            prev = self.value
+            dy = event.angleDelta().y()
+            if dy > 0:
                 if self.value < self.max_font_size:
                     self.value += 1
             else:
                 if self.value > self.min_font_size:
                     self.value -= 1
 
-            self.window.core.config.data['font_size.input'] = self.value
-            self.window.core.config.save()
-            self.window.controller.ui.update_font_size()
+            if self.value != prev:
+                self.window.core.config.data['font_size.input'] = self.value
+                self.window.core.config.save()
+                self.window.controller.ui.update_font_size()
             event.accept()
-        else:
-            super(ChatInput, self).wheelEvent(event)
+            return
+        super().wheelEvent(event)

pygpt_net/ui/widget/textarea/notepad.py

@@ -6,18 +6,17 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.22 15:00:00                  #
+# Updated Date: 2025.08.24 23:00:00                  #
 # ================================================== #
 
 from PySide6.QtCore import Qt, QEvent, QTimer
 from PySide6.QtGui import QAction, QIcon, QKeySequence, QTextCursor, QFontMetrics
-from PySide6.QtWidgets import QTextEdit, QWidget, QVBoxLayout, QApplication
+from PySide6.QtWidgets import QTextEdit, QWidget, QVBoxLayout
 
 from pygpt_net.core.tabs.tab import Tab
 from pygpt_net.core.text.finder import Finder
 from pygpt_net.ui.widget.element.labels import HelpLabel
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
 
 
 class NotepadWidget(QWidget):
@@ -83,6 +82,10 @@ class NotepadWidget(QWidget):
         self.deleteLater()
 
 class NotepadOutput(QTextEdit):
+    ICON_VOLUME = QIcon(":/icons/volume.svg")
+    ICON_SAVE = QIcon(":/icons/save.svg")
+    ICON_SEARCH = QIcon(":/icons/search.svg")
+
     def __init__(self, window=None):
         """
         Notepad output textarea
@@ -104,26 +107,34 @@ class NotepadOutput(QTextEdit):
         self.installEventFilter(self)
         self.setProperty('class', 'layout-notepad')
 
-        # tabulation
         metrics = QFontMetrics(self.font())
         space_width = metrics.horizontalAdvance(" ")
         self.setTabStopDistance(4 * space_width)
 
+        self._vscroll = self.verticalScrollBar()
+        self._vscroll.valueChanged.connect(self._on_scrollbar_value_changed)
+        self._restore_attempts = 0
+
     def on_delete(self):
         """On delete"""
         if self.finder:
             self.finder.disconnect()  # disconnect finder
             self.finder = None  # delete finder
+        try:
+            self._vscroll.valueChanged.disconnect(self._on_scrollbar_value_changed)
+        except Exception:
+            pass
         self.deleteLater()
 
     def showEvent(self, event):
         super().showEvent(event)
+        self._restore_attempts = 0
         QTimer.singleShot(0, self.restore_scroll_pos)
 
     def scroll_to_bottom(self):
         self.moveCursor(QTextCursor.End)
         self.ensureCursorVisible()
-        scroll_bar = self.verticalScrollBar()
+        scroll_bar = self._vscroll
         scroll_bar.setValue(scroll_bar.maximum())
 
     def eventFilter(self, source, event):
@@ -133,15 +144,10 @@ class NotepadOutput(QTextEdit):
         :param source: source
         :param event: event
         """
-        if event.type() == event.Type.FocusIn:
+        if event.type() == QEvent.FocusIn:
             if self.tab is not None:
                 col_idx = self.tab.column_idx
                 self.window.controller.ui.tabs.on_column_focus(col_idx)
-        elif source == self.verticalScrollBar():
-            if event.type() == QEvent.Wheel:
-                self.last_scroll_pos = self.verticalScrollBar().value()
-            elif event.type() in (QEvent.MouseButtonPress, QEvent.MouseButtonRelease):
-                self.last_scroll_pos = self.verticalScrollBar().value()
         return super().eventFilter(source, event)
 
     def set_tab(self, tab: Tab):
@@ -152,23 +158,33 @@ class NotepadOutput(QTextEdit):
         """
         self.tab = tab
 
+    def setText(self, text: str):
+        if self.toPlainText() == text:
+            return
+        self.setPlainText(text)
+
     def text_changed(self):
         """On text changed"""
         if not self.window.core.notepad.locked:
             self.window.controller.notepad.save(self.id)  # use notepad id
-        self.finder.text_changed()
-        self.last_scroll_pos = self.verticalScrollBar().value()
+        if self.finder is not None:
+            self.finder.text_changed()
+        self.last_scroll_pos = self._vscroll.value()
+
+    def _on_scrollbar_value_changed(self, value: int):
+        self.last_scroll_pos = value
 
     def restore_scroll_pos(self):
         if self.last_scroll_pos is None:
             return
-
-        scroll_bar = self.verticalScrollBar()
+        scroll_bar = self._vscroll
         current_max = scroll_bar.maximum()
         if self.last_scroll_pos > current_max:
-            self.updateGeometry()
-            QApplication.processEvents()
-            QTimer.singleShot(50, self.restore_scroll_pos)
+            if self._restore_attempts < 30:
+                self._restore_attempts += 1
+                QTimer.singleShot(16, self.restore_scroll_pos)
+            else:
+                scroll_bar.setValue(current_max)
         else:
             scroll_bar.setValue(self.last_scroll_pos)
 
@@ -179,34 +195,30 @@ class NotepadOutput(QTextEdit):
         :param event: Event
         """
         menu = self.createStandardContextMenu()
-        selected_text = self.textCursor().selectedText()
+        cursor = self.textCursor()
+        selected_text = cursor.selectedText()
         if selected_text:
-            # plain text
-            plain_text = self.textCursor().selection().toPlainText()
+            plain_text = cursor.selection().toPlainText()
 
-            # audio read
-            action = QAction(QIcon(":/icons/volume.svg"), trans('text.context_menu.audio.read'), self)
+            action = QAction(self.ICON_VOLUME, trans('text.context_menu.audio.read'), self)
             action.triggered.connect(self.audio_read_selection)
             menu.addAction(action)
 
-            # copy to (without current notepad)
-            excluded_id = "notepad_id_{}".format(self.id)
-            copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(self, selected_text, excluded=[excluded_id])
+            excluded_id = f"notepad_id_{self.id}"
+            copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(menu, selected_text, excluded=[excluded_id])
             menu.addMenu(copy_to_menu)
 
-            # save as (selected)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_selection_as'), self)
+            action = QAction(self.ICON_SAVE, trans('action.save_selection_as'), self)
             action.triggered.connect(
                 lambda: self.window.controller.chat.common.save_text(plain_text))
             menu.addAction(action)
         else:
-            # save as (all)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_as'), self)
+            action = QAction(self.ICON_SAVE, trans('action.save_as'), self)
             action.triggered.connect(
                 lambda: self.window.controller.chat.common.save_text(self.toPlainText()))
             menu.addAction(action)
 
-        action = QAction(QIcon(":/icons/search.svg"), trans('text.context_menu.find'), self)
+        action = QAction(self.ICON_SEARCH, trans('text.context_menu.find'), self)
         action.triggered.connect(self.find_open)
         action.setShortcut(QKeySequence("Ctrl+F"))
         menu.addAction(action)
@@ -246,28 +258,33 @@ class NotepadOutput(QTextEdit):
         :param event: Event
         """
         if event.modifiers() & Qt.ControlModifier:
-            if event.angleDelta().y() > 0:
+            delta = event.angleDelta().y()
+            if delta > 0:
                 if self.value < self.max_font_size:
                     self.value += 1
+                else:
+                    return
             else:
                 if self.value > self.min_font_size:
                     self.value -= 1
+                else:
+                    return
 
             self.window.core.config.data['font_size'] = self.value
             self.window.core.config.save()
             option = self.window.controller.settings.editor.get_option('font_size')
             option['value'] = self.value
             self.window.controller.config.apply(
-                parent_id='config', 
-                key='font_size', 
+                parent_id='config',
+                key='font_size',
                 option=option,
             )
             self.window.controller.ui.update_font_size()
             event.accept()
-            self.last_scroll_pos = self.verticalScrollBar().value()
+            self.last_scroll_pos = self._vscroll.value()
         else:
             super(NotepadOutput, self).wheelEvent(event)
-            self.last_scroll_pos = self.verticalScrollBar().value()
+            self.last_scroll_pos = self._vscroll.value()
 
     def focusInEvent(self, e):
         """
@@ -285,5 +302,4 @@ class NotepadOutput(QTextEdit):
         :param e: focus event
         """
         super(NotepadOutput, self).focusOutEvent(e)
-        self.window.controller.finder.focus_out(self.finder)
-
+        self.window.controller.finder.focus_out(self.finder)

pygpt_net/ui/widget/textarea/output.py

@@ -6,30 +6,34 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.05 21:00:00                  #
+# Updated Date: 2025.08.24 23:00:00                  #
 # ================================================== #
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QEvent
 from PySide6.QtWidgets import QTextBrowser
 from PySide6.QtGui import QAction, QIcon, QTextOption, QKeySequence
 
 from pygpt_net.core.text.finder import Finder
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
 
 
 class ChatOutput(QTextBrowser):
+    ICON_VOLUME = QIcon(":/icons/volume.svg")
+    ICON_SAVE = QIcon(":/icons/save.svg")
+    ICON_SEARCH = QIcon(":/icons/search.svg")
+
     def __init__(self, window=None):
         """
         Chat output
 
         :param window: main window
         """
-        super(ChatOutput, self).__init__(window)
+        super().__init__(window)
         self.window = window
         self.finder = Finder(window, self)
         self.setReadOnly(True)
         self.setAcceptRichText(False)
+        self.setUndoRedoEnabled(False)
         self.setStyleSheet(self.window.controller.theme.style('font.chat.output'))
         self.value = self.window.core.config.get('font_size')
         self.max_font_size = 42
@@ -45,15 +49,14 @@ class ChatOutput(QTextBrowser):
     def on_delete(self):
         """Clean up on delete"""
         if self.finder:
-            self.finder.disconnect()  # disconnect finder
-            self.finder = None  # delete finder
+            self.finder.disconnect()
+            self.finder = None
 
-        self.tab = None  # clear tab reference
+        self.tab = None
         self.clear()
-
-        # disconnect signals
+        self.removeEventFilter(self)
         self.anchorClicked.disconnect(self.open_external_link)
-        self.deleteLater()  # delete widget
+        self.deleteLater()
 
     def eventFilter(self, source, event):
         """
@@ -62,7 +65,7 @@ class ChatOutput(QTextBrowser):
         :param source: source
         :param event: event
         """
-        if event.type() == event.Type.FocusIn:
+        if event.type() == QEvent.FocusIn:
             if self.tab is not None:
                 col_idx = self.tab.column_idx
                 self.window.controller.ui.tabs.on_column_focus(col_idx)
@@ -91,41 +94,42 @@ class ChatOutput(QTextBrowser):
         :param event: Event
         """
         menu = self.createStandardContextMenu()
-        selected_text = self.textCursor().selectedText()
+        cursor = self.textCursor()
+        has_selection = cursor.hasSelection()
 
-        if selected_text:
-            # plain text
-            plain_text = self.textCursor().selection().toPlainText()
+        if has_selection:
+            selected_text = cursor.selectedText()
 
-            # audio read
-            action = QAction(QIcon(":/icons/volume.svg"), trans('text.context_menu.audio.read'), self)
+            action = QAction(self.ICON_VOLUME, trans('text.context_menu.audio.read'), self)
             action.triggered.connect(self.audio_read_selection)
             menu.addAction(action)
 
-            # copy to
-            copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(self, selected_text)
+            copy_to_menu = self.window.ui.context_menu.get_copy_to_menu(menu, selected_text)
             menu.addMenu(copy_to_menu)
 
-            # save as (selected)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_selection_as'), self)
-            action.triggered.connect(
-                lambda: self.window.controller.chat.common.save_text(plain_text)
-            )
+            action = QAction(self.ICON_SAVE, trans('action.save_selection_as'), self)
+            action.triggered.connect(self._save_selected_text)
             menu.addAction(action)
         else:
-            # save as (all)
-            action = QAction(QIcon(":/icons/save.svg"), trans('action.save_as'), self)
-            action.triggered.connect(
-                lambda: self.window.controller.chat.common.save_text(self.toPlainText())
-            )
+            action = QAction(self.ICON_SAVE, trans('action.save_as'), self)
+            action.triggered.connect(self._save_all_text)
             menu.addAction(action)
 
-        action = QAction(QIcon(":/icons/search.svg"), trans('text.context_menu.find'), self)
+        action = QAction(self.ICON_SEARCH, trans('text.context_menu.find'), self)
         action.triggered.connect(self.find_open)
         action.setShortcut(QKeySequence("Ctrl+F"))
         menu.addAction(action)
 
-        menu.exec_(event.globalPos())
+        menu.exec(event.globalPos())
+        menu.deleteLater()
+
+    def _save_selected_text(self):
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            self.window.controller.chat.common.save_text(cursor.selection().toPlainText())
+
+    def _save_all_text(self):
+        self.window.controller.chat.common.save_text(self.toPlainText())
 
     def audio_read_selection(self):
         """Read selected text (audio)"""
@@ -138,7 +142,7 @@ class ChatOutput(QTextBrowser):
     def on_update(self):
         """On content update"""
         if self.finder:
-            self.finder.clear()  # clear finder
+            self.finder.clear()
 
     def keyPressEvent(self, e):
         """
@@ -147,9 +151,9 @@ class ChatOutput(QTextBrowser):
         :param e: Event
         """
         if e.key() == Qt.Key_F and e.modifiers() & Qt.ControlModifier:
-            self.find_open()  # open find dialog
-        else:
-            super(ChatOutput, self).keyPressEvent(e)
+            self.find_open()
+            return
+        super().keyPressEvent(e)
 
     def wheelEvent(self, event):
         """
@@ -158,26 +162,33 @@ class ChatOutput(QTextBrowser):
         :param event: Event
         """
         if event.modifiers() & Qt.ControlModifier:
-            if event.angleDelta().y() > 0:
-                if self.value < self.max_font_size:
-                    self.value += 1
+            dy = event.angleDelta().y()
+            if dy > 0:
+                new_value = min(self.value + 1, self.max_font_size)
+            elif dy < 0:
+                new_value = max(self.value - 1, self.min_font_size)
             else:
-                if self.value > self.min_font_size:
-                    self.value -= 1
-
-            self.window.core.config.data['font_size'] = self.value
-            self.window.core.config.save()
-            option = self.window.controller.settings.editor.get_option('font_size')
-            option['value'] = self.value
-            self.window.controller.config.apply(
-                parent_id='config', 
-                key='font_size', 
-                option=option,
-            )
-            self.window.controller.ui.update_font_size()
+                event.accept()
+                return
+
+            if new_value == self.value:
+                event.accept()
+                return
+
+            self.value = new_value
+
+            cfg = self.window.core.config
+            cfg.data['font_size'] = new_value
+            cfg.save()
+
+            ctrl = self.window.controller
+            option = ctrl.settings.editor.get_option('font_size')
+            option['value'] = new_value
+            ctrl.config.apply(parent_id='config', key='font_size', option=option)
+            ctrl.ui.update_font_size()
             event.accept()
         else:
-            super(ChatOutput, self).wheelEvent(event)
+            super().wheelEvent(event)
 
     def focusInEvent(self, e):
         """
@@ -185,5 +196,5 @@ class ChatOutput(QTextBrowser):
 
         :param e: focus event
         """
-        super(ChatOutput, self).focusInEvent(e)
-        self.window.controller.finder.focus_in(self.finder)
+        super().focusInEvent(e)
+        self.window.controller.finder.focus_in(self.finder)

pygpt_net/ui/widget/textarea/search_input.py

@@ -6,15 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.09 15:00:00                  #
+# Updated Date: 2025.08.24 23:00:00                  #
 # ================================================== #
 
 from PySide6.QtGui import QAction, QIcon
-from PySide6.QtWidgets import QLineEdit, QStyle
-from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QLineEdit
+from PySide6.QtCore import QTimer, Slot
 
 from pygpt_net.utils import trans
-import pygpt_net.icons_rc
 
 
 class CtxSearchInput(QLineEdit):
@@ -56,6 +55,7 @@ class CtxSearchInput(QLineEdit):
         self._search_timer.stop()  # stop the timer to prevent triggering the search action
         self.window.controller.ctx.search_string_clear()
 
+    @Slot(str)
     def on_text_changed(self, text):
         """
         On text changed
@@ -67,6 +67,7 @@ class CtxSearchInput(QLineEdit):
         # after a pause in typing
         self._search_timer.start()
 
+    @Slot()
     def _execute_search(self):
         """Invoke the search action after a specified delay."""
         search_text = self.text()