thoth-dbmanager 0.4.12__py3-none-any.whl → 0.5.0__py3-none-any.whl

thoth_dbmanager/ThothDbManager.py

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

thoth_dbmanager/__init__.py

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

thoth_dbmanager/core/registry.py

@@ -16,6 +16,7 @@ class DbPluginRegistry:
     
     _plugins: Dict[str, Type[DbPlugin]] = {}
     _instances: Dict[tuple, DbPlugin] = {}  # Singleton instances
+    _registered_plugins: set = set()  # Track already registered plugins to avoid spam
     
     @classmethod
     def register(cls, db_type: str, plugin_class: Type[DbPlugin]) -> None:
@@ -29,7 +30,15 @@ class DbPluginRegistry:
         if not issubclass(plugin_class, DbPlugin):
             raise TypeError(f"Plugin class {plugin_class.__name__} must inherit from DbPlugin")
         
+        # Check if plugin is already registered to avoid spam logs
+        plugin_key = f"{db_type}:{plugin_class.__name__}"
+        if plugin_key in cls._registered_plugins:
+            # Plugin already registered, don't log again
+            cls._plugins[db_type] = plugin_class
+            return
+        
         cls._plugins[db_type] = plugin_class
+        cls._registered_plugins.add(plugin_key)
         logger.info(f"Registered plugin {plugin_class.__name__} for database type '{db_type}'")
     
     @classmethod
@@ -44,6 +53,10 @@ class DbPluginRegistry:
             plugin_class = cls._plugins.pop(db_type)
             logger.info(f"Unregistered plugin {plugin_class.__name__} for database type '{db_type}'")
             
+            # Remove from registered plugins set
+            plugin_key = f"{db_type}:{plugin_class.__name__}"
+            cls._registered_plugins.discard(plugin_key)
+            
             # Remove any cached instances
             keys_to_remove = [key for key in cls._instances.keys() if key[0] == db_type]
             for key in keys_to_remove:
@@ -198,6 +211,7 @@ class DbPluginRegistry:
         """Clear the entire plugin registry."""
         cls._plugins.clear()
         cls._instances.clear()
+        cls._registered_plugins.clear()
         logger.info("Cleared plugin registry")
 
 

thoth_dbmanager/helpers/multi_db_generator.py

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

thoth_dbmanager/plugins/sqlite.py

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

{thoth_dbmanager-0.4.12.dist-info → thoth_dbmanager-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.4.12
+Version: 0.5.0
 Summary: A Python library for managing SQL databases with support for multiple database types, LSH-based similarity search, and a modern plugin architecture.
 Author-email: Marco Pancotti <mp@tylconsulting.it>
 Project-URL: Homepage, https://github.com/mptyl/thoth_dbmanager
@@ -44,7 +44,7 @@ Requires-Dist: oracledb>=3.0.0; extra == "oracle"
 Provides-Extra: supabase
 Requires-Dist: supabase>=2.0.0; extra == "supabase"
 Requires-Dist: postgrest-py>=0.10.0; extra == "supabase"
-Requires-Dist: gotrue-py>=1.0.0; extra == "supabase"
+Requires-Dist: gotrue>=1.0.0; extra == "supabase"
 Provides-Extra: sqlite
 Provides-Extra: all
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
@@ -84,7 +84,7 @@ A Python library for managing SQL databases with support for multiple database t
 - **Plugin Architecture**: Extensible design for adding new database types
 - **LSH Search**: Locality-Sensitive Hashing for finding similar values across database columns
 - **Type Safety**: Pydantic-based document models for structured data
-- **Backward Compatibility**: Maintains compatibility with existing code
+- **Modern API**: Clean, plugin-based interface for all database operations
 
 ## Installation
 

{thoth_dbmanager-0.4.12.dist-info → thoth_dbmanager-0.5.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-thoth_dbmanager/ThothDbManager.py,sha256=6Ew5Z9paTE2R8SJHW29Tf4bOGrYtKyHipSN4luwUXDI,17898
-thoth_dbmanager/__init__.py,sha256=zvs3kqKA99s9RJN6JVWTm-8asMeLc1NG5mnEpJTfzNg,3190
+thoth_dbmanager/ThothDbManager.py,sha256=q-jctgt3MJCDFzq6icQdP1oLeVy1ypg402F4ybxhG8c,8943
+thoth_dbmanager/__init__.py,sha256=Qrd9n7YYMkNKCFiIkzWbjKf5LNOkfp4TkebEpsKqt7E,1655
 thoth_dbmanager/documents.py,sha256=z-f7zo_CZHqoGM0qHT8-lSUx4NhnMNZTSajpoFtRxn4,5051
 thoth_dbmanager/dynamic_imports.py,sha256=nqMmxl2KeczAK-Bi5Fq92f3rPpPsTay-Bq553iHFbWI,7507
 thoth_dbmanager/adapters/__init__.py,sha256=tKIMlo9-gbH_cqnqZJ9yw1zQZKUzsV4hljDUNzcoZXg,486
@@ -13,9 +13,9 @@ thoth_dbmanager/adapters/supabase.py,sha256=bl2C6LpOpykPF3vIbdNRDk43aXLADzSk0wQu
 thoth_dbmanager/core/__init__.py,sha256=FlqNW0GZNv1rnwNgyXGzveLqaw0Z90y5AKhR_1DvHBE,269
 thoth_dbmanager/core/factory.py,sha256=sLj8tKI1ADqSlnU5F0NRtHHtpSimnATuwAqUYx5dfxI,9694
 thoth_dbmanager/core/interfaces.py,sha256=wZpKVQJdwMlAsHTQMB7yVviD2-N_dlOe19F-GhgEoGE,9576
-thoth_dbmanager/core/registry.py,sha256=2E9btPrPVnfI4z4JauKVEkN8mp8qy5gIVm3kKxUUD5E,7960
+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=LOrWEqh-RTVZXPF7vrlF6BmBGh1XC09kM6XkqkFNPQ4,23232
+thoth_dbmanager/helpers/multi_db_generator.py,sha256=frN0SZtWAfeojoJFLs4XLR3ri6h9pHYc-2O4aLAOlbo,23238
 thoth_dbmanager/helpers/preprocess_values.py,sha256=sKMjD50UL2CZG7-g7KGe3TJQeXmXC7n28LGge8CaP5c,6183
 thoth_dbmanager/helpers/schema.py,sha256=PhHgUxfFe7qUPxdpWQ3YfS593VQjyKtaSKMlChCyLNo,13978
 thoth_dbmanager/helpers/search.py,sha256=k04L7clSPfeQOlq_ifsH3PZ21ZK-rujh_Qy4hWrvSso,3970
@@ -29,11 +29,11 @@ thoth_dbmanager/plugins/mariadb.py,sha256=ElYa4Rexwrofcjcs0UQKan8fZpbU6-n9zghYR9
 thoth_dbmanager/plugins/mysql.py,sha256=mbDsIDV2H_BWYANU4JHMsUkxLQICuGtjKTTPbig2Ngs,16546
 thoth_dbmanager/plugins/oracle.py,sha256=k4Yxvz5MdsH3Sfty9lxbhr8igSnHvGbGujz3bLpNcHo,5230
 thoth_dbmanager/plugins/postgresql.py,sha256=pI1W9oHpQty8tHMoEDcsOT-Msv6S4aoFcArOGFxLR7Q,5518
-thoth_dbmanager/plugins/sqlite.py,sha256=ATWubLiLBL04Xjk24oUcZP5rQhksDZVfCwySrLRekiY,8654
+thoth_dbmanager/plugins/sqlite.py,sha256=B-9ATDQacaBHbQTexWNeJo1_F2k1z6JrsApiYI_3FgM,8853
 thoth_dbmanager/plugins/sqlserver.py,sha256=mMb3F5FmSWV02FZwj-Ult-2TjuyeVA4Fl1iME1dbgLU,5289
 thoth_dbmanager/plugins/supabase.py,sha256=mWlaGAdpywx4-pU4Ffpmn24ze8sg0sM5kc6bFDoeYRg,8645
-thoth_dbmanager-0.4.12.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
-thoth_dbmanager-0.4.12.dist-info/METADATA,sha256=gT0cJyyrAYIKSdJWb8fzB-V6SZ-4FF3wss3o4E7jgHE,12247
-thoth_dbmanager-0.4.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thoth_dbmanager-0.4.12.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
-thoth_dbmanager-0.4.12.dist-info/RECORD,,
+thoth_dbmanager-0.5.0.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
+thoth_dbmanager-0.5.0.dist-info/METADATA,sha256=WbpRrYaYFg0H_EOUPPsjMfsTmuhuMvPSGI50jQthJLM,12246
+thoth_dbmanager-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thoth_dbmanager-0.5.0.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
+thoth_dbmanager-0.5.0.dist-info/RECORD,,