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

pyqt_code_editor/components/sigmund.py

@@ -0,0 +1,75 @@
+from sigmund_qtwidget.sigmund_widget import SigmundWidget
+from ..widgets import Dock
+from .. import watchdog
+import logging
+logging.basicConfig(level=logging.debug)
+
+
+class EditorWorkspace:
+    def __init__(self, editor_panel):
+        self._editor_panel = editor_panel
+        
+    @property
+    def _editor(self):
+        return self._editor_panel.active_editor()
+    
+    def _normalize_line_breaks(self, text):
+        """Convert paragraph separators (U+2029) to standard newlines."""
+        if text:
+            return text.replace(u'\u2029', '\n')
+        return text
+    
+    @property
+    def content(self):
+        text_cursor = self._editor.textCursor()
+        if text_cursor.hasSelection():
+            return self._normalize_line_breaks(text_cursor.selectedText())
+        return self._editor.toPlainText()
+    
+    @property        
+    def language(self):
+        return self._editor.code_editor_language
+    
+    def get(self):
+        text_cursor = self._editor.textCursor()
+        if text_cursor.hasSelection():
+            return self._normalize_line_breaks(text_cursor.selectedText()), self._editor.code_editor_language
+        return self._editor.toPlainText(), self._editor.code_editor_language
+    
+    def set(self, content, language):
+        text_cursor = self._editor.textCursor()
+        if text_cursor.hasSelection():
+            text_cursor.insertText(content)
+            self._editor.setTextCursor(text_cursor)
+        else:
+            self._editor.setPlainText(content)
+    
+    def has_changed(self, content, language):
+        text_cursor = self._editor.textCursor()
+        if text_cursor.hasSelection():
+            editor_content = self._normalize_line_breaks(text_cursor.selectedText())
+        else:
+            editor_content = self._editor.toPlainText()
+        
+        if not content:
+            return False
+        if content in (editor_content, self.strip_content(editor_content)):
+            return False
+        return True
+    
+    def strip_content(self, content):
+        if content is None:
+            return ''
+        return content
+
+
+class Sigmund(Dock):
+    def __init__(self, parent, editor_panel):
+        super().__init__('Sigmund', parent)
+        self.setObjectName("sigmund")
+        workspace = EditorWorkspace(editor_panel)
+        self.sigmund_widget = SigmundWidget(self)
+        self.sigmund_widget.set_workspace_manager(workspace)
+        self.sigmund_widget.start_server()
+        watchdog.register_subprocess(self.sigmund_widget.server_pid)
+        self.setWidget(self.sigmund_widget)

pyqt_code_editor/components/workspace_explorer.py

@@ -0,0 +1,162 @@
+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 ..widgets import Dock
+
+
+class WorkspaceModel(QAbstractTableModel):
+    """Model to display variables in the workspace"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._data = {}  # Will store the workspace data
+        self._headers = ["Name", "Type", "Value"]
+        self._var_list = []  # List of variable names for easy access
+        
+        # Define type icons - would be properly set in a real implementation
+        self._type_icons = {
+            'int': None,
+            'float': None,
+            'str': None,
+            'list': None,
+            'dict': None,
+            'DataFrame': None
+        }
+        
+    def update_data(self, workspace_data):
+        """Update the model with new workspace data"""
+        self.beginResetModel()
+        self._data = workspace_data
+        self._var_list = list(workspace_data.keys())
+        self.endResetModel()
+        
+    def rowCount(self, parent=QModelIndex()):
+        return len(self._var_list)
+    
+    def columnCount(self, parent=QModelIndex()):
+        return 3  # Name, Type, Value
+    
+    def data(self, index, role=Qt.DisplayRole):
+        if not index.isValid() or index.row() >= len(self._var_list):
+            return None
+        
+        var_name = self._var_list[index.row()]
+        var_data = self._data[var_name]
+        
+        if role == Qt.DisplayRole:
+            if index.column() == 0:
+                return var_name
+            elif index.column() == 1:
+                return var_data['type']
+            elif index.column() == 2:
+                return var_data['preview']
+                
+        elif role == Qt.FontRole:
+            font = QFont()
+            # Make variable names bold
+            if index.column() == 0:
+                font.setBold(True)
+            return font
+            
+        elif role == Qt.BackgroundRole:
+            # Color coding based on variable type
+            type_name = var_data['type']
+            if 'int' in type_name or 'float' in type_name:
+                return QBrush(QColor(240, 248, 255))  # Light blue for numbers
+            elif 'str' in type_name:
+                return QBrush(QColor(255, 248, 240))  # Light orange for strings
+            elif 'list' in type_name or 'tuple' in type_name:
+                return QBrush(QColor(240, 255, 240))  # Light green for sequences
+            
+        return None
+    
+    def headerData(self, section, orientation, role=Qt.DisplayRole):
+        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
+            return self._headers[section]
+        return None
+
+class WorkspaceExplorer(Dock):
+    """Dock widget for exploring variables in the Jupyter workspace"""
+    
+    def __init__(self, parent=None):
+        super().__init__("workspace_explorer", parent)
+        self.setObjectName('workspace_explorer')
+        # Main widget and layout
+        self.main_widget = QWidget(self)
+        self.setWidget(self.main_widget)
+        self.layout = QVBoxLayout(self.main_widget)
+        
+        # Search bar
+        self.search_layout = QHBoxLayout()
+        self.search_input = QLineEdit()
+        self.search_input.setPlaceholderText("Filter …")
+        self.search_layout.addWidget(self.search_input)
+        self.layout.addLayout(self.search_layout)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Table view
+        self.table_view = QTableView()
+        self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table_view.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.table_view.customContextMenuRequested.connect(self._show_context_menu)
+        
+        # Model setup
+        self.model = WorkspaceModel(self)
+        self.proxy_model = QSortFilterProxyModel(self)
+        self.proxy_model.setSourceModel(self.model)
+        self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
+        self.proxy_model.setFilterKeyColumn(-1)  # Search all columns
+        
+        self.table_view.setModel(self.proxy_model)
+        self.layout.addWidget(self.table_view)
+        
+        # Connect search field
+        self.search_input.textChanged.connect(self.proxy_model.setFilterFixedString)
+        
+        # Set up the table appearance
+        header = self.table_view.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.Interactive)  # Name
+        header.setSectionResizeMode(1, QHeaderView.Interactive)  # Type
+        header.setSectionResizeMode(2, QHeaderView.Stretch)      # Value
+        
+        # Initial column widths
+        self.table_view.setColumnWidth(0, 150)  # Name
+        self.table_view.setColumnWidth(1, 100)  # Type
+        
+        # Enable sorting
+        self.table_view.setSortingEnabled(True)
+        
+    def update(self, workspace_data):
+        """Update the view with new workspace data"""
+        self.model.update_data(workspace_data)
+        # Resize rows to content
+        for row in range(self.model.rowCount()):
+            self.table_view.resizeRowToContents(row)
+            
+    def _show_context_menu(self, position):
+        """Show context menu for actions on variables"""
+        menu = QMenu()
+        
+        # Get the variable at cursor position
+        index = self.table_view.indexAt(position)
+        if index.isValid():
+            # Map through proxy model to get the actual variable name
+            source_index = self.proxy_model.mapToSource(index)
+            row = source_index.row()
+            var_name = self.model._var_list[row]
+            
+            # 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)
+            

pyqt_code_editor/mixins/__init__.py

@@ -0,0 +1,15 @@
+from .auto_pair import AutoPair, PythonAutoPair
+from .base import Base
+from .check import Check
+from .comment import Comment
+from .complete import Complete
+from .execute import Execute
+from .file_link import FileLink
+from .line_number import LineNumber
+from .python_auto_indent import PythonAutoIndent
+from .search_replace import SearchReplace
+from .smart_backspace_delete import SmartBackspaceDelete
+from .symbols import Symbols
+from .shortcuts import Shortcuts
+from .theme import Theme
+from .zoom import Zoom

pyqt_code_editor/mixins/auto_pair.py

@@ -0,0 +1,201 @@
+from qtpy.QtCore import Qt
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+
+
+class AutoPair:
+    """
+    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 '\"\"\"')
+      - close_seq: string that is inserted (e.g. ')' or '\"\"\"')
+      - 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": ""},
+        {"open_seq": "{", "close_seq": "}", "inbetween_seq": ""},
+        {"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)
+
+    def keyPressEvent(self, event):
+        cursor = self.textCursor()
+        old_pos = cursor.position()
+        selected_text = cursor.selectedText()
+        
+        # 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():
+                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"]:
+                    new_cursor = self.textCursor()
+                    doc_text = self.toPlainText()
+                    if (new_cursor.position() < len(doc_text) and
+                        doc_text[new_cursor.position()] == 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)
+                break
+
+
+    def _handle_auto_pair_backspace(self) -> bool:
+        """
+        If the cursor is between an exact open_seq and close_seq pair (e.g., '(|)'),
+        remove the full pair. Returns True if handled, False if not.
+        """
+        cursor = self.textCursor()
+        pos = cursor.position()
+        text = self.toPlainText()
+
+        for pair in self.PAIRS:
+            open_seq = pair["open_seq"]
+            close_seq = pair["close_seq"]
+            if open_seq and close_seq:
+                l_open = len(open_seq)
+                l_close = len(close_seq)
+                
+                # Make sure there's enough room before and after the cursor
+                if pos >= l_open and pos + l_close <= len(text):
+                    behind = text[pos - l_open : pos]
+                    ahead = text[pos : pos + l_close]
+
+                    # If the cursor is right between open_seq and close_seq
+                    # with nothing typed in between (e.g. (|))
+                    if behind == open_seq and ahead == close_seq:
+                        c = self.textCursor()
+                        c.beginEditBlock()
+                        # Remove from open_seq start to close_seq end
+                        c.setPosition(pos - l_open)
+                        for _ in range(l_open + l_close):
+                            c.deleteChar()
+                        c.endEditBlock()
+
+                        # Move cursor to the old open_seq start
+                        c.setPosition(pos - l_open)
+                        self.setTextCursor(c)
+                        return True
+        return False
+
+
+    def _insert_pair(self, open_seq, close_seq, inbetween_seq, selected_text):
+        """
+        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).
+        """
+        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_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)
+        
+        logging.info(
+            "Auto-paired '%s' with '%s', inserted in-between '%s'. "
+            "Cursor restored to position %d",
+            open_seq, close_seq, inbetween_seq, old_pos
+        )
+        
+    def _disabled_for_position(self, pos):
+        return False
+
+
+class PythonAutoPair(AutoPair):
+    PAIRS = [
+        # Example triple quotes for Python:
+        {"open_seq": "\"\"\"", "close_seq": "\"\"\"", "inbetween_seq": "\n"}, 
+        {"open_seq": "'''",  "close_seq": "'''",  "inbetween_seq": "\n"},
+        {"open_seq": "(", "close_seq": ")", "inbetween_seq": ""},
+        {"open_seq": "[", "close_seq": "]", "inbetween_seq": ""},
+        {"open_seq": "{", "close_seq": "}", "inbetween_seq": ""},
+        {"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)
+        is (likely) inside a comment in Python code by checking
+        if there's a '#' before the cursor on this line.
+        Otherwise returns False.
+        """
+        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/mixins/base.py

@@ -0,0 +1,142 @@
+from ..worker import manager
+from qtpy.QtCore import QTimer, Signal
+from qtpy.QtGui import QTextCursor
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+active_editor = None
+
+
+class Base:
+    
+    code_editor_file_path = None
+    code_editor_colors = None
+    code_editor_language = 'text'
+    modification_changed = Signal(object, bool)
+    received_focus = Signal(object)
+    
+    def __init__(self, *args, **kwargs):
+        # Optionally set the language. This is mainly for generic editors that
+        # need to support multiple languages. This needs to be stripped from
+        # the kwargs because it's not supported by QPlainTextEdit
+        language = kwargs.pop('language', None)
+        if language is not None:
+            self.code_editor_language = language
+        super().__init__(*args, **kwargs)
+        logger.info("Initializing Base")
+        self.installEventFilter(self)
+        # Poll timer to retrieve results from the worker
+        self._cm_result_queue = None
+        self._cm_worker_pid = None
+        self._cm_poll_timer = QTimer(self)
+        self._cm_poll_timer.setInterval(50)  # 10 times/second
+        self._cm_poll_timer.timeout.connect(self._cm_check_result)
+        self._cm_poll_timer.start()
+        self.code_editor_line_annotations = {}
+        # Keep track of modified status
+        self.modified = False
+        self.modificationChanged.connect(self.set_modified)
+        # Dictionary mapping pid -> result queue
+        self._active_requests = {}        
+        
+    def eventFilter(self, obj, event):
+        """Can be implement in other mixin classes to filter certain events,
+        for example to avoid certain keypresses from being consumed.
+        """
+        return False
+
+    def focusInEvent(self, event):
+        """Allows managing widgets, such as the editor panel, to keep track of
+        which editor is active
+        """
+        super().focusInEvent(event)
+        self.received_focus.emit(self)
+    
+    def refresh(self):
+        """Can be called to indicate that the interface needs to be refreshed,
+        and implement in other mixin classes to handle the actual refresh 
+        logic.
+        """
+        pass
+        
+    def send_worker_request(self, **data):
+        """
+        Send a request to the worker manager. 
+        This returns a unique queue/pid pair each time, 
+        so we can handle multiple concurrent requests.
+        """
+        result_queue, pid = manager.send_worker_request(**data)
+        self._active_requests[pid] = result_queue
+        logger.info(f"Sent request to worker {pid}, now tracking {len(self._active_requests)} active requests.")
+
+    def handle_worker_result(self, action, result):
+        """
+        Subclasses can override this to do specialized handling 
+        for the action & result from the worker process.
+        """
+        pass
+
+    def _cm_check_result(self):
+        """
+        Called periodically (e.g. via a QTimer) to check each active
+        worker's queue. If there's a result, handle it;
+        if the worker died or the result queue is empty, keep polling.
+        """
+        to_remove = []
+        for pid, queue in self._active_requests.items():
+            # 1) Check if the worker is still alive
+            if not manager.check_worker_alive(pid):
+                logger.warning(f"Worker process {pid} no longer alive. Removing from active requests.")
+                to_remove.append(pid)
+                continue
+
+            # 2) If queue is empty, nothing more to do right now
+            if queue.empty():
+                continue
+
+            # 3) Retrieve the result, mark worker free
+            result = queue.get()
+            manager.mark_worker_as_free(pid)
+
+            # 4) Validate result structure
+            if not isinstance(result, dict):
+                logger.info(f"Got invalid response (not a dict) from {pid}: {result}")
+                to_remove.append(pid)
+                continue
+
+            # 5) Extract action and pass it to our handler
+            action = result.pop('action', None)
+            if action is None:
+                logger.info(f"Missing 'action' in worker response: {result}")
+                to_remove.append(pid)
+                continue
+
+            logger.info(f"Received worker result from {pid}: action={action}")
+            self.handle_worker_result(action, result)
+
+            # 6) We're done with this particular request
+            to_remove.append(pid)
+
+        # Cleanup: remove completed or dead requests
+        for pid in to_remove:
+            self._active_requests.pop(pid, None)
+        
+    def set_modified(self, modified):
+        logger.info(f'modified: {modified}')
+        self.document().setModified(modified)
+        self.modified = modified
+        self.modification_changed.emit(self, modified)
+        
+    def jump_to_line(self, line_number=0):
+        cursor = self.textCursor()
+        cursor.movePosition(QTextCursor.Start)
+        cursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, line_number)
+        self.setTextCursor(cursor)
+        self.ensureCursorVisible()
+
+    def update_theme(self):
+        """Mixins can implement this to update the theme in response to font changes
+        etc.
+        """
+        pass

pyqt_code_editor/mixins/check.py

@@ -0,0 +1,94 @@
+import logging; logging.basicConfig(level=logging.INFO, force=True)
+from qtpy.QtWidgets import QWidget, QPlainTextEdit
+from qtpy.QtCore import Qt, QRect, QPoint, QSize, QTimer
+from qtpy.QtGui import QPainter, QColor, QBrush
+logger = logging.getLogger(__name__)
+
+
+class Check:
+    """
+    This is a mixin class that adds code checking / linting powers to a QPlainTextEdit.
+    
+    Now with a debounce mechanism so we don't request checks on every keystroke.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        logger.info("Initializing Check")
+
+        # Where lint issues will be stored once the worker returns them
+        self._issues = []
+
+        # Debounce timer: when the user stops typing for N ms, we trigger the lint action
+        self._check_debounce_timer = QTimer(self)
+        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)
+
+    def _on_code_changed(self):
+        """
+        Called immediately on text changes. Rather than calling
+        the worker here, we restart the debounce timer so that
+        checks won't happen until the user is idle for ~500ms.
+        """
+        if self._check_debounce_timer.isActive():
+            self._check_debounce_timer.stop()
+        self._check_debounce_timer.start()
+
+    def _execute_check(self):
+        """
+        Runs the actual lint check after the debounce period.
+        """
+        code = self.toPlainText()
+        logger.info("Requesting lint check")
+        self.send_worker_request(
+            action='check',
+            code=code,
+            language=getattr(self, "code_editor_language", "python")
+        )
+
+    def handle_worker_result(self, action: str, result):
+        """
+        This is where we receive code-check results from the worker.
+        'action' will be 'check' for lint checks. 'result' is a dict 
+        with a 'messages' key that holds the issues.
+        """
+        super().handle_worker_result(action, result)
+        if action != 'check':
+            return
+        # Clear all previous check annotations
+        self.code_editor_line_annotations = {
+            line_number: annotation for line_number, annotation
+            in self.code_editor_line_annotations.items()
+            if annotation['type'] != 'check'
+        }
+        background_color = QColor(self.code_editor_colors["highlight"])
+        color = QColor(self.code_editor_colors["text"])
+        for line_number, annotations in result['messages'].items():
+            if not annotations:
+                continue
+            # There may be multiple annotations for one line. If so, we use the
+            # code of the first annotation to determine the symbol.
+            if annotations[0].get('code', False):
+                symbol = '➜'
+            else:
+                symbol = '❌'
+            description = '\n'.join([
+                str(annotation['code']) + ': ' + annotation['message']
+                for annotation in annotations
+            ])
+            annotation = {
+                'type': 'check',
+                'text': f'{symbol}{line_number}',
+                'background_color': background_color,
+                'color': color,
+                'tooltip': description
+            }
+            self.code_editor_line_annotations[line_number] = annotation
+        self.repaint()