vector-inspector 0.3.9__py3-none-any.whl → 0.3.12__py3-none-any.whl

vector_inspector/ui/loading_screen.py

@@ -0,0 +1,169 @@
+import os
+
+from PySide6.QtCore import QPropertyAnimation, Qt
+from PySide6.QtGui import QFont, QPixmap
+from PySide6.QtWidgets import QCheckBox, QLabel, QVBoxLayout, QWidget
+
+
+class LoadingScreen(QWidget):
+    def __init__(self, logo_path, version, app_name, tagline, loading_text):
+        super().__init__()
+        self.setWindowFlag(Qt.FramelessWindowHint)
+        self.setWindowFlag(Qt.WindowStaysOnTopHint)
+        self.setAttribute(Qt.WA_TranslucentBackground)
+
+        # Main layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(32, 32, 32, 32)
+        layout.setSpacing(12)
+
+        # Container with background
+        container = QWidget()
+        container.setStyleSheet("background-color: #222; border-radius: 10px; color: #fff;")
+        container_layout = QVBoxLayout(container)
+        container_layout.setContentsMargins(32, 32, 32, 32)
+        container_layout.setSpacing(12)
+
+        # Logo
+        if os.path.exists(logo_path):
+            pixmap = QPixmap(logo_path).scaled(
+                128, 128, Qt.KeepAspectRatio, Qt.SmoothTransformation
+            )
+            logo_label = QLabel()
+            logo_label.setPixmap(pixmap)
+            logo_label.setAlignment(Qt.AlignCenter)
+            container_layout.addWidget(logo_label)
+
+        # App name
+        app_name_label = QLabel(app_name)
+        app_name_label.setFont(QFont("Segoe UI", 16, QFont.Bold))
+        app_name_label.setAlignment(Qt.AlignCenter)
+        app_name_label.setStyleSheet("color: #fff;")
+        container_layout.addWidget(app_name_label)
+
+        # Tagline
+        tagline_label = QLabel(tagline)
+        tagline_label.setFont(QFont("Segoe UI", 10))
+        tagline_label.setAlignment(Qt.AlignCenter)
+        tagline_label.setStyleSheet("color: #aaa;")
+        container_layout.addWidget(tagline_label)
+
+        # Version
+        version_label = QLabel(version)
+        version_label.setFont(QFont("Segoe UI", 10))
+        version_label.setAlignment(Qt.AlignCenter)
+        version_label.setStyleSheet("color: #aaa;")
+        container_layout.addWidget(version_label)
+
+        # Loading indicator
+        self.loading_label = QLabel(loading_text)
+        self.loading_label.setFont(QFont("Segoe UI", 10))
+        self.loading_label.setAlignment(Qt.AlignCenter)
+        self.loading_label.setStyleSheet("color: #6cf;")
+        container_layout.addWidget(self.loading_label)
+
+        # Skip loading screen checkbox
+        self.skip_loading_checkbox = QCheckBox("Don't show this again")
+        self.skip_loading_checkbox.setFont(QFont("Segoe UI", 9))
+        self.skip_loading_checkbox.setStyleSheet("color: #aaa; margin-top: 10px;")
+        self.skip_loading_checkbox.stateChanged.connect(self._on_skip_changed)
+        container_layout.addWidget(self.skip_loading_checkbox, alignment=Qt.AlignCenter)
+
+        layout.addWidget(container)
+        self.setLayout(layout)
+        self.resize(400, 400)
+
+        # Center on screen
+        self._center_on_screen()
+
+    def _center_on_screen(self):
+        """Center the loading screen on the primary screen."""
+        from PySide6.QtWidgets import QApplication
+
+        screen = QApplication.primaryScreen().geometry()
+        size = self.geometry()
+        self.move((screen.width() - size.width()) // 2, (screen.height() - size.height()) // 2)
+
+    def set_loading_text(self, text):
+        self.loading_label.setText(text)
+
+    def _on_skip_changed(self, state):
+        """Save the skip loading screen preference."""
+        from vector_inspector.services.settings_service import SettingsService
+
+        settings = SettingsService()
+        settings.set("hide_loading_screen", state == Qt.CheckState.Checked.value)
+
+    def fade_out(self, duration=500):
+        """Fade out the loading screen and close after animation."""
+        animation = QPropertyAnimation(self, b"windowOpacity")
+        animation.setDuration(duration)
+        animation.setStartValue(1.0)
+        animation.setEndValue(0.0)
+        animation.finished.connect(self.close)
+        animation.start()
+        self._fade_animation = animation  # Prevent garbage collection
+
+
+def show_loading_screen(app_name, version, tagline, loading_text="Initializing providers…", logo_path=None):
+    """Show the loading screen if not disabled in settings.
+    
+    This is a convenience function that handles checking settings, finding the logo,
+    creating the loading screen, and showing it. Both vector-inspector and vector-studio
+    should use this function to avoid code duplication.
+    
+    Args:
+        app_name: Name of the application (e.g., "Vector Inspector", "Vector Studio")
+        version: Version string (e.g., "v0.3.11")
+        tagline: Tagline to display under app name
+        loading_text: Initial loading message
+        logo_path: Optional explicit path to logo. If None, will look for vector-inspector's logo.
+    
+    Returns:
+        LoadingScreen instance if shown, None otherwise.
+    """
+    from vector_inspector.services.settings_service import SettingsService
+    
+    # Check if user wants to skip loading screen
+    settings = SettingsService()
+    show_loading = not settings.get("hide_loading_screen", False)
+    
+    if not show_loading:
+        return None
+    
+    # Find logo path if not provided
+    if logo_path is None:
+        # Default to vector-inspector's logo
+        module_dir = os.path.dirname(os.path.abspath(__file__))
+        # Navigate from ui/loading_screen.py to vector_inspector/assets/logo.png
+        logo_path = os.path.join(os.path.dirname(module_dir), "assets", "logo.png")
+    
+    # Create and show loading screen
+    loading = LoadingScreen(
+        logo_path=logo_path,
+        version=version,
+        app_name=app_name,
+        tagline=tagline,
+        loading_text=loading_text,
+    )
+    loading.show()
+    
+    # Force the loading screen to render
+    from PySide6.QtWidgets import QApplication
+    QApplication.instance().processEvents()
+    
+    return loading
+
+
+# Example usage (to be called from main.py):
+# from vector_inspector.ui.loading_screen import show_loading_screen
+#
+# loading = show_loading_screen(
+#     app_name="Vector Inspector",
+#     version="v0.3.11",
+#     tagline="The missing toolset for your vector data"
+# )
+# if loading:
+#     loading.set_loading_text("Loading main window...")
+#     # ... do initialization ...
+#     loading.fade_out()

vector_inspector/ui/main_window.py

@@ -1,26 +1,28 @@
 """Updated main window with multi-database support."""
 
+from typing import Optional
+
+from PySide6.QtCore import QByteArray, Qt, QTimer
+from PySide6.QtGui import QAction
 from PySide6.QtWidgets import (
-    QMessageBox,
-    QLabel,
     QApplication,
     QDialog,
-    QToolBar,
+    QLabel,
+    QMessageBox,
     QStatusBar,
+    QToolBar,
 )
-from PySide6.QtCore import Qt, QTimer, QByteArray
-from PySide6.QtGui import QAction
 
-from vector_inspector.core.connection_manager import ConnectionManager
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.connection_manager import ConnectionInstance, ConnectionManager
+from vector_inspector.core.logging import log_error
 from vector_inspector.services.profile_service import ProfileService
 from vector_inspector.services.settings_service import SettingsService
-from vector_inspector.ui.main_window_shell import InspectorShell
 from vector_inspector.ui.components.connection_manager_panel import ConnectionManagerPanel
 from vector_inspector.ui.components.profile_manager_panel import ProfileManagerPanel
-from vector_inspector.ui.tabs import InspectorTabs
 from vector_inspector.ui.controllers.connection_controller import ConnectionController
+from vector_inspector.ui.main_window_shell import InspectorShell
 from vector_inspector.ui.services.dialog_service import DialogService
+from vector_inspector.ui.tabs import InspectorTabs
 
 
 class MainWindow(InspectorShell):
@@ -199,9 +201,10 @@ class MainWindow(InspectorShell):
         help_menu.addAction(check_update_action)
 
     def _check_for_update_from_menu(self):
+        from PySide6.QtWidgets import QMessageBox
+
         from vector_inspector.services.update_service import UpdateService
         from vector_inspector.utils.version import get_app_version
-        from PySide6.QtWidgets import QMessageBox
 
         latest = UpdateService.get_latest_release(force_refresh=True)
         if latest:
@@ -255,12 +258,13 @@ class MainWindow(InspectorShell):
         self.update_indicator.mousePressEvent = self._on_update_indicator_clicked
 
         # Check for updates on launch
-        from vector_inspector.services.update_service import UpdateService
-        from vector_inspector.utils.version import get_app_version
         import threading
 
         from PySide6.QtCore import QTimer
 
+        from vector_inspector.services.update_service import UpdateService
+        from vector_inspector.utils.version import get_app_version
+
         def check_updates():
             latest = UpdateService.get_latest_release()
             if latest:
@@ -339,6 +343,28 @@ class MainWindow(InspectorShell):
         # Show update details dialog
         if not hasattr(self, "_latest_release"):
             return
+
+        # Track that user clicked on update available
+        try:
+            from vector_inspector.services.telemetry_service import TelemetryService
+            from vector_inspector.utils.version import get_app_version
+
+            telemetry = TelemetryService(self.settings_service)
+            if telemetry.is_enabled():
+                latest_version = self._latest_release.get("tag_name", "unknown")
+                event_data = {
+                    "hwid": telemetry.get_hwid(),
+                    "event_name": "update_clicked",
+                    "app_version": get_app_version(),
+                    "client_type": "vector-inspector",
+                    "metadata": {"latest_version": latest_version},
+                }
+                telemetry.queue_event(event_data)
+                telemetry.send_batch()
+        except Exception as e:
+            # Don't let telemetry errors break the update flow
+            log_error(f"Telemetry error: {e}")
+
         DialogService.show_update_details(self._latest_release, self)
 
     def _connect_signals(self):
@@ -382,9 +408,8 @@ class MainWindow(InspectorShell):
 
             # Get active connection
             active = self.connection_manager.get_active_connection()
-            conn = active.connection if active else None
 
-            self.visualization_view = VisualizationView(conn)
+            self.visualization_view = VisualizationView(active)
             # Replace placeholder with actual view
             self.remove_main_tab(InspectorTabs.VISUALIZATION_TAB)
             self.add_main_tab(
@@ -405,7 +430,7 @@ class MainWindow(InspectorShell):
                 self.breadcrumb_label.setText(instance.get_breadcrumb())
 
                 # Update all views with new connection
-                self._update_views_with_connection(instance.connection)
+                self._update_views_with_connection(instance)
 
                 # If there's an active collection, update views with it
                 if instance.active_collection:
@@ -455,7 +480,7 @@ class MainWindow(InspectorShell):
         # If this is the active connection, refresh the info panel
         if connection_id == self.connection_manager.get_active_connection_id():
             instance = self.connection_manager.get_connection(connection_id)
-            if instance and instance.connection:
+            if instance and instance.is_connected:
                 self.info_panel.refresh_database_info()
 
     def _on_collection_selected_from_panel(self, connection_id: str, collection_name: str):
@@ -473,7 +498,7 @@ class MainWindow(InspectorShell):
         finally:
             self.connection_controller.loading_dialog.hide_loading()
 
-    def _update_views_with_connection(self, connection: VectorDBConnection):
+    def _update_views_with_connection(self, connection: Optional[ConnectionInstance]):
         """Update all views with a new connection."""
         # Clear current collection when switching connections
         self.info_panel.current_collection = None
@@ -528,12 +553,12 @@ class MainWindow(InspectorShell):
     def _refresh_active_connection(self):
         """Refresh collections for the active connection."""
         active = self.connection_manager.get_active_connection()
-        if not active or not active.connection.is_connected:
+        if not active or not active.is_connected:
             QMessageBox.information(self, "No Connection", "No active connection to refresh.")
             return
 
         try:
-            collections = active.connection.list_collections()
+            collections = active.list_collections()
             self.connection_manager.update_collections(active.id, collections)
             self.statusBar().showMessage(f"Refreshed collections ({len(collections)} found)", 3000)
 

vector_inspector/ui/services/dialog_service.py

@@ -55,6 +55,7 @@ class DialogService:
 
         from vector_inspector.ui.components.backup_restore_dialog import BackupRestoreDialog
 
+        # Pass through the connection object (ConnectionInstance expected by UI)
         dialog = BackupRestoreDialog(connection, collection_name or "", parent)
         return dialog.exec()
 

vector_inspector/ui/views/collection_browser.py

@@ -1,84 +1,88 @@
 """Collection browser for listing and selecting collections."""
 
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QAction
 from PySide6.QtWidgets import (
-    QWidget, QVBoxLayout, QListWidget, QListWidgetItem,
-    QGroupBox, QLabel, QMenu
+    QGroupBox,
+    QLabel,
+    QListWidget,
+    QListWidgetItem,
+    QMenu,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import Signal, Qt
-from PySide6.QtGui import QAction
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.connection_manager import ConnectionInstance
 
 
 class CollectionBrowser(QWidget):
     """Widget for browsing and selecting collections."""
-    
+
     collection_selected = Signal(str)
-    
-    def __init__(self, connection: VectorDBConnection, parent=None):
+
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self._setup_ui()
-        
+
     def _setup_ui(self):
         """Setup widget UI."""
         layout = QVBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
-        
+
         group = QGroupBox("Collections")
         group_layout = QVBoxLayout()
-        
+
         self.collection_list = QListWidget()
         self.collection_list.itemClicked.connect(self._on_collection_clicked)
         self.collection_list.setContextMenuPolicy(Qt.CustomContextMenu)
         self.collection_list.customContextMenuRequested.connect(self._show_context_menu)
-        
+
         group_layout.addWidget(self.collection_list)
-        
+
         self.info_label = QLabel("No collections")
         self.info_label.setWordWrap(True)
         self.info_label.setStyleSheet("color: gray; font-size: 10px;")
         group_layout.addWidget(self.info_label)
-        
+
         group.setLayout(group_layout)
         layout.addWidget(group)
-        
+
     def refresh(self):
         """Refresh collection list."""
         self.collection_list.clear()
-        
+
         if not self.connection.is_connected:
             self.info_label.setText("Not connected")
             return
-            
+
         collections = self.connection.list_collections()
-        
+
         if not collections:
             # Show more context for persistent connections
             if self.connection.path:
-                self.info_label.setText(
-                    f"No collections found at {self.connection.path}"
-                )
+                self.info_label.setText(f"No collections found at {self.connection.path}")
             else:
                 self.info_label.setText("No collections found")
             return
-            
+
         for collection_name in collections:
             item = QListWidgetItem(collection_name)
             self.collection_list.addItem(item)
-            
+
         self.info_label.setText(f"{len(collections)} collection(s)")
-        
+
     def clear(self):
         """Clear collection list."""
         self.collection_list.clear()
         self.info_label.setText("No collections")
-        
+
     def _on_collection_clicked(self, item: QListWidgetItem):
         """Handle collection selection."""
         collection_name = item.text()
         self.collection_selected.emit(collection_name)
-        
+
         # Show collection info
         info = self.connection.get_collection_info(collection_name)
         if info:
@@ -87,24 +91,22 @@ class CollectionBrowser(QWidget):
             fields_str = ", ".join(fields[:3])
             if len(fields) > 3:
                 fields_str += "..."
-            self.info_label.setText(
-                f"{count} items | Fields: {fields_str if fields else 'None'}"
-            )
-            
+            self.info_label.setText(f"{count} items | Fields: {fields_str if fields else 'None'}")
+
     def _show_context_menu(self, position):
         """Show context menu for collections."""
         item = self.collection_list.itemAt(position)
         if not item:
             return
-            
+
         menu = QMenu(self)
-        
+
         delete_action = QAction("Delete Collection", self)
         delete_action.triggered.connect(lambda: self._delete_collection(item.text()))
         menu.addAction(delete_action)
-        
+
         menu.exec(self.collection_list.mapToGlobal(position))
-        
+
     def _delete_collection(self, collection_name: str):
         """Delete a collection."""
         # TODO: Add confirmation dialog

vector_inspector/ui/views/connection_view.py

@@ -1,5 +1,7 @@
 """Connection configuration view."""
 
+from typing import Optional
+
 from PySide6.QtWidgets import (
     QWidget,
     QVBoxLayout,
@@ -437,8 +439,12 @@ class ConnectionView(QWidget):
     connection_changed = Signal(bool)
     connection_created = Signal(VectorDBConnection)  # Signal when new connection is created
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[VectorDBConnection] = None, parent=None):
         super().__init__(parent)
+        # This view may be constructed without an active connection; it manages
+        # creation of `VectorDBConnection` instances. Keep `self.connection` as
+        # the low-level `VectorDBConnection` when present.
+        self._raw_connection = None
         self.connection = connection
         self.loading_dialog = LoadingDialog("Connecting to database...", self)
         self.settings_service = SettingsService()