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

mindsdb/api/executor/utilities/mysql_to_duckdb_functions.py

@@ -0,0 +1,264 @@
+from mindsdb_sql_parser.ast import Identifier, Function, Constant, BinaryOperation
+
+
+def adapt_char_fn(node: Function) -> Function | None:
+    """Replace MySQL's multy-arg CHAR call to chain of DuckDB's CHR calls
+
+    Example:
+        CHAR(77, 78, 79) => CHR(77) || CHR(78) || CHR(79)
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        Function | None: Adapted function node
+    """
+    if len(node.args) == 1:
+        node.op = "chr"
+        return node
+
+    acc = None
+    for arg in node.args:
+        fn = Function(op="chr", args=[arg])
+        if acc is None:
+            acc = fn
+            continue
+        acc = BinaryOperation("||", args=[acc, fn])
+
+    acc.parentheses = True
+    acc.alias = node.alias
+    return acc
+
+
+def adapt_locate_fn(node: Function) -> Function | None:
+    """Replace MySQL's LOCATE (or INSTR) call to DuckDB's STRPOS call
+
+    Example:
+        LOCATE('bar', 'foobarbar') => STRPOS('foobarbar', 'bar')
+        INSTR('foobarbar', 'bar') => STRPOS('foobarbar', 'bar')
+        LOCATE('bar', 'foobarbar', 3) => ValueError (there is no analogue in DuckDB)
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        Function | None: Adapted function node
+
+    Raises:
+        ValueError: If the function has 3 arguments
+    """
+    if len(node.args) == 3:
+        raise ValueError("MySQL LOCATE function with 3 arguments is not supported")
+    if node.op == "locate":
+        node.args = [node.args[1], node.args[0]]
+    elif node.op == "insrt":
+        node.args = [node.args[0], node.args[1]]
+    node.op = "strpos"
+
+
+def adapt_unhex_fn(node: Function) -> None:
+    """Check MySQL's UNHEX function call arguments to ensure they are strings,
+    because DuckDB's UNHEX accepts only string arguments, while MySQL's UNHEX can accept integer arguments.
+    NOTE: if return dataframe from duckdb then unhex values are array - this may be an issue
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the function argument is not a string
+    """
+    for arg in node.args:
+        if not isinstance(arg, (str, bytes)):
+            raise ValueError("MySQL UNHEX function argument must be a string")
+
+
+def adapt_format_fn(node: Function) -> None:
+    """Adapt MySQL's FORMAT function to DuckDB's FORMAT function
+
+    Example:
+        FORMAT(1234567.89, 0) => FORMAT('{:,.0f}', 1234567.89)
+        FORMAT(1234567.89, 2) => FORMAT('{:,.2f}', 1234567.89)
+        FORMAT(name, 2) => FORMAT('{:,.2f}', name)
+        FORMAT('{:.2f}', 1234567.89) => FORMAT('{:,.2f}', 1234567.89)  # no changes for original style
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If MySQL's function has 3rd 'locale' argument, like FORMAT(12332.2, 2, 'de_DE')
+    """
+    match node.args[0], node.args[1]:
+        case Constant(value=(int() | float())), Constant(value=int()):
+            ...
+        case Identifier(), Constant(value=int()):
+            ...
+        case _:
+            return node
+
+    if len(node.args) > 2:
+        raise ValueError("'locale' argument of 'format' function is not supported")
+    decimal_places = node.args[1].value
+
+    if isinstance(node.args[0], Constant):
+        node.args[1].value = node.args[0].value
+        node.args[0].value = f"{{:,.{decimal_places}f}}"
+    else:
+        node.args[1] = node.args[0]
+        node.args[0] = Constant(f"{{:,.{decimal_places}f}}")
+
+
+def adapt_sha2_fn(node: Function) -> None:
+    """Adapt MySQL's SHA2 function to DuckDB's SHA256 function
+
+    Example:
+        SHA2('test', 256) => SHA256('test')
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the function has more than 1 argument or the argument is not 256
+    """
+    if len(node.args) > 1 and node.args[1].value != 256:
+        raise ValueError("Only sha256 is supported")
+    node.op = "sha256"
+    node.args = [node.args[0]]
+
+
+def adapt_length_fn(node: Function) -> None:
+    """Adapt MySQL's LENGTH function to DuckDB's STRLEN function
+    NOTE: duckdb also have LENGTH, therefore it can not be used
+
+    Example:
+        LENGTH('test') => STRLEN('test')
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+    """
+    node.op = "strlen"
+
+
+def adapt_regexp_substr_fn(node: Function) -> None:
+    """Adapt MySQL's REGEXP_SUBSTR function to DuckDB's REGEXP_EXTRACT function
+
+    Example:
+        REGEXP_SUBSTR('foobarbar', 'bar', 1, 1) => REGEXP_EXTRACT('foobarbar', 'bar')
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the function has more than 2 arguments or 3rd or 4th argument is not 1
+    """
+    if (
+        len(node.args) == 3
+        and node.args[2].value != 1
+        or len(node.args) == 4
+        and (node.args[3].value != 1 or node.args[2].value != 1)
+        or len(node.args) > 4
+    ):
+        raise ValueError("Only 2 arguments are supported for REGEXP_SUBSTR function")
+    node.args = node.args[:2]
+    node.op = "regexp_extract"
+
+
+def adapt_substring_index_fn(node: Function) -> BinaryOperation | Function:
+    """Adapt MySQL's SUBSTRING_INDEX function to DuckDB's SPLIT_PART function
+
+    Example:
+        SUBSTRING_INDEX('a.b.c.d', '.', 1) => SPLIT_PART('a.b.c.d', '.', 1)
+        SUBSTRING_INDEX('a.b.c.d', '.', 2) => CONCAT_WS('.', SPLIT_PART('a.b.c.d', '.', 1), SPLIT_PART('a.b.c.d', '.', 2))
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        BinaryOperation | Function: Binary operation node or function node
+
+    Raises:
+        ValueError: If the function has more than 3 arguments or the 3rd argument is not 1
+    """
+    if len(node.args[1].value) > 1:
+        raise ValueError("Only one car in separator")
+
+    if node.args[2].value == 1:
+        node.op = "split_part"
+        return node
+
+    acc = [node.args[1]]
+    for i in range(node.args[2].value):
+        fn = Function(op="split_part", args=[node.args[0], node.args[1], Constant(i + 1)])
+        acc.append(fn)
+
+    acc = Function(op="concat_ws", args=acc)
+    acc.alias = node.alias
+    return acc
+
+
+def adapt_curtime_fn(node: Function) -> BinaryOperation:
+    """Adapt MySQL's CURTIME function to DuckDB's GET_CURRENT_TIME function.
+    To get the same type as MySQL's CURTIME function, we need to cast the result to time type.
+
+    Example:
+        CURTIME() => GET_CURRENT_TIME()::time
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        BinaryOperation: Binary operation node
+    """
+    return BinaryOperation("::", args=[Function(op="get_current_time", args=[]), Identifier("time")], alias=node.alias)
+
+
+def adapt_timestampdiff_fn(node: Function) -> None:
+    """Adapt MySQL's TIMESTAMPDIFF function to DuckDB's DATE_DIFF function
+    NOTE: Looks like cast string args to timestamp works in most cases, but there may be some exceptions.
+
+    Example:
+        TIMESTAMPDIFF(YEAR, '2000-02-01', '2003-05-01') => DATE_DIFF('year', timestamp '2000-02-01', timestamp '2003-05-01')
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+    """
+    node.op = "date_diff"
+    node.args[0] = Constant(node.args[0].parts[0])
+    node.args[1] = BinaryOperation(" ", args=[Identifier("timestamp"), node.args[1]])
+    node.args[2] = BinaryOperation(" ", args=[Identifier("timestamp"), node.args[2]])
+
+
+def adapt_extract_fn(node: Function) -> None:
+    """Adapt MySQL's EXTRACT function to DuckDB's EXTRACT function
+    TODO: multi-part args, like YEAR_MONTH, is not supported yet
+    NOTE: Looks like adding 'timestamp' works in most cases, but there may be some exceptions.
+
+    Example:
+        EXTRACT(YEAR FROM '2000-02-01') => EXTRACT('year' from timestamp '2000-02-01')
+
+    Args:
+        node (Function): Function node to adapt
+
+    Returns:
+        None
+    """
+    node.args[0] = Constant(node.args[0].parts[0])
+    if not isinstance(node.from_arg, Identifier):
+        node.from_arg = BinaryOperation(" ", args=[Identifier("timestamp"), node.from_arg])

mindsdb/api/executor/utilities/sql.py

@@ -14,6 +14,19 @@ from mindsdb.utilities.exception import format_db_error_message
 from mindsdb.utilities.functions import resolve_table_identifier, resolve_model_identifier
 from mindsdb.utilities.json_encoder import CustomJSONEncoder
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.api.executor.utilities.mysql_to_duckdb_functions import (
+    adapt_char_fn,
+    adapt_locate_fn,
+    adapt_unhex_fn,
+    adapt_format_fn,
+    adapt_sha2_fn,
+    adapt_length_fn,
+    adapt_regexp_substr_fn,
+    adapt_substring_index_fn,
+    adapt_curtime_fn,
+    adapt_timestampdiff_fn,
+    adapt_extract_fn,
+)
 
 logger = log.getLogger(__name__)
 
@@ -185,6 +198,23 @@ def query_df(df, query, session=None):
         if isinstance(node, Function):
             fnc_name = node.op.lower()
 
+            mysql_to_duck_fn_map = {
+                "char": adapt_char_fn,
+                "locate": adapt_locate_fn,
+                "insrt": adapt_locate_fn,
+                "unhex": adapt_unhex_fn,
+                "format": adapt_format_fn,
+                "sha2": adapt_sha2_fn,
+                "length": adapt_length_fn,
+                "regexp_substr": adapt_regexp_substr_fn,
+                "substring_index": adapt_substring_index_fn,
+                "curtime": adapt_curtime_fn,
+                "timestampdiff": adapt_timestampdiff_fn,
+                "extract": adapt_extract_fn,
+            }
+            if fnc_name in mysql_to_duck_fn_map:
+                return mysql_to_duck_fn_map[fnc_name](node)
+
             if fnc_name == "database" and len(node.args) == 0:
                 if session is not None:
                     cur_db = session.database

mindsdb/api/http/initialize.py

@@ -203,7 +203,8 @@ def initialize_static():
         logger.debug("Updating gui..")
         success = update_static(last_gui_version_lv)
 
-    db.session.close()
+    if db.session:
+        db.session.close()
     return success
 
 

mindsdb/api/http/namespaces/agents.py

@@ -323,15 +323,16 @@ class AgentCompletionsStream(Resource):
     @ns_conf.doc("agent_completions_stream")
     @api_endpoint_metrics("POST", "/agents/agent/completions/stream")
     def post(self, project_name, agent_name):
-        logger.info(f"Received streaming request for agent {agent_name} in project {project_name}")
-
-        # Check for required parameters.
+        # Extract messages from request (HTTP format only)
         if "messages" not in request.json:
-            logger.error("Missing 'messages' parameter in request body")
             return http_error(
-                HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "messages" parameter in POST body'
+                HTTPStatus.BAD_REQUEST,
+                "Missing parameter",
+                'Must provide "messages" parameter in POST body',
             )
 
+        messages = request.json["messages"]
+
         session = SessionController()
         try:
             existing_agent = session.agents_controller.get_agent(agent_name, project_name=project_name)
@@ -346,8 +347,6 @@ class AgentCompletionsStream(Resource):
                 HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
 
-        messages = request.json["messages"]
-
         try:
             gen = _completion_event_generator(agent_name, messages, project_name)
             logger.info(f"Starting streaming response for agent {agent_name}")

mindsdb/api/http/namespaces/views.py

@@ -10,143 +10,127 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.utilities.exception import EntityNotExistsError
 
 
-@ns_conf.route('/<project_name>/views')
+@ns_conf.route("/<project_name>/views")
 class ViewsList(Resource):
-    @ns_conf.doc('list_views')
-    @api_endpoint_metrics('GET', '/views')
+    @ns_conf.doc("list_views")
+    @api_endpoint_metrics("GET", "/views")
     def get(self, project_name):
-        '''List all views'''
+        """List all views"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project 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")
 
         all_views = project.get_views()
         all_view_objs = []
         # Only want to return relevant fields to the user.
         for view in all_views:
-            all_view_objs.append({
-                'id': view['metadata']['id'],
-                'name': view['name'],
-                'query': view['query']
-            })
+            all_view_objs.append({"id": view["metadata"]["id"], "name": view["name"], "query": view["query"]})
         return all_view_objs
 
-    @ns_conf.doc('create_view')
-    @api_endpoint_metrics('POST', '/views')
+    @ns_conf.doc("create_view")
+    @api_endpoint_metrics("POST", "/views")
     def post(self, project_name):
-        '''Create a new view'''
-        if 'view' not in request.json:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Must provide "view" parameter in POST body')
+        """Create a new view"""
+        if "view" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Must provide "view" parameter in POST body')
         session = SessionController()
-        view_obj = request.json['view']
-        if 'name' not in view_obj:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "name" field for view')
-        if 'query' not in view_obj:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "query" field for view')
-        name = view_obj['name']
-        query = view_obj['query']
+        view_obj = request.json["view"]
+        if "name" not in view_obj:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "name" field for view')
+        if "query" not in view_obj:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "query" field for view')
+        name = view_obj["name"]
+        query = view_obj["query"]
 
         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, "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.')
+            return http_error(HTTPStatus.CONFLICT, "Name conflict", f"View with name {name} already exists.")
 
-        project.create_view(name, query)
+        project.create_view(name, query, session)
         created_view = project.get_view(name)
         # Only want to return relevant fields to the user.
         return {
-            'id': created_view['metadata']['id'],
-            'name': created_view['name'],
-            'query': created_view['query']
+            "id": created_view["metadata"]["id"],
+            "name": created_view["name"],
+            "query": created_view["query"],
         }, HTTPStatus.CREATED
 
 
-@ns_conf.route('/<project_name>/views/<view_name>')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('view_name', 'Name of the view')
+@ns_conf.route("/<project_name>/views/<view_name>")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("view_name", "Name of the view")
 class ViewResource(Resource):
-    @ns_conf.doc('get_view')
-    @api_endpoint_metrics('GET', '/views/view')
+    @ns_conf.doc("get_view")
+    @api_endpoint_metrics("GET", "/views/view")
     def get(self, project_name, view_name):
-        '''Get a view by name'''
+        """Get a view by name"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project 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")
 
         view = project.get_view(view_name)
         if view is None:
-            return http_error(HTTPStatus.NOT_FOUND, 'View not found', f'View with name {view_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "View not found", f"View with name {view_name} does not exist")
 
         # Only want to return relevant fields to the user.
-        return {
-            'id': view['metadata']['id'],
-            'name': view['name'],
-            'query': view['query']
-        }
+        return {"id": view["metadata"]["id"], "name": view["name"], "query": view["query"]}
 
-    @ns_conf.doc('update_view')
-    @api_endpoint_metrics('PUT', '/views/view')
+    @ns_conf.doc("update_view")
+    @api_endpoint_metrics("PUT", "/views/view")
     def put(self, project_name, view_name):
-        '''Updates or creates a view'''
-        if 'view' not in request.json:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Must provide "view" parameter in PUT body')
-        request_view = request.json['view']
+        """Updates or creates a view"""
+        if "view" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Must provide "view" parameter in PUT body')
+        request_view = request.json["view"]
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project 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")
 
         existing_view = project.get_view(view_name)
         if existing_view is None:
             # Create
-            if 'query' not in request_view:
-                return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "query" field for new view')
-            project.create_view(view_name, request_view['query'])
+            if "query" not in request_view:
+                return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "query" field for new view')
+            project.create_view(view_name, request_view["query"], session)
             created_view = project.get_view(view_name)
             # Only want to return relevant fields to the user.
             return {
-                'id': created_view['metadata']['id'],
-                'name': created_view['name'],
-                'query': created_view['query']
+                "id": created_view["metadata"]["id"],
+                "name": created_view["name"],
+                "query": created_view["query"],
             }, HTTPStatus.CREATED
 
-        new_query = existing_view['query']
-        if 'query' in request_view:
-            new_query = request_view['query']
+        new_query = existing_view["query"]
+        if "query" in request_view:
+            new_query = request_view["query"]
             project.update_view(view_name, new_query)
 
         existing_view = project.get_view(view_name)
         # Only want to return relevant fields to the user.
-        return {
-            'id': existing_view['metadata']['id'],
-            'name': existing_view['name'],
-            'query': existing_view['query']
-        }
+        return {"id": existing_view["metadata"]["id"], "name": existing_view["name"], "query": existing_view["query"]}
 
-    @ns_conf.doc('delete_view')
-    @api_endpoint_metrics('DELETE', '/views/view')
+    @ns_conf.doc("delete_view")
+    @api_endpoint_metrics("DELETE", "/views/view")
     def delete(self, project_name, view_name):
-        '''Deletes a view by name'''
+        """Deletes a view by name"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project 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(view_name) is None:
-            return http_error(HTTPStatus.NOT_FOUND, 'View not found', f'View with name {view_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "View not found", f"View with name {view_name} does not exist")
 
         project.delete_view(view_name)
-        return '', HTTPStatus.NO_CONTENT
+        return "", HTTPStatus.NO_CONTENT

mindsdb/integrations/handlers/db2_handler/db2_handler.py

@@ -59,16 +59,20 @@ class DB2Handler(DatabaseHandler):
             return self.connection
 
         # Mandatory connection parameters.
-        if not all(key in self.connection_data for key in ['host', 'user', 'password', 'database']):
-            raise ValueError('Required parameters (host, user, password, database) must be provided.')
-
-        connection_string = f"DRIVER={'IBM DB2 ODBC DRIVER'};DATABASE={self.connection_data['database']};HOST={self.connection_data['host']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};"
-
-        # Optional connection parameters.
-        if 'port' in self.connection_data:
-            connection_string += f"PORT={self.connection_data['port']};"
-
-        if 'schema' in self.connection_data:
+        if not all(key in self.connection_data for key in ["host", "user", "password", "database"]):
+            raise ValueError("Required parameters (host, user, password, database) must be provided.")
+        cloud = "databases.appdomain.cloud" in self.connection_data["host"]
+        if cloud:
+            connection_string = f"DATABASE={self.connection_data['database']};HOSTNAME={self.connection_data['host']};PORT={self.connection_data['port']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};SECURITY=SSL;"
+            connection_string += "SSLSERVERCERTIFICATE=;"
+        else:
+            connection_string = f"DRIVER={'IBM DB2 ODBC DRIVER'};DATABASE={self.connection_data['database']};HOST={self.connection_data['host']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};"
+
+            # Optional connection parameters.
+            if "port" in self.connection_data:
+                connection_string += f"PORT={self.connection_data['port']};"
+
+        if "schema" in self.connection_data:
             connection_string += f"CURRENTSCHEMA={self.connection_data['schema']};"
 
         try:
@@ -106,10 +110,10 @@ class DB2Handler(DatabaseHandler):
             self.connect()
             response.success = True
         except (OperationalError, ValueError) as known_error:
-            logger.error(f'Connection check to IBM Db2 failed, {known_error}!')
+            logger.error(f"Connection check to IBM Db2 failed, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Connection check to IBM Db2 failed due to an unknown error, {unknown_error}!')
+            logger.error(f"Connection check to IBM Db2 failed due to an unknown error, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success and need_to_close:
@@ -141,9 +145,7 @@ class DB2Handler(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)
@@ -198,10 +200,7 @@ class DB2Handler(DatabaseHandler):
                 }
             )
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(tables)
-        )
+        response = Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(tables))
 
         return response
 
@@ -227,9 +226,6 @@ class DB2Handler(DatabaseHandler):
 
         columns = [column["COLUMN_NAME"] for column in result]
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(columns, columns=["COLUMN_NAME"])
-        )
+        response = Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(columns, columns=["COLUMN_NAME"]))
 
         return response

mindsdb/integrations/handlers/gong_handler/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.0.1"
+__description__ = "Gong conversation intelligence platform handler for MindsDB"

mindsdb/integrations/handlers/gong_handler/__init__.py

@@ -0,0 +1,30 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+
+try:
+    from .gong_handler import GongHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Gong"
+name = "gong"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]