thoth-dbmanager 0.4.13__py3-none-any.whl → 0.5.1__py3-none-any.whl

thoth_dbmanager/ThothDbManager.py

@@ -1,4 +1,3 @@
-import pickle
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -7,20 +6,15 @@ from typing import Any, Dict, List, Optional, Union, ClassVar, Type, TypeVar
 
 from .lsh.manager import LshManager
 from .core.factory import ThothDbFactory
-from .core.interfaces import DbPlugin
-
-# Import plugins to register them
-from .plugins.postgresql import PostgreSQLPlugin
-from .plugins.sqlite import SQLitePlugin
 
 T = TypeVar('T', bound='ThothDbManager')
 
 class ThothDbManager(ABC):
     """
-    This class provides methods for interacting with a database.
-    It follows a singleton pattern for each unique set of connection parameters.
+    Modern database manager interface using plugin architecture.
     
-    This class now serves as a compatibility layer over the new plugin architecture.
+    This class provides a unified interface for database operations
+    across multiple database types through the plugin system.
     """
     _instances: ClassVar[Dict[tuple, Any]] = {}
     _lock: ClassVar[Lock] = Lock()
@@ -28,10 +22,7 @@ class ThothDbManager(ABC):
     @classmethod
     def get_instance(cls: Type[T], db_type: str, **kwargs) -> T:
         """
-        Get or create a singleton instance based on the database type.
-        This acts as a factory for different database manager implementations.
-        
-        Now uses the new plugin architecture while maintaining backward compatibility.
+        Get or create a singleton instance using the plugin architecture.
         
         Args:
             db_type (str): The type of database (e.g., 'postgresql', 'sqlite', 'mysql').
@@ -43,40 +34,13 @@ class ThothDbManager(ABC):
         Raises:
             ValueError: If the database type is unsupported or required parameters are missing.
         """
-        # Try new plugin architecture first
-        try:
-            if db_type in ["postgresql", "sqlite"]:  # Currently supported by new architecture
-                # Extract required parameters
-                db_root_path = kwargs.get('db_root_path')
-                db_mode = kwargs.get('db_mode', 'dev')
-
-                if not db_root_path:
-                    raise ValueError("db_root_path is required")
-
-                # Remove extracted parameters from kwargs to avoid duplicate parameter errors
-                kwargs_clean = kwargs.copy()
-                kwargs_clean.pop('db_root_path', None)
-                kwargs_clean.pop('db_mode', None)
-
-                # Create plugin instance using factory
-                plugin = ThothDbFactory.create_manager(db_type, db_root_path, db_mode, **kwargs_clean)
-                
-                # Wrap plugin in compatibility adapter
-                return ThothDbManagerAdapter(plugin)
-            
-        except Exception as e:
-            logging.warning(f"Failed to use new plugin architecture for {db_type}: {e}. Falling back to legacy implementation.")
+        # Import all plugins to ensure they're registered
+        from . import plugins
         
-        # Use unified plugin system for all database types
         try:
-            # Import all plugins to ensure they're registered
-            from . import plugins
-            
             # Create plugin instance using factory
             plugin = ThothDbFactory.create_manager(db_type, **kwargs)
-            
-            # Wrap plugin in compatibility adapter
-            return ThothDbManagerAdapter(plugin)
+            return plugin
             
         except Exception as e:
             logging.error(f"Failed to create {db_type} manager: {e}")
@@ -103,11 +67,6 @@ class ThothDbManager(ABC):
         self.db_id = None
         self.db_directory_path = None
         
-        # LSH related attributes (for backward compatibility)
-        self.lsh = None
-        self.minhashes = None
-        self.vector_db = None
-        
         # New LSH manager (lazy initialization)
         self._lsh_manager = None
         
@@ -245,44 +204,6 @@ class ThothDbManager(ABC):
         """
         pass
     
-    def set_lsh(self) -> str:
-        """
-        Sets the LSH and minhashes attributes by loading from storage.
-        
-        This method maintains backward compatibility while using the new LSH manager.
-        """
-        with self._lock:
-            if self.lsh is None:
-                try:
-                    # Use the new LSH manager
-                    if self.lsh_manager and self.lsh_manager.load_lsh():
-                        # Set backward compatibility attributes
-                        self.lsh = self.lsh_manager.lsh
-                        self.minhashes = self.lsh_manager.minhashes
-                        return "success"
-                    else:
-                        # Fallback to old method for compatibility
-                        lsh_path = self.db_directory_path / "preprocessed" / f"{self.db_id}_lsh.pkl"
-                        minhashes_path = self.db_directory_path / "preprocessed" / f"{self.db_id}_minhashes.pkl"
-
-                        if not lsh_path.exists() or not minhashes_path.exists():
-                            raise FileNotFoundError(f"LSH or MinHashes file not found for {self.db_id}")
-
-                        with lsh_path.open("rb") as file:
-                            self.lsh = pickle.load(file)
-                        with minhashes_path.open("rb") as file:
-                            self.minhashes = pickle.load(file)
-                        return "success"
-                except Exception as e:
-                    logging.error(f"Error loading LSH: {str(e)}")
-                    self.lsh = "error"
-                    self.minhashes = "error"
-                    return "error"
-            elif self.lsh == "error":
-                return "error"
-            else:
-                return "success"
-
     def query_lsh(self,
                  keyword: str,
                  signature_size: int = 30,
@@ -303,7 +224,6 @@ class ThothDbManager(ABC):
                 - inner key is column name
                 - value is list of similar strings
         """
-        # Try using the new LSH manager first
         if self.lsh_manager:
             try:
                 return self.lsh_manager.query(
@@ -313,148 +233,20 @@ class ThothDbManager(ABC):
                     top_n=top_n
                 )
             except Exception as e:
-                logging.warning(f"LSH manager query failed, falling back to old method: {e}")
-        
-        # Fallback to old method for backward compatibility
-        lsh_status = self.set_lsh()
-        if lsh_status == "success":
-            # Import here to avoid circular imports
-            from .helpers.search import _query_lsh
-            return _query_lsh(self.lsh, self.minhashes, keyword, signature_size, n_gram, top_n)
+                logging.error(f"LSH manager query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
         else:
-            raise Exception(f"Error loading LSH for {self.db_id}")
-
+            raise Exception(f"LSH manager not initialized for {self.db_id}")
 
-class ThothDbManagerAdapter(ThothDbManager):
-    """
-    Adapter class that wraps the new plugin architecture to provide backward compatibility
-    with the original ThothDbManager interface.
-    """
-    
-    def __init__(self, plugin: DbPlugin):
+    def health_check(self) -> bool:
         """
-        Initialize the adapter with a plugin instance.
+        Check if database connection is healthy.
         
-        Args:
-            plugin: Database plugin instance
+        Returns:
+            bool: True if connection is healthy, False otherwise
         """
-        self.plugin = plugin
-        
-        # Copy plugin attributes for backward compatibility
-        self.db_root_path = plugin.db_root_path
-        self.db_mode = plugin.db_mode
-        self.db_type = plugin.supported_db_types[0] if plugin.supported_db_types else "unknown"
-        self.db_id = getattr(plugin, 'db_id', None)
-        self.db_directory_path = getattr(plugin, 'db_directory_path', None)
-        self.schema = getattr(plugin, 'schema', "")
-        
-        # Engine and connection (delegated to adapter)
-        self.engine = getattr(plugin.adapter, 'engine', None) if plugin.adapter else None
-        
-        # LSH related attributes (for backward compatibility)
-        self.lsh = None
-        self.minhashes = None
-        self.vector_db = None
-        
-        # Flag to track initialization
-        self._initialized = plugin._initialized
-    
-    @property
-    def lsh_manager(self):
-        """Access LSH manager through plugin"""
-        return getattr(self.plugin, 'lsh_manager', None)
-    
-    def execute_sql(self, sql: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """Execute SQL queries through plugin"""
-        return self.plugin.execute_sql(sql, params, fetch, timeout)
-    
-    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
-        """Get unique values through plugin"""
-        return self.plugin.get_unique_values()
-    
-    def get_tables(self) -> List[Dict[str, str]]:
-        """Get tables through plugin"""
-        return self.plugin.get_tables()
-    
-    def get_columns(self, table_name: str) -> List[Dict[str, Any]]:
-        """Get columns through plugin"""
-        return self.plugin.get_columns(table_name)
-    
-    def get_foreign_keys(self) -> List[Dict[str, str]]:
-        """Get foreign keys through plugin"""
-        return self.plugin.get_foreign_keys()
-    
-    def set_lsh(self) -> str:
-        """Set LSH through plugin"""
-        if hasattr(self.plugin, 'set_lsh'):
-            result = self.plugin.set_lsh()
-            
-            # Update backward compatibility attributes
-            if result == "success" and self.lsh_manager:
-                self.lsh = getattr(self.lsh_manager, 'lsh', None)
-                self.minhashes = getattr(self.lsh_manager, 'minhashes', None)
-            
-            return result
-        else:
-            # Fallback to original implementation
-            return super().set_lsh()
-    
-    def query_lsh(self, keyword: str, signature_size: int = 30, n_gram: int = 3, top_n: int = 10) -> Dict[str, Dict[str, List[str]]]:
-        """Query LSH through plugin"""
-        if hasattr(self.plugin, 'query_lsh'):
-            return self.plugin.query_lsh(keyword, signature_size, n_gram, top_n)
-        else:
-            # Fallback to original implementation
-            return super().query_lsh(keyword, signature_size, n_gram, top_n)
-    
-    # Document-based methods (new functionality)
-    def get_tables_as_documents(self):
-        """Get tables as document objects"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.get_tables_as_documents()
-        return []
-    
-    def get_columns_as_documents(self, table_name: str):
-        """Get columns as document objects"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.get_columns_as_documents(table_name)
-        return []
-    
-    def get_foreign_keys_as_documents(self):
-        """Get foreign keys as document objects"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.get_foreign_keys_as_documents()
-        return []
-    
-    def get_schemas_as_documents(self):
-        """Get schemas as document objects"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.get_schemas_as_documents()
-        return []
-    
-    def get_indexes_as_documents(self, table_name: Optional[str] = None):
-        """Get indexes as document objects"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.get_indexes_as_documents(table_name)
-        return []
-    
-    def get_connection_info(self) -> Dict[str, Any]:
-        """Get connection information"""
-        if hasattr(self.plugin, 'get_connection_info'):
-            return self.plugin.get_connection_info()
-        return {}
-    
-    def health_check(self) -> bool:
-        """Check database health"""
-        if self.plugin.adapter:
-            return self.plugin.adapter.health_check()
-        return False
-    
-    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
-        """Get example data through plugin"""
-        if hasattr(self.plugin, 'get_example_data'):
-            return self.plugin.get_example_data(table_name, number_of_rows)
-        elif self.plugin.adapter:
-            return self.plugin.adapter.get_example_data(table_name, number_of_rows)
-        else:
-            raise RuntimeError("Plugin not initialized or doesn't support get_example_data")
+        try:
+            self.execute_sql("SELECT 1", fetch="one")
+            return True
+        except Exception:
+            return False

thoth_dbmanager/__init__.py

@@ -5,7 +5,7 @@ This package provides database-agnostic operations, LSH similarity search,
 and an extensible plugin architecture for managing SQL databases.
 """
 
-# Core classes - always available
+# Core classes
 from .ThothDbManager import ThothDbManager
 from .core.factory import ThothDbFactory
 from .core.interfaces import DbPlugin, DbAdapter
@@ -24,7 +24,7 @@ from .documents import (
     create_document
 )
 
-# Export LSH functionality for backward compatibility
+# LSH functionality
 from .lsh.factory import make_db_lsh
 from .lsh import LshManager, LshFactory
 
@@ -36,50 +36,13 @@ from .dynamic_imports import (
     get_available_databases,
     import_database_components,
     DatabaseImportError,
-    # Convenience functions
-    import_postgresql,
-    import_mysql,
-    import_sqlite,
-    import_sqlserver,
-    import_oracle,
-    import_mariadb,
-    import_supabase,
 )
 
-# Legacy API - will be dynamically imported when accessed
-def __getattr__(name: str):
-    """Dynamic attribute access for database managers."""
-    if name == 'ThothPgManager':
-        return import_manager('postgresql')
-    elif name == 'ThothSqliteManager':
-        return import_manager('sqlite')
-    elif name == 'ThothMySqlManager':
-        return import_manager('mysql')
-    elif name == 'ThothMariaDbManager':
-        return import_manager('mariadb')
-    elif name == 'ThothSqlServerManager':
-        return import_manager('sqlserver')
-    elif name == 'ThothOracleManager':
-        return import_manager('oracle')
-    elif name == 'ThothSupabaseManager':
-        return import_manager('supabase')
-    
-    raise AttributeError(f"module 'thoth_dbmanager' has no attribute '{name}'")
-
-# Public API
+# Public API - Modern Plugin Architecture Only
 __all__ = [
-    # Legacy API
+    # Core API
     "ThothDbManager",
-    "ThothPgManager",
-    "ThothSqliteManager",
-    "ThothMySqlManager",
-    "ThothMariaDbManager",
-    "ThothSqlServerManager",
-    "ThothOracleManager",
-    "ThothSupabaseManager",
-    
-    # New architecture
-    "ThothDbFactory",
+    "ThothDbFactory", 
     "DbPluginRegistry",
     "DbPlugin",
     "DbAdapter",
@@ -87,7 +50,7 @@ __all__ = [
     # Document models
     "BaseThothDbDocument",
     "TableDocument",
-    "ColumnDocument",
+    "ColumnDocument", 
     "QueryDocument",
     "SchemaDocument",
     "ForeignKeyDocument",
@@ -95,24 +58,6 @@ __all__ = [
     "ThothDbType",
     "create_document",
     
-    # Plugins
-    "PostgreSQLPlugin",
-    "SQLitePlugin",
-    "MySQLPlugin",
-    "MariaDBPlugin",
-    "SQLServerPlugin",
-    "OraclePlugin",
-    "SupabasePlugin",
-    
-    # Adapters
-    "PostgreSQLAdapter",
-    "SQLiteAdapter",
-    "MySQLAdapter",
-    "MariaDBAdapter",
-    "SQLServerAdapter",
-    "OracleAdapter",
-    "SupabaseAdapter",
-    
     # LSH functionality
     "make_db_lsh",
     "LshManager",
@@ -120,11 +65,11 @@ __all__ = [
     
     # Dynamic import system
     "import_manager",
-    "import_adapter",
+    "import_adapter", 
     "import_plugin",
     "get_available_databases",
     "import_database_components",
     "DatabaseImportError",
 ]
 
-__version__ = "0.4.3"
+__version__ = "0.5.0"

thoth_dbmanager/adapters/__init__.py

@@ -4,18 +4,12 @@ Database adapters for Thoth SQL Database Manager.
 
 from .postgresql import PostgreSQLAdapter
 from .sqlite import SQLiteAdapter
-from .supabase import SupabaseAdapter
-from .mysql import MySQLAdapter
 from .mariadb import MariaDBAdapter
 from .sqlserver import SQLServerAdapter
-from .oracle import OracleAdapter
 
 __all__ = [
     "PostgreSQLAdapter",
     "SQLiteAdapter",
-    "SupabaseAdapter",
-    "MySQLAdapter",
     "MariaDBAdapter",
     "SQLServerAdapter",
-    "OracleAdapter",
 ]

thoth_dbmanager/core/factory.py

@@ -124,18 +124,10 @@ class ThothDbFactory:
                     "required": ["host", "port", "database", "user", "password"],
                     "optional": ["schema", "sslmode", "connect_timeout"]
                 },
-                "supabase": {
-                    "required": ["host", "port", "database", "user", "password"],
-                    "optional": ["schema", "sslmode", "connect_timeout", "project_url", "api_key", "use_rest_api"]
-                },
                 "sqlite": {
                     "required": ["database_path"],
                     "optional": ["timeout", "check_same_thread"]
                 },
-                "mysql": {
-                    "required": ["host", "port", "database", "user", "password"],
-                    "optional": ["charset", "autocommit", "connect_timeout"]
-                },
                 "mariadb": {
                     "required": ["host", "port", "database", "user", "password"],
                     "optional": ["charset", "autocommit", "connect_timeout"]
@@ -143,14 +135,6 @@ class ThothDbFactory:
                 "sqlserver": {
                     "required": ["server", "database", "user", "password"],
                     "optional": ["driver", "trusted_connection", "timeout"]
-                },
-                "oracle": {
-                    "required": ["host", "port", "service_name", "user", "password"],
-                    "optional": ["encoding", "nencoding", "threaded"]
-                },
-                "informix": {
-                    "required": ["server", "database", "host", "user", "password"],
-                    "optional": ["protocol", "service", "timeout"]
                 }
             }
             

thoth_dbmanager/dynamic_imports.py

@@ -10,11 +10,8 @@ import warnings
 # Mapping of database names to their required packages
 DATABASE_DEPENDENCIES = {
     'postgresql': ['psycopg2'],
-    'mysql': ['mysql.connector'],
     'mariadb': ['mariadb'],
     'sqlserver': ['pyodbc'],
-    'oracle': ['cx_Oracle'],
-    'supabase': ['supabase', 'postgrest', 'gotrue'],
     'sqlite': [],  # Built into Python
 }
 
@@ -23,22 +20,16 @@ DATABASE_DEPENDENCIES = {
 # Mapping of database names to their adapter classes
 DATABASE_ADAPTERS = {
     'postgresql': 'thoth_dbmanager.adapters.postgresql.PostgreSQLAdapter',
-    'mysql': 'thoth_dbmanager.adapters.mysql.MySQLAdapter',
     'mariadb': 'thoth_dbmanager.adapters.mariadb.MariaDBAdapter',
     'sqlserver': 'thoth_dbmanager.adapters.sqlserver.SQLServerAdapter',
-    'oracle': 'thoth_dbmanager.adapters.oracle.OracleAdapter',
-    'supabase': 'thoth_dbmanager.adapters.supabase.SupabaseAdapter',
     'sqlite': 'thoth_dbmanager.adapters.sqlite.SQLiteAdapter',
 }
 
 # Mapping of database names to their plugin classes
 DATABASE_PLUGINS = {
     'postgresql': 'thoth_dbmanager.plugins.postgresql.PostgreSQLPlugin',
-    'mysql': 'thoth_dbmanager.plugins.mysql.MySQLPlugin',
     'mariadb': 'thoth_dbmanager.plugins.mariadb.MariaDBPlugin',
     'sqlserver': 'thoth_dbmanager.plugins.sqlserver.SQLServerPlugin',
-    'oracle': 'thoth_dbmanager.plugins.oracle.OraclePlugin',
-    'supabase': 'thoth_dbmanager.plugins.supabase.SupabasePlugin',
     'sqlite': 'thoth_dbmanager.plugins.sqlite.SQLitePlugin',
 }
 

thoth_dbmanager/helpers/multi_db_generator.py

@@ -4,7 +4,7 @@ import re
 from typing import Dict, List, Optional
 from pathlib import Path
 
-from dbmanager.helpers.schema import DatabaseSchema
+from thoth_dbmanager.helpers.schema import DatabaseSchema
 
 
 class MultiDbGenerator:

thoth_dbmanager/plugins/__init__.py

@@ -5,19 +5,13 @@ Database plugins for Thoth SQL Database Manager.
 # Import all plugins to ensure they are registered
 from .postgresql import PostgreSQLPlugin
 from .sqlite import SQLitePlugin
-from .supabase import SupabasePlugin
-from .mysql import MySQLPlugin
 from .mariadb import MariaDBPlugin
 from .sqlserver import SQLServerPlugin
-from .oracle import OraclePlugin
 
 # This ensures all plugins are registered when the module is imported
 __all__ = [
     "PostgreSQLPlugin",
     "SQLitePlugin",
-    "SupabasePlugin",
-    "MySQLPlugin",
     "MariaDBPlugin",
     "SQLServerPlugin",
-    "OraclePlugin",
 ]

thoth_dbmanager/plugins/sqlite.py

@@ -218,3 +218,10 @@ class SQLitePlugin(DbPlugin):
             return self.adapter.get_example_data(table_name, number_of_rows)
         else:
             raise RuntimeError("Plugin not initialized")
+    
+    def health_check(self) -> bool:
+        """Check database connection health"""
+        if self.adapter:
+            return self.adapter.health_check()
+        else:
+            return False