pyqt-code-editor 0.0.2__tar.gz → 0.0.4__tar.gz

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.2
+Version: 0.0.4
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>
@@ -8,6 +8,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: COPYING
 Requires-Dist: chardet
+Requires-Dist: detect-indent
 Requires-Dist: jedi
 Requires-Dist: mistralai
 Requires-Dist: pathspec

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyproject.toml

@@ -13,6 +13,7 @@ requires-python = ">=3.10"
 dynamic = ["version", "description"]
 dependencies = [
     "chardet",
+    "detect-indent",
     "jedi",
     "mistralai",
     "pathspec",

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.2'
+__version__ = '0.0.4'

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/_settings.py

@@ -82,6 +82,7 @@ class Settings(QObject):
     font_family = SettingProperty('Ubuntu Mono', "Appearance")
     color_scheme = SettingProperty('monokai', "Appearance")
     tab_width = SettingProperty(4, "Appearance")
+    default_indent = SettingProperty('\t', "Appearance")
     word_wrap = SettingProperty(False, "Appearance")
     character_ruler = SettingProperty(80, "Appearance")  # None to disable
     search_replace_background = SettingProperty("#fdff74", "Appearance")

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/app.py

@@ -3,7 +3,7 @@ import sys
 import logging
 from qtpy.QtWidgets import QMainWindow, QShortcut, QMessageBox, \
     QDockWidget, QToolBar, QAction, QApplication
-from qtpy.QtCore import Qt, QByteArray, QSize
+from qtpy.QtCore import Qt, QSize
 from qtpy.QtGui import QKeySequence
 import qtawesome as qta
 from .widgets import QuickOpenFileDialog
@@ -32,6 +32,7 @@ class MainWindow(QMainWindow):
         self.setWindowTitle("Sigmund Analyst")
         # The editor panel provides splittable editor tabs
         self._editor_panel = EditorPanel()
+        self._editor_panel.open_folder_requested.connect(self._open_folder)
         self.setCentralWidget(self._editor_panel)
         self._project_explorers = []
         # Track if project explorers are hidden as a group
@@ -110,28 +111,35 @@ class MainWindow(QMainWindow):
 
         # Connect to dynamically created signals
         signal_router.connect_to_signal("execute_code", self._execute_code)
-        signal_router.connect_to_signal("execute_file", self._execute_file)
+        signal_router.connect_to_signal("execute_file", self._execute_file)        
 
         self._setup_toolbar()
 
-        # If we have no saved geometry/state, hide the docks by default
-        if not settings.window_geometry or not settings.window_state:
-            self._workspace_explorer.hide()
-            self._jupyter_console.hide()
-            self._settings_panel.hide()
-        else:
-            # Restore geometry and state
-            try:
-                geom = QByteArray.fromBase64(
-                    settings.window_geometry.encode('utf-8')
-                )
-                state = QByteArray.fromBase64(
-                    settings.window_state.encode('utf-8')
-                )
-                self.restoreGeometry(geom)
-                self.restoreState(state)
-            except Exception as e:
-                logger.warning(f"Could not restore window geometry/state: {e}")
+        # Restoring the geometry often crashes with a segfault, so for now we 
+        # just use this default
+        # just use this default
+        self._workspace_explorer.hide()
+        self._jupyter_console.hide()
+        self._sigmund.hide()
+        self._settings_panel.hide()
+        # # If we have no saved geometry/state, hide the docks by default
+        # if not settings.window_geometry or not settings.window_state:
+            # self._workspace_explorer.hide()
+            # self._jupyter_console.hide()
+            # self._settings_panel.hide()
+        # else:
+            # # Restore geometry and state
+            # try:
+                # geom = QByteArray.fromBase64(
+                    # settings.window_geometry.encode('utf-8')
+                # )
+                # state = QByteArray.fromBase64(
+                    # settings.window_state.encode('utf-8')
+                # )
+                # self.restoreGeometry(geom)
+                # self.restoreState(state)
+            # except Exception as e:
+                # logger.warning(f"Could not restore window geometry/state: {e}")
 
     def _setup_toolbar(self):
         """Setup the main toolbar with Material Design icons."""
@@ -374,10 +382,14 @@ class MainWindow(QMainWindow):
     def _close_project_explorer(self, project_explorer):
         self._project_explorers.remove(project_explorer)
 
-    def _open_folder(self):
-        project_explorer = ProjectExplorer.open_folder(
-            self._editor_panel, parent=self
-        )
+    def _open_folder(self, path=None):
+        # The event handler may pass a bool argument
+        if path is None or isinstance(path, bool):
+            project_explorer = ProjectExplorer.open_folder(
+                self._editor_panel, parent=self)
+        else:
+            project_explorer = ProjectExplorer(self._editor_panel, path,
+                                               parent=self)
         if project_explorer is None:
             return
         project_explorer.closed.connect(self._close_project_explorer)

pyqt_code_editor-0.0.4/pyqt_code_editor/code_editors/languages/generic.py

@@ -0,0 +1,9 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import Complete, Theme, Zoom, LineNumber, Comment, \
+    AutoIndent, AutoPair, SearchReplace, Base, Check, Shortcuts, FileLink, Symbols
+
+
+class Editor(LineNumber, Zoom, Complete, AutoIndent, AutoPair, Comment,
+             SearchReplace, FileLink, Theme, Check, Shortcuts, Symbols, Base,
+             QPlainTextEdit):
+    pass

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/components/editor_panel.py

@@ -1,7 +1,7 @@
 import os
 from qtpy.QtWidgets import QApplication, QShortcut, QWidget, QHBoxLayout, QFileDialog
 from qtpy.QtGui import QKeySequence
-from qtpy.QtCore import Qt
+from qtpy.QtCore import Qt, Signal
 from ..widgets import TabbedEditor, TabSplitter
 from .. import settings, utils
 import logging
@@ -10,6 +10,9 @@ logger = logging.getLogger(__name__)
 
 
 class EditorPanel(QWidget):
+    
+    open_folder_requested = Signal(str)
+    
     def __init__(self, parent=None, initial_path=None):
         super().__init__(parent)
         logger.info("EditorPanel initialized")
@@ -55,6 +58,7 @@ class EditorPanel(QWidget):
         # Connect the lastTabClosed signal so that we can remove empty panels
         t.lastTabClosed.connect(self.handle_tabbed_editor_empty)
         t.tabCloseRequested.connect(self._relabel_tabs)
+        t.open_folder_requested.connect(self.open_folder_requested)
         return t
     
     def unsaved_changes(self):

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/components/sigmund.py

@@ -1,13 +1,40 @@
 from sigmund_qtwidget.sigmund_widget import SigmundWidget
 from ..widgets import Dock
 from .. import watchdog
+import textwrap
 import logging
-logging.basicConfig(level=logging.debug)
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
 
 
 class EditorWorkspace:
     def __init__(self, editor_panel):
         self._editor_panel = editor_panel
+        self._indentation = ''
+        
+    def _get_indentation(self, content):
+        dedented = textwrap.dedent(content)
+        lines = content.splitlines()
+        dedented_lines = dedented.splitlines()
+    
+        for original_line, dedented_line in zip(lines, dedented_lines):
+            # Skip empty lines
+            if original_line.strip():
+                # Count leading whitespace
+                orig_leading = len(original_line) - len(original_line.lstrip(' \t'))
+                ded_leading = len(dedented_line) - len(dedented_line.lstrip(' \t'))
+                # The difference should be the indentation sequence
+                indentation_length = orig_leading - ded_leading
+                if indentation_length > 0:
+                    return original_line[:indentation_length]
+                return ""
+        # If no non-empty lines, return no indentation
+        return ""
+        
+    def prepare(self, content):
+        if content is None:
+            return content
+        return textwrap.indent(content, self._indentation)                
         
     @property
     def _editor(self):
@@ -33,8 +60,12 @@ class EditorWorkspace:
     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
+            content = self._normalize_line_breaks(text_cursor.selectedText())
+        else:
+            content = self._editor.toPlainText()
+        self._indentation = self._get_indentation(content)
+        logger.info(f'content was indented by "{self._indentation}"')        
+        return content, self._editor.code_editor_language
     
     def set(self, content, language):
         text_cursor = self._editor.textCursor()
@@ -51,8 +82,6 @@ class EditorWorkspace:
         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
@@ -70,13 +99,14 @@ class Sigmund(Dock):
         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)
-        self.visibilityChanged.connect(self._on_visibility_changed)
 
-    def _on_visibility_changed(self, visible):
+    def setVisible(self, visible):
         if visible:
+            logger.info('starting sigmund connector')
             self.sigmund_widget.start_server()
+            watchdog.register_subprocess(self.sigmund_widget.server_pid)
         else:
+            logger.info('stopping sigmund connector')
             self.sigmund_widget.stop_server()
+        super().setVisible(visible)

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/mixins/__init__.py

@@ -1,3 +1,4 @@
+from .auto_indent import AutoIndent
 from .auto_pair import AutoPair, PythonAutoPair
 from .base import Base
 from .check import Check

pyqt_code_editor-0.0.4/pyqt_code_editor/mixins/auto_indent.py

@@ -0,0 +1,267 @@
+from qtpy.QtCore import Qt
+from .. import settings
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+
+
+class AutoIndent:
+    """
+    A generic mixin class to provide auto-indentation features for a QPlainTextEdit.
+    Implements the following specs:
+
+      1. Indentation Style Detection
+         - detect_indentation_style() returns a string representing a single indentation
+           (e.g. '\t' or '    ').
+         - Currently, we return just '\t' by default (dummy implementation).
+
+      2. Multiline Indent/Dedent
+         - Tab in multi-line selection indents those lines by one chunk.
+         - Shift+Tab (or Backtab) dedents those lines.
+
+      3. Preserving Indentation on New Lines
+         - Pressing Enter creates a new line with the same leading indentation
+           (no language-specific logic).
+
+      4. Single-Line Insert or Remove Indentation
+         - Within a single line, Tab inserts one indentation chunk at the cursor location.
+         - Shift+Tab removes up to one indentation chunk from the start of the line if possible.
+
+      5. Handling Backspace and Delete in Leading Whitespace
+         - Backspace/Delete in leading whitespace removes one indentation chunk worth of characters
+           if they match the indentation style (e.g., one tab or up to len(indent_chunk) spaces).
+
+      6. Completely Generic (No Language-Specific Rules)
+         - No indentation changes based on braces, parentheses, or keywords.
+    """
+
+    def detect_indentation_style(self):
+        """
+        Dummy function that always returns a single-tab string for now.
+        Later, this can analyze the document to decide if it should
+        use tabs or spaces (e.g. '    ' for four spaces).
+        """
+        from detect_indent import detect_indent
+        
+        indent = detect_indent(self.toPlainText())
+        if indent['type'] is None:
+            return settings.default_indent
+        return indent['indent']
+
+    def keyPressEvent(self, event):
+        key = event.key()
+        modifiers = event.modifiers()
+        logging.info("keyPressEvent: key=%s, modifiers=%s", key, modifiers)
+
+        # Check for Tab/Shift+Tab indentation
+        if key == Qt.Key_Tab and modifiers == Qt.NoModifier:
+            logging.info("Tab pressed -> indent code")
+            self.indent_code()
+            return
+        elif (key == Qt.Key_Tab and modifiers == Qt.ShiftModifier) or key == Qt.Key_Backtab:
+            logging.info("Shift+Tab pressed -> dedent code")
+            self.dedent_code()
+            return
+
+        # Handle backspace in leading indentation
+        if key == Qt.Key_Backspace and modifiers == Qt.NoModifier:
+            if self._handle_backspace():
+                return
+
+        # Handle delete in leading indentation
+        if key == Qt.Key_Delete and modifiers == Qt.NoModifier:
+            if self._handle_delete():
+                return
+
+        # Check for Enter/Return (preserve indentation)
+        if key in (Qt.Key_Enter, Qt.Key_Return):
+            logging.info("Enter/Return pressed -> preserve indentation on new line")
+            cursor = self.textCursor()
+
+            # Get leading whitespace of the current line
+            block_text = cursor.block().text()
+            leading_ws = len(block_text) - len(block_text.lstrip(' \t'))
+            preserve_ws = block_text[:leading_ws]
+
+            # Perform normal newline
+            super().keyPressEvent(event)
+
+            # Insert the same leading whitespace on the new line
+            cursor.insertText(preserve_ws)
+            self.setTextCursor(cursor)
+            return
+
+        # Default behavior for any other keys
+        super().keyPressEvent(event)
+
+    def _get_indent_string(self):
+        """
+        Returns the indentation chunk based on detect_indentation_style().
+        By default, this is a single tab ('\t') but could be '    ' for spaces, etc.
+        """
+        return self.detect_indentation_style()
+
+    def _is_multiline_selection(self):
+        """
+        Returns True if selection spans more than one line, else False.
+        """
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+        return end_block > start_block
+
+    def indent_code(self):
+        """
+        Indent either the selected lines (if multi-line selection)
+        or just the current cursor position (if single-line).
+        """
+        logging.info("indent_code triggered")
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+
+        if self._is_multiline_selection():
+            logging.info("Multi-line selection -> indent each line")
+            self._indent_selection()
+        else:
+            logging.info("Single line -> insert indent at cursor")
+            indent_str = self._get_indent_string()
+            cursor.insertText(indent_str)
+
+        cursor.endEditBlock()
+
+    def dedent_code(self):
+        """
+        Dedent either the selected lines (if multi-line selection)
+        or just the current line (if single-line).
+        """
+        logging.info("dedent_code triggered")
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+
+        if self._is_multiline_selection():
+            logging.info("Multi-line selection -> dedent each line")
+            self._dedent_selection()
+        else:
+            logging.info("Single line -> remove up to one indent chunk from start")
+            line_start = cursor.block().position()
+            line_text = cursor.block().text()
+            leading_ws = len(line_text) - len(line_text.lstrip(' \t'))
+
+            chunk_size = self._compute_chunk_size()
+            remove_chars = min(chunk_size, leading_ws)
+            logging.info("Removing up to %d chars from leading whitespace", remove_chars)
+
+            cursor.setPosition(line_start)
+            for _ in range(remove_chars):
+                self._delete_forward_if_tab_or_space(cursor)
+
+        cursor.endEditBlock()
+
+    def _indent_selection(self):
+        """
+        Increase indent for each selected line by one chunk.
+        """
+        logging.info("indent_selection (multi-line)")
+        indent_str = self._get_indent_string()
+
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+
+        for block_num in range(start_block, end_block + 1):
+            block = self.document().findBlockByNumber(block_num)
+            tmp_cursor = self.textCursor()
+            tmp_cursor.setPosition(block.position())
+            tmp_cursor.insertText(indent_str)
+
+    def _dedent_selection(self):
+        """
+        Decrease indent for each selected line by one chunk,
+        ensuring we don't go below zero indentation.
+        """
+        logging.info("dedent_selection (multi-line)")
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+
+        for block_num in range(start_block, end_block + 1):
+            block = self.document().findBlockByNumber(block_num)
+            line_text = block.text()
+            leading_ws = len(line_text) - len(line_text.lstrip(' \t'))
+
+            chunk_size = self._compute_chunk_size()
+            remove_chars = min(chunk_size, leading_ws)
+
+            tmp_cursor = self.textCursor()
+            tmp_cursor.setPosition(block.position())
+            for _ in range(remove_chars):
+                self._delete_forward_if_tab_or_space(tmp_cursor)
+
+    def _handle_backspace(self):
+        """
+        If the cursor is in leading indentation, remove one indentation chunk
+        (based on the length of detect_indentation_style()).
+        Returns True if handled, False otherwise.
+        """
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
+            block_text = cursor.block().text()
+            pos_in_block = cursor.positionInBlock()
+            leading_ws = len(block_text) - len(block_text.lstrip(' \t'))
+
+            # Only if we're in the leading whitespace region:
+            if 0 < pos_in_block <= leading_ws:
+                chunk_size = self._compute_chunk_size()
+                remove_count = min(chunk_size, pos_in_block)
+                logging.info("Backspace in leading whitespace -> removing %d chars", remove_count)
+
+                for _ in range(remove_count):
+                    cursor.deletePreviousChar()
+                return True
+        return False
+
+    def _handle_delete(self):
+        """
+        If the cursor is in leading indentation, remove one indentation chunk going forward.
+        Returns True if handled, False otherwise.
+        """
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
+            block_text = cursor.block().text()
+            pos_in_block = cursor.positionInBlock()
+            leading_ws = len(block_text) - len(block_text.lstrip(' \t'))
+
+            if pos_in_block < leading_ws:
+                chunk_size = self._compute_chunk_size()
+                remove_count = min(chunk_size, leading_ws - pos_in_block)
+                logging.info("Delete in leading whitespace -> removing %d chars", remove_count)
+
+                for _ in range(remove_count):
+                    cursor.deleteChar()
+                return True
+        return False
+
+    def _compute_chunk_size(self):
+        """
+        Returns the length of the indentation chunk returned by detect_indentation_style().
+        For example, if detect_indentation_style() returns '\t', the size is 1;
+        if it returns '    ', the size is 4, etc.
+        """
+        chunk = self.detect_indentation_style()
+        return len(chunk)
+
+    def _delete_forward_if_tab_or_space(self, cursor):
+        """
+        Deletes one character if it is a space or a tab in leading whitespace.
+        (We remove characters one by one for partial or exact chunk removal.)
+        """
+        ch = cursor.document().characterAt(cursor.position())
+        if ch in (' ', '\t'):
+            cursor.deleteChar()

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/mixins/symbols.py

@@ -31,7 +31,7 @@ class Symbols:
     def handle_worker_result(self, action, result):
         """Check for completion or calltip results from the external worker."""
         super().handle_worker_result(action, result)
-        if action != 'symbols':
+        if action != 'symbols' or not result.get('symbols', False):
             return
         QuickSymbolDialog(self, result['symbols'], self.jump_to_symbol).exec()
         

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/python_utils.py

@@ -821,12 +821,12 @@ def extract_cells_from_code(code: str) -> list:
     # Store all detected cells
     cells = []
     
-    # Track the current position
-    current_pos = 0
-    
     # Define regex patterns for cell markers
     marker_pattern = re.compile(r'^(# %%|#%%|# In\[\]:?).*?$', re.MULTILINE)
-    triple_quotes_pattern = re.compile(r'(""".*?"""|\'\'\'.*?\'\'\')', re.DOTALL)
+    triple_quotes_pattern = re.compile(
+        r'(?m)^(""".*?"""|\'\'\'.*?\'\'\')',
+        re.DOTALL
+    )
     
     # Find all marker-based cells
     marker_matches = list(marker_pattern.finditer(code))

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/syntax_highlighters/syntax_highlighter.py

@@ -5,11 +5,19 @@ logging.basicConfig(level=logging.INFO, force=True)
 logger = logging.getLogger(__name__)
 module_cache = {}
 
+# Some lexers have weird names that are not recognized by get_lexer_by_name().
+# Often this seems to be a matter of discarding a suffix after a space or /
+# This may not be a foolproof solution.
+LANGUAGE_SEPARATORS = ' ', '/'
     
 def create_syntax_highlighter(language, *args, **kwargs):
-    try:
+    for ch in LANGUAGE_SEPARATORS:
+        if ch in language:
+            logger.info(f'mapping {language} to {language[:language.find(ch)]}')
+            language = language[:language.find(ch)]
+    try:        
         lexer = get_lexer_by_name(language)
-    except:
+    except Exception:
         lexer = get_lexer_by_name('markdown')
     if language not in module_cache:
         try:

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/widgets/quick_symbol_dialog.py

@@ -1,4 +1,3 @@
-import os
 import logging
 from . import QuickOpenDialog
 logger = logging.getLogger(__name__)

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/widgets/tabbed_editor.py

@@ -110,6 +110,7 @@ class DraggableTabBar(QTabBar):
 class TabbedEditor(QTabWidget):
     """A tab widget that can hold multiple CodeEditor instances."""
     lastTabClosed = Signal(QTabWidget)
+    open_folder_requested = Signal(str)
     
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -312,7 +313,12 @@ class TabbedEditor(QTabWidget):
         if event.mimeData().hasUrls():
             for url in event.mimeData().urls():
                 path = url.toLocalFile()
-                self.add_code_editor(path)
+                # If path is a folder, open a code editor, otherwise emit the
+                # open_folder signal
+                if os.path.isdir(path):
+                    self.open_folder_requested.emit(path)
+                else:
+                    self.add_code_editor(path)
         
         if not event.mimeData().hasFormat("application/x-tabdata"):
             event.ignore()
@@ -325,7 +331,6 @@ class TabbedEditor(QTabWidget):
         dataByteArray = event.mimeData().data("application/x-tabdata")
         stream = QDataStream(dataByteArray, QDataStream.ReadOnly)
         tabText = stream.readQString()
-        hasIcon = stream.readBool()
         # (We ignore the icon detail in this example or simply set a blank icon.)
         # If you’re handing around pixmaps, you could store them more explicitly.
 

{pyqt_code_editor-0.0.2 → pyqt_code_editor-0.0.4}/pyqt_code_editor/worker/process.py

@@ -49,7 +49,7 @@ def main_worker_process_function(request_queue, result_queue):
             try:
                 worker_functions = importlib.import_module(
                     f".languages.{language}", package=__package__)
-            except ImportError as e:
+            except ImportError:
                 from .languages import generic as worker_functions
                 logger.info(f'failed to load worker functions for {language}, falling back to generic')
             else:
@@ -84,11 +84,11 @@ def main_worker_process_function(request_queue, result_queue):
             })
 
         elif action == 'calltip':
+            cursor_pos = request.get('cursor_pos', 0)
             if worker_functions.calltip is None:
                 signatures = None
             else:
                 code = request.get('code', '')
-                cursor_pos = request.get('cursor_pos', 0)
                 path = request.get('path', None)
                 logger.info(f"Performing calltip: language='{language}', path={path}")
                 signatures = worker_functions.calltip(
@@ -105,7 +105,7 @@ def main_worker_process_function(request_queue, result_queue):
                 
         elif action == 'symbols':
             if worker_functions.symbols is None:
-                check_results = []
+                symbols_results = []
             else:
                 code = request.get('code', '')
                 symbols_results = worker_functions.symbols(code)

pyqt_code_editor-0.0.2/pyqt_code_editor/code_editors/languages/generic.py

@@ -1,11 +0,0 @@
-from qtpy.QtWidgets import QPlainTextEdit
-from pyqt_code_editor.mixins import Complete, \
-    Theme, Zoom, LineNumber, Comment, \
-    AutoPair, SearchReplace, Base, Check, Shortcuts, FileLink, Symbols
-
-
-class Editor(LineNumber, Zoom, Complete, AutoPair,
-             Comment, SearchReplace, FileLink,
-             Theme, Check, Shortcuts, Symbols, Base,
-             QPlainTextEdit):
-    pass