vector-inspector 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

vector_inspector/ui/components/connection_manager_panel.py

@@ -1,30 +1,42 @@
 """Connection manager panel showing multiple active connections."""
 
 from PySide6.QtWidgets import (
-    QWidget, QVBoxLayout, QTreeWidget, QTreeWidgetItem, QPushButton,
-    QHBoxLayout, QMenu, QMessageBox, QInputDialog, QLabel
+    QWidget,
+    QVBoxLayout,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QPushButton,
+    QHBoxLayout,
+    QMenu,
+    QMessageBox,
+    QInputDialog,
+    QLabel,
 )
 from PySide6.QtCore import Qt, Signal
 from PySide6.QtGui import QIcon, QColor, QBrush
 
-from vector_inspector.core.connection_manager import ConnectionManager, ConnectionInstance, ConnectionState
+from vector_inspector.core.connection_manager import (
+    ConnectionManager,
+    ConnectionInstance,
+    ConnectionState,
+)
 
 
 class ConnectionManagerPanel(QWidget):
     """Panel for managing multiple database connections.
-    
+
     Signals:
         connection_selected: Emitted when a connection is clicked (connection_id)
         collection_selected: Emitted when a collection is clicked (connection_id, collection_name)
     """
-    
+
     connection_selected = Signal(str)  # connection_id
     collection_selected = Signal(str, str)  # connection_id, collection_name
-    
+
     def __init__(self, connection_manager: ConnectionManager, parent=None):
         """
         Initialize connection manager panel.
-        
+
         Args:
             connection_manager: The ConnectionManager instance
             parent: Parent widget
@@ -32,30 +44,30 @@ class ConnectionManagerPanel(QWidget):
         super().__init__(parent)
         self.connection_manager = connection_manager
         self._connection_items = {}  # Map connection_id to tree item
-        
+
         self._setup_ui()
         self._connect_signals()
-        
+
     def _setup_ui(self):
         """Setup the UI."""
         layout = QVBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
-        
+
         # Header
         header_layout = QHBoxLayout()
         header_label = QLabel("Connections")
         header_label.setStyleSheet("font-weight: bold; font-size: 12px;")
         header_layout.addWidget(header_label)
         header_layout.addStretch()
-        
+
         # Add connection button
         self.add_connection_btn = QPushButton("+")
         self.add_connection_btn.setMaximumWidth(30)
         self.add_connection_btn.setToolTip("Add new connection")
         header_layout.addWidget(self.add_connection_btn)
-        
+
         layout.addLayout(header_layout)
-        
+
         # Connection tree
         self.connection_tree = QTreeWidget()
         self.connection_tree.setHeaderHidden(True)
@@ -64,50 +76,54 @@ class ConnectionManagerPanel(QWidget):
         self.connection_tree.itemClicked.connect(self._on_item_clicked)
         self.connection_tree.itemExpanded.connect(self._on_item_expanded)
         # Match QListWidget selection style - use subtle highlight
-        self.connection_tree.setStyleSheet('''
+        self.connection_tree.setStyleSheet("""
             QTreeWidget::item:selected {
                 background: palette(highlight);
                 color: palette(highlighted-text);
             }
-        ''')
+        """)
         layout.addWidget(self.connection_tree)
-        
+
     def _connect_signals(self):
         """Connect to connection manager signals."""
         self.connection_manager.connection_opened.connect(self._on_connection_opened)
         self.connection_manager.connection_closed.connect(self._on_connection_closed)
         self.connection_manager.connection_state_changed.connect(self._on_connection_state_changed)
-        self.connection_manager.active_connection_changed.connect(self._on_active_connection_changed)
-        self.connection_manager.active_collection_changed.connect(self._on_active_collection_changed)
+        self.connection_manager.active_connection_changed.connect(
+            self._on_active_connection_changed
+        )
+        self.connection_manager.active_collection_changed.connect(
+            self._on_active_collection_changed
+        )
         self.connection_manager.collections_updated.connect(self._on_collections_updated)
-    
+
     def _on_connection_opened(self, connection_id: str):
         """Handle new connection opened (after successful connection)."""
         instance = self.connection_manager.get_connection(connection_id)
         if not instance:
             return
-        
+
         # Only show if not already shown
         if connection_id in self._connection_items:
             return
-        
+
         # Create tree item for connection
         item = QTreeWidgetItem(self.connection_tree)
         item.setText(0, instance.get_display_name())
         item.setData(0, Qt.UserRole, {"type": "connection", "connection_id": connection_id})
-        
+
         # Set icon/indicator based on state
         self._update_connection_indicator(item, instance.state)
-        
+
         self._connection_items[connection_id] = item
-        
+
         # Expand by default to show collections
         item.setExpanded(True)
-        
+
         # Select if active
         if self.connection_manager.get_active_connection_id() == connection_id:
             self.connection_tree.setCurrentItem(item)
-    
+
     def _on_connection_closed(self, connection_id: str):
         """Handle connection closed."""
         item = self._connection_items.pop(connection_id, None)
@@ -115,13 +131,13 @@ class ConnectionManagerPanel(QWidget):
             index = self.connection_tree.indexOfTopLevelItem(item)
             if index >= 0:
                 self.connection_tree.takeTopLevelItem(index)
-    
+
     def _on_connection_state_changed(self, connection_id: str, state: ConnectionState):
         """Handle connection state change."""
         item = self._connection_items.get(connection_id)
         if item:
             self._update_connection_indicator(item, state)
-    
+
     def _on_active_connection_changed(self, connection_id):
         """Handle active connection change."""
         # Select the active connection item in the tree
@@ -129,13 +145,13 @@ class ConnectionManagerPanel(QWidget):
             item = self._connection_items.get(connection_id)
             if item:
                 self.connection_tree.setCurrentItem(item)
-    
+
     def _on_active_collection_changed(self, connection_id: str, collection_name):
         """Handle active collection change."""
         item = self._connection_items.get(connection_id)
         if not item:
             return
-        
+
         # Select the active collection in the tree
         if collection_name:
             for i in range(item.childCount()):
@@ -144,27 +160,31 @@ class ConnectionManagerPanel(QWidget):
                 if data and data.get("collection_name") == collection_name:
                     self.connection_tree.setCurrentItem(child)
                     break
-    
+
     def _on_collections_updated(self, connection_id: str, collections: list):
         """Handle collections list updated."""
         item = self._connection_items.get(connection_id)
         if not item:
             return
-        
+
         # Remove existing collection items
         while item.childCount() > 0:
             item.removeChild(item.child(0))
-        
+
         # Add new collection items
         for collection_name in collections:
             child = QTreeWidgetItem(item)
             child.setText(0, collection_name)
-            child.setData(0, Qt.UserRole, {
-                "type": "collection",
-                "connection_id": connection_id,
-                "collection_name": collection_name
-            })
-    
+            child.setData(
+                0,
+                Qt.UserRole,
+                {
+                    "type": "collection",
+                    "connection_id": connection_id,
+                    "collection_name": collection_name,
+                },
+            )
+
     def _update_connection_indicator(self, item: QTreeWidgetItem, state: ConnectionState):
         """Update visual indicator for connection state."""
         if state == ConnectionState.CONNECTED:
@@ -175,23 +195,23 @@ class ConnectionManagerPanel(QWidget):
             indicator = "🔴"
         else:
             indicator = "⚪"
-        
+
         data = item.data(0, Qt.UserRole)
         connection_id = data.get("connection_id")
         instance = self.connection_manager.get_connection(connection_id)
-        
+
         if instance:
             item.setText(0, f"{indicator} {instance.get_display_name()}")
-    
+
     def _on_item_clicked(self, item: QTreeWidgetItem, column: int):
         """Handle tree item click."""
         data = item.data(0, Qt.UserRole)
         if not data:
             return
-        
+
         item_type = data.get("type")
         connection_id = data.get("connection_id")
-        
+
         if item_type == "connection":
             # Set as active connection
             self.connection_manager.set_active_connection(connection_id)
@@ -200,97 +220,97 @@ class ConnectionManagerPanel(QWidget):
             # Set active connection first (if different)
             if connection_id != self.connection_manager.get_active_connection_id():
                 self.connection_manager.set_active_connection(connection_id)
-            
+
             # Then set as active collection
             collection_name = data.get("collection_name")
             self.connection_manager.set_active_collection(connection_id, collection_name)
             self.collection_selected.emit(connection_id, collection_name)
-    
+
     def _on_item_expanded(self, item: QTreeWidgetItem):
         """Handle tree item expansion."""
         # Could trigger lazy loading of collections here if needed
         pass
-    
+
     def _show_context_menu(self, pos):
         """Show context menu for connection/collection."""
         item = self.connection_tree.itemAt(pos)
         if not item:
             return
-        
+
         data = item.data(0, Qt.UserRole)
         if not data:
             return
-        
+
         menu = QMenu(self)
         item_type = data.get("type")
         connection_id = data.get("connection_id")
-        
+
         if item_type == "connection":
             # Connection context menu
             set_active_action = menu.addAction("Set as Active")
             set_active_action.triggered.connect(
                 lambda: self.connection_manager.set_active_connection(connection_id)
             )
-            
+
             menu.addSeparator()
-            
+
             rename_action = menu.addAction("Rename...")
             rename_action.triggered.connect(lambda: self._rename_connection(connection_id))
-            
+
             refresh_action = menu.addAction("Refresh Collections")
             refresh_action.triggered.connect(lambda: self._refresh_collections(connection_id))
-            
+
             menu.addSeparator()
-            
+
             disconnect_action = menu.addAction("Disconnect")
             disconnect_action.triggered.connect(lambda: self._disconnect_connection(connection_id))
-        
+
         elif item_type == "collection":
             # Collection context menu
             collection_name = data.get("collection_name")
-            
+
             select_action = menu.addAction("Select Collection")
             select_action.triggered.connect(
-                lambda: self.connection_manager.set_active_collection(connection_id, collection_name)
+                lambda: self.connection_manager.set_active_collection(
+                    connection_id, collection_name
+                )
             )
-            
+
             menu.addSeparator()
-            
+
             info_action = menu.addAction("View Info")
             info_action.triggered.connect(
                 lambda: self._view_collection_info(connection_id, collection_name)
             )
-        
+
         menu.exec_(self.connection_tree.mapToGlobal(pos))
-    
+
     def _rename_connection(self, connection_id: str):
         """Rename a connection."""
         instance = self.connection_manager.get_connection(connection_id)
         if not instance:
             return
-        
+
         new_name, ok = QInputDialog.getText(
-            self,
-            "Rename Connection",
-            "Enter new name:",
-            text=instance.name
+            self, "Rename Connection", "Enter new name:", text=instance.name
         )
-        
+
         if ok and new_name:
             if self.connection_manager.rename_connection(connection_id, new_name):
                 # Update tree item
                 item = self._connection_items.get(connection_id)
                 if item:
                     self._update_connection_indicator(item, instance.state)
-    
+
     def _refresh_collections(self, connection_id: str):
         """Refresh collections for a connection."""
         instance = self.connection_manager.get_connection(connection_id)
         if not instance or not instance.connection.is_connected:
             return
-        
+
         # Show loading while refreshing
-        from ..components.loading_dialog import LoadingDialog
+        from vector_inspector.ui.components.loading_dialog import LoadingDialog
+
         loading = LoadingDialog("Refreshing collections...", self)
         loading.show_loading("Refreshing collections...")
         QApplication.processEvents()
@@ -301,27 +321,26 @@ class ConnectionManagerPanel(QWidget):
             QMessageBox.warning(self, "Error", f"Failed to refresh collections: {e}")
         finally:
             loading.hide_loading()
-    
+
     def _disconnect_connection(self, connection_id: str):
         """Disconnect a connection."""
         instance = self.connection_manager.get_connection(connection_id)
         if not instance:
             return
-        
+
         reply = QMessageBox.question(
             self,
             "Disconnect",
             f"Disconnect from '{instance.name}'?",
-            QMessageBox.Yes | QMessageBox.No
+            QMessageBox.Yes | QMessageBox.No,
         )
-        
+
         if reply == QMessageBox.Yes:
             self.connection_manager.close_connection(connection_id)
-    
+
     def _view_collection_info(self, connection_id: str, collection_name: str):
         """View collection info."""
         # This would trigger showing collection details
         # For now, just select it
         self.connection_manager.set_active_collection(connection_id, collection_name)
         self.collection_selected.emit(connection_id, collection_name)
-