pyqt-code-editor 0.0.54__tar.gz → 0.0.55__tar.gz

{pyqt_code_editor-0.0.54 → pyqt_code_editor-0.0.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.54
+Version: 0.0.55
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>
@@ -32,7 +32,7 @@ Project-URL: Source, https://github.com/open-cogsci/sigmund-analyst
 
 # PyQt Code Editor / Sigmund Analyst
 
-Copyright 2025 Sebastiaan Mathôt
+Copyright 2025-2026 Sebastiaan Mathôt
 
 
 ## About

{pyqt_code_editor-0.0.54 → pyqt_code_editor-0.0.55}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.54'
+__version__ = '0.0.55'

{pyqt_code_editor-0.0.54 → pyqt_code_editor-0.0.55}/pyqt_code_editor/_settings.py

@@ -120,6 +120,7 @@ class Settings(QObject):
     check_interval_delay = SettingProperty(5000, "Checking")
     
     # Sigmund provider
+    sigmund_review_actions = SettingProperty(True, "Sigmund")
     sigmund_max_context = SettingProperty(2000, "Sigmund")
     sigmund_fim_endpoint = SettingProperty('http://localhost:5000/code_completion/fim', "Sigmund")
     sigmund_token = SettingProperty(None, "Sigmund")

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/__init__.py

@@ -0,0 +1 @@
+from .sigmund import Sigmund

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/confirm_run_code_dialog.py

@@ -0,0 +1,59 @@
+from qtpy.QtWidgets import QVBoxLayout, QDialogButtonBox, QLabel, \
+    QSizePolicy, QDialog, QSplitter
+from qtpy.QtCore import Qt
+import logging
+from sigmund_qtwidget.chat_browser import ChatBrowser
+from pyqt_code_editor.code_editors import create_editor
+
+logger = logging.getLogger(__name__)
+
+MAX_MESSAGE_HEIGHT = 200
+
+class ConfirmRunCodeDialog(QDialog):
+    """
+    A modal dialog that displays code to be executed and asks the user to confirm or cancel.
+    """
+
+    def __init__(self, parent, code: str, language: str):
+        super().__init__(parent)
+
+        self.setWindowTitle(f"Confirm {language} code execution")
+
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        # Use ChatBrowser to display the AI message
+        self.message_browser = ChatBrowser(self)
+        self.message_browser.append_message(
+            'ai', 'Sigmund wants to run the following code:')
+        self.message_browser.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        self.message_browser.setMaximumHeight(MAX_MESSAGE_HEIGHT)
+
+        # Create code editor for the code to be executed
+        self.code_view = create_editor(language=language)
+        self.code_view.setPlainText(code)
+        self.code_view.setReadOnly(True)
+
+        # Create a vertical splitter to hold the message browser and the code
+        splitter = QSplitter(Qt.Vertical)
+        splitter.addWidget(self.message_browser)
+        splitter.addWidget(self.code_view)
+        layout.addWidget(splitter)
+
+        # The disclaimer label
+        disclaimer_label = QLabel(
+            "Carefully review the code before execution. Executing code can have unintended consequences.",
+            self
+        )
+        disclaimer_label.setWordWrap(True)
+        disclaimer_label.setObjectName('control-warning')
+        disclaimer_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        layout.addWidget(disclaimer_label)
+
+        # Dialog buttons
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+        layout.addWidget(self.button_box)
+
+        self.resize(800, 600)

pyqt_code_editor-0.0.54/pyqt_code_editor/components/sigmund.py → pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/editor_workspace.py

@@ -1,6 +1,3 @@
-from sigmund_qtwidget.sigmund_widget import SigmundWidget
-from ..widgets import Dock
-from .. import watchdog, settings
 import textwrap
 import logging
 logger = logging.getLogger(__name__)
@@ -76,11 +73,14 @@ class EditorWorkspace:
     
     def set(self, content, language):
         text_cursor = self._editor.textCursor()
+        text_cursor.beginEditBlock()
         if text_cursor.hasSelection():
             text_cursor.insertText(content)
-            self._editor.setTextCursor(text_cursor)
         else:
-            self._editor.setPlainText(content)
+            text_cursor.select(text_cursor.Document)
+            text_cursor.insertText(content)
+        text_cursor.endEditBlock()
+        self._editor.setTextCursor(text_cursor)
         self._editor.set_modified(True)
     
     def has_changed(self, content, language):
@@ -98,24 +98,3 @@ class EditorWorkspace:
         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, application='Sigmund Analyst')
-        self.sigmund_widget.setStyleSheet(f'font-size: {settings.font_size}pt')
-        self.sigmund_widget.set_workspace_manager(workspace)
-        self.setWidget(self.sigmund_widget)
-
-    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.55/pyqt_code_editor/components/sigmund/sigmund.py

@@ -0,0 +1,28 @@
+from ...widgets import Dock
+from ... import watchdog, settings
+from .editor_workspace import EditorWorkspace
+from .sigmund_analyst_widget import SigmundAnalystWidget
+import logging
+logger = logging.getLogger(__name__)
+        
+        
+class Sigmund(Dock):
+    def __init__(self, parent, editor_panel):
+        super().__init__('Sigmund', parent)
+        self.setObjectName("sigmund")
+        workspace = EditorWorkspace(editor_panel)
+        self.sigmund_widget = SigmundAnalystWidget(
+            self, editor_panel)
+        self.sigmund_widget.setStyleSheet(f'font-size: {settings.font_size}pt')
+        self.sigmund_widget.set_workspace_manager(workspace)
+        self.setWidget(self.sigmund_widget)
+
+    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.55/pyqt_code_editor/components/sigmund/sigmund_analyst_chat_widget.py

@@ -0,0 +1,35 @@
+from qtpy.QtWidgets import QCheckBox, QWidget, QVBoxLayout
+from sigmund_qtwidget.chat_widget import ChatWidget
+from ... import settings
+
+
+class SigmundAnalystChatWidget(ChatWidget):
+    """Extended chat widget with Sigmund Analyst-specific options"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Create a container for the checkboxes
+        options_container = QWidget()
+        options_layout = QVBoxLayout(options_container)
+        options_layout.setContentsMargins(5, 5, 5, 5)
+        options_layout.setSpacing(2)
+        # "Review proposed changes" checkbox
+        self._review_actions_checkbox = QCheckBox(
+            "Review Sigmund's actions (recommended)")
+        self._review_actions_checkbox.setChecked(
+            settings.sigmund_review_actions)
+        self._review_actions_checkbox.stateChanged.connect(
+            self._on_review_actions_changed)
+        options_layout.addWidget(self._review_actions_checkbox)
+        # Insert the options container before the input container
+        main_layout = self.layout()
+        main_layout.insertWidget(main_layout.count(), options_container)
+        
+    def _on_review_actions_changed(self, state):
+        """Store the review changes setting."""
+        settings.sigmund_review_actions = bool(state)
+            
+    def append_message(self, msg_type, text, scroll=True):
+        if msg_type == 'ai' and '(Suggesting IDE action)' in text:
+            text = '⚙️ Sigmund is working …'
+        self._chat_browser.append_message(msg_type, text, scroll)        

pyqt_code_editor-0.0.55/pyqt_code_editor/components/sigmund/sigmund_analyst_widget.py

@@ -0,0 +1,191 @@
+import os
+import time
+from sigmund_qtwidget.sigmund_widget import SigmundWidget
+from qtpy.QtCore import QEventLoop, QTimer
+from qtpy.QtWidgets import QMessageBox, QDialog
+from .sigmund_analyst_chat_widget import SigmundAnalystChatWidget
+from .confirm_run_code_dialog import ConfirmRunCodeDialog
+from ... import settings
+import logging
+logger = logging.getLogger(__name__)
+
+ACTION_CANCELLED = 'I do not approve this action.'
+
+
+class SigmundAnalystWidget(SigmundWidget):
+    """Extends the default Sigmund widget with Sigmund Analyst-specific
+    functionality.
+    """
+    chat_widget_cls = SigmundAnalystChatWidget
+
+    def __init__(self, parent, editor_panel):
+        super().__init__(parent, application='Sigmund Analyst')
+        try:
+            self._app = parent.parent()
+            self._jupyter_console = self._app._jupyter_console
+            # Connect the code_executed signal to a slot
+        except AttributeError:
+            logger.warning('No Jupyter console found.')
+            self._jupyter_console = None
+        else:
+            self._jupyter_console.execution_complete.connect(
+                self._handle_execution_result)
+        self._editor_panel = editor_panel
+        self._transient_settings = {
+            'tool_ide_open_file': 'true',
+            'tool_ide_execute_code': 'true'
+        }
+        # Store execution results
+        self._execution_result = None
+        self._execution_loop = None
+
+    def _confirm_action(self, action_type, details):
+        """Show a confirmation dialog for the proposed action.
+
+        Args:
+            action_type (str): Type of action (e.g., "open file", "execute code")
+            details (str): Detailed information about the action
+
+        Returns:
+            bool: True if action is approved, False otherwise
+        """
+        if not settings.sigmund_review_actions:
+            return True
+
+        if action_type == "open file":
+            return QMessageBox.question(
+                self, 
+                "Open file",
+                f"Sigmund wants to open: \n\n{details}",
+                QMessageBox.Ok | QMessageBox.Cancel,
+                QMessageBox.Ok
+            ) == QMessageBox.Ok
+        dialog = ConfirmRunCodeDialog(
+            self,
+            action_type,
+            details
+        )
+        return dialog.exec_() == QDialog.Accepted
+
+    def _handle_execution_result(self, output, result):
+        """Slot that handles the code_executed signal."""
+        self._execution_result = (output, result)
+        if self._execution_loop and self._execution_loop.isRunning():
+            time.sleep(0.5)  # Wait for errors to appear
+            self._execution_loop.quit()
+
+    def run_command_open_file(self, path):
+        if settings.sigmund_review_actions:
+            if not QMessageBox.question(self, 
+                                        "Confirm open file",
+                                        f"Sigmund wants to open: \n\n{path}",
+                                        QMessageBox.Ok | QMessageBox.Cancel,
+                                        QMessageBox.Ok) == QMessageBox.Ok:
+                return ACTION_CANCELLED
+        try:
+            self._editor_panel.open_file(path)
+        except Exception as e:
+            return f'Failed to open file: {e}'
+        return f'Opened file: {path}'
+
+    def run_command_execute_code(self, code, language):
+        if settings.sigmund_review_actions:
+            if not ConfirmRunCodeDialog(self, code, language).exec() \
+                    == ConfirmRunCodeDialog.Accepted:
+                return ACTION_CANCELLED
+        if self._jupyter_console is None:
+            return 'Code execution not supported.'
+        self._app._toggle_dock_widget(self._jupyter_console, show=True)
+        self._execution_result = None
+        self._execution_loop = QEventLoop()
+        QTimer.singleShot(30000, self._execution_loop.quit)  # 30 second timeout
+        self._jupyter_console.execute_code(code)
+        self._execution_loop.exec_()
+        self._execution_loop = None
+        if self._execution_result is None:
+            return 'Code execution timed out or failed to return a result.'
+        try:
+            console_content = self._jupyter_console.get_current_console().jupyter_widget._control.toPlainText()
+        except Exception as e:
+            return f'Failed to get results from console content: {e}'
+            console_content = ''
+        console_content = '\n'.join(console_content.splitlines()[-100:])
+        return f'# Console output (may be truncated):\n\n{console_content}'
+    @property
+    def _editor(self):
+        return self._editor_panel.active_editor()        
+        
+    def send_user_message(self, text, *args, **kwargs):
+        current_path = self._editor.code_editor_file_path
+        # If the editor is not linked to a file, simply use the working 
+        # directory.
+        if current_path is None:
+            current_path = '[unsaved file]'
+            working_directory = os.getcwd()
+        else:
+            working_directory = os.path.dirname(current_path)
+
+        # Initialize with default value
+        working_directory_contents = "(No directory contents available)"
+
+        # Get directory contents with priority to top-level items
+        top_level = []
+        all_items = []
+
+        # Only wrap file system operations in try-except
+        try:
+            # Get top-level items (depth=1)
+            top_level = [f for f in os.listdir(working_directory)
+                        if os.path.isfile(os.path.join(working_directory, f))
+                        or os.path.isdir(os.path.join(working_directory, f))]
+
+            # Then get deeper items if we haven't reached our limit
+            remaining_slots = max(0, 20 - len(top_level))
+            if remaining_slots > 0:
+                for root, dirs, files in os.walk(working_directory):
+                    # Skip the top level since we already have it
+                    if root == working_directory:
+                        continue
+                    # Add files first
+                    for file in files:
+                        if remaining_slots <= 0:
+                            break
+                        rel_path = os.path.relpath(os.path.join(root, file), working_directory)
+                        all_items.append(f".\\{rel_path}")
+                        remaining_slots -= 1
+                    # Then add directories if we still have space
+                    for dir in dirs:
+                        if remaining_slots <= 0:
+                            break
+                        rel_path = os.path.relpath(os.path.join(root, dir), working_directory)
+                        all_items.append(f".\\{rel_path}\\")
+                        remaining_slots -= 1
+
+            # Combine top level and deeper items
+            working_directory_contents = "\n".join(
+                sorted([f".\\{item}" if os.path.isfile(os.path.join(working_directory, item))
+                 else f".\\{item}\\" for item in top_level] +
+                all_items)
+            )
+
+            if len(top_level) + len(all_items) > 20:
+                working_directory_contents += "\n... (additional files truncated)"
+
+        except PermissionError:
+            working_directory_contents = "(Could not read some directory contents - permission denied)"
+        except OSError as e:
+            working_directory_contents = f"(Could not read directory contents: {str(e)})"
+
+        system_prompt = f'''## Working directory
+
+The workspace corresponds to the following file: {current_path}
+The working directory is: {working_directory}
+
+Overview of working directory:
+
+```
+{working_directory_contents}
+```
+'''
+        self._transient_system_prompt = system_prompt
+        super().send_user_message(text, *args, **kwargs)

{pyqt_code_editor-0.0.54 → pyqt_code_editor-0.0.55}/pyqt_code_editor/mixins/merge_undo_actions.py

@@ -20,11 +20,6 @@ class MergeUndoActions:
         key = event.key()
         modifiers = event.modifiers()
 
-        is_navigation = (
-            key in navigation_keys
-            and not (modifiers & Qt.KeyboardModifier.ShiftModifier)
-        )
-
         # Treat platform "command" modifier as well (Control on Windows/Linux, Meta on macOS)
         ctrl_or_meta = Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier
         has_ctrl_or_meta = bool(modifiers & ctrl_or_meta)
@@ -39,7 +34,7 @@ class MergeUndoActions:
             key == Qt.Key.Key_Y
         )
 
-        if is_navigation or is_undo or is_redo:
+        if key in navigation_keys or is_undo or is_redo:
             # Do not wrap these in an edit block
             super().keyPressEvent(event)
             return

{pyqt_code_editor-0.0.54 → pyqt_code_editor-0.0.55}/readme.md

@@ -1,6 +1,6 @@
 # PyQt Code Editor / Sigmund Analyst
 
-Copyright 2025 Sebastiaan Mathôt
+Copyright 2025-2026 Sebastiaan Mathôt
 
 
 ## About