MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.0__py3-none-any.whl

mindsdb/integrations/handlers/vertica_handler/tests/test_vertica_handler.py

@@ -8,14 +8,14 @@ class VerticaHandlerTest(unittest.TestCase):
     def setUpClass(cls):
         cls.kwargs = {
             "connection_data": {
-                "host":'127.0.0.1',
-                "port":5433,
-                "user":'dbadmin',
-                "password":'',
-                "database":'VMart',
-                "schema_name":'public'
+                "host": '127.0.0.1',
+                "port": 5433,
+                "user": 'dbadmin',
+                "password": '',
+                "database": 'VMart',
+                "schema_name": 'public'
             }
-    
+
         }
         cls.handler = VerticaHandler('test_vertica_handler', cls.kwargs)
 
@@ -24,21 +24,21 @@ class VerticaHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table TEST(id Number(1),Name Varchar(33))"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert(self):
         query = "INSERT INTO TEST (1,'lOVe yOU)"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_4_native_query_select(self):
         query = "SELECT * FROM TEST;"
         result = self.handler.query(query)
-        assert result.type is RESPONSE_TYPE.TABLE 
+        assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_get_tables(self):
         tables = self.handler.get_tables()

mindsdb/integrations/handlers/vertica_handler/vertica_handler.py

@@ -30,7 +30,7 @@ class VerticaHandler(DatabaseHandler):
 
     def __init__(self, name, connection_data: Optional[dict], **kwargs):
         super().__init__(name)
-        
+
         self.parser = parse_sql
         self.dialect = 'vertica'
         self.kwargs = kwargs
@@ -40,7 +40,6 @@ class VerticaHandler(DatabaseHandler):
         self.connection = None
         self.is_connected = False
 
-
     def connect(self):
         if self.is_connected is True:
             return self.connection
@@ -66,7 +65,7 @@ class VerticaHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-       
+
         result = StatusResponse(False)
         need_to_close = self.is_connected is False
 
@@ -96,10 +95,10 @@ class VerticaHandler(DatabaseHandler):
         connection = self.connect()
         with connection.cursor() as cur:
             try:
-                e=cur.execute(query)
+                e = cur.execute(query)
                 result = e.fetchall()
                 if e.rowcount != -1:
-                    
+
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         pd.DataFrame(
@@ -135,26 +134,24 @@ class VerticaHandler(DatabaseHandler):
         """
         Get a list with all of the tabels in VERTICA
         """
-        q = f'''SELECT 
+        q = f'''SELECT
         TABLE_NAME,
         TABLE_SCHEMA
-        from v_catalog.tables 
-        WHERE table_schema='{self.schema_name}' 
+        from v_catalog.tables
+        WHERE table_schema='{self.schema_name}'
         order by
         table_name;'''
 
-         
         return self.native_query(q)
 
     def get_columns(self, table_name) -> Response:
         """
         Show details about the table
         """
-        q = f'''SELECT 
-        column_name , 
-        data_type 
-        FROM v_catalog.columns 
+        q = f'''SELECT
+        column_name ,
+        data_type
+        FROM v_catalog.columns
         WHERE table_name='{table_name}';'''
 
-        
         return self.native_query(q)

mindsdb/integrations/handlers/vitess_handler/tests/test_vitess_handler.py

@@ -2,13 +2,14 @@ import unittest
 from mindsdb.integrations.handlers.vitess_handler.vitess_handler import VitessHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
+
 class VitessHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.kwargs = {
             "connection_data": {
                 "host": "localhost",
-                "port": 33577 ,
+                "port": 33577,
                 "user": "root",
                 "password": "",
                 "database": "vitess",
@@ -21,36 +22,33 @@ class VitessHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table IF NOT EXISTS Lover(name varchar(101));"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert(self):
         query = "INSERT INTO LOVER VALUES('Shiv Shakti');"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_4_native_query_select(self):
         query = "SELECT * FROM LOVER;"
         result = self.handler.query(query)
-        assert result.type is RESPONSE_TYPE.TABLE 
+        assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is  RESPONSE_TYPE.TABLE
+        assert tables.type is RESPONSE_TYPE.TABLE
 
     def test_6_get_columns(self):
         columns = self.handler.get_columns('LOVER')
-        
+
         query = "DROP Table IF  EXISTS Lover;"
-        result = self.handler.query(query)
+        self.handler.query(query)
         assert columns.type is not RESPONSE_TYPE.ERROR
 
 
 if __name__ == '__main__':
     unittest.main()
-
-
-    

mindsdb/integrations/handlers/vitess_handler/vitess_handler.py

@@ -15,7 +15,6 @@ class VitessHandler(MysqlHandler):
         super().__init__(name, **kwargs)
 
 
-
 connection_args = OrderedDict(
     user={
         'type': ARG_TYPE.STR,

mindsdb/integrations/handlers/web_handler/web_handler.py

@@ -83,6 +83,7 @@ class WebHandler(APIHandler):
     """
     Web handler, handling crawling content from websites.
     """
+
     def __init__(self, name=None, **kwargs):
         super().__init__(name)
         crawler = CrawlerTable(self)

mindsdb/integrations/handlers/whatsapp_handler/__init__.py

@@ -10,7 +10,7 @@ try:
 except Exception as e:
     Handler = None
     import_error = e
-    
+
 title = 'WhatsApp'
 name = 'whatsapp'
 type = HANDLER_TYPE.DATA
@@ -21,8 +21,8 @@ __all__ = [
     'version',
     'name',
     'type',
-    'title', 
+    'title',
     'description',
     'import_error',
     'icon_path'
-]
+]

mindsdb/integrations/handlers/writer_handler/evaluate.py

@@ -359,4 +359,4 @@ class WriterEvaluator:
         elif self.args.evaluation_type == "e2e":
             return self.evaluate_e2e()
         else:
-            raise ValueError(f"evaluation_type must be either 'retrieval' or 'e2e'")
+            raise ValueError("evaluation_type must be either 'retrieval' or 'e2e'")

mindsdb/integrations/handlers/writer_handler/settings.py

@@ -2,7 +2,6 @@ from typing import List, Union
 from pydantic import BaseModel, Extra, field_validator
 
 from mindsdb.integrations.handlers.rag_handler.settings import (
-    DEFAULT_EMBEDDINGS_MODEL,
     RAGBaseParameters,
 )
 from langchain_core.callbacks import StreamingStdOutCallbackHandler

mindsdb/integrations/handlers/writer_handler/writer_handler.py

@@ -22,6 +22,7 @@ from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
+
 def extract_llm_params(args):
     """extract llm params from input query args"""
 

mindsdb/integrations/handlers/youtube_handler/youtube_handler.py

@@ -14,12 +14,12 @@ from mindsdb.utilities.config import Config
 
 from googleapiclient.discovery import build
 
-from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.google import GoogleUserOAuth2Manager
 
 DEFAULT_SCOPES = [
-	'https://www.googleapis.com/auth/youtube',
-	'https://www.googleapis.com/auth/youtube.force-ssl',
-	'https://www.googleapis.com/auth/youtubepartner'
+    'https://www.googleapis.com/auth/youtube',
+    'https://www.googleapis.com/auth/youtube.force-ssl',
+    'https://www.googleapis.com/auth/youtubepartner'
 ]
 
 logger = log.getLogger(__name__)
@@ -81,7 +81,7 @@ class YoutubeHandler(APIHandler):
         """
         if self.is_connected is True:
             return self.connection
-        
+
         google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_data.get('code'))
         creds = google_oauth2_manager.get_oauth2_credentials()
 

mindsdb/integrations/handlers/youtube_handler/youtube_tables.py

@@ -1,7 +1,6 @@
 from typing import List
 
 from mindsdb.integrations.libs.api_handler import APITable
-from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 from mindsdb.utilities import log
 
 from mindsdb_sql_parser import ast
@@ -61,21 +60,21 @@ class YoutubeCommentsTable(APITable):
 
         if not video_id and not channel_id:
             raise ValueError("Either video_id or channel_id has to be present in where clause.")
-            
+
         comments_df = self.get_comments(video_id=video_id, channel_id=channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            comments_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
-            order_by_conditions, 
+            comments_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
         comments_df = select_statement_executor.execute_query()
 
         return comments_df
-    
+
     def insert(self, query: ast.Insert) -> None:
         """Inserts data into the YouTube POST /commentThreads API endpoint.
 
@@ -93,7 +92,7 @@ class YoutubeCommentsTable(APITable):
         ValueError
             If the query contains an unsupported condition
         """
-        
+
         insert_query_parser = INSERTQueryParser(query, self.get_columns())
 
         values_to_insert = insert_query_parser.parse_query()
@@ -101,13 +100,13 @@ class YoutubeCommentsTable(APITable):
         for value in values_to_insert:
             if not value.get('comment_id'):
                 if not value.get('comment'):
-                    raise ValueError(f"comment is mandatory for inserting a top-level comment.")
+                    raise ValueError("comment is mandatory for inserting a top-level comment.")
                 else:
                     self.insert_comment(video_id=value['video_id'], text=value['comment'])
 
             else:
                 if not value.get('reply'):
-                    raise ValueError(f"reply is mandatory for inserting a reply.")
+                    raise ValueError("reply is mandatory for inserting a reply.")
                 else:
                     self.insert_comment(comment_id=value['comment_id'], text=value['reply'])
 
@@ -178,7 +177,7 @@ class YoutubeCommentsTable(APITable):
                 replies = []
                 if 'replies' in comment:
                     for reply in comment["replies"]["comments"]:
-                        replies.append( 
+                        replies.append(
                             {
                                 "reply_author": reply["snippet"]["authorDisplayName"],
                                 "user_id": reply["snippet"]["authorChannelId"]["value"],
@@ -225,7 +224,7 @@ class YoutubeCommentsTable(APITable):
 
         youtube_comments_df = pd.json_normalize(data, 'replies', ['comment_id', 'channel_id', 'video_id', 'user_id', 'display_name', 'comment', "published_at", "updated_at"], record_prefix='replies.')
         youtube_comments_df = youtube_comments_df.rename(columns={'replies.user_id': 'reply_user_id', 'replies.reply_author': 'reply_author', 'replies.reply': 'reply'})
-        
+
         # check if DataFrame is empty
         if youtube_comments_df.empty:
             return youtube_comments_df
@@ -262,10 +261,10 @@ class YoutubeChannelsTable(APITable):
         channel_df = self.get_channel_details(channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            channel_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] == 'channel_id'], 
-            order_by_conditions, 
+            channel_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] == 'channel_id'],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
@@ -325,7 +324,7 @@ class YoutubeVideosTable(APITable):
                     video_id = arg2
                 else:
                     raise NotImplementedError("Only '=' operator is supported for video_id column.")
-                
+
             elif arg1 == "channel_id":
                 if op == "=":
                     channel_id = arg2
@@ -334,24 +333,24 @@ class YoutubeVideosTable(APITable):
 
         if not video_id and not channel_id:
             raise ValueError("Either video_id or channel_id has to be present in where clause.")
-        
+
         if video_id:
             video_df = self.get_videos_by_video_ids([video_id])
         else:
             video_df = self.get_videos_by_channel_id(channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            video_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
-            order_by_conditions, 
+            video_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
         video_df = select_statement_executor.execute_query()
 
         return video_df
-    
+
     def get_videos_by_channel_id(self, channel_id):
         video_ids = []
         resource = (
@@ -389,7 +388,7 @@ class YoutubeVideosTable(APITable):
         # loop over 50 video ids at a time
         # an invalid request error is caused otherwise
         for i in range(0, len(video_ids), 50):
-            resource = self.handler.connect().videos().list(part="statistics,snippet,contentDetails", id=",".join(video_ids[i:i+50])).execute()
+            resource = self.handler.connect().videos().list(part="statistics,snippet,contentDetails", id=",".join(video_ids[i:i + 50])).execute()
             for item in resource["items"]:
                 data.append(
                     {
@@ -418,15 +417,15 @@ class YoutubeVideosTable(APITable):
         except Exception as e:
             logger.error(f"Encountered an error while fetching transcripts for video ${video_id}: ${e}"),
             return "Transcript not available for this video"
-        
+
     def parse_duration(self, video_id, duration):
         try:
-            parsed_duration = re.search(f"PT(\d+H)?(\d+M)?(\d+S)", duration).groups()
+            parsed_duration = re.search(r"PT(\d+H)?(\d+M)?(\d+S)", duration).groups()
             duration_str = ""
             for d in parsed_duration:
                 if d:
                     duration_str += f"{d[:-1]}:"
-            
+
             return duration_str.strip(":")
         except Exception as e:
             logger.error(f"Encountered an error while parsing duration for video ${video_id}: ${e}"),

mindsdb/integrations/handlers/yugabyte_handler/tests/test_yugabyte_handler.py

@@ -35,7 +35,7 @@ class YugabyteHandlerTest(unittest.TestCase):
     def test_4_get_tables(self):
         tables = self.handler.get_tables()
         assert tables.type is not RESPONSE_TYPE.ERROR
- 
+
     def test_5_select_query(self):
         query = "SELECT * FROM PREM;"
         result = self.handler.native_query(query)
@@ -44,6 +44,6 @@ class YugabyteHandlerTest(unittest.TestCase):
     def test_6_check_connection(self):
         self.handler.check_connection()
 
-        
+
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

mindsdb/integrations/handlers/yugabyte_handler/yugabyte_handler.py

@@ -1,10 +1,4 @@
 from collections import OrderedDict
-from typing import Optional
-
-from mindsdb_sql_parser import parse_sql
-from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-from pandas import DataFrame
 
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
     PostgresHandler,

mindsdb/integrations/libs/response.py

@@ -6,6 +6,7 @@ import pandas
 
 from mindsdb.utilities import log
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb_sql_parser.ast import ASTNode
 
 
@@ -18,29 +19,32 @@ class _INFORMATION_SCHEMA_COLUMNS_NAMES:
     These column names match the standard INFORMATION_SCHEMA.COLUMNS structure
     used in SQL databases to describe table metadata.
     """
-    COLUMN_NAME: str = 'COLUMN_NAME'
-    DATA_TYPE: str = 'DATA_TYPE'
-    ORDINAL_POSITION: str = 'ORDINAL_POSITION'
-    COLUMN_DEFAULT: str = 'COLUMN_DEFAULT'
-    IS_NULLABLE: str = 'IS_NULLABLE'
-    CHARACTER_MAXIMUM_LENGTH: str = 'CHARACTER_MAXIMUM_LENGTH'
-    CHARACTER_OCTET_LENGTH: str = 'CHARACTER_OCTET_LENGTH'
-    NUMERIC_PRECISION: str = 'NUMERIC_PRECISION'
-    NUMERIC_SCALE: str = 'NUMERIC_SCALE'
-    DATETIME_PRECISION: str = 'DATETIME_PRECISION'
-    CHARACTER_SET_NAME: str = 'CHARACTER_SET_NAME'
-    COLLATION_NAME: str = 'COLLATION_NAME'
-    MYSQL_DATA_TYPE: str = 'MYSQL_DATA_TYPE'
+
+    COLUMN_NAME: str = "COLUMN_NAME"
+    DATA_TYPE: str = "DATA_TYPE"
+    ORDINAL_POSITION: str = "ORDINAL_POSITION"
+    COLUMN_DEFAULT: str = "COLUMN_DEFAULT"
+    IS_NULLABLE: str = "IS_NULLABLE"
+    CHARACTER_MAXIMUM_LENGTH: str = "CHARACTER_MAXIMUM_LENGTH"
+    CHARACTER_OCTET_LENGTH: str = "CHARACTER_OCTET_LENGTH"
+    NUMERIC_PRECISION: str = "NUMERIC_PRECISION"
+    NUMERIC_SCALE: str = "NUMERIC_SCALE"
+    DATETIME_PRECISION: str = "DATETIME_PRECISION"
+    CHARACTER_SET_NAME: str = "CHARACTER_SET_NAME"
+    COLLATION_NAME: str = "COLLATION_NAME"
+    MYSQL_DATA_TYPE: str = "MYSQL_DATA_TYPE"
 
 
 INF_SCHEMA_COLUMNS_NAMES = _INFORMATION_SCHEMA_COLUMNS_NAMES()
 INF_SCHEMA_COLUMNS_NAMES_SET = set(f.name for f in fields(INF_SCHEMA_COLUMNS_NAMES))
 
 
-
 class HandlerResponse:
-    def __init__(self, resp_type: RESPONSE_TYPE, data_frame: pandas.DataFrame = None, query: ASTNode = 0, error_code: int = 0,
-                 error_message: str | None = None, affected_rows: int | None = None) -> None:
+    def __init__(
+            self, resp_type: RESPONSE_TYPE, data_frame: pandas.DataFrame = None, query: ASTNode = 0,
+            error_code: int = 0, error_message: str | None = None, affected_rows: int | None = None,
+            mysql_types: list[MYSQL_DATA_TYPE] | None = None
+    ) -> None:
         self.resp_type = resp_type
         self.query = query
         self.data_frame = data_frame
@@ -49,6 +53,7 @@ class HandlerResponse:
         self.affected_rows = affected_rows
         if isinstance(self.affected_rows, int) is False or self.affected_rows < 0:
             self.affected_rows = 0
+        self.mysql_types = mysql_types
 
     @property
     def type(self):
@@ -66,7 +71,9 @@ class HandlerResponse:
                     f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}, "
                     f"the error is: {self.error_message}"
                 )
-            raise ValueError(f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}")
+            raise ValueError(
+                f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}"
+            )
 
         self.data_frame.columns = [name.upper() for name in self.data_frame.columns]
         self.data_frame[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] = self.data_frame[
@@ -77,24 +84,26 @@ class HandlerResponse:
         current_columns_set = set(self.data_frame.columns)
         if INF_SCHEMA_COLUMNS_NAMES_SET != current_columns_set:
             raise ValueError(
-                f'Columns set for INFORMATION_SCHEMA.COLUMNS is wrong: {list(current_columns_set)}'
+                f"Columns set for INFORMATION_SCHEMA.COLUMNS is wrong: {list(current_columns_set)}"
             )
         # endregion
 
-        self.data_frame = self.data_frame.astype({
-            INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME: 'string',
-        })
+        self.data_frame = self.data_frame.astype(
+            {
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT: "string",
+                INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME: "string",
+            }
+        )
         self.data_frame.replace([numpy.NaN, pandas.NA], None, inplace=True)
 
         self.resp_type = RESPONSE_TYPE.COLUMNS_TABLE
@@ -103,33 +112,39 @@ class HandlerResponse:
         try:
             data = None
             if self.data_frame is not None:
-                data = self.data_frame.to_json(orient="split", index=False, date_format="iso")
+                data = self.data_frame.to_json(
+                    orient="split", index=False, date_format="iso"
+                )
         except Exception as e:
             logger.error("%s.to_json: error - %s", self.__class__.__name__, e)
             data = None
-        return  {"type": self.resp_type,
-                 "query": self.query,
-                 "data_frame": data,
-                 "error_code": self.error_code,
-                 "error": self.error_message}
+        return {
+            "type": self.resp_type,
+            "query": self.query,
+            "data_frame": data,
+            "error_code": self.error_code,
+            "error": self.error_message,
+        }
 
     def __repr__(self):
-        return "%s: resp_type=%s, query=%s, data_frame=%s, err_code=%s, error=%s, affected_rows=%s" % (
-                self.__class__.__name__,
-                self.resp_type,
-                self.query,
-                self.data_frame,
-                self.error_code,
-                self.error_message,
-                self.affected_rows
-            )
+        return "%s: resp_type=%s, query=%s, data_frame=\n%s\nerr_code=%s, error=%s, affected_rows=%s" % (
+            self.__class__.__name__,
+            self.resp_type,
+            self.query,
+            self.data_frame,
+            self.error_code,
+            self.error_message,
+            self.affected_rows,
+        )
 
 
 class HandlerStatusResponse:
-    def __init__(self, success: bool = True,
-                 error_message: str = None,
-                 redirect_url: str = None,
-                 copy_storage: str = None
+    def __init__(
+        self,
+        success: bool = True,
+        error_message: str = None,
+        redirect_url: str = None,
+        copy_storage: str = None,
     ) -> None:
         self.success = success
         self.error_message = error_message
@@ -139,7 +154,7 @@ class HandlerStatusResponse:
     def to_json(self):
         data = {"success": self.success, "error": self.error_message}
         if self.redirect_url is not None:
-            data['redirect_url'] = self.redirect_url
+            data["redirect_url"] = self.redirect_url
         return data
 
     def __repr__(self):

mindsdb/integrations/libs/vectordatabase_handler.py

@@ -553,3 +553,9 @@ class VectorStoreHandler(BaseHandler):
             df(pd.DataFrame): Hybrid search result, sorted by hybrid search rank
         '''
         raise NotImplementedError(f'Hybrid search not supported for VectorStoreHandler {self.name}')
+
+    def create_index(self, *args, **kwargs):
+        """
+        Create an index on the specified table.
+        """
+        raise NotImplementedError(f'create_index not supported for VectorStoreHandler {self.name}')