dbhydra 2.2.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

dbhydra/dbhydra_core.py

@@ -13,7 +13,8 @@ from dbhydra.src.mongo_db import MongoDb
 from dbhydra.src.postgres_db import PostgresDb
 from dbhydra.src.xlsx_db import XlsxDb, XlsxDB
 from dbhydra.src.abstract_db import AbstractDb
-from dbhydra.src.tables import SqlServerTable, PostgresTable, MysqlTable, XlsxTable, AbstractTable, MongoTable, BigQueryTable, Table, AbstractSelectable, AbstractJoinable
+from dbhydra.src.tables import (SqlServerTable, PostgresTable, MysqlTable, XlsxTable, AbstractTable, MongoTable,
+                                BigQueryTable, Table, AbstractSelectable, AbstractJoinable, PYTHON_TO_MYSQL_DATA_MAPPING)
 ##### Do not remove imports - they are expored in the package
 
 

dbhydra/src/migrator.py

@@ -7,13 +7,13 @@ from typing import Optional
 from deepdiff import DeepDiff
 from dataclasses import dataclass, asdict
 
-CURRENT_MIGRATION_DEFAULT_PATH = "./db/migrations/current_migration.json"
+PENDING_MIGRATION_DEFAULT_PATH = "./db/migrations/pending_migration.json"
 MIGRATION_HISTORY_DEFAULT_PATH = "./db/migrations/migration_history.json"
 
-@dataclass
-class Migration:
-    forward: list[dict]
-    backward: list[dict]
+# @dataclass
+# class Migration:
+#     forward: list[dict]
+#     backward: list[dict]
 
 class Migrator:
     """
@@ -39,7 +39,8 @@ class Migrator:
         self._migration_list = []
         
         # Used in newer approach
-        self._current_migration = Migration(forward=[], backward=[])
+        self._pending_forward_migration_list = []#Migration(forward=[], backward=[])
+        self._pending_forward_migration_list = []#Migration(forward=[], backward=[])
 
     def process_migration_dict(self, migration_dict):
         matching_table_class = self.db.matching_table_class #E.g. MysqlTable
@@ -99,6 +100,15 @@ class Migrator:
             with open(f"migrations/{filename}.json", "w+") as f:
                 f.write(result)
 
+
+
+
+
+
+
+
+
+    ##### Auxilliary? #####
     def create_migrations_from_df(self, name, dataframe):
 
         columns, return_types = self.extract_columns_and_types_from_df(dataframe)
@@ -143,88 +153,99 @@ class Migrator:
 
         return columns, return_types
     # Old approach methods END
+  
+    
+  
+    
+  
+    
+  
     
-    def set_current_migration(self, migration_dict: dict[str, list]):
-        self._current_migration = Migration(**migration_dict)
+  
+    
+  
+    
+    # def set_pending_migration(self, migration_dict: dict[str, list]):
+    #     self._pending_migration = Migration(**migration_dict)
     
     def migrate_forward(self):
         """
-        Applies forward migrations from the current migration object.
+        Applies forward migrations from the pending migration object.
 
-        Iterates through each migration dictionary in the current migration's forward list,
-        processes the migration, saves it to migration history, and clears the current migration.
+        Iterates through each migration dictionary in the pending migration's forward list,
+        processes the migration, saves it to migration history, and clears the pending migration.
 
         Returns:
             None
         """
             
-        for migration_dict in self._current_migration.forward:
+        for migration_dict in self._pending_forward_migration_list:
             self.process_migration_dict(migration_dict)
             
-        self._save_migration_to_history(migration=self._current_migration)
-        self._clear_current_migration()
+        #self._save_migration_to_history(migration=self._pending_migration)
+        self._clear_pending_migration()
             
     def migrate_backward(self):
         """
-        Applies backward migrations from the current migration object.
+        Applies backward migrations from the pending migration object.
 
-        Iterates through each migration dictionary in the current migration's backward list,
-        processes the migration, saves it to migration history, and clears the current migration.
+        Iterates through each migration dictionary in the pending migration's backward list,
+        processes the migration, saves it to migration history, and clears the pending migration.
 
         Returns:
             None
         """
         
-        for migration_dict in self._current_migration.backward:
+        for migration_dict in self._pending_backward_migration_list:
             self.process_migration_dict(migration_dict)
             
-        history_migration = Migration(forward=self._current_migration.backward, backward=self._current_migration.forward)
-        self._save_migration_to_history(migration=history_migration)
-        self._clear_current_migration()
+        #history_migration = Migration(forward=self._pending_migration.backward, backward=self._pending_migration.forward)
+        #self._save_migration_to_history(migration=history_migration)
+        self._clear_pending_migration()
         
-    def migrate_n_steps_back_in_history(self, n: int, migration_history_json: str = MIGRATION_HISTORY_DEFAULT_PATH):        
-        migration_history = self._read_migration_history_json(migration_history_json)
+    # def migrate_n_steps_back_in_history(self, n: int, migration_history_json: str = MIGRATION_HISTORY_DEFAULT_PATH):        
+    #     migration_history = self._read_migration_history_json(migration_history_json)
         
-        if len(migration_history) < n:
-            raise ValueError(f"Provided n (= {n}) is larger than migration history length (= {len(migration_history)}).")
+    #     if len(migration_history) < n:
+    #         raise ValueError(f"Provided n (= {n}) is larger than migration history length (= {len(migration_history)}).")
 
-        total_backward_migration = Migration(forward=[], backward=[])
-        migrations = migration_history[-n:] # Take last n elements of migration history for execution
+    #     total_backward_migration = Migration(forward=[], backward=[])
+    #     migrations = migration_history[-n:] # Take last n elements of migration history for execution
         
-        # Loop in reversed order as we execute backward migrations in reversed order compared to forward ones
-        for migration_dict in reversed(migrations):
-            total_backward_migration.forward.append(migration_dict["forward"])
-            total_backward_migration.backward.append(migration_dict["backward"])
+    #     # Loop in reversed order as we execute backward migrations in reversed order compared to forward ones
+    #     for migration_dict in reversed(migrations):
+    #         total_backward_migration.forward.append(migration_dict["forward"])
+    #         total_backward_migration.backward.append(migration_dict["backward"])
             
-        self.set_current_migration(asdict(total_backward_migration))
-        self.migrate_backward()
+    #     self.set_pending_migration(asdict(total_backward_migration))
+    #     self.migrate_backward()
     
-    def load_migration_from_json(self, json_file_path: str = CURRENT_MIGRATION_DEFAULT_PATH):
-        with open(json_file_path, "r") as file:
-            migration_dict = json.load(file)
+    # def load_migration_from_json(self, json_file_path: str = PENDING_MIGRATION_DEFAULT_PATH):
+    #     with open(json_file_path, "r") as file:
+    #         migration_dict = json.load(file)
             
-        self.set_current_migration(migration_dict)
+    #     self.set_pending_migration(migration_dict)
     
-    def save_current_migration_to_json(self, file_path: str = CURRENT_MIGRATION_DEFAULT_PATH):
-        if not file_path.endswith(".json"):
-            raise ValueError("Current migration file must be of '.json' type.")
+    # def save_pending_migration_to_json(self, file_path: str = PENDING_MIGRATION_DEFAULT_PATH):
+    #     if not file_path.endswith(".json"):
+    #         raise ValueError("pending migration file must be of '.json' type.")
         
-        self._build_folder_structure_for_file_path(file_path)
+    #     self._build_folder_structure_for_file_path(file_path)
         
-        with open(file_path, "w+") as file:
-            json.dump(asdict(self._current_migration), file, indent=2)
+    #     with open(file_path, "w+") as file:
+    #         json.dump(asdict(self._pending_migration), file, indent=2)
     
-    def create_table_migration(self, table_name: str, old_structure: Optional[dict], new_structure: Optional[dict]):
+    def create_table_migration(self, table_name: str, old_column_type_dict: Optional[dict], new_column_type_dict: Optional[dict]):
         """
-        Creates a migration for a database table based on its old and new structures.
+        Creates a migration for a database table based on its old and new column_type_dicts.
 
         Args:
             table_name (str): The name of the database table.
-            old_structure (Optional[dict]): The old structure of the table.
-            new_structure (Optional[dict]): The new structure of the table.
+            old_column_type_dict (Optional[dict]): The old column_type_dict of the table.
+            new_column_type_dict (Optional[dict]): The new column_type_dict of the table.
 
-            If old_structure is None and new_structure is not None: CREATE table
-            If old_structure is not None and new_structure is None: DROP table
+            If old_column_type_dict is None and new_column_type_dict is not None: CREATE table
+            If old_column_type_dict is not None and new_column_type_dict is None: DROP table
 
         Returns:
             Migration: The generated migration object.
@@ -232,164 +253,173 @@ class Migrator:
         Raises:
             ValueError: If the table_name argument is empty.
         """
-    
+        
+        def _extract_column_name_from_deepdiff_key(deepdiff_key: str) -> str:
+            """
+            Extracts the column name from a key generated by deepdiff.
+
+            Args:
+                deepdiff_key (str): The key generated by deepdiff.
+
+            Returns:
+                str: The extracted column name.
+
+            Example:
+                >>> migrator = Migrator()
+                >>> column_name = migrator._extract_column_name_from_deepdiff_key("root['table']['column']")
+                >>> print(column_name)
+                'column'
+            """
+            
+            # Split the item_key by '[' and ']' to isolate the column name
+            # The column name is expected to be the last element after splitting
+            column_name = deepdiff_key.split('[')[-1].strip("']")
+            return column_name
+        
+        def _convert_deepdiff_dict_into_migration_lists(table_name: str, deepdiff_dict: dict):
+            """
+            Converts deepdiff dictionary from the new and old table column_type_dicts comparison into a Migration object.
+
+            Args:
+                table_name (str): A name of the examined DB table.
+                deepdiff_dict (dict): A dictionary from DeepDiff comparison of the old and new table column_type_dict.
+
+            Returns:
+                Migration: A Migration object containing forward and backward migrations for the given table.
+                
+            Example:
+                >>> table_name = 'results'
+                >>> deepdiff_dict = {'dictionary_item_removed': {"root['hehexd']": 'double'}}
+                >>> migrator = Migrator()
+                >>> asdict(migrator._convert_deepdiff_dict_into_migration)
+                >>> {
+                    'forward': [
+                        {'drop_column': {'table_name': 'results', 'column_name': 'hehexd'}}
+                        ],
+                    'backward': [
+                        {'add_column': {'table_name': 'results', 'column_name': 'hehexd', 'column_type': 'double'}}
+                        ]
+                    }
+            """
+            forward_migration_list, backward_migration_list = [], []
+
+            forward_conversions = {
+                "dictionary_item_added": "add_column",
+                "dictionary_item_removed": "drop_column",
+                "values_changed": "modify_column"
+                }
+            backward_conversions = {
+                "dictionary_item_added": "drop_column",
+                "dictionary_item_removed": "add_column",
+                "values_changed": "modify_column"
+                }
+
+            for action_name, deepdiff_action in deepdiff_dict.items():
+                for deepdiff_key in deepdiff_action.keys():
+                    column_name = _extract_column_name_from_deepdiff_key(deepdiff_key)
+                    forward_action, backward_action = forward_conversions[action_name], backward_conversions[action_name]
+                    
+                    if action_name=="dictionary_item_added":
+                        column_type = deepdiff_action[deepdiff_key]
+                        forward_migration_list.append({forward_action: {"table_name": table_name, "column_name": column_name, "column_type": column_type}})
+                        backward_migration_list.append({backward_action: {"table_name": table_name, "column_name": column_name}})
+                    elif action_name=="dictionary_item_removed":
+                        column_type = deepdiff_action[deepdiff_key]
+                        forward_migration_list.append({forward_action: {"table_name": table_name, "column_name": column_name}})
+                        backward_migration_list.append({backward_action: {"table_name": table_name, "column_name": column_name, "column_type": column_type}})
+                    elif action_name=="values_changed":
+                        column_type = deepdiff_action[deepdiff_key]["old_value"]
+                        column_new_type = deepdiff_action[deepdiff_key]["new_value"]
+                        
+                        # HACK: Do not create migrations for cases such as varchar(2047) --> nvarchar(2047)
+                        is_varchar_in_types = "varchar" in column_type and "varchar" in column_new_type
+                        is_max_length_equal = (
+                            column_type[column_type.index("("): column_type.index(")")] 
+                            and column_new_type[column_new_type.index("("): column_new_type.index(")")]
+                            ) if is_varchar_in_types else False
+                        is_varchar_nvarchar_conversion = is_varchar_in_types and is_max_length_equal
+                        
+                        if not is_varchar_nvarchar_conversion:
+                            forward_migration_list.append({forward_action: {"table_name": table_name, "column_name": column_name,
+                                                                "column_type": column_new_type}})
+                            backward_migration_list.append({backward_action: {"table_name": table_name, "column_name": column_name,
+                                                                "column_type": column_type}})
+                
+            return forward_migration_list, backward_migration_list
+        
+        
+        
+        
         if not table_name:
             raise ValueError("The 'table_name' argument must be a non-empty string.")
 
-        if not old_structure and new_structure:
-            # non-empty initial structure --> empty new structure
-            columns, types = list(new_structure.keys()), list(new_structure.values())
-            forward_migration = [{"create": {"table_name": table_name, "columns": columns, "types": types}}]
-            backward_migration = [{"drop": {"table_name": table_name}}]
+        if not old_column_type_dict and new_column_type_dict:
+            # non-empty initial column_type_dict --> empty new column_type_dict
+            columns, types = list(new_column_type_dict.keys()), list(new_column_type_dict.values())
+            forward_migration_list = [{"create": {"table_name": table_name, "columns": columns, "types": types}}]
+            backward_migration_list = [{"drop": {"table_name": table_name}}]
             
-            migration = Migration(forward=forward_migration, backward=backward_migration)
-        elif not new_structure:
-            # new structure is empty ==> drop the table
-            forward_migration = [{"drop": {"table_name": table_name}}]
-            backward_migration = [{"create": {"table_name": table_name, "columns": columns, "types": types}}]
+        elif not new_column_type_dict:
+            # new column_type_dict is empty ==> drop the table
+            forward_migration_list = [{"drop": {"table_name": table_name}}]
+            backward_migration_list = [{"create": {"table_name": table_name, "columns": columns, "types": types}}]
             
-            migration = Migration(forward=forward_migration, backward=backward_migration)
-        else:
-            diff = DeepDiff(old_structure, new_structure, verbose_level=2)
-            migration = self._convert_deepdiff_dict_into_migration(table_name, diff)
             
-        self._merge_migration_to_current_migration(migration=migration)
-
-        return migration
-
-    def _convert_deepdiff_dict_into_migration(self, table_name: str, deepdiff_dict: dict) -> Migration:
-        """
-        Converts deepdiff dictionary from the new and old table structures comparison into a Migration object.
-
-        Args:
-            table_name (str): A name of the examined DB table.
-            deepdiff_dict (dict): A dictionary from DeepDiff comparison of the old and new table structure.
-
-        Returns:
-            Migration: A Migration object containing forward and backward migrations for the given table.
+        else:
+            diff = DeepDiff(old_column_type_dict, new_column_type_dict, verbose_level=2)
+            forward_migration_list, backward_migration_list = _convert_deepdiff_dict_into_migration_lists(table_name, diff)
             
-        Example:
-            >>> table_name = 'results'
-            >>> deepdiff_dict = {'dictionary_item_removed': {"root['hehexd']": 'double'}}
-            >>> migrator = Migrator()
-            >>> asdict(migrator._convert_deepdiff_dict_into_migration)
-            >>> {
-                'forward': [
-                    {'drop_column': {'table_name': 'results', 'column_name': 'hehexd'}}
-                    ],
-                'backward': [
-                    {'add_column': {'table_name': 'results', 'column_name': 'hehexd', 'column_type': 'double'}}
-                    ]
-                }
-        """
-        forward_migration, backward_migration = [], []
-
-        forward_conversions = {
-            "dictionary_item_added": "add_column",
-            "dictionary_item_removed": "drop_column",
-            "values_changed": "modify_column"
-            }
-        backward_conversions = {
-            "dictionary_item_added": "drop_column",
-            "dictionary_item_removed": "add_column",
-            "values_changed": "modify_column"
-            }
-
-        for action_name, deepdiff_action in deepdiff_dict.items():
-            for deepdiff_key in deepdiff_action.keys():
-                column_name = self._extract_column_name_from_deepdiff_key(deepdiff_key)
-                forward_action, backward_action = forward_conversions[action_name], backward_conversions[action_name]
-                
-                if action_name=="dictionary_item_added":
-                    column_type = deepdiff_action[deepdiff_key]
-                    forward_migration.append({forward_action: {"table_name": table_name, "column_name": column_name, "column_type": column_type}})
-                    backward_migration.append({backward_action: {"table_name": table_name, "column_name": column_name}})
-                elif action_name=="dictionary_item_removed":
-                    column_type = deepdiff_action[deepdiff_key]
-                    forward_migration.append({forward_action: {"table_name": table_name, "column_name": column_name}})
-                    backward_migration.append({backward_action: {"table_name": table_name, "column_name": column_name, "column_type": column_type}})
-                elif action_name=="values_changed":
-                    column_type = deepdiff_action[deepdiff_key]["old_value"]
-                    column_new_type = deepdiff_action[deepdiff_key]["new_value"]
-                    
-                    # HACK: Do not create migrations for cases such as varchar(2047) --> nvarchar(2047)
-                    is_varchar_in_types = "varchar" in column_type and "varchar" in column_new_type
-                    is_max_length_equal = (
-                        column_type[column_type.index("("): column_type.index(")")] 
-                        and column_new_type[column_new_type.index("("): column_new_type.index(")")]
-                        ) if is_varchar_in_types else False
-                    is_varchar_nvarchar_conversion = is_varchar_in_types and is_max_length_equal
-                    
-                    if not is_varchar_nvarchar_conversion:
-                        forward_migration.append({forward_action: {"table_name": table_name, "column_name": column_name,
-                                                            "column_type": column_new_type}})
-                        backward_migration.append({backward_action: {"table_name": table_name, "column_name": column_name,
-                                                            "column_type": column_type}})
+        #migration = Migration(forward=forward_migration_list, backward=backward_migration_list)
             
-        return Migration(forward=forward_migration, backward=backward_migration)
-    
-    def _extract_column_name_from_deepdiff_key(self, deepdiff_key: str) -> str:
-        """
-        Extracts the column name from a key generated by deepdiff.
+        self._append_migration_to_pending_migration(forward_migration_list, backward_migration_list)
 
-        Args:
-            deepdiff_key (str): The key generated by deepdiff.
+        return forward_migration_list, backward_migration_list
 
-        Returns:
-            str: The extracted column name.
-
-        Example:
-            >>> migrator = Migrator()
-            >>> column_name = migrator._extract_column_name_from_deepdiff_key("root['table']['column']")
-            >>> print(column_name)
-            'column'
-        """
-        
-        # Split the item_key by '[' and ']' to isolate the column name
-        # The column name is expected to be the last element after splitting
-        column_name = deepdiff_key.split('[')[-1].strip("']")
-        return column_name
     
-    def _merge_migration_to_current_migration(self, migration: Migration):
-        new_forward_part = self._current_migration.forward + migration.forward
-        new_backward_part = self._current_migration.backward + migration.backward
-        self._current_migration = Migration(forward=new_forward_part, backward=new_backward_part)
+    
+ 
+    
+    def _append_migration_to_pending_migration(self, forward_migration_list, backward_migration_list):
+        self._pending_forward_migration_list += forward_migration_list
+        self._pending_backward_migration_list += backward_migration_list
+        
         
-    def _clear_current_migration(self):
-        self._current_migration = Migration(forward=[], backward=[])
+    def _clear_pending_migration(self):
+        self._pending_forward_migration_list = []
+        self._pending_backward_migration_list = []
         
-    def _read_migration_history_json(self, file_path: str = MIGRATION_HISTORY_DEFAULT_PATH):
-        if not file_path.endswith(".json"):
-            raise ValueError("Migration history file must be of '.json' type.")
+    # def _read_migration_history_json(self, file_path: str = MIGRATION_HISTORY_DEFAULT_PATH):
+    #     if not file_path.endswith(".json"):
+    #         raise ValueError("Migration history file must be of '.json' type.")
         
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"Migration history file '{file_path}' does not exist.")
+    #     if not os.path.exists(file_path):
+    #         raise FileNotFoundError(f"Migration history file '{file_path}' does not exist.")
         
-        try:
-            with open(file_path, "r") as file:
-                migration_history = json.load(file)
-        except json.JSONDecodeError:
-            migration_history = []
+    #     try:
+    #         with open(file_path, "r") as file:
+    #             migration_history = json.load(file)
+    #     except json.JSONDecodeError:
+    #         migration_history = []
             
-        return migration_history
+    #     return migration_history
         
-    def _save_migration_to_history(self, migration: Migration, file_path: str = MIGRATION_HISTORY_DEFAULT_PATH):            
-        try:
-            migration_history = self._read_migration_history_json(file_path)
-        except FileNotFoundError:
-            self._build_folder_structure_for_file_path(file_path)
-            migration_history = []
+    # def _save_migration_to_history(self, migration: Migration, file_path: str = MIGRATION_HISTORY_DEFAULT_PATH):            
+    #     try:
+    #         migration_history = self._read_migration_history_json(file_path)
+    #     except FileNotFoundError:
+    #         self._build_folder_structure_for_file_path(file_path)
+    #         migration_history = []
             
-        migration_history.append(asdict(migration))
+    #     migration_history.append(asdict(migration))
         
-        with open(file_path, "w") as file:
-            json.dump(migration_history, file, indent=2)
+    #     with open(file_path, "w") as file:
+    #         json.dump(migration_history, file, indent=2)
             
-    def _build_folder_structure_for_file_path(self, file_path: str):
-        folder_path = os.path.dirname(file_path)
-        if not os.path.exists(folder_path):
-            print(f"Folder path to the file '{file_path}' does not exist. Creating the file and the folder structure.")
-            os.makedirs(folder_path)
+    # def _build_folder_structure_for_file_path(self, file_path: str):
+    #     folder_path = os.path.dirname(file_path)
+    #     if not os.path.exists(folder_path):
+    #         print(f"Folder path to the file '{file_path}' does not exist. Creating the file and the folder structure.")
+    #         os.makedirs(folder_path)
         
 
 

dbhydra/src/mysql_db.py

@@ -43,6 +43,9 @@ class MysqlDb(AbstractDb):
         print("DB connection established")
 
     def create_new_db(self):
+        self.connection = pymysql.connect(host=self.DB_SERVER, port=self.DB_PORT, user=self.DB_USERNAME, 
+                                          charset="utf8mb4", password=self.DB_PASSWORD)
+        self.cursor = self.connection.cursor()
         create_db_command = "CREATE DATABASE " + self.DB_DATABASE
         self.execute(create_db_command)
 

dbhydra/src/tables.py

@@ -966,9 +966,8 @@ class XlsxTable(AbstractTable):
             except Exception:
                 # print(f"Error while reading data into XlsxTable: {e}")
                 # df = pd.DataFrame(columns=self.columns)
-                if attempt < self.NUMBER_OF_RETRIES:
+                if attempt < self.NUMBER_OF_RETRIES - 1:
                     time.sleep(0.1)
-                    continue
                 else:
                     print(f"Failed to read data from {self.table_directory_path}, returning empty DataFrame")
                     df = pd.DataFrame(columns=self.columns)

dbhydra/test_migrator.py

@@ -0,0 +1,27 @@
+import dbhydra.dbhydra_core as dh
+
+
+db1=dh.MysqlDb("config-mysql.ini")
+with db1.connect_to_db():
+    
+    nodes_table = dh.MysqlTable(db1, "nodes",columns=["id","name"],types=["int","int"])
+    #nodes_table.create()
+    
+    db1.initialize_migrator()
+    
+    print(nodes_table.column_type_dict)
+    
+    new_column_type_dict={"id":"int","name":"nvarchar","age":"int"}
+    
+    migration1=db1.migrator.create_table_migration("nodes", nodes_table.column_type_dict, new_column_type_dict)
+    db1.migrator.save_current_migration_to_json()
+    migration2=db1.migrator.create_table_migration("nodes", new_column_type_dict, nodes_table.column_type_dict)
+    db1.migrator.save_current_migration_to_json()    
+    print(migration1)
+    print(migration2)
+    
+    
+    
+    
+    
+    

{dbhydra-2.2.0.dist-info → dbhydra-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbhydra
-Version: 2.2.0
+Version: 2.2.1
 Summary: Data science friendly ORM combining Python
 Home-page: https://github.com/DovaX/dbhydra
 Author: DovaX

{dbhydra-2.2.0.dist-info → dbhydra-2.2.1.dist-info}/RECORD

@@ -1,15 +1,16 @@
 dbhydra/__init__.py,sha256=DCocEeXf4QxdVlBRlNiFvuP5IZJ5aa77_DbUR-_4C14,65
-dbhydra/dbhydra_core.py,sha256=QP4x9ObXCNHOJSolGVOUXZ3EbNM5kWhMNESi5kwKy-g,2405
+dbhydra/dbhydra_core.py,sha256=26xBOo3sl--xFa-IrnE3AmBjB3ut5CXUJ1add438ups,2470
+dbhydra/test_migrator.py,sha256=e3Nnb2mCd3CfjhjSexNg1tXVJMjkl5cCoYcuhbfZ4pM,803
 dbhydra/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbhydra/src/abstract_db.py,sha256=lEP24vWz0HdGjQgSoHnawNK_NvRlSLuvzVSiiawssuw,5901
 dbhydra/src/abstract_table.py,sha256=c3pkBTgMOLGDgLH4YEfqM0x33puh-gkML9Rid8xzdFs,17081
 dbhydra/src/bigquery_db.py,sha256=77XsgvYbANlvYaJnuVve-kz-PNBx_CHoYCL-eYnA8e4,1834
-dbhydra/src/migrator.py,sha256=aSOlHr3T81aAgpDG9iz3O6-GgjNk5ZYQskimSPKSXwU,18028
+dbhydra/src/migrator.py,sha256=QzaODEFfraD9_6HN_Osaidaj-nLYQryCYYWwJtUu3n8,18931
 dbhydra/src/mongo_db.py,sha256=mP48zRjI7mXKpm45R8prroZI-Eo7JKf0KJqGX-oTy3w,1922
-dbhydra/src/mysql_db.py,sha256=4_9lgszlyFxJuErgaPqje13jXJPMiRqY1rJbDvVbObo,2908
+dbhydra/src/mysql_db.py,sha256=xFYy1Ty7iS3GXSncFoaKve4QN1SMJiuDjGyMbb-b1bw,3152
 dbhydra/src/postgres_db.py,sha256=L7MaBq_6ArwDSP_5LaEqK58oLxZ1X7FgIokcDOSB7wk,1805
 dbhydra/src/sqlserver_db.py,sha256=9Xi3NAliqM79MTV8fpNQb0nWMH8Bqjl1leJSEqgyT94,3611
-dbhydra/src/tables.py,sha256=E7vnHCWzl3efhiDfuUPZsAvmzpSueIzvz_c2Vl0WkME,46682
+dbhydra/src/tables.py,sha256=QZK76rv_d0MpXGNnuAezouXN8dO0nPrkVMmKVsHxj68,46656
 dbhydra/src/xlsx_db.py,sha256=z6d-IjMYMmXC591Mt5DcxIYWyluanjPRFd-sXtjjXww,3514
 dbhydra/src/errors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbhydra/src/errors/exceptions.py,sha256=LVpfbTd3NHfQIM-D5TFAU6hOZwGQ3b5DwFD4B6vtf2U,149
@@ -17,8 +18,8 @@ dbhydra/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbhydra/tests/test_cases.py,sha256=eAFGaHaIaab3md3HHm2_ryb_HHfObtcXDAEzLh4qWx8,508
 dbhydra/tests/test_mongo.py,sha256=M8TD72M0iQAk7ZcLTWwLmcmmF_zwALnYEGTWjhQlq0s,1979
 dbhydra/tests/test_sql.py,sha256=aPFXyA0jh8o9VG3B5f9fNz7qDbuVPZ9TcE2twn5dAeQ,3126
-dbhydra-2.2.0.dist-info/LICENSE,sha256=k49Yga8CP889JJaHlOpGFzr_be2nqMoep2chYeIDctk,1091
-dbhydra-2.2.0.dist-info/METADATA,sha256=-fvfNWAhNtyQ8DLeGJsClGfDUNA9HjiFDkxQjXbbDyU,2298
-dbhydra-2.2.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-dbhydra-2.2.0.dist-info/top_level.txt,sha256=oO4Gf1T8_txIsIlp11GI0k7PtBIMb9GRwb5ObF4MLVg,8
-dbhydra-2.2.0.dist-info/RECORD,,
+dbhydra-2.2.1.dist-info/LICENSE,sha256=k49Yga8CP889JJaHlOpGFzr_be2nqMoep2chYeIDctk,1091
+dbhydra-2.2.1.dist-info/METADATA,sha256=fXT5IdyIT6MA0US_YolueauSs0KAtZJE5392uF7G03c,2298
+dbhydra-2.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+dbhydra-2.2.1.dist-info/top_level.txt,sha256=oO4Gf1T8_txIsIlp11GI0k7PtBIMb9GRwb5ObF4MLVg,8
+dbhydra-2.2.1.dist-info/RECORD,,