Implement code prefix for checking and completion

smathot · smathot · commit 0677c7133e56 · 2025-07-28T15:22:31.000+02:00
- Bump to 0.0.29
diff --git a/examples/example_single_editor.py b/examples/example_single_editor.py
@@ -1,16 +1,18 @@
 import sys
 import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from pyqt_code_editor import watchdog
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 from pyqt_code_editor.code_editors import create_editor
+from pyqt_code_editor.environment_manager import environment_manager
 
 
 class MainWindow(QWidget):
     def __init__(self, path=None):
         super().__init__()
         self.setWindowTitle("PyQtCodeEditor")
         layout = QVBoxLayout()
+        environment_manager.prefix = 'import math'
         self.editor = create_editor(path, parent=self)
         layout.addWidget(self.editor)
         self.setLayout(layout)
diff --git a/pyqt_code_editor/__init__.py b/pyqt_code_editor/__init__.py
@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.28'
+__version__ = '0.0.29'
diff --git a/pyqt_code_editor/environment_manager.py b/pyqt_code_editor/environment_manager.py
@@ -7,30 +7,30 @@ class EnvironmentManager(QObject):
     """Singleton class to share the current environment and language between all
     components of the app.
     """    
-    environment_changed = Signal(str, str, str)
+    environment_changed = Signal(str, str, str, str)
 
     def __init__(self):
         super().__init__()
         self.name = None
         self.path = None
         self.language = None
+        self.prefix = None
 
     @property
     def current_environment(self):
         return self.name, self.path, self.language
 
-    def set_environment(self, name, path, language):
-        path = os.path.abspath(path)
-        if path == self.path:
-            return
-        if not os.path.exists(path):
-            logger.warning(f'no such environment: {path}')
-            return
-        logger.info(f'environment changed: {path}')
-        self.name = name
-        self.path = path
-        self.language = language
-        self.environment_changed.emit(name, path, language)
+    def set_environment(self, name, path, language, prefix=None):
+        if path != self.path:
+            # The path may not exist if the environment is simply python or 
+            # python3, in which case we do not need to specify it at all.
+            if not os.path.exists(path):
+                path = None
+            self.name = name
+            self.path = path
+            self.language = language
+            self.prefix = prefix
+            self.environment_changed.emit(name, path, language, prefix)
 
 
 # Singleton instance
diff --git a/pyqt_code_editor/mixins/check.py b/pyqt_code_editor/mixins/check.py
@@ -1,7 +1,7 @@
-from qtpy.QtWidgets import QWidget, QPlainTextEdit
-from qtpy.QtCore import Qt, QRect, QPoint, QSize, QTimer
-from qtpy.QtGui import QPainter, QColor, QBrush
 import logging
+from qtpy.QtCore import QTimer
+from qtpy.QtGui import QColor
+from ..environment_manager import environment_manager
 logger = logging.getLogger(__name__)
 
 
@@ -50,8 +50,8 @@ def _execute_check(self):
         self.send_worker_request(
             action='check',
             code=code,
-            language=getattr(self, "code_editor_language", "python")
-        )
+            language=getattr(self, "code_editor_language", "python"),
+            prefix=environment_manager.prefix)
 
     def handle_worker_result(self, action: str, result):
         """
diff --git a/pyqt_code_editor/mixins/complete.py b/pyqt_code_editor/mixins/complete.py
@@ -276,7 +276,8 @@ def _cm_request_completion(self, multiline=False, full=False):
                                  multiline=multiline,
                                  path=self.code_editor_file_path,
                                  language=self.code_editor_language,
-                                 env_path=environment_manager.path)
+                                 env_path=environment_manager.path,
+                                 prefix=environment_manager.prefix)
 
     def _cm_request_calltip(self):
         """Send a calltip request."""
@@ -288,7 +289,8 @@ def _cm_request_calltip(self):
                                  cursor_pos=cursor_pos,
                                  path=self.code_editor_file_path,
                                  language=self.code_editor_language,
-                                 env_path=environment_manager.path)
+                                 env_path=environment_manager.path,
+                                 prefix=environment_manager.prefix)
 
     def _cm_hide_calltip(self):
         """Hide the calltip widget."""
diff --git a/pyqt_code_editor/worker/languages/generic.py b/pyqt_code_editor/worker/languages/generic.py
@@ -1,9 +1,9 @@
 from ..providers import symbol, codestral
 
-def complete(code, cursor_pos, path, multiline, full, env_path):
+def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
     if full or multiline:
         completions = codestral.codestral_complete(
-            code, cursor_pos, multiline=multiline)
+            code, cursor_pos, multiline=multiline, prefix=prefix)
     else:
         completions = []
     if not multiline:
diff --git a/pyqt_code_editor/worker/languages/python.py b/pyqt_code_editor/worker/languages/python.py
@@ -1,15 +1,16 @@
 from ..providers import jedi, codestral, ruff
 
 
-def complete(code, cursor_pos, path, multiline, full, env_path):
+def complete(code, cursor_pos, path, multiline, full, env_path, prefix):
     if full or multiline:
         codestral_completions = codestral.codestral_complete(
-            code, cursor_pos, multiline=multiline)
+            code, cursor_pos, multiline=multiline, prefix=prefix)
     else:
         codestral_completions = []
     if not multiline:
         jedi_completions = jedi.jedi_complete(code, cursor_pos, path=path,
-                                              env_path=env_path)
+                                              env_path=env_path,
+                                              prefix=prefix)
     else:
         jedi_completions = []
     # If there is at least one jedi completion, it is always insert at first.
diff --git a/pyqt_code_editor/worker/process.py b/pyqt_code_editor/worker/process.py
@@ -8,13 +8,98 @@
 
 def main_worker_process_function(request_queue, result_queue):
     """
-    Runs in a separate process, handling requests in dict form.
-    Supported actions include:
-      - 'complete': triggers code completion
-      - 'calltip': fetches calltip/signature info
-      - 'check': fetches code check/ linting info
-      - 'setting': updates settings in the 'settings' module
-      - 'quit': shuts down the worker
+    Main worker process for handling editor backend requests.
+    
+    Runs in a separate process, continuously processing requests from a queue
+    and sending results back through another queue. Supports code completion,
+    calltips, symbol extraction, code checking, and settings management.
+    
+    Parameters
+    ----------
+    request_queue : multiprocessing.Queue
+        Queue containing request dictionaries to process
+    result_queue : multiprocessing.Queue
+        Queue where results are sent back to the main process
+        
+    Request Format
+    --------------
+    Each request must be a dictionary with the following structure:
+    
+    Required fields:
+        action : str
+            The action to perform. One of: 'complete', 'calltip', 'symbols', 
+            'check', 'set_settings', 'quit'
+    
+    Optional fields (depending on action):
+        language : str, default 'text'
+            Programming language for syntax-aware processing
+        code : str, default ''
+            Source code content to analyze
+        cursor_pos : int, default 0
+            Character position of cursor in the code
+        path : str, optional
+            File path for context-aware processing
+        multiline : bool, default False
+            Whether to enable multiline completion mode
+        full : bool, default False
+            Whether to return full completion details
+        env_path : str, optional
+            Path to Python environment for context
+        prefix : str, optional
+            Prefix string for filtering results
+        settings : dict, optional
+            Settings to update (only for 'set_settings' action)
+    
+    Response Format
+    ---------------
+    Results are dictionaries placed on result_queue with action-specific content:
+    
+    For 'complete' action:
+        {
+            'action': 'complete',
+            'completions': list or None,
+            'cursor_pos': int,
+            'multiline': bool,
+            'full': bool
+        }
+    
+    For 'calltip' action:
+        {
+            'action': 'calltip', 
+            'signatures': list or None,
+            'cursor_pos': int
+        }
+    
+    For 'symbols' action:
+        {
+            'action': 'symbols',
+            'symbols': list
+        }
+    
+    For 'check' action:
+        {
+            'action': 'check',
+            'messages': dict
+        }
+    
+    Behavior
+    --------
+    - Runs indefinitely until receiving a 'quit' action
+    - Dynamically loads language-specific worker modules on first use
+    - Caches imported worker modules for efficiency
+    - Falls back to generic worker functions if language-specific module unavailable
+    - Skips invalid requests (None, non-dict, or missing 'action' field)
+    - Logs all major operations and errors
+    - For 'set_settings' action, updates the settings module attributes directly
+    - Worker modules must provide functions: complete, calltip, symbols, check
+      (functions can be None if not supported for that language)
+    
+    Notes
+    -----
+    This function is designed to run in a separate process to avoid blocking
+    the main editor thread during potentially slow operations like code analysis.
+    Language-specific worker modules are expected to be in the 'languages' 
+    subpackage.
     """
     logger.info("Started completion worker.")
     while True:
@@ -25,13 +110,21 @@ def main_worker_process_function(request_queue, result_queue):
         if request is None:
             logger.info("Received None request (possibly legacy or invalid). Skipping.")
             continue
-
         # Expect a dict with at least an 'action' field
         if not isinstance(request, dict):
             logger.info(f"Invalid request type: {type(request)}. Skipping.")
-            continue
-
+            continue        
+        # Most of the parameters apply to multiple actions, so we extract them
+        # here.
         action = request.get('action', None)
+        language = request.get('language', 'text')
+        code = request.get('code', '')
+        cursor_pos = request.get('cursor_pos', 0)
+        path = request.get('path', None)
+        multiline = request.get('multiline', False)
+        full = request.get('full', False)
+        env_path = request.get('env_path', None)
+        prefix = request.get('prefix', None)
         if action is None:
             logger.info("Request is missing 'action' field. Skipping.")
             continue
@@ -46,8 +139,7 @@ def main_worker_process_function(request_queue, result_queue):
             break
         
         # Load the worker functions depending on the language. We store the
-        # imported module in a cache for efficiency
-        language = request.get('language', 'text')
+        # imported module in a cache for efficiency        
         if language not in worker_functions_cache:
             try:
                 worker_functions = importlib.import_module(
@@ -66,16 +158,10 @@ def main_worker_process_function(request_queue, result_queue):
             if worker_functions.complete is None:
                 completions = None
             else:
-                code = request.get('code', '')
-                cursor_pos = request.get('cursor_pos', 0)
-                path = request.get('path', None)
-                multiline = request.get('multiline', False)
-                full = request.get('full', False)
-                env_path = request.get('env_path', None)
                 logger.info(f"Performing code completion: language='{language}', multiline={multiline}, path={path}, env_path={env_path}")
                 completions = worker_functions.complete(
                     code, cursor_pos, path=path, multiline=multiline, full=full,
-                    env_path=env_path)
+                    env_path=env_path, prefix=prefix)
             if not completions:
                 logger.info("No completions")
             else:
@@ -89,16 +175,13 @@ 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', '')
-                path = request.get('path', None)
-                env_path = request.get('env_path', None)
                 logger.info(f"Performing calltip: language='{language}', path={path}, env_path={env_path}")
                 signatures = worker_functions.calltip(
-                    code, cursor_pos, path=path, env_path=env_path)
+                    code, cursor_pos, path=path, env_path=env_path,
+                    prefix=prefix)
             if signatures is None:
                 logger.info("No calltip signatures. Sending result back.")
             else:
@@ -113,7 +196,6 @@ def main_worker_process_function(request_queue, result_queue):
             if worker_functions.symbols is None:
                 symbols_results = []
             else:
-                code = request.get('code', '')
                 symbols_results = worker_functions.symbols(code)
             result_queue.put({
                 'action': 'symbols',
@@ -124,11 +206,10 @@ def main_worker_process_function(request_queue, result_queue):
             if worker_functions.check is None:
                 check_results = {}
             else:
-                code = request.get('code', '')
-                check_results = worker_functions.check(code)
+                check_results = worker_functions.check(code, prefix=prefix)
             result_queue.put({
                 'action': 'check',
                 'messages': check_results
             })
 
-    logger.info("Completion worker has shut down.")
+    logger.info("Completion worker has shut down.")
diff --git a/pyqt_code_editor/worker/providers/codestral.py b/pyqt_code_editor/worker/providers/codestral.py
@@ -6,7 +6,8 @@
 
 
 def codestral_complete(code: str, cursor_pos: int,
-                       multiline: bool = False) -> list[str]:
+                       multiline: bool = False,
+                       prefix: str | None = None) -> list[str]:
     global client
 
     if not settings.codestral_api_key:
@@ -22,6 +23,10 @@ def codestral_complete(code: str, cursor_pos: int,
     start = max(0, cursor_pos - settings.codestral_max_context)
     end = cursor_pos + settings.codestral_max_context
     prompt = code[start: cursor_pos]
+    if prefix:
+        if not prefix.endswith('\n'):
+            prefix += '\n'
+        prompt = prefix + prompt
     suffix = code[cursor_pos: end]
 
     request = dict(
diff --git a/pyqt_code_editor/worker/providers/jedi.py b/pyqt_code_editor/worker/providers/jedi.py
diff --git a/pyqt_code_editor/worker/providers/ruff.py b/pyqt_code_editor/worker/providers/ruff.py

Original file line number	Diff line number	Diff line change
`@@ -2,4 +2,4 @@`
`2`	`2`
`3`	`3`	`from ._settings import settings`
`4`	`4`
`5`		`-__version__ = '0.0.28'`
	`5`	`+__version__ = '0.0.29'`