pyqt-code-editor 0.0.1__py3-none-any.whl

pyqt_code_editor/mixins/execute.py

@@ -0,0 +1,182 @@
+from qtpy.QtCore import Signal, Qt, QTimer
+from qtpy.QtGui import QTextCursor, QTextCharFormat, QColor, QKeySequence
+from qtpy.QtWidgets import QShortcut, QTextEdit
+from .. python_utils import extract_cells_from_code
+from .. import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Execute:
+    """A mixin for QPlainTextEdit that signals that code should be executed.
+
+    # Code execution
+
+    - The shortcut for executing code is defined as
+      settings.shortcut_execute_code.
+    - If text is selected, the selection is expanded to to full lines. This
+      ensures clean execution of partial line selections.    
+    - When nothing is selected, it identifies the "cell" containing the cursor.
+      This is done by extract_cells_from_code, which returns a list of cells,
+      where each cell is a dict as below. The cell that contains the cursor 
+      position is selected.
+      
+      
+      {
+        'description': str | None,
+        'start_pos': int,
+        'end_pos': int,
+        'code': str
+      }
+      
+    - Next, the selected text is executed by emitted execute_code.
+    
+    # File execution
+    
+    - The shortcut for executing a full file is defined as
+      settings.shortcut_execute_file.
+    """
+    
+    execute_code = Signal(str)
+    execute_file = Signal(str)
+    
+    def __init__(self, *args, **kwargs):
+        """Setup keyboard shortcuts for code execution."""
+        # Shortcut for executing current cell or selection
+        super().__init__(*args, **kwargs)
+        logger.info("Initializing Execute")
+        self.execute_code_shortcut = QShortcut(
+            QKeySequence(settings.shortcut_execute_code), 
+            self,
+            context=Qt.WidgetWithChildrenShortcut
+        )
+        self.execute_code_shortcut.activated.connect(self.execute_selected_text)
+        
+        # Shortcut for executing the entire file
+        self.execute_file_shortcut = QShortcut(
+            QKeySequence(settings.shortcut_execute_file), 
+            self,
+            context=Qt.WidgetWithChildrenShortcut
+        )
+        self.execute_file_shortcut.activated.connect(self.execute_current_file)
+        logger.info("Execute shortcuts initialized")
+    
+    def execute_selected_text(self):
+        """Execute the selected text or the current cell if no text is selected."""
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            # Get the start and end positions
+            start_pos = cursor.selectionStart()
+            end_pos = cursor.selectionEnd()
+            
+            # Create a new cursor to find the start of the first line
+            start_cursor = QTextCursor(self.document())
+            start_cursor.setPosition(start_pos)
+            start_cursor.movePosition(QTextCursor.StartOfLine)
+            
+            # Create a new cursor to find the end of the last line
+            end_cursor = QTextCursor(self.document())
+            end_cursor.setPosition(end_pos)
+            if not end_cursor.atBlockEnd():
+                end_cursor.movePosition(QTextCursor.EndOfLine)
+            
+            # Set the expanded selection
+            cursor.setPosition(start_cursor.position())
+            cursor.setPosition(end_cursor.position(), QTextCursor.KeepAnchor)
+            self.setTextCursor(cursor)
+            
+            # Get the selected text and execute it
+            selected_text = cursor.selectedText().replace('\u2029', '\n')  # Handle QTextEdit's line separators
+            if selected_text:
+                logger.info("Executing selected text (%d characters)", len(selected_text))
+                self.highlight_executed_code(cursor)
+                self.execute_code.emit(selected_text)
+        else:
+            # No selection, execute the current cell
+            logger.info("No selection found, executing current cell")
+            self.execute_current_cell()
+    
+    def execute_current_cell(self):
+        """Execute the cell that contains the cursor."""
+        cell = self.get_cell_at_cursor()
+        if cell:
+            # Create a cursor for the cell range
+            cursor = QTextCursor(self.document())
+            cursor.setPosition(cell['start_pos'])
+            cursor.setPosition(cell['end_pos'], QTextCursor.KeepAnchor)
+            
+            # Highlight the cell and execute it
+            logger.info("Executing cell %s-%s (%d characters)", 
+                        cell['start_pos'], cell['end_pos'], len(cell['code']))
+            if cell['description']:
+                logger.info("Cell description: %s", cell['description'])
+                
+            self.highlight_executed_code(cursor)
+            self.execute_code.emit(cell['code'])
+        else:
+            logger.info("No cell found at cursor position")
+    
+    def execute_current_file(self):
+        """Execute the entire file."""
+        text = self.toPlainText()
+        if not hasattr(self, 'code_editor_file_path'):
+            return
+        if self.code_editor_file_path is None:
+            return
+        logger.info("Executing entire file (%d characters)", len(text))
+        self.execute_file.emit(self.code_editor_file_path)
+    
+    def get_cell_at_cursor(self):
+        """Get the cell that contains the current cursor position."""
+        cursor_pos = self.textCursor().position()
+        text = self.toPlainText()
+        
+        logger.info("Finding cell at cursor position %d", cursor_pos)
+        cells = extract_cells_from_code(text)
+        logger.info("Found %d cells in document", len(cells))
+        
+        # Find the cell that contains the cursor position
+        for cell in cells:
+            if cell['start_pos'] <= cursor_pos <= cell['end_pos']:
+                logger.info("Cursor is in cell %s-%s", cell['start_pos'], cell['end_pos'])
+                return cell
+        
+        # If no cell is found (shouldn't happen as the entire document is treated as one cell)
+        # but just in case, return the entire document as a cell
+        if cells:
+            logger.info("No specific cell found, using first cell")
+            return cells[0]
+        logger.info("No cells found in document")
+        return None
+    
+    def highlight_executed_code(self, cursor, duration=200):
+        """Temporarily highlight the executed code for visual feedback.
+        
+        Args:
+            cursor: QTextCursor with the selection to highlight
+            duration: How long to show the highlight in milliseconds
+        """
+        # Store the current selection
+        original_cursor = self.textCursor()
+        
+        # Apply the highlight cursor
+        self.setTextCursor(cursor)
+        
+        # Create a highlighted format
+        highlight_format = QTextCharFormat()
+        highlight_format.setBackground(QColor(100, 100, 170, 50))  # Light blue background
+        
+        # Apply the format
+        selection = QTextEdit.ExtraSelection()
+        selection.cursor = cursor
+        selection.format = highlight_format
+        self.setExtraSelections([selection])
+        logger.info("Highlighted executed code (duration: %dms)", duration)
+        
+        # Restore the original cursor after a delay
+        def restore_selection():
+            self.setTextCursor(original_cursor)
+            self.setExtraSelections([])
+        
+        QTimer.singleShot(duration, restore_selection)

pyqt_code_editor/mixins/file_link.py

@@ -0,0 +1,166 @@
+import os
+import logging
+import chardet
+from pathlib import Path
+from qtpy.QtCore import QFileSystemWatcher, Signal
+from qtpy.QtWidgets import QMessageBox, QFileDialog
+from .. import settings
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+class FileLink:
+    """
+    A mixin for QPlainTextEdit that links the content of the editor to a
+    file on disk. By default, the editor is not linked to any file.
+
+    A QFileSystemWatcher monitors the currently opened file. If the file is
+    changed on disk, the user is prompted to possibly reload. (See _on_file_changed.)
+    """
+    file_saved = Signal(object, str)
+    file_name_changed = Signal(object, str, str)
+    code_editor_file_path = None  # str or None
+    code_editor_encoding = None   # str or None
+    _file_watcher = None          # QFileSystemWatcher or None
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        logger.info("Initializing FileLink")
+        self._watch_file_changes = True
+
+    def open_file(self, path: Path | str, encoding: str = None):
+        """
+        Reads the content from a file and sets it as the editor content.
+        If the file does not exist, a sensible exception is raised.
+        If no encoding is specified, tries:
+          1) If it's pure ASCII, use 'utf-8'.
+          2) Else guess with chardet, or default to 'utf-8' if chardet yields None.
+        """
+        path = Path(path)  # ensure we have a Path object
+        if not path.is_file():
+            raise FileNotFoundError(f"No such file: {path}")
+
+        raw_data = path.read_bytes()
+
+        if encoding is None:
+            # First see if everything is within ASCII range
+            try:
+                raw_data.decode("utf-8")
+                # If no error -> it's strictly ASCII, so decode as UTF-8
+                used_encoding = "utf-8"
+            except UnicodeDecodeError:
+                # Not pure ASCII; let chardet pick
+                detect_result = chardet.detect(raw_data)
+                # If detection fails or returns None, default to utf-8
+                used_encoding = detect_result["encoding"] or "utf-8"
+        else:
+            used_encoding = encoding
+        logger.info(f'opening file as {used_encoding}')
+        # Try reading with the chosen encoding
+        with path.open("r", encoding=used_encoding) as f:
+            content = f.read()
+
+        # Store the content in the editor
+        self.setPlainText(content)
+
+        # Update internal state
+        self.code_editor_file_path = str(path)
+        self.code_editor_encoding = used_encoding
+
+        # (Re)watch this file
+        self._saving = False        
+        self._watch_file(path)
+        self.set_modified(False)
+
+    def save_file(self):
+        """
+        Saves the editor content to the file named code_editor_file_path,
+        using code_editor_encoding. If no valid path or encoding is available,
+        a sensible exception is raised.
+        """
+        if not self.code_editor_file_path:
+            self.save_file_as()
+            return
+        if not self.code_editor_encoding:
+            self.code_editor_encoding = settings.default_encoding
+        path = Path(self.code_editor_file_path)
+        self._saving = True
+        try:
+            with path.open("w", encoding=self.code_editor_encoding) as f:
+                f.write(self.toPlainText())
+        except Exception as e:
+            QMessageBox.warning(self, "Error", f"Failed to save file:\n{str(e)}")
+        self.set_modified(False)
+        self.file_saved.emit(self, self.code_editor_encoding)
+
+    def save_file_as(self, path: Path | str =  None):
+        """
+        Saves the editor content to file and updates code_editor_file_path.
+        If no path is provided, the user asked to choose.
+        """
+        if path is None:
+            if self.code_editor_file_path is None:
+                suggested_name = os.path.join(settings.current_folder,
+                                              settings.default_filename)
+            else:
+                suggested_name = self.code_editor_file_path
+            path, _ = QFileDialog.getSaveFileName(
+                self, "Save As", suggested_name, "All Files (*.*)")
+            if not path:
+                return
+        old_path = self.code_editor_encoding
+        settings.current_folder = os.path.dirname(path)
+        self.code_editor_file_path = str(path)
+        self.save_file()
+        # Update internal pointers
+        self._watch_file(path)
+        self.set_modified(False)
+        self.file_name_changed.emit(self, old_path, self.code_editor_file_path)
+
+    def _watch_file(self, path: Path):
+        """Set up the QFileSystemWatcher to watch the newly opened or saved file."""
+        # If there's no watcher yet, create one.
+        if self._file_watcher is None:
+            self._file_watcher = QFileSystemWatcher()
+            self._file_watcher.fileChanged.connect(self._on_file_changed)
+
+        # Clear the watcher first (the old file path).
+        self._file_watcher.removePaths(self._file_watcher.files())
+
+        # Now watch the new file
+        self._file_watcher.addPath(str(path))
+
+    def _on_file_changed(self, changed_path: str):
+        """
+        Called by QFileSystemWatcher whenever the watched file changes on disk.
+        By default, offers the user to reload. If reloaded, calls open_file again.
+        """
+        if not self._watch_file_changes:
+            return
+        # If we have triggered a save ourselves, we ignore it but only once
+        if self._saving:
+            self._saving = False
+            return
+        # Only respond if it matches the current file
+        if changed_path != self.code_editor_file_path:
+            return
+
+        self._watch_file_changes = False
+        # Prompt user to reload
+        reply = QMessageBox.warning(
+            self, 
+            "File changed on disk",
+            f"The file:\n{changed_path}\nhas changed on disk.\nReload?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.Yes
+        )
+        if reply == QMessageBox.Yes:
+            # Reload file
+            logger.info("Reloading file after external change.")
+            self.open_file(changed_path, encoding=self.code_editor_encoding)
+        else:
+            logger.info("User chose not to reload. Re-watching file anyway.")
+            # Re-add the file to watcher so we keep listening for future changes
+            if self._file_watcher is not None:
+                self._file_watcher.addPath(changed_path)
+        self._watch_file_changes = True

pyqt_code_editor/mixins/line_number.py

@@ -0,0 +1,206 @@
+from qtpy.QtWidgets import QWidget, QToolTip
+from qtpy.QtCore import Qt, QRect, QSize
+from qtpy.QtGui import QPainter
+from .. import settings
+
+
+class LineNumberArea(QWidget):
+    """
+    A small widget placed to the left of the text editor
+    that displays line numbers.
+    """
+
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.setMouseTracking(True)
+        self._editor = editor
+        self.apply_stylesheet()
+
+    def sizeHint(self):
+        """
+        The width is determined by the editor's
+        lineNumberAreaWidth() callback.
+        """
+        return QSize(self._editor.lineNumberAreaWidth(), 0)
+
+    def paintEvent(self, event):
+        """
+        Delegates painting to the editor's lineNumberAreaPaintEvent method.
+        """
+        self._editor.lineNumberAreaPaintEvent(event)
+        
+    def mouseMoveEvent(self, event):
+        self._editor.mouseMoveEvent(event)
+        
+    def apply_stylesheet(self):
+        editor = self.parent()
+        if editor.code_editor_colors is not None:
+            self.setStyleSheet(f'''QWidget {{
+                color: {editor.code_editor_colors['line-number']};
+                background-color: {editor.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+            }}''')
+
+class LineNumber:
+    """
+    Mixin class that adds a line number area to a QPlainTextEdit.
+    The mixin assumes that it can access self.viewport() etc. from
+    QPlainTextEdit side of the inheritance.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setMouseTracking(True)
+        # Create the line number area
+        self.lineNumberArea = LineNumberArea(self)
+
+        # Connect signals for updating
+        self.blockCountChanged.connect(self.updateLineNumberAreaWidth)
+        self.updateRequest.connect(self.updateLineNumberArea)
+
+        # Force an initial width update
+        self.updateLineNumberAreaWidth(0)
+
+    def lineNumberAreaSizeHint(self):
+        """
+        Provide a size hint for the line number area,
+        used in the area itself.
+        """
+        return self.size()
+
+    def lineNumberAreaWidth(self):
+        """
+        Compute the width needed by the line number area based on the
+        number of digits in the total line count, plus some padding.
+        """
+        digits = len(str(max(1, self.blockCount())))
+        # Add some extra space for margins
+        padding = 3
+        charWidth = self.fontMetrics().horizontalAdvance('9')
+        return padding + self.fontMetrics().horizontalAdvance('9' * digits) + charWidth
+
+    def updateLineNumberAreaWidth(self, _):
+        """
+        Adjust left margin so the editor does not paint text under the lineNumbers.
+        """
+        self.setViewportMargins(self.lineNumberAreaWidth(), 0, 0, 0)
+
+    def updateLineNumberArea(self, rect, dy):
+        """
+        Called when the editor is scrolled or resized.
+        We move/scroll the lineNumberArea accordingly, and possibly repaint.
+        """
+        if dy:  # simply scroll
+            self.lineNumberArea.scroll(0, dy)
+        else:
+            # The entire area might need repainting
+            self.lineNumberArea.update(0, rect.y(), self.lineNumberArea.width(), rect.height())
+
+        # If resizing, update width as well
+        if rect.contains(self.viewport().rect()):
+            self.updateLineNumberAreaWidth(0)
+
+    def resizeEvent(self, event):
+        """
+        Ensure lineNumberArea is properly resized and placed.
+        """
+        super().resizeEvent(event)
+        cr = self.contentsRect()
+        self.lineNumberArea.setGeometry(
+            cr.left(), cr.top(), self.lineNumberAreaWidth(), cr.height()
+        )
+        
+    def _update_line_number_rects(self):
+        """
+        Determines the rects around the line number area parts and the full 
+        line. This is done for the entire viewport, even if we need to redraw
+        only a small part of the viewport. That way, the tooltip doesn't lose
+        track of where we're hovering.
+        """
+        self._line_number_rects = {}
+        self._line_rects = {}
+    
+        block = self.firstVisibleBlock()
+        block_number = block.blockNumber()
+    
+        # Starting Y coordinate of the current block
+        top = self.blockBoundingGeometry(block).translated(self.contentOffset()).top()
+    
+        # We'll keep iterating until we run out of visible blocks
+        viewport_rect = self.viewport().rect()
+        viewport_bottom = viewport_rect.bottom()
+        viewport_width = viewport_rect.width()
+        rect_width = self.lineNumberArea.width()
+        while block.isValid() and top <= viewport_bottom:
+            rect_height = self.blockBoundingRect(block).height()
+            if block.isVisible():
+                # We only care about block geometry if visible
+                line_number_rect = QRect(0, int(top), rect_width, int(rect_height))
+                self._line_number_rects[block_number] = line_number_rect
+                line_rect = QRect(
+                    -rect_width,
+                    line_number_rect.top(),
+                    viewport_width + rect_width,
+                    line_number_rect.height()
+                )
+                self._line_rects[block_number] = line_rect
+            block = block.next()
+            top += rect_height
+            block_number += 1      
+
+    def lineNumberAreaPaintEvent(self, event):
+        """
+        Paint line numbers for each visible block, assuming self._line_number_rects
+        is already populated with the correct geometry for each visible line.
+        """
+        self._update_line_number_rects()
+        painter = QPainter(self.lineNumberArea)
+        base_color = self.lineNumberArea.palette().base()
+        text_color = self.lineNumberArea.palette().text().color()
+        align_top_right = Qt.AlignTop | Qt.AlignRight
+        painter.fillRect(event.rect(), base_color)
+        for block_number, line_rect in self._line_number_rects.items():
+            if line_rect.intersects(event.rect()):
+                # Convert zero-based block_number to 1-based for display
+                line_num = block_number + 1
+                # Check if current line has a lint/check result
+                annotation = self.code_editor_line_annotations.get(line_num)
+                if annotation:
+                    text_str = annotation['text']
+                    painter.fillRect(line_rect, annotation['background_color'])
+                    painter.setPen(annotation['color'])
+                else:
+                    text_str = str(line_num)
+                    painter.setPen(text_color)
+                painter.drawText(line_rect, align_top_right, text_str)
+            
+    def mouseMoveEvent(self, event):
+        """
+        Called when the mouse moves over the entire QPlainTextEdit.
+        We check each line's rectangle in self._line_rects
+        to see if the cursor is in that rect (covering both gutter + text).
+        If so, we look up code_editor_line_annotations to see if there's
+        an issue for that line, and show a tooltip. If not, hide it.
+        """
+        pos = event.pos()
+        hovered_any_line = False
+        for block_number, line_rect in self._line_rects.items():
+            if line_rect.contains(pos):
+                hovered_any_line = True
+                line_num = block_number + 1
+                annotation = self.code_editor_line_annotations.get(line_num)
+                if annotation:
+                    # Convert from local to global coords
+                    line_number_rect = self._line_number_rects[block_number]
+                    global_pos = self.mapToGlobal(line_number_rect.bottomRight())
+                    QToolTip.showText(global_pos, annotation['tooltip'], self)
+                else:
+                    QToolTip.hideText()
+                break
+        if not hovered_any_line:
+            QToolTip.hideText()
+        super().mouseMoveEvent(event)
+
+    def update_theme(self):
+        super().update_theme()
+        self.lineNumberArea.apply_stylesheet()