dbhydra 2.2.6__tar.gz → 2.2.9__tar.gz

{dbhydra-2.2.6 → dbhydra-2.2.9}/PKG-INFO

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

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/dbhydra_core.py

@@ -22,6 +22,9 @@ class Jsonable(str):
     """Is used as type in python_database_type_mapping"""    
     pass
 
+class Blob(str):
+    """Store BLOBs up to 16MB."""    
+    pass
 
 
 # dataframe - dictionary auxiliary functions

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/src/abstract_db.py

@@ -58,6 +58,7 @@ class AbstractDb(abc.ABC):
         'Union': 'object',
         'Optional': 'object',
         'Jsonable': 'Jsonable',
+        'Blob': 'Blob',
         # 'FrozenSet': frozenset,
         # 'Deque': list,
         # 'Any': object,

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/src/abstract_table.py

@@ -259,16 +259,19 @@ class AbstractTable(AbstractJoinable, abc.ABC):
     
     
     def drop(self, debug_mode = False):
-        query = "DROP TABLE " + self.name
+        quote = self.db1.identifier_quote
+        query = f"DROP TABLE {quote}{self.name}{quote}"
         if debug_mode:
             print(query)
         self.execute(query)
 
     def update(self, variable_assign, where=None, debug_mode = False):
+        quote = self.db1.identifier_quote
         if where is None:
-            query = "UPDATE " + self.name + " SET " + variable_assign
+            query = f"UPDATE {quote}{self.name}{quote} SET {quote}{variable_assign}{quote}"
         else:
-            query = "UPDATE " + self.name + " SET " + variable_assign + " WHERE " + where
+            query = f"UPDATE {quote}{self.name}{quote} SET {quote}{variable_assign}{quote} WHERE {quote}{where}{quote}"
+
         if debug_mode:
             print(query)
         return self.execute(query)
@@ -303,25 +306,25 @@ class AbstractTable(AbstractJoinable, abc.ABC):
             for column_name, column_type in types_without_id_column
         ]
 
+        quote = self.db1.identifier_quote
         column_value_string = ""
         for column_name, cell_value, column_type in update_df_row_list:
             if cell_value is None:
-                column_value_string += f"{column_name} = NULL, "
+                column_value_string += f"{quote}{column_name}{quote} = NULL, "
             elif column_type in ["double", "int", "tinyint"]:
-                column_value_string += f"{column_name} = {cell_value}, "
+                column_value_string += f"{quote}{column_name}{quote} = {cell_value}, "
             elif "varchar" in column_type:
-                column_value_string += f"{column_name} = '{cell_value}', "
+                column_value_string += f"{quote}{column_name}{quote} = '{cell_value}', "
             elif column_type in ["json", "text", "mediumtext", "longtext", "datetime"]:
-                column_value_string += f"{column_name} = '{cell_value}', "
+                column_value_string += f"{quote}{column_name}{quote} = '{cell_value}', "
             else:
                 raise AttributeError(f"Unknown column type '{column_type}'")
 
         column_value_string = column_value_string.rstrip(", ")
-        quote = self.db1.identifier_quote
         sql_query = f"UPDATE {quote}{self.name}{quote} SET {column_value_string}"
 
         if where_column is not None and where_value is not None:
-            sql_query += f" WHERE {where_column} = {where_value};"
+            sql_query += f" WHERE {quote}{where_column}{quote} = {where_value};"
         else:
             sql_query += ";"
         if debug_mode:
@@ -382,7 +385,7 @@ class AbstractTable(AbstractJoinable, abc.ABC):
             inserted_columns=list(dict.fromkeys(self.columns)) #DEDUPLICATION preserving order -> better than inserted_columns = set(self.columns) 
             id_index=inserted_columns.index(self.id_column_name)
             inserted_columns.pop(id_index)
-            print(inserted_columns,df.columns)
+            # print(inserted_columns,df.columns)
             
             assert set(df.columns) == set(inserted_columns) #elements are matchin
             #df = df[inserted_columns]
@@ -429,12 +432,7 @@ class AbstractTable(AbstractJoinable, abc.ABC):
         quote = self.db1.identifier_quote
 
         if where is None:
-            query = "DELETE FROM {quote}{self.name}{quote}"
+            query = f"DELETE FROM {quote}{self.name}{quote}"
         else:
             query = f"DELETE FROM {quote}{self.name}{quote} WHERE {where}"
         return self.execute(query)
-
-
-
-
-    

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/src/mysql_db.py

@@ -19,7 +19,8 @@ class MysqlDb(AbstractDb):
     'dict': "nvarchar(2047)",
     'bool': "tinyint",
     'datetime': "datetime",
-    'Jsonable': "json"
+    'Jsonable': "json",
+    'Blob': "mediumblob",
     }
 
     def __init__(self, *args, **kwargs):

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/src/tables.py

@@ -5,9 +5,8 @@ import abc
 import time
 #xlsx imports
 import pathlib
-
 from dbhydra.src.abstract_table import AbstractTable, AbstractSelectable, AbstractJoinable
-
+import binascii
 
 MONGO_OPERATOR_DICT = {"=": "$eq", ">": "$gt", ">=": "$gte", " IN ": "$in", "<": "$lt", "<=": "$lte", "<>": "$ne"}
 
@@ -807,7 +806,10 @@ class MysqlTable(AbstractTable):
                     query += "'" + str(rows[k][j]) + "',"
                 elif "json" in self.types[j + start_index]:
                     query += f"'{rows[k][j]}', "
-
+                elif 'blob' in self.types[j + start_index]:
+                    # Convert to hex to allow insertion into SQL query
+                    hex_data = binascii.hexlify(rows[k][j]).decode('ascii')
+                    query += f"UNHEX('{hex_data}'), "
 
                 else:
                     query += str(rows[k][j]) + ","
@@ -903,6 +905,11 @@ class XlsxTable(AbstractTable):
         self.table_directory_path: pathlib.Path = self.db1.db_directory_path / table_filename
 
     def _save_table(self, df: pd.DataFrame):
+        blob_columns = [
+            column for column, type_ in self.column_type_dict.items() if type_ == "Blob"
+        ]
+        df[blob_columns] = df[blob_columns].map(lambda x: x.hex() if x is not None else None)
+
         if self.db1.is_csv:
             df.to_csv(self.table_directory_path, index=False)
         else:
@@ -960,6 +967,9 @@ class XlsxTable(AbstractTable):
         date_columns = [
             column for column, type_ in self.column_type_dict.items() if type_ == "datetime"
         ]
+        blob_columns = [
+            column for column, type_ in self.column_type_dict.items() if type_ == "Blob"
+        ]
 
         # BUG: If XlsxTable is being accessed by multiple threads, read operation
         # might fail due to race conditions. Add retry mechanism to handle these cases.
@@ -974,6 +984,8 @@ class XlsxTable(AbstractTable):
                 else:
                     print(f"Failed to read data from {self.table_directory_path}, returning empty DataFrame")
                     df = pd.DataFrame(columns=self.columns)
+
+        df[blob_columns] = df[blob_columns].map(lambda x: bytes.fromhex(x) if x else None)
         return df
 
     def _select(self, column_type_map, date_columns):

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra/src/xlsx_db.py

@@ -41,7 +41,8 @@ class XlsxDb(AbstractDb):
         'dict': "str",
         'bool': "bool",
         'datetime': "datetime",
-        'Jsonable': "str"
+        'Jsonable': "str",
+        'Blob': "Blob"
         }
 
         

{dbhydra-2.2.6 → dbhydra-2.2.9}/dbhydra.egg-info/PKG-INFO

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

{dbhydra-2.2.6 → dbhydra-2.2.9}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
     
 setuptools.setup(
     name='dbhydra',
-    version='2.2.6',
+    version='2.2.9',
     author='DovaX',
     author_email='dovax.ai@gmail.com',
     description='Data science friendly ORM combining Python',