MindsDB 1.3.1__py3-none-any.whl → 25.1.2.0__py3-none-any.whl

mindsdb/integrations/handlers/tidb_handler/tests/test_tidb_handler.py

@@ -0,0 +1,45 @@
+import unittest
+import pandas as pd
+from mindsdb.integrations.handlers.tidb_handler.tidb_handler import TiDBHandler
+
+
+class TiDBHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "host": "localhost",
+            "port": "4000",
+            "user": "root",
+            "password": "root",
+            "database": "test",
+            "ssl": False
+        }
+        cls.handler = TiDBHandler('test_tidb_handler', **cls.kwargs)
+
+    def test_0_connect(self):
+        self.handler.connect()
+
+    def test_1_check_connection(self):
+        assert self.handler.check_connection()
+
+    def test_2_native_query_show_dbs(self):
+        dbs = self.handler.native_query("SHOW DATABASES;")
+        assert isinstance(dbs, list)
+
+    def test_3_get_tables(self):
+        tbls = self.handler.get_tables()
+        assert isinstance(tbls, list)
+
+    def test_5_create_table(self):
+        try:
+            self.handler.native_query("CREATE TABLE test_tidb (test_col INT)")
+        except Exception:
+            pass
+
+    def test_6_describe_table(self):
+        described = self.handler.get_columns("dt_test")
+        assert isinstance(described, list)
+
+    def test_7_select_query(self):
+        query = "SELECT * FROM dt_test WHERE 'id'='a'"
+        result = self.handler.native_query(query)

mindsdb/integrations/handlers/tidb_handler/tidb_handler.py

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

mindsdb/integrations/handlers/timegpt_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Nixtla handler"
+__package_name__ = "mindsdb_nixtla_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Nixtla's `nixtla` package, wrapper for the TimeGPT API"
+__author__ = "MindsDB Inc"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - MindsDB Inc."

mindsdb/integrations/handlers/timegpt_handler/__init__.py

@@ -0,0 +1,18 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+
+try:
+    from .timegpt_handler import TimeGPTHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "TimeGPT"
+name = "timegpt"
+type = HANDLER_TYPE.ML
+icon_path = "icon.svg"
+permanent = False
+
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]

mindsdb/integrations/handlers/timegpt_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="M32.7177 20.4584L29.7126 23.431L36.3823 30.0288L39.3873 27.0561L32.7177 20.4584Z" fill="black"/>
+  <path d="M24.0548 20.6361L20.1254 24.5213L16.1677 20.6046L13.1641 23.5776L20.1254 30.4639L27.0584 23.6074L24.0548 20.6361Z" fill="black"/>
+  <path d="M39.3862 11.4101L36.3826 8.43884L28.4743 16.2619L20.0952 7.97485L11.7479 16.2321L3.83966 8.40908L0.834229 11.3821L8.74252 19.2052L0.834229 27.0282L3.83966 29.9995L20.0952 13.9174L28.4743 22.2062L39.3862 11.4101Z" fill="black"/>
+</svg>

mindsdb/integrations/handlers/timegpt_handler/requirements.txt

@@ -0,0 +1 @@
+nixtla==0.5.0

mindsdb/integrations/handlers/timegpt_handler/timegpt_handler.py

@@ -0,0 +1,205 @@
+from typing import Optional, Dict
+
+import pandas as pd
+from nixtla import NixtlaClient
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.integrations.utilities.handler_utils import get_api_key
+from mindsdb.integrations.utilities.time_series_utils import get_results_from_nixtla_df
+# TODO: add E2E tests.
+
+
+class TimeGPTHandler(BaseMLEngine):
+    """
+    Integration with the Nixtla TimeGPT models for
+    zero-shot time series forecasting.
+    """
+
+    name = "timegpt"
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        """
+        Create the TimeGPT Handler.
+        Requires specifying the target column and usual time series arguments. Saves model config for later usage.
+        """
+        self.generative = True
+        time_settings = args.get("timeseries_settings", {})
+        using_args = args["using"]
+
+        mode = 'forecasting'
+        if args.get('__mdb_sql_task', False) and args['__mdb_sql_task'].lower() in ('forecasting', 'anomalydetection'):
+            mode = args['__mdb_sql_task'].lower()
+
+        if mode == 'forecasting':
+            assert time_settings["is_timeseries"], "Specify time series settings in your query"
+
+        timegpt_token =  get_api_key('timegpt', using_args, self.engine_storage, strict=True)
+        timegpt = NixtlaClient(api_key=timegpt_token)
+        assert timegpt.validate_api_key(), "Invalid TimeGPT token provided."
+
+        model_args = {
+            'token': timegpt_token,
+            "target": target,
+            "freq": using_args.get("frequency", None),
+            "finetune_steps": using_args.get("finetune_steps", 0),
+            "validate_token": using_args.get("validate_token", False),
+            "date_features": using_args.get("date_features", False),
+            "date_features_to_one_hot": using_args.get("date_features_to_one_hot", True),
+            "clean_ex_first": using_args.get("clean_ex_first", True),
+            "level": using_args.get("level", [90]),
+            "add_history": using_args.get("add_history", False),
+            'mode': mode,
+        }
+
+        if time_settings:
+            model_args["horizon"] = time_settings["horizon"]
+            model_args["order_by"] = time_settings["order_by"]
+            model_args["group_by"] = time_settings.get("group_by", [])
+
+        if mode == 'anomalydetection':
+            model_args["target"] = using_args['target'] if target is None else target
+            model_args["horizon"] = using_args.get('horizon', 1)
+            model_args["order_by"] = using_args['order_by']
+            model_args["group_by"] = using_args.get("group_by", [])
+            model_args['add_history'] = True
+
+        assert isinstance(model_args["level"], list), "`level` must be a list of integers"
+        assert all([isinstance(l, int) for l in model_args["level"]]), "`level` must be a list of integers"
+
+        self.model_storage.json_set("model_args", model_args)  # persist changes to handler folder
+
+    def predict(self, df, args={}):
+        """ Makes forecasts with the TimeGPT API. """
+        model_args = self.model_storage.json_get("model_args")
+        args = args['predict_params']
+        prediction_df = self._transform_to_nixtla_df(df, model_args)
+        
+        timegpt = NixtlaClient(api_key=model_args['token'])
+        assert timegpt.validate_api_key(), "Invalid TimeGPT token provided."
+
+        forecast_df = timegpt.forecast(
+            prediction_df,
+
+            # TODO: supporting param override when JOINing with a WHERE clause is blocked by mindsdb_sql#285
+            h=args.get("horizon", model_args.get("horizon", 1)),
+            freq=args.get("freq", model_args["freq"]),  # automatically infers correct frequency if not provided by user
+            level=model_args["level"],
+            finetune_steps=args.get('finetune_steps', model_args['finetune_steps']),
+            validate_api_key=args.get('validate_token', model_args['validate_token']),
+            date_features=args.get('date_features', model_args['date_features']),
+            date_features_to_one_hot=args.get('date_features_to_one_hot', model_args['date_features_to_one_hot']),
+            clean_ex_first=args.get('clean_ex_first', model_args['clean_ex_first']),
+
+            # anomaly detection
+            add_history=args.get('add_history', model_args['add_history'])  # insample bounds and anomaly detection
+
+            # TODO: enable this post-refactor (#6861)
+            # X_df=None,  # exogenous variables
+        )
+        if model_args['mode'] == 'forecasting':
+            results_df = forecast_df[['unique_id', 'ds', 'TimeGPT']]
+            results_df = get_results_from_nixtla_df(results_df, model_args)
+        elif model_args['mode'] == 'anomalydetection':
+            forecast_df['ds'] = pd.to_datetime(forecast_df['ds'])
+            results_df = forecast_df.merge(prediction_df, how='inner')  # some rows drop because of TimeGPT's cold start
+            results_df['anomaly'] = (results_df['y'] > results_df[f'TimeGPT-hi-{model_args["level"][0]}']) | (results_df['y'] < results_df[f'TimeGPT-lo-{model_args["level"][0]}'])
+
+            forecast_df = results_df  # rewrite forecast_df so that we can reuse code below for prediction intervals
+            results_df = get_results_from_nixtla_df(results_df, model_args)
+            results_df = results_df.rename({'y': f'observed_{model_args["target"]}'}, axis=1)
+        else:
+            raise Exception(f'Unsupported prediction mode: {model_args["mode"]}')
+
+        # infer date
+        ds_col = model_args["order_by"]
+        if not pd.api.types.is_datetime64_any_dtype(results_df[ds_col]):
+            results_df[ds_col] = pd.to_datetime(results_df[ds_col])
+
+        results_df = results_df.rename({'TimeGPT': model_args['target']}, axis=1)
+
+        # add prediction intervals
+        levels = sorted(model_args['level'], reverse=True)
+        for i, level in enumerate(levels):
+            if i == 0:
+                # NOTE: this should be simplified once we refactor the expected time series output within MindsDB
+                results_df['confidence'] = level/100  # we report the highest level as the overall confidence
+                results_df['lower'] = forecast_df[f'TimeGPT-lo-{level}']
+                results_df['upper'] = forecast_df[f'TimeGPT-hi-{level}']
+            else:
+                results_df[f'lower_{level}'] = forecast_df[f'TimeGPT-lo-{level}']
+                results_df[f'upper_{level}'] = forecast_df[f'TimeGPT-hi-{level}']
+
+        return results_df
+
+    def describe(self, attribute=None):
+        model_args = self.model_storage.json_get("model_args")
+
+        if attribute == "model":
+            df = pd.DataFrame({"frequency": [model_args["freq"] if model_args["freq"] else "automatic"]})
+            return df
+
+        elif attribute == "features":
+            df = pd.DataFrame({
+                "order by": [model_args["order_by"]],
+                "target": model_args["target"]
+            })
+            if model_args["group_by"]:
+                df["group by"] = [model_args["group_by"]]
+            return df
+
+        elif attribute == 'info':
+            outputs = model_args["target"]
+            inputs = [model_args["target"], model_args["order_by"]]
+            if model_args["group_by"]:
+                inputs.append(model_args["group_by"])
+            return pd.DataFrame({"output": outputs, "input": [inputs]})
+
+        else:
+            tables = ['info', 'features', 'model']
+            return pd.DataFrame(tables, columns=['tables'])
+
+    # TODO: consolidate this method with the ones in time_series_utils.py
+    @staticmethod
+    def _convert_to_iso(df, date_column):
+        # whether values in date_column are numeric (Unix timestamp) or string (date)
+        if pd.api.types.is_numeric_dtype(df[date_column]):
+            unit = ''
+            # ascending unit order
+            for u in ['ns', 'us', 'ms', 's']:
+                mindate = pd.to_datetime(df[date_column].min(), unit=u, origin='unix')
+                maxdate = pd.to_datetime(df[date_column].max(), unit=u, origin='unix')
+                if mindate > pd.to_datetime('1970-01-01T00:00:00') and maxdate < pd.to_datetime('2050-12-31T23:59:59'):
+                    unit = u
+            df[date_column] = pd.to_datetime(df[date_column], unit=unit, origin='unix')
+        else: 
+            df[date_column] = pd.to_datetime(df[date_column])
+        df[date_column] = df[date_column].dt.strftime('%Y-%m-%dT%H:%M:%S')  # convert to ISO 8601 format
+        df[date_column] = pd.to_datetime(df[date_column])
+        return df
+
+    # TODO: consolidate this method with the ones in time_series_utils.py
+    def _transform_to_nixtla_df(self, df, settings_dict, exog_vars=[]):
+        nixtla_df = df.copy()
+        # Transform group columns into single unique_id column
+        gby = settings_dict["group_by"]
+        if len(gby) > 1:
+            for col in gby:
+                nixtla_df[col] = nixtla_df[col].astype(str)
+            nixtla_df["unique_id"] = nixtla_df[gby].agg("/".join, axis=1)
+            group_col = "ignore this"
+        elif len(gby) == 1 and gby[0] is not None:
+            group_col = settings_dict["group_by"][0]
+        else:
+            group_col = '__unique_id'
+            nixtla_df[group_col] = '1'
+
+        # Rename columns to statsforecast names
+        nixtla_df = nixtla_df.rename(
+            {settings_dict["target"]: "y", settings_dict["order_by"]: "ds", group_col: "unique_id"}, axis=1
+        )
+
+        columns_to_keep = ["unique_id", "ds", "y"] + exog_vars
+        nixtla_df = self._convert_to_iso(nixtla_df, "ds")
+        nixtla_df = nixtla_df[columns_to_keep].sort_values(by=['unique_id', 'ds'], ascending=True)  # expects ascending
+        nixtla_df['y'] = nixtla_df['y'].astype(float)
+        return nixtla_df.reset_index(drop=True)

mindsdb/integrations/handlers/timescaledb_handler/__about__.py

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

mindsdb/integrations/handlers/timescaledb_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 .timescaledb_handler import PostgresHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'TimescaleDB'
+name = 'timescaledb'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title',
+    'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/timescaledb_handler/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M19.9265 39.0476C30.4185 39.0476 38.9227 30.52 38.9227 20C38.9227 9.48001 30.4185 0.952393 19.9274 0.952393C9.43343 0.952393 0.930176 9.48001 0.930176 20C0.930176 30.52 9.43529 39.0476 19.9265 39.0476Z" fill="#FFF6E2"/>
+  <path d="M19.9275 32.7448C26.9591 32.7448 32.6596 27.0267 32.6596 19.9733C32.6596 12.92 26.9591 7.2019 19.9275 7.2019C12.8949 7.2019 7.19446 12.92 7.19446 19.9733C7.19446 27.0267 12.8949 32.7448 19.9275 32.7448Z" fill="#FDB515"/>
+  <path d="M28.3535 18.7181C29.1191 16.8505 28.5619 14.8514 27.1089 14.2524C25.6558 13.6543 23.8577 14.6838 23.093 16.5514C22.3275 18.419 22.8847 20.4181 24.3377 21.0171C25.7898 21.6152 27.5879 20.5867 28.3535 18.7181ZM19.9572 35.8048C21.974 35.8048 23.6084 34.0305 23.6084 31.8419C23.6084 29.6524 21.974 27.8781 19.9572 27.8781C17.9405 27.8781 16.3061 29.6524 16.3061 31.8419C16.3061 34.0305 17.9405 35.8048 19.9572 35.8048ZM15.64 21.0152C17.093 20.4162 17.6493 18.4171 16.8847 16.5486C16.1191 14.6819 14.3209 13.6514 12.8679 14.2505C11.4158 14.8486 10.8586 16.8486 11.6233 18.7162C12.3889 20.5838 14.187 21.6133 15.64 21.0143V21.0152Z" fill="white"/>
+  <path d="M26.4 32.26C30.3386 30.1429 33.134 26.1572 33.6 21.4819L35.8047 24.0219C34.5758 29.0353 31.0437 33.1457 26.4037 35.16C26.4484 34.76 26.4707 34.3105 26.4707 33.7981C26.4669 33.2847 26.443 32.7715 26.3991 32.26H26.4ZM15.4856 33.1677C16.8744 33.6391 18.3563 33.8915 19.9042 33.8915C21.5191 33.8915 23.0633 33.6162 24.5051 33.1048C24.2028 34.3105 23.733 35.3648 23.134 36.1924C22.0921 36.4019 21.013 36.5124 19.9089 36.5124C18.8707 36.5124 17.8595 36.4143 16.8744 36.2324C16.267 35.4096 15.7916 34.3591 15.4856 33.1677ZM13.4856 32.3C9.48374 30.1829 6.64839 26.1438 6.20094 21.4057L4.04932 24.2124C5.32653 29.1724 8.86234 33.221 13.4847 35.2C13.4409 34.7905 13.4186 34.3286 13.4186 33.8029C13.4186 33.2962 13.4409 32.7934 13.4847 32.3H13.4856ZM30.9554 11.86L32.5172 9.61813C31.401 8.26963 30.0833 7.11053 28.613 6.18384L25.9777 7.70098C27.9348 8.66487 29.6407 10.0902 30.9554 11.86ZM11.374 6.0686C9.83559 7.01019 8.45931 8.20493 7.30048 9.60479L9.06234 11.5838C10.3562 9.93128 11.9967 8.59803 13.8623 7.68289L11.373 6.0686H11.374ZM10.8456 19.9867C10.8456 15.8496 13.6 12.3581 17.3712 11.2505C17.5395 10.7743 17.7526 10.36 17.9926 10.0219C13.3256 10.9257 9.80281 15.0448 9.80281 19.9867C9.80281 23.4876 11.5684 26.5743 14.2568 28.3981C14.3768 28.0515 14.5051 27.7172 14.6475 27.3934C12.3451 25.7429 10.8456 23.0381 10.8456 19.9867Z" fill="#141E35"/>
+  <path d="M12.6326 16.9438L13.4001 17.1438C14.1005 15.5319 15.3539 14.2389 16.9229 13.5095C16.9452 13.2029 16.9759 12.9 17.0252 12.6114C16.0479 12.9976 15.1559 13.5799 14.4016 14.3241C13.6473 15.0682 13.0458 15.9592 12.6326 16.9448V16.9438ZM12.9089 21.1124H12.1191C12.2708 22.1422 12.6201 23.1311 13.147 24.0219C13.6739 24.9128 14.3679 25.688 15.1889 26.3029C15.3229 26.0724 15.4596 25.8495 15.6066 25.6362C14.1719 24.5402 13.2056 22.9197 12.9089 21.1124ZM26.4652 17.1714L27.2289 16.9705C26.3154 14.7419 24.4159 13.02 22.0736 12.3581C22.1312 12.6333 22.1805 12.9229 22.2159 13.2248C24.1322 13.8743 25.6764 15.32 26.4661 17.1705L26.4652 17.1714ZM27.828 18.9905L27.0029 18.1362L24.2922 18.5714L23.8754 19.8219L25.1219 20.6581L27.4103 19.8219L27.8289 18.9905H27.828ZM12.1368 18.9905L12.9573 18.1362L15.6726 18.5714L16.0847 19.8219L14.8382 20.6581L12.5536 19.8219L12.1368 18.9905ZM27.4419 22.3838C27.5741 21.9691 27.6725 21.5438 27.7359 21.1124H26.9452C26.9061 21.3571 26.8522 21.5924 26.7908 21.8286C27.0215 22.0152 27.2382 22.1971 27.4419 22.3838ZM24.9396 25.0267C24.7359 25.2267 24.5229 25.4229 24.2977 25.5962C24.4429 25.8095 24.5861 26.0324 24.7182 26.2629C25.0682 25.9929 25.3961 25.6941 25.6987 25.3695C25.4427 25.2629 25.1899 25.1486 24.9405 25.0267H24.9396Z" fill="#141E35"/>
+  <path d="M29.0084 19.9867C29.0075 21.1379 28.7906 22.2783 28.3693 23.3457C28.6754 23.7105 28.9061 24.0619 29.0577 24.3771C29.7151 23.0115 30.0564 21.5091 30.0549 19.9867C30.0549 14.7467 26.0977 10.4362 21.0131 9.89428C21.267 10.2095 21.4931 10.6009 21.6791 11.0505C25.854 11.8695 29.0084 15.5562 29.0084 19.9867ZM26.9275 25.7829C26.4408 26.3728 25.8846 26.8987 25.2717 27.3486C25.414 27.6686 25.5479 28.0067 25.6624 28.3543C26.6079 27.7005 27.4391 26.8881 28.121 25.9514C27.7178 25.9473 27.3167 25.8906 26.9275 25.7829ZM20.7963 18.7457C20.787 18.7457 20.7824 18.7409 20.7777 18.7362L19.9265 9.8219H19.1321L18.4047 18.799H18.4093C18.4093 18.8171 18.4047 18.8343 18.4047 18.8524C18.4093 19.0038 18.4233 19.1457 18.4493 19.2838C18.4624 19.4352 18.507 19.5905 18.5777 19.7467C18.7284 20.1371 18.9731 20.4324 19.2614 20.5695C19.3275 20.6229 19.3982 20.6714 19.4698 20.7209C19.4828 20.7305 19.5005 20.7381 19.5135 20.7476V20.7514L28.3507 25.6228L28.8121 24.9781L20.7963 18.7457ZM21.9228 30.9476C21.2354 30.9476 20.654 30.4762 20.4856 29.84L23.7554 28.5857L22.974 26.6371L19.9265 27.8733L16.8754 26.6409L16.0986 28.5857L19.3368 29.8667C19.2372 30.2031 19.0268 30.4939 18.7413 30.6893C18.4558 30.8846 18.1129 30.9726 17.7712 30.9381L17.1098 31.8686C17.3582 31.9524 17.6242 31.9971 17.9042 31.9971C18.7247 31.9971 19.4521 31.6057 19.9135 30.9971C20.2459 31.4325 20.7047 31.7485 21.2239 31.8995C21.743 32.0504 22.2956 32.0286 22.8019 31.8371L22.1535 30.9295C22.0773 30.9423 22.0001 30.9484 21.9228 30.9476Z" fill="#141E35"/>
+  <path d="M30.0996 12.2905L29.0391 13.5C30.3763 15.3805 31.0956 17.6472 31.0931 19.9733C31.0931 23.9228 29.0521 27.3971 25.9693 29.3905C26.107 29.9143 26.2177 30.4619 26.3024 31.0266C30.0996 28.8171 32.6549 24.6933 32.6549 19.9733C32.6642 17.0905 31.7061 14.4305 30.0996 12.2905ZM8.76097 19.9743C8.76097 17.5676 9.51911 15.339 10.8103 13.5105L9.74981 12.3009C8.09143 14.498 7.19262 17.1967 7.19446 19.9733C7.19446 24.7247 9.78051 28.8705 13.6224 31.0686C13.707 30.5028 13.814 29.9562 13.9517 29.4352C10.8279 27.4466 8.76097 23.9552 8.76097 19.9743ZM19.9266 7.20188C17.9703 7.20188 16.1163 7.64664 14.4614 8.43426L15.2428 9.80474C16.7137 9.12156 18.3105 8.76919 19.9256 8.77141C21.5945 8.77141 23.1777 9.14093 24.6019 9.79998L25.3833 8.42855C23.6727 7.61863 21.8103 7.19973 19.9256 7.20093L19.9266 7.20188Z" fill="#141E35"/>
+</svg>

mindsdb/integrations/handlers/timescaledb_handler/tests/test_timescaledb_handler.py

@@ -0,0 +1,47 @@
+import unittest
+from mindsdb.integrations.handlers.timescaledb_handler.timescaledb_handler import TimeScaleDBHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class TimeScaleDBHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "host": "localhost",
+            "port": 36806,
+            "user": "USERNAME",
+            "password": "P455W0rd",
+            "database": "tsdb"
+        }
+        cls.handler = TimeScaleDBHandler('test_timescaledb_handler', connection_data=cls.kwargs)
+
+    def test_0_connect(self):
+        self.handler.connect()
+
+    def test_1_drop_table(self):
+        res = self.handler.query("DROP TABLE IF EXISTS LOVE;")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_2_create_table(self):
+        res = self.handler.query("CREATE TABLE IF NOT EXISTS LOVE (LOVER varchar(20));")
+        assert res.type is not RESPONSE_TYPE.ERROR
+    
+    def test_3_insert(self):
+        res = self.handler.query("INSERT INTO LOVE VALUES('Hari');")
+        assert res.type is not RESPONSE_TYPE.ERROR
+    
+    def test_4_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables.type is RESPONSE_TYPE.TABLE
+
+    def test_5_select_query(self):
+        query = "SELECT * FROM LOVE;"
+        result = self.handler.native_query(query)
+        assert result.type is RESPONSE_TYPE.TABLE
+
+    def test_5_check_connection(self):
+        self.handler.check_connection()
+
+        
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/timescaledb_handler/timescaledb_handler.py

@@ -0,0 +1,46 @@
+from mindsdb.integrations.handlers.postgres_handler import Handler as PostgresHandler
+from collections import OrderedDict
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+class TimeScaleDBHandler(PostgresHandler):
+    name = 'timescaledb'
+
+    def __init__(self, name, **kwargs):
+        super().__init__(name, **kwargs)
+
+
+
+
+connection_args = OrderedDict(
+    host={
+        'type': ARG_TYPE.STR,
+        'description': 'The host name or IP address of the TimeScaleDB server/database.'
+    },
+    database={
+        'type': ARG_TYPE.STR,
+        'description': """
+            The database name to use when connecting with the TimeScaleDB server.
+        """
+    },
+    user={
+        'type': ARG_TYPE.STR,
+        'description': 'The user name used to authenticate with the TimeScaleDB server.'
+    },
+    password={
+        'type': ARG_TYPE.STR,
+        'description': 'The password to authenticate the user with the TimeScaleDB server.'
+    },
+    port={
+        'type': ARG_TYPE.INT,
+        'description': 'Specify port to connect TimeScaleDB '
+    }
+)
+
+connection_args_example = OrderedDict(
+    host='127.0.0.1',
+    port=36806,
+    password='P455W0rD',
+    user='tsdbadmin',
+    database="tsdb"
+)

mindsdb/integrations/handlers/tpot_handler/__about__.py

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

mindsdb/integrations/handlers/tpot_handler/__init__.py

@@ -0,0 +1,19 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from mindsdb.integrations.handlers.tpot_handler.__about__ import __version__ as version, __description__ as description
+try:
+    from .tpot_handler import TPOTHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'TPOT'
+name = 'TPOT'
+type = HANDLER_TYPE.ML
+icon_path = 'icon.png'
+permanent = False
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/tpot_handler/requirements.txt

@@ -0,0 +1,2 @@
+tpot<=0.11.7
+type_infer==0.0.20

mindsdb/integrations/handlers/tpot_handler/tpot_handler.py

@@ -0,0 +1,80 @@
+from typing import Optional
+import dill
+import pandas as pd
+from mindsdb.integrations.libs.base import BaseMLEngine
+from typing import Dict, Optional
+from type_infer.api import infer_types
+from tpot import TPOTClassifier, TPOTRegressor
+from sklearn.preprocessing import LabelEncoder
+
+
+class TPOTHandler(BaseMLEngine):
+    name = "TPOT"
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        if args is None:
+            args = {}
+        type_of_cols=infer_types(df,0).dtypes
+        target_dtype=type_of_cols[target]
+
+
+        if target_dtype in ['binary','categorical','tags']:
+            model = TPOTClassifier(generations=args.get('generations', 10),
+                                       population_size=args.get('population_size', 100),
+                                       verbosity=0,
+                                       max_time_mins=args.get('max_time_mins', None),
+                                       n_jobs=args.get('n_jobs', -1))
+            
+
+        elif target_dtype in ['integer','float','quantity'] :
+            model = TPOTRegressor(generations=args.get('generations', 10),
+                                      population_size=args.get('population_size', 100),
+                                      verbosity=0,
+                                      max_time_mins=args.get('max_time_mins', None),
+                                      n_jobs=args.get('n_jobs', -1))
+        
+
+        if df is not None:
+            # Separate out the categorical and non-categorical columns
+            categorical_cols=[col for col, type_col in type_of_cols.items() if type_col in ('categorical', 'binary')]
+
+            # Fit a LabelEncoder for each categorical column and store it in a dictionary
+            le_dict = {}
+            for col in categorical_cols:
+                le = LabelEncoder()
+                le.fit(df[col])
+                le_dict[col] = le
+
+                # Encode the categorical column using the fitted LabelEncoder
+                df[col] = le.transform(df[col])
+
+
+            model.fit(df.drop(columns=[target]), df[target])
+            self.model_storage.json_set('args', args)
+            self.model_storage.file_set('le_dict', dill.dumps(le_dict))
+            self.model_storage.file_set('model', dill.dumps(model.fitted_pipeline_))
+        else :
+            raise Exception(
+                "Data is empty!!"
+            )
+        
+
+    def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
+
+        model=dill.loads(self.model_storage.file_get("model"))
+        le_dict=dill.loads(self.model_storage.file_get("le_dict"))
+        target=self.model_storage.json_get('args').get("target")
+
+         # Encode the categorical columns in the input DataFrame using the saved LabelEncoders
+        for col, le in le_dict.items():
+            if col in df.columns:
+                df[col] = le.transform(df[col])
+                
+        # Make predictions using the trained TPOT model
+        results=pd.DataFrame(model.predict(df),columns=[target])
+
+        # Decode the predicted categorical values back into their original values
+        for col, le in le_dict.items():
+            if col in results.columns:
+                results[col] = le.inverse_transform(results[col])
+
+        return results

mindsdb/integrations/handlers/trino_handler/__about__.py

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

mindsdb/integrations/handlers/trino_handler/__init__.py

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

mindsdb/integrations/handlers/trino_handler/icon.svg

@@ -0,0 +1,23 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M30.3397 19.5193C30.3397 18.5193 29.527 17.6988 28.5365 17.6988C27.546 17.6988 26.7333 18.5193 26.7333 19.5193C26.7587 20.2372 27.2159 20.8526 27.8762 21.0577V23.827C27.0889 21.8013 25.6413 20.1347 23.7365 19.0834C24.0159 18.468 24.2952 17.9552 24.5492 17.4936C25.5651 15.9552 26.7079 14.4936 27.927 13.1347C28.6127 12.3142 29.2476 11.5706 29.7556 10.9039C31.2032 9.05774 32.8286 6.3398 32.5238 4.69877C32.4476 4.23723 32.1683 3.82698 31.7873 3.59621C29.7556 2.39108 27.0127 6.31415 24.2952 10.109C22.4921 12.5962 21.5778 16.1347 21.146 18.1347C20.3079 17.9552 19.4698 17.8526 18.6064 17.8526C17.3619 17.8526 16.1429 18.0577 14.9746 18.468C14.8984 16.2629 14.9746 14.0321 15.1778 11.827C15.7873 6.08339 15.5079 2.72441 14.4159 1.57057C14.1365 1.21159 13.7048 1.0321 13.2476 1.0321C10.0222 1.16031 10.4032 11.0065 10.454 12.1347C10.581 14.827 11.6476 18.109 12.3079 19.9039C10.8095 21.109 9.69206 22.7501 9.15873 24.6218H8.93016C7.91429 24.5706 7.0254 25.3654 7 26.4167V26.4424V29.5706C7.05079 30.6218 7.91429 31.4167 8.93016 31.3911H9.33651C9.79365 32.4424 10.454 33.4167 11.2921 34.186L10.6825 34.7244C10.4032 34.9808 10.3524 35.4167 10.6064 35.7244C12.4095 37.9295 15.3302 39.1859 18.6317 39.1859C21.9333 39.1859 24.8794 37.9295 26.6571 35.7244C26.9111 35.4167 26.8603 34.9808 26.581 34.7244L25.9714 34.186C26.8095 33.3911 27.4952 32.4167 27.927 31.3398H28.3841C29.4254 31.3911 30.2889 30.5706 30.3397 29.5449V26.4424C30.3143 25.7244 29.8571 25.0834 29.1968 24.827V21.0834C29.8571 20.8526 30.3397 20.2372 30.3397 19.5193Z" fill="#CDCCCC"/>
+  <path d="M15.7111 34.6731C16.2698 34.3141 14.8222 34.4423 14.6952 34.1859C14.1111 34.1346 13.5524 34.032 12.9936 33.8782C11.9778 33.5961 9.53966 31.9551 9.28569 30.3654C9.03172 28.7756 9.28569 25.7756 10.3778 23.9551C11.0635 22.8526 11.9524 21.8782 12.9936 21.109C12.9936 21.109 10.8603 15.9808 10.6825 12.109C10.5047 8.23717 10.8095 1.33974 13.2984 1.23717C15.7873 1.13461 15.4317 7.57051 15 11.75C14.746 14.5449 14.7206 17.3397 14.873 20.1346C15.9397 19.8013 17.0571 19.5961 18.1492 19.5705C19.1397 19.5449 20.1047 19.6474 21.0698 19.8526C21.0698 19.8526 21.8571 13.9038 24.473 10.1859C27.0889 6.46794 29.8571 2.67307 31.6603 3.74999C33.4635 4.82692 31.1778 8.69871 29.5778 10.6987C28.0032 12.6987 25.2603 15.7244 24.346 17.3397C23.7365 18.4167 23.2285 19.5192 22.7714 20.6731C24.3968 21.5192 25.7428 22.8526 26.5809 24.4936C27.8762 27.0833 27.9778 30.2885 27.2666 31.6474C26.5555 32.9295 25.3365 33.8013 23.9143 34.0577C23.127 34.0833 19.7746 34.9295 19.7746 34.9295L15.7111 34.6731Z" fill="white"/>
+  <path d="M21.5779 19.9296C21.5779 19.9296 23.5842 14.6732 25.362 11.7245C27.1398 8.77576 29.5525 6.54499 30.289 6.98088C31.0509 7.44242 28.7398 10.186 26.7334 12.904C25.108 15.2886 23.6096 17.8014 22.289 20.3655L21.5779 19.9296Z" fill="#DD00A1"/>
+  <path d="M13.5525 20.827L14.162 20.3911C14.162 20.3911 14.0858 15.1347 14.162 11.9295C14.2382 8.72441 14.416 4.75006 13.3493 4.7757C12.2826 4.80134 11.5461 7.9039 11.9779 12.2372C12.2572 15.1347 12.7906 18.0065 13.5525 20.827Z" fill="#DD00A1"/>
+  <path d="M11.7746 32.1091C12.4198 32.1091 12.9428 31.581 12.9428 30.9296C12.9428 30.2782 12.4198 29.7501 11.7746 29.7501C11.1294 29.7501 10.6063 30.2782 10.6063 30.9296C10.6063 31.581 11.1294 32.1091 11.7746 32.1091Z" fill="#F9D8D2"/>
+  <path d="M25.4889 32.1091C26.1341 32.1091 26.6572 31.581 26.6572 30.9296C26.6572 30.2782 26.1341 29.7501 25.4889 29.7501C24.8437 29.7501 24.3207 30.2782 24.3207 30.9296C24.3207 31.581 24.8437 32.1091 25.4889 32.1091Z" fill="#F9D8D2"/>
+  <path d="M20.5618 30.8271C20.511 30.8014 20.4348 30.8014 20.4094 30.8527C20.4094 30.8527 20.0539 31.4681 19.5714 31.4937C19.2158 31.4937 18.911 31.3399 18.6825 31.0835V30.186C19.0126 30.0065 19.5206 29.4681 19.5206 29.2629C19.419 28.8527 19.038 28.5706 18.6317 28.5963C18.0221 28.5963 17.6158 28.9809 17.6158 29.3142C17.6158 29.6476 18.2761 30.0578 18.4539 30.186V31.0578C18.2507 31.3142 17.9714 31.4424 17.6666 31.4681C17.184 31.4681 16.8285 30.8271 16.8285 30.8014C16.8031 30.7501 16.7269 30.7245 16.6761 30.7501C16.6253 30.7758 16.5999 30.8527 16.6253 30.904C16.6253 30.904 17.0571 31.6732 17.6666 31.6732C18.0221 31.6476 18.3523 31.4937 18.5809 31.2373C18.8348 31.4937 19.165 31.6476 19.5206 31.6732H19.5967C20.0285 31.5963 20.4094 31.3142 20.6126 30.904C20.6126 30.9296 20.6126 30.8527 20.5618 30.8271Z" fill="#10110E"/>
+  <path d="M12.9936 21.1346C12.9936 21.1346 11.3429 16.9038 11.0127 14.6987C10.6825 12.4935 10.4032 8.80123 10.8349 6.33969C11.0127 5.21148 11.2667 4.08328 11.5714 2.98071C11.5714 2.98071 10.8095 8.69866 11.0889 11.2115C11.3682 13.7243 12.9936 21.1346 12.9936 21.1346Z" fill="#E5E5E5"/>
+  <path d="M21.0953 19.8527C21.0953 19.8527 22.289 13.468 24.0414 10.9552C25.7937 8.44241 27.9525 5.39112 29.0445 4.62189L30.1366 3.85266C30.1366 3.85266 25.743 8.49369 24.0414 12.3142C22.3398 16.1091 21.0953 19.8527 21.0953 19.8527Z" fill="#E5E5E5"/>
+  <path d="M14.162 27.1091C13.654 27.1091 13.2477 27.5193 13.2477 28.0321C13.2477 28.545 13.654 28.9552 14.162 28.9552C14.6699 28.9552 15.0763 28.545 15.0763 28.0321C15.0509 27.5193 14.6445 27.1091 14.162 27.1091ZM14.4159 27.9552C14.289 27.9552 14.162 27.8527 14.162 27.6988C14.162 27.5706 14.2636 27.4424 14.4159 27.4424C14.5429 27.4424 14.6699 27.545 14.6699 27.6988C14.6445 27.8527 14.5429 27.9552 14.4159 27.9552C14.4159 27.9552 14.3905 27.9552 14.4159 27.9552Z" fill="#10110E"/>
+  <path d="M23.0763 27.1091C22.5683 27.1091 22.162 27.5193 22.162 28.0321C22.162 28.545 22.5683 28.9552 23.0763 28.9552C23.5842 28.9552 23.9906 28.545 23.9906 28.0321C23.9906 27.5193 23.5842 27.1091 23.0763 27.1091ZM23.3302 27.9552C23.2033 27.9552 23.0763 27.8527 23.0763 27.6988C23.1017 27.5706 23.2287 27.468 23.3556 27.4937C23.4572 27.5193 23.5588 27.5963 23.5588 27.6988C23.5842 27.8527 23.4572 27.9552 23.3302 27.9552Z" fill="#10110E"/>
+  <path opacity="0.2" d="M18.7842 34.4937C23.4409 34.4937 27.2159 31.75 27.2159 28.3655C27.2159 24.9809 23.4409 22.2372 18.7842 22.2372C14.1274 22.2372 10.3524 24.9809 10.3524 28.3655C10.3524 31.75 14.1274 34.4937 18.7842 34.4937Z" fill="#8ACCCE"/>
+  <path d="M28.9936 24.9553V20.9297C29.6285 20.7758 30.1111 20.2117 30.1365 19.545C30.0349 18.6732 29.273 18.0322 28.3841 18.1348C27.6476 18.2117 27.0634 18.8015 26.9873 19.545C27.0126 20.2117 27.4952 20.7758 28.1301 20.9297V24.8527H28.0285C26.8349 20.6732 23.3047 18.0579 18.6825 18.0579C14.0603 18.0579 10.5047 20.6476 9.33646 24.8527H8.93011C8.01582 24.8015 7.25392 25.4938 7.20312 26.4168V29.545C7.25392 30.4425 8.01582 31.1348 8.93011 31.1091H9.46344C9.92059 32.2886 10.6571 33.3399 11.6222 34.1861L10.8349 34.8784C10.6317 35.0579 10.6063 35.3399 10.7841 35.545C12.5365 37.6732 15.4063 38.9297 18.6317 38.9297C21.8825 38.9297 24.7269 37.7245 26.4793 35.545C26.6571 35.3399 26.6317 35.0322 26.4285 34.8784L25.6412 34.1861C26.5809 33.3399 27.3174 32.2886 27.8 31.1091H28.4095C29.2984 31.1604 30.0857 30.4681 30.1365 29.545V26.4168C30.1111 25.7245 29.6285 25.1348 28.9936 24.9553ZM18.6571 22.5194C22.9238 22.5194 26.4031 25.3656 26.4031 28.8527C26.4031 32.622 22.492 34.2886 18.6571 34.2886C14.8222 34.2886 10.9111 32.5963 10.9111 28.8527C10.9365 25.3399 14.3904 22.5194 18.6571 22.5194Z" fill="white"/>
+  <path d="M29.2732 28.4936H28.1303C28.1303 28.3141 28.1303 28.1346 28.1303 27.9295C28.1303 27.1603 28.0541 26.391 27.9017 25.6474H28.3843C28.8414 25.6218 29.2224 25.9551 29.2478 26.4167V26.4423L29.2732 28.4936Z" fill="#515151"/>
+  <path d="M28.4094 30.3141H27.7999C27.9015 29.8782 28.0031 29.4423 28.0539 29.0064H29.2475V29.5192C29.2221 29.9551 28.8666 30.3141 28.4094 30.2885C28.4348 30.3141 28.4094 30.3141 28.4094 30.3141Z" fill="#515151"/>
+  <path d="M18.6571 38.1346C15.7873 38.1346 13.2476 37.0833 11.6222 35.2372L12.4349 34.5192C14.2635 35.75 16.4476 36.391 18.6571 36.3397C20.8666 36.391 23.0254 35.7756 24.8793 34.5192L25.692 35.2372C24.092 37.0833 21.527 38.1346 18.6571 38.1346Z" fill="#515151"/>
+  <path d="M8.93026 25.6476H9.43819C9.28581 26.3912 9.20962 27.1604 9.20962 27.9296C9.18423 28.1091 9.18423 28.3143 9.20962 28.4937H8.09216V26.4168C8.09216 25.9809 8.42232 25.6476 8.85407 25.6219C8.85407 25.6219 8.90486 25.6219 8.93026 25.6476Z" fill="#515151"/>
+  <path d="M18.6571 22.0064C17.692 22.0064 16.7269 22.1603 15.7872 22.4167V19.2628C16.7269 19.0064 17.692 18.8526 18.6571 18.8782C19.6222 18.8782 20.5872 19.0064 21.5269 19.2628V22.4423C20.6126 22.1346 19.6475 22.0064 18.6571 22.0064Z" fill="black"/>
+  <path d="M15.2286 19.4423V22.6218C12.3588 23.6731 10.3524 26.0833 10.3524 28.8269C10.3524 32.391 13.7048 34.8013 18.6572 34.8013C23.6096 34.8013 26.962 32.391 26.962 28.8269C26.962 26.0833 24.9556 23.6731 22.0858 22.6218V19.4423C25.4382 20.6474 27.5207 23.7757 27.5207 27.9551C27.5207 32.6474 23.9651 35.8013 18.6318 35.8013C13.2985 35.8013 9.74292 32.6474 9.74292 27.9551C9.79371 23.7757 11.8763 20.6731 15.2286 19.4423Z" fill="#515151"/>
+  <path d="M8.06678 29.0321H9.26043C9.31122 29.468 9.41281 29.9039 9.5144 30.3398H8.90487C8.44773 30.3654 8.06678 30.0321 8.04138 29.5706V29.5449L8.06678 29.0321Z" fill="#515151"/>
+  <path d="M28.5618 20.1602C28.9546 20.1602 29.2729 19.8732 29.2729 19.5192C29.2729 19.1652 28.9546 18.8782 28.5618 18.8782C28.1691 18.8782 27.8507 19.1652 27.8507 19.5192C27.8507 19.8732 28.1691 20.1602 28.5618 20.1602Z" fill="#515151"/>
+</svg>

mindsdb/integrations/handlers/trino_handler/requirements.txt

@@ -0,0 +1,2 @@
+trino~=0.313.0
+pyhive