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

vector_inspector/core/connections/template_connection.py

@@ -6,18 +6,19 @@ Implement all abstract methods according to your database's API.
 
 from typing import Optional, List, Dict, Any
 from .base_connection import VectorDBConnection
+from vector_inspector.core.logging import log_error
 
 
 class TemplateConnection(VectorDBConnection):
     """Template vector database connection.
-    
+
     Replace this with your database provider name (e.g., PineconeConnection, QdrantConnection).
     """
-    
+
     def __init__(self, **kwargs):
         """
         Initialize connection parameters.
-        
+
         Args:
             **kwargs: Provider-specific connection parameters
                       (e.g., api_key, host, port, credentials, etc.)
@@ -25,11 +26,11 @@ class TemplateConnection(VectorDBConnection):
         # Store your connection parameters here
         self._client = None
         # Add your provider-specific attributes
-        
+
     def connect(self) -> bool:
         """
         Establish connection to the vector database.
-        
+
         Returns:
             True if connection successful, False otherwise
         """
@@ -38,29 +39,29 @@ class TemplateConnection(VectorDBConnection):
             # self._client = YourDatabaseClient(...)
             return True
         except Exception as e:
-            print(f"Connection failed: {e}")
+            log_error("Connection failed: %s", e)
             return False
-    
+
     def disconnect(self):
         """Close connection to the vector database."""
         # Clean up your connection
         self._client = None
-    
+
     @property
     def is_connected(self) -> bool:
         """
         Check if connected to the vector database.
-        
+
         Returns:
             True if connected, False otherwise
         """
         # Return whether the client is active
         return self._client is not None
-    
+
     def list_collections(self) -> List[str]:
         """
         Get list of all collections/indexes.
-        
+
         Returns:
             List of collection/index names
         """
@@ -72,16 +73,16 @@ class TemplateConnection(VectorDBConnection):
             # return [col.name for col in collections]
             return []
         except Exception as e:
-            print(f"Failed to list collections: {e}")
+            log_error("Failed to list collections: %s", e)
             return []
-    
+
     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:
                 - name: Collection name
@@ -90,22 +91,22 @@ class TemplateConnection(VectorDBConnection):
         """
         if not self._client:
             return None
-        
+
         try:
             # Get collection stats from your database
             # collection = self._client.get_collection(name)
             # count = collection.count()
             # metadata_fields = collection.get_metadata_fields()
-            
+
             return {
                 "name": name,
                 "count": 0,  # Replace with actual count
                 "metadata_fields": [],  # Replace with actual fields
             }
         except Exception as e:
-            print(f"Failed to get collection info: {e}")
+            log_error("Failed to get collection info: %s", e)
             return None
-    
+
     def query_collection(
         self,
         collection_name: str,
@@ -117,7 +118,7 @@ class TemplateConnection(VectorDBConnection):
     ) -> 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
@@ -125,7 +126,7 @@ class TemplateConnection(VectorDBConnection):
             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
@@ -136,7 +137,7 @@ class TemplateConnection(VectorDBConnection):
         """
         if not self._client:
             return None
-        
+
         try:
             # Perform similarity search
             # results = self._client.query(
@@ -145,19 +146,13 @@ class TemplateConnection(VectorDBConnection):
             #     n_results=n_results,
             #     filter=where
             # )
-            
+
             # Transform results to standard format
-            return {
-                "ids": [],
-                "distances": [],
-                "documents": [],
-                "metadatas": [],
-                "embeddings": []
-            }
+            return {"ids": [], "distances": [], "documents": [], "metadatas": [], "embeddings": []}
         except Exception as e:
-            print(f"Query failed: {e}")
+            log_error("Query failed: %s", e)
             return None
-    
+
     def get_all_items(
         self,
         collection_name: str,
@@ -167,13 +162,13 @@ class TemplateConnection(VectorDBConnection):
     ) -> 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
@@ -183,7 +178,7 @@ class TemplateConnection(VectorDBConnection):
         """
         if not self._client:
             return None
-        
+
         try:
             # Fetch items from collection with pagination
             # results = self._client.fetch(
@@ -192,17 +187,12 @@ class TemplateConnection(VectorDBConnection):
             #     offset=offset,
             #     filter=where
             # )
-            
-            return {
-                "ids": [],
-                "documents": [],
-                "metadatas": [],
-                "embeddings": []
-            }
+
+            return {"ids": [], "documents": [], "metadatas": [], "embeddings": []}
         except Exception as e:
-            print(f"Failed to get items: {e}")
+            log_error("Failed to get items: %s", e)
             return None
-    
+
     def add_items(
         self,
         collection_name: str,
@@ -213,20 +203,20 @@ class TemplateConnection(VectorDBConnection):
     ) -> bool:
         """
         Add items to a collection.
-        
+
         Args:
             collection_name: Name of collection
             documents: Document texts
             metadatas: Metadata for each document
             ids: IDs for each document
             embeddings: Pre-computed embeddings
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             # Add items to the collection
             # self._client.upsert(
@@ -238,9 +228,9 @@ class TemplateConnection(VectorDBConnection):
             # )
             return True
         except Exception as e:
-            print(f"Failed to add items: {e}")
+            log_error("Failed to add items: %s", e)
             return False
-    
+
     def update_items(
         self,
         collection_name: str,
@@ -251,20 +241,20 @@ class TemplateConnection(VectorDBConnection):
     ) -> 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
         """
         if not self._client:
             return False
-        
+
         try:
             # Update existing items
             # self._client.update(
@@ -276,9 +266,9 @@ class TemplateConnection(VectorDBConnection):
             # )
             return True
         except Exception as e:
-            print(f"Failed to update items: {e}")
+            log_error("Failed to update items: %s", e)
             return False
-    
+
     def delete_items(
         self,
         collection_name: str,
@@ -287,18 +277,18 @@ class TemplateConnection(VectorDBConnection):
     ) -> 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
         """
         if not self._client:
             return False
-        
+
         try:
             # Delete items
             # self._client.delete(
@@ -308,34 +298,34 @@ class TemplateConnection(VectorDBConnection):
             # )
             return True
         except Exception as e:
-            print(f"Failed to delete items: {e}")
+            log_error("Failed to delete items: %s", e)
             return False
-    
+
     def delete_collection(self, name: str) -> bool:
         """
         Delete an entire collection.
-        
+
         Args:
             name: Collection name
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             # Delete the collection
             # self._client.delete_collection(name)
             return True
         except Exception as e:
-            print(f"Failed to delete collection: {e}")
+            log_error("Failed to delete collection: %s", e)
             return False
-    
+
     def get_connection_info(self) -> Dict[str, Any]:
         """
         Get information about the current connection.
-        
+
         Returns:
             Dictionary with connection details
         """

vector_inspector/core/embedding_utils.py

@@ -2,6 +2,7 @@
 
 from typing import Optional, Union, Tuple
 from sentence_transformers import SentenceTransformer
+from vector_inspector.core.logging import log_info
 
 from .model_registry import get_model_registry
 
@@ -12,19 +13,17 @@ DEFAULT_MODEL = ("all-MiniLM-L6-v2", "sentence-transformer")
 
 def _get_dimension_to_model_dict():
     """Build dimension->models dictionary from registry.
-    
+
     Returns:
         Dict mapping dimension to list of (name, type, description) tuples
     """
     registry = get_model_registry()
     dimension_map = {}
-    
+
     for dimension in registry.get_all_dimensions():
         models = registry.get_models_by_dimension(dimension)
-        dimension_map[dimension] = [
-            (m.name, m.type, m.description) for m in models
-        ]
-    
+        dimension_map[dimension] = [(m.name, m.type, m.description) for m in models]
+
     return dimension_map
 
 
@@ -35,37 +34,37 @@ DIMENSION_TO_MODEL = _get_dimension_to_model_dict()
 def get_model_for_dimension(dimension: int, prefer_multimodal: bool = True) -> Tuple[str, str]:
     """
     Get the appropriate embedding model name and type for a given vector dimension.
-    
+
     Args:
         dimension: The vector dimension size
-        prefer_multimodal: If True and multiple models exist for this dimension, 
+        prefer_multimodal: If True and multiple models exist for this dimension,
                           prefer multi-modal (CLIP) over text-only models
-        
+
     Returns:
         Tuple of (model_name, model_type) where model_type is "sentence-transformer" or "clip"
     """
     registry = get_model_registry()
     models = registry.get_models_by_dimension(dimension)
-    
+
     if not models:
         # Find the closest dimension if exact match not found
         closest_dim = registry.find_closest_dimension(dimension)
         if closest_dim:
             models = registry.get_models_by_dimension(closest_dim)
-    
+
     if not models:
         return DEFAULT_MODEL
-    
+
     if len(models) == 1:
         return (models[0].name, models[0].type)
-    
+
     # Multiple models available - apply preference
     if prefer_multimodal:
         # Prefer CLIP/multimodal
         for model in models:
             if model.modality == "multimodal" or model.type == "clip":
                 return (model.name, model.type)
-    
+
     # Default to first option
     return (models[0].name, models[0].type)
 
@@ -74,10 +73,10 @@ def get_available_models_for_dimension(dimension: int) -> list:
     """
     Get all available model options for a given dimension.
     Includes both predefined (from registry) and custom user-added models.
-    
+
     Args:
         dimension: The vector dimension size
-        
+
     Returns:
         List of tuples: [(model_name, model_type, description), ...]
     """
@@ -85,39 +84,37 @@ def get_available_models_for_dimension(dimension: int) -> list:
     registry = get_model_registry()
     registry_models = registry.get_models_by_dimension(dimension)
     models = [(m.name, m.type, m.description) for m in registry_models]
-    
+
     # Add custom models from settings
     try:
         from ..services.settings_service import SettingsService
+
         settings = SettingsService()
         custom_models = settings.get_custom_embedding_models(dimension)
-        
+
         for model in custom_models:
             # Format: (model_name, model_type, description)
-            models.append((
-                model["name"],
-                model["type"],
-                f"{model['description']} (custom)"
-            ))
+            models.append((model["name"], model["type"], f"{model['description']} (custom)"))
     except Exception as e:
-        print(f"Warning: Could not load custom models: {e}")
-    
+        log_info("Warning: Could not load custom models: %s", e)
+
     return models
 
 
 def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTransformer, any]:
     """
     Load an embedding model (sentence-transformer or CLIP).
-    
+
     Args:
         model_name: Name of the model to load
         model_type: Type of model ("sentence-transformer" or "clip")
-        
+
     Returns:
         Loaded model (SentenceTransformer or CLIP model)
     """
     if model_type == "clip":
         from transformers import CLIPModel, CLIPProcessor
+
         model = CLIPModel.from_pretrained(model_name)
         processor = CLIPProcessor.from_pretrained(model_name)
         return (model, processor)
@@ -128,17 +125,18 @@ def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTran
 def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type: str) -> list:
     """
     Encode text using the appropriate model.
-    
+
     Args:
         text: Text to encode
         model: The loaded model (SentenceTransformer or (CLIPModel, CLIPProcessor) tuple)
         model_type: Type of model ("sentence-transformer" or "clip")
-        
+
     Returns:
         Embedding vector as a list
     """
     if model_type == "clip":
         import torch
+
         clip_model, processor = model
         inputs = processor(text=[text], return_tensors="pt", padding=True)
         with torch.no_grad():
@@ -152,13 +150,15 @@ def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type:
         return embedding.tolist()
 
 
-def get_embedding_model_for_dimension(dimension: int) -> Tuple[Union[SentenceTransformer, Tuple], str, str]:
+def get_embedding_model_for_dimension(
+    dimension: int,
+) -> Tuple[Union[SentenceTransformer, Tuple], str, str]:
     """
     Get a loaded embedding model for a specific dimension.
-    
+
     Args:
         dimension: The vector dimension size
-        
+
     Returns:
         Tuple of (loaded_model, model_name, model_type)
     """

vector_inspector/core/logging.py

@@ -0,0 +1,27 @@
+"""Tiny logging wrapper for consistent logs across the project.
+
+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
+
+_logger = logging.getLogger("vector_inspector")
+if not _logger.handlers:
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+    handler.setFormatter(formatter)
+    _logger.addHandler(handler)
+    _logger.setLevel(logging.INFO)
+
+
+def log_info(msg: str, *args: Any, **kwargs: Any) -> None:
+    _logger.info(msg, *args, **kwargs)
+
+
+def log_error(msg: str, *args: Any, **kwargs: Any) -> None:
+    _logger.error(msg, *args, **kwargs)
+
+
+def log_debug(msg: str, *args: Any, **kwargs: Any) -> None:
+    _logger.debug(msg, *args, **kwargs)

vector_inspector/core/model_registry.py

@@ -4,6 +4,7 @@ import json
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 from dataclasses import dataclass
+from vector_inspector.core.logging import log_info, log_error
 
 
 @dataclass
@@ -63,7 +64,7 @@ class EmbeddingModelRegistry:
         registry_path = Path(__file__).parent.parent / "config" / "known_embedding_models.json"
         
         if not registry_path.exists():
-            print(f"Warning: Model registry not found at {registry_path}")
+            log_info("Warning: Model registry not found at %s", registry_path)
             return
 
         try:
@@ -83,10 +84,10 @@ class EmbeddingModelRegistry:
                 # Index by name
                 self._name_index[model_info.name.lower()] = model_info
             
-            print(f"Loaded {len(self._models)} models from registry")
+            log_info("Loaded %d models from registry", len(self._models))
             #...
         except Exception as e:
-            print(f"Error loading model registry: {e}")
+            log_error("Error loading model registry: %s", e)
     
     def get_models_by_dimension(self, dimension: int) -> List[ModelInfo]:
         """Get all models for a specific dimension.

vector_inspector/main.py

@@ -1,19 +1,23 @@
 """Main entry point for Vector Inspector application."""
 
 import sys
+import os
 from PySide6.QtWidgets import QApplication
 from vector_inspector.ui.main_window import MainWindow
 
+# Ensures the app looks in its own folder for the raw libraries
+sys.path.append(os.path.dirname(sys.executable))
+
 
 def main():
     """Launch the Vector Inspector application."""
     app = QApplication(sys.argv)
     app.setApplicationName("Vector Inspector")
     app.setOrganizationName("Vector Inspector")
-    
+
     window = MainWindow()
     window.show()
-    
+
     sys.exit(app.exec())
 
 

vector_inspector/services/backup_helpers.py

@@ -0,0 +1,63 @@
+"""Helpers for backup/restore: zip read/write and embedding normalization.
+
+Minimal, well-tested helpers to keep `BackupRestoreService` concise.
+"""
+import json
+import zipfile
+from typing import Tuple, Dict, Any
+
+
+def write_backup_zip(path, metadata: Dict[str, Any], data: Dict[str, Any]):
+    """Write metadata and data into a zip file at `path`.
+
+    `path` may be a pathlib.Path or string.
+    """
+    with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        zipf.writestr('metadata.json', json.dumps(metadata, indent=2))
+        zipf.writestr('data.json', json.dumps(data, indent=2))
+
+
+def read_backup_zip(path) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """Read metadata.json and data.json from a backup zip and return them.
+
+    Returns (metadata, data).
+    """
+    with zipfile.ZipFile(path, 'r') as zipf:
+        metadata_str = zipf.read('metadata.json').decode('utf-8')
+        metadata = json.loads(metadata_str)
+        data_str = zipf.read('data.json').decode('utf-8')
+        data = json.loads(data_str)
+    return metadata, data
+
+
+def normalize_embeddings(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Ensure embeddings in `data` are plain python lists (no numpy objects).
+
+    This mutates and returns the same `data` dict for convenience.
+    """
+    if 'embeddings' not in data or data['embeddings'] is None:
+        return data
+
+    try:
+        import numpy as np
+    except Exception:
+        np = None
+
+    emb = data['embeddings']
+    if np is not None:
+        if isinstance(emb, np.ndarray):
+            data['embeddings'] = emb.tolist()
+            return data
+
+        if isinstance(emb, list):
+            new_list = []
+            for item in emb:
+                if isinstance(item, np.ndarray):
+                    new_list.append(item.tolist())
+                else:
+                    new_list.append(item)
+            data['embeddings'] = new_list
+            return data
+
+    # No numpy available — assume data already serializable
+    return data