MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/integrations/handlers/anyscale_endpoints_handler/anyscale_endpoints_handler.py

@@ -1,290 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,4 +0,0 @@
-<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

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

mindsdb/integrations/handlers/anyscale_endpoints_handler/settings.py

@@ -1,51 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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__])