qppte 0.7.0__py3-none-any.whl

qppte/__init__.py

@@ -0,0 +1,5 @@
+from .action_trigger import DEFAULT_ACTION_TRIGGERS, ActionTrigger
+from .qpythonplaintextedit import QPythonPlainTextEdit, Settings
+from .qpythonplaintextsettings import QPythonPlainTextSettings, QPythonPlainTextSettingsDialog
+from .qpythonplaintextwidget import QPythonPlainTextWidget
+from .style import DEFAULT_STYLES, TextCharFormat

qppte/action_trigger.py

@@ -0,0 +1,59 @@
+from functools import cache, reduce
+from typing import NamedTuple
+
+from PySide6 import QtCore
+from PySide6.QtGui import QKeyEvent, Qt
+
+
+class ActionTrigger(NamedTuple):
+    key: int
+    modifiers: tuple[int]
+
+    @cache
+    def get_modifiers(self) -> int:
+        return reduce(lambda acc, m: acc | m, self.modifiers, QtCore.Qt.KeyboardModifier.NoModifier)
+
+    def match(self, event: QKeyEvent) -> bool:
+        if event.key() == self.key and (self.modifiers == [] or self.get_modifiers() == event.modifiers()):
+            return True
+        else:
+            return False
+
+    @cache
+    def getQKeyCombination(self) -> QtCore.QKeyCombination:
+        return QtCore.QKeyCombination(self.get_modifiers(), self.key)
+
+    @cache
+    def getQKeyEvent(self) -> QKeyEvent:
+        c = self.getQKeyCombination()
+        return QKeyEvent(QtCore.QEvent.Type.KeyPress, c.key(), c.keyboardModifiers())
+
+
+DEFAULT_ACTION_TRIGGERS: dict[str, ActionTrigger] = {
+    "indent_block": ActionTrigger(Qt.Key.Key_Tab, tuple()),
+    "clear_selection": ActionTrigger(Qt.Key.Key_Escape, tuple()),
+    "backspace": ActionTrigger(Qt.Key.Key_Backspace, tuple()),
+    "new_line_enter": ActionTrigger(Qt.Key.Key_Enter, tuple()),
+    "new_line_return": ActionTrigger(Qt.Key.Key_Return, tuple()),
+    "select_all": ActionTrigger(Qt.Key.Key_A, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "cut": ActionTrigger(Qt.Key.Key_X, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "copy": ActionTrigger(Qt.Key.Key_C, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "paste": ActionTrigger(Qt.Key.Key_V, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "undo": ActionTrigger(Qt.Key.Key_Z, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "redo": ActionTrigger(Qt.Key.Key_R, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "unindent": ActionTrigger(Qt.Key.Key_Backtab, (QtCore.Qt.KeyboardModifier.ShiftModifier,)),
+    "delete_lines": ActionTrigger(Qt.Key.Key_Y, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "goto_line": ActionTrigger(Qt.Key.Key_G, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "move_line_up": ActionTrigger(
+        Qt.Key.Key_Up, (QtCore.Qt.KeyboardModifier.ControlModifier, QtCore.Qt.KeyboardModifier.ShiftModifier)
+    ),
+    "move_line_down": ActionTrigger(
+        Qt.Key.Key_Down, (QtCore.Qt.KeyboardModifier.ControlModifier, QtCore.Qt.KeyboardModifier.ShiftModifier)
+    ),
+    "duplicate_line": ActionTrigger(Qt.Key.Key_D, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "toggle_comment_block": ActionTrigger(Qt.Key.Key_Slash, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+    "join_two_lines": ActionTrigger(
+        Qt.Key.Key_J, (QtCore.Qt.KeyboardModifier.ControlModifier, QtCore.Qt.KeyboardModifier.ShiftModifier)
+    ),
+    "search": ActionTrigger(Qt.Key.Key_F, (QtCore.Qt.KeyboardModifier.ControlModifier,)),
+}

qppte/example_gui.py

@@ -0,0 +1,105 @@
+import sys
+from pathlib import Path
+
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import (
+    QApplication,
+    QFileDialog,
+    QMainWindow,
+    QMenu,
+    QMenuBar,
+    QVBoxLayout,
+    QWidget,
+)
+
+from qppte.qpythonplaintextsettings import QPythonPlainTextSettingsDialog
+from qppte.qpythonplaintextwidget import QPythonPlainTextWidget
+
+
+class TextEditorWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("QPythonPlainTextEdit Demo")
+        self.setGeometry(100, 100, 800, 600)
+
+        text_widget = QPythonPlainTextWidget()
+        text_widget.editor.setHighlightStyle("Light")
+        text_widget.editor.enableLineNumbers(True)
+        search_action = QAction("Search", self)
+        search_action.setShortcut(text_widget.editor.actionTriggers["search"].getQKeyCombination())
+        search_action.triggered.connect(text_widget.editor.startSearch)
+        self.addAction(search_action)
+
+        root_panel = QWidget()
+        layout = QVBoxLayout()
+        root_panel.setLayout(layout)
+        layout.addWidget(text_widget)
+
+        self.setCentralWidget(root_panel)
+
+        self.sample_text = """\"\"\" Module docstring \"\"\"
+
+@property
+def foo() -> None:
+    pass
+    
+@property(x=7)
+def moo() -> None:
+    pass
+    
+for i in [1, 3, 5, 7, 11]:
+    print(f"i -> {i}")
+    
+class A:
+    \"\"\" Class A \"\"\"
+    def __init__(self):
+        self.x = 1 # initializing x to 1
+    
+    def __repr__(self, /) -> str:
+        \"\"\" String representation of class A \"\"\"
+        return f"Instance of class {self.__class__.__name__}({self.a})"
+"""
+        text_widget.editor.setPlainText(self.sample_text)
+
+        menu_bar = QMenuBar()
+
+        def open_file():
+            file_name, _ = QFileDialog.getOpenFileName(
+                self, caption="Import project from file", dir=str(Path.home()), filter="*.py"
+            )
+            if file_name != "":
+                text_widget.editor.setPlainText(Path(file_name).read_text())
+
+        file_menu = QMenu("&File", menu_bar)
+        file_menu.addAction("&Open", open_file)
+        file_menu.addSeparator()
+        file_menu.addAction(
+            "&Settings",
+            lambda: QPythonPlainTextSettingsDialog(self, text_widget.editor.settings, text_widget.editor).exec(),
+        )
+        file_menu.addSeparator()
+        file_menu.addAction("&Quit", self.close)
+        menu_bar.addMenu(file_menu)
+
+        edit_menu = QMenu("&Edit", menu_bar)
+        edit_menu.addAction(
+            "&Undo", lambda: text_widget.editor.keyPressEvent(text_widget.editor.actionTriggers["undo"].getQKeyEvent())
+        ).setShortcut(text_widget.editor.actionTriggers["undo"].getQKeyCombination())
+        edit_menu.addAction(
+            "&Redo", lambda: text_widget.editor.keyPressEvent(text_widget.editor.actionTriggers["redo"].getQKeyEvent())
+        ).setShortcut(text_widget.editor.actionTriggers["redo"].getQKeyCombination())
+        edit_menu.addSeparator()
+        menu_bar.addMenu(edit_menu)
+
+        self.setMenuBar(menu_bar)
+
+
+def main():
+    app = QApplication(sys.argv)
+    window = TextEditorWindow()
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

qppte/line_number_panel.py

@@ -0,0 +1,77 @@
+from PySide6.QtCore import QLine, QRect, QRectF
+from PySide6.QtGui import QColor, QFontMetrics, QPainter, QPaintEvent, QResizeEvent, Qt
+from PySide6.QtWidgets import QWidget
+
+
+class LineNumberPanel(QWidget):
+    ___current_line_number: int | None = None
+
+    def __init__(self, editor_parent):
+        super().__init__(editor_parent)
+        self.editor_parent = editor_parent
+        self.setContentsMargins(0, 0, 0, 0)
+        self.editor_parent.signalCursorMovedLine.connect(self.on_cursor_moved_line)
+
+    def sizeHint(self):
+        return self.editor_parent.sizeHint()
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        super().resizeEvent(event)
+        r: QRect = self.editor_parent.geometry()
+        r.setLeft(1)
+        r.setTop(1)
+        r.setWidth(self.editor_parent._lineNumberPanelWidth)
+        r.setHeight(self.editor_parent.viewport().geometry().height())
+        self.setGeometry(r)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        super().paintEvent(event)
+        painter = QPainter(self)
+        event_rect = event.rect()
+        painter.fillRect(event_rect, self.editor_parent.getBackgroundColor())
+
+        painter.setPen(self.editor_parent.getLineNumberColor())
+        block = self.editor_parent.firstVisibleBlock()
+        bounding_rect_of_block: QRectF = self.editor_parent.blockBoundingGeometry(block)
+        translated_bounding_rect_of_block: QRectF = bounding_rect_of_block.translated(
+            self.editor_parent.contentOffset()
+        )
+        top = translated_bounding_rect_of_block.top()
+        bottom = top + self.editor_parent.blockBoundingRect(block).height()
+
+        height = QFontMetrics(self.font()).height()
+        while block.isValid() and (top <= event_rect.bottom()):
+            block_number = block.blockNumber()
+            if block.isVisible() and (bottom >= event_rect.top()):
+                if block_number == self.___current_line_number:
+                    painter.fillRect(
+                        QRectF(0, top, self.width(), height), self.editor_parent.getCurrentLineBackgroundColor()
+                    )
+
+                painter.drawText(
+                    5,
+                    int(top),
+                    self.width(),
+                    height,
+                    Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter,
+                    f"{block_number + 1}   ",
+                )
+            block = block.next()
+            top = bottom
+            bottom = top + self.editor_parent.blockBoundingRect(block).height()
+
+        line_color = QColor(self.editor_parent.getLineNumberColor())
+        line_color.setAlpha(80)
+        painter.setPen(line_color)
+        painter.drawLine(
+            QLine(
+                self.editor_parent._lineNumberPanelWidth - 2,
+                0,
+                self.editor_parent._lineNumberPanelWidth - 2,
+                event_rect.height(),
+            )
+        )
+
+    def on_cursor_moved_line(self, line_number: int):
+        self.___current_line_number = line_number
+        self.update()

qppte/qppte_tree_sitter.py

@@ -0,0 +1,57 @@
+import tree_sitter_python
+from tree_sitter import Language, Parser, Query
+
+PY_LANGUAGE = Language(tree_sitter_python.language())
+PYTHON_PARSER = Parser(PY_LANGUAGE)
+HIGHLIGHTER_QUERY = Query(
+    PY_LANGUAGE,
+    """
+        (function_definition
+          name: (identifier) @function_definition)
+
+        (function_definition (identifier) @special_function (#any-of? @special_function 
+                                                                        "__init__" "__new__" "__setattr__" 
+                                                                        "__delattr__" "__eq__" "__ne__" 
+                                                                        "__str__" "__hash__" "__format__" 
+                                                                        "__getattribute__" "__sizeof__" "__dir__" 
+                                                                        "__repr__"))
+        ("." (identifier) @special_function (#any-of? @special_function 
+                                                        "__init__" "__new__" "__setattr__" "__delattr__" "__eq__" 
+                                                        "__ne__" "__str__" "__hash__" "__format__" "__getattribute__" 
+                                                        "__sizeof__" "__dir__" "__repr__"))
+
+        (type) @type
+
+        (class_definition
+          name: (identifier) @class_definition_name)
+
+        (call (identifier) @function_call)
+        (decorator "@" (identifier)) @decorator 
+        (decorator "@" (call (identifier) @decorator))  
+        (decorator ("@" @decorator))
+
+        (string_start) @string
+        (string_content) @string
+        (string_end) @string
+
+        ["def" "return" "if" "else" "class" "assert" "async" "await" "break" "continue" "del" "elif" 
+         "else" "except" "finally" "for" "global" "lambda" "pass" "raise" "nonlocal" "return" "try" 
+         "while" "yield" "as" "with" "import" "from" "match" "case" "in"] @keyword
+
+        (true) @keyword
+        (false) @keyword
+
+        (integer) @number
+        (float) @number
+
+        (keyword_argument (identifier) @keyword_argument) 
+
+        ((identifier) @self (#eq? @self "self"))
+
+        (comment) @line_comment
+
+        (function_definition (block . (expression_statement (string) @docstring)))
+        (class_definition (block . (expression_statement (string) @docstring)))
+        (module . (expression_statement (string) @docstring))
+    """,
+)