MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.0__py3-none-any.whl

mindsdb/api/postgres/postgres_proxy/postgres_proxy.py

@@ -14,17 +14,38 @@ from mindsdb.api.executor.controllers import SessionController
 from mindsdb.api.postgres.postgres_proxy.executor import Executor
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import CHARSET_NUMBERS
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
-from mindsdb.api.common.check_auth import check_auth
+from mindsdb.api.common.middleware import check_auth
 from mindsdb.api.mysql.mysql_proxy.mysql_proxy import SQLAnswer
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.errors import POSTGRES_SYNTAX_ERROR_CODE
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_fields import GenericField, PostgresField
-from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_formats import Terminate, \
-    Query, AuthenticationClearTextPassword, AuthenticationOk, RowDescriptions, DataRow, CommandComplete, \
-    ReadyForQuery, ConnectionFailure, ParameterStatus, Error, Execute, Bind, Parse, Sync, ParseComplete, \
-    InvalidSQLStatementName, BindComplete, Describe, DataException, ParameterDescription
+from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_formats import (
+    Terminate,
+    Query,
+    AuthenticationClearTextPassword,
+    AuthenticationOk,
+    RowDescriptions,
+    DataRow,
+    CommandComplete,
+    ReadyForQuery,
+    ConnectionFailure,
+    ParameterStatus,
+    Error,
+    Execute,
+    Bind,
+    Parse,
+    Sync,
+    ParseComplete,
+    InvalidSQLStatementName,
+    BindComplete,
+    Describe,
+    DataException,
+    ParameterDescription,
+)
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message import PostgresMessage
-from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_packets import PostgresPacketReader, \
-    PostgresPacketBuilder
+from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_packets import (
+    PostgresPacketReader,
+    PostgresPacketBuilder,
+)
 from mindsdb.api.postgres.postgres_proxy.utilities import strip_null_byte
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
@@ -38,8 +59,8 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
     def __init__(self, request, client_address, server):
         self.logger = log.getLogger(__name__)
-        self.charset = 'utf8'
-        self.charset_text_type = CHARSET_NUMBERS['utf8_general_ci']
+        self.charset = "utf8"
+        self.charset_text_type = CHARSET_NUMBERS["utf8_general_ci"]
         self.session = None
         self.client_capabilities = None
         self.user_parameters = None
@@ -48,17 +69,16 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         self.is_cloud = False
         self.named_portals = {}
         self.unnamed_portal = None
-        self.transaction_status = b'I'  # I: Idle, T: Transaction Block, E: Failed Transaction Block
+        self.transaction_status = b"I"  # I: Idle, T: Transaction Block, E: Failed Transaction Block
         super().__init__(request, client_address, server)
 
     def handle(self) -> None:
-
         ctx.set_default()
         self.init_session()
-        self.logger.debug('handle new incoming connection')
+        self.logger.debug("handle new incoming connection")
         cloud_connection = self.is_cloud_connection()
         if cloud_connection["is_cloud"]:
-            ctx.company_id = cloud_connection.get('company_id')
+            ctx.company_id = cloud_connection.get("company_id")
             self.is_cloud = True
 
         self.message_map: Dict[Type[PostgresMessage], Callable[[Any], bool]] = {
@@ -68,7 +88,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             Bind: self.bind,
             Execute: self.execute,
             Describe: self.describe,
-            Sync: self.sync
+            Sync: self.sync,
         }
         self.client_buffer = PostgresPacketReader(self.rfile)
         if self.is_cloud:
@@ -83,69 +103,59 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             self.main_loop()
 
     def is_cloud_connection(self):
-        """ Determine source of connection. Must be call before handshake.
-                Idea based on: real mysql connection does not send anything before server handshake, so
-                socket should be in 'out' state. In opposite, clout connection sends '0000' right after
-                connection. '0000' selected because in real mysql connection it should be length of package,
-                and it can not be 0.
-
-                Copied from mysql_proxy
-                TODO: Extract method into common
-            """
-        is_cloud = config.get('cloud', False)
-
-        if sys.platform != 'linux' or is_cloud is False:
-            return {
-                'is_cloud': False
-            }
+        """Determine source of connection. Must be call before handshake.
+        Idea based on: real mysql connection does not send anything before server handshake, so
+        socket should be in 'out' state. In opposite, clout connection sends '0000' right after
+        connection. '0000' selected because in real mysql connection it should be length of package,
+        and it can not be 0.
+
+        Copied from mysql_proxy
+        TODO: Extract method into common
+        """
+        is_cloud = config.get("cloud", False)
+
+        if sys.platform != "linux" or is_cloud is False:
+            return {"is_cloud": False}
 
         read_poller = select.poll()
         read_poller.register(self.request, select.POLLIN)
         events = read_poller.poll(30)
 
         if len(events) == 0:
-            return {
-                'is_cloud': False
-            }
+            return {"is_cloud": False}
 
         first_byte = self.request.recv(4, socket.MSG_PEEK)
-        if first_byte == b'\x00\x00\x00\x00':
+        if first_byte == b"\x00\x00\x00\x00":
             self.request.recv(4)
             client_capabilities = self.request.recv(8)
-            client_capabilities = struct.unpack('L', client_capabilities)[0]
+            client_capabilities = struct.unpack("L", client_capabilities)[0]
 
             company_id = self.request.recv(4)
-            company_id = struct.unpack('I', company_id)[0]
+            company_id = struct.unpack("I", company_id)[0]
 
             user_class = self.request.recv(1)
-            user_class = struct.unpack('B', user_class)[0]
+            user_class = struct.unpack("B", user_class)[0]
 
             database_name_len = self.request.recv(2)
-            database_name_len = struct.unpack('H', database_name_len)[0]
+            database_name_len = struct.unpack("H", database_name_len)[0]
 
-            database_name = ''
+            database_name = ""
             if database_name_len > 0:
                 database_name = self.request.recv(database_name_len).decode()
 
             return {
-                'is_cloud': True,
-                'client_capabilities': client_capabilities,
-                'company_id': company_id,
-                'user_class': user_class,
-                'database': database_name
+                "is_cloud": True,
+                "client_capabilities": client_capabilities,
+                "company_id": company_id,
+                "user_class": user_class,
+                "database": database_name,
             }
 
-        return {
-            'is_cloud': False
-        }
+        return {"is_cloud": False}
 
     def parse(self, message: Parse):
         self.logger.info("Postgres_Proxy: Parsing")
-        executor = Executor(
-            session=self.session,
-            proxy_server=self,
-            charset=self.charset
-        )
+        executor = Executor(session=self.session, proxy_server=self, charset=self.charset)
         # TODO: Remove comment if unneeded ot use session since we're storing in this proxy class per session anyway
         # stmt_id = self.session.register_stmt(executor)
         executor.stmt_prepare(sql=message.query)
@@ -179,7 +189,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
     def describe(self, message: Describe):
         self.logger.info("Postgres_Proxy: Describing")
-        if message.describe_type == b'P':
+        if message.describe_type == b"P":
             if message.name:
                 describing = self.named_portals[message.name]
             elif self.unnamed_statement:
@@ -187,7 +197,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             else:
                 self.send(InvalidSQLStatementName("Portal Does not Exist"))
                 return True
-        elif message.describe_type == b'S':
+        elif message.describe_type == b"S":
             if message.name:
                 describing = self.named_statements[message.name]
             elif self.unnamed_statement:
@@ -227,8 +237,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         return True
 
     def init_session(self):
-        self.logger.info('New connection [{ip}:{port}]'.format(
-            ip=self.client_address[0], port=self.client_address[1]))
+        self.logger.info("New connection [{ip}:{port}]".format(ip=self.client_address[0], port=self.client_address[1]))
         self.logger.debug(self.__dict__)
 
         if self.server.connection_id >= 65025:
@@ -236,9 +245,9 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         self.server.connection_id += 1
         self.connection_id = self.server.connection_id
         self.session = SessionController()
-        self.session.database = config.get('default_project')
+        self.session.database = config.get("default_project")
 
-        if hasattr(self.server, 'salt') and isinstance(self.server.salt, str):
+        if hasattr(self.server, "salt") and isinstance(self.server.salt, str):
             self.salt = self.server.salt
         else:
             self.salt = base64.b64encode(os.urandom(15)).decode()
@@ -247,14 +256,10 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
         self.current_transaction = None
 
-        self.logger.debug('session salt: {salt}'.format(salt=self.salt))
+        self.logger.debug("session salt: {salt}".format(salt=self.salt))
 
     def process_query(self, sql):
-        executor = Executor(
-            session=self.session,
-            proxy_server=self,
-            charset=self.charset
-        )
+        executor = Executor(session=self.session, proxy_server=self, charset=self.charset)
         self.logger.debug("processing query\n%s", sql)
         try:
             executor.query_execute(sql)
@@ -262,7 +267,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             return SQLAnswer(
                 resp_type=RESPONSE_TYPE.ERROR,
                 error_message=str(e).encode(self.get_encoding()),
-                error_code=POSTGRES_SYNTAX_ERROR_CODE.encode(self.get_encoding())
+                error_code=POSTGRES_SYNTAX_ERROR_CODE.encode(self.get_encoding()),
             )
         return self.return_executor_data(executor)
 
@@ -277,7 +282,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
                 resp_type=RESPONSE_TYPE.TABLE,
                 state_track=executor.state_track,
                 result_set=executor.data,
-                status=executor.server_status
+                status=executor.server_status,
             )
         return resp
 
@@ -295,7 +300,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         self.client_buffer.read_verify_ssl_request()
         # self.send(NoticeResponse()) -- Should Probably not send. Looks in protocol manual to be sent for warning
         self.logger.debug("Sending No to SSL Request")
-        PostgresPacketBuilder().write_char(b'N', self.wfile)
+        PostgresPacketBuilder().write_char(b"N", self.wfile)
         self.user_parameters = self.client_buffer.read_startup_message()
 
     def authenticate(self, ask_for_password=False):
@@ -303,12 +308,12 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             self.send(AuthenticationClearTextPassword())
             password = self.client_buffer.read_authentication(encoding=self.charset)
         else:
-            password = ''
-        username = self.user_parameters[b'user'].decode(encoding=self.charset)
+            password = ""
+        username = self.user_parameters[b"user"].decode(encoding=self.charset)
         auth_data = self.server.check_auth(username, password, scramble_func, self.salt, ctx.company_id)
-        if auth_data['success']:
+        if auth_data["success"]:
             self.logger.debug("Authentication succeeded")
-            self.session.username = auth_data['username']
+            self.session.username = auth_data["username"]
             self.session.auth = True
             self.send(AuthenticationOk())
             return True
@@ -329,9 +334,9 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
     def return_ok(self, sql, rows: int = 0):
         command = self.get_command(sql)
         if command == "BEGIN":
-            self.transaction_status = b'T'
+            self.transaction_status = b"T"
         if command == "COMMIT":
-            self.transaction_status = b'I'
+            self.transaction_status = b"I"
         if command == "CREATE":
             command = "SELECT"
         if command in ("INSERT", "DELETE", "UPDATE", "SELECT", "MOVE", "FETCH", "COPY"):
@@ -347,7 +352,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         if type(sql) == bytes:
             encoding = self.get_encoding()
             sql: str = sql.decode(encoding)
-        return strip_null_byte(sql).strip(';')
+        return strip_null_byte(sql).strip(";")
 
     def return_table(self, sql_answer: SQLAnswer, row_descs=True):
         fields = self.to_postgres_fields(sql_answer.result_set.columns)
@@ -356,7 +361,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
             self.send(RowDescriptions(fields=fields))
         self.send(DataRow(rows=rows))
         encoding = self.get_encoding()
-        tag = ('SELECT %s' % str(len(rows))).encode(encoding)
+        tag = ("SELECT %s" % str(len(rows))).encode(encoding)
         self.send(CommandComplete(tag=tag))
         return True
 
@@ -389,11 +394,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         fields = []
         i = 0
         for column in columns:
-            fields.append(GenericField(
-                name=column['name'],
-                object_id=column['type'].value,
-                column_id=i
-            ))
+            fields.append(GenericField(name=column["name"], object_id=column["type"].value, column_id=i))
             i += 1
         return fields
 
@@ -410,12 +411,12 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
                     column = json.dumps(column)
                 if isinstance(column, datetime.date) or isinstance(column, datetime.datetime):
                     try:
-                        column = datetime.datetime.strftime(column, '%Y-%m-%d')
+                        column = datetime.datetime.strftime(column, "%Y-%m-%d")
                     except ValueError:
                         try:
-                            column = datetime.datetime.strftime(column, '%Y-%m-%dT%H:%M:%S')
+                            column = datetime.datetime.strftime(column, "%Y-%m-%dT%H:%M:%S")
                         except ValueError:
-                            column = datetime.datetime.strptime(column, '%Y-%m-%dT%H:%M:%S.%f')
+                            column = datetime.datetime.strptime(column, "%Y-%m-%dT%H:%M:%S.%f")
                 if isinstance(column, bool):
                     if column:
                         column = "true"
@@ -427,7 +428,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
     def send_initial_data(self):
         server_encoding = self.charset.encode(self.charset)
-        client_encoding = self.user_parameters.get(b'client_encoding', server_encoding)
+        client_encoding = self.user_parameters.get(b"client_encoding", server_encoding)
         # TODO: Send BackendKeyData Here (55.2.1)
         self.send(ParameterStatus(name=b"server_version", value=b"14.6"))
         self.send(ParameterStatus(name=b"server_encoding", value=server_encoding))
@@ -459,8 +460,8 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
     @staticmethod
     def startProxy():
-        host = config['api']['postgres']['host']
-        port = int(config['api']['postgres']['port'])
+        host = config["api"]["postgres"]["host"]
+        port = int(config["api"]["postgres"]["port"])
         server = TcpServer((host, port), PostgresProxyHandler)
         server.connection_id = 0
         server.mindsdb_config = config

mindsdb/integrations/handlers/crate_handler/crate_handler.py

@@ -56,9 +56,7 @@ class CrateHandler(DatabaseHandler):
         if self.is_connected:
             return self.connection
 
-        is_local = (
-            self.host.startswith("localhost") or self.host == "127.0.0.1"
-        )
+        is_local = self.host.startswith("localhost") or self.host == "127.0.0.1"
 
         try:
             # Build URL based on connection type
@@ -121,7 +119,7 @@ class CrateHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+                etc)
         Returns:
             HandlerResponse
         """
@@ -136,9 +134,7 @@ class CrateHandler(DatabaseHandler):
                 result = cur.fetchall()
                 response = Response(
                     RESPONSE_TYPE.TABLE,
-                    data_frame=pd.DataFrame(
-                        result, columns=[x[0] for x in cur.description]
-                    ),
+                    data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description]),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)

mindsdb/integrations/handlers/derby_handler/derby_handler.py

@@ -6,7 +6,7 @@ from mindsdb_sql_parser import parse_sql
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 import pandas as pd
 import jaydebeapi as jdbcconnector
@@ -15,11 +15,10 @@ logger = log.getLogger(__name__)
 
 
 class DerbyHandler(DatabaseHandler):
-
-    name = 'derby'
+    name = "derby"
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
-        """ Initialize the handler
+        """Initialize the handler
         Args:
             name (str): name of particular handler instance
             connection_data (dict): parameters for connecting to the database
@@ -29,16 +28,16 @@ class DerbyHandler(DatabaseHandler):
 
         self.kwargs = kwargs
         self.parser = parse_sql
-        self.database = connection_data['database']
+        self.database = connection_data["database"]
         self.connection_config = connection_data
-        self.host = connection_data['host']
-        self.port = connection_data['port']
-        self.schema = 'APP'
+        self.host = connection_data["host"]
+        self.port = connection_data["port"]
+        self.schema = "APP"
         self.connection = None
         self.is_connected = False
 
     def connect(self):
-        """ Set up any connections required by the handler
+        """Set up any connections required by the handler
         Should return output of check_connection() method after attempting
         connection. Should switch self.is_connected.
         Returns:
@@ -47,10 +46,10 @@ class DerbyHandler(DatabaseHandler):
         if self.is_connected is True:
             return self.connection
 
-        user = self.connection_config.get('user')
-        password = self.connection_config.get('password')
-        jdbc_class = self.connection_config.get('jdbcClass')
-        jar_location = self.connection_config.get('jdbcJarLocation')
+        user = self.connection_config.get("user")
+        password = self.connection_config.get("password")
+        jdbc_class = self.connection_config.get("jdbcClass")
+        jar_location = self.connection_config.get("jdbcJarLocation")
 
         jdbc_url = "jdbc:derby://" + self.host + ":" + self.port + "/" + self.database + ";"
 
@@ -62,11 +61,17 @@ class DerbyHandler(DatabaseHandler):
 
         try:
             if user and password and jar_location:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password], jars=jar_location.split(","))
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password], jars=jar_location.split(",")
+                )
             elif user and password:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password])
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password]
+                )
             elif jar_location:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, jars=jar_location.split(","))
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, jars=jar_location.split(",")
+                )
             else:
                 self.connection = jdbcconnector.connect(jdbc_class, jdbc_url)
         except Exception as e:
@@ -75,7 +80,7 @@ class DerbyHandler(DatabaseHandler):
         return self.connection
 
     def disconnect(self):
-        """ Close any existing connections
+        """Close any existing connections
         Should switch self.is_connected.
         """
         if self.is_connected is False:
@@ -89,7 +94,7 @@ class DerbyHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-        """ Check connection to the handler
+        """Check connection to the handler
         Returns:
             HandlerStatusResponse
         """
@@ -100,7 +105,7 @@ class DerbyHandler(DatabaseHandler):
             self.connect()
             responseCode.success = True
         except Exception as e:
-            logger.error(f'Error connecting to database {self.database}, {e}!')
+            logger.error(f"Error connecting to database {self.database}, {e}!")
             responseCode.error_message = str(e)
         finally:
             if responseCode.success is True and need_to_close:
@@ -114,7 +119,7 @@ class DerbyHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+                etc)
         Returns:
             HandlerResponse
         """
@@ -126,21 +131,14 @@ class DerbyHandler(DatabaseHandler):
                 if cur.description:
                     result = cur.fetchall()
                     response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        data_frame=pd.DataFrame(
-                            result,
-                            columns=[x[0] for x in cur.description]
-                        )
+                        RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description])
                     )
                 else:
                     response = Response(RESPONSE_TYPE.OK)
                 self.connection.commit()
             except Exception as e:
-                logger.error(f'Error running query: {query} on {self.database}!')
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(e)
-                )
+                logger.error(f"Error running query: {query} on {self.database}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
                 self.connection.rollback()
 
         if need_to_close is True:
@@ -173,12 +171,12 @@ class DerbyHandler(DatabaseHandler):
         Returns:
             Response: Names of the tables in the database.
         """
-        query = f'''
-        SELECT st.tablename FROM sys.systables st LEFT OUTER JOIN sys.sysschemas ss ON (st.schemaid = ss.schemaid) WHERE ss.schemaname ='{self.schema}' '''
+        query = f"""
+        SELECT st.tablename FROM sys.systables st LEFT OUTER JOIN sys.sysschemas ss ON (st.schemaid = ss.schemaid) WHERE ss.schemaname ='{self.schema}' """
 
         result = self.native_query(query)
         df = result.data_frame
-        result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+        result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
         return result
 
     def get_columns(self, table_name: str) -> StatusResponse:
@@ -191,5 +189,5 @@ class DerbyHandler(DatabaseHandler):
             Response: Details of the table.
         """
 
-        query = f''' SELECT COLUMNNAME FROM SYS.SYSCOLUMNS INNER JOIN SYS.SYSTABLES ON SYS.SYSCOLUMNS.REFERENCEID=SYS.SYSTABLES.TABLEID WHERE TABLENAME='{table_name}' '''
+        query = f""" SELECT COLUMNNAME FROM SYS.SYSCOLUMNS INNER JOIN SYS.SYSTABLES ON SYS.SYSCOLUMNS.REFERENCEID=SYS.SYSTABLES.TABLEID WHERE TABLENAME='{table_name}' """
         return self.native_query(query)

mindsdb/integrations/handlers/documentdb_handler/requirements.txt

@@ -0,0 +1 @@
+-r mindsdb/integrations/handlers/mongodb_handler/requirements.txt

mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py

@@ -11,22 +11,22 @@ from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 
 
 class DummyHandler(DatabaseHandler):
-    name = 'dummy_data'
+    name = "dummy_data"
 
     def __init__(self, **kwargs):
-        super().__init__('dummy_data')
+        super().__init__("dummy_data")
         self.db_path = None
 
-        args = kwargs.get('connection_data', {})
-        if 'db_path' in args:
-            self.db_path = args['db_path']
+        args = kwargs.get("connection_data", {})
+        if "db_path" in args:
+            self.db_path = args["db_path"]
 
     def connect(self):
         """Set up any connections required by the handler"""
         return self.db_path is not None
 
     def disconnect(self):
-        """ Close any existing connections"""
+        """Close any existing connections"""
         return
 
     def check_connection(self) -> HandlerStatusResponse:
@@ -41,7 +41,7 @@ class DummyHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow
 
         Args:
-            query (Any): query in native format (str for sql databases, dict for mongo, etc)
+            query (Any): query in native format (str for sql databases, etc)
             params (Optional[List])
 
         Returns:
@@ -49,7 +49,7 @@ class DummyHandler(DatabaseHandler):
         """
         con = duckdb.connect(self.db_path)
         if params is not None:
-            query = query.replace('%s', '?')
+            query = query.replace("%s", "?")
             cur = con.executemany(query, params)
             if cur.rowcount >= 0:
                 result_df = cur.fetchdf()
@@ -71,7 +71,7 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse
         """
-        renderer = SqlalchemyRender('postgres')
+        renderer = SqlalchemyRender("postgres")
         query_str, params = renderer.get_exec_params(query, with_failback=True)
         return self.native_query(query_str, params)
 
@@ -81,10 +81,10 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse: Names of the tables in the database
         """
-        q = 'SHOW TABLES;'
+        q = "SHOW TABLES;"
         result = self.native_query(q)
         df = result.data_frame
-        result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+        result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
         return result
 
     def get_columns(self, table_name: str) -> HandlerResponse:
@@ -96,11 +96,10 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse: Details of the table.
         """
-        query = f'DESCRIBE {table_name};'
+        query = f"DESCRIBE {table_name};"
         return self.native_query(query)
 
     def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
-
         while True:
             if stop_event.is_set():
                 return