MindsDB 25.9.2.0a1__py3-none-any.whl → 25.9.3rc1__py3-none-any.whl

mindsdb/api/http/namespaces/tab.py

@@ -1,5 +1,4 @@
 import json
-import traceback
 from http import HTTPStatus
 
 from flask import request
@@ -29,20 +28,20 @@ def _is_request_valid() -> bool:
     if (
         isinstance(data, dict) is False
         or len(data.keys()) == 0
-        or len(set(data.keys()) - {'index', 'name', 'content'}) != 0
+        or len(set(data.keys()) - {"index", "name", "content"}) != 0
     ):
         return False
     return True
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class Tabs(Resource):
-    @ns_conf.doc('get_tabs')
-    @api_endpoint_metrics('GET', '/tabs')
+    @ns_conf.doc("get_tabs")
+    @api_endpoint_metrics("GET", "/tabs")
     def get(self):
-        mode = request.args.get('mode')
+        mode = request.args.get("mode")
 
-        if mode == 'new':
+        if mode == "new":
             return tabs_controller.get_all(), 200
         else:
             # deprecated
@@ -51,26 +50,23 @@ class Tabs(Resource):
             try:
                 raw_data = storage.file_get(TABS_FILENAME)
                 tabs = json.loads(raw_data)
-            except Exception as e:
-                logger.warning("unable to get tabs data - %s", e)
+            except Exception:
+                logger.warning("unable to get tabs data - %s", exc_info=True)
                 return {}, 200
             return tabs, 200
 
-    @ns_conf.doc('save_tab')
-    @api_endpoint_metrics('POST', '/tabs')
+    @ns_conf.doc("save_tab")
+    @api_endpoint_metrics("POST", "/tabs")
     def post(self):
-        mode = request.args.get('mode')
+        mode = request.args.get("mode")
 
-        if mode == 'new':
+        if mode == "new":
             if _is_request_valid() is False:
-                return http_error(400, 'Error', 'Invalid parameters')
+                return http_error(400, "Error", "Invalid parameters")
             data = request.json
             tab_meta = tabs_controller.add(**data)
             tabs_meta = tabs_controller._get_tabs_meta()
-            return {
-                'tab_meta': tab_meta,
-                'tabs_meta': tabs_meta
-            }, 200
+            return {"tab_meta": tab_meta, "tabs_meta": tabs_meta}, 200
         else:
             # deprecated
             storage = get_storage()
@@ -78,54 +74,48 @@ class Tabs(Resource):
                 tabs = request.json
                 b_types = json.dumps(tabs).encode("utf-8")
                 storage.file_set(TABS_FILENAME, b_types)
-            except Exception as e:
-                logger.error("unable to store tabs data - %s", e)
-                logger.error(traceback.format_exc())
+            except Exception:
+                logger.exception("Unable to store tabs data:")
                 return http_error(
-                    HTTPStatus.INTERNAL_SERVER_ERROR,
-                    "Can't save tabs",
-                    'something went wrong during tabs saving'
+                    HTTPStatus.INTERNAL_SERVER_ERROR, "Can't save tabs", "something went wrong during tabs saving"
                 )
 
-            return '', 200
+            return "", 200
 
 
 @ns_conf.route("/<tab_id>")
 @ns_conf.param("tab_id", "id of tab")
 class Tab(Resource):
     @ns_conf.doc("get_tab")
-    @api_endpoint_metrics('GET', '/tabs/tab')
+    @api_endpoint_metrics("GET", "/tabs/tab")
     def get(self, tab_id: int):
         try:
             tab_data = tabs_controller.get(int(tab_id))
         except EntityNotExistsError:
-            return http_error(404, 'Error', 'The tab does not exist')
+            return http_error(404, "Error", "The tab does not exist")
 
         return tab_data, 200
 
     @ns_conf.doc("put_tab")
-    @api_endpoint_metrics('PUT', '/tabs/tab')
+    @api_endpoint_metrics("PUT", "/tabs/tab")
     def put(self, tab_id: int):
         if _is_request_valid() is False:
-            return http_error(400, 'Error', 'Invalid parameters')
+            return http_error(400, "Error", "Invalid parameters")
         data = request.json
         try:
             tab_meta = tabs_controller.modify(int(tab_id), **data)
         except EntityNotExistsError:
-            return http_error(404, 'Error', 'The tab does not exist')
+            return http_error(404, "Error", "The tab does not exist")
 
         tabs_meta = tabs_controller._get_tabs_meta()
 
-        return {
-            'tab_meta': tab_meta,
-            'tabs_meta': tabs_meta
-        }, 200
+        return {"tab_meta": tab_meta, "tabs_meta": tabs_meta}, 200
 
     @ns_conf.doc("delete_tab")
-    @api_endpoint_metrics('DELETE', '/tabs/tab')
+    @api_endpoint_metrics("DELETE", "/tabs/tab")
     def delete(self, tab_id: int):
         try:
             tabs_controller.delete(int(tab_id))
         except EntityNotExistsError:
-            return http_error(404, 'Error', 'The tab does not exist')
-        return '', 200
+            return http_error(404, "Error", "The tab does not exist")
+        return "", 200

mindsdb/api/http/namespaces/views.py

@@ -47,7 +47,7 @@ class ViewsList(Resource):
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, "Not found", f"Project name {project_name} does not exist")
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         if project.get_view(name) is not None:
             return http_error(HTTPStatus.CONFLICT, "Name conflict", f"View with name {name} already exists.")

mindsdb/api/http/start.py

@@ -3,6 +3,10 @@ import gc
 gc.disable()
 
 from flask import Flask
+from starlette.applications import Starlette
+from starlette.routing import Mount
+from a2wsgi import WSGIMiddleware
+import uvicorn
 
 from mindsdb.api.http.initialize import initialize_app
 from mindsdb.interfaces.storage import db
@@ -11,13 +15,6 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.functions import init_lexer_parsers
 from mindsdb.integrations.libs.ml_exec_base import process_cache
 from mindsdb.api.common.middleware import PATAuthMiddleware
-
-
-from starlette.applications import Starlette
-from starlette.routing import Mount
-from starlette.middleware.wsgi import WSGIMiddleware
-import uvicorn
-
 from mindsdb.api.a2a import get_a2a_app
 from mindsdb.api.mcp import get_mcp_app
 
@@ -48,7 +45,16 @@ def start(verbose, app: Flask = None):
     routes.append(Mount("/mcp", app=mcp))
 
     # Root app LAST so it won't shadow the others
-    routes.append(Mount("/", app=WSGIMiddleware(app)))
+    routes.append(
+        Mount(
+            "/",
+            app=WSGIMiddleware(
+                app,
+                workers=config["api"]["http"]["a2wsgi"]["workers"],
+                send_queue_size=config["api"]["http"]["a2wsgi"]["send_queue_size"],
+            ),
+        )
+    )
 
     # Setting logging to None makes uvicorn use the existing logging configuration
     uvicorn.run(Starlette(routes=routes, debug=verbose), host=host, port=int(port), log_level=None, log_config=None)

mindsdb/api/mcp/__init__.py

@@ -98,7 +98,7 @@ def query(query: str, context: dict | None = None) -> dict[str, Any]:
             return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": "Unknown response type"}
 
     except Exception as e:
-        logger.error(f"Error processing query: {str(e)}")
+        logger.exception("Error processing query:")
         return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": str(e)}
 
 
@@ -138,6 +138,7 @@ def list_databases() -> list[str]:
             return data
 
     except Exception as e:
+        logger.exception("Error while retrieving list of databases")
         return {
             "type": "error",
             "error_code": 0,

mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py

@@ -1,12 +1,14 @@
 from mindsdb_sql_parser import parse_sql
-from mindsdb.api.executor.planner import utils as planner_utils
+from mindsdb_sql_parser.exceptions import ParsingException
+from mindsdb_sql_parser.ast.base import ASTNode
 
 import mindsdb.utilities.profiler as profiler
-from mindsdb.api.executor.sql_query.result_set import Column
 from mindsdb.api.executor.sql_query import SQLQuery
+from mindsdb.api.executor.sql_query.result_set import Column
+from mindsdb.api.executor.planner import utils as planner_utils
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.command_executor import ExecuteCommands
-from mindsdb.api.mysql.mysql_proxy.utilities import ErSqlSyntaxError
+from mindsdb.api.executor.exceptions import SqlSyntaxError
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.utilities import log
 
@@ -18,7 +20,7 @@ class Executor:
         self.session = session
         self.sqlserver = sqlserver
 
-        self.query = None
+        self.query: ASTNode = None
 
         self.columns: list[Column] = []
         self.params: list[Column] = []
@@ -32,14 +34,13 @@ class Executor:
         self.sql = ""
         self.sql_lower = ""
 
-        context = {'connection_id': self.sqlserver.connection_id}
+        context = {"connection_id": self.sqlserver.connection_id}
         self.command_executor = ExecuteCommands(self.session, context)
 
     def change_default_db(self, new_db):
         self.command_executor.change_default_db(new_db)
 
     def stmt_prepare(self, sql):
-
         self.parse(sql)
 
         # if not params
@@ -57,11 +58,7 @@ class Executor:
 
             sqlquery.prepare_query()
 
-            self.params = [Column(
-                name=p.value,
-                alias=p.value,
-                type=MYSQL_DATA_TYPE.TEXT
-            ) for p in params]
+            self.params = [Column(name=p.value, alias=p.value, type=MYSQL_DATA_TYPE.TEXT) for p in params]
 
             # TODO:
             #   select * from mindsdb.models doesn't invoke prepare_steps and columns_list is empty
@@ -90,17 +87,15 @@ class Executor:
 
         try:
             self.query = parse_sql(sql)
-        except Exception as mdb_error:
+        except ParsingException as mdb_error:
             # not all statements are parsed by parse_sql
-            logger.warning('Failed to parse SQL query')
-            logger.debug(f'Query that cannot be parsed: {sql}')
-
-            raise ErSqlSyntaxError(
-                f"The SQL statement cannot be parsed - {sql}: {mdb_error}"
-            ) from mdb_error
+            logger.warning("Failed to parse SQL query")
+            logger.debug(f"Query that cannot be parsed: {sql}")
 
-            # == a place for workarounds ==
-            # or run sql in integration without parsing
+            raise SqlSyntaxError(f"The SQL statement cannot be parsed - {sql}: {mdb_error}") from mdb_error
+        except Exception:
+            logger.exception(f"Unexpected error while parsing SQL query: {sql}")
+            raise
 
     @profiler.profile()
     def do_execute(self):

mindsdb/api/mysql/mysql_proxy/mysql_proxy.py

@@ -20,6 +20,7 @@ import struct
 import sys
 import tempfile
 import traceback
+import logging
 from functools import partial
 from typing import List
 from dataclasses import dataclass
@@ -67,11 +68,7 @@ from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
 )
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
-from mindsdb.api.mysql.mysql_proxy.utilities import (
-    ErWrongCharset,
-    SqlApiException,
-)
-from mindsdb.api.executor import exceptions as exec_exc
+from mindsdb.api.executor import exceptions as executor_exceptions
 
 from mindsdb.api.common.middleware import check_auth
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
@@ -81,7 +78,9 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.otel import increment_otel_query_request_counter
 from mindsdb.utilities.wizards import make_ssl_cert
+from mindsdb.utilities.exception import QueryError
 from mindsdb.api.mysql.mysql_proxy.utilities.dump import dump_result_set_to_mysql, column_to_mysql_column_dict
+from mindsdb.api.executor.exceptions import WrongCharsetError
 
 logger = log.getLogger(__name__)
 
@@ -128,6 +127,14 @@ class SQLAnswer:
             raise ValueError(f"Unsupported response type for dump HTTP response: {self.resp_type}")
 
 
+class MysqlTCPServer(SocketServer.ThreadingTCPServer):
+    """
+    Custom TCP Server with increased request queue size
+    """
+
+    request_queue_size = 30
+
+
 class MysqlProxy(SocketServer.BaseRequestHandler):
     """
     The Main Server controller class
@@ -428,7 +435,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
         try:
             return text.decode("utf-8")
         except Exception:
-            raise ErWrongCharset(f"SQL contains non utf-8 values: {text}")
+            raise WrongCharsetError(f"SQL contains non utf-8 values: {text}")
 
     def is_cloud_connection(self):
         """Determine source of connection. Must be call before handshake.
@@ -489,6 +496,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
 
     @profiler.profile()
     def process_query(self, sql) -> SQLAnswer:
+        log.log_ram_info(logger)
         executor = Executor(session=self.session, sqlserver=self)
         executor.query_execute(sql)
         executor_answer = executor.executor_answer
@@ -647,8 +655,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
             try:
                 success = p.get()
             except Exception:
-                logger.error("Session closed, on packet read error")
-                logger.error(traceback.format_exc())
+                logger.exception("Session closed, on packet read error:")
                 return
 
             if success is False:
@@ -712,59 +719,28 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
                 else:
                     logger.warning("Command has no specific handler, return OK msg")
                     logger.debug(str(p))
-                    # p.pprintPacket() TODO: Make a version of print packet
-                    # that sends it to debug instead
                     response = SQLAnswer(RESPONSE_TYPE.OK)
 
-            except SqlApiException as e:
-                # classified error
-                error_type = "expected"
-
-                response = SQLAnswer(
-                    resp_type=RESPONSE_TYPE.ERROR,
-                    error_code=e.err_code,
-                    error_message=str(e),
-                )
-
-            except exec_exc.ExecutorException as e:
-                # unclassified
-                error_type = "expected"
-
-                if isinstance(e, exec_exc.NotSupportedYet):
-                    error_code = ERR.ER_NOT_SUPPORTED_YET
-                elif isinstance(e, exec_exc.KeyColumnDoesNotExist):
-                    error_code = ERR.ER_KEY_COLUMN_DOES_NOT_EXIST
-                elif isinstance(e, exec_exc.TableNotExistError):
-                    error_code = ERR.ER_TABLE_EXISTS_ERROR
-                elif isinstance(e, exec_exc.WrongArgumentError):
-                    error_code = ERR.ER_WRONG_ARGUMENTS
-                elif isinstance(e, exec_exc.LogicError):
-                    error_code = ERR.ER_WRONG_USAGE
-                elif isinstance(e, (exec_exc.BadDbError, exec_exc.BadTableError)):
-                    error_code = ERR.ER_BAD_DB_ERROR
+            except (QueryError, executor_exceptions.ExecutorException, executor_exceptions.UnknownError) as e:
+                error_type = "expected" if e.is_expected else "unexpected"
+                error_code = e.mysql_error_code
+                if e.is_expected:
+                    if logger.isEnabledFor(logging.DEBUG):
+                        logger.info("Query execution failed with expected error:", exc_info=True)
+                    else:
+                        logger.info(f"Query execution failed with expected error: {e}")
                 else:
-                    error_code = ERR.ER_SYNTAX_ERROR
-
+                    logger.exception("Query execution failed with error")
                 response = SQLAnswer(
                     resp_type=RESPONSE_TYPE.ERROR,
                     error_code=error_code,
                     error_message=str(e),
                 )
-            except exec_exc.UnknownError as e:
-                # unclassified
-                error_type = "unexpected"
-
-                response = SQLAnswer(
-                    resp_type=RESPONSE_TYPE.ERROR,
-                    error_code=ERR.ER_UNKNOWN_ERROR,
-                    error_message=str(e),
-                )
 
             except Exception as e:
-                # any other exception
                 error_type = "unexpected"
                 error_traceback = traceback.format_exc()
-                logger.error(f"ERROR while executing query\n{error_traceback}\n{e}")
+                logger.exception("ERROR while executing query:")
                 error_code = ERR.ER_SYNTAX_ERROR
                 response = SQLAnswer(
                     resp_type=RESPONSE_TYPE.ERROR,
@@ -856,7 +832,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
         logger.info(f"Starting MindsDB Mysql proxy server on tcp://{host}:{port}")
 
         SocketServer.TCPServer.allow_reuse_address = True
-        server = SocketServer.ThreadingTCPServer((host, port), MysqlProxy)
+        server = MysqlTCPServer((host, port), MysqlProxy)
         server.mindsdb_config = config
         server.check_auth = partial(check_auth, config=config)
         server.cert_path = cert_path

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

@@ -1 +0,0 @@
-from .exceptions import *

mindsdb/api/postgres/postgres_proxy/executor/executor.py

@@ -10,7 +10,7 @@ from mindsdb.api.executor.sql_query import SQLQuery
 from mindsdb.api.executor.sql_query.result_set import Column
 from mindsdb.api.mysql.mysql_proxy.utilities.lightwood_dtype import dtype
 from mindsdb.api.executor.command_executor import ExecuteCommands
-from mindsdb.api.mysql.mysql_proxy.utilities import SqlApiException
+from mindsdb.api.executor.exceptions import SqlSyntaxError
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_fields import POSTGRES_TYPES
 from mindsdb.utilities import log
 
@@ -47,12 +47,10 @@ class Executor:
             self.query = parse_sql(sql)
         except Exception as mdb_error:
             # not all statements are parsed by parse_sql
-            self.logger.warning('Failed to parse SQL query')
-            self.logger.debug(f'Query that cannot be parsed: {sql}')
+            self.logger.warning("Failed to parse SQL query")
+            self.logger.debug(f"Query that cannot be parsed: {sql}")
 
-            raise SqlApiException(
-                f"The SQL statement cannot be parsed - {sql}: {mdb_error}"
-            ) from mdb_error
+            raise SqlSyntaxError(f"The SQL statement cannot be parsed - {sql}: {mdb_error}") from mdb_error
 
     def stmt_execute(self, param_values):
         if self.is_executed:
@@ -102,20 +100,15 @@ class Executor:
             "state_track": self.state_track,
             "server_status": self.server_status,
             "is_executed": self.is_executed,
-            "session": self.session.to_json()
-
+            "session": self.session.to_json(),
         }
         return params
 
     def to_postgres_columns(self, columns):
-
         result = []
 
-        database = (
-            None if self.session.database == "" else self.session.database.lower()
-        )
+        database = None if self.session.database == "" else self.session.database.lower()
         for column_record in columns:
-
             field_type = column_record.type
 
             column_type = POSTGRES_TYPES.VARCHAR

mindsdb/api/postgres/postgres_proxy/postgres_packets/postgres_packets.py

@@ -7,8 +7,11 @@ import time
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_fields import PostgresField
 
 
-from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_identifiers import \
-    PostgresBackendMessageIdentifier, PostgresFrontendMessageIdentifier, PostgresAuthType
+from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_identifiers import (
+    PostgresBackendMessageIdentifier,
+    PostgresFrontendMessageIdentifier,
+    PostgresAuthType,
+)
 
 
 class PostgresEmptyDataException(Exception):
@@ -29,8 +32,11 @@ class UnsupportedPostgresMessageType(Exception):
 
 class PostgresPacketReader:
     def __init__(self, buffer: BinaryIO):
-        from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_formats import FE_MESSAGE_MAP, \
-            SUPPORTED_AUTH_TYPES
+        from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_formats import (
+            FE_MESSAGE_MAP,
+            SUPPORTED_AUTH_TYPES,
+        )
+
         self.fe_message_map = FE_MESSAGE_MAP
         self.supported_auth_types = SUPPORTED_AUTH_TYPES
         self.buffer = buffer
@@ -80,7 +86,7 @@ class PostgresPacketReader:
 
     def read_parameters(self, n):
         data = self.read_bytes(n)
-        return data.split(b'\x00')
+        return data.split(b"\x00")
 
     def read_verify_ssl_request(self):
         self.logger.debug("reading ssl")
@@ -94,9 +100,9 @@ class PostgresPacketReader:
         length = self.read_int32()
         version = self.read_int32()
         major_version = version >> 16
-        minor_version = version & 0xffff
+        minor_version = version & 0xFFFF
         message = self.read_parameters(length - 8)
-        self.logger.debug('PSQL Startup Message %d.%d : %s' % (major_version, minor_version, message))
+        self.logger.debug("PSQL Startup Message %d.%d : %s" % (major_version, minor_version, message))
         parameters = {}
         while len(message) != 0:
             key = message.pop(0)
@@ -111,7 +117,7 @@ class PostgresPacketReader:
             auth_type = self.read_byte()
         except PostgresEmptyDataException:
             # No authentication parameters specified. Which is fine if we're local on a mindsdbuser
-            return ''
+            return ""
         try:
             auth_type = PostgresAuthType(auth_type)
         except Exception as e:
@@ -119,27 +125,31 @@ class PostgresPacketReader:
         if auth_type not in self.supported_auth_types:
             raise UnsupportedPostgresAuthException("%s is not a supported auth type identifier" % auth_type)
         length = self.read_int32()
-        password = strip_null_byte(self.read_bytes(length - 4), encoding=encoding)  # password. Do something with later. We read to clear buffer.
+        password = strip_null_byte(
+            self.read_bytes(length - 4), encoding=encoding
+        )  # password. Do something with later. We read to clear buffer.
         return password
 
     def read_message(self):
         try:
             message_type = self.read_byte()
         except PostgresEmptyDataException:
-            self.logger.warn("Postgres Proxy: Received empty data string")
+            self.logger.warning("Postgres Proxy: Received empty data string")
             return None
         try:
             message_type = PostgresFrontendMessageIdentifier(message_type)
         except Exception as e:
             raise UnsupportedPostgresMessageType(
-                "%s is not a supported frontend message identifier:\n%s" % (message_type, str(e)))
+                "%s is not a supported frontend message identifier:\n%s" % (message_type, str(e))
+            )
 
         if message_type in self.fe_message_map:
             self.logger.debug("reading message type %s" % str(message_type.name))
             return self.fe_message_map[message_type]().read(self)
         else:
             raise UnsupportedPostgresMessageType(
-                "%s is not a supported frontend message identifier" % message_type.value)
+                "%s is not a supported frontend message identifier" % message_type.value
+            )
 
 
 class PostgresPacketBuilder:
@@ -153,8 +163,8 @@ class PostgresPacketBuilder:
         self.reset()
 
     def reset(self):
-        self.identifier = b''
-        self.pack_string = ''
+        self.identifier = b""
+        self.pack_string = ""
         self.pack_args = []
         self.length = 0
 
@@ -194,44 +204,46 @@ class PostgresPacketBuilder:
         write_file.write(packed_binary)
 
     def add_char(self, s: bytes):
-        self.pack_string += 'c'
+        self.pack_string += "c"
         if len(s) != 1:
             raise Exception("Char must be of length 1 in add_char")
         self.pack_args.append(s)
         return self.add_length(1)
 
     def add_string(self, s: bytes):
-        s = s + b'\x00'
-        self.pack_string += str(len(s)) + 's'
+        s = s + b"\x00"
+        self.pack_string += str(len(s)) + "s"
         self.pack_args.append(s)
         return self.add_length(len(s))
 
     def add_int32(self, i):
-        self.pack_string += 'i'
+        self.pack_string += "i"
         self.pack_args.append(i)
         return self.add_length(4)
 
     def add_int16(self, h):
-        self.pack_string += 'h'
+        self.pack_string += "h"
         self.pack_args.append(h)
         return self.add_length(2)
 
     def add_bytes(self, b: bytes):
         if len(b) == 1:
-            self.pack_string += 's'
+            self.pack_string += "s"
         else:
-            self.pack_string += str(len(b)) + 's'
+            self.pack_string += str(len(b)) + "s"
         self.pack_args.append(b)
         return self.add_length(len(b))
 
     def add_field(self, field: PostgresField):
-        return self.add_string(field.name.encode()) \
-            .add_int32(field.table_id) \
-            .add_int16(field.column_id) \
-            .add_int32(field.object_id) \
-            .add_int16(field.dt_size) \
-            .add_int32(field.type_modifier) \
+        return (
+            self.add_string(field.name.encode())
+            .add_int32(field.table_id)
+            .add_int16(field.column_id)
+            .add_int32(field.object_id)
+            .add_int16(field.dt_size)
+            .add_int32(field.type_modifier)
             .add_int16(field.format_code)
+        )
 
     def add_fields(self, fields: Sequence[PostgresField]):
         for field in fields:
@@ -239,7 +251,7 @@ class PostgresPacketBuilder:
         return self
 
     def add_column_value(self, val: bytes):
-        if val == b'NULL':
+        if val == b"NULL":
             self.add_int32(-1)
             return self