vector-inspector 0.2.0__py3-none-any.whl

vector_inspector/ui/views/search_view.py

@@ -0,0 +1,268 @@
+"""Search interface for similarity queries."""
+
+from typing import Optional, Dict, Any
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QTextEdit,
+    QPushButton, QLabel, QSpinBox, QTableWidget,
+    QTableWidgetItem, QGroupBox, QSplitter, QCheckBox, QApplication
+)
+from PySide6.QtCore import Qt
+
+from vector_inspector.core.connections.base_connection import VectorDBConnection
+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
+
+
+class SearchView(QWidget):
+    """View for performing similarity searches."""
+    
+    def __init__(self, connection: VectorDBConnection, parent=None):
+        super().__init__(parent)
+        self.connection = connection
+        self.current_collection: str = ""
+        self.search_results: Optional[Dict[str, Any]] = None
+        self.loading_dialog = LoadingDialog("Searching...", self)
+        
+        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):
+        """Set the current collection to search."""
+        self.current_collection = collection_name
+        self.search_results = None
+        
+        # Clear search form inputs
+        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
+            )
+            
+            if sample_data and sample_data.get("metadatas"):
+                metadatas = sample_data["metadatas"]
+                if metadatas and len(metadatas) > 0 and metadatas[0]:
+                    field_names = sorted(metadatas[0].keys())
+                    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}")
+        
+    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 = []
+        if self.filter_group.isChecked() and self.filter_builder.has_filters():
+            server_filter, client_filters = self.filter_builder.get_filters_split()
+            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:
+            # Perform query
+            results = self.connection.query_collection(
+                self.current_collection,
+                query_texts=[query_text],
+                n_results=n_results,
+                where=server_filter
+            )
+        finally:
+            self.loading_dialog.hide_loading()
+        
+        if not results:
+            self.results_status.setText("Search failed")
+            self.results_table.setRowCount(0)
+            return
+        
+        # Apply client-side filters if any
+        if client_filters and results:
+            # Restructure results for filtering
+            filter_data = {
+                "ids": results.get("ids", [[]])[0],
+                "documents": results.get("documents", [[]])[0],
+                "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"]]]
+            }
+            
+        self.search_results = results
+        self._display_results(results)
+        
+    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")

vector_inspector/ui/views/visualization_view.py

@@ -0,0 +1,245 @@
+"""Vector visualization view with dimensionality reduction."""
+
+from typing import Optional, Dict, Any
+import traceback
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
+    QLabel, QComboBox, QSpinBox, QGroupBox, QMessageBox
+)
+from PySide6.QtCore import Qt, QThread, Signal
+from PySide6.QtWebEngineWidgets import QWebEngineView
+import plotly.graph_objects as go
+import numpy as np
+
+from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.services.visualization_service import VisualizationService
+
+
+class VisualizationThread(QThread):
+    """Background thread for dimensionality reduction."""
+    
+    finished = Signal(np.ndarray)
+    error = Signal(str)
+    
+    def __init__(self, embeddings, method, n_components):
+        super().__init__()
+        self.embeddings = embeddings
+        self.method = method
+        self.n_components = n_components
+        
+    def run(self):
+        """Run dimensionality reduction."""
+        try:
+            result = VisualizationService.reduce_dimensions(
+                self.embeddings,
+                method=self.method,
+                n_components=self.n_components
+            )
+            if result is not None:
+                self.finished.emit(result)
+            else:
+                self.error.emit("Dimensionality reduction failed")
+        except Exception as e:
+            traceback.print_exc()
+            self.error.emit(str(e))
+
+
+class VisualizationView(QWidget):
+    """View for visualizing vectors in 2D/3D."""
+    
+    def __init__(self, connection: VectorDBConnection, parent=None):
+        super().__init__(parent)
+        self.connection = connection
+        self.current_collection: str = ""
+        self.current_data: Optional[Dict[str, Any]] = None
+        self.reduced_data: Optional[np.ndarray] = None
+        self.visualization_thread: Optional[VisualizationThread] = None
+        
+        self._setup_ui()
+        
+    def _setup_ui(self):
+        """Setup widget UI."""
+        layout = QVBoxLayout(self)
+        
+        # Controls
+        controls_group = QGroupBox("Visualization Settings")
+        controls_layout = QHBoxLayout()
+        
+        # Method selection
+        controls_layout.addWidget(QLabel("Method:"))
+        self.method_combo = QComboBox()
+        self.method_combo.addItems(["PCA", "t-SNE", "UMAP"])
+        controls_layout.addWidget(self.method_combo)
+        
+        # Dimensions
+        controls_layout.addWidget(QLabel("Dimensions:"))
+        self.dimensions_combo = QComboBox()
+        self.dimensions_combo.addItems(["2D", "3D"])
+        controls_layout.addWidget(self.dimensions_combo)
+        
+        # Sample size
+        controls_layout.addWidget(QLabel("Sample size:"))
+        self.sample_spin = QSpinBox()
+        self.sample_spin.setMinimum(10)
+        self.sample_spin.setMaximum(10000)
+        self.sample_spin.setValue(500)
+        self.sample_spin.setSingleStep(100)
+        controls_layout.addWidget(self.sample_spin)
+        
+        controls_layout.addStretch()
+        
+        # Generate button
+        self.generate_button = QPushButton("Generate Visualization")
+        self.generate_button.clicked.connect(self._generate_visualization)
+        controls_layout.addWidget(self.generate_button)
+        
+        controls_group.setLayout(controls_layout)
+        layout.addWidget(controls_group)
+        
+        # Embedded web view for Plotly
+        self.web_view = QWebEngineView()
+        layout.addWidget(self.web_view, stretch=10)
+        
+        # Status
+        self.status_label = QLabel("No collection selected")
+        self.status_label.setStyleSheet("color: gray;")
+        self.status_label.setMaximumHeight(30)
+        layout.addWidget(self.status_label)
+        
+    def set_collection(self, collection_name: str):
+        """Set the current collection to visualize."""
+        self.current_collection = collection_name
+        self.current_data = None
+        self.reduced_data = None
+        self.status_label.setText(f"Collection: {collection_name}")
+        
+    def _generate_visualization(self):
+        """Generate visualization of vectors."""
+        if not self.current_collection:
+            QMessageBox.warning(self, "No Collection", "Please select a collection first.")
+            return
+            
+        # Load data with embeddings
+        sample_size = self.sample_spin.value()
+        data = self.connection.get_all_items(
+            self.current_collection,
+            limit=sample_size
+        )
+        
+        if data is None or not data or "embeddings" not in data or data["embeddings"] is None or len(data["embeddings"]) == 0:
+            QMessageBox.warning(
+                self,
+                "No Data",
+                "No embeddings found in collection. Make sure the collection contains vector embeddings."
+            )
+            return
+            
+        self.current_data = data
+        self.status_label.setText("Reducing dimensions...")
+        self.generate_button.setEnabled(False)
+        
+        # Get parameters
+        method = self.method_combo.currentText().lower()
+        if method == "t-sne":
+            method = "tsne"
+        n_components = 2 if self.dimensions_combo.currentText() == "2D" else 3
+        
+        # Run dimensionality reduction in background thread
+        self.visualization_thread = VisualizationThread(
+            data["embeddings"],
+            method,
+            n_components
+        )
+        self.visualization_thread.finished.connect(self._on_reduction_finished)
+        self.visualization_thread.error.connect(self._on_reduction_error)
+        self.visualization_thread.start()
+        
+    def _on_reduction_finished(self, reduced_data: np.ndarray):
+        """Handle dimensionality reduction completion."""
+        self.reduced_data = reduced_data
+        self._create_plot()
+        self.generate_button.setEnabled(True)
+        self.status_label.setText("Visualization complete")
+        
+    def _on_reduction_error(self, error_msg: str):
+        """Handle dimensionality reduction error."""
+        print(f"Error: Visualization failed: {error_msg}")
+        QMessageBox.warning(self, "Error", f"Visualization failed: {error_msg}")
+        self.generate_button.setEnabled(True)
+        self.status_label.setText("Visualization failed")
+        
+    def _create_plot(self):
+        """Create plotly visualization."""
+        if self.reduced_data is None or self.current_data is None:
+            return
+            
+        ids = self.current_data.get("ids", [])
+        documents = self.current_data.get("documents", [])
+        metadatas = self.current_data.get("metadatas", [])
+        
+        # Prepare hover text
+        hover_texts = []
+        for i, (id_val, doc) in enumerate(zip(ids, documents)):
+            doc_preview = str(doc)[:100] if doc else "No document"
+            hover_texts.append(f"ID: {id_val}<br>Doc: {doc_preview}")
+        
+        # Create plot
+        if self.reduced_data.shape[1] == 2:
+            # 2D plot
+            fig = go.Figure(data=[
+                go.Scatter(
+                    x=self.reduced_data[:, 0],
+                    y=self.reduced_data[:, 1],
+                    mode='markers',
+                    marker=dict(
+                        size=8,
+                        color=list(range(len(ids))),
+                        colorscale='Viridis',
+                        showscale=True
+                    ),
+                    text=hover_texts,
+                    hoverinfo='text'
+                )
+            ])
+            
+            fig.update_layout(
+                title=f"Vector Visualization - {self.method_combo.currentText()}",
+                xaxis_title="Component 1",
+                yaxis_title="Component 2",
+                hovermode='closest',
+                height=800,
+                width=1200
+            )
+        else:
+            # 3D plot
+            fig = go.Figure(data=[
+                go.Scatter3d(
+                    x=self.reduced_data[:, 0],
+                    y=self.reduced_data[:, 1],
+                    z=self.reduced_data[:, 2],
+                    mode='markers',
+                    marker=dict(
+                        size=5,
+                        color=list(range(len(ids))),
+                        colorscale='Viridis',
+                        showscale=True
+                    ),
+                    text=hover_texts,
+                    hoverinfo='text'
+                )
+            ])
+            
+            fig.update_layout(
+                title=f"Vector Visualization - {self.method_combo.currentText()}",
+                scene=dict(
+                    xaxis_title="Component 1",
+                    yaxis_title="Component 2",
+                    zaxis_title="Component 3"
+                ),
+                height=800,
+                width=1200
+            )
+        
+        # Display in embedded web view
+        html = fig.to_html(include_plotlyjs='cdn')
+        self.web_view.setHtml(html)