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

vector_inspector/__init__.py

@@ -1,6 +1,6 @@
 """Vector Inspector - A comprehensive desktop application for vector database visualization."""
 
-__version__ = "0.3.11"  # Keep in sync with pyproject.toml for dev mode fallback
+__version__ = "0.3.12"  # Keep in sync with pyproject.toml for dev mode fallback
 
 
 def get_version():

vector_inspector/core/connection_manager.py

@@ -1,13 +1,15 @@
 """Connection manager for handling multiple vector database connections."""
 
 import uuid
-from typing import Dict, Optional, List, Any
 from enum import Enum
+from typing import Any
+
 from PySide6.QtCore import QObject, Signal
 
-from .connections.base_connection import VectorDBConnection
 from vector_inspector.core.logging import log_error
 
+from .connections.base_connection import VectorDBConnection
+
 
 class ConnectionState(Enum):
     """Possible connection states."""
@@ -27,7 +29,7 @@ class ConnectionInstance:
         name: str,
         provider: str,
         connection: VectorDBConnection,
-        config: Dict[str, Any],
+        config: dict[str, Any],
     ):
         """
         Initialize a connection instance.
@@ -42,12 +44,17 @@ class ConnectionInstance:
         self.id = connection_id
         self.name = name
         self.provider = provider
-        self.connection = connection
+        self.database = connection
         self.config = config
         self.state = ConnectionState.DISCONNECTED
-        self.active_collection: Optional[str] = None
-        self.collections: List[str] = []
-        self.error_message: Optional[str] = None
+        self.active_collection: str | None = None
+        self.collections: list[str] = []
+        self.error_message: str | None = None
+
+        # Set profile_name on the underlying connection object so it can be used
+        # for settings lookups (embedding models, etc.)
+        # Note: This dynamically adds an attribute to the connection object
+        self.database.profile_name = name  # type: ignore[attr-defined]
 
     def get_display_name(self) -> str:
         """Get a display-friendly connection name."""
@@ -59,6 +66,59 @@ class ConnectionInstance:
             return f"{self.name} > {self.active_collection}"
         return self.name
 
+    def __getattr__(self, name):
+        """Forward unknown attribute lookups to the underlying database connection.
+
+        This allows `ConnectionInstance` to act as a thin wrapper while
+        exposing the provider-specific API (e.g. `get_all_items`,
+        `query_collection`) without callers needing to access
+        `.database` explicitly.
+        """
+        return getattr(self.database, name)
+
+    # Convenience proxy methods to forward common operations to the underlying
+    # VectorDBConnection. This prevents callers from needing to access
+    # `instance.database` directly and centralizes error handling.
+    def list_collections(self) -> list[str]:
+        """Return list of collections from the underlying database connection.
+
+        Falls back to the cached `collections` attribute on error.
+        """
+        try:
+            return self.database.list_collections()
+        except Exception:
+            return self.collections or []
+
+    def connect(self) -> bool:
+        """Proxy to connect the underlying database connection."""
+        return self.database.connect()
+
+    def disconnect(self) -> None:
+        """Proxy to disconnect the underlying database connection; logs errors."""
+        try:
+            self.database.disconnect()
+        except Exception as e:
+            log_error("Error disconnecting underlying database: %s", e)
+
+    @property
+    def is_connected(self) -> bool:
+        """Whether the underlying database connection is currently connected."""
+        return getattr(self.database, "is_connected", False)
+
+    def get_collection_info(self, collection_name: str):
+        """Proxy to get collection-specific information."""
+        try:
+            return self.database.get_collection_info(collection_name)
+        except Exception:
+            return None
+
+    def delete_collection(self, collection_name: str) -> bool:
+        """Proxy to delete a collection on the underlying database connection."""
+        try:
+            return self.database.delete_collection(collection_name)
+        except Exception:
+            return False
+
 
 class ConnectionManager(QObject):
     """Manages multiple vector database connections and saved profiles.
@@ -85,16 +145,28 @@ class ConnectionManager(QObject):
     def __init__(self):
         """Initialize the connection manager."""
         super().__init__()
-        self._connections: Dict[str, ConnectionInstance] = {}
-        self._active_connection_id: Optional[str] = None
+        self._connections: dict[str, ConnectionInstance] = {}
+        self._active_connection_id: str | None = None
+
+    def get_active_collection(self) -> str | None:
+        """
+        Get the active collection name for the currently active connection.
+
+        Returns:
+            The active collection name, or None if no active connection or collection.
+        """
+        active_conn = self.get_active_connection()
+        if active_conn:
+            return active_conn.active_collection
+        return None
 
     def create_connection(
         self,
         name: str,
         provider: str,
         connection: VectorDBConnection,
-        config: Dict[str, Any],
-        connection_id: str = None,
+        config: dict[str, Any],
+        connection_id: str | None = None,
     ) -> str:
         """
         Create a new connection instance (not yet connected).
@@ -138,17 +210,17 @@ class ConnectionManager(QObject):
         if connection_id in self._connections:
             self.connection_opened.emit(connection_id)
 
-    def get_connection(self, connection_id: str) -> Optional[ConnectionInstance]:
+    def get_connection(self, connection_id: str) -> ConnectionInstance | None:
         """Get a connection instance by ID."""
         return self._connections.get(connection_id)
 
-    def get_active_connection(self) -> Optional[ConnectionInstance]:
+    def get_active_connection(self) -> ConnectionInstance | None:
         """Get the currently active connection instance."""
         if self._active_connection_id:
             return self._connections.get(self._active_connection_id)
         return None
 
-    def get_active_connection_id(self) -> Optional[str]:
+    def get_active_connection_id(self) -> str | None:
         """Get the currently active connection ID."""
         return self._active_connection_id
 
@@ -185,7 +257,7 @@ class ConnectionManager(QObject):
 
         # Disconnect the connection
         try:
-            instance.connection.disconnect()
+            instance.disconnect()
         except Exception as e:
             log_error("Error disconnecting: %s", e)
 
@@ -206,7 +278,7 @@ class ConnectionManager(QObject):
         return True
 
     def update_connection_state(
-        self, connection_id: str, state: ConnectionState, error: Optional[str] = None
+        self, connection_id: str, state: ConnectionState, error: str | None = None
     ):
         """
         Update the state of a connection.
@@ -225,7 +297,7 @@ class ConnectionManager(QObject):
                 instance.error_message = None
             self.connection_state_changed.emit(connection_id, state)
 
-    def update_collections(self, connection_id: str, collections: List[str]):
+    def update_collections(self, connection_id: str, collections: list[str]):
         """
         Update the collections list for a connection.
 
@@ -238,7 +310,7 @@ class ConnectionManager(QObject):
             instance.collections = collections
             self.collections_updated.emit(connection_id, collections)
 
-    def set_active_collection(self, connection_id: str, collection_name: Optional[str]):
+    def set_active_collection(self, connection_id: str, collection_name: str | None):
         """
         Set the active collection for a connection.
 
@@ -251,7 +323,7 @@ class ConnectionManager(QObject):
             instance.active_collection = collection_name
             self.active_collection_changed.emit(connection_id, collection_name)
 
-    def get_all_connections(self) -> List[ConnectionInstance]:
+    def get_all_connections(self) -> list[ConnectionInstance]:
         """Get list of all connection instances."""
         return list(self._connections.values())
 

vector_inspector/core/connections/base_connection.py

@@ -1,7 +1,8 @@
 """Abstract base class for vector database connections."""
 
 from abc import ABC, abstractmethod
-from typing import Optional, List, Dict, Any
+from typing import Any
+
 from vector_inspector.core.logging import log_error
 
 
@@ -39,7 +40,7 @@ class VectorDBConnection(ABC):
         pass
 
     @abstractmethod
-    def list_collections(self) -> List[str]:
+    def list_collections(self) -> list[str]:
         """
         Get list of all collections/indexes.
 
@@ -49,7 +50,7 @@ class VectorDBConnection(ABC):
         pass
 
     @abstractmethod
-    def get_collection_info(self, name: str) -> Optional[Dict[str, Any]]:
+    def get_collection_info(self, name: str) -> dict[str, Any] | None:
         """
         Get collection metadata and statistics.
 
@@ -73,16 +74,16 @@ class VectorDBConnection(ABC):
     def add_items(
         self,
         collection_name: str,
-        documents: List[str],
-        metadatas: Optional[List[Dict[str, Any]]] = None,
-        ids: Optional[List[str]] = None,
-        embeddings: Optional[List[List[float]]] = None,
+        documents: list[str],
+        metadatas: list[dict[str, Any]] | None = None,
+        ids: list[str] | None = None,
+        embeddings: list[list[float]] | None = None,
     ) -> bool:
         """Add items to a collection."""
         pass
 
     @abstractmethod
-    def get_items(self, name: str, ids: List[str]) -> Dict[str, Any]:
+    def get_items(self, name: str, ids: list[str]) -> dict[str, Any]:
         """Retrieve items by original ids. Should return a dict with 'documents' and 'metadatas'."""
         pass
 
@@ -100,12 +101,12 @@ class VectorDBConnection(ABC):
     def query_collection(
         self,
         collection_name: str,
-        query_texts: Optional[List[str]] = None,
-        query_embeddings: Optional[List[List[float]]] = None,
+        query_texts: list[str] | None = None,
+        query_embeddings: list[list[float]] | None = None,
         n_results: int = 10,
-        where: Optional[Dict[str, Any]] = None,
-        where_document: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        where: dict[str, Any] | None = None,
+        where_document: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | None:
         """
         Query a collection for similar vectors.
 
@@ -131,10 +132,10 @@ class VectorDBConnection(ABC):
     def get_all_items(
         self,
         collection_name: str,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
-        where: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        limit: int | None = None,
+        offset: int | None = None,
+        where: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | None:
         """
         Get all items from a collection.
 
@@ -157,10 +158,10 @@ class VectorDBConnection(ABC):
     def update_items(
         self,
         collection_name: str,
-        ids: List[str],
-        documents: Optional[List[str]] = None,
-        metadatas: Optional[List[Dict[str, Any]]] = None,
-        embeddings: Optional[List[List[float]]] = None,
+        ids: list[str],
+        documents: list[str] | None = None,
+        metadatas: list[dict[str, Any]] | None = None,
+        embeddings: list[list[float]] | None = None,
     ) -> bool:
         """
         Update items in a collection.
@@ -181,8 +182,8 @@ class VectorDBConnection(ABC):
     def delete_items(
         self,
         collection_name: str,
-        ids: Optional[List[str]] = None,
-        where: Optional[Dict[str, Any]] = None,
+        ids: list[str] | None = None,
+        where: dict[str, Any] | None = None,
     ) -> bool:
         """
         Delete items from a collection.
@@ -199,7 +200,7 @@ class VectorDBConnection(ABC):
 
     # Optional: Methods that may be provider-specific but useful to define
 
-    def get_connection_info(self) -> Dict[str, Any]:
+    def get_connection_info(self) -> dict[str, Any]:
         """
         Get information about the current connection.
 
@@ -208,7 +209,7 @@ class VectorDBConnection(ABC):
         """
         return {"provider": self.__class__.__name__, "connected": self.is_connected}
 
-    def get_supported_filter_operators(self) -> List[Dict[str, Any]]:
+    def get_supported_filter_operators(self) -> list[dict[str, Any]]:
         """
         Get list of filter operators supported by this provider.
 
@@ -228,9 +229,7 @@ class VectorDBConnection(ABC):
             {"name": "contains", "server_side": False},
         ]
 
-    def get_embedding_model(
-        self, collection_name: str, connection_id: Optional[str] = None
-    ) -> Optional[str]:
+    def get_embedding_model(self, collection_name: str) -> str | None:
         """
         Get the embedding model used for a collection.
 
@@ -260,11 +259,12 @@ class VectorDBConnection(ABC):
                     return metadata["_embedding_model"]
 
             # Finally, check user settings (for collections we can't modify)
-            if connection_id:
+            profile_name = getattr(self, "profile_name", None)
+            if profile_name:
                 from vector_inspector.services.settings_service import SettingsService
 
                 settings = SettingsService()
-                model_info = settings.get_embedding_model(connection_id, collection_name)
+                model_info = settings.get_embedding_model(profile_name, collection_name)
                 if model_info:
                     return model_info["model"]
 
@@ -274,7 +274,7 @@ class VectorDBConnection(ABC):
             return None
 
     def load_embedding_model_for_collection(
-        self, collection_name: str, connection_id: Optional[str] = None
+        self, collection_name: str, profile_name_override: str | None = None
     ):
         """
         Resolve and load an embedding model for a collection.
@@ -289,17 +289,18 @@ class VectorDBConnection(ABC):
             (loaded_model, model_name, model_type)
         """
         try:
-            from vector_inspector.services.settings_service import SettingsService
             from vector_inspector.core.embedding_utils import (
-                load_embedding_model,
-                get_embedding_model_for_dimension,
                 DEFAULT_MODEL,
+                get_embedding_model_for_dimension,
+                load_embedding_model,
             )
+            from vector_inspector.services.settings_service import SettingsService
 
             # 1) settings
-            if connection_id:
+            profile_name = profile_name_override or getattr(self, "profile_name", None)
+            if profile_name:
                 settings = SettingsService()
-                cfg = settings.get_embedding_model(connection_id, collection_name)
+                cfg = settings.get_embedding_model(profile_name, collection_name)
                 if cfg and cfg.get("model"):
                     model_name = cfg.get("model")
                     model_type = cfg.get("type", "sentence-transformer")
@@ -336,8 +337,8 @@ class VectorDBConnection(ABC):
             raise
 
     def compute_embeddings_for_documents(
-        self, collection_name: str, documents: List[str], connection_id: Optional[str] = None
-    ) -> List[List[float]]:
+        self, collection_name: str, documents: list[str], profile_name_override: str | None = None
+    ) -> list[list[float]]:
         """
         Compute embeddings for a list of documents using the resolved model for the collection.
 
@@ -345,15 +346,14 @@ class VectorDBConnection(ABC):
         raises an exception.
         """
         model, model_name, model_type = self.load_embedding_model_for_collection(
-            collection_name, connection_id
+            collection_name, profile_name_override
         )
 
         # Use batch encoding when available (sentence-transformer), otherwise per-doc
         if model_type != "clip":
             # sentence-transformer-like models support batch encode
             return model.encode(documents, show_progress_bar=False).tolist()
-        else:
-            # CLIP - use encode_text helper for each document
-            from vector_inspector.core.embedding_utils import encode_text
+        # CLIP - use encode_text helper for each document
+        from vector_inspector.core.embedding_utils import encode_text
 
-            return [encode_text(d, model, model_type) for d in documents]
+        return [encode_text(d, model, model_type) for d in documents]

vector_inspector/core/connections/chroma_connection.py

@@ -389,7 +389,7 @@ class ChromaDBConnection(VectorDBConnection):
             if not embeddings and documents:
                 try:
                     embeddings = self.compute_embeddings_for_documents(
-                        collection_name, documents, getattr(self, "connection_id", None)
+                        collection_name, documents, getattr(self, "profile_name", None)
                     )
                 except Exception as e:
                     log_error("Failed to compute embeddings for Chroma add_items: %s", e)

vector_inspector/core/connections/pgvector_connection.py

@@ -1,12 +1,11 @@
 """PgVector/PostgreSQL connection manager."""
 
-from typing import Any
 import json
+from typing import Any
+
 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
@@ -525,52 +524,12 @@ class PgVectorConnection(VectorDBConnection):
         # If caller provided query texts (not embeddings), compute embeddings using configured model
         if (not query_embeddings) and query_texts:
             try:
-                from vector_inspector.services.settings_service import SettingsService
-                from vector_inspector.core.embedding_utils import (
-                    load_embedding_model,
-                    get_embedding_model_for_dimension,
-                    DEFAULT_MODEL,
-                    encode_text,
-                )
+                from vector_inspector.core.embedding_utils import encode_text
 
-                model_name = None
-                model_type = None
-
-                # 1) settings
-                settings = SettingsService()
-                model_info = settings.get_embedding_model(self.database, collection_name)
-                if model_info:
-                    model_name = model_info.get("model")
-                    model_type = model_info.get("type", "sentence-transformer")
-
-                # 2) collection metadata
-                if not model_name:
-                    coll_info = self.get_collection_info(collection_name)
-                    if coll_info and coll_info.get("embedding_model"):
-                        model_name = coll_info.get("embedding_model")
-                        model_type = coll_info.get("embedding_model_type", "stored")
-
-                # 3) dimension-based fallback
-                loaded_model = None
-                if not model_name:
-                    # Try to get vector dimension
-                    dim = None
-                    coll_info = self.get_collection_info(collection_name)
-                    if coll_info and coll_info.get("vector_dimension"):
-                        try:
-                            dim = int(coll_info.get("vector_dimension"))
-                        except Exception:
-                            dim = None
-                    if dim:
-                        loaded_model, model_name, model_type = get_embedding_model_for_dimension(
-                            dim
-                        )
-                    else:
-                        # Use default model
-                        model_name, model_type = DEFAULT_MODEL
-
-                if not loaded_model:
-                    loaded_model = load_embedding_model(model_name, model_type)
+                # Use inherited method to resolve and load the embedding model
+                loaded_model, model_name, model_type = self.load_embedding_model_for_collection(
+                    collection_name
+                )
 
                 # Compute embeddings for the provided query_texts (use helper for CLIP)
                 if model_type != "clip":
@@ -820,70 +779,14 @@ class PgVectorConnection(VectorDBConnection):
             self._last_regenerated_count = 0
             if (not embeddings) and documents:
                 try:
-                    # Resolve model for this collection: prefer settings -> collection metadata -> dimension-based
-                    from vector_inspector.services.settings_service import SettingsService
-                    from vector_inspector.core.embedding_utils import (
-                        load_embedding_model,
-                        get_embedding_model_for_dimension,
-                        DEFAULT_MODEL,
-                    )
-
-                    model_name = None
-                    model_type = None
-
-                    # 1) settings
-                    settings = SettingsService()
-                    model_info = settings.get_embedding_model(self.database, collection_name)
-                    if model_info:
-                        model_name = model_info.get("model")
-                        model_type = model_info.get("type", "sentence-transformer")
-
-                    # 2) collection metadata
-                    if not model_name:
-                        coll_info = self.get_collection_info(collection_name)
-                        if coll_info and coll_info.get("embedding_model"):
-                            model_name = coll_info.get("embedding_model")
-                            model_type = coll_info.get("embedding_model_type", "stored")
-
-                    # 3) dimension-based fallback
-                    loaded_model = None
-                    if not model_name:
-                        # Try to get vector dimension
-                        dim = None
-                        coll_info = self.get_collection_info(collection_name)
-                        if coll_info and coll_info.get("vector_dimension"):
-                            try:
-                                dim = int(coll_info.get("vector_dimension"))
-                            except Exception:
-                                dim = None
-                        if dim:
-                            loaded_model, model_name, model_type = (
-                                get_embedding_model_for_dimension(dim)
-                            )
-                        else:
-                            # Use default model
-                            model_name, model_type = DEFAULT_MODEL
-
-                    # Load model if not already loaded
-                    if not loaded_model:
-                        loaded_model = load_embedding_model(model_name, model_type)
-
+                    # Use inherited method to compute embeddings
                     # Compute embeddings only for documents that are present
                     compute_idxs = [i for i, d in enumerate(documents) if d]
                     if compute_idxs:
                         docs_to_compute = [documents[i] for i in compute_idxs]
-                        # Use SentenceTransformer batch encode when possible
-                        if model_type != "clip":
-                            computed = loaded_model.encode(
-                                docs_to_compute, show_progress_bar=False
-                            ).tolist()
-                        else:
-                            # CLIP type - encode per document using helper
-                            from vector_inspector.core.embedding_utils import encode_text
-
-                            computed = [
-                                encode_text(d, loaded_model, model_type) for d in docs_to_compute
-                            ]
+                        computed = self.compute_embeddings_for_documents(
+                            collection_name, docs_to_compute
+                        )
                         embeddings_local = [None] * len(ids)
                         for idx, emb in zip(compute_idxs, computed):
                             embeddings_local[idx] = emb
@@ -1075,66 +978,3 @@ class PgVectorConnection(VectorDBConnection):
                 return []
         log_info("[pgvector] _parse_vector: unhandled type %s, returning []", type(vector_str))
         return []
-
-    def compute_embeddings_for_documents(
-        self, collection_name: str, documents: list[str]
-    ) -> list[list[float]] | None:
-        """
-        Compute embeddings for a list of documents using the configured/default model for the collection.
-        Returns a list of embeddings, or None on failure.
-        """
-        try:
-            from vector_inspector.services.settings_service import SettingsService
-            from vector_inspector.core.embedding_utils import (
-                load_embedding_model,
-                get_embedding_model_for_dimension,
-                DEFAULT_MODEL,
-                encode_text,
-            )
-
-            model_name = None
-            model_type = None
-
-            # 1) settings
-            settings = SettingsService()
-            model_info = settings.get_embedding_model(self.database, collection_name)
-            if model_info:
-                model_name = model_info.get("model")
-                model_type = model_info.get("type", "sentence-transformer")
-
-            # 2) collection metadata
-            if not model_name:
-                coll_info = self.get_collection_info(collection_name)
-                if coll_info and coll_info.get("embedding_model"):
-                    model_name = coll_info.get("embedding_model")
-                    model_type = coll_info.get("embedding_model_type", "stored")
-
-            # 3) dimension-based fallback
-            loaded_model = None
-            if not model_name:
-                # Try to get vector dimension
-                dim = None
-                coll_info = self.get_collection_info(collection_name)
-                if coll_info and coll_info.get("vector_dimension"):
-                    try:
-                        dim = int(coll_info.get("vector_dimension"))
-                    except Exception:
-                        dim = None
-                if dim:
-                    loaded_model, model_name, model_type = get_embedding_model_for_dimension(dim)
-                else:
-                    model_name, model_type = DEFAULT_MODEL
-
-            # Load model
-            if not loaded_model:
-                loaded_model = load_embedding_model(model_name, model_type)
-
-            # Compute embeddings for all documents
-            if model_type != "clip":
-                embeddings = loaded_model.encode(documents, show_progress_bar=False).tolist()
-            else:
-                embeddings = [encode_text(d, loaded_model, model_type) for d in documents]
-            return embeddings
-        except Exception as e:
-            log_error("Failed to compute embeddings: %s", e)
-            return None