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

vector_inspector/ui/views/metadata_view.py

@@ -18,6 +18,7 @@ from vector_inspector.services.filter_service import apply_client_side_filters
 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
 
 
 class DataLoadThread(QThread):
@@ -184,13 +185,13 @@ class MetadataView(QWidget):
             self.current_database = database_name
         
         # Debug: Check cache status
-        print(f"[MetadataView] Setting collection: db='{self.current_database}', coll='{collection_name}'")
-        print(f"[MetadataView] Cache enabled: {self.cache_manager.is_enabled()}")
+        log_info("[MetadataView] Setting collection: db='%s', coll='%s'", self.current_database, collection_name)
+        log_info("[MetadataView] Cache enabled: %s", self.cache_manager.is_enabled())
         
         # Check cache first
         cached = self.cache_manager.get(self.current_database, self.current_collection)
         if cached and cached.data:
-            print(f"[MetadataView] ✓ Cache HIT! Loading from cache.")
+            log_info("[MetadataView] ✓ Cache HIT! Loading from cache.")
             # Restore from cache
             self.current_page = 0
             self.current_data = cached.data
@@ -208,7 +209,7 @@ class MetadataView(QWidget):
             self.status_label.setText(f"✓ Loaded from cache - {len(cached.data.get('ids', []))} items")
             return
         
-        print(f"[MetadataView] ✗ Cache MISS. Loading from database...")
+        log_info("[MetadataView] ✗ Cache MISS. Loading from database...")
         # Not in cache, load from database
         self.current_page = 0
         
@@ -284,16 +285,16 @@ class MetadataView(QWidget):
         
         # Save to cache
         if self.current_database and self.current_collection:
-            print(f"[MetadataView] Saving to cache: db='{self.current_database}', coll='{self.current_collection}'")
+            log_info("[MetadataView] Saving to cache: db='%s', coll='%s'", self.current_database, self.current_collection)
             cache_entry = CacheEntry(
                 data=data,
                 scroll_position=self.table.verticalScrollBar().value(),
                 search_query=self.filter_builder.to_dict() if hasattr(self.filter_builder, 'to_dict') else ""
             )
             self.cache_manager.set(self.current_database, self.current_collection, cache_entry)
-            print(f"[MetadataView] ✓ Saved to cache. Total entries: {len(self.cache_manager._cache)}")
+            log_info("[MetadataView] ✓ Saved to cache. Total entries: %d", len(self.cache_manager._cache))
         else:
-            print(f"[MetadataView] ✗ NOT saving to cache - db='{self.current_database}', coll='{self.current_collection}'")
+            log_info("[MetadataView] ✗ NOT saving to cache - db='%s', coll='%s'", self.current_database, self.current_collection)
     
     def _on_load_error(self, error_msg: str):
         """Handle error from background thread."""

vector_inspector/ui/views/search_view.py

@@ -2,9 +2,19 @@
 
 from typing import Optional, Dict, Any
 from PySide6.QtWidgets import (
-    QWidget, QVBoxLayout, QHBoxLayout, QTextEdit,
-    QPushButton, QLabel, QSpinBox, QTableWidget,
-    QTableWidgetItem, QGroupBox, QSplitter, QCheckBox, QApplication
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QTextEdit,
+    QPushButton,
+    QLabel,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QGroupBox,
+    QSplitter,
+    QCheckBox,
+    QApplication,
 )
 from PySide6.QtCore import Qt
 
@@ -13,11 +23,12 @@ 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):
         super().__init__(parent)
         self.connection = connection
@@ -26,108 +37,112 @@ class SearchView(QWidget):
         self.search_results: Optional[Dict[str, Any]] = None
         self.loading_dialog = LoadingDialog("Searching...", self)
         self.cache_manager = get_cache_manager()
-        
+
         self._setup_ui()
-        
+
     def _setup_ui(self):
         """Setup widget UI."""
         layout = QVBoxLayout(self)
-        
+
         # Create splitter for query and results
         splitter = QSplitter(Qt.Vertical)
-        
+
         # Query section
         query_widget = QWidget()
         query_layout = QVBoxLayout(query_widget)
-        
+
         query_group = QGroupBox("Search Query")
         query_group_layout = QVBoxLayout()
-        
+
         # Query input
         query_group_layout.addWidget(QLabel("Enter search text:"))
         self.query_input = QTextEdit()
         self.query_input.setMaximumHeight(100)
         self.query_input.setPlaceholderText("Enter text to search for similar vectors...")
         query_group_layout.addWidget(self.query_input)
-        
+
         # Search controls
         controls_layout = QHBoxLayout()
-        
+
         controls_layout.addWidget(QLabel("Results:"))
         self.n_results_spin = QSpinBox()
         self.n_results_spin.setMinimum(1)
         self.n_results_spin.setMaximum(100)
         self.n_results_spin.setValue(10)
         controls_layout.addWidget(self.n_results_spin)
-        
+
         controls_layout.addStretch()
-        
+
         self.search_button = QPushButton("Search")
         self.search_button.clicked.connect(self._perform_search)
         self.search_button.setDefault(True)
         controls_layout.addWidget(self.search_button)
-        
+
         query_group_layout.addLayout(controls_layout)
         query_group.setLayout(query_group_layout)
         query_layout.addWidget(query_group)
-        
+
         # Advanced filters section
         filter_group = QGroupBox("Advanced Metadata Filters")
         filter_group.setCheckable(True)
         filter_group.setChecked(False)
         filter_group_layout = QVBoxLayout()
-        
+
         # Filter builder
         self.filter_builder = FilterBuilder()
         filter_group_layout.addWidget(self.filter_builder)
-        
+
         filter_group.setLayout(filter_group_layout)
         query_layout.addWidget(filter_group)
         self.filter_group = filter_group
-        
+
         splitter.addWidget(query_widget)
-        
+
         # Results section
         results_widget = QWidget()
         results_layout = QVBoxLayout(results_widget)
         results_layout.setContentsMargins(0, 0, 0, 0)
-        
+
         results_group = QGroupBox("Search Results")
         results_group_layout = QVBoxLayout()
-        
+
         self.results_table = QTableWidget()
         self.results_table.setSelectionBehavior(QTableWidget.SelectRows)
         self.results_table.setAlternatingRowColors(True)
         results_group_layout.addWidget(self.results_table)
-        
+
         self.results_status = QLabel("No search performed")
         self.results_status.setStyleSheet("color: gray;")
         results_group_layout.addWidget(self.results_status)
-        
+
         results_group.setLayout(results_group_layout)
         results_layout.addWidget(results_group)
-        
+
         splitter.addWidget(results_widget)
-        
+
         # Set splitter proportions
         splitter.setStretchFactor(0, 1)
         splitter.setStretchFactor(1, 2)
-        
+
         layout.addWidget(splitter)
-        
+
     def set_collection(self, collection_name: str, database_name: str = ""):
         """Set the current collection to search."""
         self.current_collection = collection_name
         # Always update database_name if provided (even if empty string on first call)
         if database_name:  # Only update if non-empty
             self.current_database = database_name
-        
-        print(f"[SearchView] Setting collection: db='{self.current_database}', coll='{collection_name}'")
-        
+
+        log_info(
+            "[SearchView] Setting collection: db='%s', coll='%s'",
+            self.current_database,
+            collection_name,
+        )
+
         # Check cache first
         cached = self.cache_manager.get(self.current_database, self.current_collection)
         if cached:
-            print(f"[SearchView] ✓ Cache HIT! Restoring search state.")
+            log_info("[SearchView] ✓ Cache HIT! Restoring search state.")
             # Restore search query and results from cache
             if cached.search_query:
                 self.query_input.setPlainText(cached.search_query)
@@ -135,37 +150,34 @@ class SearchView(QWidget):
                 self.search_results = cached.search_results
                 self._display_results(cached.search_results)
                 return
-        
-        print(f"[SearchView] ✗ Cache MISS or no cached search.")
+
+        log_info("[SearchView] ✗ Cache MISS or no cached search.")
         # Not in cache, clear form
         self.search_results = None
         self.query_input.clear()
         self.results_table.setRowCount(0)
         self.results_status.setText(f"Collection: {collection_name}")
-        
+
         # Reset filters
         self.filter_builder._clear_all()
         self.filter_group.setChecked(False)
-        
+
         # Update filter builder with supported operators
         operators = self.connection.get_supported_filter_operators()
         self.filter_builder.set_operators(operators)
-        
+
         # Load metadata fields immediately (even if tab is not visible)
         self._load_metadata_fields()
-    
+
     def _load_metadata_fields(self):
         """Load metadata field names from collection for filter builder."""
         if not self.current_collection:
             return
-            
+
         try:
             # Get a small sample to extract field names
-            sample_data = self.connection.get_all_items(
-                self.current_collection,
-                limit=1
-            )
-            
+            sample_data = self.connection.get_all_items(self.current_collection, limit=1)
+
             if sample_data and sample_data.get("metadatas"):
                 metadatas = sample_data["metadatas"]
                 if metadatas and len(metadatas) > 0 and metadatas[0]:
@@ -173,21 +185,21 @@ class SearchView(QWidget):
                     self.filter_builder.set_available_fields(field_names)
         except Exception as e:
             # Silently ignore errors - fields can still be typed manually
-            print(f"Note: Could not auto-populate filter fields: {e}")
-        
+            log_info("Note: Could not auto-populate filter fields: %s", e)
+
     def _perform_search(self):
         """Perform similarity search."""
         if not self.current_collection:
             self.results_status.setText("No collection selected")
             return
-            
+
         query_text = self.query_input.toPlainText().strip()
         if not query_text:
             self.results_status.setText("Please enter search text")
             return
-            
+
         n_results = self.n_results_spin.value()
-        
+
         # Get filters split into server-side and client-side
         server_filter = None
         client_filters = []
@@ -196,33 +208,37 @@ class SearchView(QWidget):
             if server_filter or client_filters:
                 filter_summary = self.filter_builder.get_filter_summary()
                 self.results_status.setText(f"Searching with filters: {filter_summary}")
-        
+
         # Show loading indicator
         self.loading_dialog.show_loading("Searching for similar vectors...")
         QApplication.processEvents()
-        
+
         try:
             # Always pass query_texts; provider handles embedding if needed
             results = self.connection.query_collection(
                 self.current_collection,
                 query_texts=[query_text],
                 n_results=n_results,
-                where=server_filter
+                where=server_filter,
             )
         finally:
             self.loading_dialog.hide_loading()
-        
+
         if not results:
             self.results_status.setText("Search failed")
             self.results_table.setRowCount(0)
             return
-        
+
         # Check if results have the expected structure
-        if not results.get("ids") or not isinstance(results["ids"], list) or len(results["ids"]) == 0:
+        if (
+            not results.get("ids")
+            or not isinstance(results["ids"], list)
+            or len(results["ids"]) == 0
+        ):
             self.results_status.setText("No results found or query failed")
             self.results_table.setRowCount(0)
             return
-        
+
         # Apply client-side filters if any
         if client_filters and results:
             # Restructure results for filtering
@@ -232,20 +248,24 @@ class SearchView(QWidget):
                 "metadatas": results.get("metadatas", [[]])[0],
             }
             filtered = apply_client_side_filters(filter_data, client_filters)
-            
+
             # Restructure back to query results format
             results = {
                 "ids": [filtered["ids"]],
                 "documents": [filtered["documents"]],
                 "metadatas": [filtered["metadatas"]],
-                "distances": [[results.get("distances", [[]])[0][i] 
-                              for i, orig_id in enumerate(results.get("ids", [[]])[0]) 
-                              if orig_id in filtered["ids"]]]
+                "distances": [
+                    [
+                        results.get("distances", [[]])[0][i]
+                        for i, orig_id in enumerate(results.get("ids", [[]])[0])
+                        if orig_id in filtered["ids"]
+                    ]
+                ],
             }
-            
+
         self.search_results = results
         self._display_results(results)
-        
+
         # Save to cache
         if self.current_database and self.current_collection:
             self.cache_manager.update(
@@ -254,55 +274,57 @@ class SearchView(QWidget):
                 search_query=query_text,
                 search_results=results,
                 user_inputs={
-                    'n_results': n_results,
-                    'filters': self.filter_builder.to_dict() if hasattr(self.filter_builder, 'to_dict') else {}
-                }
+                    "n_results": n_results,
+                    "filters": self.filter_builder.to_dict()
+                    if hasattr(self.filter_builder, "to_dict")
+                    else {},
+                },
             )
-        
+
     def _display_results(self, results: Dict[str, Any]):
         """Display search results in table."""
         ids = results.get("ids", [[]])[0]
         documents = results.get("documents", [[]])[0]
         metadatas = results.get("metadatas", [[]])[0]
         distances = results.get("distances", [[]])[0]
-        
+
         if not ids:
             self.results_table.setRowCount(0)
             self.results_status.setText("No results found")
             return
-            
+
         # Determine columns
         columns = ["Rank", "Distance", "ID", "Document"]
         if metadatas and metadatas[0]:
             metadata_keys = list(metadatas[0].keys())
             columns.extend(metadata_keys)
-            
+
         self.results_table.setColumnCount(len(columns))
         self.results_table.setHorizontalHeaderLabels(columns)
         self.results_table.setRowCount(len(ids))
-        
+
         # Populate rows
         for row, (id_val, doc, meta, dist) in enumerate(zip(ids, documents, metadatas, distances)):
             # Rank
             self.results_table.setItem(row, 0, QTableWidgetItem(str(row + 1)))
-            
+
             # Distance/similarity score
             self.results_table.setItem(row, 1, QTableWidgetItem(f"{dist:.4f}"))
-            
+
             # ID
             self.results_table.setItem(row, 2, QTableWidgetItem(str(id_val)))
-            
+
             # Document
             doc_text = str(doc) if doc else ""
             if len(doc_text) > 150:
                 doc_text = doc_text[:150] + "..."
             self.results_table.setItem(row, 3, QTableWidgetItem(doc_text))
-            
+
             # Metadata columns
             if meta:
                 for col_idx, key in enumerate(metadata_keys, start=4):
                     value = meta.get(key, "")
                     self.results_table.setItem(row, col_idx, QTableWidgetItem(str(value)))
-                    
+
         self.results_table.resizeColumnsToContents()
         self.results_status.setText(f"Found {len(ids)} results")