MindsDB 1.2.9__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/integrations/handlers/unify_handler/unify_handler.py

@@ -0,0 +1,67 @@
+from typing import Optional, Dict
+
+import unify
+import pandas as pd
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+
+from mindsdb.utilities import log
+
+from mindsdb.integrations.utilities.handler_utils import get_api_key
+
+
+logger = log.getLogger(__name__)
+
+class UnifyHandler(BaseMLEngine):
+    """
+    Integration with the Unifyai Python Library
+    """
+    name = 'unify'
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        if 'using' not in args:
+            raise Exception("Unify engine requires a USING clause! Refer to its documentation for more details.")
+
+        self.generative = True
+        self.model_storage.json_set('args', args)
+
+    def predict(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        
+        args = self.model_storage.json_get('args')
+        
+
+        input_keys = list(args.keys())
+
+        logger.info(f"Input keys: {input_keys}!")
+
+        if 'model' not in args['using']:
+            raise Exception("Unify requires an model parameter in the USING clause! Refer to its documentation for more details.")
+        model = args['using']['model']
+
+        if 'provider' not in args['using']:
+            raise Exception("Unify requires a provider parameter in the USING clause! Refer to its documentation for more details.")
+        provider = args['using']['provider']
+        
+        self.endpoint = model + '@' + provider
+        self.api_key = get_api_key('unify', args["using"], self.engine_storage, strict=False)
+        available_endpoints = unify.utils.list_endpoints(api_key=self.api_key)
+        if self.endpoint not in available_endpoints:
+            raise Exception("The model, provider or their combination is not supported by Unify! The supported endpoints are: " + str(available_endpoints))
+
+        question_column = args['using']['column']
+        if question_column not in df.columns:
+            raise RuntimeError(f'Column "{question_column}" not found in input data')
+        
+        result_df = pd.DataFrame() 
+        result_df['predictions'] = df[question_column].apply(self.predict_answer)     
+        result_df = result_df.rename(columns={'predictions': args['target']})
+        
+        return result_df
+    
+    def predict_answer(self, text):
+        
+        client = unify.Unify(self.endpoint, api_key=self.api_key)
+
+        response = client.generate(text)
+
+        return response

mindsdb/integrations/handlers/vertex_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Vertex handler"
+__package_name__ = "mindsdb_vertex_handler"
+__version__ = "0.0.0"
+__description__ = "MindsDB handler for Google Vertex AI API"
+__author__ = "MindsDB Inc"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022- mindsdb"

mindsdb/integrations/handlers/vertex_handler/__init__.py

@@ -0,0 +1,19 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+
+try:
+    from .vertex_handler import VertexHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Google Vertex AI"
+name = "vertex"
+type = HANDLER_TYPE.ML
+icon_path = "icon.png"
+permanent = False
+
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]

mindsdb/integrations/handlers/vertex_handler/requirements.txt

@@ -0,0 +1 @@
+google-cloud-aiplatform>=1.35.0

mindsdb/integrations/handlers/vertex_handler/vertex_client.py

@@ -0,0 +1,95 @@
+from mindsdb.utilities import log
+from google.cloud.aiplatform import init, TabularDataset, Model, Endpoint
+import pandas as pd
+
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleServiceAccountOAuth2Manager
+
+logger = log.getLogger(__name__)
+
+
+class VertexClient:
+    """A class to interact with Vertex AI"""
+
+    def __init__(self, args_json, credentials_url=None, credentials_file=None, credentials_json=None):
+        google_sa_oauth2_manager = GoogleServiceAccountOAuth2Manager(
+            credentials_url=credentials_url,
+            credentials_file=credentials_file,
+            credentials_json=credentials_json,
+        )
+        credentials = google_sa_oauth2_manager.get_oauth2_credentials()
+
+        init(
+            credentials=credentials,
+            project=args_json["project_id"],
+            location=args_json["location"],
+            staging_bucket=args_json["staging_bucket"],
+            # the name of the experiment to use to track
+            # logged metrics and parameters
+            experiment=args_json["experiment"],
+            # description of the experiment above
+            experiment_description=args_json["experiment_description"],
+        )
+
+    def print_datasets(self):
+        """Print all datasets and dataset ids in the project"""
+        for dataset in TabularDataset.list():
+            logger.info(f"Dataset display name: {dataset.display_name}, ID: {dataset.name}")
+
+    def print_models(self):
+        """Print all model names and model ids in the project"""
+        for model in Model.list():
+            logger.info(f"Model display name: {model.display_name}, ID: {model.name}")
+
+    def print_endpoints(self):
+        """Print all endpoints and endpoint ids in the project"""
+        for endpoint in Endpoint.list():
+            logger.info(f"Endpoint display name: {endpoint.display_name}, ID: {endpoint.name}")
+
+    def get_model_by_display_name(self, display_name):
+        """Get a model by its display name"""
+        try:
+            return Model.list(filter=f"display_name={display_name}")[0]
+        except IndexError:
+            logger.info(f"Model with display name {display_name} not found")
+
+    def get_endpoint_by_display_name(self, display_name):
+        """Get an endpoint by its display name"""
+        try:
+            return Endpoint.list(filter=f"display_name={display_name}")[0]
+        except IndexError:
+            logger.info(f"Endpoint with display name {display_name} not found")
+
+    def get_model_by_id(self, model_id):
+        """Get a model by its ID"""
+        try:
+            return Model(model_name=model_id)
+        except IndexError:
+            logger.info(f"Model with ID {model_id} not found")
+
+    def deploy_model(self, model):
+        """Deploy a model to an endpoint - long runtime"""
+        endpoint = model.deploy()
+        return endpoint
+
+    def predict_from_df(self, endpoint_display_name, df, custom_model=False):
+        """Make a prediction from a Pandas dataframe"""
+        endpoint = self.get_endpoint_by_display_name(endpoint_display_name)
+        if custom_model:
+            records = df.values.tolist()
+        else:
+            records = df.astype(str).to_dict(orient="records")  # list of dictionaries
+        prediction = endpoint.predict(instances=records)
+        return prediction
+
+    def predict_from_csv(self, endpoint_display_name, csv_to_predict):
+        """Make a prediction from a CSV file"""
+        df = pd.read_csv(csv_to_predict)
+        return self.predict_from_df(endpoint_display_name, df)
+
+    def predict_from_dict(self, endpoint_display_name, data):
+
+        # convert to list of dictionaries
+        instances = [dict(zip(data.keys(), values)) for values in zip(*data.values())]
+        endpoint = self.get_endpoint_by_display_name(endpoint_display_name)
+        prediction = endpoint.predict(instances=instances)
+        return prediction

mindsdb/integrations/handlers/vertex_handler/vertex_handler.py

@@ -0,0 +1,87 @@
+import pandas as pd
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.integrations.handlers.vertex_handler.vertex_client import VertexClient
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class VertexHandler(BaseMLEngine):
+    """Handler for the Vertex Google AI cloud API"""
+
+    name = "Vertex"
+
+    def create(self, target, args=None, **kwargs):
+        """Logs in to Vertex and deploy a pre-trained model to an endpoint.
+
+        If the endpoint already exists for the model, we do nothing.
+
+        If the endpoint does not exist, we create it and deploy the model to it.
+        The runtime for this is long, it took 15 minutes for a small model.
+        """
+        assert "using" in args, "Must provide USING arguments for this handler"
+        args = args["using"]
+
+        model_name = args.pop("model_name")
+        custom_model = args.pop("custom_model", False)
+
+        # get credentials from engine
+        credentials_url, credentials_file, credentials_json = self._get_credentials_from_engine()
+
+        # get vertex args from handler then update args from model
+        vertex_args = self.engine_storage.json_get('args')
+        vertex_args.update(args)
+
+        vertex = VertexClient(vertex_args, credentials_url, credentials_file, credentials_json)
+
+        model = vertex.get_model_by_display_name(model_name)
+        if not model:
+            raise Exception(f"Vertex model {model_name} not found")
+        endpoint_name = model_name + "_endpoint"
+        if vertex.get_endpoint_by_display_name(endpoint_name):
+            logger.info(f"Endpoint {endpoint_name} already exists, skipping deployment")
+        else:
+            logger.info(f"Starting deployment at {endpoint_name}")
+            endpoint = vertex.deploy_model(model)
+            endpoint.display_name = endpoint_name
+            endpoint.update()
+            logger.info(f"Endpoint {endpoint_name} deployed")
+
+        predict_args = {}
+        predict_args["target"] = target
+        predict_args["endpoint_name"] = endpoint_name
+        predict_args["custom_model"] = custom_model
+        self.model_storage.json_set("predict_args", predict_args)
+        self.model_storage.json_set("vertex_args", vertex_args)
+
+    def predict(self, df, args=None):
+        """Predict using the deployed model by calling the endpoint."""
+
+        if "__mindsdb_row_id" in df.columns:
+            df.drop("__mindsdb_row_id", axis=1, inplace=True)  # TODO is this required?
+
+        predict_args = self.model_storage.json_get("predict_args")
+        vertex_args = self.model_storage.json_get("vertex_args")
+
+        # get credentials from engine
+        credentials_url, credentials_file, credentials_json = self._get_credentials_from_engine()
+
+        vertex = VertexClient(vertex_args, credentials_url, credentials_file, credentials_json)
+        results = vertex.predict_from_df(predict_args["endpoint_name"], df, custom_model=predict_args["custom_model"])
+
+        if predict_args["custom_model"]:
+            return pd.DataFrame(results.predictions, columns=[predict_args["target"]])
+        else:
+            return pd.DataFrame(results.predictions)
+
+    def create_engine(self, connection_args):
+        # check if one of credentials_url, credentials_file, or credentials_json is provided
+        if 'service_account_key_url' not in connection_args and 'service_account_key_file' not in connection_args and 'service_account_key_json' not in connection_args:
+            raise KeyError('Either service_account_key_url, service_account_key_file, or service_account_key_json must be provided')
+
+        self.engine_storage.json_set('args', connection_args)
+
+    def _get_credentials_from_engine(self):
+        engine_args = self.engine_storage.json_get('args')
+
+        return engine_args.get('service_account_key_url'), engine_args.get('service_account_key_file'), engine_args.get('service_account_key_json')

mindsdb/integrations/handlers/vertica_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Vertica handler'
+__package_name__ = 'mindsdb_vertica_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Vertica"
+__author__ = 'Parthiv Makwana'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/vertica_handler/__init__.py

@@ -0,0 +1,20 @@
+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 .vertica_handler import VerticaHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Vertica'
+name = 'vertica'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description',
+    'connection_args', 'connection_args_example', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/vertica_handler/connection_args.py

@@ -0,0 +1,41 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    user={
+        'type': ARG_TYPE.STR,
+        'description': 'The user name used to authenticate with the Vertica server.'
+    },
+    password={
+        'type': ARG_TYPE.PWD,
+        'description': 'The password to authenticate the user with the VERTICA server.',
+        'secret': True
+    },
+    database={
+        'type': ARG_TYPE.STR,
+        'description': 'The database name to use when connecting with the VERTICA server.'
+    },
+    host={
+        'type': ARG_TYPE.STR,
+        'description': 'The host name or IP address of the VERTICA server. NOTE: use \'127.0.0.1\' instead of \'localhost\' to connect to local server.'
+    },
+    port={
+        'type': ARG_TYPE.INT,
+        'description': 'The TCP/IP port of the VERTICA server. Must be an integer.'
+    },
+    schema_name={
+        'type': ARG_TYPE.STR,
+        'description': 'Table are listed according to schema name (it is optional). Note: Default value is "public"'
+    }
+)
+
+connection_args_example = OrderedDict(
+    host='127.0.0.1',
+    port=5433,
+    user='root',
+    password='password',
+    database='database',
+    schema_name='xyz'
+)

mindsdb/integrations/handlers/vertica_handler/icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M12.721 16.5957H7.83727L5.09308 21.459L2.3489 16.5957H1.02332L5.09308 23.7859L8.51169 17.7359H12.721V16.5957Z" fill="black"/>
+  <path d="M12.7209 20.6445V19.4811H7.86047V23.4601H12.7209V22.3199H9.00001V20.6445H12.7209Z" fill="black"/>
+  <path d="M25.8837 16.5957H24.7441V23.4602H25.8837V16.5957Z" fill="black"/>
+  <path d="M24.3024 16.5957H18.4884V16.619C18.8372 16.8982 19.1163 17.2938 19.2791 17.7359H20.8372V23.4602H21.9768V17.7359H24.3256L24.3024 16.5957Z" fill="black"/>
+  <path d="M18.2093 23.4602H19.3488L17.6744 20.3653C18.3953 20.0861 18.907 19.3648 18.907 18.5503C18.907 17.4567 18.0232 16.5957 16.9535 16.5957H14.3721H13.6046H13.2325V23.4602H14.3721V20.5282H16.6279L18.2093 23.4602ZM14.3488 17.7359H16.9302C17.3953 17.7359 17.7442 18.1082 17.7442 18.5503C17.7442 19.0157 17.3721 19.3648 16.9302 19.3648H14.3488V17.7359Z" fill="black"/>
+  <path d="M34.6977 16.3397L31.7675 21.2263C31.3489 21.9011 30.6047 22.3665 29.7675 22.3665C28.4652 22.3665 27.4186 21.3194 27.4186 20.0163C27.4186 18.7132 28.4652 17.6661 29.7675 17.6661C30.5582 17.6661 31.2559 18.0617 31.6977 18.6667L32.3024 17.6428C31.6745 16.968 30.7675 16.5259 29.7675 16.5259C27.8373 16.5259 26.3024 18.0849 26.3024 19.993C26.3024 21.9011 27.8605 23.4601 29.7675 23.4601C31.0233 23.4601 32.1396 22.7853 32.7442 21.7847L34.6977 18.527L37.6512 23.4601L38.9768 23.4369L34.6977 16.3397Z" fill="black"/>
+</svg>

mindsdb/integrations/handlers/vertica_handler/requirements.txt

@@ -0,0 +1,2 @@
+vertica-python
+sqlalchemy-vertica-python

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

@@ -0,0 +1,53 @@
+import unittest
+from mindsdb.integrations.handlers.vertica_handler.vertica_handler import VerticaHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class VerticaHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "connection_data": {
+                "host":'127.0.0.1',
+                "port":5433,
+                "user":'dbadmin',
+                "password":'',
+                "database":'VMart',
+                "schema_name":'public'
+            }
+    
+        }
+        cls.handler = VerticaHandler('test_vertica_handler', cls.kwargs)
+
+    def test_0_check_connection(self):
+        assert self.handler.check_connection()
+
+    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 
+
+    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 
+
+    def test_4_native_query_select(self):
+        query = "SELECT * FROM TEST;"
+        result = self.handler.query(query)
+        assert result.type is RESPONSE_TYPE.TABLE 
+
+    def test_5_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables.type is not RESPONSE_TYPE.TABLE
+
+    def test_6_get_columns(self):
+        columns = self.handler.get_columns('TEMP')
+        assert columns.type is not RESPONSE_TYPE.ERROR
+
+
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/vertica_handler/vertica_handler.py

@@ -0,0 +1,160 @@
+from typing import Optional
+
+import pandas as pd
+import vertica_python as vp
+
+from mindsdb_sql_parser import parse_sql
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb_sql_parser.ast.base import ASTNode
+
+from mindsdb.utilities import log
+from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE
+)
+
+# from sqlalchemy_vertica.dialect_pyodbc  import VerticaDialect
+from sqla_vertica_python.vertica_python import VerticaDialect
+
+logger = log.getLogger(__name__)
+
+
+class VerticaHandler(DatabaseHandler):
+    """
+    This handler handles connection and execution of the Vertica statements.
+    """
+
+    name = 'vertica'
+
+    def __init__(self, name, connection_data: Optional[dict], **kwargs):
+        super().__init__(name)
+        
+        self.parser = parse_sql
+        self.dialect = 'vertica'
+        self.kwargs = kwargs
+        self.connection_data = connection_data
+        self.schema_name = connection_data['schema_name'] if 'schema_name' in connection_data else "public"
+
+        self.connection = None
+        self.is_connected = False
+
+
+    def connect(self):
+        if self.is_connected is True:
+            return self.connection
+
+        config = {
+            'host': self.connection_data['host'],
+            'port': self.connection_data['port'],
+            'user': self.connection_data['user'],
+            'password': self.connection_data['password'],
+            'database': self.connection_data['database']
+        }
+
+        connection = vp.connect(**config)
+        self.is_connected = True
+        self.connection = connection
+        return self.connection
+
+    def disconnect(self):
+        if self.is_connected is False:
+            return
+        self.connection.close()
+        self.is_connected = False
+        return
+
+    def check_connection(self) -> StatusResponse:
+       
+        result = StatusResponse(False)
+        need_to_close = self.is_connected is False
+
+        try:
+            connection = self.connect()
+            result.success = connection.opened()
+        except Exception as e:
+            logger.error(f'Error connecting to Vertica {self.connection_data["database"]}, {e}!')
+            result.error_message = str(e)
+
+        if result.success is True and need_to_close:
+            self.disconnect()
+        if result.success is False and self.is_connected is True:
+            self.is_connected = False
+
+        return result
+
+    def native_query(self, query: str) -> Response:
+        """
+        Receive SQL query and runs it
+        :param query: The SQL query to run in VERTICA
+        :return: returns the records from the current recordset
+        """
+
+        need_to_close = self.is_connected is False
+
+        connection = self.connect()
+        with connection.cursor() as cur:
+            try:
+                e=cur.execute(query)
+                result = e.fetchall()
+                if e.rowcount != -1:
+                    
+                    response = Response(
+                        RESPONSE_TYPE.TABLE,
+                        pd.DataFrame(
+                            result,
+                            columns=[x.name for x in cur.description]
+                        )
+                    )
+                else:
+                    response = Response(RESPONSE_TYPE.OK)
+                connection.commit()
+            except Exception as e:
+                logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
+                response = Response(
+                    RESPONSE_TYPE.ERROR,
+                    error_message=str(e)
+                )
+                connection.rollback()
+
+        if need_to_close is True:
+            self.disconnect()
+
+        return response
+
+    def query(self, query: ASTNode) -> Response:
+        """
+        Retrieve the data from the SQL statement.
+        """
+        renderer = SqlalchemyRender(VerticaDialect)
+        query_str = renderer.get_string(query, with_failback=True)
+        return self.native_query(query_str)
+
+    def get_tables(self) -> Response:
+        """
+        Get a list with all of the tabels in VERTICA
+        """
+        q = f'''SELECT 
+        TABLE_NAME,
+        TABLE_SCHEMA
+        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 
+        WHERE table_name='{table_name}';'''
+
+        
+        return self.native_query(q)

mindsdb/integrations/handlers/vitess_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Vitess handler'
+__package_name__ = 'mindsdb_vitess_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Vitess"
+__author__ = 'Parthiv Makwana'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/vitess_handler/__init__.py

@@ -0,0 +1,20 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+try:
+    from .vitess_handler import VitessHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+from .__about__ import __version__ as version, __description__ as description
+
+
+title = 'Vitess'
+name = 'vitess'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description',
+    'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/vitess_handler/icon.svg

@@ -0,0 +1,23 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="37" viewBox="0 0 40 37" fill="none">
+  <g clip-path="url(#clip0_155_2380)">
+    <path d="M22.5609 22.8962L22.5646 22.877L23.8188 15.468L22.5609 22.8962ZM31.6203 15.4504L27.5497 22.8728L19.8544 36.937L19.8548 36.9376L27.5515 22.871L31.6222 15.4496L36.0693 7.31086L31.6203 15.4504ZM31.7594 0.89209L30.4528 3.30124L31.7601 0.89209H31.7594ZM7.24634 13.5766L12.2366 8.17314L7.24634 13.5766ZM8.3086 15.5335L13.8196 11.1167L8.3086 15.5335ZM8.3086 15.5335L7.93884 14.8534L8.30772 15.5335L12.2288 22.7954L12.8654 23.9799L12.2283 22.7939L8.3086 15.5335ZM9.6834 12.9574L12.2366 8.17314L13.8196 11.1167L16.8889 16.829L13.8213 11.1159L12.2371 8.17079L8.29108 0.89209H8.29019L12.2366 8.17314L9.6834 12.9574ZM21.17 24.7805L21.1881 24.8142L21.927 26.1846L21.17 24.7805Z" fill="#284E64"/>
+    <path d="M26.386 10.7751L23.8175 15.4663L20.9604 20.7744L23.8188 15.4679L26.386 10.7751Z" fill="#284E64"/>
+    <path d="M16.1453 30.0843L19.8538 36.9386L21.8947 26.3525L16.1453 30.0843Z" fill="#F16827"/>
+    <path d="M21.9271 26.1846L21.1882 24.8142L18.655 20.1156L16.1453 30.0843L21.8947 26.3525L21.9271 26.1846Z" fill="#F48029"/>
+    <path d="M12.2283 22.7939L12.8654 23.9799L16.1452 30.0843L18.6549 20.1156L12.2283 22.7939Z" fill="#F89A2E"/>
+    <path d="M12.2283 22.7937L18.6549 20.1155L16.8889 16.8288L13.8196 11.1166L12.2283 22.7937Z" fill="#F16827"/>
+    <path d="M22.561 22.8961L23.8189 15.4679L20.9605 20.7744L19.9858 22.5839L21.1701 24.7804L21.927 26.1845L22.561 22.8961Z" fill="#F89921"/>
+    <path d="M8.30872 15.5334L12.2284 22.7937L13.8197 11.1166L8.30872 15.5334Z" fill="#F89A2E"/>
+    <path d="M27.5497 22.8727L31.6203 15.4503L22.5646 22.8769L27.5497 22.8727Z" fill="#F48029"/>
+    <path d="M12.2367 8.1731L9.68352 12.9574L8.30872 15.5335L13.8197 11.1167L12.2367 8.1731ZM22.5647 22.877L27.7832 8.2211L26.3861 10.7752L23.8189 15.4679L22.5647 22.877Z" fill="#F4AE5C"/>
+    <path d="M8.30862 15.5335L9.68342 12.9574L12.2366 8.1731L7.24636 13.5765L7.24536 13.5776L7.93886 14.8534L8.30862 15.5335Z" fill="#CD4E27"/>
+    <path d="M31.6203 15.4503L27.7831 8.22106L22.5646 22.8769L31.6203 15.4503ZM7.24636 13.5765L12.2366 8.17305L8.29021 0.891998L8.28977 0.890991L7.24536 13.5776L7.24636 13.5765Z" fill="#F16938"/>
+    <path d="M31.6204 15.4503L31.7606 0.891998V0.890991L31.7601 0.891998L30.4529 3.30115L27.7831 8.22106L31.6204 15.4503ZM8.28983 0.890991H0.438965L7.24542 13.5776L8.28983 0.890991Z" fill="#F89A2E"/>
+    <path d="M31.7606 0.890991V0.891998L31.6204 15.4503L36.0694 7.31077L39.5784 0.890991H31.7606ZM22.5647 22.8769L22.561 22.8961L21.9271 26.1845L21.8947 26.3525L19.8538 36.9385L19.8545 36.937L27.5498 22.8727L22.5647 22.8769Z" fill="#CD4E27"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_155_2380">
+      <rect width="40" height="37" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/vitess_handler/requirements.txt

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