thoth-dbmanager 0.4.13__tar.gz → 0.5.0__tar.gz

{thoth_dbmanager-0.4.13/thoth_dbmanager.egg-info → thoth_dbmanager-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.4.13
+Version: 0.5.0
 Summary: A Python library for managing SQL databases with support for multiple database types, LSH-based similarity search, and a modern plugin architecture.
 Author-email: Marco Pancotti <mp@tylconsulting.it>
 Project-URL: Homepage, https://github.com/mptyl/thoth_dbmanager
@@ -84,7 +84,7 @@ A Python library for managing SQL databases with support for multiple database t
 - **Plugin Architecture**: Extensible design for adding new database types
 - **LSH Search**: Locality-Sensitive Hashing for finding similar values across database columns
 - **Type Safety**: Pydantic-based document models for structured data
-- **Backward Compatibility**: Maintains compatibility with existing code
+- **Modern API**: Clean, plugin-based interface for all database operations
 
 ## Installation
 

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0}/README.md

@@ -8,7 +8,7 @@ A Python library for managing SQL databases with support for multiple database t
 - **Plugin Architecture**: Extensible design for adding new database types
 - **LSH Search**: Locality-Sensitive Hashing for finding similar values across database columns
 - **Type Safety**: Pydantic-based document models for structured data
-- **Backward Compatibility**: Maintains compatibility with existing code
+- **Modern API**: Clean, plugin-based interface for all database operations
 
 ## Installation
 

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "thoth_dbmanager"
-version = "0.4.13"
+version = "0.5.0"
 authors = [
   { name="Marco Pancotti", email="mp@tylconsulting.it" },
 ]
@@ -81,8 +81,8 @@ test-mysql = ["pytest>=7.0.0", "mysql-connector-python>=8.0.0"]
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["dbmanager*", "thoth_dbmanager*"]
-exclude = ["tests*", "test_*", "*.tests", "*.tests.*", "data*", "lsh-test*"]
+include = ["thoth_dbmanager*"]
+exclude = ["tests*", "test_*", "*.tests", "*.tests.*", "data*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.md", "*.txt", "*.yml", "*.yaml"]

thoth_dbmanager-0.5.0/thoth_dbmanager/ThothDbManager.py

@@ -0,0 +1,252 @@
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from threading import Lock
+from typing import Any, Dict, List, Optional, Union, ClassVar, Type, TypeVar
+
+from .lsh.manager import LshManager
+from .core.factory import ThothDbFactory
+
+T = TypeVar('T', bound='ThothDbManager')
+
+class ThothDbManager(ABC):
+    """
+    Modern database manager interface using 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()
+
+    @classmethod
+    def get_instance(cls: Type[T], db_type: str, **kwargs) -> T:
+        """
+        Get or create a singleton instance using the plugin architecture.
+        
+        Args:
+            db_type (str): The type of database (e.g., 'postgresql', 'sqlite', 'mysql').
+            **kwargs: Connection parameters specific to the database implementation.
+            
+        Returns:
+            An instance of the appropriate database manager.
+            
+        Raises:
+            ValueError: If the database type is unsupported or required parameters are missing.
+        """
+        # Import all plugins to ensure they're registered
+        from . import plugins
+        
+        try:
+            # Create plugin instance using factory
+            plugin = ThothDbFactory.create_manager(db_type, **kwargs)
+            return plugin
+            
+        except Exception as e:
+            logging.error(f"Failed to create {db_type} manager: {e}")
+            raise ValueError(f"Unsupported database type '{db_type}' or invalid parameters: {e}")
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", db_type: Optional[str] = None, **kwargs) -> None:
+        """
+        Initialize the database manager.
+        
+        Args:
+            db_root_path (str): Path to the database root directory.
+            db_mode (str, optional): Database mode (dev, prod, etc.). Defaults to "dev".
+            db_type (Optional[str], optional): Type of database. Defaults to None.
+            **kwargs: Additional parameters specific to the database implementation.
+        """
+        self._validate_common_params(db_root_path, db_mode)
+        
+        self.db_root_path = db_root_path
+        self.db_mode = db_mode
+        self.db_type = db_type
+        
+        # These will be set by subclasses
+        self.engine = None
+        self.db_id = None
+        self.db_directory_path = None
+        
+        # New LSH manager (lazy initialization)
+        self._lsh_manager = None
+        
+        # Flag to track initialization
+        self._initialized = False
+    
+    def _validate_common_params(self, db_root_path: str, db_mode: str) -> None:
+        """
+        Validate common parameters for all database implementations.
+        
+        Args:
+            db_root_path (str): Path to the database root directory.
+            db_mode (str): Database mode (dev, prod, etc.).
+            
+        Raises:
+            ValueError: If parameters are invalid.
+        """
+        if not db_root_path:
+            raise ValueError("db_root_path is required")
+        
+        if not isinstance(db_mode, str):
+            raise TypeError("db_mode must be a string")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """
+        Set up the database directory path.
+        
+        Args:
+            db_id (str): Database identifier.
+        """
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = self.db_root_path / f"{self.db_mode}_databases" / db_id
+        self.db_id = db_id
+        
+        # Reset LSH manager when directory path changes
+        self._lsh_manager = None
+
+    @property
+    def lsh_manager(self) -> Optional[LshManager]:
+        """
+        Lazy load LSH manager.
+        
+        Returns:
+            LshManager instance if db_directory_path is set, None otherwise
+        """
+        if self._lsh_manager is None and self.db_directory_path:
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+
+    @abstractmethod
+    def execute_sql(self,
+                   sql: str, 
+                   params: Optional[Dict] = None, 
+                   fetch: Union[str, int] = "all", 
+                   timeout: int = 60) -> Any:
+        """
+        Abstract method to execute SQL queries.
+
+        Args:
+            sql (str): The SQL query to execute.
+            params (Optional[Dict]): Parameters for the SQL query.
+            fetch (Union[str, int]): Specifies how to fetch the results.
+            timeout (int): Timeout for the query execution.
+
+        Returns:
+            Any: The result of the SQL query execution.
+        """
+        pass
+    
+    @abstractmethod
+    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
+        """
+        Get unique values from the database.
+        
+        Returns:
+            Dict[str, Dict[str, List[str]]]: Dictionary where:
+                - outer key is table name
+                - inner key is column name
+                - value is list of unique values
+        """
+        pass
+
+    @abstractmethod
+    def get_tables(self) -> List[Dict[str, str]]:
+        """
+        Abstract method to get a list of tables in the database.
+
+        Returns:
+            List[Dict[str, str]]: A list of dictionaries, where each dictionary
+                                  represents a table with 'name' and 'comment' keys.
+        """
+        pass
+
+    @abstractmethod
+    def get_columns(self, table_name: str) -> List[Dict[str, Any]]:
+        """
+        Abstract method to get a list of columns for a given table.
+
+        Args:
+            table_name (str): The name of the table.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries, where each dictionary
+                                  represents a column with 'name', 'data_type',
+                                  'comment', and 'is_pk' keys.
+        """
+        pass
+
+    @abstractmethod
+    def get_foreign_keys(self) -> List[Dict[str, str]]:
+        """
+        Abstract method to get a list of foreign key relationships in the database.
+
+        Returns:
+            List[Dict[str, str]]: A list of dictionaries, where each dictionary
+                                  represents a foreign key relationship with
+                                  'source_table_name', 'source_column_name',
+                                  'target_table_name', and 'target_column_name' keys.
+        """
+        pass
+    
+    @abstractmethod
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """
+        Abstract method to get example data (most frequent values) for each column in a table.
+
+        Args:
+            table_name (str): The name of the table.
+            number_of_rows (int, optional): Maximum number of example values to return per column. Defaults to 30.
+
+        Returns:
+            Dict[str, List[Any]]: A dictionary mapping column names to lists of example values.
+        """
+        pass
+    
+    def query_lsh(self,
+                 keyword: str,
+                 signature_size: int = 30,
+                 n_gram: int = 3,
+                 top_n: int = 10) -> Dict[str, Dict[str, List[str]]]:
+        """
+        Queries the LSH for similar values to the given keyword.
+
+        Args:
+            keyword (str): The keyword to search for.
+            signature_size (int, optional): The size of the MinHash signature. Defaults to 30.
+            n_gram (int, optional): The n-gram size for the MinHash. Defaults to 3.
+            top_n (int, optional): The number of top results to return. Defaults to 10.
+
+        Returns:
+            Dict[str, Dict[str, List[str]]]: Dictionary where:
+                - outer key is table name
+                - inner key is column name
+                - value is list of similar strings
+        """
+        if self.lsh_manager:
+            try:
+                return self.lsh_manager.query(
+                    keyword=keyword,
+                    signature_size=signature_size,
+                    n_gram=n_gram,
+                    top_n=top_n
+                )
+            except Exception as e:
+                logging.error(f"LSH manager query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH manager not initialized for {self.db_id}")
+
+    def health_check(self) -> bool:
+        """
+        Check if database connection is healthy.
+        
+        Returns:
+            bool: True if connection is healthy, False otherwise
+        """
+        try:
+            self.execute_sql("SELECT 1", fetch="one")
+            return True
+        except Exception:
+            return False

thoth_dbmanager-0.5.0/thoth_dbmanager/__init__.py

@@ -0,0 +1,75 @@
+"""
+Thoth Database Manager - A unified interface for multiple database systems.
+
+This package provides database-agnostic operations, LSH similarity search,
+and an extensible plugin architecture for managing SQL databases.
+"""
+
+# Core classes
+from .ThothDbManager import ThothDbManager
+from .core.factory import ThothDbFactory
+from .core.interfaces import DbPlugin, DbAdapter
+from .core.registry import DbPluginRegistry
+
+# Document models
+from .documents import (
+    BaseThothDbDocument,
+    TableDocument,
+    ColumnDocument,
+    QueryDocument,
+    SchemaDocument,
+    ForeignKeyDocument,
+    IndexDocument,
+    ThothDbType,
+    create_document
+)
+
+# LSH functionality
+from .lsh.factory import make_db_lsh
+from .lsh import LshManager, LshFactory
+
+# Dynamic import system
+from .dynamic_imports import (
+    import_manager,
+    import_adapter,
+    import_plugin,
+    get_available_databases,
+    import_database_components,
+    DatabaseImportError,
+)
+
+# Public API - Modern Plugin Architecture Only
+__all__ = [
+    # Core API
+    "ThothDbManager",
+    "ThothDbFactory", 
+    "DbPluginRegistry",
+    "DbPlugin",
+    "DbAdapter",
+    
+    # Document models
+    "BaseThothDbDocument",
+    "TableDocument",
+    "ColumnDocument", 
+    "QueryDocument",
+    "SchemaDocument",
+    "ForeignKeyDocument",
+    "IndexDocument",
+    "ThothDbType",
+    "create_document",
+    
+    # LSH functionality
+    "make_db_lsh",
+    "LshManager",
+    "LshFactory",
+    
+    # Dynamic import system
+    "import_manager",
+    "import_adapter", 
+    "import_plugin",
+    "get_available_databases",
+    "import_database_components",
+    "DatabaseImportError",
+]
+
+__version__ = "0.5.0"

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0}/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-0.4.13 → thoth_dbmanager-0.5.0}/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

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0/thoth_dbmanager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.4.13
+Version: 0.5.0
 Summary: A Python library for managing SQL databases with support for multiple database types, LSH-based similarity search, and a modern plugin architecture.
 Author-email: Marco Pancotti <mp@tylconsulting.it>
 Project-URL: Homepage, https://github.com/mptyl/thoth_dbmanager
@@ -84,7 +84,7 @@ A Python library for managing SQL databases with support for multiple database t
 - **Plugin Architecture**: Extensible design for adding new database types
 - **LSH Search**: Locality-Sensitive Hashing for finding similar values across database columns
 - **Type Safety**: Pydantic-based document models for structured data
-- **Backward Compatibility**: Maintains compatibility with existing code
+- **Modern API**: Clean, plugin-based interface for all database operations
 
 ## Installation
 

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0}/thoth_dbmanager.egg-info/SOURCES.txt

@@ -2,19 +2,7 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
-tests/test_integration_new_architecture.py
-tests/test_lsh_query.py
-tests/test_new_architecture.py
-tests/test_parameter_validation.py
 tests/test_thoth_db_manager_base.py
-tests/test_thoth_informix_manager.py
-tests/test_thoth_mariadb_manager.py
-tests/test_thoth_mysql_manager.py
-tests/test_thoth_oracle_manager.py
-tests/test_thoth_pg_manager.py
-tests/test_thoth_sqlite_manager.py
-tests/test_thoth_sqlserver_manager.py
-tests/test_thoth_supabase_manager.py
 thoth_dbmanager/ThothDbManager.py
 thoth_dbmanager/__init__.py
 thoth_dbmanager/documents.py

{thoth_dbmanager-0.4.13 → thoth_dbmanager-0.5.0}/thoth_dbmanager.egg-info/top_level.txt

@@ -1,2 +1 @@
-dbmanager
 thoth_dbmanager