MindsDB 25.5.4.1__py3-none-any.whl → 25.6.2.0__py3-none-any.whl

mindsdb/api/mysql/mysql_proxy/utilities/dump.py

@@ -1,6 +1,7 @@
-import json
+import struct
 import datetime
 from typing import Any
+from array import array
 
 import numpy as np
 from numpy import dtype as np_dtype
@@ -9,11 +10,19 @@ from pandas.api import types as pd_types
 
 from mindsdb.api.executor.sql_query.result_set import ResultSet, get_mysql_data_type_from_series, Column
 from mindsdb.api.mysql.mysql_proxy.utilities.lightwood_dtype import dtype as lightwood_dtype
-from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE, DATA_C_TYPE_MAP, CTypeProperties
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
+    MYSQL_DATA_TYPE,
+    DATA_C_TYPE_MAP,
+    CTypeProperties,
+    CHARSET_NUMBERS,
+)
 from mindsdb.utilities import log
+from mindsdb.utilities.json_encoder import CustomJSONEncoder
 
 logger = log.getLogger(__name__)
 
+json_encoder = CustomJSONEncoder()
+
 
 def column_to_mysql_column_dict(column: Column, database_name: str | None = None) -> dict[str, str | int]:
     """Convert Column object to dict with column properties.
@@ -52,9 +61,13 @@ def column_to_mysql_column_dict(column: Column, database_name: str | None = None
     # endregion
 
     if isinstance(column.type, MYSQL_DATA_TYPE) is False:
-        logger.warning(f'Unexpected column type: {column.type}. Use TEXT as fallback.')
+        logger.warning(f"Unexpected column type: {column.type}. Use TEXT as fallback.")
         column.type = MYSQL_DATA_TYPE.TEXT
 
+    charset = CHARSET_NUMBERS["utf8_unicode_ci"]
+    if column.type in (MYSQL_DATA_TYPE.JSON, MYSQL_DATA_TYPE.VECTOR):
+        charset = CHARSET_NUMBERS["binary"]
+
     type_properties: CTypeProperties = DATA_C_TYPE_MAP[column.type]
 
     result = {
@@ -66,6 +79,7 @@ def column_to_mysql_column_dict(column: Column, database_name: str | None = None
         "size": type_properties.size,
         "flags": type_properties.flags,
         "type": type_properties.code,
+        "charset": charset,
     }
     return result
 
@@ -82,7 +96,7 @@ def _dump_bool(var: Any) -> int | None:
     """
     if pd.isna(var):
         return None
-    return '1' if var else '0'
+    return "1" if var else "0"
 
 
 def _dump_str(var: Any) -> str | None:
@@ -94,18 +108,19 @@ def _dump_str(var: Any) -> str | None:
     Returns:
         str | None: The string representation of the value or None if the value is None
     """
-    if pd.isna(var):
-        return None
     if isinstance(var, bytes):
         try:
-            return var.decode('utf-8')
+            return var.decode("utf-8")
         except Exception:
             return str(var)[2:-1]
-    if isinstance(var, dict):
+    if isinstance(var, (dict, list)):
         try:
-            return json.dumps(var)
+            return json_encoder.encode(var)
         except Exception:
             return str(var)
+    if isinstance(var, list) is False and pd.isna(var):
+        # pd.isna returns array of bools for list, so we need to check if it is not a list
+        return None
     return str(var)
 
 
@@ -142,7 +157,7 @@ def _dump_date(var: datetime.date | str | None) -> str | None:
         return var
     elif pd.isna(var):
         return None
-    logger.warning(f'Unexpected value type for DATE: {type(var)}, {var}')
+    logger.warning(f"Unexpected value type for DATE: {type(var)}, {var}")
     return _dump_str(var)
 
 
@@ -157,18 +172,18 @@ def _dump_datetime(var: datetime.datetime | str | None) -> str | None:
         str | None: The string representation of the datetime value or None if the value is None
     """
     if isinstance(var, datetime.date):  # it is also datetime.datetime
-        if hasattr(var, 'tzinfo') and var.tzinfo is not None:
+        if hasattr(var, "tzinfo") and var.tzinfo is not None:
             return var.astimezone(datetime.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
         return var.strftime("%Y-%m-%d %H:%M:%S")
     elif isinstance(var, pd.Timestamp):
         if var.tzinfo is not None:
-            return var.tz_convert('UTC').strftime("%Y-%m-%d %H:%M:%S")
+            return var.tz_convert("UTC").strftime("%Y-%m-%d %H:%M:%S")
         return var.strftime("%Y-%m-%d %H:%M:%S")
     elif isinstance(var, str):
         return var
     elif pd.isna(var):
         return None
-    logger.warning(f'Unexpected value type for DATETIME: {type(var)}, {var}')
+    logger.warning(f"Unexpected value type for DATETIME: {type(var)}, {var}")
     return _dump_str(var)
 
 
@@ -198,16 +213,34 @@ def _dump_time(var: datetime.time | str | None) -> str | None:
         return var.strftime("%H:%M:%S")
     elif isinstance(var, pd.Timestamp):
         if var.tzinfo is not None:
-            return var.tz_convert('UTC').strftime("%H:%M:%S")
+            return var.tz_convert("UTC").strftime("%H:%M:%S")
         return var.strftime("%H:%M:%S")
     elif isinstance(var, str):
         return var
     elif pd.isna(var):
         return None
-    logger.warning(f'Unexpected value type for TIME: {type(var)}, {var}')
+    logger.warning(f"Unexpected value type for TIME: {type(var)}, {var}")
     return _dump_str(var)
 
 
+def _dump_vector(value: Any) -> bytes | None:
+    """Convert array or list of floats to a bytes.
+
+    Args:
+        value (Any): The value to dump
+
+    Returns:
+        bytes | None: The bytes representation of the vector value or None if the value is None
+    """
+    if isinstance(value, (array, list, np.ndarray)):
+        return b"".join([struct.pack("<f", el) for el in value])
+    elif pd.isna(value):
+        return None
+    err_msg = f"Unexpected value type for VECTOR: {type(value)}, {value}"
+    logger.error(err_msg)
+    raise ValueError(err_msg)
+
+
 def _handle_series_as_date(series: pd.Series) -> pd.Series:
     """Convert values in a series to a string representation of a date.
     NOTE: MySQL require exactly %Y-%m-%d for DATE type.
@@ -219,10 +252,10 @@ def _handle_series_as_date(series: pd.Series) -> pd.Series:
         pd.Series: The series with the date values as strings
     """
     if pd_types.is_datetime64_any_dtype(series.dtype):
-        return series.dt.strftime('%Y-%m-%d')
+        return series.dt.strftime("%Y-%m-%d")
     elif pd_types.is_object_dtype(series.dtype):
         return series.apply(_dump_date)
-    logger.info(f'Unexpected dtype: {series.dtype} for column with type DATE')
+    logger.info(f"Unexpected dtype: {series.dtype} for column with type DATE")
     return series.apply(_dump_str)
 
 
@@ -237,10 +270,10 @@ def _handle_series_as_datetime(series: pd.Series) -> pd.Series:
         pd.Series: The series with the datetime values as strings
     """
     if pd_types.is_datetime64_any_dtype(series.dtype):
-        return series.dt.strftime('%Y-%m-%d %H:%M:%S')
+        return series.dt.strftime("%Y-%m-%d %H:%M:%S")
     elif pd_types.is_object_dtype(series.dtype):
         return series.apply(_dump_datetime)
-    logger.info(f'Unexpected dtype: {series.dtype} for column with type DATETIME')
+    logger.info(f"Unexpected dtype: {series.dtype} for column with type DATETIME")
     return series.apply(_dump_str)
 
 
@@ -255,14 +288,14 @@ def _handle_series_as_time(series: pd.Series) -> pd.Series:
         pd.Series: The series with the time values as strings
     """
     if pd_types.is_timedelta64_ns_dtype(series.dtype):
-        base_time = pd.Timestamp('2000-01-01')
-        series = ((base_time + series).dt.strftime('%H:%M:%S'))
+        base_time = pd.Timestamp("2000-01-01")
+        series = (base_time + series).dt.strftime("%H:%M:%S")
     elif pd_types.is_datetime64_dtype(series.dtype):
-        series = series.dt.strftime('%H:%M:%S')
+        series = series.dt.strftime("%H:%M:%S")
     elif pd_types.is_object_dtype(series.dtype):
         series = series.apply(_dump_time)
     else:
-        logger.info(f'Unexpected dtype: {series.dtype} for column with type TIME')
+        logger.info(f"Unexpected dtype: {series.dtype} for column with type TIME")
         series = series.apply(_dump_str)
     return series
 
@@ -278,14 +311,29 @@ def _handle_series_as_int(series: pd.Series) -> pd.Series:
         pd.Series: The series with the int values as strings
     """
     if pd_types.is_integer_dtype(series.dtype):
-        if series.dtype == 'Int64':
+        if series.dtype == "Int64":
             # NOTE: 'apply' converts values to python floats
             return series.astype(object).apply(_dump_str)
         return series.apply(_dump_str)
     return series.apply(_dump_int_or_str)
 
 
-def dump_result_set_to_mysql(result_set: ResultSet, infer_column_size: bool = False) -> tuple[pd.DataFrame, list[dict[str, str | int]]]:
+def _handle_series_as_vector(series: pd.Series) -> pd.Series:
+    """Convert values in a series to a bytes representation of a vector.
+    NOTE: MySQL's VECTOR type require exactly 4 bytes per float.
+
+    Args:
+        series (pd.Series): The series to handle
+
+    Returns:
+        pd.Series: The series with the vector values as bytes
+    """
+    return series.apply(_dump_vector)
+
+
+def dump_result_set_to_mysql(
+    result_set: ResultSet, infer_column_size: bool = False
+) -> tuple[pd.DataFrame, list[dict[str, str | int]]]:
     """
     Dumps the ResultSet to a format that can be used to send as MySQL response packet.
     NOTE: This method modifies the original DataFrame and columns.
@@ -319,10 +367,16 @@ def dump_result_set_to_mysql(result_set: ResultSet, infer_column_size: bool = Fa
             case MYSQL_DATA_TYPE.TIME:
                 series = _handle_series_as_time(series)
             case (
-                MYSQL_DATA_TYPE.INT | MYSQL_DATA_TYPE.TINYINT | MYSQL_DATA_TYPE.SMALLINT
-                | MYSQL_DATA_TYPE.MEDIUMINT | MYSQL_DATA_TYPE.BIGINT | MYSQL_DATA_TYPE.YEAR
+                MYSQL_DATA_TYPE.INT
+                | MYSQL_DATA_TYPE.TINYINT
+                | MYSQL_DATA_TYPE.SMALLINT
+                | MYSQL_DATA_TYPE.MEDIUMINT
+                | MYSQL_DATA_TYPE.BIGINT
+                | MYSQL_DATA_TYPE.YEAR
             ):
                 series = _handle_series_as_int(series)
+            case MYSQL_DATA_TYPE.VECTOR:
+                series = _handle_series_as_vector(series)
             case _:
                 series = series.apply(_dump_str)
 
@@ -330,22 +384,19 @@ def dump_result_set_to_mysql(result_set: ResultSet, infer_column_size: bool = Fa
         # we may split this operation for dt and other types for optimisation
         df[i] = series.replace([np.NaN, pd.NA, pd.NaT], None)
 
-    columns_dicts = [
-        column_to_mysql_column_dict(column)
-        for column in result_set.columns
-    ]
+    columns_dicts = [column_to_mysql_column_dict(column) for column in result_set.columns]
 
-    if infer_column_size and any(column_info.get('size') is None for column_info in columns_dicts):
+    if infer_column_size and any(column_info.get("size") is None for column_info in columns_dicts):
         if len(df) == 0:
             for column_info in columns_dicts:
-                if column_info['size'] is None:
-                    column_info['size'] = 1
+                if column_info["size"] is None:
+                    column_info["size"] = 1
         else:
             sample = df.head(100)
             for i, column_info in enumerate(columns_dicts):
                 try:
-                    column_info['size'] = sample[sample.columns[i]].astype(str).str.len().max()
+                    column_info["size"] = sample[sample.columns[i]].astype(str).str.len().max()
                 except Exception:
-                    column_info['size'] = 1
+                    column_info["size"] = 1
 
     return df, columns_dicts

mindsdb/integrations/handlers/file_handler/file_handler.py

@@ -75,10 +75,7 @@ class FileHandler(DatabaseHandler):
     def query(self, query: ASTNode) -> Response:
         if type(query) is DropTables:
             for table_identifier in query.tables:
-                if (
-                    len(table_identifier.parts) == 2
-                    and table_identifier.parts[0] != self.name
-                ):
+                if len(table_identifier.parts) == 2 and table_identifier.parts[0] != self.name:
                     return Response(
                         RESPONSE_TYPE.ERROR,
                         error_message=f"Can't delete table from database '{table_identifier.parts[0]}'",
@@ -136,9 +133,20 @@ class FileHandler(DatabaseHandler):
             return Response(RESPONSE_TYPE.OK)
 
         elif isinstance(query, Select):
-            table_name, page_name = self._get_table_page_names(query.from_table)
+            if isinstance(query.from_table, Select):
+                # partitioning mode
+                sub_result = self.query(query.from_table)
+                if sub_result.error_message is not None:
+                    raise RuntimeError(sub_result.error_message)
 
-            df = self.file_controller.get_file_data(table_name, page_name)
+                df = sub_result.data_frame
+                query.from_table = Identifier("t")
+            elif isinstance(query.from_table, Identifier):
+                table_name, page_name = self._get_table_page_names(query.from_table)
+
+                df = self.file_controller.get_file_data(table_name, page_name)
+            else:
+                raise RuntimeError(f"Not supported query target: {query}")
 
             # Process the SELECT query
             result_df = query_df(df, query)
@@ -191,9 +199,7 @@ class FileHandler(DatabaseHandler):
             data_frame=pd.DataFrame(
                 [
                     {
-                        "Field": x["name"].strip()
-                        if isinstance(x, dict)
-                        else x.strip(),
+                        "Field": x["name"].strip() if isinstance(x, dict) else x.strip(),
                         "Type": "str",
                     }
                     for x in file_meta["columns"]

mindsdb/integrations/handlers/file_handler/tests/test_file_handler.py

@@ -7,12 +7,22 @@ from pathlib import Path
 import pandas
 import pytest
 from mindsdb_sql_parser.exceptions import ParsingException
-from mindsdb_sql_parser.ast import CreateTable, DropTables, Identifier, Insert, TableColumn, Update
+from mindsdb_sql_parser.ast import (
+    CreateTable,
+    DropTables,
+    Identifier,
+    Insert,
+    TableColumn,
+    Update,
+)
 
 from mindsdb.integrations.handlers.file_handler.file_handler import FileHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
-from mindsdb.integrations.utilities.files.file_reader import FileReader
+from mindsdb.integrations.utilities.files.file_reader import (
+    FileReader,
+    FileProcessingError,
+)
 
 
 # Define a table to use as content for all of the file types
@@ -103,21 +113,18 @@ class TestIsItX:
 
     def test_is_it_csv(self):
         # We can't test xlsx or parquet here because they're binary files
-        for file_path, result in (
-            (csv_file(), True),
-            (json_file(), False)
-        ):
+        for file_path, result in ((csv_file(), True), (json_file(), False)):
             with open(file_path, "r") as fh:
                 assert FileReader.is_csv(StringIO(fh.read())) is result
 
     def test_format(self):
         for file_path, result in (
-            (csv_file(), 'csv'),
-            (xlsx_file(), 'xlsx'),
-            (json_file(), 'json'),
-            (parquet_file(), 'parquet'),
-            (txt_file(), 'txt'),
-            (pdf_file(), 'pdf'),
+            (csv_file(), "csv"),
+            (xlsx_file(), "xlsx"),
+            (json_file(), "json"),
+            (parquet_file(), "parquet"),
+            (txt_file(), "txt"),
+            (pdf_file(), "pdf"),
         ):
             assert FileReader(path=file_path).get_format() == result
 
@@ -182,6 +189,7 @@ class TestQuery:
 
         def mock_get_file_path(self, name):
             return csv_tmp
+
         monkeypatch.setattr(MockFileController, "get_file_path", mock_get_file_path)
 
         file_handler = FileHandler(file_controller=MockFileController())
@@ -255,14 +263,13 @@ class TestQuery:
 
 
 def test_handle_source():
-
     def get_reader(file_path):
         # using path
         reader = FileReader(path=file_path)
         yield reader
 
         # using file descriptor
-        with open(file_path, 'rb') as fd:
+        with open(file_path, "rb") as fd:
             reader = FileReader(file=fd)
             yield reader
             fd.seek(0)
@@ -310,14 +317,31 @@ def test_check_valid_dialects(csv_string, delimiter):
 def test_tsv():
     file = BytesIO(b"example;csv;file\tname")
 
-    reader = FileReader(file=file, name='test.tsv')
-    assert reader.get_format() == 'csv'
-    assert reader.parameters['delimiter'] == '\t'
+    reader = FileReader(file=file, name="test.tsv")
+    assert reader.get_format() == "csv"
+    assert reader.parameters["delimiter"] == "\t"
 
     df = reader.get_page_content()
     assert len(df.columns) == 2
 
 
+def test_bad_csv_header():
+    file = BytesIO(b" a,b  ,c\n1,2,3\n")
+    reader = FileReader(file=file, name="test.tsv")
+    df = reader.get_page_content()
+    assert set(df.columns) == set(["a", "b", "c"])
+
+    wrong_data = [
+        b"a, ,c\n1,2,3\n",
+        b"a,  \t,c\n1,2,3\n",
+        b"   ,b,c\n1,2,3\n",
+    ]
+    for data in wrong_data:
+        reader = FileReader(file=BytesIO(data), name="test.tsv")
+        with pytest.raises(FileProcessingError):
+            df = reader.get_page_content()
+
+
 def test_check_invalid_dialects():
     with pytest.raises(Exception):
         FileHandler._get_csv_dialect("example csv file")
@@ -334,10 +358,7 @@ def test_get_tables():
     assert response.type == RESPONSE_TYPE.TABLE
 
     expected_df = pandas.DataFrame(
-        [
-            {"TABLE_NAME": x[0], "TABLE_ROWS": x[1], "TABLE_TYPE": "BASE TABLE"}
-            for x in file_records
-        ]
+        [{"TABLE_NAME": x[0], "TABLE_ROWS": x[1], "TABLE_TYPE": "BASE TABLE"} for x in file_records]
     )
 
     assert response.data_frame.equals(expected_df)
@@ -349,8 +370,6 @@ def test_get_columns():
 
     assert response.type == RESPONSE_TYPE.TABLE
 
-    expected_df = pandas.DataFrame(
-        [{"Field": x, "Type": "str"} for x in file_records[0][2]]
-    )
+    expected_df = pandas.DataFrame([{"Field": x, "Type": "str"} for x in file_records[0][2]])
 
     assert response.data_frame.equals(expected_df)

mindsdb/integrations/handlers/litellm_handler/litellm_handler.py

@@ -2,7 +2,7 @@ import ast
 from typing import Dict, Optional, List
 
 
-from litellm import completion, batch_completion, embedding
+from litellm import completion, batch_completion, embedding, acompletion
 import pandas as pd
 
 from mindsdb.integrations.libs.base import BaseMLEngine
@@ -42,10 +42,17 @@ class LiteLLMHandler(BaseMLEngine):
                 f"https://{args['snowflake_account_id']}.snowflakecomputing.com/api/v2/cortex/inference:complete"
             )
 
-        from litellm import acompletion
-
         return await acompletion(model=model, messages=messages, stream=False, **args)
 
+    @staticmethod
+    def completion(model: str, messages: List[dict], args: dict):
+        if model.startswith("snowflake/") and "snowflake_account_id" in args:
+            args["api_base"] = (
+                f"https://{args['snowflake_account_id']}.snowflakecomputing.com/api/v2/cortex/inference:complete"
+            )
+
+        return completion(model=model, messages=messages, stream=False, **args)
+
     def create(
         self,
         target: str,

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -31,9 +31,7 @@ def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
     try:
         return MYSQL_DATA_TYPE(mysql_type_text.upper())
     except Exception:
-        logger.warning(
-            f"MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback."
-        )
+        logger.warning(f"MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback.")
         return MYSQL_DATA_TYPE.TEXT
 
 
@@ -65,22 +63,23 @@ def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQ
             mysql_types.append(reverse_c_type_map[type_int])
             continue
 
-        if type_int != C_TYPES.MYSQL_TYPE_BLOB:
-            raise ValueError(f'Unknown MySQL type id={type_int} in column {col[0]}')
-
-        # region determine text/blob type by flags
-        # Unfortunately, there is no way to determine particular type of text/blob column by flags.
-        # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
-        # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
-        # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
-        if col[7] == 16:  # and col[8] == 45
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-        elif col[7] == 144:  # and col[8] == 63
-            mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+        if type_int == C_TYPES.MYSQL_TYPE_BLOB:
+            # region determine text/blob type by flags
+            # Unfortunately, there is no way to determine particular type of text/blob column by flags.
+            # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
+            # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
+            # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
+            if col[7] == 16:  # and col[8] == 45
+                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            elif col[7] == 144:  # and col[8] == 63
+                mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+            else:
+                logger.debug(f"MySQL handler: unknown type code {col[7]}, use TEXT as fallback.")
+                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            # endregion
         else:
-            logger.debug(f'MySQL handler: unknown type code {col[7]}, use TEXT as fallback.')
+            logger.warning(f"MySQL handler: unknown type id={type_int} in column {col[0]}, use TEXT as fallback.")
             mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-        # endregion
 
     # region cast int and bool to nullable types
     serieses = []
@@ -88,22 +87,20 @@ def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQ
         expected_dtype = None
         column_name = description[i][0]
         if mysql_type in (
-            MYSQL_DATA_TYPE.SMALLINT, MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.MEDIUMINT,
-            MYSQL_DATA_TYPE.BIGINT, MYSQL_DATA_TYPE.TINYINT
+            MYSQL_DATA_TYPE.SMALLINT,
+            MYSQL_DATA_TYPE.INT,
+            MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.BIGINT,
+            MYSQL_DATA_TYPE.TINYINT,
         ):
-            expected_dtype = 'Int64'
+            expected_dtype = "Int64"
         elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
-            expected_dtype = 'boolean'
+            expected_dtype = "boolean"
         serieses.append(pd.Series([row[column_name] for row in result], dtype=expected_dtype, name=description[i][0]))
     df = pd.concat(serieses, axis=1, copy=False)
     # endregion
 
-    response = Response(
-        RESPONSE_TYPE.TABLE,
-        df,
-        affected_rows=cursor.rowcount,
-        mysql_types=mysql_types
-    )
+    response = Response(RESPONSE_TYPE.TABLE, df, affected_rows=cursor.rowcount, mysql_types=mysql_types)
     return response
 
 
@@ -219,9 +216,7 @@ class MySQLHandler(DatabaseHandler):
             connection = self.connect()
             result.success = connection.is_connected()
         except mysql.connector.Error as e:
-            logger.error(
-                f'Error connecting to MySQL {self.connection_data["database"]}, {e}!'
-            )
+            logger.error(f"Error connecting to MySQL {self.connection_data['database']}, {e}!")
             result.error_message = str(e)
 
         if result.success and need_to_close:
@@ -252,9 +247,7 @@ class MySQLHandler(DatabaseHandler):
                 else:
                     response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
         except mysql.connector.Error as e:
-            logger.error(
-                f'Error running query: {query} on {self.connection_data["database"]}!'
-            )
+            logger.error(f"Error running query: {query} on {self.connection_data['database']}!")
             response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
             if connection is not None and connection.is_connected():
                 connection.rollback()