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

vector_inspector/services/backup_restore_service.py

@@ -1,13 +1,12 @@
 """Service for backing up and restoring collections."""
 
-import json
-from typing import Dict, Any, Optional
+from datetime import datetime, timezone
 from pathlib import Path
-from datetime import datetime
-import shutil
+from typing import Optional
 
-from vector_inspector.core.logging import log_info, log_error, log_debug
-from .backup_helpers import write_backup_zip, read_backup_zip, normalize_embeddings
+from vector_inspector.core.logging import log_debug, log_error, log_info
+
+from .backup_helpers import normalize_embeddings, read_backup_zip, write_backup_zip
 
 
 class BackupRestoreService:
@@ -15,7 +14,11 @@ class BackupRestoreService:
 
     @staticmethod
     def backup_collection(
-        connection, collection_name: str, backup_dir: str, include_embeddings: bool = True
+        connection,
+        collection_name: str,
+        backup_dir: str,
+        include_embeddings: bool = True,
+        profile_name: Optional[str] = None,
     ) -> Optional[str]:
         """
         Backup a collection to a directory.
@@ -25,6 +28,7 @@ class BackupRestoreService:
             collection_name: Name of collection to backup
             backup_dir: Directory to store backups
             include_embeddings: Whether to include embedding vectors
+            connection_id: Optional connection ID for retrieving model config from settings
 
         Returns:
             Path to backup file or None if failed
@@ -50,13 +54,51 @@ class BackupRestoreService:
 
             backup_metadata = {
                 "collection_name": collection_name,
-                "backup_timestamp": datetime.now().isoformat(),
+                "backup_timestamp": datetime.now(tz=timezone.utc).isoformat(),
                 "item_count": len(all_data["ids"]),
                 "collection_info": collection_info,
                 "include_embeddings": include_embeddings,
             }
-
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            # Include embedding model info when available to assist accurate restores
+            try:
+                embed_model = None
+                embed_model_type = None
+                # Prefer explicit collection_info entries
+                if collection_info and collection_info.get("embedding_model"):
+                    embed_model = collection_info.get("embedding_model")
+                    embed_model_type = collection_info.get("embedding_model_type")
+                else:
+                    # Ask connection for a model hint (may consult settings/service)
+                    try:
+                        embed_model = connection.get_embedding_model(collection_name)
+                    except Exception:
+                        embed_model = None
+
+                # If not found yet, check app settings as a fallback
+                if not embed_model and profile_name:
+                    try:
+                        from vector_inspector.services.settings_service import SettingsService
+
+                        settings = SettingsService()
+                        model_info = settings.get_embedding_model(
+                            profile_name,
+                            collection_name,
+                        )
+                        if model_info:
+                            embed_model = model_info.get("model")
+                            embed_model_type = model_info.get("type", "sentence-transformer")
+                    except Exception:
+                        pass
+
+                if embed_model:
+                    backup_metadata["embedding_model"] = embed_model
+                if embed_model_type:
+                    backup_metadata["embedding_model_type"] = embed_model_type
+            except Exception as e:
+                # Embedding metadata is optional; log failure but do not abort backup.
+                log_debug("Failed to populate embedding metadata for %s: %s", collection_name, e)
+
+            timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_filename = f"{collection_name}_backup_{timestamp}.zip"
             backup_path = Path(backup_dir) / backup_filename
 
@@ -67,9 +109,14 @@ class BackupRestoreService:
             log_error("Backup failed: %s", e)
             return None
 
-    @staticmethod
     def restore_collection(
-        connection, backup_file: str, collection_name: Optional[str] = None, overwrite: bool = False
+        self,
+        connection,
+        backup_file: str,
+        collection_name: Optional[str] = None,
+        overwrite: bool = False,
+        recompute_embeddings: Optional[bool] = None,
+        profile_name: Optional[str] = None,
     ) -> bool:
         """
         Restore a collection from a backup file.
@@ -79,6 +126,11 @@ class BackupRestoreService:
             backup_file: Path to backup zip file
             collection_name: Optional new name for restored collection
             overwrite: Whether to overwrite existing collection
+            recompute_embeddings: How to handle embeddings during restore:
+                - None (default): Use stored embeddings as-is from backup (safest, fastest)
+                - True: Force recompute embeddings from documents using model metadata
+                - False: Omit embeddings entirely (documents/metadata only)
+            connection_id: Optional connection ID for saving model config to app settings
 
         Returns:
             True if successful, False otherwise
@@ -96,8 +148,48 @@ class BackupRestoreService:
                         restore_collection_name,
                     )
                     return False
-                else:
-                    connection.delete_collection(restore_collection_name)
+                connection.delete_collection(restore_collection_name)
+            else:
+                # Collection does not exist on target; attempt to create it.
+                # Try to infer vector size from metadata or embedded vectors in backup.
+                try:
+                    inferred_size = None
+                    col_info = metadata.get("collection_info") if metadata else None
+                    if (
+                        col_info
+                        and col_info.get("vector_dimension")
+                        and isinstance(col_info.get("vector_dimension"), int)
+                    ):
+                        inferred_size = int(col_info.get("vector_dimension"))
+
+                    # Fallback: inspect embeddings in backup data
+                    if inferred_size is None and data and data.get("embeddings"):
+                        first_emb = data.get("embeddings")[0]
+                        if first_emb is not None:
+                            inferred_size = len(first_emb)
+
+                    # Final fallback: common default
+                    if inferred_size is None:
+                        log_error(
+                            "Unable to infer vector dimension for collection %s from metadata or backup data; restore aborted.",
+                            restore_collection_name,
+                        )
+                        return False
+
+                    created = True
+                    if hasattr(connection, "create_collection"):
+                        created = connection.create_collection(
+                            restore_collection_name, inferred_size
+                        )
+
+                    if not created:
+                        log_error(
+                            "Failed to create collection %s before restore", restore_collection_name
+                        )
+                        return False
+                except Exception as e:
+                    log_error("Error while creating collection %s: %s", restore_collection_name, e)
+                    return False
 
             # Provider-specific preparation hook
             if hasattr(connection, "prepare_restore"):
@@ -109,17 +201,138 @@ class BackupRestoreService:
             # Ensure embeddings normalized
             data = normalize_embeddings(data)
 
+            # Decide how to handle embeddings based on user choice
+            embeddings_to_use = None
+            stored_embeddings = data.get("embeddings")
+
+            if recompute_embeddings is False:
+                # User explicitly chose to omit embeddings
+                log_info("Restoring without embeddings (user choice)")
+                embeddings_to_use = None
+
+            elif recompute_embeddings is True:
+                # User explicitly chose to recompute embeddings
+                log_info("Recomputing embeddings from documents")
+                try:
+                    from vector_inspector.core.embedding_utils import (
+                        encode_text,
+                        load_embedding_model,
+                    )
+
+                    model_name = metadata.get("embedding_model") if metadata else None
+                    docs = data.get("documents", [])
+
+                    if not model_name:
+                        log_error(
+                            "Cannot recompute: No embedding model available in backup metadata"
+                        )
+                        embeddings_to_use = None
+                    elif not docs:
+                        log_error("Cannot recompute: No documents available in backup")
+                        embeddings_to_use = None
+                    else:
+                        model_type = metadata.get("embedding_model_type", "sentence-transformer")
+                        log_info("Loading embedding model: %s (%s)", model_name, model_type)
+                        model = load_embedding_model(model_name, model_type)
+                        new_embeddings = []
+                        if model_type == "clip":
+                            # CLIP: encode per-document
+                            for d in docs:
+                                new_embeddings.append(encode_text(d, model, model_type))
+                        else:
+                            # sentence-transformer supports batch encode
+                            new_embeddings = model.encode(docs, show_progress_bar=False).tolist()
+
+                        embeddings_to_use = new_embeddings
+                        log_info("Successfully recomputed %d embeddings", len(new_embeddings))
+                except Exception as e:
+                    log_error("Failed to recompute embeddings: %s", e)
+                    embeddings_to_use = None
+
+            else:
+                # Default (None): Use stored embeddings as-is if available
+                if stored_embeddings:
+                    # Check dimension compatibility with target collection
+                    try:
+                        if stored_embeddings and len(stored_embeddings) > 0:
+                            stored_dim = len(stored_embeddings[0])
+                            target_dim = inferred_size  # We already calculated this above
+
+                            if stored_dim == target_dim:
+                                log_info(
+                                    "Using stored embeddings from backup (dimension: %d)",
+                                    stored_dim,
+                                )
+                                embeddings_to_use = stored_embeddings
+                            else:
+                                log_error(
+                                    "Dimension mismatch: backup has %d, target needs %d. Omitting embeddings.",
+                                    stored_dim,
+                                    target_dim,
+                                )
+                                embeddings_to_use = None
+                        else:
+                            embeddings_to_use = stored_embeddings
+                    except Exception as e:
+                        log_error("Error checking embedding dimensions: %s", e)
+                        # Try to use them anyway
+                        embeddings_to_use = stored_embeddings
+                else:
+                    log_info("No embeddings in backup to restore")
+                    embeddings_to_use = None
+
             success = connection.add_items(
                 restore_collection_name,
                 documents=data.get("documents", []),
                 metadatas=data.get("metadatas"),
                 ids=data.get("ids"),
-                embeddings=data.get("embeddings"),
+                embeddings=embeddings_to_use,
             )
 
             if success:
                 log_info("Collection '%s' restored from backup", restore_collection_name)
                 log_info("Restored %d items", len(data.get("ids", [])))
+
+                # Save model config to app settings if available
+                if profile_name and restore_collection_name and metadata:
+                    try:
+                        embed_model = metadata.get("embedding_model")
+                        embed_model_type = metadata.get(
+                            "embedding_model_type", "sentence-transformer"
+                        )
+                        if embed_model:
+                            from vector_inspector.services.settings_service import SettingsService
+
+                            settings = SettingsService()
+                            settings.save_embedding_model(
+                                profile_name,
+                                restore_collection_name,
+                                embed_model,
+                                embed_model_type,
+                            )
+                            log_info(
+                                "Saved model config to settings: %s (%s)",
+                                embed_model,
+                                embed_model_type,
+                            )
+                    except Exception as e:
+                        log_error("Failed to save model config to settings: %s", e)
+
+                # Clear the cache for this collection so the info panel gets fresh data
+                if profile_name and restore_collection_name:
+                    try:
+                        from vector_inspector.core.cache_manager import get_cache_manager
+
+                        cache = get_cache_manager()
+                        # Use profile_name as the database identifier for cache
+                        cache.invalidate(profile_name, restore_collection_name)
+                        log_info(
+                            "Cleared cache for restored collection: %s",
+                            restore_collection_name,
+                        )
+                    except Exception as e:
+                        log_error("Failed to clear cache after restore: %s", e)
+
                 return True
 
             # Failure: attempt cleanup

vector_inspector/services/settings_service.py

@@ -1,19 +1,37 @@
 """Service for persisting application settings."""
 
-import json
 import base64
-from PySide6.QtCore import QObject, Signal
+import json
 from pathlib import Path
-from typing import Dict, Any, Optional, List
+from typing import Any, Optional
+
+from PySide6.QtCore import QObject, Signal
+
 from vector_inspector.core.cache_manager import invalidate_cache_on_settings_change
 from vector_inspector.core.logging import log_error
 
 
 class SettingsService:
-    """Handles loading and saving application settings."""
+    """Handles loading and saving application settings.
+
+    This is a singleton - all instances share the same settings data.
+    """
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls):
+        """Ensure only one instance exists (singleton pattern)."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
 
     def __init__(self):
         """Initialize settings service."""
+        # Only initialize once
+        if SettingsService._initialized:
+            return
+        SettingsService._initialized = True
 
         # Expose a shared QObject-based signal emitter so UI can react to
         # settings changes without polling.
@@ -28,14 +46,14 @@ class SettingsService:
 
         self.settings_dir = Path.home() / ".vector-inspector"
         self.settings_file = self.settings_dir / "settings.json"
-        self.settings: Dict[str, Any] = {}
+        self.settings: dict[str, Any] = {}
         self._load_settings()
 
     def _load_settings(self):
         """Load settings from file."""
         try:
             if self.settings_file.exists():
-                with open(self.settings_file, "r", encoding="utf-8") as f:
+                with open(self.settings_file, encoding="utf-8") as f:
                     self.settings = json.load(f)
         except Exception as e:
             log_error("Failed to load settings: %s", e)
@@ -52,11 +70,11 @@ class SettingsService:
         except Exception as e:
             log_error("Failed to save settings: %s", e)
 
-    def get_last_connection(self) -> Optional[Dict[str, Any]]:
+    def get_last_connection(self) -> Optional[dict[str, Any]]:
         """Get the last connection configuration."""
         return self.settings.get("last_connection")
 
-    def save_last_connection(self, config: Dict[str, Any]):
+    def save_last_connection(self, config: dict[str, Any]):
         """Save the last connection configuration."""
         self.settings["last_connection"] = config
         self._save_settings()
@@ -137,6 +155,14 @@ class SettingsService:
         else:
             cache.disable()
 
+    def get_telemetry_enabled(self) -> bool:
+        """Get whether telemetry is enabled (default: True)."""
+        return bool(self.settings.get("telemetry.enabled", True))
+
+    def set_telemetry_enabled(self, enabled: bool):
+        """Set whether telemetry is enabled."""
+        self.set("telemetry.enabled", bool(enabled))
+
     def set(self, key: str, value: Any):
         """Set a setting value."""
         self.settings[key] = value
@@ -158,7 +184,7 @@ class SettingsService:
 
     def save_embedding_model(
         self,
-        connection_id: str,
+        profile_name: str,
         collection_name: str,
         model_name: str,
         model_type: str = "user-configured",
@@ -166,7 +192,7 @@ class SettingsService:
         """Save embedding model mapping for a collection.
 
         Args:
-            connection_id: Connection identifier
+            profile_name: Profile/connection name
             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')
@@ -174,7 +200,7 @@ class SettingsService:
         if "collection_embedding_models" not in self.settings:
             self.settings["collection_embedding_models"] = {}
 
-        collection_key = f"{connection_id}:{collection_name}"
+        collection_key = f"{profile_name}:{collection_name}"
         self.settings["collection_embedding_models"][collection_key] = {
             "model": model_name,
             "type": model_type,
@@ -183,35 +209,69 @@ class SettingsService:
         self._save_settings()
 
     def get_embedding_model(
-        self, connection_id: str, collection_name: str
-    ) -> Optional[Dict[str, Any]]:
+        self,
+        profile_name: str,
+        collection_name: str,
+    ) -> Optional[dict[str, Any]]:
         """Get embedding model mapping for a collection.
 
         Args:
-            connection_id: Connection identifier
+            profile_name: Profile/connection name
             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}"
+        collection_key = f"{profile_name}:{collection_name}"
         return collection_models.get(collection_key)
 
-    def remove_embedding_model(self, connection_id: str, collection_name: str):
+    def remove_embedding_model(
+        self,
+        profile_name: str,
+        collection_name: str,
+    ):
         """Remove embedding model mapping for a collection.
 
         Args:
-            connection_id: Connection identifier
+            profile_name: Profile/connection name
             collection_name: Collection name
         """
         if "collection_embedding_models" not in self.settings:
             return
 
-        collection_key = f"{connection_id}:{collection_name}"
+        collection_key = f"{profile_name}:{collection_name}"
         self.settings["collection_embedding_models"].pop(collection_key, None)
         self._save_settings()
 
+    def remove_profile_settings(self, profile_name: str):
+        """Remove all settings for a profile (e.g., when profile is deleted).
+
+        Args:
+            profile_name: Profile/connection name
+        """
+        if "collection_embedding_models" not in self.settings:
+            return
+
+        # Remove all keys that start with profile_name:
+        prefix = f"{profile_name}:"
+        keys_to_remove = [
+            key for key in self.settings["collection_embedding_models"] if key.startswith(prefix)
+        ]
+
+        for key in keys_to_remove:
+            self.settings["collection_embedding_models"].pop(key, None)
+
+        if keys_to_remove:
+            self._save_settings()
+            from vector_inspector.core.logging import log_info
+
+            log_info(
+                "Removed %d embedding model settings for profile: %s",
+                len(keys_to_remove),
+                profile_name,
+            )
+
     def _get_timestamp(self) -> str:
         """Get current timestamp as ISO string."""
         from datetime import datetime
@@ -259,7 +319,7 @@ class SettingsService:
         )
         self._save_settings()
 
-    def get_custom_embedding_models(self, dimension: Optional[int] = None) -> List[Dict[str, Any]]:
+    def get_custom_embedding_models(self, dimension: Optional[int] = None) -> list[dict[str, Any]]:
         """Get list of custom embedding models.
 
         Args:

vector_inspector/services/telemetry_service.py

@@ -0,0 +1,88 @@
+import json
+import platform
+import uuid
+import requests
+from pathlib import Path
+from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.core.logging import log_info, log_error
+
+TELEMETRY_ENDPOINT = "https://api.divinedevops.com/api/v1/telemetry"
+
+
+class TelemetryService:
+    def __init__(self, settings_service=None):
+        self.settings = settings_service or SettingsService()
+        self.queue_file = Path.home() / ".vector-inspector" / "telemetry_queue.json"
+        self._load_queue()
+
+    def _load_queue(self):
+        if self.queue_file.exists():
+            try:
+                with open(self.queue_file, encoding="utf-8") as f:
+                    self.queue = json.load(f)
+            except Exception:
+                self.queue = []
+        else:
+            self.queue = []
+
+    def _save_queue(self):
+        self.queue_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.queue_file, "w", encoding="utf-8") as f:
+            json.dump(self.queue, f, indent=2)
+
+    def is_enabled(self):
+        return bool(self.settings.get("telemetry.enabled", True))
+
+    def get_hwid(self):
+        # Use a persistent UUID for this client
+        hwid = self.settings.get("telemetry.hwid")
+        if not hwid:
+            hwid = str(uuid.uuid4())
+            self.settings.set("telemetry.hwid", hwid)
+        return hwid
+
+    def queue_event(self, event):
+        self.queue.append(event)
+        self._save_queue()
+
+    def send_batch(self):
+        if not self.is_enabled() or not self.queue:
+            return
+        sent = []
+        for event in self.queue:
+            try:
+                log_info(
+                    f"[Telemetry] Sending to {TELEMETRY_ENDPOINT}\nPayload: {json.dumps(event, indent=2)}"
+                )
+                resp = requests.post(TELEMETRY_ENDPOINT, json=event, timeout=5)
+                log_info(f"[Telemetry] Response: {resp.status_code} {resp.text}")
+                if resp.status_code in (200, 201):
+                    sent.append(event)
+            except Exception as e:
+                log_error(f"[Telemetry] Exception: {e}")
+        # Remove sent events
+        self.queue = [e for e in self.queue if e not in sent]
+        self._save_queue()
+
+    def send_launch_ping(self, app_version, client_type="vector-inspector"):
+        log_info("[Telemetry] send_launch_ping called")
+        if not self.is_enabled():
+            log_info("[Telemetry] Telemetry is not enabled; skipping launch ping.")
+            return
+        event = {
+            "hwid": self.get_hwid(),
+            "event_name": "app_launch",
+            "app_version": app_version,
+            "client_type": client_type,
+            "metadata": {"os": platform.system() + "-" + platform.release()},
+        }
+        log_info(f"[Telemetry] Launch event payload: {json.dumps(event, indent=2)}")
+        self.queue_event(event)
+        self.send_batch()
+
+    def purge(self):
+        self.queue = []
+        self._save_queue()
+
+    def get_queue(self):
+        return list(self.queue)