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

vector_inspector/core/connection_manager.py

@@ -6,10 +6,12 @@ from enum import Enum
 from PySide6.QtCore import QObject, Signal
 
 from .connections.base_connection import VectorDBConnection
+from vector_inspector.core.logging import log_error
 
 
 class ConnectionState(Enum):
     """Possible connection states."""
+
     DISCONNECTED = "disconnected"
     CONNECTING = "connecting"
     CONNECTED = "connected"
@@ -18,18 +20,18 @@ class ConnectionState(Enum):
 
 class ConnectionInstance:
     """Represents a single active connection with its state and context."""
-    
+
     def __init__(
         self,
         connection_id: str,
         name: str,
         provider: str,
         connection: VectorDBConnection,
-        config: Dict[str, Any]
+        config: Dict[str, Any],
     ):
         """
         Initialize a connection instance.
-        
+
         Args:
             connection_id: Unique connection identifier
             name: User-friendly connection name
@@ -46,11 +48,11 @@ class ConnectionInstance:
         self.active_collection: Optional[str] = None
         self.collections: List[str] = []
         self.error_message: Optional[str] = None
-        
+
     def get_display_name(self) -> str:
         """Get a display-friendly connection name."""
         return f"{self.name} ({self.provider})"
-    
+
     def get_breadcrumb(self) -> str:
         """Get breadcrumb showing connection > collection."""
         if self.active_collection:
@@ -60,7 +62,7 @@ class ConnectionInstance:
 
 class ConnectionManager(QObject):
     """Manages multiple vector database connections and saved profiles.
-    
+
     Signals:
         connection_opened: Emitted when a new connection is opened (connection_id)
         connection_closed: Emitted when a connection is closed (connection_id)
@@ -69,7 +71,7 @@ class ConnectionManager(QObject):
         active_collection_changed: Emitted when active collection changes (connection_id, collection_name or None)
         collections_updated: Emitted when collections list is updated (connection_id, collections)
     """
-    
+
     # Signals
     connection_opened = Signal(str)  # connection_id
     connection_closed = Signal(str)  # connection_id
@@ -77,116 +79,119 @@ class ConnectionManager(QObject):
     active_connection_changed = Signal(object)  # connection_id or None
     active_collection_changed = Signal(str, object)  # connection_id, collection_name or None
     collections_updated = Signal(str, list)  # connection_id, collections
-    
+
     MAX_CONNECTIONS = 10  # Limit to prevent resource exhaustion
-    
+
     def __init__(self):
         """Initialize the connection manager."""
         super().__init__()
         self._connections: Dict[str, ConnectionInstance] = {}
         self._active_connection_id: Optional[str] = None
-        
+
     def create_connection(
         self,
         name: str,
         provider: str,
         connection: VectorDBConnection,
-        config: Dict[str, Any]
+        config: Dict[str, Any],
+        connection_id: str = None,
     ) -> str:
         """
         Create a new connection instance (not yet connected).
-        
+
         Args:
             name: User-friendly connection name
             provider: Provider type
             connection: The connection object
             config: Connection configuration
-            
+            connection_id: Optional. Use this ID instead of generating a new one (for profiles).
+
         Returns:
             The connection ID
-            
+
         Raises:
             RuntimeError: If maximum connections limit reached
         """
         if len(self._connections) >= self.MAX_CONNECTIONS:
             raise RuntimeError(f"Maximum number of connections ({self.MAX_CONNECTIONS}) reached")
-        
-        connection_id = str(uuid.uuid4())
+
+        if connection_id is None:
+            connection_id = str(uuid.uuid4())
         instance = ConnectionInstance(connection_id, name, provider, connection, config)
         self._connections[connection_id] = instance
-        
+
         # Set as active if it's the first connection
         if len(self._connections) == 1:
             self._active_connection_id = connection_id
             self.active_connection_changed.emit(connection_id)
-        
+
         # Don't emit connection_opened yet - wait until actually connected
         return connection_id
-    
+
     def mark_connection_opened(self, connection_id: str):
         """
         Mark a connection as opened (after successful connection).
-        
+
         Args:
             connection_id: ID of connection that opened
         """
         if connection_id in self._connections:
             self.connection_opened.emit(connection_id)
-    
+
     def get_connection(self, connection_id: str) -> Optional[ConnectionInstance]:
         """Get a connection instance by ID."""
         return self._connections.get(connection_id)
-    
+
     def get_active_connection(self) -> Optional[ConnectionInstance]:
         """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]:
         """Get the currently active connection ID."""
         return self._active_connection_id
-    
+
     def set_active_connection(self, connection_id: str) -> bool:
         """
         Set the active connection.
-        
+
         Args:
             connection_id: ID of connection to make active
-            
+
         Returns:
             True if successful, False if connection not found
         """
         if connection_id not in self._connections:
             return False
-        
+
         self._active_connection_id = connection_id
         self.active_connection_changed.emit(connection_id)
         return True
-    
+
     def close_connection(self, connection_id: str) -> bool:
         """
         Close and remove a connection.
-        
+
         Args:
             connection_id: ID of connection to close
-            
+
         Returns:
             True if successful, False if connection not found
         """
         instance = self._connections.get(connection_id)
         if not instance:
             return False
-        
+
         # Disconnect the connection
         try:
             instance.connection.disconnect()
         except Exception as e:
-            print(f"Error disconnecting: {e}")
-        
+            log_error("Error disconnecting: %s", e)
+
         # Remove from connections dict
         del self._connections[connection_id]
-        
+
         # If this was the active connection, set a new one or None
         if self._active_connection_id == connection_id:
             if self._connections:
@@ -196,14 +201,16 @@ class ConnectionManager(QObject):
             else:
                 self._active_connection_id = None
                 self.active_connection_changed.emit(None)
-        
+
         self.connection_closed.emit(connection_id)
         return True
-    
-    def update_connection_state(self, connection_id: str, state: ConnectionState, error: Optional[str] = None):
+
+    def update_connection_state(
+        self, connection_id: str, state: ConnectionState, error: Optional[str] = None
+    ):
         """
         Update the state of a connection.
-        
+
         Args:
             connection_id: ID of connection
             state: New connection state
@@ -217,11 +224,11 @@ class ConnectionManager(QObject):
             else:
                 instance.error_message = None
             self.connection_state_changed.emit(connection_id, state)
-    
+
     def update_collections(self, connection_id: str, collections: List[str]):
         """
         Update the collections list for a connection.
-        
+
         Args:
             connection_id: ID of connection
             collections: List of collection names
@@ -230,11 +237,11 @@ class ConnectionManager(QObject):
         if instance:
             instance.collections = collections
             self.collections_updated.emit(connection_id, collections)
-    
+
     def set_active_collection(self, connection_id: str, collection_name: Optional[str]):
         """
         Set the active collection for a connection.
-        
+
         Args:
             connection_id: ID of connection
             collection_name: Name of collection to make active, or None
@@ -243,29 +250,29 @@ class ConnectionManager(QObject):
         if instance:
             instance.active_collection = collection_name
             self.active_collection_changed.emit(connection_id, collection_name)
-    
+
     def get_all_connections(self) -> List[ConnectionInstance]:
         """Get list of all connection instances."""
         return list(self._connections.values())
-    
+
     def get_connection_count(self) -> int:
         """Get the number of active connections."""
         return len(self._connections)
-    
+
     def close_all_connections(self):
         """Close all connections. Typically called on application exit."""
         connection_ids = list(self._connections.keys())
         for conn_id in connection_ids:
             self.close_connection(conn_id)
-    
+
     def rename_connection(self, connection_id: str, new_name: str) -> bool:
         """
         Rename a connection.
-        
+
         Args:
             connection_id: ID of connection
             new_name: New name for the connection
-            
+
         Returns:
             True if successful, False if connection not found
         """
@@ -274,4 +281,3 @@ class ConnectionManager(QObject):
             instance.name = new_name
             return True
         return False
-

vector_inspector/core/connections/base_connection.py

@@ -2,59 +2,60 @@
 
 from abc import ABC, abstractmethod
 from typing import Optional, List, Dict, Any
+from vector_inspector.core.logging import log_error
 
 
 class VectorDBConnection(ABC):
     """Abstract base class for vector database connections.
-    
+
     This class defines the interface that all vector database providers
     must implement to be compatible with Vector Inspector.
     """
-    
+
     @abstractmethod
     def connect(self) -> bool:
         """
         Establish connection to the vector database.
-        
+
         Returns:
             True if connection successful, False otherwise
         """
         pass
-    
+
     @abstractmethod
     def disconnect(self):
         """Close connection to the vector database."""
         pass
-    
+
     @property
     @abstractmethod
     def is_connected(self) -> bool:
         """
         Check if connected to the vector database.
-        
+
         Returns:
             True if connected, False otherwise
         """
         pass
-    
+
     @abstractmethod
     def list_collections(self) -> List[str]:
         """
         Get list of all collections/indexes.
-        
+
         Returns:
             List of collection/index names
         """
         pass
-    
+
     @abstractmethod
     def get_collection_info(self, name: str) -> Optional[Dict[str, Any]]:
         """
         Get collection metadata and statistics.
-        
+
         Args:
             name: Collection/index name
-            
+
         Returns:
             Dictionary with collection info including:
                 - name: Collection name
@@ -94,7 +95,7 @@ class VectorDBConnection(ABC):
     def count_collection(self, name: str) -> int:
         """Return the number of items in the collection."""
         pass
-    
+
     @abstractmethod
     def query_collection(
         self,
@@ -107,7 +108,7 @@ class VectorDBConnection(ABC):
     ) -> Optional[Dict[str, Any]]:
         """
         Query a collection for similar vectors.
-        
+
         Args:
             collection_name: Name of collection to query
             query_texts: Text queries to embed and search
@@ -115,7 +116,7 @@ class VectorDBConnection(ABC):
             n_results: Number of results to return
             where: Metadata filter
             where_document: Document content filter
-            
+
         Returns:
             Query results dictionary with keys:
                 - ids: List of result IDs
@@ -125,7 +126,7 @@ class VectorDBConnection(ABC):
                 - embeddings: List of embedding vectors (optional)
         """
         pass
-    
+
     @abstractmethod
     def get_all_items(
         self,
@@ -136,13 +137,13 @@ class VectorDBConnection(ABC):
     ) -> Optional[Dict[str, Any]]:
         """
         Get all items from a collection.
-        
+
         Args:
             collection_name: Name of collection
             limit: Maximum number of items to return
             offset: Number of items to skip
             where: Metadata filter
-            
+
         Returns:
             Dictionary with collection items:
                 - ids: List of item IDs
@@ -151,7 +152,7 @@ class VectorDBConnection(ABC):
                 - embeddings: List of embedding vectors
         """
         pass
-    
+
     @abstractmethod
     def update_items(
         self,
@@ -163,19 +164,19 @@ class VectorDBConnection(ABC):
     ) -> bool:
         """
         Update items in a collection.
-        
+
         Args:
             collection_name: Name of collection
             ids: IDs of items to update
             documents: New document texts
             metadatas: New metadata
             embeddings: New embeddings
-            
+
         Returns:
             True if successful, False otherwise
         """
         pass
-    
+
     @abstractmethod
     def delete_items(
         self,
@@ -185,36 +186,32 @@ class VectorDBConnection(ABC):
     ) -> bool:
         """
         Delete items from a collection.
-        
+
         Args:
             collection_name: Name of collection
             ids: IDs of items to delete
             where: Metadata filter for items to delete
-            
+
         Returns:
             True if successful, False otherwise
         """
         pass
-    
 
     # Optional: Methods that may be provider-specific but useful to define
-    
+
     def get_connection_info(self) -> Dict[str, Any]:
         """
         Get information about the current connection.
-        
+
         Returns:
             Dictionary with connection details (provider-specific)
         """
-        return {
-            "provider": self.__class__.__name__,
-            "connected": self.is_connected
-        }
-    
+        return {"provider": self.__class__.__name__, "connected": self.is_connected}
+
     def get_supported_filter_operators(self) -> List[Dict[str, Any]]:
         """
         Get list of filter operators supported by this provider.
-        
+
         Returns:
             List of operator dictionaries with 'name' and 'server_side' keys
         """
@@ -230,20 +227,22 @@ class VectorDBConnection(ABC):
             {"name": "not in", "server_side": True},
             {"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, connection_id: Optional[str] = None
+    ) -> Optional[str]:
         """
         Get the embedding model used for a collection.
-        
+
         Retrieves the model name from:
         1. Collection-level metadata (if supported)
         2. Vector metadata (_embedding_model field)
         3. User settings (for collections we can't modify)
-        
+
         Args:
             collection_name: Name of collection
             connection_id: Optional connection ID for settings lookup
-            
+
         Returns:
             Model name string (e.g., "sentence-transformers/all-MiniLM-L6-v2") or None
         """
@@ -252,23 +251,24 @@ class VectorDBConnection(ABC):
             info = self.get_collection_info(collection_name)
             if info and info.get("embedding_model"):
                 return info["embedding_model"]
-            
+
             # Fall back to checking a sample vector's metadata
             data = self.get_all_items(collection_name, limit=1, offset=0)
             if data and data.get("metadatas") and len(data["metadatas"]) > 0:
                 metadata = data["metadatas"][0]
                 if "_embedding_model" in metadata:
                     return metadata["_embedding_model"]
-            
+
             # Finally, check user settings (for collections we can't modify)
             if connection_id:
                 from ...services.settings_service import SettingsService
+
                 settings = SettingsService()
                 model_info = settings.get_embedding_model(connection_id, collection_name)
                 if model_info:
                     return model_info["model"]
-            
+
             return None
         except Exception as e:
-            print(f"Failed to get embedding model: {e}")
+            log_error("Failed to get embedding model: %s", e)
             return None