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

pyqt_code_editor/signal_router.py

@@ -0,0 +1,116 @@
+import inspect
+from qtpy.QtCore import QObject, Signal
+import logging
+
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+class SignalRouter(QObject):
+    """
+    A central signal router that dynamically discovers and forwards signals.
+    """
+    # Generic signal that forwards all signals with metadata
+    signal_triggered = Signal(str, object)
+    
+    def __init__(self):
+        super().__init__()
+        self._registered_widgets = set()
+        self._signal_map = {}  # Maps signal names to widgets
+        self._connections = {}  # Maps widget IDs to connection info
+        logger.info("Signal router initialized")
+        
+    def register_widget(self, widget):
+        """Register a widget and all its signals for routing"""
+        if widget in self._registered_widgets:
+            return
+            
+        self._registered_widgets.add(widget)
+        widget_id = id(widget)
+        self._connections[widget_id] = []
+        
+        # Connect to destroyed signal for auto cleanup
+        widget.destroyed.connect(lambda: self.unregister_widget(widget))
+        
+        logger.info(f"Registering widget {widget.__class__.__name__} for signal routing")
+        
+        # Discover all signals in the widget
+        for name, obj in inspect.getmembers(widget.__class__):
+            if isinstance(obj, Signal):
+                logger.info(f"  Discovered signal: {name}")
+                self._signal_map[name] = self._signal_map.get(name, []) + [widget]
+                
+                # Create a forwarder function that will be connected to the signal
+                def create_forwarder(signal_name=name):
+                    forwarder = lambda *args: self.signal_triggered.emit(signal_name, args)
+                    return forwarder
+                
+                forwarder = create_forwarder()
+                
+                # Connect the widget's signal to our forwarder
+                try:
+                    signal = getattr(widget, name)
+                    signal.connect(forwarder)
+                    
+                    # Store connection information for cleanup
+                    self._connections[widget_id].append({
+                        'signal': signal,
+                        'slot': forwarder,
+                        'name': name
+                    })
+                except (RuntimeError, TypeError) as e:
+                    logger.warning(f"Failed to connect to signal {name}: {e}")
+    
+    def unregister_widget(self, widget):
+        """Unregister a widget and disconnect all its signals"""
+        widget_id = id(widget)
+        
+        if widget_id in self._connections:
+            logger.info(f"Unregistering widget {widget.__class__.__name__}")
+            
+            # Disconnect all signals from this widget
+            for connection in self._connections[widget_id]:
+                try:
+                    connection['signal'].disconnect(connection['slot'])
+                    logger.debug(f"Disconnected signal {connection['name']}")
+                except (RuntimeError, TypeError):
+                    # Signal might already be disconnected or invalid
+                    pass
+            
+            # Clean up our data structures
+            del self._connections[widget_id]
+            
+            # Update signal map to remove this widget
+            for signal_name, widgets in list(self._signal_map.items()):
+                self._signal_map[signal_name] = [w for w in widgets if id(w) != widget_id]
+                # Remove empty entries
+                if not self._signal_map[signal_name]:
+                    del self._signal_map[signal_name]
+            
+            # Try to remove from registered widgets
+            try:
+                self._registered_widgets.remove(widget)
+            except KeyError:
+                pass
+        
+    def connect_to_signal(self, signal_name, slot):
+        """
+        Connect a slot to a specific named signal from any registered widget
+        """
+        def filtered_forwarder(name, args):
+            if name == signal_name:
+                # Use *args to unpack the arguments
+                if len(args) == 1:
+                    slot(args[0])
+                else:
+                    slot(*args)
+                    
+        self.signal_triggered.connect(filtered_forwarder)
+        logger.info(f"Connected external slot to '{signal_name}' signal")
+        
+    def get_available_signals(self):
+        """Return a list of all available signals from registered widgets"""
+        return list(self._signal_map.keys())
+
+
+signal_router = SignalRouter()

pyqt_code_editor/syntax_highlighters/languages/generic.py

@@ -0,0 +1,86 @@
+from pygments.styles import get_style_by_name
+from pygments.formatters.html import HtmlFormatter
+from qtpy.QtGui import QSyntaxHighlighter, QTextCharFormat, QBrush, QColor, QFont
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+class SyntaxHighlighter(QSyntaxHighlighter):
+    """
+    A standalone syntax highlighter that uses Pygments to highlight code
+    in a QTextDocument. Merged from the original SyntaxHighlighter and
+    PygmentsSH, removing PyQode dependencies and extra logic.
+    """
+
+    def __init__(self, document, lexer, color_scheme=None):
+        super().__init__(document)
+        self._lexer = lexer
+        # If you have a custom ColorScheme, adapt here.
+        # If color_scheme is a string, interpret it as a Pygments style name:
+        self._color_scheme_name = color_scheme or "default"
+
+        # Prepare a style from Pygments
+        self._setup_style()
+        self._token_formats = {}
+        self._in_multiline_string = {}
+
+    def _setup_style(self):
+        """Initialize the Pygments style objects."""
+        try:
+            self._style = get_style_by_name(self._color_scheme_name)
+        except Exception:
+            logger.error(f"[PygmentsSyntaxHighlighter] style '{self._color_scheme_name}' not found")
+            self._style = get_style_by_name("default")
+        self._formatter = HtmlFormatter(style=self._style)
+
+    def highlightBlock(self, text):
+        """
+        Called automatically by QSyntaxHighlighter for each line in the document.
+        We tokenize the line with Pygments, then apply the relevant formats.
+        """
+        tokens = list(self._lexer.get_tokens(text))
+
+        index = 0
+        for token_type, token_text in tokens:
+            length = len(token_text)
+            fmt = self._get_format(token_type)
+            self.setFormat(index, length, fmt)
+            index += length
+    
+
+    def _get_format(self, token_type):
+        """
+        Retrieve (or create) a QTextCharFormat for the given Pygments token type.
+        """
+        if token_type in self._token_formats:
+            return self._token_formats[token_type]
+
+        fmt = QTextCharFormat()
+        style_defs = self._style.style_for_token(token_type)
+
+        if style_defs['color']:
+            color_str = style_defs['color']
+            fmt.setForeground(self._make_brush(color_str))
+        if style_defs['bgcolor']:
+            bg_color_str = style_defs['bgcolor']
+            fmt.setBackground(self._make_brush(bg_color_str))
+        if style_defs['bold']:
+            fmt.setFontWeight(QFont.Bold)
+        if style_defs['italic']:
+            fmt.setFontItalic(True)
+        if style_defs['underline']:
+            fmt.setUnderlineStyle(QTextCharFormat.SingleUnderline)
+
+        self._token_formats[token_type] = fmt
+        return fmt
+
+    def _make_brush(self, color_str):
+        """Convert a hex string (e.g. 'fff' or 'ffffff') to a QBrush."""
+        color_str = color_str.lstrip('#')
+        if len(color_str) == 3:
+            color_str = ''.join(ch * 2 for ch in color_str)
+        red = int(color_str[0:2], 16)
+        green = int(color_str[2:4], 16)
+        blue = int(color_str[4:6], 16)
+        return QBrush(QColor(red, green, blue))

pyqt_code_editor/syntax_highlighters/languages/python.py

@@ -0,0 +1,62 @@
+from pygments.token import Token
+import logging
+from .generic import SyntaxHighlighter as GenericSyntaxHighlighter
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+class SyntaxHighlighter(GenericSyntaxHighlighter):
+    """Extends the default highlighter with support for multiline strings."""
+    
+    def highlightBlock(self, text):
+        """
+        1) Determine if this line starts as 'in' or 'out' of a triple-quoted string
+           from the previous block's state.
+        2) Scan for triple-quote transitions, toggling in/out state.
+        3) If in triple-quote mode, highlight everything as a string, else use normal
+           Pygments highlighting for this line.
+        4) Use self.setCurrentBlockState(...) to mark the final state for this line, so
+           that QSyntaxHighlighter can handle subsequent lines correctly.
+        """
+    
+        # old_state is typically -1 for the very first block, otherwise what we last set
+        old_state = self.previousBlockState()
+        previously_in_string = (old_state == 1)
+        currently_in_string = previously_in_string
+    
+        # Search line text for triple quotes
+        triple_quotes = ('"""', "'''")
+        idx = 0
+        while True:
+            next_quote_pos = -1
+            found_quote = None
+            for quote in triple_quotes:
+                pos = text.find(quote, idx)
+                if pos != -1 and (next_quote_pos == -1 or pos < next_quote_pos):
+                    next_quote_pos = pos
+                    found_quote = quote
+    
+            if next_quote_pos == -1:
+                # No more triple quotes in this line
+                break
+            else:
+                # Toggle the multiline string state
+                currently_in_string = not currently_in_string
+                # Move index past the found triple quotes
+                idx = next_quote_pos + len(found_quote)
+    
+        if currently_in_string:
+            # Highlight the entire line as string
+            string_format = self._get_format(Token.String)
+            self.setFormat(0, len(text), string_format)
+            self.setCurrentBlockState(1)
+        else:
+            # Use normal Pygments line-by-line highlighting
+            tokens = list(self._lexer.get_tokens(text))
+            index = 0
+            for token_type, token_text in tokens:
+                token_len = len(token_text)
+                fmt = self._get_format(token_type)
+                self.setFormat(index, token_len, fmt)
+                index += token_len
+            self.setCurrentBlockState(0)    

pyqt_code_editor/syntax_highlighters/syntax_highlighter.py

@@ -0,0 +1,26 @@
+import importlib
+import logging
+from pygments.lexers import get_lexer_by_name
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+module_cache = {}
+
+    
+def create_syntax_highlighter(language, *args, **kwargs):
+    try:
+        lexer = get_lexer_by_name(language)
+    except:
+        lexer = get_lexer_by_name('markdown')
+    if language not in module_cache:
+        try:
+            module = importlib.import_module(
+                f".languages.{language}", package=__package__)
+        except ImportError:
+            from .languages import generic as module
+            logger.info(f'failed to load syntax highlighter module for {language}, falling back to generic')
+        else:
+            logger.info(f'loaded editor module for {language}')
+        module_cache[language] = module
+    else:
+        module = module_cache[language]        
+    return module.SyntaxHighlighter(*args, lexer=lexer, **kwargs)

pyqt_code_editor/themes.py

@@ -0,0 +1,36 @@
+THEMES = {
+    'light': {
+        'background_color': '#FFFFFF',
+        'text_color': '#000000',
+        'selection_background': '#ADD6FF',
+        'selection_color': '#000000',
+    },
+    'dark': {
+        'background_color': '#1E1E1E',
+        'text_color': '#D4D4D4',
+        'selection_background': '#264F78',
+        'selection_color': '#FFFFFF',
+    },
+    'monokai': {
+        'background_color': '#272822',
+        'text_color': '#F8F8F2',
+        'selection_background': '#49483E',
+        'selection_color': '#F8F8F2',
+    },
+    'solarized_light': {
+        'background_color': '#FDF6E3',
+        'text_color': '#657B83',
+        'selection_background': '#EEE8D5',
+        'selection_color': '#586E75',
+    },
+    'solarized_dark': {
+        'background_color': '#002B36',
+        'text_color': '#839496',
+        'selection_background': '#073642',
+        'selection_color': '#93A1A1',
+    }
+}
+
+OUTER_CONTENT_MARGINS = [6, 6, 6, 6]
+HORIZONTAL_SPACING = 6
+VERTICAL_SPACING = 12

pyqt_code_editor/utils.py

@@ -0,0 +1,96 @@
+import os
+from pygments.lexers import guess_lexer_for_filename
+from pygments.util import ClassNotFound
+
+
+def guess_language_from_path(filepath):
+    """
+    Detect programming language for a given file using Pygments.
+    Returns a lowercase string, e.g. 'python', or falls back to 'text'.
+    """
+    if filepath is None:
+        return 'text'
+    try:
+        # Read entire file as text (note: could be slow for very large files)
+        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+            contents = f.read()
+
+        # Attempt to guess language
+        lexer = guess_lexer_for_filename(filepath, contents)
+        return lexer.name.lower()
+    except (FileNotFoundError, ClassNotFound, UnicodeDecodeError):
+        # If file doesn't exist or we can't guess the language,
+        # we fall back to 'text'
+        return 'text'
+
+
+def shorten_paths(paths):
+    """
+    Given a list of file paths, return a list of shortened names that are unique,
+    but only as long as necessary. Files sharing the same base name will get
+    additional path components prepended from the right until they are unique.
+    """
+    
+    # Split into lists of path components. We also note if the path is absolute.
+    splitted = []
+    for p in paths:
+        # On some systems, you might want to use os.path.normpath first:
+        # p = os.path.normpath(p)
+        is_abs = p.startswith(os.path.sep)
+        parts = p.strip(os.path.sep).split(os.path.sep)
+        splitted.append((is_abs, parts))
+    
+    # Group by base name (last component)
+    from collections import defaultdict
+    base_map = defaultdict(list)
+    for i, (is_abs, parts) in enumerate(splitted):
+        base_map[parts[-1]].append(i)  # group by last component
+    
+    # For each group of files sharing the same base name, expand as necessary
+    expansions = [1] * len(splitted)  # how many path parts (from the right) we are using
+    
+    def make_short_name(is_abs, parts, count):
+        """
+        Produce the short name using the last `count` components.
+        If the original path was absolute and we use more than 1 component, we
+        add a leading slash. (You can tweak this logic as desired.)
+        """
+        selected = parts[-count:]
+        return "/".join(selected)
+
+    
+    for base_name, indices in base_map.items():
+        if len(indices) == 1:
+            # No conflict, no need to expand
+            continue
+        # We have multiple files with the same base name
+        # so keep expanding path components until unique
+        done = False
+        while not done:
+            # Build short names for all members
+            used_names = {}
+            collisions = False
+            for idx in indices:
+                is_abs, parts = splitted[idx]
+                short = make_short_name(is_abs, parts, expansions[idx])
+                if short in used_names:
+                    collisions = True  # we have a collision
+                used_names[short] = idx
+            if collisions:
+                # Increase expansions for all in this group
+                for idx in indices:
+                    expansions[idx] = min(expansions[idx] + 1, len(splitted[idx][1])) 
+                # If expansions reach the entire path length, it can't expand further.
+                # Next loop check might still find collisions if two paths are identical.
+            else:
+                done = True
+    
+    # Now build the final short names
+    results = []
+    for i, (is_abs, parts) in enumerate(splitted):
+        count = expansions[i]
+        short = make_short_name(is_abs, parts, count)
+        results.append(short)
+    
+    return results
+

pyqt_code_editor/watchdog.py

@@ -0,0 +1,141 @@
+"""This module implements a watchdog that ensures that subprocess are killed
+when the main process is no longer alive. It does so by starting a separate
+watchdog process that occasionally checks whether the main process is still
+alive.
+
+To handle unexpected crashes of the application, it periodically checks whether
+the main process is still alive. When the main process has died, it first kills
+all registerd subprocesses, and then shuts itself down. 
+
+To handle clean application exist, it also listens for an explicit shutdown
+signal, in which case it does the same.
+
+In all cases, the watchdog should make sure that no subprocesses, including 
+itself, stay alive after the main process has died.
+"""
+import multiprocessing as mp
+import os
+import signal
+import sys
+import time
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+# Global variables
+_main_pid = os.getpid()
+logger.info(f'main process is {_main_pid}')
+_watchdog_process = None
+_conn = None
+_registered_pids = set()
+_CHECK_INTERVAL = 1.0  # seconds
+
+
+def _watchdog_main(main_pid, child_conn):
+    """The main function of the watchdog process."""
+    
+    registered_pids = set()
+    
+    while True:
+        # Check if main process is still alive
+        if not _is_process_alive(main_pid):
+            logger.info("watchdog: Main process died, killing all subprocesses")
+            _kill_all_processes(registered_pids)
+            sys.exit(0)
+        
+        # Check for messages from the main process
+        if child_conn.poll():
+            msg = child_conn.recv()
+            if msg["command"] == "shutdown":
+                logger.info("watchdog: Received shutdown command")
+                _kill_all_processes(registered_pids)
+                sys.exit(0)
+            elif msg["command"] == "register":
+                pid = msg["pid"]
+                if pid not in registered_pids:
+                    registered_pids.add(pid)
+                    logger.info(f"watchdog: Registered subprocess {pid}")
+        
+        time.sleep(_CHECK_INTERVAL)
+
+
+def _is_process_alive(pid):
+    """Check if a process with the given pid is alive."""
+    try:
+        # Sending signal 0 checks if process exists without affecting it
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _kill_all_processes(pids):
+    """Kill all processes with the given pids."""
+    for pid in pids:
+        try:
+            # Try SIGTERM first
+            os.kill(pid, signal.SIGTERM)
+            logger.info(f"watchdog: Sent SIGTERM to {pid}")
+        except OSError:
+            pass
+    
+    # Give processes time to exit gracefully
+    time.sleep(0.5)
+    
+    # Force kill any remaining processes
+    for pid in pids:
+        try:
+            if _is_process_alive(pid):
+                os.kill(pid, signal.SIGKILL)
+                logger.info(f"watchdog: Sent SIGKILL to {pid}")
+        except OSError:
+            pass
+
+
+def _ensure_watchdog_running():
+    """Ensure that the watchdog process is running."""
+    global _watchdog_process, _conn
+    
+    if _watchdog_process is None and _main_pid is not None:
+        parent_conn, child_conn = mp.Pipe()
+        _watchdog_process = mp.Process(
+            target=_watchdog_main,
+            args=(_main_pid, child_conn),
+            name="watchdog-process"
+        )
+        _watchdog_process.start()
+        _conn = parent_conn
+        logger.info(f"watchdog: Started watchdog process with PID {_watchdog_process.pid}")
+
+
+def set_main_process(pid: int):
+    """Sets the main process pid. This does not yet launch the watchdog process."""
+    global _main_pid
+    _main_pid = pid
+    
+    
+def register_subprocess(pid: int):
+    """If no watchdog process is running, this is launched now. The pid is
+    registered with the watchdog.    
+    """
+    global _registered_pids
+    
+    if _main_pid is None:
+        raise RuntimeError("Main process PID not set. Call set_main_process() first.")
+    
+    _ensure_watchdog_running()
+    _registered_pids.add(pid)
+    
+    # Send registration to watchdog process
+    if _conn is not None:
+        _conn.send({"command": "register", "pid": pid})
+    
+
+def shutdown():
+    """Explicitly tell the watchdog to kill all subprocesses."""
+    logger.info('shutdown')
+    if _conn is not None:
+        _conn.send({"command": "shutdown"})
+        # Give watchdog time to process the shutdown command
+        time.sleep(0.1)

pyqt_code_editor/widgets/__init__.py

@@ -0,0 +1,6 @@
+from .quick_open_dialog import QuickOpenDialog
+from .quick_open_file_dialog import QuickOpenFileDialog
+from .quick_symbol_dialog import QuickSymbolDialog
+from .tabbed_editor import TabbedEditor
+from .tab_splitter import TabSplitter
+from .dock import Dock

pyqt_code_editor/widgets/calltip_widget.py

@@ -0,0 +1,44 @@
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QFrame, QLabel, QVBoxLayout
+from .. import settings
+
+
+class CalltipWidget(QFrame):
+    """
+    A small persistent widget to show calltip text so it won't vanish
+    until explicitly hidden (unlike QToolTip).
+    """
+    def __init__(self, editor):
+        # We set window flags separately (cannot OR widget attributes).
+        super().__init__(editor)
+        self.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
+        # WA_ShowWithoutActivating means the widget won’t take focus
+        self.setAttribute(Qt.WA_ShowWithoutActivating)
+        # Make background translucent (use setAttribute):
+        self.setAttribute(Qt.WA_TranslucentBackground, True)
+        self.apply_stylesheet()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(8, 4, 8, 4)
+        self._label = QLabel(self)
+        self._label.setTextFormat(Qt.RichText)
+        self._label.setWordWrap(True)
+        layout.addWidget(self._label)
+        self.setLayout(layout)
+
+    def setText(self, text):
+        self._label.setText(text)
+        self.adjustSize()
+
+    def apply_stylesheet(self):
+        editor = self.parent()
+        if editor.code_editor_colors is not None:
+            self.setStyleSheet(f'''QFrame {{
+                color: {editor.code_editor_colors['text']};
+                background-color: {editor.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+                border-color: {editor.code_editor_colors['border']};
+                border-width: 1px;
+                border-style: solid;
+                border-radius: 4px;
+                padding: 8px;
+            }}''')