pyqt-code-editor 0.0.27__tar.gz → 0.0.29__tar.gz

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.27
+Version: 0.0.29
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.27'
+__version__ = '0.0.29'

pyqt_code_editor-0.0.29/pyqt_code_editor/environment_manager.py

@@ -0,0 +1,37 @@
+import os
+from qtpy.QtCore import Signal, QObject
+import logging
+logger = logging.getLogger(__name__)
+
+class EnvironmentManager(QObject):
+    """Singleton class to share the current environment and language between all
+    components of the app.
+    """    
+    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, 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
+environment_manager = EnvironmentManager()

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/mixins/base.py

@@ -125,9 +125,11 @@ class Base:
             # 6) We're done with this particular request
             to_remove.append(pid)
 
-        # Cleanup: remove completed or dead requests
+        # Cleanup: remove completed or dead requests. Also stop unused workers.
+        # This function periodically prunes worker processes if they are unused.
         for pid in to_remove:
-            self._active_requests.pop(pid, None)
+            self._active_requests.pop(pid, None)            
+        manager.stop_unused_workers()
         
     def set_modified(self, modified):
         logger.info(f'modified: {modified}')

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/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 @@ class Check:
         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):
         """

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/mixins/complete.py

@@ -276,7 +276,8 @@ class Complete:
                                  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 @@ class Complete:
                                  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."""

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/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:

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/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.

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/worker/manager.py

@@ -1,9 +1,11 @@
 import logging
+import time
 from multiprocessing import Process, Queue
 from .process import main_worker_process_function
 from .. import watchdog, settings
 logger = logging.getLogger(__name__)
-
+STOP_UNUSED_INTERVAL = 10
+_last_stop_unused_time = 0
 _workers = {}  # pid -> {"process", "request_queue", "result_queue", "is_free"}
 
 
@@ -63,11 +65,15 @@ def check_worker_alive(pid: int) -> bool:
     w = _workers.get(pid)
     return w and w["process"].is_alive()
 
-def stop_unused_workers(max_free: int = 1):
+def stop_unused_workers(max_free: int = 1, force: bool = False):
     """
     Stop free worker processes until there is at most 'max_free' free processes left.
     This keeps us from accumulating too many idle worker processes.
     """
+    global _last_stop_unused_time
+    if force or time.time() - _last_stop_unused_time < STOP_UNUSED_INTERVAL:
+        return
+    _last_stop_unused_time = time.time()
     # Gather a list of free worker PIDs
     free_pids = [pid for pid, w in _workers.items() if w["is_free"] and w["process"].is_alive()]
     logger.info(f"stop_unused_workers called: max_free={max_free}, found {len(free_pids)} free workers")

pyqt_code_editor-0.0.29/pyqt_code_editor/worker/process.py

@@ -0,0 +1,215 @@
+import logging
+import importlib
+from . import settings
+import queue
+logger = logging.getLogger(__name__)
+worker_functions_cache = {}
+
+
+def main_worker_process_function(request_queue, result_queue):
+    """
+    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:
+        try:
+            request = request_queue.get(True, 5)
+        except queue.Empty:
+            continue
+        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        
+        # 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
+
+        logger.info(f"Received request action='{action}'")
+        if action == 'set_settings':
+            for name, value in request.get('settings', {}).items():
+                setattr(settings, name, value)
+            continue
+        if action == 'quit':
+            logger.info("Received 'quit' action. Worker will shut down.")
+            break
+        
+        # Load the worker functions depending on the language. We store the
+        # imported module in a cache for efficiency        
+        if language not in worker_functions_cache:
+            try:
+                worker_functions = importlib.import_module(
+                    f".languages.{language}", package=__package__)
+            except ImportError:
+                from .languages import generic as worker_functions
+                logger.info(f'failed to load worker functions for {language}, falling back to generic')
+            else:
+                logger.info(f'loaded worker functions for {language}')
+            worker_functions_cache[language] = worker_functions
+        else:
+            worker_functions = worker_functions_cache[language]
+
+        if action == 'complete':
+            # Action not supported for language
+            if worker_functions.complete is None:
+                completions = None
+            else:
+                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, prefix=prefix)
+            if not completions:
+                logger.info("No completions")
+            else:
+                logger.info(f"Generated {len(completions)} completions")
+            result_queue.put({
+                'action': 'complete',
+                'completions': completions,
+                'cursor_pos': cursor_pos,
+                'multiline': multiline,
+                'full': full
+            })
+
+        elif action == 'calltip':
+            if worker_functions.calltip is None:
+                signatures = None
+            else:
+                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,
+                    prefix=prefix)
+            if signatures is None:
+                logger.info("No calltip signatures. Sending result back.")
+            else:
+                logger.info(f"Retrieved {len(signatures)} calltip signatures.")
+            result_queue.put({
+                'action': 'calltip',
+                'signatures': signatures,
+                'cursor_pos': cursor_pos
+            })
+                
+        elif action == 'symbols':
+            if worker_functions.symbols is None:
+                symbols_results = []
+            else:
+                symbols_results = worker_functions.symbols(code)
+            result_queue.put({
+                'action': 'symbols',
+                'symbols': symbols_results
+            })
+            
+        elif action == 'check':
+            if worker_functions.check is None:
+                check_results = {}
+            else:
+                check_results = worker_functions.check(code, prefix=prefix)
+            result_queue.put({
+                'action': 'check',
+                'messages': check_results
+            })
+
+    logger.info("Completion worker has shut down.")

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/worker/providers/codestral.py

@@ -6,7 +6,8 @@ client = None
 
 
 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(

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/worker/providers/jedi.py

@@ -21,11 +21,16 @@ def _signature_to_html(signature) -> str:
 
 
 def _prepare_jedi_script(code: str, cursor_position: int, path: str | None,
-                         env_path: str | None):
+                         env_path: str | None, prefix: str | None = None):
     """
     Prepare a Jedi Script object and calculate line_no/column_no from the
     given code and cursor_position. Returns (script, line_no, column_no).
     """
+    if prefix:
+        if not prefix.endswith('\n'):
+            prefix += '\n'
+        code = prefix + code
+        cursor_position += len(prefix)
     # Convert the flat cursor_position into line & column (1-based indexing for Jedi)
     line_no = code[:cursor_position].count('\n') + 1
     last_newline_idx = code.rfind('\n', 0, cursor_position)
@@ -43,7 +48,8 @@ def _prepare_jedi_script(code: str, cursor_position: int, path: str | None,
 
 
 def jedi_complete(code: str, cursor_position: int, path: str | None,
-                  env_path: str | None = None) -> list[str]:
+                  env_path: str | None = None,
+                  prefix: str | None = None) -> list[str]:
     """
     Perform Python-specific completion using Jedi. Returns a list of possible completions
     for the text at the given cursor position, or None if no completion is found.
@@ -61,7 +67,7 @@ def jedi_complete(code: str, cursor_position: int, path: str | None,
         return []
     # Go Jedi!
     script, line_no, column_no = _prepare_jedi_script(code, cursor_position,
-                                                      path, env_path)
+                                                      path, env_path, prefix)
     completions = script.complete(line=line_no, column=column_no)
     if not completions:
         return []
@@ -75,7 +81,8 @@ def jedi_complete(code: str, cursor_position: int, path: str | None,
 def jedi_signatures(code: str, cursor_position: int, path: str | None,
                     multiline: bool = False, max_width: int = 40,
                     max_lines: int = 10,
-                    env_path: str | None = None):
+                    env_path: str | None = None,
+                    prefix: str | None = None) -> list[str]:
     """
     Retrieve function signatures (calltips) from Jedi given the current cursor position.
     Returns a list of strings describing each signature, or None if none.
@@ -90,7 +97,7 @@ def jedi_signatures(code: str, cursor_position: int, path: str | None,
 
     logger.info("Starting Jedi calltip request (multiline=%r).", multiline)
     script, line_no, column_no = _prepare_jedi_script(code, cursor_position,
-                                                      path, env_path)
+                                                      path, env_path, prefix)
 
     signatures = script.get_signatures(line=line_no, column=column_no)
     if not signatures:

{pyqt_code_editor-0.0.27 → pyqt_code_editor-0.0.29}/pyqt_code_editor/worker/providers/ruff.py

@@ -6,13 +6,20 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-def ruff_check(code: str) -> list[dict]:
+def ruff_check(code: str, prefix: str | None = None) -> list[dict]:
     """
     Lints Python source code using Ruff.
     
     Args:
         code (str): The Python source code to lint.
     """
+    if prefix:
+        if not prefix.endswith('\n'):
+            prefix += '\n'
+        code = prefix + code
+        prefix_line_offset = prefix.count('\n')
+    else:
+        prefix_line_offset = 0
     with tempfile.NamedTemporaryFile(delete=False, suffix=".py", mode="w") as tmp_file:
         tmp_file.write(code)
         tmp_file_path = tmp_file.name
@@ -35,7 +42,7 @@ def ruff_check(code: str) -> list[dict]:
         return {}
     formatted_result = {}
     for message in result:
-        row = message['location']['row']
+        row = message['location']['row'] - prefix_line_offset
         if row not in formatted_result:
             formatted_result[row] = []
         formatted_result[row].append({

pyqt_code_editor-0.0.27/pyqt_code_editor/environment_manager.py

@@ -1,37 +0,0 @@
-import os
-from qtpy.QtCore import Signal, QObject
-import logging
-logger = logging.getLogger(__name__)
-
-class EnvironmentManager(QObject):
-    """Singleton class to share the current environment and language between all
-    components of the app.
-    """    
-    environment_changed = Signal(str, str, str)
-
-    def __init__(self):
-        super().__init__()
-        self.name = None
-        self.path = None
-        self.language = 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)
-
-
-# Singleton instance
-environment_manager = EnvironmentManager()

pyqt_code_editor-0.0.27/pyqt_code_editor/worker/process.py

@@ -1,130 +0,0 @@
-import logging
-import importlib
-from . import settings
-logger = logging.getLogger(__name__)
-worker_functions_cache = {}
-
-
-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
-    """
-    logger.info("Started completion worker.")
-    while True:
-        request = request_queue.get()
-        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
-
-        action = request.get('action', None)
-        if action is None:
-            logger.info("Request is missing 'action' field. Skipping.")
-            continue
-
-        logger.info(f"Received request action='{action}'")
-        if action == 'set_settings':
-            for name, value in request.get('settings', {}).items():
-                setattr(settings, name, value)
-            continue
-        if action == 'quit':
-            logger.info("Received 'quit' action. Worker will shut down.")
-            break
-        
-        # Load the worker functions depending on the language. We store the
-        # imported module in a cache for efficiency
-        language = request.get('language', 'text')
-        if language not in worker_functions_cache:
-            try:
-                worker_functions = importlib.import_module(
-                    f".languages.{language}", package=__package__)
-            except ImportError:
-                from .languages import generic as worker_functions
-                logger.info(f'failed to load worker functions for {language}, falling back to generic')
-            else:
-                logger.info(f'loaded worker functions for {language}')
-            worker_functions_cache[language] = worker_functions
-        else:
-            worker_functions = worker_functions_cache[language]
-
-        if action == 'complete':
-            # Action not supported for language
-            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)
-            if not completions:
-                logger.info("No completions")
-            else:
-                logger.info(f"Generated {len(completions)} completions")
-            result_queue.put({
-                'action': 'complete',
-                'completions': completions,
-                'cursor_pos': cursor_pos,
-                'multiline': multiline,
-                'full': full
-            })
-
-        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)
-            if signatures is None:
-                logger.info("No calltip signatures. Sending result back.")
-            else:
-                logger.info(f"Retrieved {len(signatures)} calltip signatures.")
-            result_queue.put({
-                'action': 'calltip',
-                'signatures': signatures,
-                'cursor_pos': cursor_pos
-            })
-                
-        elif action == 'symbols':
-            if worker_functions.symbols is None:
-                symbols_results = []
-            else:
-                code = request.get('code', '')
-                symbols_results = worker_functions.symbols(code)
-            result_queue.put({
-                'action': 'symbols',
-                'symbols': symbols_results
-            })
-            
-        elif action == 'check':
-            if worker_functions.check is None:
-                check_results = {}
-            else:
-                code = request.get('code', '')
-                check_results = worker_functions.check(code)
-            result_queue.put({
-                'action': 'check',
-                'messages': check_results
-            })
-
-    logger.info("Completion worker has shut down.")