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

vector_inspector/ui/views/info_panel.py

@@ -1,33 +1,34 @@
 """Information panel for displaying database and collection metadata."""
 
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
+    QApplication,
+    QDialog,
+    QGroupBox,
     QHBoxLayout,
     QLabel,
-    QGroupBox,
-    QScrollArea,
-    QFrame,
     QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
 )
-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.cache_manager import get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
 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
+from vector_inspector.core.connections.qdrant_connection import QdrantConnection
 from vector_inspector.core.logging import log_info
 
 
 class InfoPanel(QWidget):
     """Panel for displaying database and collection information."""
 
-    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.connection_id: str = ""  # Will be set when collection is set
         self.current_collection: str = ""
@@ -149,8 +150,29 @@ class InfoPanel(QWidget):
         """Clear the embedding model configuration for this collection (reset to autodetect)."""
         from vector_inspector.services.settings_service import SettingsService
 
+        # Ensure we have a valid connection_id
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id:
+            log_info("Cannot clear embedding model: no connection_id available")
+            return
+
         settings = SettingsService()
-        settings.remove_embedding_model(self.connection_id, self.current_collection)
+        settings.remove_embedding_model(
+            self.connection.name if self.connection else "",
+            self.current_collection,
+        )
+
+        # Clear cache to ensure fresh collection info on next load
+        if effective_connection_id and self.current_collection:
+            self.cache_manager.invalidate(effective_connection_id, self.current_collection)
+            log_info(
+                "Cleared cache for collection after clearing embedding model: %s",
+                self.current_collection,
+            )
+
         # Refresh display (force reload collection info)
         if self.current_collection:
             self.set_collection(self.current_collection, self.current_database)
@@ -163,13 +185,21 @@ class InfoPanel(QWidget):
         """Update the clear button state based on current configuration."""
         from vector_inspector.services.settings_service import SettingsService
 
-        if not self.connection_id or not self.current_collection:
+        # Ensure we have valid identifiers
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id or not self.current_collection:
             self.clear_embedding_btn.setEnabled(False)
             return
 
         # Check if there's a user-configured model in settings
         settings = SettingsService()
-        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+        model_info = settings.get_embedding_model(
+            self.connection.name if self.connection else "",
+            self.current_collection,
+        )
 
         # Enable button if there's a user-configured model
         self.clear_embedding_btn.setEnabled(model_info is not None)
@@ -213,50 +243,48 @@ class InfoPanel(QWidget):
             return
 
         # Get provider name
-        provider_name = self.connection.__class__.__name__.replace("Connection", "")
+        # Extract the underlying database connection from ConnectionInstance wrapper.
+        backend = getattr(self.connection, "database", self.connection)
+        provider_name = (
+            backend.__class__.__name__.replace("Connection", "") if backend else "Unknown"
+        )
         self._update_label(self.provider_label, provider_name)
 
         # Get connection details
-        if isinstance(self.connection, ChromaDBConnection):
-            if self.connection.path:
+        if isinstance(backend, ChromaDBConnection):
+            if getattr(backend, "path", None):
                 self._update_label(self.connection_type_label, "Persistent (Local)")
-                self._update_label(self.endpoint_label, self.connection.path)
-            elif self.connection.host and self.connection.port:
+                self._update_label(self.endpoint_label, backend.path)
+            elif getattr(backend, "host", None) and getattr(backend, "port", None):
                 self._update_label(self.connection_type_label, "HTTP (Remote)")
-                self._update_label(
-                    self.endpoint_label, f"{self.connection.host}:{self.connection.port}"
-                )
+                self._update_label(self.endpoint_label, f"{backend.host}:{backend.port}")
             else:
                 self._update_label(self.connection_type_label, "Ephemeral (In-Memory)")
                 self._update_label(self.endpoint_label, "N/A")
             self._update_label(self.api_key_label, "Not required")
-
-        elif isinstance(self.connection, QdrantConnection):
-            if self.connection.path:
+        elif isinstance(backend, QdrantConnection):
+            if getattr(backend, "path", None):
                 self._update_label(self.connection_type_label, "Embedded (Local)")
-                self._update_label(self.endpoint_label, self.connection.path)
-            elif self.connection.url:
+                self._update_label(self.endpoint_label, backend.path)
+            elif getattr(backend, "url", None):
                 self._update_label(self.connection_type_label, "Remote (URL)")
-                self._update_label(self.endpoint_label, self.connection.url)
-            elif self.connection.host:
+                self._update_label(self.endpoint_label, backend.url)
+            elif getattr(backend, "host", None):
                 self._update_label(self.connection_type_label, "Remote (Host)")
-                self._update_label(
-                    self.endpoint_label, f"{self.connection.host}:{self.connection.port}"
-                )
+                self._update_label(self.endpoint_label, f"{backend.host}:{backend.port}")
             else:
                 self._update_label(self.connection_type_label, "In-Memory")
                 self._update_label(self.endpoint_label, "N/A")
-
-            if self.connection.api_key:
+            if getattr(backend, "api_key", None):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
 
-        elif isinstance(self.connection, PineconeConnection):
+        elif isinstance(backend, PineconeConnection):
+            # backend already assigned above
             self._update_label(self.connection_type_label, "Cloud")
             self._update_label(self.endpoint_label, "Pinecone Cloud")
-
-            if self.connection.api_key:
+            if getattr(backend, "api_key", None):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
@@ -274,7 +302,7 @@ class InfoPanel(QWidget):
         try:
             collections = self.connection.list_collections()
             self._update_label(self.collections_count_label, str(len(collections)))
-        except Exception as e:
+        except Exception:
             self._update_label(self.collections_count_label, "Error")
 
     def refresh_collection_info(self):
@@ -323,11 +351,11 @@ class InfoPanel(QWidget):
             self._update_label(self.vector_dim_label, "Error")
             self._update_label(self.distance_metric_label, "Error")
             self._update_label(self.total_points_label, "Error")
-            self.schema_label.setText(f"Error: {str(e)}")
+            self.schema_label.setText(f"Error: {e!s}")
             self.schema_label.setStyleSheet("color: red; padding-left: 20px;")
             self.provider_details_label.setText("N/A")
 
-    def _display_collection_info(self, collection_info: Dict[str, Any]):
+    def _display_collection_info(self, collection_info: dict[str, Any]):
         """Display collection information (from cache or fresh query)."""
         # Update basic info
         self._update_label(self.collection_name_label, self.current_collection)
@@ -395,6 +423,11 @@ class InfoPanel(QWidget):
             details_list.append("• Provider: Pinecone")
             details_list.append("• Supports: Vectors, Metadata")
             details_list.append("• Cloud-hosted vector database")
+            # Check if using Pinecone-hosted embedding model
+            if collection_info.get("embedding_model_type") == "pinecone-hosted":
+                hosted_model = collection_info.get("embedding_model", "Unknown")
+                details_list.append(f"• Hosted Model: {hosted_model}")
+                details_list.append("• Supports text-based queries (no local embedding needed)")
             # Add Pinecone-specific info if available
             if "host" in collection_info:
                 details_list.append(f"• Host: {collection_info['host']}")
@@ -443,7 +476,7 @@ class InfoPanel(QWidget):
         if value_label and isinstance(value_label, QLabel):
             value_label.setText(value)
 
-    def _update_embedding_model_display(self, collection_info: Dict[str, Any]):
+    def _update_embedding_model_display(self, collection_info: dict[str, Any]):
         """Update the embedding model label based on current configuration."""
         from vector_inspector.services.settings_service import SettingsService
 
@@ -459,20 +492,28 @@ class InfoPanel(QWidget):
             self.clear_embedding_btn.setEnabled(True)
             return
 
+        # Ensure we have a valid connection_id for settings lookup
+        # Fallback to connection.id if connection_id not set
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
         # 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
-            )
+            detected_model = self.connection.get_embedding_model(self.current_collection)
             if detected_model:
                 self.embedding_model_label.setText(f"{detected_model} (detected)")
                 self.embedding_model_label.setStyleSheet("color: lightgreen;")
                 self.clear_embedding_btn.setEnabled(False)
                 return
 
-        # Check user settings
+        # Check user settings directly
         settings = SettingsService()
-        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+        profile_name = self.connection.name if self.connection else ""
+        model_info = settings.get_embedding_model(
+            profile_name,
+            self.current_collection,
+        )
 
         if model_info:
             model_name = model_info["model"]
@@ -492,6 +533,14 @@ class InfoPanel(QWidget):
         if not self.current_collection:
             return
 
+        # Ensure we have a valid connection_id
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id:
+            return
+
         # Show loading immediately; preparing can touch DB/registry
         from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
@@ -499,8 +548,8 @@ class InfoPanel(QWidget):
         loading.show_loading("Preparing model configuration...")
         QApplication.processEvents()
 
-        from vector_inspector.ui.dialogs import ProviderTypeDialog, EmbeddingConfigDialog
         from vector_inspector.services.settings_service import SettingsService
+        from vector_inspector.ui.dialogs import EmbeddingConfigDialog, ProviderTypeDialog
 
         # Get current collection info
         try:
@@ -527,7 +576,10 @@ class InfoPanel(QWidget):
             current_type = collection_info.get("embedding_model_type", "stored")
         # Then check settings
         else:
-            model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+            model_info = settings.get_embedding_model(
+                self.connection.name if self.connection else "",
+                self.current_collection,
+            )
             if model_info:
                 current_model = model_info.get("model")
                 current_type = model_info.get("type")
@@ -558,9 +610,20 @@ class InfoPanel(QWidget):
             if selection:
                 model_name, model_type = selection
                 settings.save_embedding_model(
-                    self.connection_id, self.current_collection, model_name, model_type
+                    self.connection.name if self.connection else "",
+                    self.current_collection,
+                    model_name,
+                    model_type,
                 )
 
+                # Clear cache to ensure fresh collection info on next load
+                if effective_connection_id and self.current_collection:
+                    self.cache_manager.invalidate(effective_connection_id, self.current_collection)
+                    log_info(
+                        "Cleared cache for collection after configuring embedding model: %s",
+                        self.current_collection,
+                    )
+
                 # Update the display immediately to show new model
                 self.embedding_model_label.setText(f"{model_name} ({model_type})")
                 self.embedding_model_label.setStyleSheet("color: lightblue;")
@@ -577,7 +640,10 @@ class InfoPanel(QWidget):
 
         elif result == 2:  # Clear configuration
             # Remove from settings using the new SettingsService method
-            settings.remove_embedding_model(self.connection_id, self.current_collection)
+            settings.remove_embedding_model(
+                self.connection.name if self.connection else "",
+                self.current_collection,
+            )
 
             # Refresh display
             self._update_embedding_model_display(collection_info)

vector_inspector/ui/views/metadata_view.py

@@ -1,38 +1,36 @@
 """Metadata browsing and data view."""
 
-from typing import Optional, Dict, Any, List
+import math
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt, QThread, QTimer, Signal
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QPushButton,
+    QApplication,
     QCheckBox,
-    QLabel,
-    QSpinBox,
-    QLineEdit,
-    QComboBox,
-    QGroupBox,
-    QHeaderView,
-    QMessageBox,
     QDialog,
     QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
     QMenu,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import Qt, QTimer, QThread, Signal
-import math
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
-from vector_inspector.ui.components.item_dialog import ItemDialog
-from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.ui.components.filter_builder import FilterBuilder
-from vector_inspector.services.import_export_service import ImportExportService
+from vector_inspector.core.cache_manager import CacheEntry, get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_info
 from vector_inspector.services.filter_service import apply_client_side_filters
+from vector_inspector.services.import_export_service import ImportExportService
 from vector_inspector.services.settings_service import SettingsService
-from vector_inspector.core.cache_manager import get_cache_manager, CacheEntry
-from PySide6.QtWidgets import QApplication
-from vector_inspector.core.logging import log_info
+from vector_inspector.ui.components.filter_builder import FilterBuilder
+from vector_inspector.ui.components.item_dialog import ItemDialog
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
 
 class DataLoadThread(QThread):
@@ -66,12 +64,13 @@ class DataLoadThread(QThread):
 class MetadataView(QWidget):
     """View for browsing collection data and metadata."""
 
-    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.current_collection: str = ""
         self.current_database: str = ""
-        self.current_data: Optional[Dict[str, Any]] = None
+        self.current_data: Optional[dict[str, Any]] = None
         self.page_size = 50
         self.current_page = 0
         self.loading_dialog = LoadingDialog("Loading data...", self)
@@ -308,7 +307,7 @@ class MetadataView(QWidget):
         self.load_thread.error.connect(self._on_load_error)
         self.load_thread.start()
 
-    def _on_data_loaded(self, data: Dict[str, Any]):
+    def _on_data_loaded(self, data: dict[str, Any]):
         """Handle data loaded from background thread."""
         # If no data returned
         if not data:
@@ -358,7 +357,7 @@ class MetadataView(QWidget):
                     data=full_data,
                     scroll_position=self.table.verticalScrollBar().value(),
                     search_query=(
-                        getattr(self.filter_builder, "to_dict")()
+                        self.filter_builder.to_dict()
                         if callable(getattr(self.filter_builder, "to_dict", None))
                         else ""
                     ),
@@ -401,7 +400,7 @@ class MetadataView(QWidget):
                 data=data,
                 scroll_position=self.table.verticalScrollBar().value(),
                 search_query=(
-                    getattr(self.filter_builder, "to_dict")()
+                    self.filter_builder.to_dict()
                     if callable(getattr(self.filter_builder, "to_dict", None))
                     else ""
                 ),
@@ -422,7 +421,7 @@ class MetadataView(QWidget):
         self.status_label.setText(f"Failed to load data: {error_msg}")
         self.table.setRowCount(0)
 
-    def _update_filter_fields(self, data: Dict[str, Any]):
+    def _update_filter_fields(self, data: dict[str, Any]):
         """Update filter builder with available metadata field names."""
         field_names = []
 
@@ -441,7 +440,7 @@ class MetadataView(QWidget):
         if field_names:
             self.filter_builder.set_available_fields(field_names)
 
-    def _populate_table(self, data: Dict[str, Any]):
+    def _populate_table(self, data: dict[str, Any]):
         """Populate table with data."""
         ids = data.get("ids", [])
         documents = data.get("documents", [])

vector_inspector/ui/views/search_view.py

@@ -1,38 +1,38 @@
 """Search interface for similarity queries."""
 
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFontMetrics
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
+    QApplication,
+    QGroupBox,
     QHBoxLayout,
-    QTextEdit,
-    QPushButton,
     QLabel,
+    QMenu,
+    QPushButton,
     QSizePolicy,
     QSpinBox,
+    QSplitter,
     QTableWidget,
     QTableWidgetItem,
-    QGroupBox,
-    QSplitter,
-    QCheckBox,
-    QApplication,
-    QMenu,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QFontMetrics
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.cache_manager import get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_info
+from vector_inspector.services.filter_service import apply_client_side_filters
 from vector_inspector.ui.components.filter_builder import FilterBuilder
 from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.services.filter_service import apply_client_side_filters
-from vector_inspector.core.cache_manager import get_cache_manager, CacheEntry
-from vector_inspector.core.logging import log_info
 
 
 class SearchView(QWidget):
     """View for performing similarity searches."""
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
         # Initialize all UI attributes to None to avoid AttributeError
         self.breadcrumb_label = None
@@ -47,10 +47,11 @@ class SearchView(QWidget):
         self.loading_dialog = None
         self.cache_manager = None
 
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self.current_collection: str = ""
         self.current_database: str = ""
-        self.search_results: Optional[Dict[str, Any]] = None
+        self.search_results: Optional[dict[str, Any]] = None
         self.loading_dialog = LoadingDialog("Searching...", self)
         self.cache_manager = get_cache_manager()
 
@@ -414,7 +415,7 @@ class SearchView(QWidget):
         if not menu.isEmpty():
             menu.exec(self.results_table.viewport().mapToGlobal(position))
 
-    def _display_results(self, results: Dict[str, Any]):
+    def _display_results(self, results: dict[str, Any]):
         """Display search results in table."""
         ids = results.get("ids", [[]])[0]
         documents = results.get("documents", [[]])[0]

vector_inspector/ui/views/visualization_view.py

@@ -1,28 +1,30 @@
 """Vector visualization view with dimensionality reduction."""
 
 from __future__ import annotations
-from typing import Any
+
 import traceback
+from typing import Any, Optional
+
+import numpy as np
+from PySide6.QtCore import QThread, Signal
+from PySide6.QtWebEngineWidgets import QWebEngineView
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QPushButton,
-    QLabel,
+    QApplication,
     QComboBox,
-    QSpinBox,
     QGroupBox,
+    QHBoxLayout,
+    QLabel,
     QMessageBox,
-    QApplication,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import QThread, Signal
-from PySide6.QtWebEngineWidgets import QWebEngineView
-import numpy as np
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_error
 from vector_inspector.services.visualization_service import VisualizationService
 from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.core.logging import log_error
 
 
 class VisualizationThread(QThread):
@@ -55,8 +57,9 @@ class VisualizationThread(QThread):
 class VisualizationView(QWidget):
     """View for visualizing vectors in 2D/3D."""
 
-    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.current_collection: str = ""
         self.current_data: dict[str, Any] | None = None
@@ -296,8 +299,8 @@ class VisualizationView(QWidget):
             webbrowser.open(f"file://{self._last_temp_html}")
 
     def cleanup_temp_html(self):
-        import os
         import contextlib
+        import os
 
         for f in getattr(self, "temp_html_files", []):
             with contextlib.suppress(Exception):