thoth-dbmanager 0.5.2__py3-none-any.whl → 0.5.8__py3-none-any.whl

thoth_dbmanager/__init__.py

@@ -72,4 +72,4 @@ __all__ = [
     "DatabaseImportError",
 ]
 
-__version__ = "0.5.0"
+__version__ = "0.5.7"

thoth_dbmanager/adapters/__init__.py

@@ -2,14 +2,38 @@
 Database adapters for Thoth SQL Database Manager.
 """
 
-from .postgresql import PostgreSQLAdapter
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Always available adapter (SQLite is built into Python)
 from .sqlite import SQLiteAdapter
-from .mariadb import MariaDBAdapter
-from .sqlserver import SQLServerAdapter
 
 __all__ = [
-    "PostgreSQLAdapter",
     "SQLiteAdapter",
-    "MariaDBAdapter",
-    "SQLServerAdapter",
 ]
+
+# Optional adapters - only import if dependencies are available
+try:
+    import psycopg2
+    from .postgresql import PostgreSQLAdapter
+    __all__.append("PostgreSQLAdapter")
+except ImportError:
+    logger.debug("psycopg2 not installed, PostgreSQLAdapter not available")
+    PostgreSQLAdapter = None
+
+try:
+    import mariadb
+    from .mariadb import MariaDBAdapter
+    __all__.append("MariaDBAdapter")
+except ImportError:
+    logger.debug("MariaDB connector not installed, MariaDBAdapter not available")
+    MariaDBAdapter = None
+
+try:
+    import pyodbc
+    from .sqlserver import SQLServerAdapter
+    __all__.append("SQLServerAdapter")
+except ImportError:
+    logger.debug("pyodbc not installed, SQLServerAdapter not available")
+    SQLServerAdapter = None

thoth_dbmanager/adapters/mariadb.py

@@ -1,165 +1,388 @@
+# Copyright (c) 2025 Marco Pancotti
+# This file is part of Thoth and is released under the MIT License.
+# See the LICENSE.md file in the project root for full license information.
+
 """
-MariaDB adapter for Thoth SQL Database Manager.
+MariaDB adapter implementation.
 """
-
-from typing import Any, Dict, List, Optional
-from sqlalchemy import create_engine, text
-from sqlalchemy.engine import Engine
+import logging
+from typing import Any, Dict, List, Optional, Union
+import mariadb
+from sqlalchemy import create_engine, text, inspect
 from sqlalchemy.exc import SQLAlchemyError
 
 from ..core.interfaces import DbAdapter
+from ..documents import (
+    TableDocument,
+    ColumnDocument,
+    SchemaDocument,
+    ForeignKeyDocument,
+    IndexDocument
+)
+
+logger = logging.getLogger(__name__)
 
 
 class MariaDBAdapter(DbAdapter):
-    """MariaDB database adapter."""
+    """
+    MariaDB database adapter implementation.
+    """
     
-    def __init__(self, connection_string: str, **kwargs: Any) -> None:
-        """
-        Initialize MariaDB adapter.
-        
-        Args:
-            connection_string: MariaDB connection string
-            **kwargs: Additional connection parameters
-        """
-        self.connection_string = connection_string
+    def __init__(self, connection_params: Dict[str, Any]):
+        super().__init__(connection_params)
         self.engine = None
-        self.connection_params = kwargs
-        
+        self.raw_connection = None
+        self.host = connection_params.get('host', 'localhost')
+        self.port = connection_params.get('port', 3307)
+        self.database = connection_params.get('database')
+        self.user = connection_params.get('user')
+        self.password = connection_params.get('password')
+    
     def connect(self) -> None:
-        """Establish database connection."""
+        """Establish MariaDB connection"""
         try:
-            self.engine = create_engine(
-                self.connection_string,
-                pool_pre_ping=True,
-                **self.connection_params
+            # Create SQLAlchemy engine
+            connection_string = self._build_connection_string()
+            self.engine = create_engine(connection_string, echo=False)
+            
+            # Test connection
+            with self.engine.connect() as conn:
+                conn.execute(text("SELECT 1"))
+            
+            # Also create raw mariadb connection for specific operations
+            self.raw_connection = mariadb.connect(
+                host=self.host,
+                port=self.port,
+                database=self.database,
+                user=self.user,
+                password=self.password
             )
+            
+            self._initialized = True
+            logger.info("MariaDB connection established successfully")
+            
         except Exception as e:
-            raise ConnectionError(f"Failed to connect to MariaDB: {e}")
+            logger.error(f"Failed to connect to MariaDB: {e}")
+            raise
     
     def disconnect(self) -> None:
-        """Close database connection."""
-        if self.engine:
-            self.engine.dispose()
-            self.engine = None
+        """Close MariaDB connection"""
+        try:
+            if self.engine:
+                self.engine.dispose()
+                self.engine = None
+            
+            if self.raw_connection:
+                self.raw_connection.close()
+                self.raw_connection = None
+            
+            self._initialized = False
+            logger.info("MariaDB connection closed")
+            
+        except Exception as e:
+            logger.error(f"Error closing MariaDB connection: {e}")
+    
+    def _build_connection_string(self) -> str:
+        """Build SQLAlchemy connection string for MariaDB"""
+        if not all([self.database, self.user, self.password]):
+            raise ValueError("Missing required connection parameters: database, user, password")
+        
+        # MariaDB uses mysql+pymysql or mariadb+mariadbconnector dialect
+        return f"mariadb+mariadbconnector://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}"
     
-    def execute_query(self, query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
-        """Execute a query and return results."""
+    def execute_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
+        """Execute SQL query"""
         if not self.engine:
-            self.connect()
-            
+            raise RuntimeError("Not connected to database")
+        
         try:
             with self.engine.connect() as conn:
-                result = conn.execute(text(query), params or {})
-                return [dict(row._mapping) for row in result]
+                # MariaDB doesn't have direct query timeout in the same way
+                # but we can set connection timeout
+                conn.execute(text(f"SET SESSION max_statement_time = {timeout}"))
+                
+                # Execute query
+                if params:
+                    result = conn.execute(text(query), params)
+                else:
+                    result = conn.execute(text(query))
+                
+                # Handle different fetch modes
+                if query.strip().upper().startswith(('SELECT', 'WITH', 'SHOW', 'DESCRIBE')):
+                    if fetch == "all":
+                        return [dict(row._mapping) for row in result]
+                    elif fetch == "one":
+                        row = result.first()
+                        return dict(row._mapping) if row else None
+                    elif isinstance(fetch, int):
+                        rows = result.fetchmany(fetch)
+                        return [dict(row._mapping) for row in rows]
+                else:
+                    # For INSERT, UPDATE, DELETE
+                    conn.commit()
+                    return result.rowcount
+                    
         except SQLAlchemyError as e:
-            raise RuntimeError(f"MariaDB query failed: {e}")
+            logger.error(f"MariaDB query execution failed: {e}")
+            raise
     
-    def execute_update(self, query: str, params: Optional[Dict[str, Any]] = None) -> int:
-        """Execute an update query and return affected row count."""
+    def get_tables_as_documents(self) -> List[TableDocument]:
+        """Return tables as document objects"""
         if not self.engine:
-            self.connect()
-            
+            raise RuntimeError("Not connected to database")
+        
         try:
-            with self.engine.connect() as conn:
-                result = conn.execute(text(query), params or {})
-                conn.commit()
-                return result.rowcount
-        except SQLAlchemyError as e:
-            raise RuntimeError(f"MariaDB update failed: {e}")
-    
-    def get_tables(self) -> List[str]:
-        """Get list of tables in the database."""
-        query = "SHOW TABLES"
-        result = self.execute_query(query)
-        return [list(row.values())[0] for row in result]
+            inspector = inspect(self.engine)
+            tables = []
+            
+            for table_name in inspector.get_table_names():
+                # Get row count
+                count_result = self.execute_query(f"SELECT COUNT(*) as count FROM {table_name}", fetch="one")
+                row_count = count_result.get('count', 0) if count_result else 0
+                
+                # Get column count
+                columns = inspector.get_columns(table_name)
+                
+                # Get table comment (if available)
+                table_comment = ""
+                try:
+                    comment_result = self.execute_query(
+                        f"SELECT table_comment FROM information_schema.tables WHERE table_name = '{table_name}'",
+                        fetch="one"
+                    )
+                    table_comment = comment_result.get('table_comment', '') if comment_result else ''
+                except:
+                    pass
+                
+                tables.append(TableDocument(
+                    table_name=table_name,
+                    table_type="TABLE",
+                    row_count=row_count,
+                    column_count=len(columns),
+                    description=table_comment
+                ))
+            
+            return tables
+            
+        except Exception as e:
+            logger.error(f"Error getting tables as documents: {e}")
+            raise
     
-    def get_table_schema(self, table_name: str) -> Dict[str, Any]:
-        """Get schema information for a specific table."""
-        query = f"DESCRIBE {table_name}"
-        columns = self.execute_query(query)
-        
-        schema = {
-            'table_name': table_name,
-            'columns': []
-        }
+    def get_columns_as_documents(self, table_name: str) -> List[ColumnDocument]:
+        """Return columns as document objects"""
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
         
-        for col in columns:
-            schema['columns'].append({
-                'name': col['Field'],
-                'type': col['Type'],
-                'nullable': col['Null'] == 'YES',
-                'default': col['Default'],
-                'primary_key': col['Key'] == 'PRI'
-            })
+        try:
+            inspector = inspect(self.engine)
+            columns = []
+            
+            for col in inspector.get_columns(table_name):
+                columns.append(ColumnDocument(
+                    table_name=table_name,
+                    column_name=col['name'],
+                    data_type=str(col['type']),
+                    is_nullable=col.get('nullable', True),
+                    column_default=col.get('default'),
+                    is_pk=col.get('primary_key', False),
+                    column_comment=col.get('comment', '')
+                ))
+            
+            # Mark primary keys
+            pk_constraint = inspector.get_pk_constraint(table_name)
+            if pk_constraint and pk_constraint.get('constrained_columns'):
+                pk_columns = pk_constraint['constrained_columns']
+                for col in columns:
+                    if col.column_name in pk_columns:
+                        col.is_pk = True
+            
+            return columns
+            
+        except Exception as e:
+            logger.error(f"Error getting columns as documents: {e}")
+            raise
+    
+    def get_foreign_keys_as_documents(self) -> List[ForeignKeyDocument]:
+        """Return foreign keys as document objects"""
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
         
-        return schema
+        try:
+            inspector = inspect(self.engine)
+            foreign_keys = []
+            
+            for table_name in inspector.get_table_names():
+                for fk in inspector.get_foreign_keys(table_name):
+                    # Each foreign key can have multiple column pairs
+                    for i, const_col in enumerate(fk['constrained_columns']):
+                        foreign_keys.append(ForeignKeyDocument(
+                            constraint_name=fk['name'],
+                            table_name=table_name,
+                            column_name=const_col,
+                            foreign_table_name=fk['referred_table'],
+                            foreign_column_name=fk['referred_columns'][i] if i < len(fk['referred_columns']) else None
+                        ))
+            
+            return foreign_keys
+            
+        except Exception as e:
+            logger.error(f"Error getting foreign keys as documents: {e}")
+            raise
     
-    def get_indexes(self, table_name: str) -> List[Dict[str, Any]]:
-        """Get index information for a table."""
-        query = f"SHOW INDEX FROM {table_name}"
-        indexes = self.execute_query(query)
+    def get_schemas_as_documents(self) -> List[SchemaDocument]:
+        """Return schemas as document objects"""
+        # MariaDB uses database as schema concept
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
         
-        result = []
-        for idx in indexes:
-            result.append({
-                'name': idx['Key_name'],
-                'column': idx['Column_name'],
-                'unique': not idx['Non_unique'],
-                'type': idx['Index_type']
-            })
+        try:
+            # Get current database as schema
+            result = self.execute_query("SELECT DATABASE() as db_name", fetch="one")
+            current_db = result.get('db_name') if result else self.database
+            
+            # Get table count for current database
+            tables = self.get_tables_as_documents()
+            
+            return [SchemaDocument(
+                catalog_name=current_db,
+                schema_name=current_db,
+                schema_owner=self.user,
+                table_count=len(tables)
+            )]
+            
+        except Exception as e:
+            logger.error(f"Error getting schemas as documents: {e}")
+            raise
+    
+    def get_indexes_as_documents(self, table_name: Optional[str] = None) -> List[IndexDocument]:
+        """Return indexes as document objects"""
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
         
-        return result
+        try:
+            inspector = inspect(self.engine)
+            indexes = []
+            
+            # Get tables to process
+            tables = [table_name] if table_name else inspector.get_table_names()
+            
+            for tbl in tables:
+                for idx in inspector.get_indexes(tbl):
+                    indexes.append(IndexDocument(
+                        table_name=tbl,
+                        index_name=idx['name'],
+                        column_names=idx['column_names'],
+                        is_unique=idx.get('unique', False),
+                        index_type='BTREE'  # MariaDB default
+                    ))
+            
+            return indexes
+            
+        except Exception as e:
+            logger.error(f"Error getting indexes as documents: {e}")
+            raise
     
-    def get_foreign_keys(self, table_name: str) -> List[Dict[str, Any]]:
-        """Get foreign key information for a table."""
-        query = f"""
-        SELECT 
-            CONSTRAINT_NAME as name,
-            COLUMN_NAME as column_name,
-            REFERENCED_TABLE_NAME as referenced_table,
-            REFERENCED_COLUMN_NAME as referenced_column
-        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-        WHERE TABLE_NAME = '{table_name}' 
-        AND REFERENCED_TABLE_NAME IS NOT NULL
+    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
         """
+        Get unique values from the database.
         
-        return self.execute_query(query)
-    
-    def create_table(self, table_name: str, schema: Dict[str, Any]) -> None:
-        """Create a new table with the given schema."""
-        columns = []
-        for col in schema.get('columns', []):
-            col_def = f"{col['name']} {col['type']}"
-            if not col.get('nullable', True):
-                col_def += " NOT NULL"
-            if col.get('default') is not None:
-                col_def += f" DEFAULT {col['default']}"
-            if col.get('primary_key'):
-                col_def += " PRIMARY KEY"
-            columns.append(col_def)
+        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
+        """
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
         
-        query = f"CREATE TABLE {table_name} ({', '.join(columns)})"
-        self.execute_update(query)
-    
-    def drop_table(self, table_name: str) -> None:
-        """Drop a table."""
-        query = f"DROP TABLE IF EXISTS {table_name}"
-        self.execute_update(query)
+        try:
+            inspector = inspect(self.engine)
+            unique_values = {}
+            
+            for table_name in inspector.get_table_names():
+                unique_values[table_name] = {}
+                
+                for col in inspector.get_columns(table_name):
+                    col_name = col['name']
+                    # Only get unique values for reasonable data types
+                    col_type = str(col['type']).upper()
+                    
+                    if any(t in col_type for t in ['VARCHAR', 'CHAR', 'TEXT', 'INT', 'ENUM']):
+                        try:
+                            # Limit to first 100 unique values
+                            query = f"SELECT DISTINCT `{col_name}` FROM `{table_name}` LIMIT 100"
+                            result = self.execute_query(query)
+                            
+                            values = []
+                            for row in result:
+                                val = row.get(col_name)
+                                if val is not None:
+                                    values.append(str(val))
+                            
+                            if values:
+                                unique_values[table_name][col_name] = values
+                                
+                        except Exception as e:
+                            logger.debug(f"Could not get unique values for {table_name}.{col_name}: {e}")
+                            continue
+            
+            return unique_values
+            
+        except Exception as e:
+            logger.error(f"Error getting unique values: {e}")
+            raise
     
-    def table_exists(self, table_name: str) -> bool:
-        """Check if a table exists."""
-        query = f"""
-        SELECT COUNT(*) as count
-        FROM INFORMATION_SCHEMA.TABLES
-        WHERE TABLE_NAME = '{table_name}'
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
         """
-        result = self.execute_query(query)
-        return result[0]['count'] > 0
-    
-    def get_connection_info(self) -> Dict[str, Any]:
-        """Get connection information."""
-        return {
-            'type': 'mariadb',
-            'connection_string': self.connection_string,
-            'connected': self.engine is not None
-        }
+        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.
+        """
+        if not self.engine:
+            raise RuntimeError("Not connected to database")
+        
+        try:
+            inspector = inspect(self.engine)
+            columns = inspector.get_columns(table_name)
+            
+            example_data = {}
+            
+            for col in columns:
+                col_name = col['name']
+                col_type = str(col['type']).upper()
+                
+                # Skip blob/binary columns
+                if any(t in col_type for t in ['BLOB', 'BINARY', 'IMAGE']):
+                    example_data[col_name] = []
+                    continue
+                
+                try:
+                    # Get most frequent values
+                    query = f"""
+                    SELECT `{col_name}`, COUNT(*) as freq
+                    FROM `{table_name}`
+                    WHERE `{col_name}` IS NOT NULL
+                    GROUP BY `{col_name}`
+                    ORDER BY freq DESC
+                    LIMIT {number_of_rows}
+                    """
+                    
+                    result = self.execute_query(query)
+                    values = [row[col_name] for row in result]
+                    
+                    example_data[col_name] = values
+                    
+                except Exception as e:
+                    logger.debug(f"Could not get example data for {table_name}.{col_name}: {e}")
+                    example_data[col_name] = []
+            
+            return example_data
+            
+        except Exception as e:
+            logger.error(f"Error getting example data: {e}")
+            raise

thoth_dbmanager/adapters/sqlserver.py

@@ -23,6 +23,7 @@ class SQLServerAdapter(DbAdapter):
         self.database = connection_params.get('database')
         self.user = connection_params.get('user')
         self.password = connection_params.get('password')
+        self.schema = connection_params.get('schema', 'dbo')  # Default to 'dbo' for SQL Server
         self.driver = connection_params.get('driver', 'ODBC Driver 17 for SQL Server')
         
     def connect(self) -> None:
@@ -142,10 +143,11 @@ class SQLServerAdapter(DbAdapter):
     
     def get_tables(self) -> List[str]:
         """Get list of tables in the database."""
-        query = """
+        query = f"""
         SELECT TABLE_NAME as name
         FROM INFORMATION_SCHEMA.TABLES
         WHERE TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_SCHEMA = '{self.schema}'
         ORDER BY TABLE_NAME
         """
         result = self.execute_query(query)
@@ -159,15 +161,17 @@ class SQLServerAdapter(DbAdapter):
             DATA_TYPE as type,
             IS_NULLABLE as nullable,
             COLUMN_DEFAULT as default_value,
-            CASE WHEN COLUMNPROPERTY(OBJECT_ID(TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 THEN 1 ELSE 0 END as is_identity,
+            CASE WHEN COLUMNPROPERTY(OBJECT_ID('{self.schema}.' + TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 THEN 1 ELSE 0 END as is_identity,
             CASE WHEN EXISTS (
                 SELECT 1 FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE 
                 WHERE TABLE_NAME = '{table_name}' 
+                AND TABLE_SCHEMA = '{self.schema}'
                 AND COLUMN_NAME = c.COLUMN_NAME 
                 AND CONSTRAINT_NAME LIKE 'PK_%'
             ) THEN 1 ELSE 0 END as is_primary_key
         FROM INFORMATION_SCHEMA.COLUMNS c
         WHERE TABLE_NAME = '{table_name}'
+        AND TABLE_SCHEMA = '{self.schema}'
         ORDER BY ORDINAL_POSITION
         """
         
@@ -255,6 +259,7 @@ class SQLServerAdapter(DbAdapter):
         SELECT COUNT(*) as count
         FROM INFORMATION_SCHEMA.TABLES
         WHERE TABLE_NAME = '{table_name}'
+        AND TABLE_SCHEMA = '{self.schema}'
         AND TABLE_TYPE = 'BASE TABLE'
         """
         result = self.execute_query(query)
@@ -276,13 +281,14 @@ class SQLServerAdapter(DbAdapter):
         if not self.engine:
             raise RuntimeError("Not connected to database")
 
-        query = """
+        query = f"""
         SELECT
             TABLE_NAME as name,
             TABLE_SCHEMA as schema_name,
             '' as comment
         FROM INFORMATION_SCHEMA.TABLES
         WHERE TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_SCHEMA = '{self.schema}'
         ORDER BY TABLE_NAME
         """
 
@@ -323,9 +329,10 @@ class SQLServerAdapter(DbAdapter):
         """Get example data (most frequent values) for each column in a table."""
         inspector = inspect(self.engine)
         try:
-            columns = inspector.get_columns(table_name)
+            # For SQL Server, we need to specify the schema when inspecting columns
+            columns = inspector.get_columns(table_name, schema=self.schema)
         except SQLAlchemyError as e:
-            logger.error(f"Error inspecting columns for table {table_name}: {e}")
+            logger.error(f"Error inspecting columns for table {table_name} in schema {self.schema}: {e}")
             raise e
 
         if not columns:
@@ -374,16 +381,18 @@ class SQLServerAdapter(DbAdapter):
                 CASE WHEN EXISTS (
                     SELECT 1 FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
                     WHERE TABLE_NAME = c.TABLE_NAME
+                    AND TABLE_SCHEMA = c.TABLE_SCHEMA
                     AND COLUMN_NAME = c.COLUMN_NAME
                     AND CONSTRAINT_NAME LIKE 'PK_%'
                 ) THEN 1 ELSE 0 END as is_primary_key
             FROM INFORMATION_SCHEMA.COLUMNS c
             WHERE c.TABLE_NAME = '{table_name}'
+            AND c.TABLE_SCHEMA = '{self.schema}'
             ORDER BY c.ORDINAL_POSITION
             """
         else:
             # Get all columns
-            query = """
+            query = f"""
             SELECT
                 c.TABLE_NAME as table_name,
                 c.COLUMN_NAME as column_name,
@@ -394,10 +403,12 @@ class SQLServerAdapter(DbAdapter):
                 CASE WHEN EXISTS (
                     SELECT 1 FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
                     WHERE TABLE_NAME = c.TABLE_NAME
+                    AND TABLE_SCHEMA = c.TABLE_SCHEMA
                     AND COLUMN_NAME = c.COLUMN_NAME
                     AND CONSTRAINT_NAME LIKE 'PK_%'
                 ) THEN 1 ELSE 0 END as is_primary_key
             FROM INFORMATION_SCHEMA.COLUMNS c
+            WHERE c.TABLE_SCHEMA = '{self.schema}'
             ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION
             """
 

thoth_dbmanager/core/factory.py

@@ -6,6 +6,9 @@ from typing import Any, Dict, List, Optional
 from .registry import DbPluginRegistry
 from .interfaces import DbPlugin
 
+# Import plugins to ensure they are registered
+from .. import plugins  # This imports all plugins and registers them
+
 logger = logging.getLogger(__name__)
 
 

thoth_dbmanager/core/interfaces.py

@@ -278,85 +278,4 @@ class DbPlugin(ABC):
         """Get unique values (backward compatibility)"""
         if not self.adapter:
             raise RuntimeError("Plugin not initialized")
-        return self.adapter.get_unique_values()
-    
-    def get_embedding_function(self):
-        """
-        Get the embedding function for similarity computations.
-        
-        Returns:
-            SafeSentenceTransformer: An embedding function with encode method
-        """
-        try:
-            # Import SafeSentenceTransformer
-            try:
-                from sentence_transformers import SentenceTransformer
-                import logging
-                
-                logger = logging.getLogger(__name__)
-                
-                class SafeSentenceTransformer:
-                    """
-                    Wrapper for SentenceTransformer that handles PyTorch meta tensor issues.
-                    """
-                    def __init__(self, model_name_or_path: str):
-                        self.model_name_or_path = model_name_or_path
-                        self._model = None
-
-                    def _get_model(self):
-                        """Lazy initialization of the SentenceTransformer model."""
-                        if self._model is None:
-                            try:
-                                logger.info(f"Initializing SentenceTransformer with model: {self.model_name_or_path}")
-                                self._model = SentenceTransformer(
-                                    model_name_or_path=self.model_name_or_path,
-                                    device='cpu'  # Explicitly set device to CPU to avoid meta tensor issues
-                                )
-                                logger.info("SentenceTransformer initialized successfully")
-                            except Exception as e:
-                                logger.error(f"Failed to initialize SentenceTransformer: {e}")
-                                # Try alternative initialization approach
-                                try:
-                                    logger.info("Trying alternative initialization approach...")
-                                    self._model = SentenceTransformer(self.model_name_or_path)
-                                    # Move to CPU explicitly after initialization
-                                    self._model = self._model.to('cpu')
-                                    logger.info("Alternative initialization successful")
-                                except Exception as e2:
-                                    logger.error(f"Alternative initialization also failed: {e2}")
-                                    raise e2
-                        return self._model
-
-                    def encode(self, sentences, **kwargs):
-                        """Encode sentences using the underlying SentenceTransformer model."""
-                        model = self._get_model()
-                        return model.encode(sentences, **kwargs)
-                
-                return SafeSentenceTransformer(
-                    model_name_or_path="paraphrase-multilingual-MiniLM-L12-v2"
-                )
-                
-            except ImportError:
-                import logging
-                logger = logging.getLogger(__name__)
-                logger.warning("sentence_transformers not available, creating dummy embedding function")
-                # Create a dummy embedding function for testing
-                class DummyEmbeddingFunction:
-                    def encode(self, sentences, **kwargs):
-                        import numpy as np
-                        # Return dummy embeddings - same shape for all sentences
-                        return np.random.rand(len(sentences), 384)  # 384 is typical embedding size
-                
-                return DummyEmbeddingFunction()
-                
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Failed to create embedding function: {e}")
-            # Return a basic dummy function as fallback
-            class BasicDummyEmbeddingFunction:
-                def encode(self, sentences, **kwargs):
-                    import numpy as np
-                    return np.random.rand(len(sentences), 384)
-            
-            return BasicDummyEmbeddingFunction()
+        return self.adapter.get_unique_values()

thoth_dbmanager/plugins/__init__.py

@@ -2,16 +2,41 @@
 Database plugins for Thoth SQL Database Manager.
 """
 
-# Import all plugins to ensure they are registered
-from .postgresql import PostgreSQLPlugin
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Always available plugin (SQLite is built into Python)
 from .sqlite import SQLitePlugin
-from .mariadb import MariaDBPlugin
-from .sqlserver import SQLServerPlugin
 
-# This ensures all plugins are registered when the module is imported
 __all__ = [
-    "PostgreSQLPlugin",
     "SQLitePlugin",
-    "MariaDBPlugin",
-    "SQLServerPlugin",
 ]
+
+# Optional plugins - only import if dependencies are available
+try:
+    import psycopg2
+    from .postgresql import PostgreSQLPlugin
+    __all__.append("PostgreSQLPlugin")
+    logger.debug("PostgreSQL plugin loaded successfully")
+except ImportError:
+    logger.debug("psycopg2 not installed, PostgreSQL plugin not available")
+    PostgreSQLPlugin = None
+
+try:
+    import mariadb
+    from .mariadb import MariaDBPlugin
+    __all__.append("MariaDBPlugin")
+    logger.debug("MariaDB plugin loaded successfully")
+except ImportError:
+    logger.debug("MariaDB connector not installed, MariaDB plugin not available")
+    MariaDBPlugin = None
+
+try:
+    import pyodbc
+    from .sqlserver import SQLServerPlugin
+    __all__.append("SQLServerPlugin")
+    logger.debug("SQL Server plugin loaded successfully")
+except ImportError:
+    logger.debug("pyodbc not installed, SQL Server plugin not available")
+    SQLServerPlugin = None

thoth_dbmanager/plugins/mariadb.py

@@ -1,265 +1,27 @@
+# Copyright (c) 2025 Marco Pancotti
+# This file is part of Thoth and is released under the MIT License.
+# See the LICENSE.md file in the project root for full license information.
+
 """
 MariaDB plugin for Thoth SQL Database Manager.
-Unified implementation combining plugin architecture with full database functionality.
+Uses the MariaDB adapter from adapters.mariadb module.
 """
 
 import logging
-import os
 from pathlib import Path
 from threading import Lock
-from typing import Any, Dict, List, Optional, Union
-
-from sqlalchemy import create_engine, inspect, text
-from sqlalchemy.exc import SQLAlchemyError
+from typing import Any, Dict, List, Optional
 
 from ..core.interfaces import DbPlugin, DbAdapter
 from ..core.registry import register_plugin
-from ..documents import TableDocument, ColumnDocument, ForeignKeyDocument, SchemaDocument, IndexDocument
+from ..adapters.mariadb import MariaDBAdapter
 
 logger = logging.getLogger(__name__)
 
 
-class MariaDBAdapter(DbAdapter):
-    """MariaDB database adapter with full functionality."""
-    
-    def __init__(self, connection_params: Dict[str, Any]):
-        super().__init__(connection_params)
-        self.engine = None
-        self.host = connection_params.get('host')
-        self.port = connection_params.get('port', 3306)
-        self.dbname = connection_params.get('database') or connection_params.get('dbname')
-        self.user = connection_params.get('user') or connection_params.get('username')
-        self.password = connection_params.get('password')
-    
-    def connect(self) -> None:
-        """Establish database connection."""
-        try:
-            # Try different connection methods for MariaDB
-            connection_methods = [
-                # Use MySQL driver (MariaDB is MySQL-compatible)
-                f"mysql+pymysql://{self.user}:{self.password}@{self.host}:{self.port}/{self.dbname}",
-                # Use MySQL connector with explicit TCP
-                f"mysql+mysqlconnector://{self.user}:{self.password}@{self.host}:{self.port}/{self.dbname}",
-                # Use MariaDB connector with TCP parameters
-                f"mariadb+mariadbconnector://{self.user}:{self.password}@{self.host}:{self.port}/{self.dbname}?unix_socket=",
-            ]
-
-            last_error = None
-            for connection_string in connection_methods:
-                try:
-                    self.engine = create_engine(connection_string, pool_pre_ping=True)
-                    # Test the connection
-                    with self.engine.connect() as conn:
-                        conn.execute(text("SELECT 1"))
-                    self.connection = self.engine
-                    self._initialized = True
-                    logger.info(f"MariaDB connected using: {connection_string.split('://')[0]}")
-                    return
-                except Exception as e:
-                    last_error = e
-                    logger.debug(f"MariaDB connection failed with {connection_string.split('://')[0]}: {e}")
-                    if self.engine:
-                        self.engine.dispose()
-                        self.engine = None
-                    continue
-
-            # If all methods fail, raise the last error
-            raise ConnectionError(f"Failed to connect to MariaDB: {last_error}")
-
-        except Exception as e:
-            raise ConnectionError(f"Failed to connect to MariaDB: {e}")
-    
-    def disconnect(self) -> None:
-        """Close database connection."""
-        if self.engine:
-            self.engine.dispose()
-            self.engine = None
-            self.connection = None
-    
-    def execute_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """Execute a query and return results."""
-        if not self.engine:
-            self.connect()
-
-        with self.engine.connect() as connection:
-            try:
-                if params:
-                    result = connection.execute(text(query), params)
-                else:
-                    result = connection.execute(text(query))
-
-                # Check if this is a query that returns rows (SELECT, SHOW, etc.)
-                query_upper = query.strip().upper()
-                if query_upper.startswith(('SELECT', 'SHOW', 'DESCRIBE', 'DESC', 'EXPLAIN', 'WITH')):
-                    if fetch == "all":
-                        return [row._asdict() for row in result.fetchall()]
-                    elif fetch == "one":
-                        row = result.fetchone()
-                        return row._asdict() if row else None
-                    elif isinstance(fetch, int) and fetch > 0:
-                        return [row._asdict() for row in result.fetchmany(fetch)]
-                    else:
-                        return [row._asdict() for row in result.fetchall()]
-                else:
-                    # For DDL/DML queries (CREATE, INSERT, UPDATE, DELETE), return rowcount
-                    connection.commit()
-                    return result.rowcount
-            except SQLAlchemyError as e:
-                logger.error(f"Error executing SQL: {str(e)}")
-                raise e
-    
-    def get_tables_as_documents(self) -> List[TableDocument]:
-        """Return tables as document objects."""
-        inspector = inspect(self.engine)
-        table_names = inspector.get_table_names()
-        tables = []
-        
-        for table_name in table_names:
-            try:
-                table_comment = inspector.get_table_comment(table_name).get('text', '')
-            except SQLAlchemyError:
-                table_comment = ''
-            
-            tables.append(TableDocument(
-                table_name=table_name,
-                schema_name="",  # MariaDB doesn't have explicit schemas like PostgreSQL
-                comment=table_comment or "",
-                row_count=None  # Could be populated if needed
-            ))
-        
-        return tables
-    
-    def get_columns_as_documents(self, table_name: str) -> List[ColumnDocument]:
-        """Return columns as document objects."""
-        inspector = inspect(self.engine)
-        columns_metadata = inspector.get_columns(table_name)
-        pk_columns = inspector.get_pk_constraint(table_name).get('constrained_columns', [])
-        
-        columns = []
-        for col_meta in columns_metadata:
-            columns.append(ColumnDocument(
-                table_name=table_name,
-                column_name=col_meta['name'],
-                data_type=str(col_meta['type']),
-                is_nullable=col_meta.get('nullable', True),
-                is_pk=col_meta['name'] in pk_columns,
-                comment=col_meta.get('comment', '') or ""
-            ))
-        
-        return columns
-    
-    def get_foreign_keys_as_documents(self) -> List[ForeignKeyDocument]:
-        """Return foreign keys as document objects."""
-        inspector = inspect(self.engine)
-        all_foreign_keys = []
-        
-        for table_name in inspector.get_table_names():
-            fks = inspector.get_foreign_keys(table_name)
-            for fk in fks:
-                all_foreign_keys.append(ForeignKeyDocument(
-                    source_table_name=table_name,
-                    source_column_name=fk['constrained_columns'][0],
-                    target_table_name=fk['referred_table'],
-                    target_column_name=fk['referred_columns'][0],
-                    constraint_name=fk.get('name', '')
-                ))
-        
-        return all_foreign_keys
-    
-    def get_schemas_as_documents(self) -> List[SchemaDocument]:
-        """Return schemas as document objects."""
-        # MariaDB doesn't have explicit schemas like PostgreSQL
-        return [SchemaDocument(
-            schema_name="default",
-            comment="Default MariaDB schema"
-        )]
-    
-    def get_indexes_as_documents(self, table_name: Optional[str] = None) -> List[IndexDocument]:
-        """Return indexes as document objects."""
-        inspector = inspect(self.engine)
-        indexes = []
-        
-        tables = [table_name] if table_name else inspector.get_table_names()
-        
-        for tbl_name in tables:
-            try:
-                table_indexes = inspector.get_indexes(tbl_name)
-                for idx in table_indexes:
-                    indexes.append(IndexDocument(
-                        table_name=tbl_name,
-                        index_name=idx['name'],
-                        column_names=idx['column_names'],
-                        is_unique=idx['unique'],
-                        index_type="BTREE"  # Default for MariaDB
-                    ))
-            except SQLAlchemyError as e:
-                logger.warning(f"Could not get indexes for table {tbl_name}: {e}")
-        
-        return indexes
-    
-    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
-        """Get unique values from the database."""
-        # This is a placeholder implementation.
-        # A more sophisticated version like in ThothPgManager should be implemented.
-        return {}
-    
-    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
-        """Get example data (most frequent values) for each column in a table."""
-        inspector = inspect(self.engine)
-        try:
-            columns = inspector.get_columns(table_name)
-        except SQLAlchemyError as e:
-            logger.error(f"Error inspecting columns for table {table_name}: {e}")
-            raise e
-
-        if not columns:
-            logger.warning(f"No columns found for table {table_name}")
-            return {}
-
-        most_frequent_values: Dict[str, List[Any]] = {}
-        
-        with self.engine.connect() as connection:
-            for col_info in columns:
-                column_name = col_info['name']
-                # MariaDB uses backticks for identifier quoting (same as MySQL)
-                quoted_column_name = f'`{column_name}`'
-                quoted_table_name = f'`{table_name}`'
-
-                query_str = f"""
-                    SELECT {quoted_column_name}
-                    FROM (
-                        SELECT {quoted_column_name}, COUNT(*) as _freq
-                        FROM {quoted_table_name}
-                        WHERE {quoted_column_name} IS NOT NULL
-                        GROUP BY {quoted_column_name}
-                        ORDER BY _freq DESC
-                        LIMIT :num_rows
-                    ) as subquery;
-                """
-                try:
-                    result = connection.execute(text(query_str), {"num_rows": number_of_rows})
-                    values = [row[0] for row in result]
-                    most_frequent_values[column_name] = values
-                except SQLAlchemyError as e:
-                    logger.error(f"Error fetching frequent values for {column_name} in {table_name}: {e}")
-                    most_frequent_values[column_name] = []
-
-        # Normalize list lengths
-        max_length = 0
-        if most_frequent_values:
-            max_length = max(len(v) for v in most_frequent_values.values()) if most_frequent_values else 0
-        
-        for column_name in most_frequent_values:
-            current_len = len(most_frequent_values[column_name])
-            if current_len < max_length:
-                most_frequent_values[column_name].extend([None] * (max_length - current_len))
-                
-        return most_frequent_values
-
-
 @register_plugin("mariadb")
 class MariaDBPlugin(DbPlugin):
-    """MariaDB database plugin with full functionality."""
+    """MariaDB database plugin."""
     
     plugin_name = "MariaDB Plugin"
     plugin_version = "1.0.0"
@@ -315,11 +77,19 @@ class MariaDBPlugin(DbPlugin):
     
     def create_adapter(self, **kwargs) -> DbAdapter:
         """Create and return a MariaDB adapter instance."""
-        return MariaDBAdapter(kwargs)
+        # Map plugin parameters to adapter parameters
+        connection_params = {
+            'host': kwargs.get('host', 'localhost'),
+            'port': kwargs.get('port', 3307),
+            'database': kwargs.get('database') or kwargs.get('dbname'),
+            'user': kwargs.get('user') or kwargs.get('username'),
+            'password': kwargs.get('password')
+        }
+        return MariaDBAdapter(connection_params)
     
     def validate_connection_params(self, **kwargs) -> bool:
         """Validate connection parameters for MariaDB."""
-        required = ['host', 'port', 'user', 'password']
+        required = ['host', 'user', 'password']
         database = kwargs.get('database') or kwargs.get('dbname')
         
         if not database:
@@ -331,7 +101,7 @@ class MariaDBPlugin(DbPlugin):
                 logger.error(f"Missing required parameter: {param}")
                 return False
         
-        port = kwargs.get('port')
+        port = kwargs.get('port', 3307)
         if not isinstance(port, int) or not (1 <= port <= 65535):
             logger.error("port must be an integer between 1 and 65535")
             return False
@@ -341,8 +111,8 @@ class MariaDBPlugin(DbPlugin):
     def initialize(self, **kwargs) -> None:
         """Initialize the MariaDB plugin."""
         # Validate and extract parameters
-        self.host = kwargs.get('host')
-        self.port = kwargs.get('port', 3306)
+        self.host = kwargs.get('host', 'localhost')
+        self.port = kwargs.get('port', 3307)
         self.dbname = kwargs.get('database') or kwargs.get('dbname')
         self.user = kwargs.get('user') or kwargs.get('username')
         self.password = kwargs.get('password')
@@ -434,3 +204,13 @@ class MariaDBPlugin(DbPlugin):
             return self.adapter.get_example_data(table_name, number_of_rows)
         else:
             raise RuntimeError("Plugin not initialized")
+    
+    @classmethod
+    def get_required_parameters(cls) -> List[str]:
+        """Get list of required connection parameters."""
+        return ['host', 'port', 'database', 'user', 'password']
+    
+    @classmethod
+    def get_optional_parameters(cls) -> List[str]:
+        """Get list of optional connection parameters."""
+        return ['db_root_path', 'db_mode']

{thoth_dbmanager-0.5.2.dist-info → thoth_dbmanager-0.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.5.2
+Version: 0.5.8
 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
@@ -22,11 +22,11 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+License-File: LICENSE.md
 Requires-Dist: datasketch>=1.5.0
 Requires-Dist: tqdm>=4.60.0
 Requires-Dist: SQLAlchemy>=1.4.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: pandas>=1.3.0
 Requires-Dist: requests>=2.25.0
 Provides-Extra: postgresql
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgresql"
@@ -35,15 +35,10 @@ Requires-Dist: mariadb>=1.1.0; extra == "mariadb"
 Provides-Extra: sqlserver
 Requires-Dist: pyodbc>=4.0.0; extra == "sqlserver"
 Provides-Extra: sqlite
-Provides-Extra: embeddings
-Requires-Dist: sentence-transformers>=2.0.0; extra == "embeddings"
-Requires-Dist: numpy>=1.21.0; extra == "embeddings"
 Provides-Extra: all
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: mariadb>=1.1.0; extra == "all"
 Requires-Dist: pyodbc>=4.0.0; extra == "all"
-Requires-Dist: sentence-transformers>=2.0.0; extra == "all"
-Requires-Dist: numpy>=1.21.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{thoth_dbmanager-0.5.2.dist-info → thoth_dbmanager-0.5.8.dist-info}/RECORD

@@ -1,15 +1,15 @@
 thoth_dbmanager/ThothDbManager.py,sha256=q-jctgt3MJCDFzq6icQdP1oLeVy1ypg402F4ybxhG8c,8943
-thoth_dbmanager/__init__.py,sha256=Qrd9n7YYMkNKCFiIkzWbjKf5LNOkfp4TkebEpsKqt7E,1655
+thoth_dbmanager/__init__.py,sha256=tsW5bAgsXd4m2bZmcQZ5G8NHoSg-F4h1tiXwpXFAFXs,1655
 thoth_dbmanager/documents.py,sha256=z-f7zo_CZHqoGM0qHT8-lSUx4NhnMNZTSajpoFtRxn4,5051
 thoth_dbmanager/dynamic_imports.py,sha256=xDahgiqKvwSYqjPgHiQqD1XPhAbM_JqnU3OhBp2N-fc,7013
-thoth_dbmanager/adapters/__init__.py,sha256=Ua3ZjSOFlP9kVMFTiC6fyrpcv327b_mBimQ_4fnUsGY,318
-thoth_dbmanager/adapters/mariadb.py,sha256=LTsf0gORiwqZkd6WtKcOsYLHyDgysxdqNesBscbJwNs,5709
+thoth_dbmanager/adapters/__init__.py,sha256=5q15dASHBVqsoNj-l1t371VtfuBjhxDAhW68COYI6QI,999
+thoth_dbmanager/adapters/mariadb.py,sha256=PkFHUDism4X_P5W26NDsxdK2T_rmKlPHdwALOXWMExY,15301
 thoth_dbmanager/adapters/postgresql.py,sha256=qxdlxOV7Nvn8U4Lhat50w87Z2S8AzBfmLfEwKfz7dis,17299
 thoth_dbmanager/adapters/sqlite.py,sha256=RTDszgnAtkE14LKFeoe9lBHgsqXqkmDk6jDCTmVpnoM,14659
-thoth_dbmanager/adapters/sqlserver.py,sha256=V555kUH54Fb1Atow0BfvbSHmoSwGnrB_RJGn718VQSI,23880
+thoth_dbmanager/adapters/sqlserver.py,sha256=7RGZ3qQTJCfVyvjOj4jQ9G2NAD9vtmzcho4Dbi3is_o,24557
 thoth_dbmanager/core/__init__.py,sha256=FlqNW0GZNv1rnwNgyXGzveLqaw0Z90y5AKhR_1DvHBE,269
-thoth_dbmanager/core/factory.py,sha256=84EeZYRoH7y7b19EFHqN4X0CSA6dv-0yxUmlX2zHETk,8840
-thoth_dbmanager/core/interfaces.py,sha256=MRtNWvsXgtvK7_vdngSe8mNCM0hmRRHyTKnI78uxZ6o,13725
+thoth_dbmanager/core/factory.py,sha256=zPqyo2kVPvSsjKrzfyg5rEwqKpay6RmymQ1NZr15Onw,8958
+thoth_dbmanager/core/interfaces.py,sha256=s6t-8w4QWu_4Dl654LAU2p3Ao34wjeNaGEsUOJwYHaM,9575
 thoth_dbmanager/core/registry.py,sha256=url4qpQMoMw4rDrdAAvV6L7-NdO4z86xSJPSwTH_l5g,8624
 thoth_dbmanager/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thoth_dbmanager/helpers/multi_db_generator.py,sha256=frN0SZtWAfeojoJFLs4XLR3ri6h9pHYc-2O4aLAOlbo,23238
@@ -21,13 +21,14 @@ thoth_dbmanager/lsh/core.py,sha256=171FqHW7ItAqAPk6g_AoayKTE3Bs1rRZxnt55MJVzjY,6
 thoth_dbmanager/lsh/factory.py,sha256=2Bpkk-OygjaptZAw1yysxO1cxG3QTxmJ1yFGcXHqX3w,2411
 thoth_dbmanager/lsh/manager.py,sha256=LGrKbGKiBuISlNXaU4Yxfc_BqJfN27MaXapJbzEAjJQ,6513
 thoth_dbmanager/lsh/storage.py,sha256=qei6fwpmRCBSS8CRtDlnZCuWEmyuOK9gVSTkEJdX0eI,4543
-thoth_dbmanager/plugins/__init__.py,sha256=KiamB8UgZujwLUE8Q5suYgqC2i5VEAdmC1m0KF9GgvM,430
-thoth_dbmanager/plugins/mariadb.py,sha256=ElYa4Rexwrofcjcs0UQKan8fZpbU6-n9zghYR9SgRb4,17975
+thoth_dbmanager/plugins/__init__.py,sha256=J_ojrJNK1_xeAXbmk8UdiYfqG9vCoD6OI99QxajFM3E,1157
+thoth_dbmanager/plugins/mariadb.py,sha256=p4ey4_bfgAogLaM9lWgvFiWNrX-tElKSnnT0t6o-xo0,8212
 thoth_dbmanager/plugins/postgresql.py,sha256=pI1W9oHpQty8tHMoEDcsOT-Msv6S4aoFcArOGFxLR7Q,5518
 thoth_dbmanager/plugins/sqlite.py,sha256=gkgZ6-Vjkab0IP3ffHOg4bbpDHsjO_N4DesUnSDNAmQ,8857
 thoth_dbmanager/plugins/sqlserver.py,sha256=mMb3F5FmSWV02FZwj-Ult-2TjuyeVA4Fl1iME1dbgLU,5289
-thoth_dbmanager-0.5.2.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
-thoth_dbmanager-0.5.2.dist-info/METADATA,sha256=kjNeZj0QtbNG4zG1cynSzBGf9NYjSfPU3Bh6rNL99go,15032
-thoth_dbmanager-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thoth_dbmanager-0.5.2.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
-thoth_dbmanager-0.5.2.dist-info/RECORD,,
+thoth_dbmanager-0.5.8.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
+thoth_dbmanager-0.5.8.dist-info/licenses/LICENSE.md,sha256=TtKT2ej3GRki3W8FmSeYzRuQtZ1oMGWchpWykZ4vA7c,1070
+thoth_dbmanager-0.5.8.dist-info/METADATA,sha256=clF9gFLahTJJX9HxDYK8kiZgAsgKwoHwjV0qvhpdmOY,14777
+thoth_dbmanager-0.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thoth_dbmanager-0.5.8.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
+thoth_dbmanager-0.5.8.dist-info/RECORD,,

thoth_dbmanager-0.5.8.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marco Pancotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.