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

vector_inspector/core/embedding_providers/provider_factory.py

@@ -4,18 +4,18 @@ from typing import Optional, Dict, Type
 from .base_provider import EmbeddingProvider
 from .sentence_transformer_provider import SentenceTransformerProvider
 from .clip_provider import CLIPProvider
-from ..model_registry import get_model_registry
+from vector_inspector.core.model_registry import get_model_registry
 
 
 class ProviderFactory:
     """Factory for creating appropriate embedding providers based on model type."""
-    
+
     # Registry of provider classes by type
     _PROVIDER_REGISTRY: Dict[str, Type[EmbeddingProvider]] = {
         "sentence-transformer": SentenceTransformerProvider,
         "clip": CLIPProvider,
     }
-    
+
     # Model name patterns to auto-detect provider type
     _MODEL_PATTERNS = {
         "clip": ["clip", "CLIP"],
@@ -33,40 +33,37 @@ class ProviderFactory:
             "e5-",
             "jina-",
             "nomic-",
-        ]
+        ],
     }
-    
+
     @classmethod
     def create(
-        cls,
-        model_name: str,
-        model_type: Optional[str] = None,
-        **kwargs
+        cls, model_name: str, model_type: Optional[str] = None, **kwargs
     ) -> EmbeddingProvider:
         """Create an embedding provider for the given model.
-        
+
         Args:
             model_name: Model identifier (HF ID, path, or API name)
             model_type: Explicit provider type (sentence-transformer, clip, openai, etc.)
                        If None, will attempt auto-detection based on model name
             **kwargs: Additional arguments passed to provider constructor
-            
+
         Returns:
             Appropriate EmbeddingProvider instance
-            
+
         Raises:
             ValueError: If model type is unknown or cannot be auto-detected
         """
         # Auto-detect provider type if not specified
         if model_type is None:
             model_type = cls._detect_provider_type(model_name)
-        
+
         # Normalize model type
         model_type = model_type.lower()
-        
+
         # Get provider class from registry
         provider_class = cls._PROVIDER_REGISTRY.get(model_type)
-        
+
         if provider_class is None:
             # Check if it's a cloud provider (not yet implemented)
             if model_type in ["openai", "cohere", "vertex-ai", "voyage"]:
@@ -79,22 +76,22 @@ class ProviderFactory:
                     f"Unknown provider type: {model_type}. "
                     f"Supported types: {', '.join(cls._PROVIDER_REGISTRY.keys())}"
                 )
-        
+
         # Create and return provider instance
         return provider_class(model_name, **kwargs)
-    
+
     @classmethod
     def _detect_provider_type(cls, model_name: str) -> str:
         """Auto-detect provider type based on model name patterns.
-        
+
         First checks the known model registry, then falls back to pattern matching.
-        
+
         Args:
             model_name: Model identifier
-            
+
         Returns:
             Detected provider type
-            
+
         Raises:
             ValueError: If provider type cannot be detected
         """
@@ -103,54 +100,54 @@ class ProviderFactory:
         model_info = registry.get_model_by_name(model_name)
         if model_info:
             return model_info.type
-        
+
         # Fall back to pattern matching
         model_name_lower = model_name.lower()
-        
+
         # Check each pattern category
         for provider_type, patterns in cls._MODEL_PATTERNS.items():
             for pattern in patterns:
                 if pattern.lower() in model_name_lower:
                     return provider_type
-        
+
         # Default to sentence-transformer for HuggingFace models
         if "/" in model_name and not model_name.startswith("http"):
             return "sentence-transformer"
-        
+
         raise ValueError(
             f"Cannot auto-detect provider type for model: {model_name}. "
             "Please specify model_type explicitly."
         )
-    
+
     @classmethod
     def register_provider(cls, model_type: str, provider_class: Type[EmbeddingProvider]):
         """Register a new provider type.
-        
+
         Args:
             model_type: Provider type identifier
             provider_class: Provider class (must inherit from EmbeddingProvider)
         """
         if not issubclass(provider_class, EmbeddingProvider):
             raise TypeError(f"{provider_class} must inherit from EmbeddingProvider")
-        
+
         cls._PROVIDER_REGISTRY[model_type.lower()] = provider_class
-    
+
     @classmethod
     def list_supported_types(cls) -> list:
         """Get list of supported provider types.
-        
+
         Returns:
             List of registered provider type names
         """
         return list(cls._PROVIDER_REGISTRY.keys())
-    
+
     @classmethod
     def supports_type(cls, model_type: str) -> bool:
         """Check if a provider type is supported.
-        
+
         Args:
             model_type: Provider type to check
-            
+
         Returns:
             True if supported, False otherwise
         """
@@ -159,17 +156,15 @@ class ProviderFactory:
 
 # Convenience function for creating providers
 def create_provider(
-    model_name: str,
-    model_type: Optional[str] = None,
-    **kwargs
+    model_name: str, model_type: Optional[str] = None, **kwargs
 ) -> EmbeddingProvider:
     """Create an embedding provider (convenience wrapper around ProviderFactory).
-    
+
     Args:
         model_name: Model identifier
         model_type: Optional explicit provider type
         **kwargs: Additional arguments for provider
-        
+
     Returns:
         EmbeddingProvider instance
     """

vector_inspector/core/embedding_utils.py

@@ -4,7 +4,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
+from vector_inspector.core.model_registry import get_model_registry
 
 
 # Default model to use when dimension is unknown or not mapped
@@ -87,7 +87,7 @@ def get_available_models_for_dimension(dimension: int) -> list:
 
     # Add custom models from settings
     try:
-        from ..services.settings_service import SettingsService
+        from vector_inspector.services.settings_service import SettingsService
 
         settings = SettingsService()
         custom_models = settings.get_custom_embedding_models(dimension)

vector_inspector/services/backup_restore_service.py

@@ -6,29 +6,26 @@ from pathlib import Path
 from datetime import datetime
 import shutil
 
-from ..core.logging import log_info, log_error, log_debug
+from vector_inspector.core.logging import log_info, log_error, log_debug
 from .backup_helpers import write_backup_zip, read_backup_zip, normalize_embeddings
 
 
 class BackupRestoreService:
     """Handles backup and restore operations for vector database collections."""
-    
+
     @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
     ) -> Optional[str]:
         """
         Backup a collection to a directory.
-        
+
         Args:
             connection: Vector database connection
             collection_name: Name of collection to backup
             backup_dir: Directory to store backups
             include_embeddings: Whether to include embedding vectors
-            
+
         Returns:
             Path to backup file or None if failed
         """
@@ -69,23 +66,20 @@ class BackupRestoreService:
         except Exception as e:
             log_error("Backup failed: %s", e)
             return None
-    
+
     @staticmethod
     def restore_collection(
-        connection,
-        backup_file: str,
-        collection_name: Optional[str] = None,
-        overwrite: bool = False
+        connection, backup_file: str, collection_name: Optional[str] = None, overwrite: bool = False
     ) -> bool:
         """
         Restore a collection from a backup file.
-        
+
         Args:
             connection: Vector database connection
             backup_file: Path to backup zip file
             collection_name: Optional new name for restored collection
             overwrite: Whether to overwrite existing collection
-            
+
         Returns:
             True if successful, False otherwise
         """
@@ -97,7 +91,10 @@ class BackupRestoreService:
             existing_collections = connection.list_collections()
             if restore_collection_name in existing_collections:
                 if not overwrite:
-                    log_info("Collection %s already exists. Use overwrite=True to replace it.", restore_collection_name)
+                    log_info(
+                        "Collection %s already exists. Use overwrite=True to replace it.",
+                        restore_collection_name,
+                    )
                     return False
                 else:
                     connection.delete_collection(restore_collection_name)
@@ -129,7 +126,10 @@ class BackupRestoreService:
             log_error("Failed to restore collection %s", restore_collection_name)
             try:
                 if restore_collection_name in connection.list_collections():
-                    log_info("Cleaning up failed restore: deleting collection '%s'", restore_collection_name)
+                    log_info(
+                        "Cleaning up failed restore: deleting collection '%s'",
+                        restore_collection_name,
+                    )
                     connection.delete_collection(restore_collection_name)
             except Exception as cleanup_error:
                 log_error("Warning: Failed to clean up collection: %s", cleanup_error)
@@ -138,21 +138,27 @@ class BackupRestoreService:
         except Exception as e:
             log_error("Restore failed: %s", e)
             try:
-                if restore_collection_name and restore_collection_name in connection.list_collections():
-                    log_info("Cleaning up failed restore: deleting collection '%s'", restore_collection_name)
+                if (
+                    restore_collection_name
+                    and restore_collection_name in connection.list_collections()
+                ):
+                    log_info(
+                        "Cleaning up failed restore: deleting collection '%s'",
+                        restore_collection_name,
+                    )
                     connection.delete_collection(restore_collection_name)
             except Exception as cleanup_error:
                 log_error("Warning: Failed to clean up collection: %s", cleanup_error)
             return False
-    
+
     @staticmethod
     def list_backups(backup_dir: str) -> list:
         """
         List all backup files in a directory.
-        
+
         Args:
             backup_dir: Directory containing backups
-            
+
         Returns:
             List of backup file information dictionaries
         """
@@ -164,28 +170,30 @@ class BackupRestoreService:
         for backup_file in backup_path.glob("*_backup_*.zip"):
             try:
                 metadata, _ = read_backup_zip(backup_file)
-                backups.append({
-                    "file_path": str(backup_file),
-                    "file_name": backup_file.name,
-                    "collection_name": metadata.get("collection_name", "Unknown"),
-                    "timestamp": metadata.get("backup_timestamp", "Unknown"),
-                    "item_count": metadata.get("item_count", 0),
-                    "file_size": backup_file.stat().st_size,
-                })
+                backups.append(
+                    {
+                        "file_path": str(backup_file),
+                        "file_name": backup_file.name,
+                        "collection_name": metadata.get("collection_name", "Unknown"),
+                        "timestamp": metadata.get("backup_timestamp", "Unknown"),
+                        "item_count": metadata.get("item_count", 0),
+                        "file_size": backup_file.stat().st_size,
+                    }
+                )
             except Exception:
                 continue
 
         backups.sort(key=lambda x: x["timestamp"], reverse=True)
         return backups
-    
+
     @staticmethod
     def delete_backup(backup_file: str) -> bool:
         """
         Delete a backup file.
-        
+
         Args:
             backup_file: Path to backup file to delete
-            
+
         Returns:
             True if successful, False otherwise
         """