vector-inspector 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

vector_inspector/ui/dialogs/provider_type_dialog.py

@@ -0,0 +1,189 @@
+"""Dialog for selecting embedding provider type (Step 1 of model selection)."""
+
+from typing import Optional, Tuple
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
+    QPushButton, QRadioButton, QButtonGroup, QGroupBox,
+    QScrollArea, QWidget
+)
+from PySide6.QtCore import Qt
+
+from vector_inspector.core.model_registry import get_model_registry
+
+
+class ProviderTypeDialog(QDialog):
+    """Dialog for selecting the provider/type category before choosing specific model."""
+    
+    # Provider categories with display info
+    PROVIDER_CATEGORIES = [
+        {
+            "id": "sentence-transformer",
+            "name": "🤗 Sentence Transformers",
+            "description": "Local models from HuggingFace\nNo API key required, runs on your machine",
+            "filter_type": "sentence-transformer",
+            "icon": "📦"
+        },
+        {
+            "id": "clip",
+            "name": "🖼️ CLIP Models",
+            "description": "Multimodal embeddings (text + images)\nLocal models, no API key required",
+            "filter_type": "clip",
+            "icon": "🎨"
+        },
+        {
+            "id": "openai",
+            "name": "☁️ OpenAI API",
+            "description": "Cloud-based embeddings\nRequires OpenAI API key",
+            "filter_type": "openai",
+            "icon": "🔑"
+        },
+        {
+            "id": "cohere",
+            "name": "☁️ Cohere API",
+            "description": "Cloud-based embeddings\nRequires Cohere API key",
+            "filter_type": "cohere",
+            "icon": "🔑"
+        },
+        {
+            "id": "vertex-ai",
+            "name": "☁️ Google Vertex AI",
+            "description": "Cloud-based embeddings\nRequires Google Cloud credentials",
+            "filter_type": "vertex-ai",
+            "icon": "🔑"
+        },
+        {
+            "id": "voyage",
+            "name": "☁️ Voyage AI",
+            "description": "Cloud-based embeddings\nRequires Voyage API key",
+            "filter_type": "voyage",
+            "icon": "🔑"
+        },
+        {
+            "id": "custom",
+            "name": "✏️ Custom Model",
+            "description": "Enter your own model name\nFor models not in the registry",
+            "filter_type": None,  # Special case
+            "icon": "⚙️"
+        }
+    ]
+    
+    def __init__(self, collection_name: str, vector_dimension: int, parent=None):
+        super().__init__(parent)
+        self.collection_name = collection_name
+        self.vector_dimension = vector_dimension
+        self.selected_type = None
+        
+        self.setWindowTitle("Select Embedding Provider Type")
+        self.setMinimumWidth(550)
+        self.setMinimumHeight(500)
+        self._setup_ui()
+        
+    def _setup_ui(self):
+        """Setup dialog UI."""
+        layout = QVBoxLayout(self)
+        
+        # Header
+        header = QLabel(f"<h3>Select Provider Type</h3>")
+        layout.addWidget(header)
+        
+        info = QLabel(f"<b>Collection:</b> {self.collection_name}<br>"
+                     f"<b>Vector Dimension:</b> {self.vector_dimension}")
+        layout.addWidget(info)
+        
+        layout.addWidget(QLabel("<i>Choose the type of embedding provider to use:</i>"))
+        
+        # Scroll area for provider options
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        
+        scroll_widget = QWidget()
+        scroll_layout = QVBoxLayout(scroll_widget)
+        scroll_layout.setSpacing(10)
+        
+        # Radio button group
+        self.button_group = QButtonGroup(self)
+        
+        # Get registry to count models
+        registry = get_model_registry()
+        
+        # Create radio buttons for each provider type
+        for i, category in enumerate(self.PROVIDER_CATEGORIES):
+            provider_id = category["id"]
+            
+            # Count available models for this type + dimension
+            if provider_id == "custom":
+                count_text = "Enter manually"
+            else:
+                filter_type = category["filter_type"]
+                models = registry.get_models_by_dimension(self.vector_dimension)
+                matching = [m for m in models if m.type == filter_type]
+                count = len(matching)
+                
+                if count == 0:
+                    continue  # Skip categories with no models for this dimension
+                
+                count_text = f"{count} model{'s' if count != 1 else ''} available"
+            
+            # Create group box for this option
+            group = QGroupBox()
+            group_layout = QVBoxLayout()
+            
+            # Radio button
+            radio = QRadioButton(category["name"])
+            radio.setProperty("provider_id", provider_id)
+            self.button_group.addButton(radio, i)
+            group_layout.addWidget(radio)
+            
+            # Description
+            desc_label = QLabel(category["description"])
+            desc_label.setStyleSheet("color: gray; margin-left: 25px;")
+            desc_label.setWordWrap(True)
+            group_layout.addWidget(desc_label)
+            
+            # Count
+            count_label = QLabel(f"<b>{count_text}</b>")
+            count_label.setStyleSheet("margin-left: 25px; color: #0066cc;")
+            group_layout.addWidget(count_label)
+            
+            group.setLayout(group_layout)
+            scroll_layout.addWidget(group)
+        
+        scroll_layout.addStretch()
+        scroll.setWidget(scroll_widget)
+        layout.addWidget(scroll)
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        
+        self.next_btn = QPushButton("Next →")
+        self.next_btn.clicked.connect(self._on_next)
+        self.next_btn.setEnabled(False)
+        self.next_btn.setDefault(True)
+        
+        # Enable Next when selection is made
+        self.button_group.buttonClicked.connect(lambda: self.next_btn.setEnabled(True))
+        
+        button_layout.addWidget(cancel_btn)
+        button_layout.addWidget(self.next_btn)
+        
+        layout.addLayout(button_layout)
+    
+    def _on_next(self):
+        """Handle Next button click."""
+        selected_button = self.button_group.checkedButton()
+        if selected_button:
+            self.selected_type = selected_button.property("provider_id")
+            self.accept()
+    
+    def get_selected_type(self) -> Optional[str]:
+        """Get the selected provider type ID.
+        
+        Returns:
+            Provider type ID or None if cancelled
+        """
+        return self.selected_type

vector_inspector/ui/main_window.py

@@ -12,6 +12,7 @@ from vector_inspector.core.connection_manager import ConnectionManager, Connecti
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
 from vector_inspector.core.connections.qdrant_connection import QdrantConnection
+from vector_inspector.core.connections.pinecone_connection import PineconeConnection
 from vector_inspector.services.profile_service import ProfileService
 from vector_inspector.services.settings_service import SettingsService
 from vector_inspector.ui.components.connection_manager_panel import ConnectionManagerPanel
@@ -219,6 +220,7 @@ class MainWindow(QMainWindow):
         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)
+        self.connection_manager.connection_opened.connect(self._on_connection_opened)
         
         # Connection panel signals
         self.connection_panel.collection_selected.connect(self._on_collection_selected_from_panel)
@@ -277,17 +279,36 @@ class MainWindow(QMainWindow):
             
             # Update views if this is the active connection
             if connection_id == self.connection_manager.get_active_connection_id():
+                # Show loading immediately when collection changes
                 if collection_name:
-                    self._update_views_for_collection(collection_name)
+                    self.loading_dialog.show_loading(f"Loading collection '{collection_name}'...")
+                    QApplication.processEvents()
+                    try:
+                        self._update_views_for_collection(collection_name)
+                    finally:
+                        self.loading_dialog.hide_loading()
                 else:
                     # Clear collection from views
-                    self._update_views_for_collection(None)
+                    self.loading_dialog.show_loading("Clearing collection...")
+                    QApplication.processEvents()
+                    try:
+                        self._update_views_for_collection(None)
+                    finally:
+                        self.loading_dialog.hide_loading()
     
     def _on_collections_updated(self, connection_id: str, collections: list):
         """Handle collections list updated."""
         # UI automatically updates via connection_manager_panel
         pass
     
+    def _on_connection_opened(self, connection_id: str):
+        """Handle connection successfully opened."""
+        # 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:
+                self.info_panel.refresh_database_info()
+    
     def _on_collection_selected_from_panel(self, connection_id: str, collection_name: str):
         """Handle collection selection from connection panel."""
         # Show loading dialog while switching collections
@@ -378,6 +399,8 @@ class MainWindow(QMainWindow):
                 connection = self._create_chroma_connection(config, credentials)
             elif provider == "qdrant":
                 connection = self._create_qdrant_connection(config, credentials)
+            elif provider == "pinecone":
+                connection = self._create_pinecone_connection(config, credentials)
             else:
                 QMessageBox.warning(self, "Error", f"Unsupported provider: {provider}")
                 return
@@ -439,6 +462,14 @@ class MainWindow(QMainWindow):
         else:  # ephemeral
             return QdrantConnection()
     
+    def _create_pinecone_connection(self, config: dict, credentials: dict) -> PineconeConnection:
+        """Create a Pinecone connection."""
+        api_key = credentials.get("api_key")
+        if not api_key:
+            raise ValueError("Pinecone requires an API key")
+        
+        return PineconeConnection(api_key=api_key)
+    
     def _on_connection_finished(self, connection_id: str, success: bool, collections: list, error: str):
         """Handle connection thread completion."""
         self.loading_dialog.hide_loading()

vector_inspector/ui/views/connection_view.py

@@ -10,6 +10,7 @@ from PySide6.QtCore import Signal, QThread
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
 from vector_inspector.core.connections.qdrant_connection import QdrantConnection
+from vector_inspector.core.connections.pinecone_connection import PineconeConnection
 from vector_inspector.ui.components.loading_dialog import LoadingDialog
 from vector_inspector.services.settings_service import SettingsService
 
@@ -66,6 +67,7 @@ class ConnectionDialog(QDialog):
         self.provider_combo = QComboBox()
         self.provider_combo.addItem("ChromaDB", "chromadb")
         self.provider_combo.addItem("Qdrant", "qdrant")
+        self.provider_combo.addItem("Pinecone", "pinecone")
         self.provider_combo.currentIndexChanged.connect(self._on_provider_changed)
         provider_layout.addWidget(self.provider_combo)
         provider_group.setLayout(provider_layout)
@@ -179,19 +181,42 @@ class ConnectionDialog(QDialog):
             if self.port_input.text() == "6333":
                 self.port_input.setText("8000")
         
-        # Show/hide API key field
-        is_http = self.http_radio.isChecked()
-        self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
+        # For Pinecone, hide persistent/HTTP options and only show API key
+        if self.provider == "pinecone":
+            self.persistent_radio.setEnabled(False)
+            self.http_radio.setEnabled(True)
+            self.http_radio.setChecked(True)
+            self.ephemeral_radio.setEnabled(False)
+            self.path_input.setEnabled(False)
+            self.host_input.setEnabled(False)
+            self.port_input.setEnabled(False)
+            self.api_key_input.setEnabled(True)
+        else:
+            self.persistent_radio.setEnabled(True)
+            self.http_radio.setEnabled(True)
+            self.ephemeral_radio.setEnabled(True)
+            # Show/hide API key field
+            is_http = self.http_radio.isChecked()
+            self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
+            # Update path/host/port based on connection type
+            self._on_type_changed()
         
     def _on_type_changed(self):
         """Handle connection type change."""
         is_persistent = self.persistent_radio.isChecked()
         is_http = self.http_radio.isChecked()
         
-        self.path_input.setEnabled(is_persistent)
-        self.host_input.setEnabled(is_http)
-        self.port_input.setEnabled(is_http)
-        self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
+        # Pinecone always uses API key, no path/host/port
+        if self.provider == "pinecone":
+            self.path_input.setEnabled(False)
+            self.host_input.setEnabled(False)
+            self.port_input.setEnabled(False)
+            self.api_key_input.setEnabled(True)
+        else:
+            self.path_input.setEnabled(is_persistent)
+            self.host_input.setEnabled(is_http)
+            self.port_input.setEnabled(is_http)
+            self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
 
         self._update_absolute_preview()
         
@@ -202,7 +227,13 @@ class ConnectionDialog(QDialog):
         
         config = {"provider": self.provider}
         
-        if self.persistent_radio.isChecked():
+        # Pinecone only needs API key
+        if self.provider == "pinecone":
+            config.update({
+                "type": "cloud",
+                "api_key": self.api_key_input.text()
+            })
+        elif self.persistent_radio.isChecked():
             config.update({"type": "persistent", "path": self.path_input.text()})
         elif self.http_radio.isChecked():
             config.update({
@@ -286,7 +317,13 @@ class ConnectionDialog(QDialog):
         
         # Set connection type
         conn_type = last_config.get("type", "persistent")
-        if conn_type == "persistent":
+        if conn_type == "cloud":
+            # Pinecone cloud connection
+            self.http_radio.setChecked(True)
+            api_key = last_config.get("api_key")
+            if api_key:
+                self.api_key_input.setText(api_key)
+        elif conn_type == "persistent":
             self.persistent_radio.setChecked(True)
             path = last_config.get("path", "")
             if path:
@@ -370,7 +407,15 @@ class ConnectionView(QWidget):
         conn_type = config.get("type")
         
         # Create appropriate connection instance based on provider
-        if provider == "qdrant":
+        if provider == "pinecone":
+            api_key = config.get("api_key")
+            if not api_key:
+                self.loading_dialog.hide_loading()
+                from PySide6.QtWidgets import QMessageBox
+                QMessageBox.warning(self, "Missing API Key", "Pinecone requires an API key to connect.")
+                return
+            self.connection = PineconeConnection(api_key=api_key)
+        elif provider == "qdrant":
             if conn_type == "persistent":
                 self.connection = QdrantConnection(path=config.get("path"))
             elif conn_type == "http":

vector_inspector/ui/views/info_panel.py

@@ -7,10 +7,12 @@ from PySide6.QtWidgets import (
 )
 from PySide6.QtCore import Qt, QObject
 from PySide6.QtWidgets import QDialog
+from PySide6.QtWidgets import QApplication
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
 from vector_inspector.core.connections.qdrant_connection import QdrantConnection
+from vector_inspector.core.connections.pinecone_connection import PineconeConnection
 from vector_inspector.core.cache_manager import get_cache_manager
 
 
@@ -199,6 +201,15 @@ class InfoPanel(QWidget):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
+                
+        elif isinstance(self.connection, PineconeConnection):
+            self._update_label(self.connection_type_label, "Cloud")
+            self._update_label(self.endpoint_label, "Pinecone Cloud")
+            
+            if self.connection.api_key:
+                self._update_label(self.api_key_label, "Present (hidden)")
+            else:
+                self._update_label(self.api_key_label, "Not configured")
         else:
             self._update_label(self.connection_type_label, "Unknown")
             self._update_label(self.endpoint_label, "N/A")
@@ -317,6 +328,18 @@ class InfoPanel(QWidget):
                     opt = config["optimizer_config"]
                     details_list.append(f"• Indexing threshold: {opt.get('indexing_threshold', 'N/A')}")
         
+        elif isinstance(self.connection, PineconeConnection):
+            details_list.append("• Provider: Pinecone")
+            details_list.append("• Supports: Vectors, Metadata")
+            details_list.append("• Cloud-hosted vector database")
+            # Add Pinecone-specific info if available
+            if "host" in collection_info:
+                details_list.append(f"• Host: {collection_info['host']}")
+            if "status" in collection_info:
+                details_list.append(f"• Status: {collection_info['status']}")
+            if "spec" in collection_info:
+                details_list.append(f"• Spec: {collection_info['spec']}")
+        
         if details_list:
             self.provider_details_label.setText("\n".join(details_list))
             self.provider_details_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
@@ -358,18 +381,24 @@ class InfoPanel(QWidget):
         # Check if stored in collection metadata
         if 'embedding_model' in collection_info:
             model_name = collection_info['embedding_model']
-            model_type = collection_info.get('embedding_model_type', 'unknown')
+            model_type = collection_info.get('embedding_model_type', 'stored')
             self.embedding_model_label.setText(f"{model_name} ({model_type})")
             self.embedding_model_label.setStyleSheet("color: lightgreen;")
             return
         
+        # Try to get from connection using the helper method
+        if self.connection and self.current_collection:
+            detected_model = self.connection.get_embedding_model(self.current_collection, self.connection_id)
+            if detected_model:
+                self.embedding_model_label.setText(f"{detected_model} (detected)")
+                self.embedding_model_label.setStyleSheet("color: lightgreen;")
+                return
+        
         # Check user settings
         settings = SettingsService()
-        collection_models = settings.get('collection_embedding_models', {})
-        collection_key = f"{self.connection_id}:{self.current_collection}"
+        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
         
-        if collection_key in collection_models:
-            model_info = collection_models[collection_key]
+        if model_info:
             model_name = model_info['model']
             model_type = model_info.get('type', 'unknown')
             self.embedding_model_label.setText(f"{model_name} ({model_type})")
@@ -385,11 +414,21 @@ class InfoPanel(QWidget):
         if not self.current_collection:
             return
         
-        from ..dialogs.embedding_config_dialog import EmbeddingConfigDialog
+        # Show loading immediately; preparing can touch DB/registry
+        from ..components.loading_dialog import LoadingDialog
+        loading = LoadingDialog("Preparing model configuration...", self)
+        loading.show_loading("Preparing model configuration...")
+        QApplication.processEvents()
+
+        from ..dialogs import ProviderTypeDialog, EmbeddingConfigDialog
         from ...services.settings_service import SettingsService
         
         # Get current collection info
-        collection_info = self.connection.get_collection_info(self.current_collection)
+        try:
+            collection_info = self.connection.get_collection_info(self.current_collection)
+        finally:
+            # Hide loading before presenting dialogs
+            loading.hide_loading()
         if not collection_info:
             return
         
@@ -399,8 +438,6 @@ class InfoPanel(QWidget):
         
         # Get current configuration if any
         settings = SettingsService()
-        collection_models = settings.get('collection_embedding_models', {})
-        collection_key = f"{self.connection_id}:{self.current_collection}"
         
         current_model = None
         current_type = None
@@ -408,37 +445,49 @@ class InfoPanel(QWidget):
         # Check metadata first
         if 'embedding_model' in collection_info:
             current_model = collection_info['embedding_model']
-            current_type = collection_info.get('embedding_model_type')
+            current_type = collection_info.get('embedding_model_type', 'stored')
         # Then check settings
-        elif collection_key in collection_models:
-            model_info = collection_models[collection_key]
-            current_model = model_info.get('model')
-            current_type = model_info.get('type')
+        else:
+            model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+            if model_info:
+                current_model = model_info.get('model')
+                current_type = model_info.get('type')
+        
+        # Step 1: Provider Type Selection
+        type_dialog = ProviderTypeDialog(
+            self.current_collection,
+            vector_dim,
+            self
+        )
+        
+        type_result = type_dialog.exec()
+        if type_result != QDialog.DialogCode.Accepted:
+            return  # User cancelled
         
-        # Open dialog
-        dialog = EmbeddingConfigDialog(
+        provider_type = type_dialog.get_selected_type()
+        if not provider_type:
+            return
+        
+        # Step 2: Model Selection (filtered by provider type)
+        model_dialog = EmbeddingConfigDialog(
             self.current_collection,
             vector_dim,
+            provider_type,
             current_model,
             current_type,
             self
         )
         
-        result = dialog.exec()
+        # Optionally show brief loading while populating models
+        # (dialog itself handles content; only show if provider lists are large)
+        result = model_dialog.exec()
         
         if result == QDialog.DialogCode.Accepted:
-            # Save the configuration
-            selection = dialog.get_selection()
+            # Save the configuration using the new SettingsService method
+            selection = model_dialog.get_selection()
             if selection:
                 model_name, model_type = selection
-                
-                if collection_key not in collection_models:
-                    collection_models[collection_key] = {}
-                
-                collection_models[collection_key]['model'] = model_name
-                collection_models[collection_key]['type'] = model_type
-                
-                settings.set('collection_embedding_models', collection_models)
+                settings.save_embedding_model(self.connection_id, self.current_collection, model_name, model_type)
                 
                 # Refresh display
                 self._update_embedding_model_display(collection_info)
@@ -446,12 +495,10 @@ class InfoPanel(QWidget):
                 print(f"✓ Configured embedding model for '{self.current_collection}': {model_name} ({model_type})")
                 
         elif result == 2:  # Clear configuration
-            # Remove from settings
-            if collection_key in collection_models:
-                del collection_models[collection_key]
-                settings.set('collection_embedding_models', collection_models)
-                
-                # Refresh display
-                self._update_embedding_model_display(collection_info)
-                
-                print(f"✓ Cleared embedding model configuration for '{self.current_collection}'")
+            # Remove from settings using the new SettingsService method
+            settings.remove_embedding_model(self.connection_id, self.current_collection)
+            
+            # Refresh display
+            self._update_embedding_model_display(collection_info)
+            
+            print(f"✓ Cleared embedding model configuration for '{self.current_collection}'")

vector_inspector/ui/views/search_view.py

@@ -202,7 +202,7 @@ class SearchView(QWidget):
         QApplication.processEvents()
         
         try:
-            # Perform query
+            # Always pass query_texts; provider handles embedding if needed
             results = self.connection.query_collection(
                 self.current_collection,
                 query_texts=[query_text],

vector_inspector/ui/views/visualization_view.py

@@ -13,6 +13,7 @@ import numpy as np
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.services.visualization_service import VisualizationService
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
 
 class VisualizationThread(QThread):
@@ -106,6 +107,9 @@ class VisualizationView(QWidget):
         self.status_label.setMaximumHeight(30)
         layout.addWidget(self.status_label)
         
+        # Loading dialog for data fetch and reduction
+        self.loading_dialog = LoadingDialog("Loading visualization...", self)
+        
     def set_collection(self, collection_name: str):
         """Set the current collection to visualize."""
         self.current_collection = collection_name
@@ -119,12 +123,17 @@ class VisualizationView(QWidget):
             QMessageBox.warning(self, "No Collection", "Please select a collection first.")
             return
             
-        # Load data with embeddings
+        # Load data with embeddings (show loading immediately)
+        self.loading_dialog.show_loading("Loading data for visualization...")
+        QApplication.processEvents()
         sample_size = self.sample_spin.value()
-        data = self.connection.get_all_items(
-            self.current_collection,
-            limit=sample_size
-        )
+        try:
+            data = self.connection.get_all_items(
+                self.current_collection,
+                limit=sample_size
+            )
+        finally:
+            self.loading_dialog.hide_loading()
         
         if data is None or not data or "embeddings" not in data or data["embeddings"] is None or len(data["embeddings"]) == 0:
             QMessageBox.warning(
@@ -152,10 +161,14 @@ class VisualizationView(QWidget):
         )
         self.visualization_thread.finished.connect(self._on_reduction_finished)
         self.visualization_thread.error.connect(self._on_reduction_error)
+        # Show loading during reduction
+        self.loading_dialog.show_loading("Reducing dimensions...")
+        QApplication.processEvents()
         self.visualization_thread.start()
         
     def _on_reduction_finished(self, reduced_data: Any):
         """Handle dimensionality reduction completion."""
+        self.loading_dialog.hide_loading()
         self.reduced_data = reduced_data
         self._create_plot()
         self.generate_button.setEnabled(True)
@@ -163,6 +176,7 @@ class VisualizationView(QWidget):
         
     def _on_reduction_error(self, error_msg: str):
         """Handle dimensionality reduction error."""
+        self.loading_dialog.hide_loading()
         print(f"Error: Visualization failed: {error_msg}")
         QMessageBox.warning(self, "Error", f"Visualization failed: {error_msg}")
         self.generate_button.setEnabled(True)

{vector_inspector-0.2.7.dist-info → vector_inspector-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.2.7
+Version: 0.3.1
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT