pyqt-code-editor 0.0.48__tar.gz → 0.0.51__tar.gz

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.48
+Version: 0.0.51
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>
@@ -12,15 +12,22 @@ Requires-Dist: detect-indent
 Requires-Dist: jedi
 Requires-Dist: httpx<0.29.0
 Requires-Dist: mistralai
+Requires-Dist: opensesame-extension-sigmund
 Requires-Dist: pathspec
 Requires-Dist: psutil
 Requires-Dist: pygments
 Requires-Dist: qtawesome
 Requires-Dist: qtpy
-Requires-Dist: ruff
-Requires-Dist: opensesame-extension-sigmund
 Requires-Dist: pyqt6
 Requires-Dist: qtconsole
+Requires-Dist: tree-sitter
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-json
+Requires-Dist: tree-sitter-html
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-toml
+Requires-Dist: tree-sitter-yaml
+Requires-Dist: ruff
 Project-URL: Source, https://github.com/open-cogsci/sigmund-analyst
 
 # PyQt Code Editor / Sigmund Analyst

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyproject.toml

@@ -17,15 +17,22 @@ dependencies = [
     "jedi",
     "httpx<0.29.0",
     "mistralai",
+    "opensesame-extension-sigmund",
     "pathspec",
     "psutil",
     "pygments",
     "qtawesome",
     "qtpy",
-    "ruff",
-    "opensesame-extension-sigmund",
     "pyqt6",
-    "qtconsole"
+    "qtconsole",
+    "tree-sitter",
+    "tree-sitter-javascript",
+    "tree-sitter-json",
+    "tree-sitter-html",
+    "tree-sitter-python",
+    "tree-sitter-toml",
+    "tree-sitter-yaml",
+    "ruff"
 ]
 keywords = ["code editor", "pyqt", "ide"]
 

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.48'
+__version__ = '0.0.51'

pyqt_code_editor-0.0.51/pyqt_code_editor/code_editors/languages/generic.py

@@ -0,0 +1,13 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete, Theme, Zoom,
+                                     LineNumber, Comment, AutoIndent,
+                                     AutoPair, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols,
+                                     HighlightMatchingBrackets)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, AutoIndent,
+             AutoPair, Comment, SearchReplace, FileLink, Theme, Check,
+             Shortcuts, HighlightMatchingBrackets, Symbols, Base,
+             QPlainTextEdit):
+    pass

pyqt_code_editor-0.0.51/pyqt_code_editor/code_editors/languages/markdown.py

@@ -0,0 +1,11 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete,
+                                     HighlightSyntax, Zoom, LineNumber,
+                                     Comment, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, Comment,
+             SearchReplace, FileLink, HighlightSyntax, Check, Shortcuts,
+             Symbols, Base, QPlainTextEdit):
+    pass

pyqt_code_editor-0.0.51/pyqt_code_editor/code_editors/languages/python.py

@@ -0,0 +1,16 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (Complete, PythonAutoIndent,
+                                     PythonAutoPair, Theme, Zoom, LineNumber,
+                                     Comment, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols,
+                                     SmartBackspaceDelete, Execute,
+                                     MergeUndoActions,
+                                     HighlightMatchingBrackets)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, SmartBackspaceDelete,
+             PythonAutoPair, Complete, Comment, PythonAutoIndent,
+             SearchReplace, FileLink, Execute, Check, Theme, Shortcuts,
+             HighlightMatchingBrackets, Symbols, Base, QPlainTextEdit):
+                 
+    code_editor_language = 'python'

pyqt_code_editor-0.0.51/pyqt_code_editor/code_editors/languages/text.py

@@ -0,0 +1,11 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete,
+                                     HighlightSyntax, Zoom, LineNumber,
+                                     SearchReplace, Base, Check, Shortcuts,
+                                     FileLink)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, SearchReplace,
+             FileLink, HighlightSyntax, Check, Shortcuts, Base,
+             QPlainTextEdit):
+    pass

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/components/workspace_explorer.py

@@ -1,8 +1,9 @@
-from qtpy.QtWidgets import (QDockWidget, QWidget, QVBoxLayout, QHBoxLayout, 
-                            QTableView, QHeaderView, QLineEdit, QLabel, 
-                            QAbstractItemView, QMenu, QAction)
-from qtpy.QtCore import Qt, QSortFilterProxyModel, QAbstractTableModel, QModelIndex
-from qtpy.QtGui import QIcon, QColor, QFont, QBrush
+from qtpy.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QTableView, 
+                            QHeaderView, QLineEdit, QAbstractItemView, QMenu,
+                            QAction)
+from qtpy.QtCore import (Qt, QSortFilterProxyModel, QAbstractTableModel,
+                         QModelIndex)
+from qtpy.QtGui import QColor, QFont, QBrush
 from ..widgets import Dock
 
 
@@ -77,6 +78,7 @@ class WorkspaceModel(QAbstractTableModel):
             return self._headers[section]
         return None
 
+
 class WorkspaceExplorer(Dock):
     """Dock widget for exploring variables in the Jupyter workspace"""
     
@@ -150,13 +152,7 @@ class WorkspaceExplorer(Dock):
             # Add actions specific to the variable
             inspect_action = QAction(f"Inspect '{var_name}'", self)
             delete_action = QAction(f"Delete '{var_name}'", self)
-            
             menu.addAction(inspect_action)
             menu.addAction(delete_action)
-            
-            # Show the menu
-            action = menu.exec_(self.table_view.mapToGlobal(position))
-            
-            # Handle action selection
-            # (In a real implementation, would connect to actual functionality)
+            menu.exec_(self.table_view.mapToGlobal(position))
             

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/__init__.py

@@ -14,3 +14,5 @@ from .symbols import Symbols
 from .shortcuts import Shortcuts
 from .theme import Theme
 from .zoom import Zoom
+from .merge_undo_actions import MergeUndoActions
+from .highlight_matching_brackets import HighlightMatchingBrackets

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/auto_indent.py

@@ -118,7 +118,6 @@ class AutoIndent:
         """
         logger.info("indent_code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
 
         if self._is_multiline_selection():
             logger.info("Multi-line selection -> indent each line")
@@ -128,8 +127,6 @@ class AutoIndent:
             indent_str = self._get_indent_string()
             cursor.insertText(indent_str)
 
-        cursor.endEditBlock()
-
     def dedent_code(self):
         """
         Dedent either the selected lines (if multi-line selection)
@@ -137,7 +134,6 @@ class AutoIndent:
         """
         logger.info("dedent_code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
 
         if self._is_multiline_selection():
             logger.info("Multi-line selection -> dedent each line")
@@ -156,8 +152,6 @@ class AutoIndent:
             for _ in range(remove_chars):
                 self._delete_forward_if_tab_or_space(cursor)
 
-        cursor.endEditBlock()
-
     def _indent_selection(self):
         """
         Increase indent for each selected line by one chunk.

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/auto_pair.py

@@ -4,9 +4,8 @@ logger = logging.getLogger(__name__)
 
 
 class AutoPair:
-    """
-    Generic mixin for auto-pairing brackets/quotes/etc.
-    
+    """Generic mixin for auto-pairing brackets/quotes/etc.
+
     You can override self.PAIRS to add or remove different open/close
     sequences. Each entry is a dict with:
       - open_seq: string that triggers auto-pair (e.g. '(' or '\"\"\"')
@@ -14,7 +13,7 @@ class AutoPair:
       - inbetween_seq: optional string inserted between open_seq and close_seq
                       (can be empty). e.g. '\n' for triple quotes.
     """
-    
+
     PAIRS = [
         {"open_seq": "(", "close_seq": ")", "inbetween_seq": ""},
         {"open_seq": "[", "close_seq": "]", "inbetween_seq": ""},
@@ -22,155 +21,179 @@ class AutoPair:
         {"open_seq": "\"", "close_seq": "\"", "inbetween_seq": ""},
         {"open_seq": "\'", "close_seq": "\'", "inbetween_seq": ""},
     ]
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.setUndoRedoEnabled(True)
         # For scanning up to the max length of an open_seq
         self._max_open_len = max(len(pair["open_seq"]) for pair in self.PAIRS)
+        self._trigger_chars = ''.join([pair['open_seq'] + pair['close_seq']
+                                      for pair in self.PAIRS])
 
     def keyPressEvent(self, event):
+        # Determine all relevant variables upfront
+        typed_char = event.text()
+        typed_key = event.key()
         cursor = self.textCursor()
         old_pos = cursor.position()
         selected_text = cursor.selectedText()
-        
+        doc_text = self.toPlainText()
+        doc_len = len(doc_text)
+        # Get character before cursor
+        if old_pos > 0:
+            char_before = doc_text[old_pos - 1]
+        else:
+            char_before = ""        
+        # Get character after cursor
+        if old_pos < doc_len:
+            char_after = doc_text[old_pos]
+        else:
+            char_after = ""
+
+        # If there is no opening (trigger character or backspace), then we 
+        # don't need to do anything.
+        if typed_char not in self._trigger_chars and typed_key != Qt.Key_Backspace:
+            super().keyPressEvent(event)
+            return
+
+        # Don't autopair when there is no selection and the next character is
+        # alphanumeric or underscore. This is for example when we're typing the
+        # opening bracket of a list that is already completed
+        if not selected_text:
+            if char_after.isalnum() or char_after == "_":
+                super().keyPressEvent(event)
+                return
+
         # Allows auto-pairing to be disabled for certain positions
         if self._disabled_for_position(old_pos):
             super().keyPressEvent(event)
             return
-        
+
         # 1) Handle backspace for removing empty pairs like (|)
-        if event.key() == Qt.Key_Backspace:
-            if self._handle_auto_pair_backspace():
+        if typed_key == Qt.Key_Backspace:
+            if self._handle_auto_pair_backspace(char_before, char_after, old_pos):
                 super().keyPressEvent(event)
                 return
-        
-        typed_char = event.text()
-        
+
         # Pass the event up (inserts the typed_char)
         super().keyPressEvent(event)
-        
+
         # 2) Possibly skip duplicate closing bracket/quote
         #    when the user manually types it.
         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()
-                    doc_text = self.toPlainText()
-                    if (new_cursor.position() < len(doc_text) and
-                        doc_text[new_cursor.position()] == typed_char):
+                    new_pos = new_cursor.position()
+                    new_doc_text = self.toPlainText()
+                    new_doc_len = len(new_doc_text)
+                    if new_pos < new_doc_len and new_doc_text[new_pos] == typed_char:
                         # We remove the newly typed character and move cursor forward
-                        new_cursor.beginEditBlock()
                         # Remove the bracket that was just typed
                         new_cursor.setPosition(old_pos)
                         new_cursor.deleteChar()
                         # Move cursor to skip the existing bracket
                         new_cursor.setPosition(old_pos + 1)
-                        new_cursor.endEditBlock()
                         self.setTextCursor(new_cursor)
                     break
-        
+
         # 3) After insertion, see if the text before the cursor matches an 'open_seq'
         #    If it does, insert close_seq + inbetween_seq, then restore cursor.
         new_cursor = self.textCursor()
         new_pos = new_cursor.position()
         text = self.toPlainText()
-        
+
         # We'll scan backward from new_pos for up to _max_open_len chars
         start_search = max(0, new_pos - self._max_open_len)
         just_typed = text[start_search:new_pos]
-        
+
         for pair in self.PAIRS:
             open_seq = pair["open_seq"]
             close_seq = pair["close_seq"]
             inbetween_seq = pair["inbetween_seq"]
-            
+
             if just_typed.endswith(open_seq) and event.text() == text[new_pos - 1: new_pos]:
                 self._insert_pair(open_seq, close_seq, inbetween_seq,
-                                  selected_text)
+                                  selected_text, new_pos)
                 break
 
-
-    def _handle_auto_pair_backspace(self) -> bool:
+    def _handle_auto_pair_backspace(self, char_before, char_after, pos) -> bool:
         """
         If the cursor is between an exact open_seq and close_seq pair (e.g., '(|)'),
         remove the following close_seq. The preceding open_seq will be removed 
         by the standard backspace. Only works for pairs of single characters.
-        Returns True if handled, False if not.
+
+        Args:
+            char_before: The character before the cursor
+            char_after: The character after the cursor
+            pos: The cursor position
+
+        Returns:
+            True if handled, False if not.
         """
-        cursor = self.textCursor()
-        pos = cursor.position()
-    
         # We need at least one character before and after cursor
-        if pos < 1 or cursor.atEnd():
+        if not char_before or not char_after:
             return False
-    
-        # Get the character before the cursor
-        cursor.setPosition(pos - 1)
-        cursor.setPosition(pos, cursor.KeepAnchor)
-        char_before = cursor.selectedText()
-    
-        # Get the character after the cursor
-        cursor.setPosition(pos)
-        cursor.setPosition(pos + 1, cursor.KeepAnchor)
-        char_after = cursor.selectedText()
-    
+
         # Check if they form a pair
         for pair in self.PAIRS:
             open_seq = pair["open_seq"]
             close_seq = pair["close_seq"]
-        
+
             # Only handle single-character pairs
             if len(open_seq) != 1 or len(close_seq) != 1:
                 continue
-            
+
             if char_before == open_seq and char_after == close_seq:
                 logger.info("deleting closing bracket")
                 # Delete only the closing character
+                cursor = self.textCursor()
                 cursor.setPosition(pos)
                 cursor.deleteChar()
-            
+
                 # The standard backspace will handle the opening character
                 return True
-    
-        return False
 
+        return False
 
-    def _insert_pair(self, open_seq, close_seq, inbetween_seq, selected_text):
+    def _insert_pair(self, open_seq, close_seq, inbetween_seq, selected_text, cursor_pos):
         """
         Called when we recognize that the user typed an open_seq in full.
         Insert the close_seq plus any inbetween_seq, and restore the cursor
         to the original position (right after the open_seq).
+
+        Args:
+            open_seq: The opening sequence that was typed
+            close_seq: The closing sequence to insert
+            inbetween_seq: Text to insert between open and close
+            selected_text: Text that was selected (if any)
+            cursor_pos: Current cursor position (after the open_seq was inserted)
         """
         c = self.textCursor()
-        
-        # We'll remember where the user ended up (right after open_seq).
-        old_pos = c.position()
+
         if inbetween_seq == '\n':
             # Get indentation level of block after cursor
-            block = self.document().findBlock(old_pos)
+            block = self.document().findBlock(cursor_pos)
             block_text = block.text()
             indent = block_text[:len(block_text) - len(block_text.lstrip())]        
             inbetween_seq = '\n' + indent
-        # Insert the close_seq and inbetween_seq, indented to the same level as the block
-        c.beginEditBlock()
-                
+
         # Insert in-between text, then the closing
         c.insertText(selected_text + inbetween_seq + close_seq)
-        
+
         # Move the cursor back so that it's right after the open_seq and (if any)
         # the selected text
         c.movePosition(c.Left, c.MoveAnchor, len(close_seq) + len(inbetween_seq))
-        
-        c.endEditBlock()
+
         self.setTextCursor(c)
-        
+
         logger.info(
             "Auto-paired '%s' with '%s', inserted in-between '%s'. "
             "Cursor restored to position %d",
-            open_seq, close_seq, inbetween_seq, old_pos
+            open_seq, close_seq, inbetween_seq, cursor_pos
         )
-        
+
     def _disabled_for_position(self, pos):
         return False
 
@@ -186,7 +209,7 @@ class PythonAutoPair(AutoPair):
         {"open_seq": "\"", "close_seq": "\"", "inbetween_seq": ""},
         {"open_seq": "\'", "close_seq": "\'", "inbetween_seq": ""},
     ]
-    
+
     def _disabled_for_position(self, pos):
         """
         Returns True if 'pos' (a QTextCursor.position() in self)
@@ -197,12 +220,12 @@ class PythonAutoPair(AutoPair):
         block = self.document().findBlock(pos)
         line_text = block.text()
         column = pos - block.position()
-    
+
         # Find the first '#' in line_text
         hash_index = line_text.find('#')
-    
+
         # If a '#' is found and it's to the left of the cursor, assume comment
         if hash_index != -1 and hash_index < column:
             return True
-    
+
         return False

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/check.py

@@ -23,10 +23,6 @@ class Check:
         self._check_debounce_timer.setSingleShot(True)
         self._check_debounce_timer.setInterval(500)
         self._check_debounce_timer.timeout.connect(self._execute_check)
-        # Periodic timer: also periodically run a check
-        self._check_interval_timer = QTimer(self)
-        self._check_interval_timer.setInterval(5000)
-        self._check_interval_timer.timeout.connect(self._execute_check)
 
         # Connect textChanged signal to a debounced method
         self.textChanged.connect(self._on_code_changed)

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/comment.py

@@ -35,10 +35,8 @@ class Comment:
                 # Extract the indentation from the current line
                 indentation = line_text[:len(line_text) - len(stripped)]                
                 # Insert newline with same indentation plus comment marker
-                cursor.beginEditBlock()
                 cursor.insertText(
                     '\n' + indentation + self.code_editor_comment_string)
-                cursor.endEditBlock()
                 event.accept()
                 return
         super().keyPressEvent(event)    
@@ -76,7 +74,6 @@ class Comment:
     def _comment_blocks(self, start_block: int, end_block: int):
         """Comment all lines from start_block to end_block."""
         cursor = self.textCursor()
-        cursor.beginEditBlock()  # group undo steps
         for block_num in range(start_block, end_block + 1):
             block = self.document().findBlockByNumber(block_num)
             if not block.isValid():
@@ -87,12 +84,10 @@ class Comment:
             insert_position = block.position() + leading_spaces
             cursor.setPosition(insert_position)
             cursor.insertText(self.code_editor_comment_string)  
-        cursor.endEditBlock()
 
     def _uncomment_blocks(self, start_block: int, end_block: int):
         """Uncomment all lines from start_block to end_block."""
         cursor = self.textCursor()
-        cursor.beginEditBlock()
         for block_num in range(start_block, end_block + 1):
             block = self.document().findBlockByNumber(block_num)
             if not block.isValid():
@@ -107,4 +102,3 @@ class Comment:
                 cursor.setPosition(remove_position + strip_len, cursor.KeepAnchor)
                 if cursor.selectedText() == self.code_editor_comment_string.rstrip('\r\n'):
                     cursor.removeSelectedText()
-        cursor.endEditBlock()

pyqt_code_editor-0.0.51/pyqt_code_editor/mixins/highlight_matching_brackets.py

@@ -0,0 +1,98 @@
+import logging
+from qtpy.QtCore import QTimer
+from qtpy.QtGui import QTextCursor, QColor, QTextCharFormat
+from qtpy.QtWidgets import QTextEdit
+
+logger = logging.getLogger(__name__)
+
+
+class HighlightMatchingBrackets:
+    """Highlights matching brackets that match the current cursor position.
+    The actual matching is done in the backend.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._bracket_request_pending = False
+        self._current_bracket_pairs = []
+
+        # Connect to text changes
+        self.textChanged.connect(self._on_text_changed)
+
+        # Connect to cursor position changes
+        self.cursorPositionChanged.connect(self._on_cursor_changed)
+
+        # Set up debounce timer (500ms)
+        self._debounce_timer = QTimer()
+        self._debounce_timer.setSingleShot(True)
+        self._debounce_timer.timeout.connect(self._on_debounce_timeout)
+
+    def _on_text_changed(self):
+        """Called when text changes - restart debounce timer."""
+        # Restart the debounce timer
+        self._debounce_timer.stop()
+        self._debounce_timer.start(500)
+
+    def _on_debounce_timeout(self):
+        """Called after 500ms of no text changes - request bracket update."""
+        if not self._bracket_request_pending:
+            self._request_matching_brackets()
+
+    def _on_cursor_changed(self):
+        """Called when cursor position changes - update highlighting."""
+        self._highlight_brackets()
+
+    def _request_matching_brackets(self):
+        self._bracket_request_pending = True
+        self.send_worker_request(action='matching_brackets',
+                                 language=getattr(self, "code_editor_language", "python"),
+                                 code=self.toPlainText())
+
+    def _handle_matching_brackets(self, pairs):
+        """Pairs is a list of (open_pos, close_pos) positions relative to the
+        start of the document.
+        """
+        self._bracket_request_pending = False
+        self._current_bracket_pairs = pairs
+        self._highlight_brackets()
+
+    def _highlight_brackets(self):
+        """Highlight matching bracket pairs where cursor is on one of the brackets."""
+        extra_selections = []
+        cursor_pos = self.textCursor().position()
+        for open_pos, close_pos in self._current_bracket_pairs:
+            # Check if cursor is on either bracket
+            if cursor_pos in (open_pos, open_pos + 1,
+                              close_pos, close_pos + 1):
+                # Highlight opening bracket
+                open_selection = self._create_bracket_selection(open_pos)
+                if open_selection:
+                    extra_selections.append(open_selection)
+
+                # Highlight closing bracket
+                close_selection = self._create_bracket_selection(close_pos)
+                if close_selection:
+                    extra_selections.append(close_selection)
+
+        self.setExtraSelections(extra_selections)
+
+    def _create_bracket_selection(self, pos):
+        """Create an extra selection for a single bracket at position."""
+        cursor = self.textCursor()
+        cursor.setPosition(pos)
+        cursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor, 1)
+
+        # Create yellow background format
+        fmt = QTextCharFormat()
+        fmt.setBackground(QColor(255, 255, 0, 50))  # Yellow with some transparency
+
+        selection = QTextEdit.ExtraSelection()
+        selection.cursor = cursor
+        selection.format = fmt
+
+        return selection
+
+    def handle_worker_result(self, action, result):
+        super().handle_worker_result(action, result)
+        if action == 'matching_brackets':
+            logger.info("Handling matching brackets result")
+            self._handle_matching_brackets(**result)

pyqt_code_editor-0.0.51/pyqt_code_editor/mixins/merge_undo_actions.py

@@ -0,0 +1,32 @@
+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()

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/python_auto_indent.py

@@ -51,7 +51,6 @@ class PythonAutoIndent:
         if key in (Qt.Key_Enter, Qt.Key_Return):
             logger.info("Enter/Return pressed")
             cursor = self.textCursor()
-            cursor.beginEditBlock()
     
             # Use QTextCursor to get text up to cursor position
             # This handles UTF-16 encoding correctly
@@ -66,7 +65,6 @@ class PythonAutoIndent:
             if new_indent > 0:
                 logger.info("Inserting %d spaces of indentation", new_indent)
                 self._insert_indentation(new_indent)
-            cursor.endEditBlock()
             self.setTextCursor(cursor)
             return
         # Otherwise, default behavior
@@ -144,7 +142,6 @@ class PythonAutoIndent:
         """
         logger.info("Indent code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
 
         if self._is_multiline_selection():
             logger.info("Multi-line selection detected -> Indenting each line")
@@ -154,8 +151,6 @@ class PythonAutoIndent:
             # Insert spacing at the current cursor position
             cursor.insertText(' ' * settings.tab_width)
 
-        cursor.endEditBlock()
-
     def dedent_code(self):
         """
         Dedent either the selected lines (if multi-line selection)
@@ -164,8 +159,6 @@ class PythonAutoIndent:
         """
         logger.info("Dedent code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
-
         if self._is_multiline_selection():
             logger.info("Multi-line selection detected -> Dedenting each line")
             self._dedent_selection()
@@ -185,8 +178,6 @@ class PythonAutoIndent:
             for _ in range(remove_spaces):
                 self._delete_forward_if_space(cursor)
 
-        cursor.endEditBlock()
-
     def _indent_selection(self):
         """
         Increase indent for each selected line by settings.tab_width spaces.

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/mixins/shortcuts.py

@@ -47,7 +47,6 @@ class Shortcuts:
         start, end = self._current_line_bounds(cursor)
         doc_length = self.document().characterCount()
         
-        cursor.beginEditBlock()
         # We want to remove the trailing or preceding newline, but not both.
         if end < doc_length - 1:
             end += 1
@@ -56,7 +55,6 @@ class Shortcuts:
         cursor.setPosition(start)
         cursor.setPosition(end, QTextCursor.KeepAnchor)
         cursor.removeSelectedText()
-        cursor.endEditBlock()
 
     def _current_line_bounds(self, cursor=None):
         """
@@ -85,7 +83,6 @@ class Shortcuts:
         """
         doc = self.document()
         cursor = self.textCursor()
-        cursor.beginEditBlock()
     
         anchor = cursor.anchor()
         pos = cursor.position()
@@ -164,7 +161,6 @@ class Shortcuts:
         cursor.setPosition(anchor)
         cursor.setPosition(pos, QTextCursor.KeepAnchor)
         self.setTextCursor(cursor)        
-        cursor.endEditBlock()
         self.refresh()
     
     def _move_line_up(self):
@@ -183,7 +179,6 @@ class Shortcuts:
         In other words, it should appear as if the duplication is inserted above.
         """
         cursor = self.textCursor()
-        cursor.beginEditBlock()
         
         # 1) Remember original anchor and cursor positions
         original_anchor = cursor.anchor()
@@ -223,5 +218,4 @@ class Shortcuts:
         cursor.setPosition(original_anchor + inserted_length, cursor.MoveAnchor)
         cursor.setPosition(original_position + inserted_length, cursor.KeepAnchor)
         
-        self.setTextCursor(cursor)        
-        cursor.endEditBlock()
+        self.setTextCursor(cursor)        

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/worker/languages/generic.py

@@ -1,4 +1,4 @@
-from ..providers import symbol, codestral
+from ..providers import symbol, codestral, tree_sitter
 
 def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
     if full or multiline:
@@ -13,3 +13,4 @@ def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
 calltip = None
 check = None
 symbols = None
+matching_brackets = tree_sitter.tree_sitter_matching_brackets

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/worker/languages/python.py

@@ -1,4 +1,4 @@
-from ..providers import jedi, codestral, ruff
+from ..providers import jedi, codestral, ruff, tree_sitter
 
 
 def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
@@ -24,3 +24,4 @@ def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
 calltip = jedi.jedi_signatures
 check = ruff.ruff_check
 symbols = jedi.jedi_symbols
+matching_brackets = tree_sitter.tree_sitter_matching_brackets

{pyqt_code_editor-0.0.48 → pyqt_code_editor-0.0.51}/pyqt_code_editor/worker/process.py

@@ -28,7 +28,7 @@ def main_worker_process_function(request_queue, result_queue):
     Required fields:
         action : str
             The action to perform. One of: 'complete', 'calltip', 'symbols', 
-            'check', 'set_settings', 'quit'
+            'check', 'set_settings', 'quit', 'matching_brackets'
     
     Optional fields (depending on action):
         language : str, default 'text'
@@ -81,6 +81,12 @@ def main_worker_process_function(request_queue, result_queue):
             'action': 'check',
             'messages': dict
         }
+        
+    For 'matching_brackets' action:
+        {
+             'action': 'matching_brackets',
+             'pairs': list[(int, int)]
+        }
     
     Behavior
     --------
@@ -211,5 +217,15 @@ def main_worker_process_function(request_queue, result_queue):
                 'action': 'check',
                 'messages': check_results
             })
+            
+        elif action == 'matching_brackets':
+            if worker_functions.matching_brackets is None:
+                pairs = []
+            else:
+                pairs = worker_functions.matching_brackets(code, language)
+            result_queue.put({
+                'action': 'matching_brackets',
+                'pairs': pairs
+            })            
 
     logger.info("Completion worker has shut down.")

pyqt_code_editor-0.0.51/pyqt_code_editor/worker/providers/tree_sitter.py

@@ -0,0 +1,61 @@
+from tree_sitter import Language, Parser
+import importlib
+
+
+def tree_sitter_matching_brackets(code, language):
+    """Find matching brackets using tree-sitter parsing. Handles
+    incomplete/invalid code gracefully.
+
+    Returns
+    -------
+    List of tuples (open_pos, close_pos) for matching brackets
+    """
+    module_name = language.lower().split('+')[0]
+    ts_module_name = f'tree_sitter_{module_name}'
+    try:
+        # Dynamically import the tree-sitter language module
+        ts_module = importlib.import_module(ts_module_name)        
+    except (ImportError, AttributeError):
+        # Language not available, return empty list
+        return []    
+    # Set up parser
+    lang = Language(ts_module.language())
+    parser = Parser(lang)
+    # Parse the code
+    tree = parser.parse(bytes(code, "utf8"))
+
+    # Find all bracket positions in the source
+    bracket_map = {'(': ')', '[': ']', '{': '}'}
+    opening = []
+    closing = []
+    
+    for i, char in enumerate(code):
+        if char in bracket_map:
+            opening.append((i, char))
+        elif char in bracket_map.values():
+            closing.append((i, char))
+    
+    # Match brackets using a stack-based approach
+    # But verify positions are within valid syntax nodes
+    matches = []
+    stack = []
+    
+    # Merge and sort all bracket positions
+    all_brackets = [(pos, char, True) for pos, char in opening]
+    all_brackets += [(pos, char, False) for pos, char in closing]
+    all_brackets.sort()
+    
+    for pos, char, is_opening in all_brackets:
+        if is_opening:
+            stack.append((pos, char))
+        else:
+            # Find matching opening bracket
+            if stack:
+                expected_close = bracket_map.get(stack[-1][1])
+                if expected_close == char:
+                    open_pos = stack.pop()[0]
+                    matches.append((open_pos, pos))
+
+    # Sort by opening position
+    matches.sort()
+    return matches

pyqt_code_editor-0.0.48/pyqt_code_editor/code_editors/languages/generic.py

@@ -1,9 +0,0 @@
-from qtpy.QtWidgets import QPlainTextEdit
-from pyqt_code_editor.mixins import Complete, Theme, Zoom, LineNumber, Comment, \
-    AutoIndent, AutoPair, SearchReplace, Base, Check, Shortcuts, FileLink, Symbols
-
-
-class Editor(LineNumber, Zoom, Complete, AutoIndent, AutoPair, Comment,
-             SearchReplace, FileLink, Theme, Check, Shortcuts, Symbols, Base,
-             QPlainTextEdit):
-    pass

pyqt_code_editor-0.0.48/pyqt_code_editor/code_editors/languages/markdown.py

@@ -1,11 +0,0 @@
-from qtpy.QtWidgets import QPlainTextEdit
-from pyqt_code_editor.mixins import Complete, \
-    HighlightSyntax, Zoom, LineNumber, Comment, \
-    SearchReplace, Base, Check, Shortcuts, FileLink, Symbols
-
-
-class Editor(LineNumber, Zoom, Complete,
-             Comment, SearchReplace, FileLink,
-             HighlightSyntax, Check, Shortcuts, Symbols, Base,
-             QPlainTextEdit):
-    pass

pyqt_code_editor-0.0.48/pyqt_code_editor/code_editors/languages/python.py

@@ -1,13 +0,0 @@
-from qtpy.QtWidgets import QPlainTextEdit
-from pyqt_code_editor.mixins import Complete, PythonAutoIndent, \
-    PythonAutoPair, Theme, Zoom, LineNumber, Comment, \
-    SearchReplace, Base, Check, Shortcuts, FileLink, Symbols, \
-    SmartBackspaceDelete, Execute
-
-
-class Editor(LineNumber, Zoom, SmartBackspaceDelete, PythonAutoPair, Complete,
-             Comment, PythonAutoIndent, SearchReplace, FileLink, Execute,
-             Check, Theme, Shortcuts, Symbols, Base, 
-             QPlainTextEdit):
-                 
-    code_editor_language = 'python'

pyqt_code_editor-0.0.48/pyqt_code_editor/code_editors/languages/text.py

@@ -1,9 +0,0 @@
-from qtpy.QtWidgets import QPlainTextEdit
-from pyqt_code_editor.mixins import Complete, \
-    HighlightSyntax, Zoom, LineNumber, \
-    SearchReplace, Base, Check, Shortcuts, FileLink, Symbols
-
-
-class Editor(LineNumber, Zoom, Complete, SearchReplace, FileLink,
-             HighlightSyntax, Check, Shortcuts, Base, QPlainTextEdit):
-    pass