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

vector_inspector/services/settings_service.py

@@ -4,67 +4,69 @@ import json
 from pathlib import Path
 from typing import Dict, Any, Optional, List
 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."""
-    
+
     def __init__(self):
         """Initialize settings service."""
         self.settings_dir = Path.home() / ".vector-inspector"
         self.settings_file = self.settings_dir / "settings.json"
         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, "r", encoding="utf-8") as f:
                     self.settings = json.load(f)
         except Exception as e:
-            print(f"Failed to load settings: {e}")
+            log_error("Failed to load settings: %s", e)
             self.settings = {}
-    
+
     def _save_settings(self):
         """Save settings to file."""
         try:
             # Create settings directory if it doesn't exist
             self.settings_dir.mkdir(parents=True, exist_ok=True)
-            
-            with open(self.settings_file, 'w', encoding='utf-8') as f:
+
+            with open(self.settings_file, "w", encoding="utf-8") as f:
                 json.dump(self.settings, f, indent=2, ensure_ascii=False)
         except Exception as e:
-            print(f"Failed to save settings: {e}")
-    
+            log_error("Failed to save settings: %s", e)
+
     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]):
         """Save the last connection configuration."""
         self.settings["last_connection"] = config
         self._save_settings()
-    
+
     def get(self, key: str, default: Any = None) -> Any:
         """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
@@ -72,15 +74,21 @@ class SettingsService:
         # Invalidate cache when settings change (only if cache is enabled)
         if key != "cache_enabled":  # Don't invalidate when toggling cache itself
             invalidate_cache_on_settings_change()
-    
+
     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"):
+
+    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
@@ -89,51 +97,60 @@ class SettingsService:
         """
         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()
+            "timestamp": self._get_timestamp(),
         }
         self._save_settings()
-    
-    def get_embedding_model(self, connection_id: str, collection_name: str) -> Optional[Dict[str, Any]]:
+
+    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"):
+
+    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
@@ -142,7 +159,7 @@ class SettingsService:
         """
         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:
@@ -152,24 +169,26 @@ class SettingsService:
                 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.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
         """
@@ -177,19 +196,20 @@ class SettingsService:
         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"]
+            m
+            for m in self.settings["custom_embedding_models"]
             if not (m["name"] == model_name and m["dimension"] == dimension)
         ]
         self._save_settings()

vector_inspector/services/visualization_service.py

@@ -2,103 +2,96 @@
 
 from typing import Optional, List, Tuple, Any
 import warnings
+from vector_inspector.core.logging import log_error
 
 
 class VisualizationService:
     """Service for vector dimensionality reduction and visualization."""
-    
+
     @staticmethod
     def reduce_dimensions(
-        embeddings: List[List[float]],
-        method: str = "pca",
-        n_components: int = 2,
-        **kwargs
+        embeddings: List[List[float]], method: str = "pca", n_components: int = 2, **kwargs
     ) -> Optional[Any]:
         """
         Reduce dimensionality of embeddings.
-        
+
         Args:
             embeddings: List of embedding vectors
             method: Reduction method ('pca', 'tsne', or 'umap')
             n_components: Target number of dimensions (2 or 3)
             **kwargs: Additional method-specific parameters
-            
+
         Returns:
             Reduced embeddings as numpy array, or None if failed
         """
         if embeddings is None or len(embeddings) == 0:
             return None
-            
+
         try:
             # Lazy import numpy and models
             from vector_inspector.utils.lazy_imports import get_numpy, get_sklearn_model
+
             np = get_numpy()
-            
+
             X = np.array(embeddings)
-            
+
             if method.lower() == "pca":
-                PCA = get_sklearn_model('PCA')
+                PCA = get_sklearn_model("PCA")
                 reducer = PCA(n_components=n_components)
                 reduced = reducer.fit_transform(X)
-                
+
             elif method.lower() in ["t-sne", "tsne"]:
-                TSNE = get_sklearn_model('TSNE')
+                TSNE = get_sklearn_model("TSNE")
                 perplexity = kwargs.get("perplexity", min(30, len(embeddings) - 1))
-                reducer = TSNE(
-                    n_components=n_components,
-                    perplexity=perplexity,
-                    random_state=42
-                )
+                reducer = TSNE(n_components=n_components, perplexity=perplexity, random_state=42)
                 reduced = reducer.fit_transform(X)
-                
+
             elif method.lower() == "umap":
-                UMAP = get_sklearn_model('UMAP')
+                UMAP = get_sklearn_model("UMAP")
                 n_neighbors = kwargs.get("n_neighbors", min(15, len(embeddings) - 1))
                 # Suppress n_jobs warning when using random_state
                 with warnings.catch_warnings():
                     warnings.filterwarnings("ignore", message=".*n_jobs.*overridden.*")
                     reducer = UMAP(
-                        n_components=n_components,
-                        n_neighbors=n_neighbors,
-                        random_state=42
+                        n_components=n_components, n_neighbors=n_neighbors, random_state=42
                     )
                     reduced = reducer.fit_transform(X)
-                
+
             else:
-                print(f"Unknown method: {method}")
+                log_error("Unknown method: %s", method)
                 return None
-                
+
             return reduced
-            
+
         except Exception as e:
-            print(f"Dimensionality reduction failed: {e}")
+            log_error("Dimensionality reduction failed: %s", e)
             return None
-    
+
     @staticmethod
     def prepare_plot_data(
         reduced_embeddings: Any,
         labels: Optional[List[str]] = None,
         metadata: Optional[List[dict]] = None,
-        color_by: Optional[str] = None
+        color_by: Optional[str] = None,
     ) -> Tuple[Any, List[str], List[str]]:
         """
         Prepare data for plotting.
-        
+
         Args:
             reduced_embeddings: Reduced dimension embeddings
             labels: Text labels for each point
             metadata: Metadata dictionaries for each point
             color_by: Metadata field to use for coloring
-            
+
         Returns:
             Tuple of (embeddings, labels, colors)
         """
         n_points = len(reduced_embeddings)
-        
+
         # Prepare labels
         if labels is None:
             labels = [f"Point {i}" for i in range(n_points)]
-        
+
         # Prepare colors
         colors = ["blue"] * n_points
         if color_by and metadata:
@@ -108,16 +101,24 @@ class VisualizationService:
                 value = meta.get(color_by, "unknown")
                 values.append(str(value))
                 unique_values.add(str(value))
-            
+
             # Map values to colors
             color_map = {}
             color_palette = [
-                "red", "blue", "green", "orange", "purple",
-                "cyan", "magenta", "yellow", "pink", "brown"
+                "red",
+                "blue",
+                "green",
+                "orange",
+                "purple",
+                "cyan",
+                "magenta",
+                "yellow",
+                "pink",
+                "brown",
             ]
             for i, val in enumerate(sorted(unique_values)):
                 color_map[val] = color_palette[i % len(color_palette)]
-            
+
             colors = [color_map[val] for val in values]
-        
+
         return reduced_embeddings, labels, colors

vector_inspector/ui/components/splash_window.py

@@ -0,0 +1,57 @@
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QLabel, QCheckBox, QPushButton, QTextBrowser
+from PySide6.QtCore import Qt
+
+
+class SplashWindow(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Welcome to Vector Inspector!")
+        self.setModal(True)
+        self.setMinimumWidth(420)
+
+        layout = QVBoxLayout(self)
+
+        # Welcome message
+        label = QLabel("<h2>Thanks for trying <b>Vector Inspector</b>!</h2>")
+        label.setAlignment(Qt.AlignCenter)
+        layout.addWidget(label)
+
+        # Feedback prompt
+        feedback = QLabel(
+            "If you have thoughts, feature requests, or run into anything confusing,<br>"
+            "I’d really appreciate hearing from you. Feedback helps shape the roadmap."
+        )
+        feedback.setTextFormat(Qt.RichText)
+        feedback.setWordWrap(True)
+        layout.addWidget(feedback)
+
+        # GitHub link
+        github = QLabel(
+            '<a href="https://github.com/anthonypdawson/vector-inspector/issues">Submit feedback or issues on GitHub</a>'
+        )
+        github.setOpenExternalLinks(True)
+        github.setAlignment(Qt.AlignCenter)
+        layout.addWidget(github)
+
+        # About info (reuse About dialog text)
+        from vector_inspector.ui.main_window import get_about_html
+
+        about = QTextBrowser()
+        about.setHtml(get_about_html())
+        about.setOpenExternalLinks(True)
+        about.setMaximumHeight(160)
+        layout.addWidget(about)
+
+        # Do not show again checkbox
+        self.hide_checkbox = QCheckBox("Do not show this again")
+        layout.addWidget(self.hide_checkbox)
+
+        # OK button
+        ok_btn = QPushButton("OK")
+        ok_btn.clicked.connect(self.accept)
+        layout.addWidget(ok_btn)
+
+        layout.addStretch(1)
+
+    def should_hide(self):
+        return self.hide_checkbox.isChecked()

vector_inspector/ui/dialogs/cross_db_migration.py

@@ -12,6 +12,7 @@ from PySide6.QtCore import QThread, Signal
 
 from vector_inspector.core.connection_manager import ConnectionManager, ConnectionInstance
 from vector_inspector.services.backup_restore_service import BackupRestoreService
+from vector_inspector.core.logging import log_info, log_error
 
 
 class MigrationThread(QThread):
@@ -111,26 +112,26 @@ class MigrationThread(QThread):
                 try:
                     if self.target_collection in self.target_conn.connection.list_collections():
                         self.progress.emit(90, "Cleaning up failed migration...")
-                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        log_info("Cleaning up failed migration: deleting target collection '%s'", self.target_collection)
                         self.target_conn.connection.delete_collection(self.target_collection)
                 except Exception as cleanup_error:
-                    print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+                    log_error("Warning: Failed to clean up target collection: %s", cleanup_error)
                 
                 self.finished.emit(False, "Failed to restore to target collection. Target collection cleaned up.")
         
         except Exception as e:
             import traceback
             error_details = traceback.format_exc()
-            print(f"Migration error details:\n{error_details}")
+            log_error("Migration error details:\n%s", error_details)
             
             # Clean up target collection on exception
             try:
                 if self.target_conn and self.target_conn.connection.is_connected:
                     if self.target_collection in self.target_conn.connection.list_collections():
-                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        log_info("Cleaning up failed migration: deleting target collection '%s'", self.target_collection)
                         self.target_conn.connection.delete_collection(self.target_collection)
             except Exception as cleanup_error:
-                print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+                    log_error("Warning: Failed to clean up target collection: %s", cleanup_error)
             
             self.finished.emit(False, f"Migration error: {str(e)}")