thoth-dbmanager 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

thoth_dbmanager/plugins/postgresql.py

@@ -0,0 +1,145 @@
+"""
+PostgreSQL plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.postgresql import PostgreSQLAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("postgresql")
+class PostgreSQLPlugin(DbPlugin):
+    """
+    PostgreSQL database plugin implementation.
+    """
+    
+    plugin_name = "PostgreSQL Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["postgresql", "postgres"]
+    required_dependencies = ["psycopg2-binary", "SQLAlchemy"]
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+        
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+    
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a PostgreSQL adapter instance"""
+        return PostgreSQLAdapter(kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for PostgreSQL"""
+        required_params = ['host', 'port', 'database', 'user', 'password']
+        
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter: {param}")
+                return False
+        
+        # Validate types
+        try:
+            port = int(kwargs['port'])
+            if port <= 0 or port > 65535:
+                logger.error(f"Invalid port number: {port}")
+                return False
+        except (ValueError, TypeError):
+            logger.error(f"Port must be a valid integer: {kwargs.get('port')}")
+            return False
+        
+        # Validate required string parameters are not empty
+        string_params = ['host', 'database', 'user', 'password']
+        for param in string_params:
+            if not kwargs.get(param) or not isinstance(kwargs[param], str):
+                logger.error(f"Parameter {param} must be a non-empty string")
+                return False
+        
+        return True
+    
+    def initialize(self, **kwargs) -> None:
+        """Initialize the PostgreSQL plugin"""
+        super().initialize(**kwargs)
+        
+        # Set up database directory path (for LSH and other features)
+        if 'database' in kwargs:
+            self.db_id = kwargs['database']
+            self._setup_directory_path(self.db_id)
+        
+        logger.info(f"PostgreSQL plugin initialized for database: {self.db_id}")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up the database directory path"""
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = 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):
+        """Lazy load LSH manager for backward compatibility"""
+        if self._lsh_manager is None and self.db_directory_path:
+            from ..lsh.manager import LshManager
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+    
+    # LSH integration methods for backward compatibility
+    def set_lsh(self) -> str:
+        """Set LSH for backward compatibility"""
+        try:
+            if self.lsh_manager and self.lsh_manager.load_lsh():
+                return "success"
+            else:
+                return "error"
+        except Exception as e:
+            logger.error(f"Error loading LSH: {e}")
+            return "error"
+    
+    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 for backward compatibility"""
+        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:
+                logger.error(f"LSH query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH not available for {self.db_id}")
+    
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+        
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+        
+        base_info.update({
+            "db_id": self.db_id,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+        
+        return base_info
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")

thoth_dbmanager/plugins/sqlite.py

@@ -0,0 +1,170 @@
+"""
+SQLite plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.sqlite import SQLiteAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("sqlite")
+class SQLitePlugin(DbPlugin):
+    """
+    SQLite database plugin implementation.
+    """
+    
+    plugin_name = "SQLite Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["sqlite", "sqlite3"]
+    required_dependencies = ["SQLAlchemy"]
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+        self.database_path = None
+        
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+    
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a SQLite adapter instance"""
+        return SQLiteAdapter(kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for SQLite"""
+        # For SQLite, we need either database_path or database_name
+        database_path = kwargs.get('database_path')
+        database_name = kwargs.get('database_name')
+        
+        if not database_path and not database_name:
+            logger.error("Either 'database_path' or 'database_name' is required for SQLite")
+            return False
+        
+        if database_path:
+            # Validate that the path is a string
+            if not isinstance(database_path, str):
+                logger.error("database_path must be a string")
+                return False
+            
+            # Check if parent directory exists or can be created
+            try:
+                db_path = Path(database_path)
+                db_path.parent.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                logger.error(f"Cannot create directory for database path {database_path}: {e}")
+                return False
+        
+        if database_name:
+            if not isinstance(database_name, str) or not database_name.strip():
+                logger.error("database_name must be a non-empty string")
+                return False
+        
+        return True
+    
+    def initialize(self, **kwargs) -> None:
+        """Initialize the SQLite plugin"""
+        # Handle database path resolution
+        database_path = kwargs.get('database_path')
+        database_name = kwargs.get('database_name')
+        
+        if not database_path and database_name:
+            # Create database path from name and root path
+            db_root = Path(self.db_root_path)
+            db_dir = db_root / f"{self.db_mode}_databases" / database_name
+            db_dir.mkdir(parents=True, exist_ok=True)
+            database_path = str(db_dir / f"{database_name}.db")
+            kwargs['database_path'] = database_path
+        
+        # Set database path for adapter
+        self.database_path = database_path
+        
+        # Initialize with updated kwargs
+        super().initialize(**kwargs)
+        
+        # Set up database directory path and ID
+        if database_name:
+            self.db_id = database_name
+        else:
+            # Extract database name from path
+            self.db_id = Path(database_path).stem
+        
+        self._setup_directory_path(self.db_id)
+        
+        logger.info(f"SQLite plugin initialized for database: {self.db_id} at {self.database_path}")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up the database directory path"""
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = 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):
+        """Lazy load LSH manager for backward compatibility"""
+        if self._lsh_manager is None and self.db_directory_path:
+            from ..lsh.manager import LshManager
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+    
+    # LSH integration methods for backward compatibility
+    def set_lsh(self) -> str:
+        """Set LSH for backward compatibility"""
+        try:
+            if self.lsh_manager and self.lsh_manager.load_lsh():
+                return "success"
+            else:
+                return "error"
+        except Exception as e:
+            logger.error(f"Error loading LSH: {e}")
+            return "error"
+    
+    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 for backward compatibility"""
+        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:
+                logger.error(f"LSH query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH not available for {self.db_id}")
+    
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+        
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+        
+        base_info.update({
+            "db_id": self.db_id,
+            "database_path": self.database_path,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+        
+        return base_info
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")

thoth_dbmanager/plugins/sqlserver.py

@@ -0,0 +1,149 @@
+"""
+SQL Server plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.sqlserver import SQLServerAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("sqlserver")
+class SQLServerPlugin(DbPlugin):
+    """
+    SQL Server database plugin implementation.
+    """
+
+    plugin_name = "SQL Server Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["sqlserver", "mssql"]
+    required_dependencies = ["pyodbc", "SQLAlchemy"]
+
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a SQL Server adapter instance"""
+        return SQLServerAdapter(kwargs)
+
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for SQL Server"""
+        required_params = ['host', 'port', 'database', 'user', 'password']
+
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter: {param}")
+                return False
+
+        # Validate types
+        try:
+            port = int(kwargs['port'])
+            if port <= 0 or port > 65535:
+                logger.error(f"Invalid port number: {port}")
+                return False
+        except (ValueError, TypeError):
+            logger.error(f"Port must be a valid integer: {kwargs.get('port')}")
+            return False
+
+        # Validate required string parameters are not empty
+        string_params = ['host', 'database', 'user', 'password']
+        for param in string_params:
+            if not kwargs.get(param) or not isinstance(kwargs[param], str):
+                logger.error(f"Parameter {param} must be a non-empty string")
+                return False
+
+        return True
+
+    def initialize(self, **kwargs) -> None:
+        """Initialize the SQL Server plugin"""
+        super().initialize(**kwargs)
+
+        # Set up database directory path (for LSH and other features)
+        if 'database' in kwargs:
+            self.db_id = kwargs['database']
+            self._setup_directory_path(self.db_id)
+
+        logger.info(f"SQL Server plugin initialized for database: {self.db_id}")
+
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up directory path for database-specific files"""
+        if self.db_root_path:
+            self.db_directory_path = Path(self.db_root_path) / "sqlserver" / db_id
+            self.db_directory_path.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def lsh_manager(self):
+        """Get LSH manager (for backward compatibility)"""
+        return self._lsh_manager
+
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+
+        base_info.update({
+            "db_id": self.db_id,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+
+        return base_info
+
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")
+    
+    def validate_connection_string(self, connection_string: str) -> bool:
+        """Validate SQL Server connection string format."""
+        return "mssql+pyodbc://" in connection_string
+    
+    def get_database_info(self) -> Dict[str, Any]:
+        """Get SQL Server database information."""
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "version": self.version,
+            "features": [
+                "transactions",
+                "foreign_keys",
+                "indexes",
+                "views",
+                "stored_procedures",
+                "triggers",
+                "computed_columns",
+                "partitioning"
+            ],
+            "data_types": [
+                "INT", "BIGINT", "DECIMAL", "NUMERIC", "FLOAT", "REAL",
+                "VARCHAR", "NVARCHAR", "TEXT", "NTEXT", "BINARY", "VARBINARY",
+                "DATE", "TIME", "DATETIME", "DATETIME2", "SMALLDATETIME",
+                "BIT", "UNIQUEIDENTIFIER", "XML"
+            ]
+        }
+    
+    def get_sample_connection_config(self) -> Dict[str, Any]:
+        """Get sample connection configuration."""
+        return {
+            "host": "localhost",
+            "port": 1433,
+            "database": "mydatabase",
+            "username": "user",
+            "password": "password",
+            "driver": "ODBC Driver 17 for SQL Server"
+        }

thoth_dbmanager/plugins/supabase.py

@@ -0,0 +1,224 @@
+"""
+Supabase plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+from urllib.parse import urlparse
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.supabase import SupabaseAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("supabase")
+class SupabasePlugin(DbPlugin):
+    """
+    Supabase database plugin implementation.
+    Extends PostgreSQL functionality with Supabase-specific features.
+    """
+    
+    plugin_name = "Supabase Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["supabase", "supabase-postgresql"]
+    required_dependencies = ["psycopg2-binary", "SQLAlchemy", "supabase", "postgrest-py"]
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+        self.project_url = None
+        self.api_key = None
+        
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+    
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a Supabase adapter instance"""
+        return SupabaseAdapter(kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for Supabase"""
+        # Support both direct database connection and REST API connection
+        use_rest_api = kwargs.get('use_rest_api', False)
+        
+        if use_rest_api:
+            return self._validate_rest_params(**kwargs)
+        else:
+            return self._validate_direct_params(**kwargs)
+    
+    def _validate_rest_params(self, **kwargs) -> bool:
+        """Validate REST API connection parameters"""
+        required_params = ['project_url', 'api_key']
+        
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter for REST API: {param}")
+                return False
+        
+        # Validate project URL format
+        project_url = kwargs.get('project_url')
+        try:
+            parsed = urlparse(project_url)
+            if not parsed.netloc.endswith('.supabase.co'):
+                logger.error("Invalid Supabase project URL format")
+                return False
+        except Exception:
+            logger.error("Invalid project URL format")
+            return False
+        
+        # Validate API key format
+        api_key = kwargs.get('api_key')
+        if not api_key or not isinstance(api_key, str):
+            logger.error("API key must be a non-empty string")
+            return False
+        
+        return True
+    
+    def _validate_direct_params(self, **kwargs) -> bool:
+        """Validate direct database connection parameters"""
+        required_params = ['host', 'port', 'database', 'user', 'password']
+        
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter: {param}")
+                return False
+        
+        # Validate types
+        try:
+            port = int(kwargs['port'])
+            if port <= 0 or port > 65535:
+                logger.error(f"Invalid port number: {port}")
+                return False
+        except (ValueError, TypeError):
+            logger.error(f"Port must be a valid integer: {kwargs.get('port')}")
+            return False
+        
+        # Validate required string parameters are not empty
+        string_params = ['host', 'database', 'user', 'password']
+        for param in string_params:
+            if not kwargs.get(param) or not isinstance(kwargs[param], str):
+                logger.error(f"Parameter {param} must be a non-empty string")
+                return False
+        
+        # Validate SSL parameters if provided
+        ssl_params = ['sslcert', 'sslkey', 'sslrootcert']
+        for param in ssl_params:
+            if param in kwargs and kwargs[param]:
+                if not isinstance(kwargs[param], str):
+                    logger.error(f"SSL parameter {param} must be a string")
+                    return False
+        
+        return True
+    
+    def initialize(self, **kwargs) -> None:
+        """Initialize the Supabase plugin"""
+        super().initialize(**kwargs)
+        
+        # Store connection parameters
+        self.project_url = kwargs.get('project_url')
+        self.api_key = kwargs.get('api_key')
+        
+        # Set up database directory path (for LSH and other features)
+        if 'database' in kwargs:
+            self.db_id = kwargs['database']
+        elif 'project_url' in kwargs:
+            # Extract database name from project URL
+            parsed = urlparse(kwargs['project_url'])
+            self.db_id = parsed.netloc.split('.')[0]
+        
+        if self.db_id:
+            self._setup_directory_path(self.db_id)
+        
+        logger.info(f"Supabase plugin initialized for project: {self.db_id}")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up the database directory path"""
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = 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):
+        """Lazy load LSH manager for backward compatibility"""
+        if self._lsh_manager is None and self.db_directory_path:
+            from ..lsh.manager import LshManager
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+    
+    # LSH integration methods for backward compatibility
+    def set_lsh(self) -> str:
+        """Set LSH for backward compatibility"""
+        try:
+            if self.lsh_manager and self.lsh_manager.load_lsh():
+                return "success"
+            else:
+                return "error"
+        except Exception as e:
+            logger.error(f"Error loading LSH: {e}")
+            return "error"
+    
+    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 for backward compatibility"""
+        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:
+                logger.error(f"LSH query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH not available for {self.db_id}")
+    
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+        
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+        
+        base_info.update({
+            "db_id": self.db_id,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None,
+            "project_url": self.project_url,
+            "connection_mode": "REST API" if self.connection_params.get('use_rest_api') else "Direct Database"
+        })
+        
+        return base_info
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")
+    
+    def get_required_parameters(self) -> Dict[str, Any]:
+        """Get required connection parameters for Supabase"""
+        use_rest_api = self.connection_params.get('use_rest_api', False)
+        
+        if use_rest_api:
+            return {
+                "required": ["project_url", "api_key"],
+                "optional": ["schema", "timeout", "pool_size"],
+                "connection_mode": "REST API"
+            }
+        else:
+            return {
+                "required": ["host", "port", "database", "user", "password"],
+                "optional": ["schema", "sslmode", "sslcert", "sslkey", "sslrootcert", "pool_size", "connect_timeout"],
+                "connection_mode": "Direct Database"
+            }