thoth-dbmanager 0.4.2__tar.gz → 0.4.3__tar.gz

{thoth_dbmanager-0.4.2/thoth_dbmanager.egg-info → thoth_dbmanager-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.4.2
+Version: 0.4.3
 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>
 License: MIT
@@ -28,6 +28,8 @@ 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"
 Provides-Extra: mysql
@@ -36,28 +38,24 @@ Provides-Extra: mariadb
 Requires-Dist: mariadb>=1.1.0; extra == "mariadb"
 Provides-Extra: sqlserver
 Requires-Dist: pyodbc>=4.0.0; extra == "sqlserver"
+Requires-Dist: pymssql>=2.3.0; extra == "sqlserver"
 Provides-Extra: oracle
 Requires-Dist: cx_Oracle>=8.3.0; extra == "oracle"
-Provides-Extra: informix
-Requires-Dist: informixdb>=2.2.0; extra == "informix"
+Requires-Dist: oracledb>=3.0.0; extra == "oracle"
 Provides-Extra: supabase
 Requires-Dist: supabase>=2.0.0; extra == "supabase"
-Requires-Dist: postgrest-py>=0.16.0; extra == "supabase"
-Requires-Dist: gotrue-py>=2.0.0; extra == "supabase"
+Requires-Dist: postgrest-py>=0.10.0; extra == "supabase"
+Requires-Dist: gotrue-py>=1.0.0; extra == "supabase"
 Provides-Extra: sqlite
-Provides-Extra: qdrant
-Requires-Dist: qdrant-client>=1.7.0; extra == "qdrant"
 Provides-Extra: all
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: mysql-connector-python>=8.0.0; extra == "all"
 Requires-Dist: mariadb>=1.1.0; extra == "all"
 Requires-Dist: pyodbc>=4.0.0; extra == "all"
+Requires-Dist: pymssql>=2.3.0; extra == "all"
 Requires-Dist: cx_Oracle>=8.3.0; extra == "all"
-Requires-Dist: informixdb>=2.2.0; extra == "all"
+Requires-Dist: oracledb>=3.0.0; extra == "all"
 Requires-Dist: supabase>=2.0.0; extra == "all"
-Requires-Dist: postgrest-py>=0.16.0; extra == "all"
-Requires-Dist: gotrue-py>=2.0.0; extra == "all"
-Requires-Dist: qdrant-client>=1.7.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -65,6 +63,10 @@ Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: flake8>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: psutil>=5.8.0; extra == "dev"
+Requires-Dist: docker>=6.0.0; extra == "dev"
 Provides-Extra: test-postgresql
 Requires-Dist: pytest>=7.0.0; extra == "test-postgresql"
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "test-postgresql"

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "thoth_dbmanager"
-version = "0.4.2"
+version = "0.4.3"
 authors = [
   { name="Marco Pancotti", email="mp@tylconsulting.it" },
 ]
@@ -30,43 +30,44 @@ classifiers = [
 dependencies = [
     "datasketch>=1.5.0",
     "tqdm>=4.60.0",
-    "SQLAlchemy>=1.4.0",
+    "SQLAlchemy>=1.4.0", 
     "pydantic>=2.0.0",
+    "pandas>=1.3.0",
+    "requests>=2.25.0",
 ]
-
 [project.optional-dependencies]
 postgresql = ["psycopg2-binary>=2.9.0"]
 mysql = ["mysql-connector-python>=8.0.0"]
 mariadb = ["mariadb>=1.1.0"]
-sqlserver = ["pyodbc>=4.0.0"]
-oracle = ["cx_Oracle>=8.3.0"]
-informix = ["informixdb>=2.2.0"]
-supabase = ["supabase>=2.0.0", "postgrest-py>=0.16.0", "gotrue-py>=2.0.0"]
-sqlite = []  # Built into Python
-qdrant = ["qdrant-client>=1.7.0"]
+sqlserver = ["pyodbc>=4.0.0", "pymssql>=2.3.0"]
+oracle = ["cx_Oracle>=8.3.0", "oracledb>=3.0.0"]
+supabase = ["supabase>=2.0.0", "postgrest-py>=0.10.0", "gotrue-py>=1.0.0"]
+sqlite = []
 
 # Convenience groups
 all = [
     "psycopg2-binary>=2.9.0",
-    "mysql-connector-python>=8.0.0",
+    "mysql-connector-python>=8.0.0", 
     "mariadb>=1.1.0",
     "pyodbc>=4.0.0",
+    "pymssql>=2.3.0",
     "cx_Oracle>=8.3.0",
-    "informixdb>=2.2.0",
+    "oracledb>=3.0.0",
     "supabase>=2.0.0",
-    "postgrest-py>=0.16.0",
-    "gotrue-py>=2.0.0",
-    "qdrant-client>=1.7.0"
 ]
 
 # Development dependencies
 dev = [
-    "pytest>=7.0.0", 
+    "pytest>=7.0.0",
     "pytest-cov>=4.0.0", 
-    "black>=22.0.0", 
+    "black>=22.0.0",
     "flake8>=5.0.0",
     "mypy>=1.0.0",
-    "pre-commit>=3.0.0"
+    "pre-commit>=3.0.0",
+    "build>=1.0.0",
+    "twine>=4.0.0",
+    "psutil>=5.8.0",  # Add this for system resource monitoring
+    "docker>=6.0.0",  # Add this for Docker management in tests
 ]
 
 # Testing with specific databases

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/tests/test_thoth_sqlite_manager.py

@@ -3,7 +3,7 @@ import os
 import logging
 from pathlib import Path
 
-from dbmanager.impl.ThothSqliteManager import ThothSqliteManager
+from thoth_dbmanager import ThothSqliteManager
 
 # Configure logging
 logging.basicConfig(level=logging.INFO,
@@ -47,7 +47,7 @@ class TestThothSqliteManager(unittest.TestCase):
         try:
             cls.db_manager = ThothSqliteManager.get_instance(
                 db_id=cls.db_id,
-                db_root_path="data",
+                db_root_path=cls.db_root_path,
                 db_mode=cls.db_mode
             )
             logger.info("Successfully connected to california_schools SQLite database")
@@ -59,7 +59,7 @@ class TestThothSqliteManager(unittest.TestCase):
         """Test that get_instance returns the same instance for same parameters."""
         second_instance = ThothSqliteManager.get_instance(
             db_id=self.db_id,
-            db_root_path="data",
+            db_root_path=self.db_root_path,
             db_mode=self.db_mode
         )
 
@@ -71,7 +71,7 @@ class TestThothSqliteManager(unittest.TestCase):
         # Using a different db_mode should create a new instance
         different_instance = ThothSqliteManager.get_instance(
             db_id=self.db_id,
-            db_root_path="data",
+            db_root_path=self.db_root_path,
             db_mode="different_mode"
         )
 
@@ -200,41 +200,58 @@ class TestThothSqliteManager(unittest.TestCase):
 
     def test_transaction_rollback(self):
         """Test transaction rollback on error."""
-        # First, create a temporary table
-        create_table_sql = """CREATE TABLE IF NOT EXISTS test_rollback (
+        # First, clean up any existing test table
+        cleanup_sql = "DROP TABLE IF EXISTS test_rollback"
+        try:
+            self.db_manager.execute_sql(cleanup_sql, fetch=None)
+        except:
+            pass  # Ignore if table doesn't exist
+
+        # Create a temporary table
+        create_table_sql = """CREATE TABLE test_rollback (
                                 id INTEGER PRIMARY KEY,
                                 name TEXT
                             )"""
 
         try:
-            self.db_manager.execute_sql(create_table_sql)
+            # Create the table (use fetch=None to avoid fetchall() on non-SELECT)
+            create_result = self.db_manager.execute_sql(create_table_sql, fetch=None)
+            logger.info(f"Table creation result: {create_result}")
 
-            # Insert a valid row
+            # Insert a valid row (use fetch=None to avoid fetchall() on non-SELECT)
             insert_sql = """INSERT INTO test_rollback (name) VALUES ('test_value')"""
-            self.db_manager.execute_sql(insert_sql)
+            insert_result = self.db_manager.execute_sql(insert_sql, fetch=None)
+            logger.info(f"Insert result: {insert_result}")
 
-            # Try an invalid insert that should cause a rollback
+            # Try an invalid insert that should cause an error
             invalid_insert = """INSERT INTO test_rollback (non_existent_column) VALUES ('test')"""
 
             with self.assertRaises(Exception):
-                self.db_manager.execute_sql(invalid_insert)
+                self.db_manager.execute_sql(invalid_insert, fetch=None)
 
             # Check that the valid insert was committed (SQLite behavior differs from PostgreSQL)
-            count_sql = """SELECT COUNT(*) as row_count FROM test_rollback"""
-            result = self.db_manager.execute_sql(count_sql, fetch="one")
+            count_sql = """SELECT COUNT(*) as count FROM test_rollback"""
+            result = self.db_manager.execute_sql(count_sql)
 
             # In SQLite, each statement is its own transaction by default,
             # so the first INSERT should still be there
-            self.assertEqual(result['row_count'], 1,
-                             "Valid insert should be committed")
+            # Legacy manager returns list of dictionaries
+            self.assertIsNotNone(result, "Count result should not be None")
+            self.assertIsInstance(result, list, "Result should be a list")
+            self.assertEqual(len(result), 1, "Should have one result row")
+            self.assertEqual(result[0]['count'], 1, "Valid insert should be committed")
 
-            # Clean up - drop the test table
-            cleanup_sql = "DROP TABLE IF EXISTS test_rollback"
-            self.db_manager.execute_sql(cleanup_sql)
+            logger.info("Transaction rollback test completed successfully")
 
         except Exception as e:
-            logger.warning(f"Transaction test failed: {str(e)}")
-            self.skipTest(f"Skipping transaction test: {str(e)}")
+            logger.error(f"Transaction test failed: {str(e)}")
+            raise
+        finally:
+            # Clean up - drop the test table
+            try:
+                self.db_manager.execute_sql("DROP TABLE IF EXISTS test_rollback", fetch=None)
+            except Exception as cleanup_error:
+                logger.warning(f"Cleanup failed: {cleanup_error}")
 
     def test_database_file_exists(self):
         """Test that the database file exists at the expected location."""
@@ -250,69 +267,116 @@ class TestThothSqliteManager(unittest.TestCase):
 
     def test_data_types(self):
         """Test handling of different data types in SQLite."""
-        # First, get a table to work with
-        tables_sql = """SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"""
+        # Create a test table with various data types
+        create_table_sql = """CREATE TABLE IF NOT EXISTS test_data_types (
+                                id INTEGER PRIMARY KEY,
+                                text_col TEXT,
+                                integer_col INTEGER,
+                                real_col REAL,
+                                blob_col BLOB,
+                                null_col TEXT
+                            )"""
 
-        tables = self.db_manager.execute_sql(tables_sql)
-        if not tables:
-            self.skipTest("No tables available to test data types")
+        try:
+            # Create the table
+            self.db_manager.execute_sql(create_table_sql, fetch=None)
 
-        sample_table = tables[0]['name']
+            # Insert test data with various types
+            insert_sql = """INSERT INTO test_data_types
+                           (text_col, integer_col, real_col, blob_col, null_col)
+                           VALUES ('test_string', 42, 3.14159, 'binary_data', NULL)"""
+            self.db_manager.execute_sql(insert_sql, fetch=None)
 
-        # Get column information including data types
-        columns_sql = f"PRAGMA table_info({sample_table})"
+            # Get column information including data types
+            columns_sql = "PRAGMA table_info(test_data_types)"
+            columns = self.db_manager.execute_sql(columns_sql)
 
-        columns = self.db_manager.execute_sql(columns_sql)
+            # Log column types for the test table
+            column_types = {col['name']: col['type'] for col in columns}
+            logger.info(f"Column types in test_data_types: {column_types}")
 
-        # Log column types for the sample table
-        column_types = {col['name']: col['type'] for col in columns}
-        logger.info(f"Column types in {sample_table}: {column_types}")
+            # Test a query that returns different data types
+            query_sql = "SELECT * FROM test_data_types LIMIT 1"
+            result = self.db_manager.execute_sql(query_sql, fetch="one")
 
-        # Test a query that returns different data types
-        query_sql = f"SELECT * FROM {sample_table} LIMIT 1"
+            if result:
+                # Log the types of values returned
+                value_types = {key: type(value).__name__ for key, value in result.items()}
+                logger.info(f"Value types in result: {value_types}")
 
-        result = self.db_manager.execute_sql(query_sql, fetch="one")
+                # Verify that we can access the values
+                for key, value in result.items():
+                    self.assertIsNotNone(key, "Column name should not be None")
+                    # Value can be None, so we don't assert on that
 
-        if result:
-            # Log the types of values returned
-            value_types = {key: type(value).__name__ for key, value in result.items()}
-            logger.info(f"Value types in result: {value_types}")
+                # Test specific data type handling
+                self.assertEqual(result['text_col'], 'test_string')
+                self.assertEqual(result['integer_col'], 42)
+                self.assertAlmostEqual(result['real_col'], 3.14159, places=5)
+                self.assertIsNone(result['null_col'])
 
-            # Verify that we can access the values
-            for key, value in result.items():
-                self.assertIsNotNone(key, "Column name should not be None")
-                # Value can be None, so we don't assert on that
+            # Clean up
+            self.db_manager.execute_sql("DROP TABLE IF EXISTS test_data_types", fetch=None)
+
+        except Exception as e:
+            logger.error(f"Data types test failed: {str(e)}")
+            # Clean up on error
+            try:
+                self.db_manager.execute_sql("DROP TABLE IF EXISTS test_data_types", fetch=None)
+            except:
+                pass
+            raise
 
     def test_large_result_set(self):
         """Test handling of larger result sets."""
-        # First, get a table to work with
-        tables_sql = """SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"""
-
-        tables = self.db_manager.execute_sql(tables_sql)
-        if not tables:
-            self.skipTest("No tables available to test large result sets")
-
-        sample_table = tables[0]['name']
-
-        # Get row count for the sample table
-        count_sql = f"SELECT COUNT(*) as row_count FROM {sample_table}"
-
-        count_result = self.db_manager.execute_sql(count_sql, fetch="one")
-        row_count = count_result['row_count']
-
-        logger.info(f"Table {sample_table} has {row_count} rows")
-
-        if row_count < 10:
-            self.skipTest(f"Table {sample_table} has too few rows ({row_count}) to test large result sets")
+        # Create a test table with sufficient data
+        create_table_sql = """CREATE TABLE IF NOT EXISTS test_large_data (
+                                id INTEGER PRIMARY KEY,
+                                name TEXT,
+                                value INTEGER
+                            )"""
 
-        # Test fetching a larger number of rows
-        query_sql = f"SELECT * FROM {sample_table} LIMIT 100"
+        try:
+            self.db_manager.execute_sql(create_table_sql, fetch=None)
+
+            # Insert multiple rows to create a larger dataset
+            # Insert 50 rows of test data
+            for i in range(50):
+                # Use fetch=None for INSERT statements
+                self.db_manager.execute_sql(
+                    f"INSERT INTO test_large_data (name, value) VALUES ('test_name_{i}', {i})",
+                    fetch=None
+                )
+
+            # Test fetching all rows
+            query_sql = "SELECT * FROM test_large_data"
+            result = self.db_manager.execute_sql(query_sql)
+
+            self.assertIsNotNone(result, "Query result should not be None")
+            self.assertIsInstance(result, list, "Result should be a list")
+            self.assertEqual(len(result), 50, "Should have 50 rows")
+            logger.info(f"Successfully fetched {len(result)} rows from test_large_data")
+
+            # Test fetching with LIMIT
+            limit_query_sql = "SELECT * FROM test_large_data LIMIT 25"
+            limit_result = self.db_manager.execute_sql(limit_query_sql)
+
+            self.assertIsNotNone(limit_result, "Limited query result should not be None")
+            self.assertIsInstance(limit_result, list, "Limited result should be a list")
+            self.assertEqual(len(limit_result), 25, "Should have 25 rows with LIMIT")
 
-        result = self.db_manager.execute_sql(query_sql)
+            # Clean up - drop the test table
+            cleanup_sql = "DROP TABLE IF EXISTS test_large_data"
+            self.db_manager.execute_sql(cleanup_sql, fetch=None)
 
-        self.assertIsNotNone(result, "Query result should not be None")
-        self.assertIsInstance(result, list, "Result should be a list")
-        logger.info(f"Successfully fetched {len(result)} rows from {sample_table}")
+        except Exception as e:
+            logger.error(f"Large result set test failed: {str(e)}")
+            # Clean up on error
+            try:
+                self.db_manager.execute_sql("DROP TABLE IF EXISTS test_large_data", fetch=None)
+            except:
+                pass
+            raise
 
     @classmethod
     def tearDownClass(cls):

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/thoth_dbmanager/__init__.py

@@ -43,7 +43,6 @@ from .dynamic_imports import (
     import_sqlserver,
     import_oracle,
     import_mariadb,
-    import_informix,
     import_supabase,
 )
 
@@ -62,8 +61,6 @@ def __getattr__(name: str):
         return import_manager('sqlserver')
     elif name == 'ThothOracleManager':
         return import_manager('oracle')
-    elif name == 'ThothInformixManager':
-        return import_manager('informix')
     elif name == 'ThothSupabaseManager':
         return import_manager('supabase')
     
@@ -79,7 +76,6 @@ __all__ = [
     "ThothMariaDbManager",
     "ThothSqlServerManager",
     "ThothOracleManager",
-    "ThothInformixManager",
     "ThothSupabaseManager",
     
     # New architecture
@@ -106,7 +102,6 @@ __all__ = [
     "MariaDBPlugin",
     "SQLServerPlugin",
     "OraclePlugin",
-    "InformixPlugin",
     "SupabasePlugin",
     
     # Adapters
@@ -116,7 +111,6 @@ __all__ = [
     "MariaDBAdapter",
     "SQLServerAdapter",
     "OracleAdapter",
-    "InformixAdapter",
     "SupabaseAdapter",
     
     # LSH functionality
@@ -133,4 +127,4 @@ __all__ = [
     "DatabaseImportError",
 ]
 
-__version__ = "0.4.0"
+__version__ = "0.4.3"

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/thoth_dbmanager/dynamic_imports.py

@@ -14,45 +14,32 @@ DATABASE_DEPENDENCIES = {
     'mariadb': ['mariadb'],
     'sqlserver': ['pyodbc'],
     'oracle': ['cx_Oracle'],
-    'informix': ['informixdb'],
     'supabase': ['supabase', 'postgrest', 'gotrue'],
     'sqlite': [],  # Built into Python
 }
 
-# Mapping of database names to their manager classes
-DATABASE_MANAGERS = {
-    'postgresql': 'dbmanager.impl.ThothPgManager.ThothPgManager',
-    'mysql': 'dbmanager.impl.ThothMySqlManager.ThothMySqlManager',
-    'mariadb': 'dbmanager.impl.ThothMariaDbManager.ThothMariaDbManager',
-    'sqlserver': 'dbmanager.impl.ThothSqlServerManager.ThothSqlServerManager',
-    'oracle': 'dbmanager.impl.ThothOracleManager.ThothOracleManager',
-    'informix': 'dbmanager.impl.ThothInformixManager.ThothInformixManager',
-    'supabase': 'dbmanager.impl.ThothSupabaseManager.ThothSupabaseManager',
-    'sqlite': 'dbmanager.impl.ThothSqliteManager.ThothSqliteManager',
-}
+# Note: DATABASE_MANAGERS is no longer used - managers are created via factory pattern
 
 # Mapping of database names to their adapter classes
 DATABASE_ADAPTERS = {
-    'postgresql': 'dbmanager.adapters.postgresql.PostgreSQLAdapter',
-    'mysql': 'dbmanager.adapters.mysql.MySQLAdapter',
-    'mariadb': 'dbmanager.adapters.mariadb.MariaDBAdapter',
-    'sqlserver': 'dbmanager.adapters.sqlserver.SQLServerAdapter',
-    'oracle': 'dbmanager.adapters.oracle.OracleAdapter',
-    'informix': 'dbmanager.adapters.informix.InformixAdapter',
-    'supabase': 'dbmanager.adapters.supabase.SupabaseAdapter',
-    'sqlite': 'dbmanager.adapters.sqlite.SQLiteAdapter',
+    'postgresql': 'thoth_dbmanager.adapters.postgresql.PostgreSQLAdapter',
+    'mysql': 'thoth_dbmanager.adapters.mysql.MySQLAdapter',
+    'mariadb': 'thoth_dbmanager.adapters.mariadb.MariaDBAdapter',
+    'sqlserver': 'thoth_dbmanager.adapters.sqlserver.SQLServerAdapter',
+    'oracle': 'thoth_dbmanager.adapters.oracle.OracleAdapter',
+    'supabase': 'thoth_dbmanager.adapters.supabase.SupabaseAdapter',
+    'sqlite': 'thoth_dbmanager.adapters.sqlite.SQLiteAdapter',
 }
 
 # Mapping of database names to their plugin classes
 DATABASE_PLUGINS = {
-    'postgresql': 'dbmanager.plugins.postgresql.PostgreSQLPlugin',
-    'mysql': 'dbmanager.plugins.mysql.MySQLPlugin',
-    'mariadb': 'dbmanager.plugins.mariadb.MariaDBPlugin',
-    'sqlserver': 'dbmanager.plugins.sqlserver.SQLServerPlugin',
-    'oracle': 'dbmanager.plugins.oracle.OraclePlugin',
-    'informix': 'dbmanager.plugins.informix.InformixPlugin',
-    'supabase': 'dbmanager.plugins.supabase.SupabasePlugin',
-    'sqlite': 'dbmanager.plugins.sqlite.SQLitePlugin',
+    'postgresql': 'thoth_dbmanager.plugins.postgresql.PostgreSQLPlugin',
+    'mysql': 'thoth_dbmanager.plugins.mysql.MySQLPlugin',
+    'mariadb': 'thoth_dbmanager.plugins.mariadb.MariaDBPlugin',
+    'sqlserver': 'thoth_dbmanager.plugins.sqlserver.SQLServerPlugin',
+    'oracle': 'thoth_dbmanager.plugins.oracle.OraclePlugin',
+    'supabase': 'thoth_dbmanager.plugins.supabase.SupabasePlugin',
+    'sqlite': 'thoth_dbmanager.plugins.sqlite.SQLitePlugin',
 }
 
 
@@ -93,30 +80,39 @@ def check_dependencies(database: str) -> List[str]:
 
 def import_manager(database: str) -> Any:
     """
-    Dynamically import a database manager class.
-    
+    Dynamically import a database manager using the factory pattern.
+
     Args:
         database: Name of the database
-        
+
     Returns:
-        The database manager class
-        
+        The database manager class (factory-created)
+
     Raises:
         DatabaseImportError: If dependencies are missing
         ImportError: If the manager class cannot be imported
     """
-    if database not in DATABASE_MANAGERS:
+    if database not in DATABASE_PLUGINS:
         raise ValueError(f"Unknown database: {database}")
-    
+
     # Check dependencies
     missing_deps = check_dependencies(database)
     if missing_deps:
         raise DatabaseImportError(database, missing_deps)
-    
-    # Import the manager class
-    module_path, class_name = DATABASE_MANAGERS[database].rsplit('.', 1)
-    module = importlib.import_module(module_path)
-    return getattr(module, class_name)
+
+    # Import the factory and create a manager class
+    from thoth_dbmanager.core.factory import ThothDbFactory
+
+    # Create a wrapper class that can be instantiated like the old managers
+    class DatabaseManagerWrapper:
+        def __init__(self, *args, **kwargs):
+            # Create manager using factory
+            self._manager = ThothDbFactory.create_manager(database, *args, **kwargs)
+
+        def __getattr__(self, name):
+            return getattr(self._manager, name)
+
+    return DatabaseManagerWrapper
 
 
 def import_adapter(database: str) -> Any:
@@ -241,10 +237,6 @@ def import_mariadb():
     """Import MariaDB components."""
     return import_database_components(['mariadb'])['mariadb']
 
-def import_informix():
-    """Import Informix components."""
-    return import_database_components(['informix'])['informix']
-
 def import_supabase():
     """Import Supabase components."""
     return import_database_components(['supabase'])['supabase']

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3/thoth_dbmanager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.4.2
+Version: 0.4.3
 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>
 License: MIT
@@ -28,6 +28,8 @@ 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"
 Provides-Extra: mysql
@@ -36,28 +38,24 @@ Provides-Extra: mariadb
 Requires-Dist: mariadb>=1.1.0; extra == "mariadb"
 Provides-Extra: sqlserver
 Requires-Dist: pyodbc>=4.0.0; extra == "sqlserver"
+Requires-Dist: pymssql>=2.3.0; extra == "sqlserver"
 Provides-Extra: oracle
 Requires-Dist: cx_Oracle>=8.3.0; extra == "oracle"
-Provides-Extra: informix
-Requires-Dist: informixdb>=2.2.0; extra == "informix"
+Requires-Dist: oracledb>=3.0.0; extra == "oracle"
 Provides-Extra: supabase
 Requires-Dist: supabase>=2.0.0; extra == "supabase"
-Requires-Dist: postgrest-py>=0.16.0; extra == "supabase"
-Requires-Dist: gotrue-py>=2.0.0; extra == "supabase"
+Requires-Dist: postgrest-py>=0.10.0; extra == "supabase"
+Requires-Dist: gotrue-py>=1.0.0; extra == "supabase"
 Provides-Extra: sqlite
-Provides-Extra: qdrant
-Requires-Dist: qdrant-client>=1.7.0; extra == "qdrant"
 Provides-Extra: all
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: mysql-connector-python>=8.0.0; extra == "all"
 Requires-Dist: mariadb>=1.1.0; extra == "all"
 Requires-Dist: pyodbc>=4.0.0; extra == "all"
+Requires-Dist: pymssql>=2.3.0; extra == "all"
 Requires-Dist: cx_Oracle>=8.3.0; extra == "all"
-Requires-Dist: informixdb>=2.2.0; extra == "all"
+Requires-Dist: oracledb>=3.0.0; extra == "all"
 Requires-Dist: supabase>=2.0.0; extra == "all"
-Requires-Dist: postgrest-py>=0.16.0; extra == "all"
-Requires-Dist: gotrue-py>=2.0.0; extra == "all"
-Requires-Dist: qdrant-client>=1.7.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -65,6 +63,10 @@ Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: flake8>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: psutil>=5.8.0; extra == "dev"
+Requires-Dist: docker>=6.0.0; extra == "dev"
 Provides-Extra: test-postgresql
 Requires-Dist: pytest>=7.0.0; extra == "test-postgresql"
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "test-postgresql"

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/thoth_dbmanager.egg-info/SOURCES.txt

@@ -29,7 +29,6 @@ thoth_dbmanager/adapters/mariadb.py
 thoth_dbmanager/adapters/mysql.py
 thoth_dbmanager/adapters/oracle.py
 thoth_dbmanager/adapters/postgresql.py
-thoth_dbmanager/adapters/qdrant.py
 thoth_dbmanager/adapters/sqlite.py
 thoth_dbmanager/adapters/sqlserver.py
 thoth_dbmanager/adapters/supabase.py
@@ -52,7 +51,6 @@ thoth_dbmanager/plugins/mariadb.py
 thoth_dbmanager/plugins/mysql.py
 thoth_dbmanager/plugins/oracle.py
 thoth_dbmanager/plugins/postgresql.py
-thoth_dbmanager/plugins/qdrant.py
 thoth_dbmanager/plugins/sqlite.py
 thoth_dbmanager/plugins/sqlserver.py
 thoth_dbmanager/plugins/supabase.py

{thoth_dbmanager-0.4.2 → thoth_dbmanager-0.4.3}/thoth_dbmanager.egg-info/requires.txt

@@ -2,18 +2,18 @@ datasketch>=1.5.0
 tqdm>=4.60.0
 SQLAlchemy>=1.4.0
 pydantic>=2.0.0
+pandas>=1.3.0
+requests>=2.25.0
 
 [all]
 psycopg2-binary>=2.9.0
 mysql-connector-python>=8.0.0
 mariadb>=1.1.0
 pyodbc>=4.0.0
+pymssql>=2.3.0
 cx_Oracle>=8.3.0
-informixdb>=2.2.0
+oracledb>=3.0.0
 supabase>=2.0.0
-postgrest-py>=0.16.0
-gotrue-py>=2.0.0
-qdrant-client>=1.7.0
 
 [dev]
 pytest>=7.0.0
@@ -22,9 +22,10 @@ black>=22.0.0
 flake8>=5.0.0
 mypy>=1.0.0
 pre-commit>=3.0.0
-
-[informix]
-informixdb>=2.2.0
+build>=1.0.0
+twine>=4.0.0
+psutil>=5.8.0
+docker>=6.0.0
 
 [mariadb]
 mariadb>=1.1.0
@@ -34,22 +35,21 @@ mysql-connector-python>=8.0.0
 
 [oracle]
 cx_Oracle>=8.3.0
+oracledb>=3.0.0
 
 [postgresql]
 psycopg2-binary>=2.9.0
 
-[qdrant]
-qdrant-client>=1.7.0
-
 [sqlite]
 
 [sqlserver]
 pyodbc>=4.0.0
+pymssql>=2.3.0
 
 [supabase]
 supabase>=2.0.0
-postgrest-py>=0.16.0
-gotrue-py>=2.0.0
+postgrest-py>=0.10.0
+gotrue-py>=1.0.0
 
 [test-mysql]
 pytest>=7.0.0

thoth_dbmanager-0.4.2/thoth_dbmanager/adapters/qdrant.py

@@ -1,189 +0,0 @@
-"""
-Qdrant adapter for Thoth SQL Database Manager.
-"""
-
-from typing import Any, Dict, List, Optional, Union
-from ..core.interfaces import DbAdapter
-
-
-class QdrantAdapter(DbAdapter):
-    """
-    Qdrant vector database adapter implementation.
-    """
-    
-    def __init__(self, **kwargs):
-        """Initialize Qdrant adapter with connection parameters."""
-        super().__init__()
-        self.host = kwargs.get('host', 'localhost')
-        self.port = kwargs.get('port', 6333)
-        self.api_key = kwargs.get('api_key')
-        self.collection_name = kwargs.get('collection_name', 'thoth_documents')
-        self._client = None
-    
-    def connect(self) -> bool:
-        """Establish connection to Qdrant."""
-        try:
-            # Import qdrant_client here to avoid dependency issues
-            from qdrant_client import QdrantClient
-            
-            if self.api_key:
-                self._client = QdrantClient(
-                    host=self.host,
-                    port=self.port,
-                    api_key=self.api_key
-                )
-            else:
-                self._client = QdrantClient(
-                    host=self.host,
-                    port=self.port
-                )
-            
-            # Test connection
-            self._client.get_collections()
-            return True
-        except Exception as e:
-            print(f"Failed to connect to Qdrant: {e}")
-            return False
-    
-    def disconnect(self) -> None:
-        """Disconnect from Qdrant."""
-        if self._client:
-            self._client.close()
-            self._client = None
-    
-    def execute_query(self, query: str, params: Optional[Dict] = None, 
-                     fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """
-        Execute a query against Qdrant.
-        Note: Qdrant doesn't use SQL, so this adapts the interface.
-        """
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        # This is a placeholder - adapt based on your specific needs
-        # Qdrant uses vector search, not SQL queries
-        return {"message": "Qdrant uses vector search, not SQL queries"}
-    
-    def get_tables(self) -> List[Dict[str, str]]:
-        """Get collections (equivalent to tables in Qdrant)."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        try:
-            collections = self._client.get_collections()
-            return [
-                {
-                    "table_name": collection.name,
-                    "table_type": "COLLECTION"
-                }
-                for collection in collections.collections
-            ]
-        except Exception as e:
-            print(f"Error getting collections: {e}")
-            return []
-    
-    def get_columns(self, table_name: str) -> List[Dict[str, Any]]:
-        """Get collection info (equivalent to columns in Qdrant)."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        try:
-            collection_info = self._client.get_collection(table_name)
-            return [
-                {
-                    "column_name": "id",
-                    "data_type": "UUID",
-                    "is_nullable": False
-                },
-                {
-                    "column_name": "vector",
-                    "data_type": f"VECTOR({collection_info.config.params.vectors.size})",
-                    "is_nullable": False
-                },
-                {
-                    "column_name": "payload",
-                    "data_type": "JSON",
-                    "is_nullable": True
-                }
-            ]
-        except Exception as e:
-            print(f"Error getting collection info: {e}")
-            return []
-    
-    def get_foreign_keys(self) -> List[Dict[str, str]]:
-        """Get foreign keys (not applicable for Qdrant)."""
-        return []
-    
-    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
-        """Get unique values from collections."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        # This is a simplified implementation
-        # In practice, you'd need to scroll through points and extract unique payload values
-        return {}
-    
-    def add_documentation(self, doc_type: str, content: Dict[str, Any]) -> str:
-        """Add documentation to Qdrant collection."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        try:
-            from qdrant_client.models import PointStruct
-            import uuid
-            
-            # Generate a unique ID for the document
-            doc_id = str(uuid.uuid4())
-            
-            # Create a point with the documentation content
-            point = PointStruct(
-                id=doc_id,
-                vector=content.get('vector', [0.0] * 384),  # Default vector size
-                payload={
-                    "doc_type": doc_type,
-                    "content": content
-                }
-            )
-            
-            # Upsert the point
-            self._client.upsert(
-                collection_name=self.collection_name,
-                points=[point]
-            )
-            
-            return doc_id
-        except Exception as e:
-            print(f"Error adding documentation: {e}")
-            raise
-    
-    def delete_collection(self, collection_name: str) -> bool:
-        """Delete a collection from Qdrant."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        try:
-            self._client.delete_collection(collection_name)
-            return True
-        except Exception as e:
-            print(f"Error deleting collection: {e}")
-            return False
-    
-    def create_collection(self, collection_name: str, vector_size: int = 384) -> bool:
-        """Create a new collection in Qdrant."""
-        if not self._client:
-            raise RuntimeError("Not connected to Qdrant")
-        
-        try:
-            from qdrant_client.models import VectorParams, Distance
-            
-            self._client.create_collection(
-                collection_name=collection_name,
-                vectors_config=VectorParams(
-                    size=vector_size,
-                    distance=Distance.COSINE
-                )
-            )
-            return True
-        except Exception as e:
-            print(f"Error creating collection: {e}")
-            return False

thoth_dbmanager-0.4.2/thoth_dbmanager/plugins/qdrant.py

@@ -1,41 +0,0 @@
-"""
-Qdrant plugin for Thoth SQL Database Manager.
-"""
-
-from typing import List
-from ..core.interfaces import DbPlugin
-from ..adapters.qdrant import QdrantAdapter
-
-
-class QdrantPlugin(DbPlugin):
-    """Plugin for Qdrant vector database."""
-    
-    plugin_name = "qdrant"
-    plugin_version = "1.0.0"
-    supported_db_types = ["qdrant"]
-    required_dependencies = ["qdrant-client"]
-    
-    def create_adapter(self, **kwargs) -> QdrantAdapter:
-        """Create and return a QdrantAdapter instance."""
-        return QdrantAdapter(**kwargs)
-    
-    def validate_connection_params(self, **kwargs) -> bool:
-        """Validate Qdrant connection parameters."""
-        required_params = ['host']
-        
-        for param in required_params:
-            if param not in kwargs:
-                return False
-        
-        # Validate host format
-        host = kwargs.get('host')
-        if not isinstance(host, str) or not host.strip():
-            return False
-        
-        # Validate port if provided
-        port = kwargs.get('port')
-        if port is not None:
-            if not isinstance(port, int) or port <= 0 or port > 65535:
-                return False
-        
-        return True