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

mindsdb/api/executor/sql_query/steps/insert_step.py

@@ -2,23 +2,15 @@ from mindsdb_sql_parser.ast import (
     Identifier,
 )
 
-from mindsdb.api.executor.planner.steps import (
-    SaveToTable,
-    InsertToTable,
-    CreateTableStep
-)
+from mindsdb.api.executor.planner.steps import SaveToTable, InsertToTable, CreateTableStep
 from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
-from mindsdb.api.executor.exceptions import (
-    NotSupportedYet,
-    LogicError
-)
+from mindsdb.api.executor.exceptions import NotSupportedYet, LogicError
 from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
 
 from .base import BaseStepCall
 
 
 class InsertToTableCall(BaseStepCall):
-
     bind = InsertToTable
 
     def call(self, step):
@@ -35,16 +27,16 @@ class InsertToTableCall(BaseStepCall):
             integration_name = step.table.parts[0]
             table_name = Identifier(parts=step.table.parts[1:])
         else:
-            integration_name = self.context['database']
+            integration_name = self.context["database"]
             table_name = step.table
 
         dn = self.session.datahub.get(integration_name)
 
-        if hasattr(dn, 'create_table') is False:
+        if hasattr(dn, "create_table") is False:
             raise NotSupportedYet(f"Creating table in '{integration_name}' is not supported")
 
         if step.dataframe is not None:
-            data = self.steps_data[step.dataframe.result.step_num]
+            data = self.steps_data[step.dataframe.step_num]
         elif step.query is not None:
             data = ResultSet()
             if step.query.columns is None:
@@ -62,7 +54,7 @@ class InsertToTableCall(BaseStepCall):
             for row in step.query.values:
                 record = []
                 for v in row:
-                    if isinstance(v, Identifier) and v.parts[0] == 'None':
+                    if isinstance(v, Identifier) and v.parts[0] == "None":
                         # Allow explicitly inserting NULL values.
                         record.append(None)
                         continue
@@ -72,12 +64,12 @@ class InsertToTableCall(BaseStepCall):
 
             data.add_raw_values(records)
         else:
-            raise LogicError(f'Data not found for insert: {step}')
+            raise LogicError(f"Data not found for insert: {step}")
 
         #  del 'service' columns
-        for col in data.find_columns('__mindsdb_row_id'):
+        for col in data.find_columns("__mindsdb_row_id"):
             data.del_column(col)
-        for col in data.find_columns('__mdb_forecast_offset'):
+        for col in data.find_columns("__mdb_forecast_offset"):
             data.del_column(col)
 
         # region del columns filtered at projection step
@@ -85,7 +77,7 @@ class InsertToTableCall(BaseStepCall):
         if columns_list is not None:
             filtered_column_names = [x.name for x in columns_list]
             for col in data.columns:
-                if col.name.startswith('predictor.'):
+                if col.name.startswith("predictor."):
                     continue
                 if col.name in filtered_column_names:
                     continue
@@ -101,39 +93,27 @@ class InsertToTableCall(BaseStepCall):
                 col_names.add(col.alias)
 
         response = dn.create_table(
-            table_name=table_name,
-            result_set=data,
-            is_replace=is_replace,
-            is_create=is_create,
-            params=step.params
+            table_name=table_name, result_set=data, is_replace=is_replace, is_create=is_create, params=step.params
         )
         return ResultSet(affected_rows=response.affected_rows)
 
 
 class SaveToTableCall(InsertToTableCall):
-
     bind = SaveToTable
 
 
 class CreateTableCall(BaseStepCall):
-
     bind = CreateTableStep
 
     def call(self, step):
-
         if len(step.table.parts) > 1:
             integration_name = step.table.parts[0]
             table_name = Identifier(parts=step.table.parts[1:])
         else:
-            integration_name = self.context['database']
+            integration_name = self.context["database"]
             table_name = step.table
 
         dn = self.session.datahub.get(integration_name)
 
-        dn.create_table(
-            table_name=table_name,
-            columns=step.columns,
-            is_replace=step.is_replace,
-            is_create=True
-        )
+        dn.create_table(table_name=table_name, columns=step.columns, is_replace=step.is_replace, is_create=True)
         return ResultSet()

mindsdb/api/executor/sql_query/steps/subselect_step.py

@@ -2,29 +2,22 @@ from collections import defaultdict
 
 import pandas as pd
 
-from mindsdb_sql_parser.ast import (
-    Identifier, Select, Star, Constant, Parameter, Function, Variable, BinaryOperation
-)
+from mindsdb_sql_parser.ast import Identifier, Select, Star, Constant, Parameter, Function, Variable, BinaryOperation
 
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import SERVER_VARIABLES
-
 from mindsdb.api.executor.planner.step_result import Result
 from mindsdb.api.executor.planner.steps import SubSelectStep, QueryStep
-from mindsdb.integrations.utilities.query_traversal import query_traversal
-
 from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
 from mindsdb.api.executor.utilities.sql import query_df
-
-from mindsdb.interfaces.query_context.context_controller import query_context_controller
-
 from mindsdb.api.executor.exceptions import KeyColumnDoesNotExist
+from mindsdb.integrations.utilities.query_traversal import query_traversal
+from mindsdb.interfaces.query_context.context_controller import query_context_controller
 
 from .base import BaseStepCall
 from .fetch_dataframe import get_fill_param_fnc
 
 
 class SubSelectStepCall(BaseStepCall):
-
     bind = SubSelectStep
 
     def call(self, step):
@@ -32,12 +25,12 @@ class SubSelectStepCall(BaseStepCall):
 
         table_name = step.table_name
         if table_name is None:
-            table_name = 'df_table'
+            table_name = "df_table"
         else:
             table_name = table_name
 
         query = step.query
-        query.from_table = Identifier('df_table')
+        query.from_table = Identifier("df_table")
 
         if step.add_absent_cols and isinstance(query, Select):
             query_cols = set()
@@ -64,6 +57,7 @@ class SubSelectStepCall(BaseStepCall):
                 if isinstance(node, Parameter) and isinstance(node.value, Result):
                     prev_result = self.steps_data[node.value.step_num]
                     return Constant(prev_result.get_column_values(col_idx=0)[0])
+
             query_traversal(query, inject_values)
 
         df = result.to_df()
@@ -76,7 +70,6 @@ class SubSelectStepCall(BaseStepCall):
 
 
 class QueryStepCall(BaseStepCall):
-
     bind = QueryStep
 
     def call(self, step: QueryStep):
@@ -103,6 +96,15 @@ class QueryStepCall(BaseStepCall):
             if col.table_name != col.table_alias:
                 tbl_idx[col.table_alias].append(name)
 
+        lower_col_idx = {}
+        for key, value in col_idx.items():
+            if isinstance(key, int):
+                key = str(key)
+            if isinstance(key, str):
+                lower_col_idx[key.lower()] = value
+                continue
+            lower_col_idx[tuple(str(x).lower() for x in key)] = value
+
         # get aliases of first level
         aliases = []
         for col in query.targets:
@@ -120,7 +122,8 @@ class QueryStepCall(BaseStepCall):
                     "user": self.session.username,
                     "version": "8.0.17",
                     "current_schema": "public",
-                    "connection_id": self.context.get('connection_id')
+                    "schema": "public",
+                    "connection_id": self.context.get("connection_id"),
                 }
                 if function_name in functions_results:
                     return Constant(functions_results[function_name], alias=Identifier(parts=[function_name]))
@@ -144,14 +147,11 @@ class QueryStepCall(BaseStepCall):
                     else:
                         # replace with all columns from table
                         table_name = node.parts[-2]
-                        return [
-                            Identifier(parts=[col])
-                            for col in tbl_idx.get(table_name, [])
-                        ]
+                        return [Identifier(parts=[col]) for col in tbl_idx.get(table_name, [])]
 
                 if node.parts[-1].lower() == "session_user":
                     return Constant(self.session.username, alias=node)
-                if node.parts[-1].lower() == '$$':
+                if node.parts[-1].lower() == "$$":
                     # NOTE: sinve version 9.0 mysql client sends query 'select $$'.
                     # Connection can be continued only if answer is parse error.
                     raise ValueError(
@@ -159,23 +159,31 @@ class QueryStepCall(BaseStepCall):
                         "version for the right syntax to use near '$$' at line 1"
                     )
 
-                if len(node.parts) == 1:
-                    key = col_name
-                    if key in aliases:
-                        # key is defined as alias
-                        return
-                else:
-                    table_name = node.parts[-2]
-                    key = (table_name, col_name)
+                match node.parts, node.is_quoted:
+                    case [column_name], [column_quoted]:
+                        if column_name in aliases:
+                            # key is defined as alias
+                            return
 
-                if key not in col_idx:
-                    if len(node.parts) == 1:
-                        # it can be local alias of a query
-                        return
+                        key = column_name if column_quoted else column_name.lower()
+
+                        if key not in col_idx and key not in lower_col_idx:
+                            # it can be local alias of a query, like:
+                            # SELECT t1.a + t2.a col1, min(t1.a) c
+                            # FROM dummy_data.tbl1 as t1
+                            # JOIN pg.tbl2 as t2 on t1.c=t2.c
+                            # group by col1
+                            # order by c -- <--- "с" is alias
+                            return
+                    case [*_, table_name, column_name], [*_, column_quoted]:
+                        key = (table_name, column_name) if column_quoted else (table_name.lower(), column_name.lower())
+
+                search_idx = col_idx if column_quoted else lower_col_idx
 
-                    raise KeyColumnDoesNotExist(f'Table not found for column: {key}')
+                if key not in search_idx:
+                    raise KeyColumnDoesNotExist(f"Table not found for column: {key}")
 
-                new_name = col_idx[key]
+                new_name = search_idx[key]
                 return Identifier(parts=[new_name], alias=node.alias)
 
         # fill params
@@ -196,14 +204,14 @@ class QueryStepCall(BaseStepCall):
                             if key not in col_idx:
                                 # exclude
                                 node.args = [Constant(0), Constant(0)]
-                                node.op = '='
+                                node.op = "="
 
             query_traversal(query.where, remove_not_used_conditions)
 
         query_traversal(query, check_fields)
         query.where = query_context_controller.remove_lasts(query.where)
 
-        query.from_table = Identifier('df_table')
+        query.from_table = Identifier("df_table")
         res = query_df(df, query, session=self.session)
 
         return ResultSet.from_df_cols(df=res, columns_dict=col_names, strict=False)

mindsdb/api/executor/utilities/sql.py

@@ -8,10 +8,7 @@ import numpy as np
 from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.utilities.query_traversal import query_traversal
-from mindsdb_sql_parser.ast import (
-    ASTNode, Select, Identifier,
-    Function, Constant
-)
+from mindsdb_sql_parser.ast import ASTNode, Select, Identifier, Function, Constant
 from mindsdb.utilities.functions import resolve_table_identifier, resolve_model_identifier
 
 from mindsdb.utilities import log
@@ -53,37 +50,38 @@ def get_query_models(query: ASTNode, default_database: str = None) -> List[tuple
 
 
 def query_df_with_type_infer_fallback(query_str: str, dataframes: dict, user_functions=None):
-    ''' Duckdb need to infer column types if column.dtype == object. By default it take 1000 rows,
-        but that may be not sufficient for some cases. This func try to run query multiple times
-        increasing butch size for type infer
+    """Duckdb need to infer column types if column.dtype == object. By default it take 1000 rows,
+    but that may be not sufficient for some cases. This func try to run query multiple times
+    increasing butch size for type infer
 
-        Args:
-            query_str (str): query to execute
-            dataframes (dict): dataframes
-            user_functions: functions controller which register new functions in connection
+    Args:
+        query_str (str): query to execute
+        dataframes (dict): dataframes
+        user_functions: functions controller which register new functions in connection
 
-        Returns:
-            pandas.DataFrame
-            pandas.columns
-    '''
+    Returns:
+        pandas.DataFrame
+        pandas.columns
+    """
 
     for name, value in dataframes.items():
         locals()[name] = value
 
-    con = duckdb.connect(database=':memory:')
+    con = duckdb.connect(database=":memory:")
     if user_functions:
         user_functions.register(con)
 
+    exception = None
     for sample_size in [1000, 10000, 1000000]:
         try:
-            con.execute(f'set global pandas_analyze_sample={sample_size};')
+            con.execute(f"set global pandas_analyze_sample={sample_size};")
             result_df = con.execute(query_str).fetchdf()
-        except InvalidInputException:
-            pass
+        except InvalidInputException as e:
+            exception = e
         else:
             break
     else:
-        raise InvalidInputException
+        raise exception
     description = con.description
     con.close()
 
@@ -91,14 +89,14 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict, user_fun
 
 
 def query_df(df, query, session=None):
-    """ Perform simple query ('select' from one table, without subqueries and joins) on DataFrame.
+    """Perform simple query ('select' from one table, without subqueries and joins) on DataFrame.
 
-        Args:
-            df (pandas.DataFrame): data
-            query (mindsdb_sql_parser.ast.Select | str): select query
+    Args:
+        df (pandas.DataFrame): data
+        query (mindsdb_sql_parser.ast.Select | str): select query
 
-        Returns:
-            pandas.DataFrame
+    Returns:
+        pandas.DataFrame
     """
 
     if isinstance(query, str):
@@ -106,14 +104,11 @@ def query_df(df, query, session=None):
     else:
         query_ast = copy.deepcopy(query)
 
-    if isinstance(query_ast, Select) is False \
-       or isinstance(query_ast.from_table, Identifier) is False:
-        raise Exception(
-            "Only 'SELECT from TABLE' statements supported for internal query"
-        )
+    if isinstance(query_ast, Select) is False or isinstance(query_ast.from_table, Identifier) is False:
+        raise Exception("Only 'SELECT from TABLE' statements supported for internal query")
 
     table_name = query_ast.from_table.parts[0]
-    query_ast.from_table.parts = ['df']
+    query_ast.from_table.parts = ["df"]
 
     json_columns = set()
 
@@ -131,18 +126,18 @@ def query_df(df, query, session=None):
                 return node
         if isinstance(node, Function):
             fnc_name = node.op.lower()
-            if fnc_name == 'database' and len(node.args) == 0:
+            if fnc_name == "database" and len(node.args) == 0:
                 if session is not None:
                     cur_db = session.database
                 else:
                     cur_db = None
                 return Constant(cur_db)
-            elif fnc_name == 'truncate':
+            elif fnc_name == "truncate":
                 # replace mysql 'truncate' function to duckdb 'round'
-                node.op = 'round'
+                node.op = "round"
                 if len(node.args) == 1:
                     node.args.append(0)
-            elif fnc_name == 'json_extract':
+            elif fnc_name == "json_extract":
                 json_columns.add(node.args[0].parts[-1])
             else:
                 if user_functions is not None:
@@ -160,28 +155,27 @@ def query_df(df, query, session=None):
             except Exception:
                 pass
         return v
+
     for column in json_columns:
         df[column] = df[column].apply(_convert)
 
-    render = SqlalchemyRender('postgres')
+    render = SqlalchemyRender("postgres")
     try:
         query_str = render.get_string(query_ast, with_failback=False)
     except Exception as e:
-        logger.error(
-            f"Exception during query casting to 'postgres' dialect. Query: {str(query)}. Error: {e}"
-        )
+        logger.error(f"Exception during query casting to 'postgres' dialect. Query: {str(query)}. Error: {e}")
         query_str = render.get_string(query_ast, with_failback=True)
 
     # workaround to prevent duckdb.TypeMismatchException
     if len(df) > 0:
-        if table_name.lower() in ('models', 'predictors'):
-            if 'TRAINING_OPTIONS' in df.columns:
-                df = df.astype({'TRAINING_OPTIONS': 'string'})
-        if table_name.lower() == 'ml_engines':
-            if 'CONNECTION_DATA' in df.columns:
-                df = df.astype({'CONNECTION_DATA': 'string'})
-
-    result_df, description = query_df_with_type_infer_fallback(query_str, {'df': df}, user_functions=user_functions)
+        if table_name.lower() in ("models", "predictors"):
+            if "TRAINING_OPTIONS" in df.columns:
+                df = df.astype({"TRAINING_OPTIONS": "string"})
+        if table_name.lower() == "ml_engines":
+            if "CONNECTION_DATA" in df.columns:
+                df = df.astype({"CONNECTION_DATA": "string"})
+
+    result_df, description = query_df_with_type_infer_fallback(query_str, {"df": df}, user_functions=user_functions)
     result_df.replace({np.nan: None}, inplace=True)
     result_df.columns = [x[0] for x in description]
     return result_df

mindsdb/api/http/namespaces/config.py

@@ -28,7 +28,7 @@ class GetConfig(Resource):
     def get(self):
         config = Config()
         resp = {"auth": {"http_auth_enabled": config["auth"]["http_auth_enabled"]}}
-        for key in ["default_llm", "default_embedding_model", "default_reranking_model"]:
+        for key in ["default_llm", "default_embedding_model", "default_reranking_model", "a2a"]:
             value = config.get(key)
             if value is not None:
                 resp[key] = value

mindsdb/api/http/namespaces/file.py

@@ -18,6 +18,7 @@ from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities import log
 from mindsdb.utilities.security import is_private_url, clear_filename, validate_urls
 from mindsdb.utilities.fs import safe_extract
+from mindsdb.integrations.utilities.files.file_reader import FileProcessingError
 
 logger = log.getLogger(__name__)
 MAX_FILE_SIZE = 1024 * 1024 * 100  # 100Mb
@@ -26,7 +27,7 @@ MAX_FILE_SIZE = 1024 * 1024 * 100  # 100Mb
 @ns_conf.route("/")
 class FilesList(Resource):
     @ns_conf.doc("get_files_list")
-    @api_endpoint_metrics('GET', '/files')
+    @api_endpoint_metrics("GET", "/files")
     def get(self):
         """List all files"""
         return ca.file_controller.get_files()
@@ -36,7 +37,7 @@ class FilesList(Resource):
 @ns_conf.param("name", "MindsDB's name for file")
 class File(Resource):
     @ns_conf.doc("put_file")
-    @api_endpoint_metrics('PUT', '/files/file')
+    @api_endpoint_metrics("PUT", "/files/file")
     def put(self, name: str):
         """add new file
         params in FormData:
@@ -105,15 +106,13 @@ class File(Resource):
         if data.get("source_type") == "url":
             url = data["source"]
             config = Config()
-            allowed_urls = config.get('file_upload_domains', [])
+            allowed_urls = config.get("file_upload_domains", [])
             if allowed_urls and not validate_urls(url, allowed_urls):
                 return http_error(400, "Invalid File URL source.", f"Allowed hosts are: {', '.join(allowed_urls)}.")
             data["file"] = clear_filename(data["name"])
             is_cloud = config.get("cloud", False)
             if is_cloud and is_private_url(url):
-                return http_error(
-                    400, f'URL is private: {url}'
-                )
+                return http_error(400, f"URL is private: {url}")
 
             if is_cloud is True and ctx.user_class != 1:
                 info = requests.head(url)
@@ -130,14 +129,10 @@ class File(Resource):
                         "Сan't determine remote file size",
                     )
                 if file_size > MAX_FILE_SIZE:
-                    return http_error(
-                        400, "File is too big", f"Upload limit for file is {MAX_FILE_SIZE >> 20} MB"
-                    )
+                    return http_error(400, "File is too big", f"Upload limit for file is {MAX_FILE_SIZE >> 20} MB")
             with requests.get(url, stream=True) as r:
                 if r.status_code != 200:
-                    return http_error(
-                        400, "Error getting file", f"Got status code: {r.status_code}"
-                    )
+                    return http_error(400, "Error getting file", f"Got status code: {r.status_code}")
                 file_path = os.path.join(temp_dir_path, data["file"])
                 with open(file_path, "wb") as f:
                     for chunk in r.iter_content(chunk_size=8192):
@@ -158,30 +153,26 @@ class File(Resource):
             files = os.listdir(temp_dir_path)
             if len(files) != 1:
                 os.rmdir(temp_dir_path)
-                return http_error(
-                    400, "Wrong content.", "Archive must contain only one data file."
-                )
+                return http_error(400, "Wrong content.", "Archive must contain only one data file.")
             file_path = os.path.join(temp_dir_path, files[0])
             mindsdb_file_name = files[0]
             if not os.path.isfile(file_path):
                 os.rmdir(temp_dir_path)
-                return http_error(
-                    400, "Wrong content.", "Archive must contain data file in root."
-                )
+                return http_error(400, "Wrong content.", "Archive must contain data file in root.")
 
         try:
-            ca.file_controller.save_file(
-                mindsdb_file_name, file_path, file_name=original_file_name
-            )
+            ca.file_controller.save_file(mindsdb_file_name, file_path, file_name=original_file_name)
+        except FileProcessingError as e:
+            return http_error(400, "Error", str(e))
         except Exception as e:
-            return http_error(500, 'Error', str(e))
+            return http_error(500, "Error", str(e))
         finally:
             shutil.rmtree(temp_dir_path, ignore_errors=True)
 
         return "", 200
 
     @ns_conf.doc("delete_file")
-    @api_endpoint_metrics('DELETE', '/files/file')
+    @api_endpoint_metrics("DELETE", "/files/file")
     def delete(self, name: str):
         """delete file"""
 

mindsdb/api/mysql/mysql_proxy/data_types/mysql_datum.py

@@ -8,6 +8,7 @@
  * permission of MindsDB Inc
  *******************************************************
 """
+
 import struct
 
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
@@ -25,16 +26,16 @@ NULL_VALUE_INT = ord(NULL_VALUE)
 
 
 class Datum:
-    __slots__ = ['value', 'var_type', 'var_len']
+    __slots__ = ["value", "var_type", "var_len"]
 
     def __init__(self, var_type, value=None, var_len=None):
         # TODO other types: float, timestamp
         self.value = b""
 
         if var_len is None:
-            idx = var_type.find('<')
-            var_len = var_type[idx + 1: -1]
-            var_type = var_type[: idx]
+            idx = var_type.find("<")
+            var_len = var_type[idx + 1 : -1]
+            var_type = var_type[:idx]
         self.var_type = var_type
         self.var_len = var_len
 
@@ -128,7 +129,7 @@ class Datum:
         return self.get_serializer()(self.value)
 
     def get_serializer(self):
-        if self.var_type == "string":
+        if self.var_type in ("string", "byte"):
             if self.var_len == "lenenc":
                 if isinstance(self.value, bytes):
                     return self.serialize_bytes
@@ -140,15 +141,13 @@ class Datum:
             if self.var_len == "packet":
                 return lambda v: v.get_packet_string()
             else:
-                return lambda v: struct.pack(self.var_len + "s", bytes(v, "utf-8"))[
-                    :int(self.var_len)
-                ]
+                return lambda v: struct.pack(self.var_len + "s", bytes(v, "utf-8"))[: int(self.var_len)]
 
         if self.var_type == "int":
             if self.var_len == "lenenc":
                 return self.serialize_int
             else:
-                return lambda v: struct.pack("Q", v)[:int(self.var_len)]
+                return lambda v: struct.pack("Q", v)[: int(self.var_len)]
 
     @classmethod
     def serialize_str_eof(cls, value):
@@ -157,9 +156,7 @@ class Datum:
         if length == 0:
             return b""
         else:
-            return struct.pack(
-                "{len}s".format(len=var_len), bytes(value, "utf-8")
-            )[:length]
+            return struct.pack("{len}s".format(len=var_len), bytes(value, "utf-8"))[:length]
 
     # def serialize_obj(self, value):
     #     return self.serialize_str(str(value))
@@ -170,7 +167,6 @@ class Datum:
 
     @classmethod
     def serialize_bytes(cls, value):
-
         val_len = len(value)
 
         if val_len == 0:
@@ -181,23 +177,11 @@ class Datum:
 
         byte_count = -(val_len.bit_length() // (-8))
         if byte_count <= 2:
-            return (
-                TWO_BYTE_ENC
-                + struct.pack("H", val_len)
-                + value
-            )
+            return TWO_BYTE_ENC + struct.pack("H", val_len) + value
         if byte_count <= 3:
-            return (
-                THREE_BYTE_ENC
-                + struct.pack("i", val_len)[:3]
-                + value
-            )
+            return THREE_BYTE_ENC + struct.pack("i", val_len)[:3] + value
         if byte_count <= 8:
-            return (
-                THREE_BYTE_ENC
-                + struct.pack("Q", val_len)
-                + value
-            )
+            return THREE_BYTE_ENC + struct.pack("Q", val_len) + value
 
 
 def test():