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

mindsdb/integrations/handlers/anyscale_endpoints_handler/anyscale_endpoints_handler.py

@@ -0,0 +1,290 @@
+import os
+import json
+import pandas as pd
+from typing import Text, Optional, Dict
+
+from mindsdb.integrations.utilities.handler_utils import get_api_key
+from mindsdb.integrations.libs.llm.utils import ft_jsonl_validation, ft_formatter
+from mindsdb.integrations.handlers.openai_handler.openai_handler import OpenAIHandler
+from mindsdb.integrations.handlers.anyscale_endpoints_handler.settings import anyscale_handler_config
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class AnyscaleEndpointsHandler(OpenAIHandler):
+    """
+    This handler handles connection and inference with the Anyscale Endpoints API.
+    """
+
+    name = 'anyscale_endpoints'
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.all_models = []
+        self.chat_completion_models = []
+        self.supported_ft_models = []
+        self.default_model = anyscale_handler_config.DEFAULT_MODEL
+        self.api_base = anyscale_handler_config.ANYSCALE_API_BASE
+        self.default_mode = anyscale_handler_config.DEFAULT_MODE
+        self.supported_modes = anyscale_handler_config.SUPPORTED_MODES
+        self.rate_limit = anyscale_handler_config.RATE_LIMIT
+        self.max_batch_size = anyscale_handler_config.MAX_BATCH_SIZE
+        self.default_max_tokens = anyscale_handler_config.DEFAULT_MAX_TOKENS
+
+    def create_engine(self, connection_args: Dict) -> None:
+        """
+        Validate the Anyscale Endpoints credentials on engine creation.
+
+        Args:
+            connection_args (Dict): Connection arguments.
+
+        Raises:
+            Exception: If the handler is not configured with valid API credentials.
+
+        Returns:
+            None
+        """
+
+        connection_args = {k.lower(): v for k, v in connection_args.items()}
+        api_key = connection_args.get('anyscale_endpoints_api_key')
+        if api_key is not None:
+            org = connection_args.get('api_organization')
+            api_base = connection_args.get('api_base') or os.environ.get('ANYSCALE_API_BASE', anyscale_handler_config.ANYSCALE_API_BASE)
+            client = self._get_client(api_key=api_key, base_url=api_base, org=org)
+            OpenAIHandler._check_client_connection(client)
+
+    @staticmethod
+    def create_validation(target: Text, args: Optional[Dict] = None, **kwargs: Optional[Dict]) -> None:
+        """
+        Validate the Anyscale Endpoints credentials on model creation.
+
+        Args:
+            target (Text): Target column, not required for LLMs.
+            args (Dict): Handler arguments.
+            kwargs (Dict): Handler keyword arguments.
+
+        Raises:
+            Exception: If the handler is not configured with valid API credentials.
+
+        Returns:
+            None
+        """
+
+        if 'using' not in args:
+            raise Exception(
+                "Anyscale Endpoints engine requires a USING clause! Refer to its documentation for more details."
+            )
+        else:
+            args = args['using']
+
+        engine_storage = kwargs['handler_storage']
+        connection_args = engine_storage.get_connection_args()
+        api_key = get_api_key('anyscale_endpoints', args, engine_storage=engine_storage)
+        api_base = connection_args.get('api_base') or args.get('api_base') or os.environ.get('ANYSCALE_API_BASE', anyscale_handler_config.ANYSCALE_API_BASE)
+
+        client = OpenAIHandler._get_client(api_key=api_key, base_url=api_base)
+        OpenAIHandler._check_client_connection(client)
+
+    def create(self, target: Text, args: Optional[Dict] = None, **kwargs: Optional[Dict]) -> None:
+        """
+        Create a model via an engine.
+
+        Args:
+            target (Text): Target column.
+            args (Dict): Model arguments.
+            kwargs (Dict): Other arguments.
+
+        Returns:
+            None
+        """
+
+        # Set the base and fine-tuned models and call the parent method
+        self._set_models_from_args(args)
+        super().create(target, args, **kwargs)
+
+    def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
+        """
+        Make a prediction using a model.
+
+        Args:
+            df (pd.DataFrame): Input data.
+            args (Dict): Handler arguments.
+
+        Returns:
+            pd.DataFrame: Predicted data
+        """
+
+        # Set the base and fine-tuned models and call the parent method
+        self._set_models_from_args(args)
+        return super().predict(df, args)
+
+    def finetune(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        """
+        Fine-tune a supported model.
+
+        Args:
+            df (pd.DataFrame): Input data.
+            args (Dict): Handler arguments.
+
+        Returns:
+            None
+        """
+
+        using_args = args.get('using', {})
+        self._set_models(using_args)
+        super().finetune(df, args)
+
+        # Rewrite chat_completion_models to include the newly fine-tuned model
+        args = self.model_storage.json_get('args')
+        args['chat_completion_models'] = list(self.chat_completion_models) + [args['model_name']]
+        self.model_storage.json_set('args', args)
+
+    def describe(self, attribute: Optional[Text] = None) -> pd.DataFrame:
+        """
+        Describe a model or its metadata.
+
+        Args:
+            attribute (Text): Attribute to describe.
+
+        Returns:
+            pd.DataFrame: Model or metadata description.
+        """
+
+        args = self.model_storage.json_get('args')
+
+        # Remove keys from args to display
+        for arg in ('api_key', 'openai_api_key'):
+            if arg in args:
+                del args[arg]
+
+        if attribute == 'args':
+            return pd.DataFrame(args.items(), columns=['key', 'value'])
+        elif attribute == 'metadata':
+            # The URL is used as some models require completing a form to access their artifacts
+            model_name = args.get('model_name', self.default_model)
+            model_card_url = 'https://huggingface.co/' + model_name
+            return pd.DataFrame({'model_name': [model_name], 'model_card': [model_card_url]})
+        else:
+            tables = ['args', 'metadata']
+            return pd.DataFrame(tables, columns=['tables'])
+
+    def _set_models(self, args: Dict) -> None:
+        """
+        Set the base and fine-tuned models.
+
+        Args:
+            args (Dict): Model arguments.
+
+        Returns:
+            None
+        """
+
+        api_key = get_api_key('anyscale_endpoints', args, self.engine_storage)
+        client = OpenAIHandler._get_client(api_key=api_key, base_url=self.api_base)
+        self.all_models = [m.id for m in client.models.list()]
+        self.chat_completion_models = [m.id for m in client.models.list() if m.rayllm_metadata['engine_config']['model_type'] == 'text-generation']  # noqa
+        # Set base models compatible with fine-tuning
+        self.supported_ft_models = self.chat_completion_models
+
+    def _set_models_from_args(self, args: Dict) -> None:
+        """
+        Set the base and fine-tuned models from the arguments, if specified. Otherwise, use the default list.
+
+        Args:
+            args (Dict): Model arguments.
+
+        Returns:
+            None
+        """
+
+        self._set_models(args.get('using', {}))
+
+        # Update the models if they are specified in the arguments
+        model_args = self.model_storage.json_get('args')
+        if model_args and 'chat_completion_models' in model_args:
+            self.chat_completion_models = model_args.get('chat_completion_models')
+
+    @staticmethod
+    def _prepare_ft_jsonl(df, temp_storage_path: Text, temp_filename: Text, _, test_size: Optional[float] = 0.2) -> Dict:
+        """
+        Prepare the data for fine-tuning.
+
+        Args:
+            df (pd.DataFrame): Input data.
+            temp_storage_path (Text): Temporary storage path.
+            temp_filename (Text): Temporary filename.
+            _: Unused.
+            test_size (float): Test size.
+
+        Returns:
+            dict: File names mapped to the prepared data.
+        """
+
+        # 1. Format data
+        chats = ft_formatter(df)
+
+        # 2. Split chats in training and validation subsets
+        series = pd.Series(chats)
+        if len(series) < anyscale_handler_config.MIN_FT_DATASET_LEN:
+            raise Exception(f"Dataset is too small to finetune. Please include at least {anyscale_handler_config.MIN_FT_DATASET_LEN} samples (complete chats).")
+        val_size = max(anyscale_handler_config.MIN_FT_VAL_LEN, int(len(series) * test_size))  # at least as many samples as required by Anyscale
+        train = series.iloc[:-val_size]
+        val = series.iloc[-val_size:]
+
+        # 3. Write as JSONL files
+        file_names = {
+            'train': f'{temp_filename}_prepared_train.jsonl',
+            'val': f'{temp_filename}_prepared_valid.jsonl',
+        }
+        train.to_json(os.path.join(temp_storage_path, file_names['train']), orient='records', lines=True)
+        val.to_json(os.path.join(temp_storage_path, file_names['val']), orient='records', lines=True)
+
+        # 4. Validate and return
+        with open(os.path.join(temp_storage_path, file_names['train']), 'r', encoding='utf-8') as f:
+            ft_jsonl_validation([json.loads(line) for line in f])
+
+        with open(os.path.join(temp_storage_path, file_names['val']), 'r', encoding='utf-8') as f:
+            ft_jsonl_validation([json.loads(line) for line in f])
+
+        return file_names
+
+    def _get_ft_model_type(self, model_name: Text) -> Text:
+        """
+        Get the fine-tuning model type.
+
+        Args:
+            model_name (Text): Model name.
+
+        Returns:
+            Text: Model type.
+        """
+
+        for base_model in self.chat_completion_models:
+            if base_model.lower() in model_name.lower():
+                return base_model
+        logger.warning(f'Cannot recognize model {model_name}. Finetuning may fail.')
+        return model_name.lower()
+
+    @staticmethod
+    def _add_extra_ft_params(ft_params: Dict, using_args: Dict) -> Dict:
+        """
+        Add extra fine-tuning parameters.
+
+        Args:
+            ft_params (Dict): Fine-tuning parameters.
+            using_args (Dict): Model arguments.
+
+        Returns:
+            Dict: Fine-tuning parameters with extra parameters.
+        """
+
+        hyperparameters = {}
+        # Populate separately because keys with `None` break the API
+        for key in ('n_epochs', 'context_length'):
+            if using_args.get(key, None):
+                hyperparameters[key] = using_args[key]
+        if hyperparameters:
+            return {**ft_params, **{'hyperparameters': hyperparameters}}
+        else:
+            return ft_params

mindsdb/integrations/handlers/anyscale_endpoints_handler/creation_args.py

@@ -0,0 +1,14 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+creation_args = OrderedDict(
+    anyscale_endpoints_api_key={
+        'type': ARG_TYPE.STR,
+        'description': 'Key for anyscale endpoints.',
+        'required': False,
+        'label': 'Anyscale endpoints API key',
+        'secret': True
+    }
+)

mindsdb/integrations/handlers/anyscale_endpoints_handler/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M13.3722 21.826H4.85157C2.13017 21.826 0 23.9511 0 26.6661V35.1627C0 37.8752 2.13017 40.0003 4.85157 40.0003H13.3722C16.0949 40.0003 18.2251 37.8752 18.2251 35.1627V26.6636C18.2251 23.9498 15.9756 21.826 13.3722 21.826ZM15.2664 35.0427C15.2664 36.1052 14.438 36.9302 13.3722 36.9302H4.85157C4.60193 36.9332 4.35421 36.8865 4.12301 36.7926C3.89181 36.6988 3.68182 36.5599 3.5054 36.3839C3.32898 36.208 3.18972 35.9987 3.09582 35.7684C3.00191 35.538 2.95527 35.2912 2.95864 35.0427V26.5474C2.95864 25.4849 3.78711 24.6598 4.85157 24.6598H13.3722C14.438 24.6598 15.2664 25.4849 15.2664 26.5474V35.0427Z" fill="#2055BE"/>
+  <path d="M35.2664 14.9855H25.0888V4.83765C24.9696 2.12507 22.8406 0 20.118 0H4.85157C2.13017 0 0 2.12507 0 4.83765V13.0979C0 15.8117 2.13017 17.9356 4.85157 17.9356H22.0109V35.0448C22.0109 37.7587 24.1423 39.8825 26.8637 39.8825H35.1484C37.8698 39.8825 40 37.7587 40 35.0448V19.8231C40 17.228 37.8698 15.1042 35.2664 14.9855ZM4.85157 14.9855C4.60193 14.9885 4.35421 14.9417 4.12301 14.8479C3.89181 14.7541 3.68182 14.6151 3.5054 14.4392C3.32898 14.2633 3.18972 14.054 3.09582 13.8236C3.00191 13.5933 2.95527 13.3465 2.95864 13.0979V4.83765C2.95864 3.77512 3.78711 2.95009 4.85157 2.95009H20.118C21.1837 2.95009 22.0122 3.77512 22.0122 4.83765V14.9855H4.85157ZM37.1594 35.0448C37.1594 36.1074 36.3309 36.9324 35.2664 36.9324H26.9817C26.7321 36.9354 26.4844 36.8886 26.2532 36.7948C26.022 36.701 25.812 36.562 25.6356 36.3861C25.4592 36.2102 25.3199 36.0009 25.226 35.7705C25.1321 35.5402 25.0854 35.2934 25.0888 35.0448V17.9356H35.2664C36.3309 17.9356 37.1594 18.7606 37.1594 19.8231V35.0448Z" fill="#2055BE"/>
+</svg>

mindsdb/integrations/handlers/anyscale_endpoints_handler/requirements.txt

@@ -0,0 +1,3 @@
+openai == 1.24.0
+pydantic-settings >= 2.1.0
+-r mindsdb/integrations/handlers/openai_handler/requirements.txt

mindsdb/integrations/handlers/anyscale_endpoints_handler/settings.py

@@ -0,0 +1,51 @@
+from typing import Text, List
+from pydantic_settings import BaseSettings
+
+
+class AnyscaleHandlerConfig(BaseSettings):
+    """
+    Configuration for the Anyscale handler.
+
+    Attributes
+    ----------
+
+    ANYSCALE_API_BASE : Text
+        Base URL for the Anyscale API.
+
+    MIN_FT_VAL_LEN : int
+        Minimum number of validation chats required for fine-tuning.
+
+    MIN_FT_DATASET_LEN : int
+        Minimum number of training and validation chats required for fine-tuning.
+
+    DEFAULT_MODEL : Text
+        Default model to use for models.
+
+    DEFAULT_MODE : Text
+        Default mode to use for models. Can be 'default', 'conversational', or 'conversational-full'.
+
+    SUPPORTED_MODES : List
+        List of supported modes. Can be 'default', 'conversational', or 'conversational-full'.
+
+    RATE_LIMIT : int
+        Number of requests per minute.
+
+    MAX_BATCH_SIZE : int
+        Maximum batch size for requests.
+
+    DEFAULT_MAX_TOKENS : int
+        Default maximum tokens for requests.
+    """
+
+    ANYSCALE_API_BASE: Text = 'https://api.endpoints.anyscale.com/v1'
+    MIN_FT_VAL_LEN: int = 20
+    MIN_FT_DATASET_LEN: int = MIN_FT_VAL_LEN * 2
+    DEFAULT_MODEL: Text = 'meta-llama/Llama-2-7b-chat-hf'
+    DEFAULT_MODE: Text = 'default'
+    SUPPORTED_MODES: List = ['default', 'conversational', 'conversational-full']
+    RATE_LIMIT: int = 25
+    MAX_BATCH_SIZE: int = 20
+    DEFAULT_MAX_TOKENS: int = 100
+
+
+anyscale_handler_config = AnyscaleHandlerConfig()

mindsdb/integrations/handlers/anyscale_endpoints_handler/tests/test_anyscale_endpoints_handler.py

@@ -0,0 +1,212 @@
+import os
+import pytest
+import pandas as pd
+from unittest.mock import patch
+
+from tests.unit.ml_handlers.base_ml_test import BaseMLAPITest
+
+
+@pytest.mark.skipif(os.environ.get('MDB_TEST_ANYSCALE_ENDPOINTS_API_KEY') is None, reason='Missing API key!')
+class TestAnyscaleEndpoints(BaseMLAPITest):
+    """
+    Integration tests for Anyscale Endpoints AI engine.
+    """
+
+    def setup_method(self):
+        """
+        Setup test environment by creating a project and a Anyscale Endpoints engine.
+        """
+
+        super().setup_method()
+        self.run_sql("CREATE DATABASE proj")
+        self.run_sql(
+            f"""
+            CREATE ML_ENGINE anyscale_endpoints_engine
+            FROM anyscale_endpoints
+            USING
+            anyscale_endpoints_api_key = '{self.get_api_key('MDB_TEST_ANYSCALE_ENDPOINTS_API_KEY')}';
+            """
+        )
+
+    def test_create_model_raises_exception_with_invalid_model_parameter(self):
+        """
+        Test for invalid parameter during model creation.
+        """
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_invalid_parameter_model
+            PREDICT answer
+            USING
+                engine='anyscale_endpoints_engine',
+                model_name='this-model-does-not-exist',
+                prompt_template='dummy_prompt_template';
+            """
+        )
+        with pytest.raises(Exception):
+            self.wait_predictor("proj", "test_anyscale_invalid_parameter_model")
+
+    # TODO: Uncomment this once the handler is updated to handle unknown arguments.
+    # def test_create_model_raises_exception_with_unknown_model_argument(self):
+    #     """
+    #     Test for unknown argument during model creation.
+    #     """
+
+    #     self.run_sql(
+    #         """
+    #         CREATE MODEL proj.test_anyscale_unknown_argument_model
+    #         PREDICT answer
+    #         USING
+    #             engine='anyscale_endpoints_engine',
+    #             prompt_template='dummy_prompt_template',
+    #             evidently_wrong_argument='wrong value';
+    #         """
+    #     )
+    #     with pytest.raises(Exception):
+    #         self.wait_predictor("proj", "test_anyscale_unknown_argument_model")
+
+    def test_create_model_raises_exception_with_invalid_operation_mode(self):
+        """
+        Test for invalid operation mode during model creation.
+        """
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_invalid_operation_mode
+            PREDICT answer
+            USING
+                engine='anyscale_endpoints_engine',
+                prompt_template='dummy_prompt_template',
+                mode='invalid_mode';
+            """
+        )
+        with pytest.raises(Exception):
+            self.wait_predictor("proj", "test_anyscale_invalid_operation_mode")
+
+    def test_select_runs_no_errors_on_completion_sentiment_analysis_single(self):
+        """
+        Test for a valid response to a sentiment analysis task (completion).
+        """
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_single_sa
+            PREDICT sentiment
+            USING
+                engine='anyscale_endpoints_engine',
+                model_name = 'mistralai/Mistral-7B-Instruct-v0.1',
+                prompt_template = 'Classify the sentiment of the following text as one of `positive`, `neutral` or `negative`: {{text}}';
+            """
+        )
+        self.wait_predictor("proj", "test_anyscale_single_sa")
+
+        result_df = self.run_sql(
+            """
+            SELECT sentiment
+            FROM proj.test_anyscale_single_sa
+            WHERE text = 'I love machine learning!';
+            """
+        )
+
+        assert "positive" in result_df["sentiment"].iloc[0].lower()
+
+    @patch("mindsdb.integrations.handlers.postgres_handler.Handler")
+    def test_select_runs_no_errors_on_completion_sentiment_analysis_bulk(self, mock_postgres_handler):
+        """
+        Test for valid reponses to bulk questions in a sentiment analysis task (completion).
+        """
+
+        df = pd.DataFrame.from_dict({"text": [
+            "I love machine learning!",
+            "I hate slow internet connections!"
+        ]})
+        self.set_handler(mock_postgres_handler, name="pg", tables={"df": df})
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_bulk_sa
+            PREDICT sentiment
+            USING
+                engine='anyscale_endpoints_engine',
+                model_name = 'mistralai/Mistral-7B-Instruct-v0.1',
+                prompt_template = 'Classify the sentiment of the following text as one of `positive`, `neutral` or `negative`: {{text}}';
+            """
+        )
+        self.wait_predictor("proj", "test_anyscale_bulk_sa")
+
+        result_df = self.run_sql(
+            """
+            SELECT p.sentiment
+            FROM pg.df as t
+            JOIN proj.test_anyscale_bulk_sa as p;
+        """
+        )
+
+        assert "positive" in result_df["sentiment"].iloc[0].lower()
+        assert "negative" in result_df["sentiment"].iloc[1].lower()
+
+    def test_select_runs_no_errors_on_chat_completion_question_answering_single(self):
+        """
+        Test for a valid response to a question answering task (chat completion).
+        """
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_single_qa
+            PREDICT answer
+            USING
+                engine='anyscale_endpoints_engine',
+                model_name = 'mistralai/Mistral-7B-Instruct-v0.1',
+                question_column='question';
+            """
+        )
+        self.wait_predictor("proj", "test_anyscale_single_qa")
+
+        result_df = self.run_sql(
+            """
+            SELECT answer
+            FROM proj.test_anyscale_single_qa
+            WHERE question = 'What is the capital of Sweden?';
+            """
+        )
+
+        assert "stockholm" in result_df["answer"].iloc[0].lower()
+
+    @patch("mindsdb.integrations.handlers.postgres_handler.Handler")
+    def test_select_runs_no_errors_on_chat_completion_question_answering_bulk(self, mock_postgres_handler):
+        """
+        Test for valid reponses to bulk questions in a question answering task (chat completion).
+        """
+
+        df = pd.DataFrame.from_dict({"question": [
+            "What is the capital of Sweden?",
+            "What is the second planet in the solar system?"
+        ]})
+        self.set_handler(mock_postgres_handler, name="pg", tables={"df": df})
+
+        self.run_sql(
+            """
+            CREATE MODEL proj.test_anyscale_bulk_qa
+            PREDICT answer
+            USING
+                engine='anyscale_endpoints_engine',
+                model_name = 'mistralai/Mistral-7B-Instruct-v0.1',
+                question_column='question';
+            """
+        )
+        self.wait_predictor("proj", "test_anyscale_bulk_qa")
+
+        result_df = self.run_sql(
+            """
+            SELECT p.answer
+            FROM pg.df as t
+            JOIN proj.test_anyscale_bulk_qa as p;
+        """
+        )
+
+        assert "stockholm" in result_df["answer"].iloc[0].lower()
+        assert "venus" in result_df["answer"].iloc[1].lower()
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])

mindsdb/integrations/handlers/apache_doris_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Apache Doris handler'
+__package_name__ = 'mindsdb_apache_doris_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Apache Doris"
+__author__ = 'Aditya Azad'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023- mindsdb'

mindsdb/integrations/handlers/apache_doris_handler/__init__.py

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

mindsdb/integrations/handlers/apache_doris_handler/apache_doris_handler.py

@@ -0,0 +1,10 @@
+from mindsdb.integrations.handlers.mysql_handler import Handler as MySQLHandler
+
+
+class ApacheDorisHandler(MySQLHandler):
+    """This handler handles connection and execution of the Apache Doris statements."""
+
+    name = 'apache_doris'
+
+    def __init__(self, name, **kwargs):
+        super().__init__(name, **kwargs)

mindsdb/integrations/handlers/apache_doris_handler/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M23.9804 6.12572L19.6161 1.76143C19.06 1.20377 18.3993 0.761187 17.672 0.458957C16.9447 0.156728 16.1649 0.000782551 15.3773 2.57491e-05C13.9247 -0.00438563 12.5276 0.55818 11.4834 1.56804C10.9381 2.09443 10.503 2.72407 10.2034 3.42028C9.90388 4.11648 9.74585 4.86533 9.73855 5.62321C9.73125 6.38111 9.87484 7.13287 10.1609 7.83471C10.447 8.53655 10.8699 9.17445 11.405 9.71124L19.3235 17.6297C19.4915 17.7889 19.714 17.8776 19.9455 17.8776C20.1768 17.8776 20.3995 17.7889 20.5675 17.6297L23.9752 14.2219C24.1895 13.9657 27.7541 9.89417 23.9804 6.12572Z" fill="#15A9CA"/>
+  <path d="M31.1304 13.0981C30.2993 12.2932 29.4369 11.4622 28.6583 10.5632V10.5318C28.6304 10.6136 28.6095 10.6975 28.5955 10.7827C28.2685 12.6931 27.3315 14.4462 25.9247 15.7795C21.3304 20.3424 16.6838 25.0045 12.1889 29.5152L11.5826 30.1163C10.656 30.9687 10.0307 32.0983 9.80025 33.336C9.70293 34.2183 9.79529 35.1112 10.0711 35.955C10.347 36.7987 10.7999 37.5737 11.3996 38.2281C11.9116 38.8089 12.5462 39.2687 13.2576 39.5741C13.969 39.8797 14.7394 40.0233 15.5131 39.9948C17.3058 40.0209 18.1787 39.7857 19.4853 38.5156C24.712 33.3987 29.9388 28.2399 33.8953 24.3199C35.7613 22.4644 36.1899 19.3911 34.8676 17.3213C33.7921 15.7716 32.5377 14.3541 31.1304 13.0981Z" fill="#52CAA3"/>
+  <path d="M5.83334 10.3646V29.6407C5.83325 29.8527 5.89604 30.06 6.01377 30.2363C6.1315 30.4125 6.29887 30.5499 6.49471 30.6311C6.69056 30.7121 6.90606 30.7333 7.11397 30.692C7.32188 30.6507 7.51284 30.5485 7.66268 30.3985L17.3635 20.6979C17.5467 20.5128 17.6494 20.2631 17.6494 20.0027C17.6494 19.7423 17.5467 19.4925 17.3635 19.3075L7.66268 9.60672C7.56525 9.50732 7.44896 9.42837 7.32061 9.37452C7.19226 9.32067 7.05445 9.293 6.91527 9.29312C6.63013 9.29311 6.3565 9.40566 6.1539 9.60631C5.95129 9.80695 5.83609 10.0795 5.83334 10.3646Z" fill="#5268AD"/>
+</svg>

mindsdb/integrations/handlers/apache_doris_handler/requirements.txt

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

mindsdb/integrations/handlers/aqicn_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB World Air Quality Index handler"
+__package_name__ = "mindsdb_aqicn_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for World Air Quality Index"
+__author__ = "Abhilash K R"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"

mindsdb/integrations/handlers/aqicn_handler/__init__.py

@@ -0,0 +1,28 @@
+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 .aqicn_handler import AQICNHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Air Quality Index API"
+name = "aqicn"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.png"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]