pyqt-code-editor 0.0.8__tar.gz → 0.0.10__tar.gz

{pyqt_code_editor-0.0.8 → pyqt_code_editor-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.8
+Version: 0.0.10
 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.8 → pyqt_code_editor-0.0.10}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.8'
+__version__ = '0.0.10'

{pyqt_code_editor-0.0.8 → pyqt_code_editor-0.0.10}/pyqt_code_editor/_settings.py

@@ -75,6 +75,9 @@ class Settings(QObject):
     search_replace_background = SettingProperty("#fdff74", "Appearance")
     search_replace_foreground = SettingProperty("#000000", "Appearance")
     
+    # Jupyter Console
+    default_kernel = SettingProperty('python3', "JupyterConsole")
+    
     # Files and Folders
     current_folder = SettingProperty(os.path.expanduser('~'), "Files")
     default_filename = SettingProperty('untitled.txt', "Files")

{pyqt_code_editor-0.0.8 → pyqt_code_editor-0.0.10}/pyqt_code_editor/app.py

@@ -46,10 +46,10 @@ class MainWindow(QMainWindow):
         self._setup_dock_widget(self._workspace_explorer, "Workspace Explorer")
 
         # Set up the jupyter console
-        self._jupyter_console = JupyterConsole(parent=self)
+        self._jupyter_console = JupyterConsole(
+            parent=self, default_kernel=settings.default_kernel)
         self._jupyter_console.workspace_updated.connect(
-            self._workspace_explorer.update
-        )
+            self._workspace_explorer.update)
         self.addDockWidget(Qt.BottomDockWidgetArea, self._jupyter_console)
         self._setup_dock_widget(self._jupyter_console, "Jupyter Console")
 

{pyqt_code_editor-0.0.8 → pyqt_code_editor-0.0.10}/pyqt_code_editor/components/jupyter_console.py

@@ -52,6 +52,8 @@ class JupyterConsoleTab(QWidget):
         self._internal_messages = set()
         # Set of message IDs where output should be hidden
         self._silent_messages = set()
+        # Flag to prevent recursive workspace updates
+        self._updating_workspace = False        
         
         # Create Jupyter console widget
         self.jupyter_widget = RichJupyterWidget()
@@ -93,6 +95,13 @@ class JupyterConsoleTab(QWidget):
             .out-prompt-number {{ color: red; }}
         '''
         self.jupyter_widget.setStyleSheet(stylesheet)
+        # Recent versions of Jupyter require setting the stylesheet also on the 
+        # control and page control widget. But these may not exist in older 
+        # versions.
+        if hasattr(self.jupyter_widget, '_control'):
+            self.jupyter_widget._control.setStyleSheet(stylesheet)
+        if hasattr(self.jupyter_widget, '_page_control'):
+            self.jupyter_widget._page_control.setStyleSheet(stylesheet)
         
         # Connect execution_complete to auto-update workspace
         self.execution_complete.connect(self._on_execution_complete)
@@ -185,11 +194,18 @@ class JupyterConsoleTab(QWidget):
     
     def _on_execution_complete(self, output, content):
         """Automatically update workspace after regular code execution"""
+        # Prevent recursive updates
+        if self._updating_workspace:
+            return        
         # Use a small delay to ensure the kernel has processed everything
         QTimer.singleShot(100, self.update_workspace)
     
     def update_workspace(self):
         """Trigger a workspace update and emit the signal when complete"""
+        if self._updating_workspace:
+            logger.debug("Workspace update already in progress, skipping")
+            return
+        self._updating_workspace = True        
         future = self.get_workspace_async()
         future.add_done_callback(self._on_workspace_update_complete)
     
@@ -206,6 +222,9 @@ class JupyterConsoleTab(QWidget):
             logger.error(f"Error updating workspace: {e}")
             # Emit empty workspace on error
             self.workspace_updated.emit({})
+        finally:
+            self._updating_workspace = False
+                
     
     def execute_code(self, code):
         """Execute a code snippet in this kernel"""
@@ -337,78 +356,94 @@ print(json.dumps({result_var}))
         self.kernel_client.stop_channels()
         self.kernel_manager.shutdown_kernel()
 
-
 class JupyterConsole(Dock):
     """Dockable widget containing tabbed Jupyter consoles"""
     
     execution_complete = Signal(str, object)  # Signal for output interception
-    workspace_updated = Signal(dict)  # Signal for workspace updates
+    workspace_updated = Signal(dict)          # Signal for workspace updates
     
     def __init__(self, parent=None, default_kernel='python3'):
         super().__init__("Jupyter Console", parent)
         self.setObjectName('jupyter_console')
         self.default_kernel = default_kernel
+
+        # ---------------------------------------------------------------------
+        # Kernel cache
+        # ---------------------------------------------------------------------
+        self.available_kernels = []  # will be filled by refresh_kernel_menu()
         
-        # Initialize the tab widget
+        # ---------------------------------------------------------------------
+        # UI setup
+        # ---------------------------------------------------------------------
         self.tab_widget = QTabWidget()
         self.tab_widget.setTabsClosable(True)
         self.tab_widget.tabCloseRequested.connect(self.close_tab)
         self.tab_widget.currentChanged.connect(self._on_tab_changed)
         self.setWidget(self.tab_widget)
         
-        # Create corner widget with multiple buttons
+        # Corner widget with buttons
         corner_widget = QWidget()
         corner_layout = QHBoxLayout(corner_widget)
         corner_layout.setContentsMargins(0, 0, 0, 0)
         corner_layout.setSpacing(HORIZONTAL_SPACING)
         
-        # Add kernel button (for new kernels)
         self.kernel_button = QToolButton()
         self.kernel_button.setIcon(qta.icon('mdi6.plus'))
         self.kernel_button.setToolTip("Add new kernel")
         self.kernel_button.setPopupMode(QToolButton.InstantPopup)
-        self.kernel_button.setAutoRaise(True)  # Make the button flat
+        self.kernel_button.setAutoRaise(True)
         corner_layout.addWidget(self.kernel_button)
         
-        # Add restart kernel button
         self.restart_button = QToolButton()
         self.restart_button.setIcon(qta.icon('mdi6.restart'))
         self.restart_button.setToolTip("Restart current kernel")
         self.restart_button.clicked.connect(self.restart_current_kernel)
-        self.restart_button.setAutoRaise(True)  # Make the button flat
+        self.restart_button.setAutoRaise(True)
         corner_layout.addWidget(self.restart_button)
         
-        # Add interrupt kernel button
         self.interrupt_button = QToolButton()
         self.interrupt_button.setIcon(qta.icon('mdi6.stop'))
         self.interrupt_button.setToolTip("Interrupt current kernel (Ctrl+C)")
         self.interrupt_button.clicked.connect(self.interrupt_current_kernel)
-        self.interrupt_button.setAutoRaise(True)  # Make the button flat
+        self.interrupt_button.setAutoRaise(True)
         corner_layout.addWidget(self.interrupt_button)
         
-        # Set the corner widget
         self.tab_widget.setCornerWidget(corner_widget)
         
-        # Create kernel menu
+        # ---------------------------------------------------------------------
+        # Kernel menu
+        # ---------------------------------------------------------------------
         self.kernel_menu = QMenu(self.kernel_button)
         self.kernel_button.setMenu(self.kernel_menu)
         self.refresh_kernel_menu()
         
+        # ---------------------------------------------------------------------
         # Start with a default kernel
+        # ---------------------------------------------------------------------
         self.add_console_tab(self.default_kernel)
-        
+    
+    # -------------------------------------------------------------------------
+    # Helper methods
+    # -------------------------------------------------------------------------
     def _on_tab_changed(self, index):
         console_tab = self.tab_widget.widget(index)
-        console_tab.update_workspace()
+        if console_tab:
+            console_tab.update_workspace()
     
+    # -------------------------------------------------------------------------
+    # Kernel handling
+    # -------------------------------------------------------------------------
     def refresh_kernel_menu(self):
-        """Refresh the list of available kernels"""
+        """Refresh the list of available kernels and rebuild the kernel menu."""
         self.kernel_menu.clear()
         
         # Get available kernelspecs
         kernel_spec_manager = HomeAwareKernelSpecManager()
         specs = kernel_spec_manager.get_all_specs()
         
+        # Cache available kernels
+        self.available_kernels = list(specs.keys())
+        
         for spec_name, spec in specs.items():
             display_name = spec['spec']['display_name']
             action = QAction(display_name, self)
@@ -417,15 +452,26 @@ class JupyterConsole(Dock):
             self.kernel_menu.addAction(action)
     
     def kernel_menu_triggered(self):
-        """Handle kernel menu item selection"""
         action = self.sender()
         if action:
-            kernel_name = action.data()
-            self.add_console_tab(kernel_name)
+            self.add_console_tab(action.data())
     
     def add_console_tab(self, kernel_name):
-        """Add a new console tab with the specified kernel"""
-        # Create and add the new tab
+        """Add a new console tab with the specified kernel.
+        Falls back to the first available kernel if the requested one is invalid.
+        """
+        if kernel_name not in self.available_kernels:
+            if self.available_kernels:
+                fallback = self.available_kernels[0]
+                logger.warning(
+                    "Requested kernel '%s' not found. "
+                    "Falling back to '%s'.", kernel_name, fallback
+                )
+                kernel_name = fallback
+            else:
+                logger.error("No available kernels found. Cannot create console tab.")
+                return None
+        
         console_tab = JupyterConsoleTab(kernel_name=kernel_name, parent=self)
         console_tab.execution_complete.connect(self.handle_execution_complete)
         console_tab.workspace_updated.connect(self.handle_workspace_updated)
@@ -433,72 +479,60 @@ class JupyterConsole(Dock):
         self.tab_widget.setCurrentIndex(index)
         return console_tab
     
+    # -------------------------------------------------------------------------
+    # Tab / kernel management
+    # -------------------------------------------------------------------------
     def close_tab(self, index):
-        """Close a console tab and shut down its kernel"""
         widget = self.tab_widget.widget(index)
         if widget:
-            # Shut down the kernel
             widget.shutdown_kernel()
-            
-            # Remove the tab
             self.tab_widget.removeTab(index)
-            
-            # If that was the last tab, add a new one with the default kernel
             if self.tab_widget.count() == 0:
                 self.add_console_tab(self.default_kernel)
     
     def get_current_console(self):
-        """Get the currently active console tab"""
         return self.tab_widget.currentWidget()
     
     def restart_current_kernel(self):
-        """Restart the kernel in the current tab"""
         console = self.get_current_console()
         if console:
             logger.info("Restarting current kernel")
-            success = console.restart_kernel()
-            if success:
+            if console.restart_kernel():
                 logger.info("Kernel restart initiated")
             else:
                 logger.warning("Failed to restart kernel")
     
     def interrupt_current_kernel(self):
-        """Send interrupt signal to the current kernel"""
         console = self.get_current_console()
         if console:
             logger.info("Interrupting current kernel")
-            success = console.interrupt_kernel()
-            if success:
+            if console.interrupt_kernel():
                 logger.info("Interrupt signal sent to kernel")
             else:
                 logger.warning("Failed to interrupt kernel")
     
+    # -------------------------------------------------------------------------
+    # Execution helpers
+    # -------------------------------------------------------------------------
     def execute_code(self, code, silent=False):
-        """Execute code in the current console"""
         console = self.get_current_console()
         if console:
-            if silent:
-                console.execute_silently(code)
-            else:
-                console.execute_code(code)
+            (console.execute_silently if silent else console.execute_code)(code)
     
     def execute_file(self, filepath):
-        """Execute a file in the current console"""
         console = self.get_current_console()
         if console:
             console.execute_file(filepath)
     
     def change_directory(self, directory):
-        """Change working directory of the current console"""
         console = self.get_current_console()
-        if console:
-            return console.change_directory(directory)
-        return False
+        return console.change_directory(directory) if console else False
     
+    # -------------------------------------------------------------------------
+    # Signals
+    # -------------------------------------------------------------------------
     def handle_execution_complete(self, output, result):
-        """Handle execution complete signal from a console tab"""
         self.execution_complete.emit(output, result)
         
-    def handle_workspace_updated(self, dict):
-        """Handle workspace updated signal from a console tab"""
-        self.workspace_updated.emit(dict)
+    def handle_workspace_updated(self, data):
+        self.workspace_updated.emit(data)

{pyqt_code_editor-0.0.8 → pyqt_code_editor-0.0.10}/pyqt_code_editor/widgets/completion_popup.py

@@ -25,7 +25,9 @@ class CompletionPopup(QListWidget):
             }}''')
         # Use a frameless tool window so it can float above the editor
         # without stealing focus. Note we do NOT use Qt.Popup here.
-        self.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
+        self.setWindowFlags(Qt.Tool | Qt.FramelessWindowHint | 
+                            Qt.NoDropShadowWindowHint | 
+                            Qt.WindowDoesNotAcceptFocus)
 
         # Let the editor keep focus
         self.setFocusPolicy(Qt.NoFocus)