PrEditor 2.7.0__tar.gz → 2.9.0__tar.gz

{preditor-2.7.0 → preditor-2.9.0}/.github/workflows/static-analysis-and-test.yml

@@ -49,10 +49,14 @@ jobs:
     strategy:
       matrix:
         os: ['ubuntu-latest', 'windows-latest']
-        python: ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        python: ['3.10', '3.11', '3.12', '3.13']
         # Works around the depreciation of python 3.7 for ubuntu
         # https://github.com/actions/setup-python/issues/544
         include:
+          - os: 'ubuntu-24.04'
+            python: '3.9'
+          - os: 'ubuntu-24.04'
+            python: '3.8'
           - os: 'ubuntu-22.04'
             python: '3.7'
 

{preditor-2.7.0 → preditor-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PrEditor
-Version: 2.7.0
+Version: 2.9.0
 Summary: A python REPL and Editor and console based on Qt.
 Author-email: Blur Studio <opensource@blur.com>
 License: LGPL-3.0
@@ -84,6 +84,13 @@ blocks([...](https://docs.python.org/3/glossary.html#term-...)), use the workbox
 loggers, and tracebacks(not using stderr). This can be used in various widgets to
 show selected output. See [examples/output_console.py](examples/output_console.py)
 for an example of the various modes.
+* **Traceback markers:** Set the `PREDITOR_WRAP_TB` environment variable to
+`prefix,suffix` to print those lines to stderr before and after every traceback
+handled by PrEditor's excepthook. The traceback is still raised normally. This
+makes tracebacks easy to find or parse in log files, for example:
+    ```
+    PREDITOR_WRAP_TB=--- TRACEBACK START ---,--- TRACEBACK END ---
+    ```
 * All code is run in `__main__`. In code you can add objects to it for inspection in PrEditor.
 * `Ctrl + Shift + PgUp/PgDown` changes focus between the console and workbox.
 * `Ctrl + Alt + Shift + PgUp/PgDown` changes focus and copies the current prompt

{preditor-2.7.0 → preditor-2.9.0}/PrEditor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PrEditor
-Version: 2.7.0
+Version: 2.9.0
 Summary: A python REPL and Editor and console based on Qt.
 Author-email: Blur Studio <opensource@blur.com>
 License: LGPL-3.0
@@ -84,6 +84,13 @@ blocks([...](https://docs.python.org/3/glossary.html#term-...)), use the workbox
 loggers, and tracebacks(not using stderr). This can be used in various widgets to
 show selected output. See [examples/output_console.py](examples/output_console.py)
 for an example of the various modes.
+* **Traceback markers:** Set the `PREDITOR_WRAP_TB` environment variable to
+`prefix,suffix` to print those lines to stderr before and after every traceback
+handled by PrEditor's excepthook. The traceback is still raised normally. This
+makes tracebacks easy to find or parse in log files, for example:
+    ```
+    PREDITOR_WRAP_TB=--- TRACEBACK START ---,--- TRACEBACK END ---
+    ```
 * All code is run in `__main__`. In code you can add objects to it for inspection in PrEditor.
 * `Ctrl + Shift + PgUp/PgDown` changes focus between the console and workbox.
 * `Ctrl + Alt + Shift + PgUp/PgDown` changes focus and copies the current prompt

{preditor-2.7.0 → preditor-2.9.0}/PrEditor.egg-info/scm_file_list.json

@@ -214,6 +214,7 @@
     "tests/ide/test_delayable_engine.py",
     "tests/test_config.py",
     "tests/test_cute.py",
+    "tests/test_debug.py",
     "tests/test_prefs.py",
     "tests/test_stream.py",
     "tox.ini"

preditor-2.9.0/PrEditor.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.9.0",
+  "distance": 0,
+  "node": "gb07591e17dc3fff29e25be4c2875475638a95942",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-11-02"
+}

{preditor-2.7.0 → preditor-2.9.0}/README.md

@@ -38,6 +38,13 @@ blocks([...](https://docs.python.org/3/glossary.html#term-...)), use the workbox
 loggers, and tracebacks(not using stderr). This can be used in various widgets to
 show selected output. See [examples/output_console.py](examples/output_console.py)
 for an example of the various modes.
+* **Traceback markers:** Set the `PREDITOR_WRAP_TB` environment variable to
+`prefix,suffix` to print those lines to stderr before and after every traceback
+handled by PrEditor's excepthook. The traceback is still raised normally. This
+makes tracebacks easy to find or parse in log files, for example:
+    ```
+    PREDITOR_WRAP_TB=--- TRACEBACK START ---,--- TRACEBACK END ---
+    ```
 * All code is run in `__main__`. In code you can add objects to it for inspection in PrEditor.
 * `Ctrl + Shift + PgUp/PgDown` changes focus between the console and workbox.
 * `Ctrl + Alt + Shift + PgUp/PgDown` changes focus and copies the current prompt

{preditor-2.7.0 → preditor-2.9.0}/preditor/debug.py

@@ -3,15 +3,20 @@ from __future__ import absolute_import, print_function
 import datetime
 import inspect
 import logging
+import os
 import sys
 
 logger = logging.getLogger(__name__)
 
+# Keeps the file `faulthandlerToFile` installed open for the life of the process
+_faulthandlerFile = None
+
 
 class FileLogger:
     def __init__(self, stdhandle, logfile, _print=True, clearLog=True):
         self.old_stream = stdhandle
-        self._logfile = logfile
+        # Accept pathlib objects but store the path as a string
+        self._logfile = os.fspath(logfile)
         self._print = _print
         if clearLog:
             # clear the log file
@@ -48,18 +53,21 @@ def logToFile(path, stdout=True, stderr=True, useOldStd=True, clearLog=True):
     sys.version info when stdout is True.
 
     Args:
-        path (str): File path to log output to.
-
+        path (str or os.PathLike): File path to log output to. If None is explicitly
+            passed the path returned by `preditor.osystem.defaultLogFile()` is used.
         stdout (bool): If True(default) override sys.stdout.
-
         stderr (bool): If True(default) override sys.stderr.
-
         useOldStd (bool): If True, messages will be written to the FileLogger
             and the previous sys.stdout/sys.stderr.
 
         clearLog (bool): If True(default) clear the log file when this command is
         called.
     """
+    if path is None:
+        from . import osystem
+
+        path = osystem.defaultLogFile()
+
     if stderr:
         sys.stderr = FileLogger(sys.stderr, path, useOldStd, clearLog=clearLog)
     if stdout:
@@ -76,6 +84,63 @@ def logToFile(path, stdout=True, stderr=True, useOldStd=True, clearLog=True):
         StreamHandlerHelper.replace_stream(sys.stderr.old_stream, sys.stderr)
 
 
+def faulthandlerToFile(path, allThreads=True, clearLog=True, force=False):
+    """Install faulthandler so hard crashes are written to a log file.
+
+    Python normally can't report fatal errors like segfaults, they simply kill
+    the process without any output. Enabling faulthandler makes python dump the
+    traceback of each thread to a file when one of those errors happens, which
+    is often the only record of what a host application was doing when it died.
+
+    Unlike `logToFile` this doesn't touch sys.stdout/sys.stderr. faulthandler
+    writes to the file descriptor directly, so it needs a real file on disk, not
+    a `FileLogger`. The file is left open for the life of the process, closing
+    it would leave faulthandler writing to an invalid file descriptor.
+
+    If faulthandler is already enabled it's left alone unless force is used.
+    This includes it being enabled outside of this function, for example by the
+    `PYTHONFAULTHANDLER` env var or `python -X faulthandler`.
+
+    Args:
+        path (str or os.PathLike): File path to write faulthandler output to. If
+            None is explicitly passed the path returned by
+            `preditor.osystem.defaultLogFile('preditorFaulthandler.log')` is used.
+        allThreads (bool): If True(default) dump the traceback of all threads,
+            otherwise only the thread that crashed.
+        clearLog (bool): If True(default) clear the log file when this command
+            is called, otherwise append to the existing contents.
+        force (bool): If True, install faulthandler even if it was already
+            enabled. Any file opened by a previous call is closed.
+
+    Returns:
+        bool: If faulthandler was installed by this call. False is returned if
+            it was already enabled and force was not used.
+    """
+    global _faulthandlerFile
+    import faulthandler
+
+    if faulthandler.is_enabled() and not force:
+        logger.debug('faulthandler is already enabled, not logging to: %s', path)
+        return False
+
+    if path is None:
+        from . import osystem
+
+        path = osystem.defaultLogFile('preditorFaulthandler.log')
+
+    # Newline forces windows to write unix style newlines
+    output = open(path, 'w' if clearLog else 'a', newline="\n", encoding="utf-8")
+    faulthandler.enable(file=output, all_threads=allThreads)
+
+    # Only close the file used by a previous call once the new one is installed
+    previous = _faulthandlerFile
+    _faulthandlerFile = output
+    if previous is not None:
+        previous.close()
+
+    return True
+
+
 def printCallingFunction(compact=False):
     """Prints and returns info about the calling function
 

{preditor-2.7.0 → preditor-2.9.0}/preditor/excepthooks.py

@@ -1,5 +1,6 @@
 from __future__ import absolute_import, print_function
 
+import os
 import sys
 import traceback
 
@@ -73,14 +74,24 @@ class PreditorExceptHook(object):
         A newline is printed pre-traceback to ensure the first line of output
         is not printed in-line with the prompt. This also provides visual
         separation between tracebacks, when received consecutively.
+
+        Checks the env var `PREDITOR_WRAP_TB`, if set it will split on commas and
+        print the first item to stderr before the traceback and the second item after
+        the traceback is handled on newlines.
         """
         # Print the newline to stderr so it will show up in the same stream as
         # the traceback will be printed to.
         print("", file=sys.stderr)
+        fixes = os.getenv("PREDITOR_WRAP_TB", "").split(",", 2)
+        if len(fixes):
+            print(fixes[0], file=sys.stderr)
         try:
             self.base_excepthook(*exc_info)
         except (TypeError, NameError):
             sys.__excepthook__(*exc_info)
+        finally:
+            if len(fixes) > 1:
+                print(fixes[1], file=sys.stderr)
 
     @classmethod
     def call_callbacks(cls, *exc_info):

{preditor-2.7.0 → preditor-2.9.0}/preditor/gui/__init__.py

@@ -1,29 +1,9 @@
-import re
-
-from Qt.QtGui import QCursor
-from Qt.QtWidgets import QStackedWidget, QToolTip
+from Qt.QtWidgets import QStackedWidget
 
 from .dialog import Dialog  # noqa: F401
 from .window import Window  # noqa: F401
 
 
-def handleMenuHovered(action):
-    """Actions in QMenus which are not descendants of a QToolBar will not show
-    their toolTips, because... Reasons?
-    """
-    # Don't show if it's just the text of the action
-    text = re.sub(r"(?<!&)&(?!&)", "", action.text())
-    text = text.replace('...', '')
-
-    if text == action.toolTip():
-        text = ''
-    else:
-        text = action.toolTip()
-
-    menu = action.parent()
-    QToolTip.showText(QCursor.pos(), text, menu)
-
-
 def loadUi(filename, widget, uiname=''):
     """use's Qt's uic loader to load dynamic interafces onto the inputed widget
 

{preditor-2.7.0 → preditor-2.9.0}/preditor/gui/codehighlighter.py

@@ -101,72 +101,28 @@ class CodeHighlighter(QSyntaxHighlighter):
         if not self.enabled():
             return
 
-        # Reset the highlight spans for this text block
-        self.spans = []
-
-        if not self.isConsoleMode() or str(text).startswith('>>>'):
-
-            # We only have a result pattern if the parent has an attr "outputPrompt", so
-            # only proceed if we have been able to define self._resultPattern.
-            if self._resultPattern:
-                self.highlightText(
-                    text,
-                    self._resultPattern,
-                    self._resultFormat,
-                )
-
-            # Format the strings
-            self.highlightText(
-                text,
-                self._stringPattern,
-                self._stringFormat,
-            )
-
-            # format the comments
-            self.highlightText(
-                text,
-                self._commentPattern,
-                self._commentFormat,
-            )
-
-            # Format the keywords
-            self.highlightText(
-                text,
-                self._keywordPattern,
-                self._keywordFormat,
-            )
-
-    def highlightText(self, text, expr, format):
-        """Highlights a text group with an expression and format
-
-        Args:
-            text (str): text to highlight
-            expr (re.compile): search parameter
-            format (QTextCharFormat): formatting rule
-        """
-        if expr is None or not text:
+        if self.isConsoleMode() and not text.startswith('>>>'):
             return
 
-        # highlight all the given matches to the expression in the text
-        for match in expr.finditer(text):
-            match_span = match.span()
-            start, end = match_span
-            length = end - start
-
-            # Determine if the current highlight is within an already determined
-            # highlight, if so, let's block it.
-            blocked = False
-            for span in self.spans:
-                if start > span[0] and start < span[-1]:
-                    blocked = True
-                    break
-
-            if not blocked:
-                self.setFormat(start, length, format)
-
-                # Append the current span to self.spans, so we can later block
-                # new highlights which should be blocked
-                self.spans.append(match_span)
+        pattern = self._highlightPattern
+        if pattern is None:
+            pattern = self.defineHighlightPattern()
+
+        # Map the named groups of the combined pattern to their formats
+        formats = {
+            "result": self._resultFormat,
+            "string": self._stringFormat,
+            "comment": self._commentFormat,
+            "keyword": self._keywordFormat,
+        }
+
+        # The combined pattern finds the leftmost highlight first and continues
+        # searching after it. This prevents highlighting text inside of an
+        # existing highlight, for example a keyword inside a string or comment.
+        setFormat = self.setFormat
+        for match in pattern.finditer(text):
+            start, end = match.span()
+            setFormat(start, end - start, formats[match.lastgroup])
 
     def isConsoleMode(self):
         """checks to see if this highlighter is in console mode"""
@@ -267,12 +223,40 @@ class CodeHighlighter(QSyntaxHighlighter):
         """Define the regex pattern to use for comment"""
         pattern = "|".join(self._comments)
         self._commentPattern = re.compile(pattern)
+        self._highlightPattern = None
+
+    def defineHighlightPattern(self):
+        """Combine the result, string, comment and keyword patterns into a
+        single regex pattern with a named group for each. Searching once with
+        this pattern is much faster than searching for each pattern separately.
+
+        Returns:
+            re.Pattern: The combined pattern, also stored on this instance.
+        """
+        parts = []
+        for name, expr in (
+            ("result", self._resultPattern),
+            ("string", self._stringPattern),
+            ("comment", self._commentPattern),
+            ("keyword", self._keywordPattern),
+        ):
+            # Patterns that match empty text would prevent the other patterns
+            # from matching so skip them, they wouldn't highlight anything.
+            if expr is not None and expr.pattern:
+                parts.append(f"(?P<{name}>{expr.pattern})")
+
+        # If there is nothing to highlight, use a pattern that never matches.
+        self._highlightPattern = re.compile("|".join(parts) or "(?!)")
+        return self._highlightPattern
 
     def defineKeywordPattern(self):
         """Define the regex pattern to use for keyword"""
-        keywords = [r"\b{}\b".format(word) for word in self._keywords]
-        pattern = "|".join(keywords)
+        pattern = ""
+        if self._keywords:
+            keywords = "|".join(self._keywords)
+            pattern = rf"\b(?:{keywords})\b"
         self._keywordPattern = re.compile(pattern)
+        self._highlightPattern = None
 
     def defineResultPattern(self):
         """Define the regex pattern to use for results"""
@@ -281,9 +265,11 @@ class CodeHighlighter(QSyntaxHighlighter):
             prompt = parent.outputPrompt()
             pattern = '{}[^\n]*'.format(prompt)
             self._resultPattern = re.compile(pattern)
+            self._highlightPattern = None
 
     def defineStringPattern(self):
         """Define the regex pattern to use for strings."""
         lst = ["""{0}[^{0}\n]*{0}""".format(st) for st in self._strings]
         pattern = "|".join(lst)
         self._stringPattern = re.compile(pattern)
+        self._highlightPattern = None

{preditor-2.7.0 → preditor-2.9.0}/preditor/gui/completer.py

@@ -1,14 +1,14 @@
 from __future__ import absolute_import
 
+import heapq
 import inspect
 import re
 import sys
 from enum import Enum
 
-import Qt as Qt_py
-from Qt.QtCore import QRegExp, QSortFilterProxyModel, QStringListModel, Qt
-from Qt.QtGui import QCursor, QTextCursor
-from Qt.QtWidgets import QCompleter, QToolTip
+from Qt.QtCore import QRegularExpression, QSortFilterProxyModel, QStringListModel, Qt
+from Qt.QtGui import QCursor, QFontMetrics, QTextCursor
+from Qt.QtWidgets import QCompleter, QStyle, QToolTip
 
 
 class CompleterMode(Enum):
@@ -53,6 +53,9 @@ class PythonCompleter(QCompleter):
 
         # update this completer
         self.setWidget(widget)
+        # All items use the same font, so let the popup skip measuring every row
+        # when laying out large lists.
+        self.popup().setUniformItemSizes(True)
 
         self.setCaseSensitive()
         self.setCompleterMode()
@@ -136,6 +139,27 @@ class PythonCompleter(QCompleter):
     def hideDocumentation(self):
         QToolTip.hideText()
 
+    def popupWidth(self, sampleCount=20):
+        """Returns the width needed to show the longest completions in the popup.
+
+        This is much faster than `popup().sizeHintForColumn(0)` for large lists
+        as that measures every row using the item delegate. Instead only the
+        `sampleCount` longest completions are measured.
+        """
+        popup = self.popup()
+        model = self.completionModel()
+        completions = (model.index(row, 0).data() for row in range(model.rowCount()))
+        longest = heapq.nlargest(sampleCount, completions, key=len)
+
+        metrics = QFontMetrics(popup.font())
+        textWidth = max((metrics.horizontalAdvance(t) for t in longest), default=0)
+        # Match the text margins QStyledItemDelegate adds on each side of the text.
+        margin = popup.style().pixelMetric(
+            QStyle.PixelMetric.PM_FocusFrameHMargin, None, popup
+        )
+        scrollBarWidth = popup.verticalScrollBar().sizeHint().width()
+        return textWidth + (margin + 1) * 2 + scrollBarWidth
+
     def refreshList(self, scope=None):
         """refreshes the string list based on the cursor word"""
         object, prefix = self.currentObject(scope)
@@ -150,24 +174,28 @@ class PythonCompleter(QCompleter):
         except AttributeError:
             keys = []
         keys.sort()
-        self.model().sourceModel().setStringList(keys)
+        # Resetting the model can get expensive for large lists, this is called
+        # on every key press while the popup is visible, but the keys only change
+        # when the object being completed changes.
+        sourceModel = self.model().sourceModel()
+        if keys != sourceModel.stringList():
+            sourceModel.setStringList(keys)
 
         regExStr = ""
         if self._completerMode == CompleterMode.STARTS_WITH:
-            regExStr = "^{}.*".format(prefix)
+            regExStr = f"^{QRegularExpression.escape(prefix)}"
         if self._completerMode == CompleterMode.OUTER_FUZZY:
-            regExStr = ".*{}.*".format(prefix)
+            regExStr = QRegularExpression.escape(prefix)
         if self._completerMode == CompleterMode.FULL_FUZZY:
-            regExStr = ".*".join(prefix)
-
-        if Qt_py.IsPyQt6 or Qt_py.IsPySide6:
-            regexp = QRegExp(regExStr)
-            if self._sensitivity:
-                regexp.setPatternOptions(QRegExp.PatternOption.CaseInsensitiveOption)
+            regExStr = ".*".join(QRegularExpression.escape(c) for c in prefix)
+
+        regexp = QRegularExpression(regExStr)
+        if self._sensitivity == Qt.CaseSensitivity.CaseInsensitive:
+            regexp.setPatternOptions(
+                QRegularExpression.PatternOption.CaseInsensitiveOption
+            )
+        if regexp != self.filterModel.filterRegularExpression():
             self.filterModel.setFilterRegularExpression(regexp)
-        else:
-            regexp = QRegExp(regExStr, self._sensitivity)
-            self.filterModel.setFilterRegExp(regexp)
 
     def clear(self):
         self.popup().hide()

{preditor-2.7.0 → preditor-2.9.0}/preditor/gui/console.py

@@ -135,6 +135,7 @@ class ConsolePrEdit(ConsoleBase):
 
     def clear(self):
         """clears the text in the editor"""
+        self._pending_writes = []
         super(ConsoleBase, self).clear()
         self.startInputLine()
         # Note: Don't use the regular `super()` call here as it would result
@@ -483,15 +484,18 @@ class ConsolePrEdit(ConsoleBase):
                         self.controller
                         and self.controller.uiHighlightExactCompletionCHK.isChecked()
                     ):
-                        for i in range(completer.completionCount()):
-                            completer.setCurrentRow(i)
-                            curCompletion = completer.currentCompletion()
-                            if prefix == curCompletion:
-                                index = model.index(i, 0)
-                                break
-                            elif prefix == curCompletion.lower():
-                                index = model.index(i, 0)
-                                break
+                        # Find the first completion that equals prefix. Let Qt
+                        # search the model, as checking each row from python is
+                        # slow for large lists.
+                        flags = Qt.MatchFlag.MatchFixedString
+                        if prefix != prefix.lower():
+                            # Handle lowercase options
+                            flags |= Qt.MatchFlag.MatchCaseSensitive
+                        matches = model.match(
+                            index, Qt.ItemDataRole.DisplayRole, prefix, 1, flags
+                        )
+                        if matches:
+                            index = matches[0]
 
                     # Set completer current Row, so finishing the completer will use
                     # correct text
@@ -504,10 +508,7 @@ class ConsolePrEdit(ConsoleBase):
 
                     # show the completer for the rect
                     rect = self.cursorRect()
-                    rect.setWidth(
-                        completer.popup().sizeHintForColumn(0)
-                        + completer.popup().verticalScrollBar().sizeHint().width()
-                    )
+                    rect.setWidth(completer.popupWidth())
                     completer.complete(rect)
 
                 if completer.popup().isVisible():