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

mindsdb/integrations/handlers/cockroach_handler/tests/test_cockroachdb_handler.py

@@ -0,0 +1,34 @@
+import unittest
+from mindsdb.integrations.handlers.cockroach_handler.cockroach_handler import CockroachHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class CockroachHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "connection_data": {
+                "host": "localhost",
+                "port": "5432",
+                "user": "mindsdb",
+                "password": "mindsdb",
+                "database": "postgres"
+            }
+        }
+        cls.handler = CockroachHandler('test_cockroach_handler', **cls.kwargs)
+
+    def test_0_check_connection(self):
+        assert self.handler.check_connection()
+
+    def test_1_describe_table(self):
+        described = self.handler.describe_table("test_mdb")
+        assert described['type'] is not RESPONSE_TYPE.ERROR
+
+    def test_2_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables['type'] is not RESPONSE_TYPE.ERROR
+
+    def test_4_select_query(self):
+        query = "SELECT * FROM data.test_mdb WHERE 'id'='1'"
+        result = self.handler.query(query)
+        assert result['type'] is RESPONSE_TYPE.TABLE

mindsdb/integrations/handlers/cohere_handler/__about__.py

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

mindsdb/integrations/handlers/cohere_handler/__init__.py

@@ -0,0 +1,21 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+from .__about__ import __version__ as version, __description__ as description
+try:
+    from .cohere_handler import CohereHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Cohere'
+name = 'cohere'
+type = HANDLER_TYPE.ML
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/cohere_handler/cohere_handler.py

@@ -0,0 +1,88 @@
+import os
+from typing import Optional, Dict
+
+import cohere
+import pandas as pd
+
+from mindsdb.utilities.config import Config
+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 CohereHandler(BaseMLEngine):
+    """
+    Integration with the Cohere Python Library
+    """
+    name = 'cohere'
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        if 'using' not in args:
+            raise Exception("Cohere 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}!")
+
+        input_column = args['using']['column']
+
+        if input_column not in df.columns:
+            raise RuntimeError(f'Column "{input_column}" not found in input data')
+        
+        result_df = pd.DataFrame() 
+
+        if args['using']['task'] == 'text-summarization':
+            result_df['predictions'] = df[input_column].apply(self.predict_text_summary)     
+
+        elif args['using']['task'] == 'text-generation':
+            result_df['predictions'] = df[input_column].apply(self.predict_text_generation)
+      
+        else:
+            raise Exception(f"Task {args['using']['task']} is not supported!")
+
+        result_df = result_df.rename(columns={'predictions': args['target']})
+        
+        return result_df
+
+
+    def predict_text_summary(self,text):
+        """ 
+        connects with cohere api to predict the summary of the input text
+
+        """ 
+
+        args = self.model_storage.json_get('args')
+
+        api_key = get_api_key('cohere', args["using"], self.engine_storage, strict=False)
+        co = cohere.Client(api_key)
+
+        response = co.summarize(text)
+        text_summary = response.summary
+
+        return text_summary
+
+    def predict_text_generation(self,text):
+        """    
+        connects with cohere api to predict the next prompt of the input text
+
+        """
+        args = self.model_storage.json_get('args')
+
+        api_key = get_api_key('cohere', args["using"], self.engine_storage, strict=False)
+        co = cohere.Client(api_key)
+
+        response = co.generate(text)
+        text_generated = response.generations[0].text
+
+        return text_generated

mindsdb/integrations/handlers/cohere_handler/icon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <g clip-path="url(#clip0_173_183)">
+    <path fill-rule="evenodd" clip-rule="evenodd" d="M12.9594 23.8162C14.036 23.8162 16.1776 23.7572 19.1379 22.5384C22.5876 21.1181 29.4508 18.5398 34.4019 15.8915C37.8645 14.0392 39.3823 11.5895 39.3823 8.29045C39.3823 3.71179 35.6706 0 31.092 0H11.9081C5.33143 0 0 5.33143 0 11.9081C0 18.4848 4.99179 23.8162 12.9594 23.8162Z" fill="#39594D"/>
+    <path fill-rule="evenodd" clip-rule="evenodd" d="M16.2035 32.0167C16.2035 28.7929 18.1442 25.8863 21.1217 24.6505L27.1632 22.1432C33.274 19.6071 40.0001 24.0978 40.0001 30.7143C40.0001 35.8402 35.8439 39.9952 30.7178 39.9938L24.1768 39.9922C19.7729 39.991 16.2035 36.4207 16.2035 32.0167Z" fill="#D18EE2"/>
+    <path d="M6.86468 25.3861C3.07348 25.3861 0 28.4593 0 32.2506V33.1398C0 36.9308 3.07336 40.0042 6.86456 40.0042C10.6558 40.0042 13.7292 36.9308 13.7292 33.1398V32.2506C13.7292 28.4593 10.6559 25.3861 6.86468 25.3861Z" fill="#FF7759"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_173_183">
+      <rect width="40" height="40" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/cohere_handler/requirements.txt

@@ -0,0 +1 @@
+cohere==4.5.1

mindsdb/integrations/handlers/coinbase_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB CoinBase handler'
+__package_name__ = 'mindsdb_coinbase_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for the CoinBase API"
+__author__ = 'Bustedware LLC'
+__github__ = 'https://github.com/bustedware'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023 - mindsdb'

mindsdb/integrations/handlers/coinbase_handler/__init__.py

@@ -0,0 +1,21 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .connection_args import connection_args, connection_args_example
+try:
+    from .coinbase_handler import CoinBaseHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+from .__about__ import __version__ as version, __description__ as description
+
+
+title = 'Coinbase'
+name = 'coinbase'
+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/coinbase_handler/coinbase_handler.py

@@ -0,0 +1,138 @@
+import time
+import hmac
+import base64
+import hashlib
+import datetime
+from typing import Dict
+
+import pandas as pd
+import requests
+
+from mindsdb.integrations.handlers.coinbase_handler.coinbase_tables import CoinBaseAggregatedTradesTable
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+)
+
+from mindsdb_sql_parser import parse_sql
+
+_BASE_COINBASE_US_URL = 'https://api.exchange.coinbase.com'
+
+
+class CoinBaseHandler(APIHandler):
+    """A class for handling connections and interactions with the CoinBase API.
+
+    Attributes:
+        api_key (str): API key
+        api_secret (str): API secret
+        is_connected (bool): Whether or not the API client is connected to CoinBase.
+
+    """
+
+    def __init__(self, name: str = None, **kwargs):
+        """Registers all API tables and prepares the handler for an API connection.
+
+        Args:
+            name: (str): The handler name to use
+        """
+        super().__init__(name)
+        self.api_key = None
+        self.api_secret = None
+        self.api_passphrase = None
+
+        args = kwargs.get('connection_data', {})
+        if 'api_key' in args:
+            self.api_key = args['api_key']
+        if 'api_secret' in args:
+            self.api_secret = args['api_secret']
+        if 'api_passphrase' in args:
+            self.api_passphrase = args['api_passphrase']
+        self.client = None
+        self.is_connected = False
+
+        coinbase_candle_data = CoinBaseAggregatedTradesTable(self)
+        self._register_table('coinbase_candle_data', coinbase_candle_data)
+
+    def connect(self):
+        """Creates a new CoinBase API client if needed and sets it as the client to use for requests.
+
+        Returns newly created CoinBase API client, or current client if already set.
+        """
+        self.is_connected = True
+        return self.client
+
+    def check_connection(self) -> StatusResponse:
+        """Checks connection to CoinBase API by sending a ping request.
+
+        Returns StatusResponse indicating whether or not the handler is connected.
+        """
+        response = StatusResponse(True)
+        self.is_connected = response.success
+        return response
+
+    # symbol: BTC-USD
+    # granularity 60, 300, 900, 3600, 21600, 86400
+    def get_coinbase_candle(self, symbol: str, granularity: int) -> pd.DataFrame:
+        jdocs = []
+        current_time = datetime.datetime.now()
+        start_time = current_time - datetime.timedelta(seconds=granularity)
+        start_time_iso = start_time.isoformat().split(".")[0] + "-04:00"
+        path = "/products/" + symbol + "/candles?granularity=" + str(granularity) + "&start=" + start_time_iso
+        headers = self.generate_api_headers("GET", path)
+        url = _BASE_COINBASE_US_URL + path
+        response = requests.get(url, headers=headers)
+        candles = response.json()
+        for candle in candles:
+            dt = datetime.datetime.fromtimestamp(candle[0], None).isoformat()
+            low, high, open, close, volume = candle[1:]
+            jdoc = {"symbol": symbol, "low": low, "high": high, "open": open, "close": close, "volume": volume, "timestamp": candle[0], "timestamp_iso": dt}
+            jdocs.append(jdoc)
+        return pd.DataFrame(jdocs)
+
+    def _get_candle(self, params: Dict = None) -> pd.DataFrame:
+        """Gets aggregate trade data for a symbol based on given parameters
+
+        Returns results as a pandas DataFrame.
+
+        Args:
+            params (Dict): Trade data params (symbol, interval)
+        """
+        if 'symbol' not in params:
+            raise ValueError('Missing "symbol" param to fetch trade data for.')
+        if 'interval' not in params:
+            raise ValueError('Missing "interval" param (60, 300, 900, 3600, 21600, 86400).')
+
+        candle = self.get_coinbase_candle(params['symbol'], int(params['interval']))
+        return candle
+
+    def native_query(self, query: str = None) -> Response:
+        ast = parse_sql(query)
+        return self.query(ast)
+
+    def generate_api_headers(self, method: str, path: str) -> dict:
+        timestamp = str(int(time.time()))
+        message = timestamp + method + path
+        signature = base64.b64encode(hmac.new(base64.b64decode(self.api_secret), str.encode(message), hashlib.sha256).digest())
+        headers = {
+            "Content-Type": "application/json",
+            "CB-ACCESS-SIGN": signature,
+            "CB-ACCESS-KEY": self.api_key,
+            "CB-ACCESS-TIMESTAMP": timestamp,
+            "CB-VERSION": "2015-04-08",
+            "CB-ACCESS-PASSPHRASE": self.api_passphrase
+        }
+        return headers
+
+    def call_coinbase_api(self, method_name: str = None, params: Dict = None) -> pd.DataFrame:
+        """Calls the CoinBase API method with the given params.
+
+        Returns results as a pandas DataFrame.
+
+        Args:
+            method_name (str): Method name to call
+            params (Dict): Params to pass to the API call
+        """
+        if method_name == 'get_candle':
+            return self._get_candle(params)
+        raise NotImplementedError('Method name {} not supported by CoinBase API Handler'.format(method_name))

mindsdb/integrations/handlers/coinbase_handler/coinbase_tables.py

@@ -0,0 +1,56 @@
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb_sql_parser import ast
+
+import pandas as pd
+
+
+class CoinBaseAggregatedTradesTable(APITable):
+
+    DEFAULT_INTERVAL = 60
+    DEFAULT_SYMBOL = 'BTC-USD'
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Selects data from the CoinBase API and returns it as a pandas DataFrame.
+
+        Returns dataframe representing the CoinBase API results.
+
+        Args:
+            query (ast.Select): Given SQL SELECT query
+        """
+        conditions = extract_comparison_conditions(query.where)
+
+        params = {
+            'interval': CoinBaseAggregatedTradesTable.DEFAULT_INTERVAL,
+            'symbol': CoinBaseAggregatedTradesTable.DEFAULT_SYMBOL,
+        }
+        for op, arg1, arg2 in conditions:
+            if arg1 == 'interval':
+                if op != '=':
+                    raise NotImplementedError
+                params['interval'] = arg2
+
+            elif arg1 == 'symbol':
+                if op != '=':
+                    raise NotImplementedError
+                params['symbol'] = arg2
+
+        coinbase_candle_data = self.handler.call_coinbase_api(
+            method_name='get_candle',
+            params=params
+        )
+
+        return coinbase_candle_data
+
+    def get_columns(self):
+        """Gets all columns to be returned in pandas DataFrame responses"""
+        return [
+            'symbol',
+            'low',
+            'high',
+            'open',
+            'close',
+            'volume',
+            'timestamp',
+            'current_time'
+        ]

mindsdb/integrations/handlers/coinbase_handler/connection_args.py

@@ -0,0 +1,34 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    api_key={
+        'type': ARG_TYPE.STR,
+        'description': 'API Key For Connecting to CoinBase API.',
+        'required': True,
+        'label': 'API Key',
+        'secret': True
+    },
+    api_secret={
+        'type': ARG_TYPE.PWD,
+        'description': 'API Secret For Connecting to CoinBase API.',
+        'required': True,
+        'label': 'API Secret',
+        'secret': True
+    },
+    api_passphrase={
+        'type': ARG_TYPE.PWD,
+        'description': 'API Passphrase.',
+        'required': True,
+        'label': 'API Passphrase',
+        'secret': True
+    },
+)
+
+connection_args_example = OrderedDict(
+    api_key='public_key',
+    api_secret='secret_key',
+    api_passphrase='passphrase'
+)

mindsdb/integrations/handlers/coinbase_handler/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M17.4424 0.112214C17.4424 0.173932 17.2908 0.224428 17.1057 0.224428C16.6639 0.224428 14.7114 0.689893 13.5807 1.0648C11.5554 1.73629 8.85508 3.2495 7.20061 4.63995C2.44249 8.63881 -0.264033 14.7365 0.020387 20.8167C0.461176 30.2408 6.99063 37.8714 16.2163 39.7441C17.3469 39.9736 17.8091 40.0038 20.1288 39.9997C22.5818 39.9953 22.849 39.9744 24.0904 39.6896C27.8919 38.8174 30.9615 37.2151 33.7209 34.6625C36.5464 32.0488 38.7475 28.1167 39.5563 24.2383C40.6667 18.9134 39.6805 13.6038 36.7388 9.06792C34.3704 5.41579 30.5196 2.419 26.4529 1.06312C25.4028 0.713009 23.3406 0.226897 22.8991 0.225438C22.7299 0.224877 22.5913 0.173932 22.5913 0.112214C22.5913 0.0406215 21.6586 0 20.0168 0C18.3751 0 17.4424 0.0406215 17.4424 0.112214ZM18.4498 6.01311C13.0737 6.64218 8.43164 10.3681 6.71807 15.4295C6.13513 17.1514 5.99152 18.0535 5.98548 20.0302C5.98145 21.3424 6.03338 22.0755 6.17834 22.7535C6.90724 26.163 8.6357 28.9865 11.304 31.1269C15.0079 34.0977 20.1808 34.9373 24.795 33.3164C27.8411 32.2463 30.6607 29.8451 32.3114 26.915C33.0918 25.5299 33.7892 23.4067 33.9595 21.898L34.0372 21.2085H30.5153H26.9934L26.7993 21.9084C26.4668 23.107 25.8749 24.1006 24.9312 25.0442C23.729 26.2462 22.5476 26.8167 20.7828 27.0474C18.0295 27.4074 15.1373 25.8748 13.8239 23.3596C13.2014 22.1678 13.0286 21.4382 13.0351 20.0302C13.04 18.9807 13.0882 18.6555 13.3573 17.8587C14.7015 13.8789 19.1331 11.9177 22.8938 13.6384C23.8578 14.0795 24.3693 14.4416 25.0861 15.1909C25.931 16.074 26.5347 17.1677 26.8434 18.3751L26.9653 18.852H30.4869H34.0084V18.6083C34.0084 18.4742 33.9279 17.9341 33.8296 17.408C32.968 12.7979 29.6562 8.75136 25.3058 6.99263C23.6834 6.33685 22.2989 6.05542 20.4646 6.00873C19.5719 5.98595 18.6653 5.98797 18.4498 6.01311Z" fill="#0854F5"/>
+</svg>

mindsdb/integrations/handlers/confluence_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Confluence handler"
+__package_name__ = "mindsdb_confluence_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Confluence"
+__author__ = "Balaji Seetharaman"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"

mindsdb/integrations/handlers/confluence_handler/__init__.py

@@ -0,0 +1,29 @@
+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 .confluence_handler import ConfluenceHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Confluence"
+name = "confluence"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]

mindsdb/integrations/handlers/confluence_handler/confluence_handler.py

@@ -0,0 +1,102 @@
+from typing import Optional, Union
+
+import requests
+from atlassian import Confluence
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.integrations.handlers.confluence_handler.confluence_table import (
+    ConfluencePagesTable,
+)
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+)
+from mindsdb_sql_parser import parse_sql
+from mindsdb.utilities import log
+
+from atlassian import Confluence
+from typing import Optional
+import requests
+
+logger = log.getLogger(__name__)
+
+class ConfluenceHandler(APIHandler):
+    """Confluence handler implementation"""
+
+    def __init__(self, name=None, **kwargs):
+        """Initialize the Confluence handler.
+        Parameters
+        ----------
+        name : str
+            name of a handler instance
+        """
+        super().__init__(name)
+
+        connection_data = kwargs.get("connection_data", {})
+
+        self.parser = parse_sql
+        self.dialect = 'confluence'
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+        self.connection = None
+        self.is_connected = False
+
+        confluence_pages_data = ConfluencePagesTable(self)
+        self._register_table("pages", confluence_pages_data)
+
+    def connect(self):
+        """Set up the connection required by the handler.
+        Returns
+        -------
+        StatusResponse
+            connection object
+        """
+        if self.is_connected is True:
+            return self.connection
+        
+        if not all(key in self.connection_data and self.connection_data.get(key) for key in ['url', 'username', 'password']):
+            raise ValueError('Required parameters (url, username, password) must be provided and should not be empty.')
+        
+        conf = Confluence(
+            url=self.connection_data.get('url'),
+            username=self.connection_data.get('username'),
+            password=self.connection_data.get('password'),
+        )
+        self.connection = conf
+        self.is_connected = True
+        return self.connection
+
+    def check_connection(self) -> StatusResponse:
+        """Check connection to the handler.
+        Returns
+        -------
+        StatusResponse
+            Status confirmation
+        """
+        response = StatusResponse(False)
+        need_to_close = self.is_connected is False
+
+        try:
+            self.connect()
+            response.success = True
+        except Exception as e:
+            logger.error(f"Error connecting to Confluence API: {e}!")
+            response.error_message = e
+
+        self.is_connected = response.success
+
+        return response
+
+    def native_query(self, query: str) -> StatusResponse:
+        """Receive and process a raw query.
+        Parameters
+        ----------
+        query : str
+            query in a native format
+        Returns
+        -------
+        StatusResponse
+            Request status
+        """
+        ast = parse_sql(query)
+        return self.query(ast)