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

vector_inspector/core/connections/qdrant_connection.py

@@ -1,27 +1,22 @@
 """Qdrant connection manager."""
 
-from typing import Optional, List, Dict, Any
 import uuid
+from typing import Any, Optional
+
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
     Distance,
-    VectorParams,
-    PointStruct,
     Filter,
-    FieldCondition,
-    MatchValue,
-    MatchText,
-    MatchAny,
-    MatchExcept,
-    Range,
+    PointStruct,
+    VectorParams,
 )
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
-from vector_inspector.core.logging import log_info, log_error, log_debug
-from vector_inspector.core.connections.qdrant_helpers.qdrant_filter_builder import build_filter
 from vector_inspector.core.connections.qdrant_helpers.qdrant_embedding_resolver import (
     resolve_embedding_model,
 )
+from vector_inspector.core.connections.qdrant_helpers.qdrant_filter_builder import build_filter
+from vector_inspector.core.logging import log_error, log_info
 
 
 class QdrantConnection(VectorDBConnection):
@@ -133,7 +128,7 @@ class QdrantConnection(VectorDBConnection):
         except Exception:
             return 0
 
-    def get_items(self, name: str, ids: List[str]) -> Dict[str, Any]:
+    def get_items(self, name: str, ids: list[str]) -> dict[str, Any]:
         """
         Get items by IDs (implementation for compatibility).
 
@@ -162,7 +157,7 @@ class QdrantConnection(VectorDBConnection):
             log_error("Failed to get items: %s", e)
             return {"documents": [], "metadatas": []}
 
-    def list_collections(self) -> List[str]:
+    def list_collections(self) -> list[str]:
         """
         Get list of all collections.
 
@@ -178,7 +173,7 @@ class QdrantConnection(VectorDBConnection):
             log_error("Failed to list collections: %s", e)
             return []
 
-    def get_collection_info(self, name: str) -> Optional[Dict[str, Any]]:
+    def get_collection_info(self, name: str) -> Optional[dict[str, Any]]:
         """
         Get collection metadata and statistics.
 
@@ -296,7 +291,7 @@ class QdrantConnection(VectorDBConnection):
             model = load_embedding_model(model_name, model_type)
             return (model, model_name, model_type)
 
-    def _build_qdrant_filter(self, where: Optional[Dict[str, Any]] = None) -> Optional[Filter]:
+    def _build_qdrant_filter(self, where: Optional[dict[str, Any]] = None) -> Optional[Filter]:
         """Delegate filter construction to helper module."""
         try:
             return build_filter(where)
@@ -307,12 +302,12 @@ class QdrantConnection(VectorDBConnection):
     def query_collection(
         self,
         collection_name: str,
-        query_texts: Optional[List[str]] = None,
-        query_embeddings: Optional[List[List[float]]] = None,
+        query_texts: Optional[list[str]] = None,
+        query_embeddings: Optional[list[list[float]]] = None,
         n_results: int = 10,
-        where: Optional[Dict[str, Any]] = None,
-        where_document: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        where: Optional[dict[str, Any]] = None,
+        where_document: Optional[dict[str, Any]] = None,
+    ) -> Optional[dict[str, Any]]:
         """
         Query a collection for similar vectors.
 
@@ -357,9 +352,9 @@ class QdrantConnection(VectorDBConnection):
             for query in queries:
                 # Embed text queries if needed
                 if isinstance(query, str):
-                    # Generate embeddings for text query using appropriate model for this collection
+                    # Generate embeddings for text query using inherited method
                     try:
-                        model, model_name, model_type = self._get_embedding_model_for_collection(
+                        model, model_name, model_type = self.load_embedding_model_for_collection(
                             collection_name
                         )
 
@@ -425,8 +420,8 @@ class QdrantConnection(VectorDBConnection):
         collection_name: str,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
-        where: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        where: Optional[dict[str, Any]] = None,
+    ) -> Optional[dict[str, Any]]:
         """
         Get all items from a collection.
 
@@ -492,10 +487,10 @@ class QdrantConnection(VectorDBConnection):
     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: Optional[list[dict[str, Any]]] = None,
+        ids: Optional[list[str]] = None,
+        embeddings: Optional[list[list[float]]] = None,
     ) -> bool:
         """
         Add items to a collection.
@@ -532,9 +527,7 @@ class QdrantConnection(VectorDBConnection):
                 embeddings = self.compute_embeddings_for_documents(
                     collection_name,
                     documents,
-                    getattr(self, "path", None)
-                    or getattr(self, "url", None)
-                    or getattr(self, "host", None),
+                    getattr(self, "profile_name", None),
                 )
             except Exception as e:
                 log_error("Embeddings are required for Qdrant and computing them failed: %s", e)
@@ -569,10 +562,10 @@ class QdrantConnection(VectorDBConnection):
     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: Optional[list[str]] = None,
+        metadatas: Optional[list[dict[str, Any]]] = None,
+        embeddings: Optional[list[list[float]]] = None,
     ) -> bool:
         """
         Update items in a collection.
@@ -627,9 +620,7 @@ class QdrantConnection(VectorDBConnection):
                         computed = self.compute_embeddings_for_documents(
                             collection_name,
                             [documents[i]],
-                            getattr(self, "path", None)
-                            or getattr(self, "url", None)
-                            or getattr(self, "host", None),
+                            getattr(self, "profile_name", None),
                         )
                         vector = computed[0] if computed else vector
                     except Exception as e:
@@ -651,8 +642,8 @@ class QdrantConnection(VectorDBConnection):
     def delete_items(
         self,
         collection_name: str,
-        ids: Optional[List[str]] = None,
-        where: Optional[Dict[str, Any]] = None,
+        ids: Optional[list[str]] = None,
+        where: Optional[dict[str, Any]] = None,
     ) -> bool:
         """
         Delete items from a collection.
@@ -739,7 +730,7 @@ class QdrantConnection(VectorDBConnection):
             log_error(f"Failed to create collection: {e}")
             return False
 
-    def prepare_restore(self, metadata: Dict[str, Any], data: Dict[str, Any]) -> bool:
+    def prepare_restore(self, metadata: dict[str, Any], data: dict[str, Any]) -> bool:
         """Provider-specific hook invoked before restoring data.
 
         The connection can use metadata and data to pre-create collections,
@@ -832,9 +823,9 @@ class QdrantConnection(VectorDBConnection):
             log_error("prepare_restore failed: %s", e)
             return False
 
-    def get_connection_info(self) -> Dict[str, Any]:
+    def get_connection_info(self) -> dict[str, Any]:
         """Get information about the current connection."""
-        info: Dict[str, Any] = {
+        info: dict[str, Any] = {
             "provider": "Qdrant",
             "connected": self.is_connected,
         }
@@ -852,7 +843,7 @@ class QdrantConnection(VectorDBConnection):
             info["mode"] = "memory"
         return info
 
-    def get_supported_filter_operators(self) -> List[Dict[str, Any]]:
+    def get_supported_filter_operators(self) -> list[dict[str, Any]]:
         """Get filter operators supported by Qdrant."""
         return [
             {"name": "=", "server_side": True},

vector_inspector/core/embedding_utils.py

@@ -1,7 +1,9 @@
 """Utilities for managing embedding models and vector dimensions."""
 
-from typing import Optional, Union, Tuple
-from sentence_transformers import SentenceTransformer
+from __future__ import annotations  # Allows us to use class names in typehints while lazyloading
+from typing import Optional, Tuple, Any
+
+# Lazy import: see below
 from vector_inspector.core.logging import log_info
 
 from vector_inspector.core.model_registry import get_model_registry
@@ -101,7 +103,7 @@ def get_available_models_for_dimension(dimension: int) -> list:
     return models
 
 
-def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTransformer, any]:
+def load_embedding_model(model_name: str, model_type: str) -> SentenceTransformer | Any:
     """
     Load an embedding model (sentence-transformer or CLIP).
 
@@ -117,12 +119,16 @@ def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTran
 
         model = CLIPModel.from_pretrained(model_name)
         processor = CLIPProcessor.from_pretrained(model_name)
+        # Returns a tuple: (CLIPModel, CLIPProcessor)
         return (model, processor)
     else:
+        from sentence_transformers import SentenceTransformer
+
+        # Returns a SentenceTransformer instance
         return SentenceTransformer(model_name)
 
 
-def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type: str) -> list:
+def encode_text(text: str, model: "SentenceTransformer" | Tuple, model_type: str) -> list:
     """
     Encode text using the appropriate model.
 
@@ -146,13 +152,15 @@ def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type:
         return text_features[0].cpu().numpy().tolist()
     else:
         # sentence-transformer
+        # Lazy import for type hint only
+        # from sentence_transformers import SentenceTransformer
         embedding = model.encode(text)
         return embedding.tolist()
 
 
 def get_embedding_model_for_dimension(
     dimension: int,
-) -> Tuple[Union[SentenceTransformer, Tuple], str, str]:
+) -> Tuple["SentenceTransformer" | Tuple, str, str]:
     """
     Get a loaded embedding model for a specific dimension.
 
@@ -164,4 +172,5 @@ def get_embedding_model_for_dimension(
     """
     model_name, model_type = get_model_for_dimension(dimension)
     model = load_embedding_model(model_name, model_type)
+    # Returns a tuple: (loaded_model, model_name, model_type)
     return (model, model_name, model_type)

vector_inspector/core/logging.py

@@ -3,6 +3,7 @@
 Provides `log_info`, `log_error`, and `log_debug` helpers that delegate
 to the standard `logging` module but keep call sites concise.
 """
+
 import logging
 from typing import Any
 
@@ -12,7 +13,8 @@ if not _logger.handlers:
     formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
     handler.setFormatter(formatter)
     _logger.addHandler(handler)
-    _logger.setLevel(logging.INFO)
+    # Default to WARNING to reduce console noise; set to DEBUG for troubleshooting
+    _logger.setLevel(logging.WARNING)
 
 
 def log_info(msg: str, *args: Any, **kwargs: Any) -> None:

vector_inspector/extensions/__init__.py

@@ -103,3 +103,9 @@ class SettingsPanelHook:
 
 # Global singleton instance
 settings_panel_hook = SettingsPanelHook()
+
+# Register built-in settings panel extensions
+try:
+    import vector_inspector.extensions.telemetry_settings_panel
+except Exception:
+    pass

vector_inspector/extensions/telemetry_settings_panel.py

@@ -0,0 +1,25 @@
+from PySide6.QtWidgets import QCheckBox, QHBoxLayout
+from vector_inspector.extensions import settings_panel_hook
+
+
+def add_telemetry_section(parent_layout, settings_service, dialog=None):
+    telemetry_checkbox = QCheckBox("Enable anonymous telemetry (app launch events)")
+    # Default to checked if not set
+    checked = settings_service.get("telemetry.enabled")
+    if checked is None:
+        checked = True
+    telemetry_checkbox.setChecked(checked)
+    telemetry_checkbox.setToolTip(
+        "Allow the app to send anonymous launch events to help improve reliability. No personal or document data is sent."
+    )
+
+    def on_state_changed(state):
+        settings_service.set_telemetry_enabled(bool(state))
+
+    telemetry_checkbox.stateChanged.connect(on_state_changed)
+    layout = QHBoxLayout()
+    layout.addWidget(telemetry_checkbox)
+    parent_layout.addLayout(layout)
+
+
+settings_panel_hook.register(add_telemetry_section)

vector_inspector/main.py

@@ -1,9 +1,13 @@
 """Main entry point for Vector Inspector application."""
 
-import sys
 import os
+import sys
+
+from PySide6.QtCore import QTimer
 from PySide6.QtWidgets import QApplication
-from vector_inspector.ui.main_window import MainWindow
+
+from vector_inspector import get_version
+from vector_inspector.ui.loading_screen import show_loading_screen
 
 # Ensures the app looks in its own folder for the raw libraries
 sys.path.append(os.path.dirname(sys.executable))
@@ -15,9 +19,48 @@ def main():
     app.setApplicationName("Vector Inspector")
     app.setOrganizationName("Vector Inspector")
 
+    # Get version once for all uses
+    app_version = get_version()
+
+    # Show loading screen (if not disabled in settings)
+    loading = show_loading_screen(
+        app_name="Vector Inspector",
+        version=f"v{app_version}",
+        tagline="The missing toolset for your vector data",
+        loading_text="Initializing providers…"
+    )
+
+    # Heavy imports after loading screen is visible
+    if loading:
+        loading.set_loading_text("Loading main window...")
+        app.processEvents()
+
+    from vector_inspector.core.logging import log_error
+    from vector_inspector.ui.main_window import MainWindow
+
+    def send_ping():
+        # Telemetry: send launch ping if enabled
+        try:
+            from vector_inspector.services.telemetry_service import TelemetryService
+
+            telemetry = TelemetryService()
+            telemetry.send_launch_ping(app_version=app_version)
+        except Exception as e:
+            log_error(f"[Telemetry] Failed to send launch ping: {e}")
+
+    if loading:
+        loading.set_loading_text("Preparing interface...")
+        app.processEvents()
+
     window = MainWindow()
     window.show()
 
+    # Always fade out loading screen automatically
+    if loading:
+        loading.fade_out()
+
+    QTimer.singleShot(0, lambda: send_ping())
+
     sys.exit(app.exec())