pyqt-code-editor 0.0.52__tar.gz → 0.0.54__tar.gz

{pyqt_code_editor-0.0.52 → pyqt_code_editor-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.52
+Version: 0.0.54
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>

{pyqt_code_editor-0.0.52 → pyqt_code_editor-0.0.54}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.52'
+__version__ = '0.0.54'

{pyqt_code_editor-0.0.52 → pyqt_code_editor-0.0.54}/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.52 → pyqt_code_editor-0.0.54}/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.52 → pyqt_code_editor-0.0.54}/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.52 → pyqt_code_editor-0.0.54}/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.54/pyqt_code_editor/mixins/merge_undo_actions.py

@@ -0,0 +1,54 @@
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QTextCursor
+
+
+class MergeUndoActions:
+    """Ensures that all changes made as part of a key press result in a 
+    single edit block for undo purposes. This class should be the first
+    mixin of the list.
+    """
+    def keyPressEvent(self, event):
+        # Navigation keys that should NOT be wrapped in edit blocks. This 
+        # avoids cursor glitches when navigating vertically/horizontally.
+        navigation_keys = {
+            Qt.Key.Key_Up, Qt.Key.Key_Down, 
+            Qt.Key.Key_Left, Qt.Key.Key_Right,
+            Qt.Key.Key_Home, Qt.Key.Key_End,
+            Qt.Key.Key_PageUp, Qt.Key.Key_PageDown,
+        }
+
+        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)
+        has_shift = bool(modifiers & Qt.KeyboardModifier.ShiftModifier)
+
+        # Common Undo/Redo shortcuts:
+        # - Undo:  Ctrl+Z / Cmd+Z
+        # - Redo:  Ctrl+Shift+Z / Cmd+Shift+Z / Ctrl+Y / Cmd+Y
+        is_undo = has_ctrl_or_meta and key == Qt.Key.Key_Z and not has_shift
+        is_redo = has_ctrl_or_meta and (
+            (key == Qt.Key.Key_Z and has_shift) or
+            key == Qt.Key.Key_Y
+        )
+
+        if is_navigation or is_undo or is_redo:
+            # Do not wrap these in an edit block
+            super().keyPressEvent(event)
+            return
+
+        # For editing keys, wrap the operation in a single edit block.
+        # Use the widget's actual text cursor, not a fresh document cursor.
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+        try:
+            super().keyPressEvent(event)
+        finally:
+            cursor.endEditBlock()

{pyqt_code_editor-0.0.52 → pyqt_code_editor-0.0.54}/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.52/pyqt_code_editor/mixins/merge_undo_actions.py

@@ -1,32 +0,0 @@
-from qtpy.QtCore import Qt
-from qtpy.QtGui import QTextCursor
-
-
-class MergeUndoActions:
-    """Ensures that all changes made as part of a key press result in a 
-    single edit block for undo purposes. This class should be the first
-    mixin of the list.
-    """
-    def keyPressEvent(self, event):
-        # Navigation keys that should NOT be wrapped in edit blocks. This 
-        # causes a specific issue with the cursor jumping to the start of a 
-        # line when navigating vertically.
-        navigation_keys = {
-            Qt.Key.Key_Up, Qt.Key.Key_Down, 
-            Qt.Key.Key_Left, Qt.Key.Key_Right,
-            Qt.Key.Key_Home, Qt.Key.Key_End,
-            Qt.Key.Key_PageUp, Qt.Key.Key_PageDown
-        }
-        is_navigation = (event.key() in navigation_keys and 
-                         not (event.modifiers() & Qt.KeyboardModifier.ShiftModifier))        
-        if is_navigation:            
-            super().keyPressEvent(event)
-            return
-        # Wrap all other keys (editing operations) in a single edit block to
-        # unify changes into a single undo action
-        cursor = QTextCursor(self.document())
-        cursor.beginEditBlock()
-        try:
-            super().keyPressEvent(event)
-        finally:
-            cursor.endEditBlock()