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

vector_inspector/core/connections/pgvector_connection.py

@@ -5,6 +5,8 @@ import json
 import psycopg2
 from psycopg2 import sql
 
+from vector_inspector.core.logging import log_info
+
 ## No need to import register_vector; pgvector extension is enabled at table creation
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.logging import log_error, log_info
@@ -1043,12 +1045,35 @@ class PgVectorConnection(VectorDBConnection):
         Returns:
             List of floats
         """
+        log_info("[pgvector] _parse_vector raw value: %r (type: %s)", vector_str, type(vector_str))
         if isinstance(vector_str, list):
+            log_info("[pgvector] _parse_vector: already list, len=%d", len(vector_str))
             return vector_str
+        # Handle numpy arrays
+        try:
+            import numpy as np
+
+            if isinstance(vector_str, np.ndarray):
+                log_info("[pgvector] _parse_vector: numpy array, shape=%s", vector_str.shape)
+                return vector_str.tolist()
+        except ImportError:
+            pass
         if isinstance(vector_str, str):
             # Remove brackets and split by comma
             vector_str = vector_str.strip("[]")
-            return [float(x) for x in vector_str.split(",")]
+            if not vector_str:
+                log_info("[pgvector] _parse_vector: empty string after strip")
+                return []
+            try:
+                parsed = [float(x) for x in vector_str.split(",")]
+                log_info("[pgvector] _parse_vector: parsed list of len %d", len(parsed))
+                return parsed
+            except Exception as e:
+                log_info(
+                    "[pgvector] _parse_vector: failed to parse '%s' with error: %s", vector_str, e
+                )
+                return []
+        log_info("[pgvector] _parse_vector: unhandled type %s, returning []", type(vector_str))
         return []
 
     def compute_embeddings_for_documents(

vector_inspector/core/provider_factory.py

@@ -0,0 +1,97 @@
+"""Factory for creating vector database connections from provider configs."""
+
+from typing import Dict, Any
+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.connections.pgvector_connection import PgVectorConnection
+
+
+class ProviderFactory:
+    """Factory for creating database connections from configuration."""
+
+    @staticmethod
+    def create(
+        provider: str, config: Dict[str, Any], credentials: Dict[str, Any] = None
+    ) -> VectorDBConnection:
+        """Create a connection object for the specified provider.
+
+        Args:
+            provider: Provider type (chromadb, qdrant, pinecone, pgvector)
+            config: Provider-specific configuration
+            credentials: Optional credentials (API keys, passwords, etc.)
+
+        Returns:
+            VectorDBConnection instance
+
+        Raises:
+            ValueError: If provider is unsupported or configuration is invalid
+        """
+        credentials = credentials or {}
+
+        if provider == "chromadb":
+            return ProviderFactory._create_chroma(config, credentials)
+        elif provider == "qdrant":
+            return ProviderFactory._create_qdrant(config, credentials)
+        elif provider == "pinecone":
+            return ProviderFactory._create_pinecone(config, credentials)
+        elif provider == "pgvector":
+            return ProviderFactory._create_pgvector(config, credentials)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+    @staticmethod
+    def _create_chroma(config: Dict[str, Any], credentials: Dict[str, Any]) -> ChromaDBConnection:
+        """Create a ChromaDB connection."""
+        conn_type = config.get("type")
+
+        if conn_type == "persistent":
+            return ChromaDBConnection(path=config.get("path"))
+        elif conn_type == "http":
+            return ChromaDBConnection(host=config.get("host"), port=config.get("port"))
+        else:  # ephemeral
+            return ChromaDBConnection()
+
+    @staticmethod
+    def _create_qdrant(config: Dict[str, Any], credentials: Dict[str, Any]) -> QdrantConnection:
+        """Create a Qdrant connection."""
+        conn_type = config.get("type")
+        api_key = credentials.get("api_key")
+
+        if conn_type == "persistent":
+            return QdrantConnection(path=config.get("path"))
+        elif conn_type == "http":
+            return QdrantConnection(
+                host=config.get("host"), port=config.get("port"), api_key=api_key
+            )
+        else:  # ephemeral
+            return QdrantConnection()
+
+    @staticmethod
+    def _create_pinecone(config: Dict[str, Any], credentials: Dict[str, Any]) -> 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)
+
+    @staticmethod
+    def _create_pgvector(config: Dict[str, Any], credentials: Dict[str, Any]) -> PgVectorConnection:
+        """Create a PgVector/Postgres connection."""
+        conn_type = config.get("type")
+
+        if conn_type == "http":
+            host = config.get("host", "localhost")
+            port = int(config.get("port", 5432))
+            database = config.get("database")
+            user = config.get("user")
+            # Prefer password from credentials
+            password = credentials.get("password")
+
+            return PgVectorConnection(
+                host=host, port=port, database=database, user=user, password=password
+            )
+
+        raise ValueError("Unsupported connection type for PgVector profile")

vector_inspector/extensions/__init__.py

@@ -0,0 +1,105 @@
+"""Extension points for Vector Inspector.
+
+This module provides hooks and callbacks that allow pro versions
+or plugins to extend core functionality without modifying the base code.
+"""
+
+from typing import Any, ClassVar
+from collections.abc import Callable
+from PySide6.QtWidgets import QMenu, QTableWidget
+
+
+class TableContextMenuHook:
+    """Hook for adding custom context menu items to table widgets."""
+
+    _handlers: ClassVar[list[Callable]] = []
+
+    @classmethod
+    def register(cls, handler: Callable):
+        """Register a context menu handler.
+
+        Args:
+            handler: Callable that takes (menu: QMenu, table: QTableWidget, row: int, data: Dict)
+                    and adds menu items to the menu.
+        """
+        if handler not in cls._handlers:
+            cls._handlers.append(handler)
+
+    @classmethod
+    def unregister(cls, handler: Callable):
+        """Unregister a context menu handler."""
+        if handler in cls._handlers:
+            cls._handlers.remove(handler)
+
+    @classmethod
+    def trigger(
+        cls,
+        menu: QMenu,
+        table: QTableWidget,
+        row: int,
+        data: dict[str, Any] | None = None,
+    ):
+        """Trigger all registered handlers.
+
+        Args:
+            menu: The QMenu to add items to
+            table: The QTableWidget that was right-clicked
+            row: The row number that was clicked
+            data: Optional data dictionary with context (ids, documents, metadatas, etc.)
+        """
+        for handler in cls._handlers:
+            try:
+                handler(menu, table, row, data)
+            except Exception as e:
+                # Log but don't break if a handler fails
+                from vector_inspector.core.logging import log_error
+
+                log_error("Context menu handler error: %s", e)
+
+    @classmethod
+    def clear(cls):
+        """Clear all registered handlers."""
+        cls._handlers.clear()
+
+
+# Global singleton instance
+table_context_menu_hook = TableContextMenuHook()
+
+
+class SettingsPanelHook:
+    """Hook for adding custom sections to the Settings/Preferences dialog."""
+
+    _handlers: ClassVar[list[Callable]] = []
+
+    @classmethod
+    def register(cls, handler: Callable):
+        """Register a settings panel provider.
+
+        Handler signature: (parent_layout, settings_service, dialog)
+        where `parent_layout` is a QLayout the handler can add widgets to.
+        """
+        if handler not in cls._handlers:
+            cls._handlers.append(handler)
+
+    @classmethod
+    def unregister(cls, handler: Callable):
+        if handler in cls._handlers:
+            cls._handlers.remove(handler)
+
+    @classmethod
+    def trigger(cls, parent_layout, settings_service, dialog=None):
+        for handler in cls._handlers:
+            try:
+                handler(parent_layout, settings_service, dialog)
+            except Exception as e:
+                from vector_inspector.core.logging import log_error
+
+                log_error("Settings panel handler error: %s", e)
+
+    @classmethod
+    def clear(cls):
+        cls._handlers.clear()
+
+
+# Global singleton instance
+settings_panel_hook = SettingsPanelHook()

vector_inspector/services/settings_service.py

@@ -1,6 +1,8 @@
 """Service for persisting application settings."""
 
 import json
+import base64
+from PySide6.QtCore import QObject, Signal
 from pathlib import Path
 from typing import Dict, Any, Optional, List
 from vector_inspector.core.cache_manager import invalidate_cache_on_settings_change
@@ -12,6 +14,18 @@ class SettingsService:
 
     def __init__(self):
         """Initialize settings service."""
+
+        # Expose a shared QObject-based signal emitter so UI can react to
+        # settings changes without polling.
+        class _Signals(QObject):
+            setting_changed = Signal(str, object)
+
+        # singleton-like per-process signals instance
+        try:
+            self.signals
+        except Exception:
+            self.signals = _Signals()
+
         self.settings_dir = Path.home() / ".vector-inspector"
         self.settings_file = self.settings_dir / "settings.json"
         self.settings: Dict[str, Any] = {}
@@ -51,6 +65,62 @@ class SettingsService:
         """Get a setting value."""
         return self.settings.get(key, default)
 
+    # Convenience accessors for common settings
+    def get_breadcrumb_enabled(self) -> bool:
+        return bool(self.settings.get("breadcrumb.enabled", True))
+
+    def set_breadcrumb_enabled(self, enabled: bool):
+        self.set("breadcrumb.enabled", bool(enabled))
+
+    def get_breadcrumb_elide_mode(self) -> str:
+        return str(self.settings.get("breadcrumb.elide_mode", "left"))
+
+    def set_breadcrumb_elide_mode(self, mode: str):
+        if mode not in ("left", "middle"):
+            mode = "left"
+        self.set("breadcrumb.elide_mode", mode)
+
+    def get_default_n_results(self) -> int:
+        return int(self.settings.get("search.default_n_results", 10))
+
+    def set_default_n_results(self, n: int):
+        self.set("search.default_n_results", int(n))
+
+    def get_auto_generate_embeddings(self) -> bool:
+        return bool(self.settings.get("embeddings.auto_generate", True))
+
+    def set_auto_generate_embeddings(self, enabled: bool):
+        self.set("embeddings.auto_generate", bool(enabled))
+
+    def get_window_restore_geometry(self) -> bool:
+        return bool(self.settings.get("window.restore_geometry", True))
+
+    def set_window_restore_geometry(self, enabled: bool):
+        self.set("window.restore_geometry", bool(enabled))
+
+    def set_window_geometry(self, geometry_bytes: bytes):
+        """Save window geometry as base64 string."""
+        try:
+            if isinstance(geometry_bytes, str):
+                # assume base64 already
+                b64 = geometry_bytes
+            else:
+                b64 = base64.b64encode(bytes(geometry_bytes)).decode("ascii")
+            self.set("window.geometry", b64)
+        except Exception as e:
+            log_error("Failed to set window geometry: %s", e)
+
+    def get_window_geometry(self) -> Optional[bytes]:
+        """Return geometry bytes or None."""
+        try:
+            b64 = self.settings.get("window.geometry")
+            if not b64:
+                return None
+            return base64.b64decode(b64)
+        except Exception as e:
+            log_error("Failed to get window geometry: %s", e)
+            return None
+
     def get_cache_enabled(self) -> bool:
         """Get whether caching is enabled (default: True)."""
         return self.settings.get("cache_enabled", True)
@@ -74,6 +144,12 @@ class SettingsService:
         # Invalidate cache when settings change (only if cache is enabled)
         if key != "cache_enabled":  # Don't invalidate when toggling cache itself
             invalidate_cache_on_settings_change()
+        # Emit change signal for UI/reactive components
+        try:
+            # Emit the raw python object (value) for convenience
+            self.signals.setting_changed.emit(key, value)
+        except Exception:
+            pass
 
     def clear(self):
         """Clear all settings."""

vector_inspector/ui/components/splash_window.py

@@ -34,10 +34,22 @@ class SplashWindow(QDialog):
         layout.addWidget(github)
 
         # About info (reuse About dialog text)
-        from vector_inspector.ui.main_window import get_about_html
+        from vector_inspector.utils.version import get_app_version
 
         about = QTextBrowser()
-        about.setHtml(get_about_html())
+        version = get_app_version()
+        version_html = (
+            f"<h2>Vector Inspector {version}</h2>" if version else "<h2>Vector Inspector</h2>"
+        )
+        about_text = (
+            version_html + "<p>A comprehensive desktop application for visualizing, "
+            "querying, and managing multiple vector databases simultaneously.</p>"
+            '<p><a href="https://github.com/anthonypdawson/vector-inspector" style="color:#2980b9;">GitHub Project Page</a></p>'
+            "<hr />"
+            "<p>Built with PySide6</p>"
+            "<p><b>New:</b> Pinecone support!</p>"
+        )
+        about.setHtml(about_text)
         about.setOpenExternalLinks(True)
         about.setMaximumHeight(160)
         layout.addWidget(about)

vector_inspector/ui/controllers/__init__.py

@@ -0,0 +1 @@
+"""UI controllers for managing application logic."""

vector_inspector/ui/controllers/connection_controller.py

@@ -0,0 +1,177 @@
+"""Controller for managing connection lifecycle and threading."""
+
+from typing import Dict, Optional
+from PySide6.QtCore import QObject, Signal, QThread
+from PySide6.QtWidgets import QMessageBox, QWidget
+
+from vector_inspector.core.connection_manager import ConnectionManager, ConnectionState
+from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.provider_factory import ProviderFactory
+from vector_inspector.services.profile_service import ProfileService
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
+
+
+class ConnectionThread(QThread):
+    """Background thread for connecting to database."""
+
+    finished = Signal(bool, list, str)  # success, collections, error_message
+
+    def __init__(self, connection: VectorDBConnection):
+        super().__init__()
+        self.connection = connection
+
+    def run(self):
+        """Connect to database and get collections."""
+        try:
+            success = self.connection.connect()
+            if success:
+                collections = self.connection.list_collections()
+                self.finished.emit(True, collections, "")
+            else:
+                self.finished.emit(False, [], "Connection failed")
+        except Exception as e:
+            self.finished.emit(False, [], str(e))
+
+
+class ConnectionController(QObject):
+    """Controller for managing connection operations and lifecycle.
+
+    This handles:
+    - Creating connections from profiles
+    - Starting connection threads
+    - Handling connection results
+    - Managing loading dialogs
+    - Emitting signals for UI updates
+    """
+
+    connection_completed = Signal(
+        str, bool, list, str
+    )  # connection_id, success, collections, error
+
+    def __init__(
+        self,
+        connection_manager: ConnectionManager,
+        profile_service: ProfileService,
+        parent: Optional[QWidget] = None,
+    ):
+        super().__init__(parent)
+        self.connection_manager = connection_manager
+        self.profile_service = profile_service
+        self.parent_widget = parent
+
+        # State
+        self._connection_threads: Dict[str, ConnectionThread] = {}
+        self.loading_dialog = LoadingDialog("Loading...", parent)
+
+    def connect_to_profile(self, profile_id: str) -> bool:
+        """Connect to a profile.
+
+        Args:
+            profile_id: ID of the profile to connect to
+
+        Returns:
+            True if connection initiated successfully, False otherwise
+        """
+        profile_data = self.profile_service.get_profile_with_credentials(profile_id)
+        if not profile_data:
+            QMessageBox.warning(self.parent_widget, "Error", "Profile not found.")
+            return False
+
+        # Check connection limit
+        if self.connection_manager.get_connection_count() >= ConnectionManager.MAX_CONNECTIONS:
+            QMessageBox.warning(
+                self.parent_widget,
+                "Connection Limit",
+                f"Maximum number of connections ({ConnectionManager.MAX_CONNECTIONS}) reached. "
+                "Please close a connection first.",
+            )
+            return False
+
+        # Create connection
+        provider = profile_data["provider"]
+        config = profile_data["config"]
+        credentials = profile_data.get("credentials", {})
+
+        try:
+            # Create connection object using factory
+            connection = ProviderFactory.create(provider, config, credentials)
+
+            # Register with connection manager, using profile_id as connection_id for persistence
+            connection_id = self.connection_manager.create_connection(
+                name=profile_data["name"],
+                provider=provider,
+                connection=connection,
+                config=config,
+                connection_id=profile_data["id"],
+            )
+
+            # Update state to connecting
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.CONNECTING
+            )
+
+            # Connect in background thread
+            thread = ConnectionThread(connection)
+            thread.finished.connect(
+                lambda success, collections, error: self._on_connection_finished(
+                    connection_id, success, collections, error
+                )
+            )
+            self._connection_threads[connection_id] = thread
+            thread.start()
+
+            # Show loading dialog
+            self.loading_dialog.show_loading(f"Connecting to {profile_data['name']}...")
+            return True
+
+        except Exception as e:
+            QMessageBox.critical(
+                self.parent_widget, "Connection Error", f"Failed to create connection: {e}"
+            )
+            return False
+
+    def _on_connection_finished(
+        self, connection_id: str, success: bool, collections: list, error: str
+    ):
+        """Handle connection thread completion."""
+        self.loading_dialog.hide_loading()
+
+        # Clean up thread
+        thread = self._connection_threads.pop(connection_id, None)
+        if thread:
+            thread.wait()  # Wait for thread to fully finish
+            thread.deleteLater()
+
+        if success:
+            # Update state to connected
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.CONNECTED
+            )
+
+            # Mark connection as opened first (will show in UI)
+            self.connection_manager.mark_connection_opened(connection_id)
+
+            # Then update collections (UI item now exists to receive them)
+            self.connection_manager.update_collections(connection_id, collections)
+        else:
+            # Update state to error
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.ERROR, error
+            )
+
+            QMessageBox.warning(
+                self.parent_widget, "Connection Failed", f"Failed to connect: {error}"
+            )
+
+            # Remove the failed connection
+            self.connection_manager.close_connection(connection_id)
+
+        # Emit signal for UI updates
+        self.connection_completed.emit(connection_id, success, collections, error)
+
+    def cleanup(self):
+        """Clean up connection threads on shutdown."""
+        for thread in list(self._connection_threads.values()):
+            if thread.isRunning():
+                thread.quit()
+                thread.wait(1000)  # Wait up to 1 second

vector_inspector/ui/dialogs/settings_dialog.py

@@ -0,0 +1,124 @@
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QCheckBox,
+    QComboBox,
+    QSpinBox,
+    QPushButton,
+)
+from PySide6.QtCore import Qt
+
+from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.extensions import settings_panel_hook
+
+
+class SettingsDialog(QDialog):
+    """Modal settings dialog backed by SettingsService."""
+
+    def __init__(self, settings_service: SettingsService = None, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Preferences")
+        self.settings = settings_service or SettingsService()
+        self._init_ui()
+        self._load_values()
+
+    def _init_ui(self):
+        layout = QVBoxLayout(self)
+
+        # Breadcrumb controls are provided by pro extensions (vector-studio)
+        # via the settings_panel_hook. Core does not add breadcrumb options.
+
+        # Search defaults
+        search_layout = QHBoxLayout()
+        search_layout.addWidget(QLabel("Default results:"))
+        self.default_results = QSpinBox()
+        self.default_results.setMinimum(1)
+        self.default_results.setMaximum(1000)
+        search_layout.addWidget(self.default_results)
+        layout.addLayout(search_layout)
+
+        # Embeddings
+        self.auto_embed_checkbox = QCheckBox("Auto-generate embeddings for new text")
+        layout.addWidget(self.auto_embed_checkbox)
+
+        # Window geometry
+        self.restore_geometry_checkbox = QCheckBox("Restore window size/position on startup")
+        layout.addWidget(self.restore_geometry_checkbox)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        self.apply_btn = QPushButton("Apply")
+        self.ok_btn = QPushButton("OK")
+        self.cancel_btn = QPushButton("Cancel")
+        self.reset_btn = QPushButton("Reset to defaults")
+        btn_layout.addWidget(self.reset_btn)
+        btn_layout.addStretch()
+        btn_layout.addWidget(self.apply_btn)
+        btn_layout.addWidget(self.ok_btn)
+        btn_layout.addWidget(self.cancel_btn)
+        # Allow external extensions to add sections before the buttons
+        try:
+            # Handlers receive (parent_layout, settings_service, dialog)
+            settings_panel_hook.trigger(layout, self.settings, self)
+        except Exception:
+            pass
+
+        layout.addLayout(btn_layout)
+
+        # Signals
+        self.apply_btn.clicked.connect(self._apply)
+        self.ok_btn.clicked.connect(self._ok)
+        self.cancel_btn.clicked.connect(self.reject)
+        self.reset_btn.clicked.connect(self._reset_defaults)
+
+        # Immediate apply on change for some controls
+        self.default_results.valueChanged.connect(lambda v: self.settings.set_default_n_results(v))
+        self.auto_embed_checkbox.stateChanged.connect(
+            lambda s: self.settings.set_auto_generate_embeddings(bool(s))
+        )
+        self.restore_geometry_checkbox.stateChanged.connect(
+            lambda s: self.settings.set_window_restore_geometry(bool(s))
+        )
+
+        # Container for programmatic sections
+        self._extra_sections = []
+
+    def add_section(self, widget_or_layout):
+        """Programmatically add a section (widget or layout) to the dialog.
+
+        `widget_or_layout` can be a QWidget or QLayout. It will be added
+        immediately to the dialog's main layout.
+        """
+        try:
+            if hasattr(widget_or_layout, "setParent"):
+                # QWidget
+                self.layout().addWidget(widget_or_layout)
+            else:
+                # Assume QLayout
+                self.layout().addLayout(widget_or_layout)
+            self._extra_sections.append(widget_or_layout)
+        except Exception:
+            pass
+
+    def _load_values(self):
+        # Breadcrumb controls are not present in core dialog.
+        self.default_results.setValue(self.settings.get_default_n_results())
+        self.auto_embed_checkbox.setChecked(self.settings.get_auto_generate_embeddings())
+        self.restore_geometry_checkbox.setChecked(self.settings.get_window_restore_geometry())
+
+    def _apply(self):
+        # Values are already applied on change; ensure persistence and close
+        self.settings._save_settings()
+
+    def _ok(self):
+        self._apply()
+        self.accept()
+
+    def _reset_defaults(self):
+        # Reset to recommended defaults
+        self.default_results.setValue(10)
+        self.auto_embed_checkbox.setChecked(True)
+        self.restore_geometry_checkbox.setChecked(True)
+        self._apply()