thoth-dbmanager 0.5.3__py3-none-any.whl → 0.5.9__py3-none-any.whl

thoth_dbmanager/plugins/__init__.py

@@ -1,17 +1,56 @@
+# Copyright 2025 Marco Pancotti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """
 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,37 @@
+# Copyright 2025 Marco Pancotti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """
 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 +87,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 +111,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 +121,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 +214,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/plugins/postgresql.py

@@ -1,3 +1,17 @@
+# Copyright 2025 Marco Pancotti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """
 PostgreSQL plugin implementation.
 """

thoth_dbmanager/plugins/sqlite.py

@@ -1,3 +1,17 @@
+# Copyright 2025 Marco Pancotti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """
 SQLite plugin implementation.
 """

thoth_dbmanager/plugins/sqlserver.py

@@ -1,3 +1,17 @@
+# Copyright 2025 Marco Pancotti
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """
 SQL Server plugin implementation.
 """

{thoth_dbmanager-0.5.3.dist-info → thoth_dbmanager-0.5.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoth_dbmanager
-Version: 0.5.3
+Version: 0.5.9
 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,6 +22,7 @@ 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

thoth_dbmanager-0.5.9.dist-info/RECORD

@@ -0,0 +1,34 @@
+thoth_dbmanager/ThothDbManager.py,sha256=Mt3MCvV7vVPgS2jXuyGJVMLslKRpbhxmTCeHL6s80XA,9522
+thoth_dbmanager/__init__.py,sha256=7TpqAsZhwGyr3tA_oyGbAOaVhd7k6Ta3wGQTK7mdUpE,2234
+thoth_dbmanager/documents.py,sha256=BnYL9MR9eOl9cNOrY58SgHgXACnHCk_UzKjpfV8RjgY,5630
+thoth_dbmanager/dynamic_imports.py,sha256=nKCwg3Y2e5f4oP_-9X53t4Z9InbIGDMgidQjeN1Xgoo,7592
+thoth_dbmanager/adapters/__init__.py,sha256=rfXo8IxWPx2TQV2OwFrZqpOzrkKuO6HR0q8ftkuGhW0,1578
+thoth_dbmanager/adapters/mariadb.py,sha256=Bc31B4LNzlqu1QwhBP49Ia1jlh-XWh14Q_ya-KqWvsQ,15636
+thoth_dbmanager/adapters/postgresql.py,sha256=7NiYHGWQpiZ3NMT6G3tqLeCJztxNZ4E0jB-aeT5FhK0,18453
+thoth_dbmanager/adapters/sqlite.py,sha256=sg9ifwBL3L_aBf6i3Z0wq_Z7mTjnVeWhCY1VK6Cfh9E,15147
+thoth_dbmanager/adapters/sqlserver.py,sha256=VcWW5xudK4_3BuPwX0WcBAxgN6j9seRssvwsWPpJudo,25320
+thoth_dbmanager/core/__init__.py,sha256=22dsupbGskkjGgS9IzeCwaf5o7nIKH_og1qARZURAFM,848
+thoth_dbmanager/core/factory.py,sha256=4RHiAlqTGbtMKGCboDM8dnCgyJhO4PTWgkGyJ-ZSrFc,9537
+thoth_dbmanager/core/interfaces.py,sha256=SAmPllSyJamLb8eyN9CdpnunNxje6M-q1SrR3hxTAE4,10154
+thoth_dbmanager/core/registry.py,sha256=0yqZGs2zVoX601pr4Sct1LITt1O87IG4Yyhay8EpNg0,9203
+thoth_dbmanager/helpers/__init__.py,sha256=4URWmUXMDcn9N4Jd-1vGA93MG6TOhTF55wVC0nBpPIw,578
+thoth_dbmanager/helpers/multi_db_generator.py,sha256=qoSJA-xfUEPyFgKLcJDJUAkcvTxRG-IJzHHi05a6Tpc,23817
+thoth_dbmanager/helpers/preprocess_values.py,sha256=fuRebc34DvE6OSZztCG8iJDFu2W6_mXpYvymoP0s_LU,6762
+thoth_dbmanager/helpers/schema.py,sha256=9zmQXZYPpWErYxhKiGjw84iqi2R1bfuULzEdxuzZhrI,14557
+thoth_dbmanager/helpers/search.py,sha256=pN-GNKA25jAFrspEyZoLI9pw4VKGC75nABeUEwIrVQQ,4549
+thoth_dbmanager/lsh/__init__.py,sha256=nOCWWb4FUJ3ukggaTdPA2AOZI3m3iu54OKschnqxThc,1134
+thoth_dbmanager/lsh/core.py,sha256=eqeqHvOiHcEiwt0xxInn5iQT7rOX2Chl_tWBBNq1Stw,7392
+thoth_dbmanager/lsh/factory.py,sha256=jf-_0VXOHsCdgKb8KgWDMSQk9TpTg6KbpPXc0Mn_Lqc,2990
+thoth_dbmanager/lsh/manager.py,sha256=mHdgVgkOhVcJvu0ED0qgHmZKp28er6avx2MZzTOJCSQ,7092
+thoth_dbmanager/lsh/storage.py,sha256=ijryQWavoPAQ7tRGvjc-2dBJmI7mzNGUa1dSR_ke6Vw,5122
+thoth_dbmanager/plugins/__init__.py,sha256=uTGI4GZNE6xSEfzuf_7llqGHY5D1BbC2EMJjgKXU-xM,1736
+thoth_dbmanager/plugins/mariadb.py,sha256=OW_u_x3mfaQYH5dUEreUbelPE6KEQU4kiqT3_DzHgUg,8610
+thoth_dbmanager/plugins/postgresql.py,sha256=VFGiGa1qAWRR00DkoHIAFS-U9uMLMwb5gKa_NB-cQA8,6097
+thoth_dbmanager/plugins/sqlite.py,sha256=yqqa_lToLabOv_ut2uRTXxhjyEQSVbB8kIcUwy7HNZk,9436
+thoth_dbmanager/plugins/sqlserver.py,sha256=AxEXwe21FRh6L1lX6-gu3VzcxDQ7dO5YLvLXTrIyaRk,5868
+thoth_dbmanager-0.5.9.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
+thoth_dbmanager-0.5.9.dist-info/licenses/LICENSE.md,sha256=TtKT2ej3GRki3W8FmSeYzRuQtZ1oMGWchpWykZ4vA7c,1070
+thoth_dbmanager-0.5.9.dist-info/METADATA,sha256=Bic4w9wYxCM8SKiJVKVwvJJTrFo9XC96BftJivljIcw,14777
+thoth_dbmanager-0.5.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thoth_dbmanager-0.5.9.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
+thoth_dbmanager-0.5.9.dist-info/RECORD,,

thoth_dbmanager-0.5.9.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.

thoth_dbmanager-0.5.3.dist-info/RECORD

@@ -1,33 +0,0 @@
-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=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/postgresql.py,sha256=qxdlxOV7Nvn8U4Lhat50w87Z2S8AzBfmLfEwKfz7dis,17299
-thoth_dbmanager/adapters/sqlite.py,sha256=RTDszgnAtkE14LKFeoe9lBHgsqXqkmDk6jDCTmVpnoM,14659
-thoth_dbmanager/adapters/sqlserver.py,sha256=V555kUH54Fb1Atow0BfvbSHmoSwGnrB_RJGn718VQSI,23880
-thoth_dbmanager/core/__init__.py,sha256=FlqNW0GZNv1rnwNgyXGzveLqaw0Z90y5AKhR_1DvHBE,269
-thoth_dbmanager/core/factory.py,sha256=84EeZYRoH7y7b19EFHqN4X0CSA6dv-0yxUmlX2zHETk,8840
-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
-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
-thoth_dbmanager/lsh/__init__.py,sha256=zAUTRuRX4MNc2nU93tTBkT2_IVL7OBkBL0WZPPgO3Ec,555
-thoth_dbmanager/lsh/core.py,sha256=171FqHW7ItAqAPk6g_AoayKTE3Bs1rRZxnt55MJVzjY,6813
-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/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.3.dist-info/licenses/LICENSE,sha256=81-BOzGgwtY1XdYfkwMQB87AkOGXI9OMq0kjNcZA4UE,1071
-thoth_dbmanager-0.5.3.dist-info/METADATA,sha256=ex4_W1vKNmcoFo0ZDHa4Hq-uaoO2YM6T_2a0VvdChvw,14752
-thoth_dbmanager-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thoth_dbmanager-0.5.3.dist-info/top_level.txt,sha256=b9ttxm9RUc0KUCASEKRx6FqoREYJ1-KZWSpNuaM0uQ4,16
-thoth_dbmanager-0.5.3.dist-info/RECORD,,