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

vector_inspector/services/credential_service.py

@@ -0,0 +1,130 @@
+"""Service for secure credential storage using system keychains."""
+
+from typing import Optional
+import json
+
+
+class CredentialService:
+    """Handles secure storage and retrieval of credentials using system keychains.
+    
+    Falls back to in-memory storage if keyring is not available (not recommended for production).
+    """
+    
+    SERVICE_NAME = "vector-inspector"
+    
+    def __init__(self):
+        """Initialize credential service with keyring if available."""
+        self._use_keyring = False
+        self._memory_store = {}  # Fallback in-memory storage
+        
+        try:
+            import keyring
+            self._keyring = keyring
+            self._use_keyring = True
+        except ImportError:
+            print("Warning: keyring module not available. Credentials will not be persisted securely.")
+            self._keyring = None
+    
+    def store_credentials(self, profile_id: str, credentials: dict) -> bool:
+        """
+        Store credentials for a profile.
+        
+        Args:
+            profile_id: Unique profile identifier
+            credentials: Dictionary of credential data (api_key, password, etc.)
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            credential_key = f"profile:{profile_id}"
+            credential_json = json.dumps(credentials)
+            
+            if self._use_keyring:
+                self._keyring.set_password(
+                    self.SERVICE_NAME,
+                    credential_key,
+                    credential_json
+                )
+            else:
+                # Fallback to in-memory (not persistent)
+                self._memory_store[credential_key] = credential_json
+            
+            return True
+        except Exception as e:
+            print(f"Failed to store credentials: {e}")
+            return False
+    
+    def get_credentials(self, profile_id: str) -> Optional[dict]:
+        """
+        Retrieve credentials for a profile.
+        
+        Args:
+            profile_id: Unique profile identifier
+            
+        Returns:
+            Dictionary of credential data, or None if not found
+        """
+        try:
+            credential_key = f"profile:{profile_id}"
+            
+            if self._use_keyring:
+                credential_json = self._keyring.get_password(
+                    self.SERVICE_NAME,
+                    credential_key
+                )
+            else:
+                # Fallback to in-memory
+                credential_json = self._memory_store.get(credential_key)
+            
+            if credential_json:
+                return json.loads(credential_json)
+            return None
+        except Exception as e:
+            print(f"Failed to retrieve credentials: {e}")
+            return None
+    
+    def delete_credentials(self, profile_id: str) -> bool:
+        """
+        Delete stored credentials for a profile.
+        
+        Args:
+            profile_id: Unique profile identifier
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            credential_key = f"profile:{profile_id}"
+            
+            if self._use_keyring:
+                try:
+                    self._keyring.delete_password(
+                        self.SERVICE_NAME,
+                        credential_key
+                    )
+                except self._keyring.errors.PasswordDeleteError:
+                    # Credential doesn't exist, that's okay
+                    pass
+            else:
+                # Fallback to in-memory
+                self._memory_store.pop(credential_key, None)
+            
+            return True
+        except Exception as e:
+            print(f"Failed to delete credentials: {e}")
+            return False
+    
+    def is_keyring_available(self) -> bool:
+        """Check if system keyring is available."""
+        return self._use_keyring
+    
+    def clear_all_credentials(self):
+        """Clear all stored credentials. Use with caution!"""
+        if not self._use_keyring:
+            self._memory_store.clear()
+        else:
+            # For keyring, we'd need to track all profile IDs
+            # This is typically not needed, but can be implemented if required
+            print("Warning: clear_all_credentials not implemented for keyring backend")
+

vector_inspector/services/filter_service.py

@@ -66,7 +66,7 @@ def apply_client_side_filters(data: Dict[str, Any], filters: List[Dict[str, Any]
         "metadatas": [metadatas[i] for i in keep_indices if i < len(metadatas)],
     }
     
-    if embeddings:
+    if embeddings is not None and len(embeddings) > 0:
         filtered_data["embeddings"] = [embeddings[i] for i in keep_indices if i < len(embeddings)]
     
     return filtered_data

vector_inspector/services/profile_service.py

@@ -0,0 +1,409 @@
+"""Service for managing connection profiles."""
+
+import json
+import uuid
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from PySide6.QtCore import QObject, Signal
+
+from .credential_service import CredentialService
+
+
+class ConnectionProfile:
+    """Represents a saved connection profile."""
+    
+    def __init__(
+        self,
+        profile_id: str,
+        name: str,
+        provider: str,
+        config: Dict[str, Any],
+        credential_fields: Optional[List[str]] = None
+    ):
+        """
+        Initialize a connection profile.
+        
+        Args:
+            profile_id: Unique profile identifier
+            name: User-friendly profile name
+            provider: Provider type (chromadb, qdrant, etc.)
+            config: Non-sensitive configuration (host, port, path, etc.)
+            credential_fields: List of field names that contain credentials
+        """
+        self.id = profile_id
+        self.name = name
+        self.provider = provider
+        self.config = config
+        self.credential_fields = credential_fields or []
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert profile to dictionary (without credentials)."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "provider": self.provider,
+            "config": self.config,
+            "credential_fields": self.credential_fields
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ConnectionProfile":
+        """Create profile from dictionary."""
+        return cls(
+            profile_id=data["id"],
+            name=data["name"],
+            provider=data["provider"],
+            config=data.get("config", {}),
+            credential_fields=data.get("credential_fields", [])
+        )
+
+
+class ProfileService(QObject):
+    """Manages connection profiles and persistence.
+    
+    Signals:
+        profile_added: Emitted when a profile is added (profile_id)
+        profile_updated: Emitted when a profile is updated (profile_id)
+        profile_deleted: Emitted when a profile is deleted (profile_id)
+    """
+    
+    # Signals
+    profile_added = Signal(str)  # profile_id
+    profile_updated = Signal(str)  # profile_id
+    profile_deleted = Signal(str)  # profile_id
+    
+    def __init__(self):
+        """Initialize profile service."""
+        super().__init__()
+        self.profiles_dir = Path.home() / ".vector-inspector"
+        self.profiles_file = self.profiles_dir / "profiles.json"
+        self.credential_service = CredentialService()
+        self._profiles: Dict[str, ConnectionProfile] = {}
+        self._last_active_connections: List[str] = []
+        self._load_profiles()
+    
+    def _load_profiles(self):
+        """Load profiles from disk."""
+        try:
+            if self.profiles_file.exists():
+                with open(self.profiles_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    
+                    # Load profiles
+                    for profile_data in data.get("profiles", []):
+                        profile = ConnectionProfile.from_dict(profile_data)
+                        self._profiles[profile.id] = profile
+                    
+                    # Load last active connections
+                    self._last_active_connections = data.get("last_active_connections", [])
+        except Exception as e:
+            print(f"Failed to load profiles: {e}")
+            self._profiles = {}
+            self._last_active_connections = []
+    
+    def _save_profiles(self):
+        """Save profiles to disk."""
+        try:
+            # Create directory if it doesn't exist
+            self.profiles_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Prepare data
+            data = {
+                "profiles": [profile.to_dict() for profile in self._profiles.values()],
+                "last_active_connections": self._last_active_connections
+            }
+            
+            # Write to file
+            with open(self.profiles_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"Failed to save profiles: {e}")
+    
+    def create_profile(
+        self,
+        name: str,
+        provider: str,
+        config: Dict[str, Any],
+        credentials: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Create a new connection profile.
+        
+        Args:
+            name: Profile name
+            provider: Provider type
+            config: Connection configuration (non-sensitive)
+            credentials: Credential data to store securely (optional)
+            
+        Returns:
+            The profile ID
+        """
+        profile_id = str(uuid.uuid4())
+        credential_fields = list(credentials.keys()) if credentials else []
+        
+        profile = ConnectionProfile(
+            profile_id=profile_id,
+            name=name,
+            provider=provider,
+            config=config,
+            credential_fields=credential_fields
+        )
+        
+        self._profiles[profile_id] = profile
+        
+        # Store credentials if provided
+        if credentials:
+            self.credential_service.store_credentials(profile_id, credentials)
+        
+        self._save_profiles()
+        self.profile_added.emit(profile_id)
+        
+        return profile_id
+    
+    def get_profile(self, profile_id: str) -> Optional[ConnectionProfile]:
+        """Get a profile by ID."""
+        return self._profiles.get(profile_id)
+    
+    def get_all_profiles(self) -> List[ConnectionProfile]:
+        """Get all saved profiles."""
+        return list(self._profiles.values())
+    
+    def update_profile(
+        self,
+        profile_id: str,
+        name: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+        credentials: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Update an existing profile.
+        
+        Args:
+            profile_id: ID of profile to update
+            name: New name (optional)
+            config: New configuration (optional)
+            credentials: New credentials (optional)
+            
+        Returns:
+            True if successful, False if profile not found
+        """
+        profile = self._profiles.get(profile_id)
+        if not profile:
+            return False
+        
+        if name is not None:
+            profile.name = name
+        
+        if config is not None:
+            profile.config = config
+        
+        if credentials is not None:
+            profile.credential_fields = list(credentials.keys())
+            self.credential_service.store_credentials(profile_id, credentials)
+        
+        self._save_profiles()
+        self.profile_updated.emit(profile_id)
+        
+        return True
+    
+    def delete_profile(self, profile_id: str) -> bool:
+        """
+        Delete a profile.
+        
+        Args:
+            profile_id: ID of profile to delete
+            
+        Returns:
+            True if successful, False if profile not found
+        """
+        if profile_id not in self._profiles:
+            return False
+        
+        # Delete credentials
+        self.credential_service.delete_credentials(profile_id)
+        
+        # Remove from profiles
+        del self._profiles[profile_id]
+        
+        # Remove from last active connections if present
+        if profile_id in self._last_active_connections:
+            self._last_active_connections.remove(profile_id)
+        
+        self._save_profiles()
+        self.profile_deleted.emit(profile_id)
+        
+        return True
+    
+    def duplicate_profile(self, profile_id: str, new_name: str) -> Optional[str]:
+        """
+        Duplicate an existing profile.
+        
+        Args:
+            profile_id: ID of profile to duplicate
+            new_name: Name for the new profile
+            
+        Returns:
+            New profile ID, or None if source profile not found
+        """
+        source_profile = self._profiles.get(profile_id)
+        if not source_profile:
+            return None
+        
+        # Get credentials from source
+        credentials = self.credential_service.get_credentials(profile_id)
+        
+        # Create new profile
+        new_id = self.create_profile(
+            name=new_name,
+            provider=source_profile.provider,
+            config=source_profile.config.copy(),
+            credentials=credentials
+        )
+        
+        return new_id
+    
+    def get_profile_with_credentials(self, profile_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a profile along with its credentials.
+        
+        Args:
+            profile_id: ID of profile
+            
+        Returns:
+            Dictionary with profile data and credentials, or None if not found
+        """
+        profile = self._profiles.get(profile_id)
+        if not profile:
+            return None
+        
+        credentials = self.credential_service.get_credentials(profile_id)
+        
+        return {
+            "id": profile.id,
+            "name": profile.name,
+            "provider": profile.provider,
+            "config": profile.config,
+            "credentials": credentials or {}
+        }
+    
+    def export_profiles(self, include_credentials: bool = False) -> List[Dict[str, Any]]:
+        """
+        Export all profiles for backup/sharing.
+        
+        Args:
+            include_credentials: Whether to include credentials (NOT RECOMMENDED)
+            
+        Returns:
+            List of profile dictionaries
+        """
+        exported = []
+        for profile in self._profiles.values():
+            data = profile.to_dict()
+            if include_credentials:
+                credentials = self.credential_service.get_credentials(profile.id)
+                if credentials:
+                    data["credentials"] = credentials
+            exported.append(data)
+        return exported
+    
+    def import_profiles(
+        self,
+        profiles_data: List[Dict[str, Any]],
+        overwrite: bool = False
+    ) -> Dict[str, str]:
+        """
+        Import profiles from exported data.
+        
+        Args:
+            profiles_data: List of profile dictionaries
+            overwrite: Whether to overwrite existing profiles with same ID
+            
+        Returns:
+            Dictionary mapping old IDs to new IDs
+        """
+        id_mapping = {}
+        
+        for profile_data in profiles_data:
+            old_id = profile_data.get("id")
+            
+            # Generate new ID if not overwriting or ID exists
+            if not overwrite or old_id in self._profiles:
+                new_id = str(uuid.uuid4())
+            else:
+                new_id = str(old_id) if old_id else str(uuid.uuid4())
+            
+            credentials = profile_data.pop("credentials", None)
+            
+            # Create profile
+            profile = ConnectionProfile(
+                profile_id=new_id,
+                name=profile_data["name"],
+                provider=profile_data["provider"],
+                config=profile_data.get("config", {}),
+                credential_fields=profile_data.get("credential_fields", [])
+            )
+            
+            self._profiles[new_id] = profile
+            
+            # Store credentials if provided
+            if credentials:
+                self.credential_service.store_credentials(new_id, credentials)
+            
+            id_mapping[old_id] = new_id
+        
+        self._save_profiles()
+        
+        return id_mapping
+    
+    def save_last_active_connections(self, connection_ids: List[str]):
+        """
+        Save list of last active connection profile IDs for session restore.
+        
+        Args:
+            connection_ids: List of profile IDs that were active
+        """
+        self._last_active_connections = connection_ids
+        self._save_profiles()
+    
+    def get_last_active_connections(self) -> List[str]:
+        """Get list of last active connection profile IDs."""
+        return self._last_active_connections.copy()
+    
+    def migrate_legacy_connection(self, config: Dict[str, Any]) -> str:
+        """
+        Migrate a legacy single-connection configuration to a profile.
+        
+        Args:
+            config: Legacy connection configuration
+            
+        Returns:
+            The new profile ID
+        """
+        provider = config.get("provider", "chromadb")
+        conn_type = config.get("type", "persistent")
+        
+        # Create a name based on connection type
+        if conn_type == "persistent":
+            name = f"Legacy {provider.title()} (Persistent)"
+        elif conn_type == "http":
+            host = config.get("host", "localhost")
+            name = f"Legacy {provider.title()} ({host})"
+        else:
+            name = f"Legacy {provider.title()} (Ephemeral)"
+        
+        # Extract credentials if any
+        credentials = {}
+        if "api_key" in config and config["api_key"]:
+            credentials["api_key"] = config["api_key"]
+            del config["api_key"]  # Remove from config
+        
+        # Create profile
+        profile_id = self.create_profile(
+            name=name,
+            provider=provider,
+            config=config,
+            credentials=credentials if credentials else None
+        )
+        
+        return profile_id
+

vector_inspector/services/settings_service.py

@@ -2,7 +2,8 @@
 
 import json
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
+from vector_inspector.core.cache_manager import invalidate_cache_on_settings_change
 
 
 class SettingsService:
@@ -49,12 +50,146 @@ class SettingsService:
         """Get a setting value."""
         return self.settings.get(key, default)
     
+    def get_cache_enabled(self) -> bool:
+        """Get whether caching is enabled (default: True)."""
+        return self.settings.get("cache_enabled", True)
+    
+    def set_cache_enabled(self, enabled: bool):
+        """Set whether caching is enabled."""
+        self.set("cache_enabled", enabled)
+        # Update cache manager state
+        from vector_inspector.core.cache_manager import get_cache_manager
+        cache = get_cache_manager()
+        if enabled:
+            cache.enable()
+        else:
+            cache.disable()
+    
     def set(self, key: str, value: Any):
         """Set a setting value."""
         self.settings[key] = value
         self._save_settings()
+        # 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()
     
     def clear(self):
         """Clear all settings."""
         self.settings = {}
         self._save_settings()
+    
+    def save_embedding_model(self, connection_id: str, collection_name: str, model_name: str, model_type: str = "user-configured"):
+        """Save embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+            model_name: Embedding model name (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
+            model_type: Type of configuration ('user-configured', 'auto-detected', 'stored')
+        """
+        if "collection_embedding_models" not in self.settings:
+            self.settings["collection_embedding_models"] = {}
+        
+        collection_key = f"{connection_id}:{collection_name}"
+        self.settings["collection_embedding_models"][collection_key] = {
+            "model": model_name,
+            "type": model_type,
+            "timestamp": self._get_timestamp()
+        }
+        self._save_settings()
+    
+    def get_embedding_model(self, connection_id: str, collection_name: str) -> Optional[Dict[str, Any]]:
+        """Get embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+            
+        Returns:
+            Dictionary with 'model', 'type', and 'timestamp' or None
+        """
+        collection_models = self.settings.get("collection_embedding_models", {})
+        collection_key = f"{connection_id}:{collection_name}"
+        return collection_models.get(collection_key)
+    
+    def remove_embedding_model(self, connection_id: str, collection_name: str):
+        """Remove embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+        """
+        if "collection_embedding_models" not in self.settings:
+            return
+        
+        collection_key = f"{connection_id}:{collection_name}"
+        self.settings["collection_embedding_models"].pop(collection_key, None)
+        self._save_settings()
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp as ISO string."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    def add_custom_embedding_model(self, model_name: str, dimension: int, model_type: str = "sentence-transformer", description: str = "Custom model"):
+        """Add a custom embedding model to the known models list.
+        
+        Args:
+            model_name: Name of the embedding model
+            dimension: Vector dimension
+            model_type: Type of model (e.g., 'sentence-transformer', 'clip', 'openai')
+            description: Brief description of the model
+        """
+        if "custom_embedding_models" not in self.settings:
+            self.settings["custom_embedding_models"] = []
+        
+        # Check if already exists
+        for model in self.settings["custom_embedding_models"]:
+            if model["name"] == model_name and model["dimension"] == dimension:
+                # Update existing entry
+                model["type"] = model_type
+                model["description"] = description
+                model["last_used"] = self._get_timestamp()
+                self._save_settings()
+                return
+        
+        # Add new entry
+        self.settings["custom_embedding_models"].append({
+            "name": model_name,
+            "dimension": dimension,
+            "type": model_type,
+            "description": description,
+            "added": self._get_timestamp(),
+            "last_used": self._get_timestamp()
+        })
+        self._save_settings()
+    
+    def get_custom_embedding_models(self, dimension: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Get list of custom embedding models.
+        
+        Args:
+            dimension: Optional filter by dimension
+            
+        Returns:
+            List of custom model dictionaries
+        """
+        models = self.settings.get("custom_embedding_models", [])
+        if dimension is not None:
+            return [m for m in models if m["dimension"] == dimension]
+        return models
+    
+    def remove_custom_embedding_model(self, model_name: str, dimension: int):
+        """Remove a custom embedding model.
+        
+        Args:
+            model_name: Name of the model to remove
+            dimension: Vector dimension
+        """
+        if "custom_embedding_models" not in self.settings:
+            return
+        
+        self.settings["custom_embedding_models"] = [
+            m for m in self.settings["custom_embedding_models"]
+            if not (m["name"] == model_name and m["dimension"] == dimension)
+        ]
+        self._save_settings()