pyqt-code-editor 0.0.53__tar.gz → 0.0.55__tar.gz

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.53
+Version: 0.0.55
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>
@@ -32,7 +32,7 @@ Project-URL: Source, https://github.com/open-cogsci/sigmund-analyst
 
 # PyQt Code Editor / Sigmund Analyst
 
-Copyright 2025 Sebastiaan Mathôt
+Copyright 2025-2026 Sebastiaan Mathôt
 
 
 ## About

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.53'
+__version__ = '0.0.55'

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/_settings.py

@@ -120,6 +120,7 @@ class Settings(QObject):
     check_interval_delay = SettingProperty(5000, "Checking")
     
     # Sigmund provider
+    sigmund_review_actions = SettingProperty(True, "Sigmund")
     sigmund_max_context = SettingProperty(2000, "Sigmund")
     sigmund_fim_endpoint = SettingProperty('http://localhost:5000/code_completion/fim', "Sigmund")
     sigmund_token = SettingProperty(None, "Sigmund")

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/app.py

@@ -349,6 +349,10 @@ class SigmundAnalyst(QMainWindow):
         self._jupyter_console.execute_code(code)
 
     def _execute_file(self, path):
+        working_directory = os.path.dirname(path)
+        if os.path.isdir(working_directory):
+            self._jupyter_console.change_directory(working_directory)
+        self._toggle_dock_widget(self._jupyter_console, show=True)
         self._jupyter_console.execute_file(path)
 
     def _find_in_files(self):

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/__init__.py

@@ -0,0 +1 @@
+from .sigmund import Sigmund

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/confirm_run_code_dialog.py

@@ -0,0 +1,59 @@
+from qtpy.QtWidgets import QVBoxLayout, QDialogButtonBox, QLabel, \
+    QSizePolicy, QDialog, QSplitter
+from qtpy.QtCore import Qt
+import logging
+from sigmund_qtwidget.chat_browser import ChatBrowser
+from pyqt_code_editor.code_editors import create_editor
+
+logger = logging.getLogger(__name__)
+
+MAX_MESSAGE_HEIGHT = 200
+
+class ConfirmRunCodeDialog(QDialog):
+    """
+    A modal dialog that displays code to be executed and asks the user to confirm or cancel.
+    """
+
+    def __init__(self, parent, code: str, language: str):
+        super().__init__(parent)
+
+        self.setWindowTitle(f"Confirm {language} code execution")
+
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        # Use ChatBrowser to display the AI message
+        self.message_browser = ChatBrowser(self)
+        self.message_browser.append_message(
+            'ai', 'Sigmund wants to run the following code:')
+        self.message_browser.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        self.message_browser.setMaximumHeight(MAX_MESSAGE_HEIGHT)
+
+        # Create code editor for the code to be executed
+        self.code_view = create_editor(language=language)
+        self.code_view.setPlainText(code)
+        self.code_view.setReadOnly(True)
+
+        # Create a vertical splitter to hold the message browser and the code
+        splitter = QSplitter(Qt.Vertical)
+        splitter.addWidget(self.message_browser)
+        splitter.addWidget(self.code_view)
+        layout.addWidget(splitter)
+
+        # The disclaimer label
+        disclaimer_label = QLabel(
+            "Carefully review the code before execution. Executing code can have unintended consequences.",
+            self
+        )
+        disclaimer_label.setWordWrap(True)
+        disclaimer_label.setObjectName('control-warning')
+        disclaimer_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        layout.addWidget(disclaimer_label)
+
+        # Dialog buttons
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+        layout.addWidget(self.button_box)
+
+        self.resize(800, 600)

pyqt_code_editor-0.0.53/pyqt_code_editor/components/sigmund.py → pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/editor_workspace.py

@@ -1,6 +1,3 @@
-from sigmund_qtwidget.sigmund_widget import SigmundWidget
-from ..widgets import Dock
-from .. import watchdog, settings
 import textwrap
 import logging
 logger = logging.getLogger(__name__)
@@ -76,11 +73,14 @@ class EditorWorkspace:
     
     def set(self, content, language):
         text_cursor = self._editor.textCursor()
+        text_cursor.beginEditBlock()
         if text_cursor.hasSelection():
             text_cursor.insertText(content)
-            self._editor.setTextCursor(text_cursor)
         else:
-            self._editor.setPlainText(content)
+            text_cursor.select(text_cursor.Document)
+            text_cursor.insertText(content)
+        text_cursor.endEditBlock()
+        self._editor.setTextCursor(text_cursor)
         self._editor.set_modified(True)
     
     def has_changed(self, content, language):
@@ -98,24 +98,3 @@ class EditorWorkspace:
         if content is None:
             return ''
         return content
-
-
-class Sigmund(Dock):
-    def __init__(self, parent, editor_panel):
-        super().__init__('Sigmund', parent)
-        self.setObjectName("sigmund")
-        workspace = EditorWorkspace(editor_panel)
-        self.sigmund_widget = SigmundWidget(self, application='Sigmund Analyst')
-        self.sigmund_widget.setStyleSheet(f'font-size: {settings.font_size}pt')
-        self.sigmund_widget.set_workspace_manager(workspace)
-        self.setWidget(self.sigmund_widget)
-
-    def setVisible(self, visible):
-        if visible:
-            logger.info('starting sigmund connector')
-            self.sigmund_widget.start_server()
-            watchdog.register_subprocess(self.sigmund_widget.server_pid)
-        else:
-            logger.info('stopping sigmund connector')
-            self.sigmund_widget.stop_server()
-        super().setVisible(visible)

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/sigmund.py

@@ -0,0 +1,28 @@
+from ...widgets import Dock
+from ... import watchdog, settings
+from .editor_workspace import EditorWorkspace
+from .sigmund_analyst_widget import SigmundAnalystWidget
+import logging
+logger = logging.getLogger(__name__)
+        
+        
+class Sigmund(Dock):
+    def __init__(self, parent, editor_panel):
+        super().__init__('Sigmund', parent)
+        self.setObjectName("sigmund")
+        workspace = EditorWorkspace(editor_panel)
+        self.sigmund_widget = SigmundAnalystWidget(
+            self, editor_panel)
+        self.sigmund_widget.setStyleSheet(f'font-size: {settings.font_size}pt')
+        self.sigmund_widget.set_workspace_manager(workspace)
+        self.setWidget(self.sigmund_widget)
+
+    def setVisible(self, visible):
+        if visible:
+            logger.info('starting sigmund connector')
+            self.sigmund_widget.start_server()
+            watchdog.register_subprocess(self.sigmund_widget.server_pid)
+        else:
+            logger.info('stopping sigmund connector')
+            self.sigmund_widget.stop_server()
+        super().setVisible(visible)

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/sigmund_analyst_chat_widget.py

@@ -0,0 +1,35 @@
+from qtpy.QtWidgets import QCheckBox, QWidget, QVBoxLayout
+from sigmund_qtwidget.chat_widget import ChatWidget
+from ... import settings
+
+
+class SigmundAnalystChatWidget(ChatWidget):
+    """Extended chat widget with Sigmund Analyst-specific options"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Create a container for the checkboxes
+        options_container = QWidget()
+        options_layout = QVBoxLayout(options_container)
+        options_layout.setContentsMargins(5, 5, 5, 5)
+        options_layout.setSpacing(2)
+        # "Review proposed changes" checkbox
+        self._review_actions_checkbox = QCheckBox(
+            "Review Sigmund's actions (recommended)")
+        self._review_actions_checkbox.setChecked(
+            settings.sigmund_review_actions)
+        self._review_actions_checkbox.stateChanged.connect(
+            self._on_review_actions_changed)
+        options_layout.addWidget(self._review_actions_checkbox)
+        # Insert the options container before the input container
+        main_layout = self.layout()
+        main_layout.insertWidget(main_layout.count(), options_container)
+        
+    def _on_review_actions_changed(self, state):
+        """Store the review changes setting."""
+        settings.sigmund_review_actions = bool(state)
+            
+    def append_message(self, msg_type, text, scroll=True):
+        if msg_type == 'ai' and '(Suggesting IDE action)' in text:
+            text = '⚙️ Sigmund is working …'
+        self._chat_browser.append_message(msg_type, text, scroll)        

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/sigmund_analyst_widget.py

@@ -0,0 +1,191 @@
+import os
+import time
+from sigmund_qtwidget.sigmund_widget import SigmundWidget
+from qtpy.QtCore import QEventLoop, QTimer
+from qtpy.QtWidgets import QMessageBox, QDialog
+from .sigmund_analyst_chat_widget import SigmundAnalystChatWidget
+from .confirm_run_code_dialog import ConfirmRunCodeDialog
+from ... import settings
+import logging
+logger = logging.getLogger(__name__)
+
+ACTION_CANCELLED = 'I do not approve this action.'
+
+
+class SigmundAnalystWidget(SigmundWidget):
+    """Extends the default Sigmund widget with Sigmund Analyst-specific
+    functionality.
+    """
+    chat_widget_cls = SigmundAnalystChatWidget
+
+    def __init__(self, parent, editor_panel):
+        super().__init__(parent, application='Sigmund Analyst')
+        try:
+            self._app = parent.parent()
+            self._jupyter_console = self._app._jupyter_console
+            # Connect the code_executed signal to a slot
+        except AttributeError:
+            logger.warning('No Jupyter console found.')
+            self._jupyter_console = None
+        else:
+            self._jupyter_console.execution_complete.connect(
+                self._handle_execution_result)
+        self._editor_panel = editor_panel
+        self._transient_settings = {
+            'tool_ide_open_file': 'true',
+            'tool_ide_execute_code': 'true'
+        }
+        # Store execution results
+        self._execution_result = None
+        self._execution_loop = None
+
+    def _confirm_action(self, action_type, details):
+        """Show a confirmation dialog for the proposed action.
+
+        Args:
+            action_type (str): Type of action (e.g., "open file", "execute code")
+            details (str): Detailed information about the action
+
+        Returns:
+            bool: True if action is approved, False otherwise
+        """
+        if not settings.sigmund_review_actions:
+            return True
+
+        if action_type == "open file":
+            return QMessageBox.question(
+                self, 
+                "Open file",
+                f"Sigmund wants to open: \n\n{details}",
+                QMessageBox.Ok | QMessageBox.Cancel,
+                QMessageBox.Ok
+            ) == QMessageBox.Ok
+        dialog = ConfirmRunCodeDialog(
+            self,
+            action_type,
+            details
+        )
+        return dialog.exec_() == QDialog.Accepted
+
+    def _handle_execution_result(self, output, result):
+        """Slot that handles the code_executed signal."""
+        self._execution_result = (output, result)
+        if self._execution_loop and self._execution_loop.isRunning():
+            time.sleep(0.5)  # Wait for errors to appear
+            self._execution_loop.quit()
+
+    def run_command_open_file(self, path):
+        if settings.sigmund_review_actions:
+            if not QMessageBox.question(self, 
+                                        "Confirm open file",
+                                        f"Sigmund wants to open: \n\n{path}",
+                                        QMessageBox.Ok | QMessageBox.Cancel,
+                                        QMessageBox.Ok) == QMessageBox.Ok:
+                return ACTION_CANCELLED
+        try:
+            self._editor_panel.open_file(path)
+        except Exception as e:
+            return f'Failed to open file: {e}'
+        return f'Opened file: {path}'
+
+    def run_command_execute_code(self, code, language):
+        if settings.sigmund_review_actions:
+            if not ConfirmRunCodeDialog(self, code, language).exec() \
+                    == ConfirmRunCodeDialog.Accepted:
+                return ACTION_CANCELLED
+        if self._jupyter_console is None:
+            return 'Code execution not supported.'
+        self._app._toggle_dock_widget(self._jupyter_console, show=True)
+        self._execution_result = None
+        self._execution_loop = QEventLoop()
+        QTimer.singleShot(30000, self._execution_loop.quit)  # 30 second timeout
+        self._jupyter_console.execute_code(code)
+        self._execution_loop.exec_()
+        self._execution_loop = None
+        if self._execution_result is None:
+            return 'Code execution timed out or failed to return a result.'
+        try:
+            console_content = self._jupyter_console.get_current_console().jupyter_widget._control.toPlainText()
+        except Exception as e:
+            return f'Failed to get results from console content: {e}'
+            console_content = ''
+        console_content = '\n'.join(console_content.splitlines()[-100:])
+        return f'# Console output (may be truncated):\n\n{console_content}'
+    @property
+    def _editor(self):
+        return self._editor_panel.active_editor()        
+        
+    def send_user_message(self, text, *args, **kwargs):
+        current_path = self._editor.code_editor_file_path
+        # If the editor is not linked to a file, simply use the working 
+        # directory.
+        if current_path is None:
+            current_path = '[unsaved file]'
+            working_directory = os.getcwd()
+        else:
+            working_directory = os.path.dirname(current_path)
+
+        # Initialize with default value
+        working_directory_contents = "(No directory contents available)"
+
+        # Get directory contents with priority to top-level items
+        top_level = []
+        all_items = []
+
+        # Only wrap file system operations in try-except
+        try:
+            # Get top-level items (depth=1)
+            top_level = [f for f in os.listdir(working_directory)
+                        if os.path.isfile(os.path.join(working_directory, f))
+                        or os.path.isdir(os.path.join(working_directory, f))]
+
+            # Then get deeper items if we haven't reached our limit
+            remaining_slots = max(0, 20 - len(top_level))
+            if remaining_slots > 0:
+                for root, dirs, files in os.walk(working_directory):
+                    # Skip the top level since we already have it
+                    if root == working_directory:
+                        continue
+                    # Add files first
+                    for file in files:
+                        if remaining_slots <= 0:
+                            break
+                        rel_path = os.path.relpath(os.path.join(root, file), working_directory)
+                        all_items.append(f".\\{rel_path}")
+                        remaining_slots -= 1
+                    # Then add directories if we still have space
+                    for dir in dirs:
+                        if remaining_slots <= 0:
+                            break
+                        rel_path = os.path.relpath(os.path.join(root, dir), working_directory)
+                        all_items.append(f".\\{rel_path}\\")
+                        remaining_slots -= 1
+
+            # Combine top level and deeper items
+            working_directory_contents = "\n".join(
+                sorted([f".\\{item}" if os.path.isfile(os.path.join(working_directory, item))
+                 else f".\\{item}\\" for item in top_level] +
+                all_items)
+            )
+
+            if len(top_level) + len(all_items) > 20:
+                working_directory_contents += "\n... (additional files truncated)"
+
+        except PermissionError:
+            working_directory_contents = "(Could not read some directory contents - permission denied)"
+        except OSError as e:
+            working_directory_contents = f"(Could not read directory contents: {str(e)})"
+
+        system_prompt = f'''## Working directory
+
+The workspace corresponds to the following file: {current_path}
+The working directory is: {working_directory}
+
+Overview of working directory:
+
+```
+{working_directory_contents}
+```
+'''
+        self._transient_system_prompt = system_prompt
+        super().send_user_message(text, *args, **kwargs)

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/auto_pair.py

@@ -88,7 +88,6 @@ class AutoPair:
         if typed_char and len(typed_char) == 1:
             for pair in self.PAIRS:
                 if typed_char == pair["close_seq"]:
-                    print(typed_char)
                     new_cursor = self.textCursor()
                     new_pos = new_cursor.position()
                     new_doc_text = self.toPlainText()

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/base.py

@@ -106,7 +106,9 @@ class Base:
         if the worker died or the result queue is empty, keep polling.
         """
         to_remove = []
-        for pid, queue in self._active_requests.items():
+        # Create a list of active requests to avoid the dictionary being 
+        # changed during iteration
+        for pid, queue in list(self._active_requests.items()):
             # 1) Check if the worker is still alive
             if not manager.check_worker_alive(pid):
                 logger.warning(f"Worker process {pid} no longer alive. Removing from active requests.")
@@ -143,7 +145,7 @@ class Base:
         # Cleanup: remove completed or dead requests. Also stop unused workers.
         # This function periodically prunes worker processes if they are unused.
         for pid in to_remove:
-            self._active_requests.pop(pid, None)            
+            self._active_requests.pop(pid, None)
         manager.stop_unused_workers()
         
     def set_modified(self, modified):

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/comment.py

@@ -44,6 +44,7 @@ class Comment:
     def _toggle_comment(self):
         """Toggle comment on the current selection or current line."""
         cursor = self.textCursor()
+        cursor.beginEditBlock()
         if not cursor.hasSelection():
             # If no selection, just operate on the current line
             cursor.select(cursor.LineUnderCursor)
@@ -70,6 +71,7 @@ class Comment:
             self._uncomment_blocks(startBlock, endBlock)
         else:
             self._comment_blocks(startBlock, endBlock)
+        cursor.endEditBlock()
 
     def _comment_blocks(self, start_block: int, end_block: int):
         """Comment all lines from start_block to end_block."""
@@ -84,6 +86,7 @@ class Comment:
             insert_position = block.position() + leading_spaces
             cursor.setPosition(insert_position)
             cursor.insertText(self.code_editor_comment_string)  
+        self.setTextCursor(cursor)
 
     def _uncomment_blocks(self, start_block: int, end_block: int):
         """Uncomment all lines from start_block to end_block."""
@@ -102,3 +105,4 @@ class Comment:
                 cursor.setPosition(remove_position + strip_len, cursor.KeepAnchor)
                 if cursor.selectedText() == self.code_editor_comment_string.rstrip('\r\n'):
                     cursor.removeSelectedText()
+        self.setTextCursor(cursor)                    

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/merge_undo_actions.py

@@ -20,11 +20,6 @@ class MergeUndoActions:
         key = event.key()
         modifiers = event.modifiers()
 
-        is_navigation = (
-            key in navigation_keys
-            and not (modifiers & Qt.KeyboardModifier.ShiftModifier)
-        )
-
         # Treat platform "command" modifier as well (Control on Windows/Linux, Meta on macOS)
         ctrl_or_meta = Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier
         has_ctrl_or_meta = bool(modifiers & ctrl_or_meta)
@@ -39,7 +34,7 @@ class MergeUndoActions:
             key == Qt.Key.Key_Y
         )
 
-        if is_navigation or is_undo or is_redo:
+        if key in navigation_keys or is_undo or is_redo:
             # Do not wrap these in an edit block
             super().keyPressEvent(event)
             return

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/search_replace.py

@@ -8,10 +8,9 @@ from qtpy.QtCore import Qt
 from .. import settings
 from ..widgets.search_replace_frame import SearchReplaceFrame
 
-
 class SearchReplaceHighlighter(QSyntaxHighlighter):
     """
-    Simple syntax highlighter that highlights all matches of a given pattern.
+    Syntax highlighter that highlights all matches of a given pattern.
     Updated whenever the pattern or text changes.
     """
     def __init__(self, parent=None):
@@ -20,46 +19,87 @@ class SearchReplaceHighlighter(QSyntaxHighlighter):
         self._use_regex = False
         self._case_sensitive = False
         self._whole_word = False
-        
+        self._matches = []  # Stores all matches in the document as (block_number, start, length)
+
         # Highlight style
         self.highlight_format = QTextCharFormat()
         self.highlight_format.setBackground(QColor(settings.search_replace_background))
         self.highlight_format.setForeground(QColor(settings.search_replace_foreground))
-    
+
     def setSearchOptions(self, pattern, use_regex, case_sensitive, whole_word):
         self._pattern = pattern
         self._use_regex = use_regex
         self._case_sensitive = case_sensitive
         self._whole_word = whole_word
         self.rehighlight()  # Trigger a re-scan
-    
-    def highlightBlock(self, text):
-        if not self._pattern:
+
+    def rehighlight(self):
+        """Find all matches in the entire document and store them"""
+        if not self._pattern or not self.document():
+            self._matches = []
+            super().rehighlight()
             return
-        
+
         # Build the pattern
         pattern = self._pattern
         flags = 0 if self._case_sensitive else re.IGNORECASE
-    
+
         if self._use_regex:
-            # If whole_word is asked for, add \b on both sides (can be tricky with punctuation).
             if self._whole_word:
                 pattern = rf"\b{pattern}\b"
             try:
                 regex = re.compile(pattern, flags)
             except re.error:
-                return  # invalid regex, just skip
+                self._matches = []
+                super().rehighlight()
+                return
         else:
-            # Escape user text if not in regex mode
             pattern = re.escape(pattern)
             if self._whole_word:
                 pattern = rf"\b{pattern}\b"
             regex = re.compile(pattern, flags)
-        
-        for match in regex.finditer(text):
+
+        # Find all matches in the entire document
+        self._matches = []
+        full_text = self.document().toPlainText()
+        for match in regex.finditer(full_text):
             start = match.start()
-            length = match.end() - match.start()
-            self.setFormat(start, length, self.highlight_format)
+            end = match.end()
+
+            # Convert character positions to block/position
+            block = self.document().findBlock(start)
+            block_number = block.blockNumber()
+            block_start = block.position()
+            block_end = block_start + block.length() - 1
+
+            # Handle matches that span multiple blocks
+            while start <= block_end and end > block_start:
+                match_start_in_block = max(start - block_start, 0)
+                match_end_in_block = min(end - block_start, block.length() - 1)
+                match_length = match_end_in_block - match_start_in_block
+
+                if match_length > 0:
+                    self._matches.append((block_number, match_start_in_block, match_length))
+
+                # Move to next block if match spans multiple blocks
+                if end > block_end:
+                    block = block.next()
+                    if not block.isValid():
+                        break
+                    block_number = block.blockNumber()
+                    block_start = block.position()
+                    block_end = block_start + block.length() - 1
+                else:
+                    break
+
+        super().rehighlight()
+
+    def highlightBlock(self, text):
+        """Highlight matches that belong to this block"""
+        block_number = self.currentBlock().blockNumber()
+        for match_block, start, length in self._matches:
+            if match_block == block_number:
+                self.setFormat(start, length, self.highlight_format)
 
 
 class SearchReplace:
@@ -325,13 +365,14 @@ class SearchReplace:
         needle = self._searchFrame.findEdit.text()
         if not needle:
             return
-        
+
         replacement = self._searchFrame.replaceEdit.text()
-        
-        # Save cursor
+
+        # Save cursor and get current text
         saved_cursor = self.textCursor()
+        cursor_pos = saved_cursor.position()
         text = self.toPlainText()
-        
+
         # Build regex pattern
         flags = 0 if self._searchFrame.caseBox.isChecked() else re.IGNORECASE
         patt = needle
@@ -339,20 +380,34 @@ class SearchReplace:
             patt = re.escape(patt)
         if self._searchFrame.wholeWordBox.isChecked():
             patt = rf"\b{patt}\b"
-        
+
         try:
             compiled = re.compile(patt, flags)
         except re.error:
             return
-        
+
+        # Get text before cursor
+        text_before = text[:cursor_pos]
+
+        # Apply replacement to full text
         new_text, num_replacements = compiled.subn(replacement, text)
-        self.setPlainText(new_text)
-        
-        # After replace all, set the needle to the replacement text
+
+        # Apply replacement to just the before portion to calculate position change
+        new_text_before, _ = compiled.subn(replacement, text_before)
+        length_change = len(new_text_before) - len(text_before)
+        new_cursor_pos = cursor_pos + length_change
+
+        # Use a single undoable operation
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+        cursor.select(QTextCursor.Document)
+        cursor.insertText(new_text)
+        cursor.setPosition(new_cursor_pos)
+        cursor.endEditBlock()
+        self.setTextCursor(cursor)
+
+        # Update UI
         self._searchFrame.findEdit.setText(replacement)
-        
-        # Restore cursor
-        self.setTextCursor(saved_cursor)
         self.updateHighlighter()
         self.set_modified(True)
     

{pyqt_code_editor-0.0.53 → pyqt_code_editor-0.0.55}/readme.md

@@ -1,6 +1,6 @@
 # PyQt Code Editor / Sigmund Analyst
 
-Copyright 2025 Sebastiaan Mathôt
+Copyright 2025-2026 Sebastiaan Mathôt
 
 
 ## About