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

mindsdb/integrations/handlers/derby_handler/derby_handler.py

@@ -0,0 +1,203 @@
+from typing import Optional
+from mindsdb_sql_parser.ast.base import ASTNode
+from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.utilities import log
+from mindsdb_sql_parser import parse_sql
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE
+)
+import pandas as pd
+import jaydebeapi as jdbcconnector
+
+logger = log.getLogger(__name__)
+
+class DerbyHandler(DatabaseHandler):
+
+
+    name= 'derby'
+
+
+    def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
+        """ Initialize the handler
+        Args:
+            name (str): name of particular handler instance
+            connection_data (dict): parameters for connecting to the database
+            **kwargs: arbitrary keyword arguments.
+        """
+        super().__init__(name)
+        
+        self.kwargs = kwargs
+        self.parser = parse_sql
+        self.database = connection_data['database']
+        self.connection_config = connection_data
+        self.host = connection_data['host']
+        self.port = connection_data['port']
+        self.schema =  'APP'
+        self.connection = None
+        self.is_connected = False
+          
+    
+    def connect(self):
+        """ Set up any connections required by the handler
+        Should return output of check_connection() method after attempting
+        connection. Should switch self.is_connected.
+        Returns:
+            Connection Object
+        """
+        if self.is_connected is True:
+            return self.connection
+
+        user = self.connection_config.get('user')
+        password = self.connection_config.get('password')
+        jdbc_class = self.connection_config.get('jdbcClass')
+        jar_location = self.connection_config.get('jdbcJarLocation')
+
+        jdbc_url = "jdbc:derby://" + self.host + ":" + self.port + "/" + self.database + ";"
+
+        if not jdbc_class: 
+            jdbc_class = "org.apache.derby.jdbc.ClientDriver"
+
+        if user: 
+            self.schema = user
+
+        try:
+            if user and password and jar_location: 
+                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password], jars=jar_location.split(","))
+            elif user and password: 
+                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password])
+            elif jar_location: 
+                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, jars=jar_location.split(","))
+            else:
+                self.connection = jdbcconnector.connect(jdbc_class, jdbc_url)
+        except Exception as e:
+            logger.error(f"Error while connecting to {self.database}, {e}")
+
+        return self.connection
+
+
+    def disconnect(self):
+        """ Close any existing connections
+        Should switch self.is_connected.
+        """
+        if self.is_connected is False:
+            return
+        try:
+            self.connection.close()
+            self.is_connected=False
+        except Exception as e:
+            logger.error(f"Error while disconnecting to {self.database}, {e}")
+
+        return 
+
+
+    def check_connection(self) -> StatusResponse:
+        """ Check connection to the handler
+        Returns:
+            HandlerStatusResponse
+        """
+        responseCode = StatusResponse(False)
+        need_to_close = self.is_connected is False
+
+        try:
+            self.connect()
+            responseCode.success = True
+        except Exception as e:
+            logger.error(f'Error connecting to database {self.database}, {e}!')
+            responseCode.error_message = str(e)
+        finally:
+            if responseCode.success is True and need_to_close:
+                self.disconnect()
+            if responseCode.success is False and self.is_connected is True:
+                self.is_connected = False
+
+        return responseCode
+
+
+    def native_query(self, query: str) -> StatusResponse:
+        """Receive raw query and act upon it somehow.
+        Args:
+            query (Any): query in native format (str for sql databases,
+                dict for mongo, etc)
+        Returns:
+            HandlerResponse
+        """
+        need_to_close = self.is_connected is False
+        conn = self.connect()
+        with conn.cursor() as cur:
+            try:
+                cur.execute(query)
+                if cur.description:
+                    result = cur.fetchall() 
+                    response = Response(
+                        RESPONSE_TYPE.TABLE,
+                        data_frame=pd.DataFrame(
+                            result,
+                            columns=[x[0] for x in cur.description]
+                        )
+                    )
+                else:
+                    response = Response(RESPONSE_TYPE.OK)
+                self.connection.commit()
+            except Exception as e:
+                logger.error(f'Error running query: {query} on {self.database}!')
+                response = Response(
+                    RESPONSE_TYPE.ERROR,
+                    error_message=str(e)
+                )
+                self.connection.rollback()
+
+        if need_to_close is True:
+            self.disconnect()
+
+        return response
+
+    
+    def query(self, query: ASTNode) -> StatusResponse:
+        """Render and execute a SQL query.
+
+        Args:
+            query (ASTNode): The SQL query.
+
+        Returns:
+            Response: The query result.
+        """
+        if isinstance(query, ASTNode):
+            query_str = query.to_string()
+        else:
+            query_str = str(query)
+
+        # Replace backticks with double quotes for Derby compatibility
+        query_str = query_str.replace("`", '"')
+
+        return self.native_query(query_str)
+
+
+    def get_tables(self) -> StatusResponse:
+        """Get a list of all the tables in the database.
+
+        Returns:
+            Response: Names of the tables in the database.
+        """
+        query = f'''
+        SELECT st.tablename FROM sys.systables st LEFT OUTER JOIN sys.sysschemas ss ON (st.schemaid = ss.schemaid) WHERE ss.schemaname ='{self.schema}' '''
+    
+        result = self.native_query(query)
+        df = result.data_frame
+        result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+        return result
+
+    
+    def get_columns(self, table_name: str) -> StatusResponse:
+        """Get details about a table.
+
+        Args:
+            table_name (str): Name of the table to retrieve details of.
+
+        Returns:
+            Response: Details of the table.
+        """
+
+        query = f''' SELECT COLUMNNAME FROM SYS.SYSCOLUMNS INNER JOIN SYS.SYSTABLES ON SYS.SYSCOLUMNS.REFERENCEID=SYS.SYSTABLES.TABLEID WHERE TABLENAME='{table_name}' '''
+        return self.native_query(query)

mindsdb/integrations/handlers/derby_handler/icon.svg

@@ -0,0 +1,21 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M21.78 19.0132C21.78 19.0132 9.32917 22.989 6.86047 23.0339C6.86047 23.0339 6.79786 24.1647 7.50448 26.5699C8.30949 26.857 17.4329 24.5236 18.4437 23.9852C22.5134 21.8402 21.1807 20.7543 31.0465 17.308C31.0465 17.308 30.8587 16.4465 30.1073 15.2349C30.1252 15.2349 26.4848 17.7209 21.78 19.0132Z" fill="white"/>
+  <path d="M7.63863 26.534C7.31663 26.1032 6.86046 23.4287 6.86046 23.4287C6.86046 23.4287 0.330942 26.2737 1.07334 31.0213C1.42218 33.256 3.31842 33.5521 4.12343 33.6508C5.87656 33.8483 8.42575 32.5021 9.87477 31.488C12.7907 29.4507 14.3649 27.4763 18.9893 23.689C18.9893 23.698 12.4508 26.2019 7.63863 26.534Z" fill="url(#paint0_linear_141_665)"/>
+  <path d="M6.86941 23.0339C6.86941 23.0339 4.3381 13.6464 10.5546 10.0745C12.6297 8.88086 16.6637 7.57954 18.6673 7.3103C20.6708 7.04106 25.4025 6.19745 27.8354 10.2181C28.7209 11.6899 29.8837 14.2926 30.1252 15.2259C27.585 18.017 9.68694 22.8544 6.86941 23.0339Z" fill="url(#paint1_linear_141_665)"/>
+  <path d="M22.8801 21.4812C22.8801 21.4812 27.1109 20.6376 32.6476 20.4222C37.0751 20.2427 39.6154 18.4029 38.9893 17.4516C38.3631 16.5003 33.5599 13.6105 22.8801 21.4812Z" fill="url(#paint2_linear_141_665)"/>
+  <path d="M39.1324 17.3439C39.1324 17.3439 32.4956 9.76035 11.4938 29.8994C6.79791 33.6508 2.36142 34.306 1.23441 31.5687C2.12886 34.1803 4.69594 34.1355 7.87126 33.0675C12.0215 31.6764 17.7729 26.166 18.4974 25.6275C24.1772 21.3735 33.8909 14.5079 39.0609 17.9721C39.0519 17.9811 39.2398 17.6401 39.1324 17.3439Z" fill="black"/>
+  <defs>
+    <linearGradient id="paint0_linear_141_665" x1="1.01244" y1="28.5528" x2="18.9899" y2="28.5528" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#575757"/>
+      <stop offset="1"/>
+    </linearGradient>
+    <linearGradient id="paint1_linear_141_665" x1="6.35843" y1="15.0443" x2="30.1235" y2="15.0443" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#666666"/>
+      <stop offset="1"/>
+    </linearGradient>
+    <linearGradient id="paint2_linear_141_665" x1="22.8777" y1="18.8121" x2="39.0809" y2="18.8121" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#616161"/>
+      <stop offset="1"/>
+    </linearGradient>
+  </defs>
+</svg>

mindsdb/integrations/handlers/derby_handler/requirements.txt

@@ -0,0 +1 @@
+jaydebeapi

mindsdb/integrations/handlers/derby_handler/tests/test_derby_handler.py

@@ -0,0 +1,46 @@
+import unittest
+from mindsdb.integrations.handlers.derby_handler.derby_handler import DerbyHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+class DerbyHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "connection_data": {
+                "host": "localhost",
+                "port": "1527",
+                "database": "seconddb",                
+            }
+        }
+        cls.handler = DerbyHandler('test_derby_handler', **cls.kwargs)
+
+    def test_0_connect(self):
+        self.handler.connect()
+    
+    def test_1_check_connection(self):
+        self.handler.check_connection()
+
+    def test_2_create(self):
+        res = self.handler.query('CREATE TABLE TESTTABLEX (ID INT PRIMARY KEY, NAME VARCHAR(14))')
+        assert res.type is RESPONSE_TYPE.OK
+
+    def test_3_insert(self):
+        res = self.handler.query("INSERT INTO TESTTABLEX VALUES (100,'ONE HUNDRED'),(200,'TWO HUNDRED'),(300,'THREE HUNDRED')")
+        assert res.type is RESPONSE_TYPE.OK
+
+    def test_4_select(self):
+        res = self.handler.query('SELECT * FROM TESTTABLEX')
+        assert res.type is RESPONSE_TYPE.TABLE
+    
+    def test_5_get_tables(self):
+        res = self.handler.get_tables()
+        assert res.type is RESPONSE_TYPE.TABLE
+
+    def test_6_get_columns(self):
+        res = self.handler.get_columns("TESTTABLEX")
+        assert res.type is RESPONSE_TYPE.TABLE
+    
+
+        
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/discord_handler/__about__.py

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

mindsdb/integrations/handlers/discord_handler/__init__.py

@@ -0,0 +1,27 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+
+try:
+    from .discord_handler import DiscordHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Discord"
+name = "discord"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+]

mindsdb/integrations/handlers/discord_handler/discord_handler.py

@@ -0,0 +1,187 @@
+import requests
+import asyncio
+import pandas as pd
+
+from mindsdb.integrations.handlers.discord_handler.discord_tables import MessagesTable
+
+from mindsdb.utilities import log
+
+from mindsdb.integrations.libs.api_handler import APIHandler, FuncParser
+from mindsdb.integrations.utilities.date_utils import parse_utc_date
+
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE,
+)
+
+discord_bot = None
+logger = log.getLogger(__name__)
+
+class DiscordHandler(APIHandler):
+    """
+    The Discord handler implementation.
+    """
+
+    name = 'discord'
+
+    def __init__(self, name: str, **kwargs):
+        """
+        Initialize the handler.
+        Args:
+            name (str): name of particular handler instance
+            **kwargs: arbitrary keyword arguments.
+        """
+        super().__init__(name)
+
+        connection_data = kwargs.get("connection_data", {})
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+
+        self.is_connected = False
+
+        messages = MessagesTable(self)
+        self._register_table('messages', messages)
+
+    def connect(self):
+        """
+        Set up the connection required by the handler.
+        Returns
+        -------
+        StatusResponse
+            connection object
+        """
+
+        if self.is_connected:
+            return StatusResponse(True)
+
+        url = f'https://discord.com/api/v10/applications/@me'
+        result = requests.get(
+            url,
+            headers={
+                'Authorization': f'Bot {self.connection_data["token"]}',
+                'Content-Type': 'application/json',
+            },
+        )
+
+        if result.status_code != 200:
+            raise ValueError(result.text)
+
+        self.is_connected = True
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Check connection to the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+
+        response = StatusResponse(False)
+
+        try:
+            self.connect()
+            response.success = True
+        except Exception as e:
+            response.error_message = e
+            logger.error(f'Error connecting to Discord: {response.error_message}')
+
+        self.is_connected = response.success
+
+        return response
+
+    def native_query(self, query: str = None) -> StatusResponse:
+        """Receive and process a raw query.
+        Parameters
+        ----------
+        query : str
+            query in a native format
+        Returns
+        -------
+        StatusResponse
+            Request status
+        """
+        operation, params = FuncParser().from_string(query)
+
+        df = self.call_discord_api(operation, params)
+
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
+    
+    def utc_to_snowflake(self, utc_date: str) -> int:
+        """
+        Convert a UTC date to a Snowflake date.
+        Args:
+            utc_date (str): the UTC date
+        Returns:
+            int
+        """
+        # https://discord.com/developers/docs/reference#snowflakes
+        return str(
+            int(parse_utc_date(utc_date).timestamp() * 1000 - 1420070400000) << 22
+        )
+
+    def call_discord_api(
+            self, operation: str, params: dict = None, filters: list = None
+        ):
+        """
+        Call a Discord API method.
+        Args:
+            method_name (str): the method name
+            params (dict): the method parameters
+        Returns:
+            pd.DataFrame
+        """
+
+        if operation == 'get_messages':
+            param_strings = {'limit': params['limit']}
+            if 'after' in params:
+                param_strings['after'] = self.utc_to_snowflake(params['after'])
+            if 'before' in params:
+                param_strings['before'] = self.utc_to_snowflake(params['before'])
+
+            url = (
+                f'https://discord.com/api/v10/channels/{params["channel_id"]}/messages'
+            )
+            result = requests.get(
+                url,
+                headers={
+                    'Authorization': f'Bot {self.connection_data["token"]}',
+                    'Content-Type': 'application/json',
+                },
+                params=param_strings,
+            )
+
+            if result.status_code != 200:
+                raise ValueError(f'Error calling Discord API: {result.json()}')
+
+            json = result.json()
+            for message in json:
+                author = message.get('author')
+                if author is not None:
+                    message['author_id'] = author.get('id')
+                    message['author_username'] = author.get('username')
+                    message['author_global_name'] = author.get('global_name')
+
+            df = pd.DataFrame.from_records(json)
+            return df
+        elif operation == 'send_message':
+            url = (
+                f'https://discord.com/api/v10/channels/{params["channel_id"]}/messages'
+            )
+            result = requests.post(
+                url,
+                headers={
+                    'Authorization': f'Bot {self.connection_data["token"]}',
+                    'Content-Type': 'application/json',
+                },
+                json={
+                    'content': params['text'],
+                },
+            )
+
+            if result.status_code != 200:
+                raise ValueError(f'Error calling Discord API: {result.json()}')
+
+            df = pd.DataFrame.from_records([result.json()])
+            return df
+        else:
+            raise ValueError(f"Unsupported method: {operation}")

mindsdb/integrations/handlers/discord_handler/discord_tables.py

@@ -0,0 +1,189 @@
+import pandas as pd
+from typing import Text, List, Dict, Any
+
+from mindsdb_sql_parser import ast
+
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+
+from mindsdb.integrations.libs.response import HandlerResponse as Response
+
+from mindsdb.integrations.utilities.handlers.query_utilities.insert_query_utilities import (
+    INSERTQueryParser
+)
+
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class MessagesTable(APITable):
+    """The Discord Table implementation"""
+
+    def get_columns(self):
+        return [
+            'id',
+            'type',
+            'content',
+            'author_id',
+            'author_username',
+            'author_global_name',
+            'author_avatar',
+            'author_banner_color',
+            'attachments',
+            'embeds',
+            'mentions',
+            'mention_roles',
+            'pinned',
+            'mention_everyone',
+            'tts',
+            'timestamp',
+            'edited_timestamp',
+            'flags',
+            'components',
+            'nonce',
+            'referenced_message',
+        ]
+
+    def select(self, query: ast.Select) -> Response:
+        """Selects data from the Discord channel.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query.
+
+        Returns
+        -------
+        Response
+            Response object representing collected data from Discord.
+        """
+
+        conditions = extract_comparison_conditions(query.where)
+
+        params = {}
+        filters = []
+        user_filter_flag = channel_filter_flag = False
+        for op, arg1, arg2 in conditions:
+            if op == 'or':
+                raise NotImplementedError('OR is not supported')
+            if arg1 == 'timestamp':
+                if op == '>':
+                    params['after'] = arg2
+                elif op == '<':
+                    params['before'] = arg2
+                else:
+                    raise NotImplementedError(
+                        f'Unsupported operator {op} for timestamp'
+                    )
+            
+            elif arg1 in ['author_id', 'author_username', 'author_global_name']:
+                if user_filter_flag:
+                    raise NotImplementedError('Multiple user filters are not supported')
+                user_filter_flag = True
+
+                if op != '=':
+                    raise NotImplementedError(f'Unsupported operator {op} for {arg1}')
+
+                # if arg1 == 'author_id':
+                #     filters.append(lambda x: x.author.id == int(arg2))
+                # elif arg1 == 'author_username':
+                #     filters.append(lambda x: x.author.username == arg2)
+                # elif arg1 == 'author_global_name':
+                #     filters.append(lambda x: x.author.global_name == arg2)
+
+            elif arg1 == 'channel_id':
+                if op != '=':
+                    raise NotImplementedError(f'Unsupported operator {op} for {arg1}')
+                channel_filter_flag = True
+                params['channel_id'] = int(arg2)
+
+            else:
+                filters.append([op, arg1, arg2])
+
+        if query.limit is not None:
+            params['limit'] = query.limit
+        else:
+            params['limit'] = 100
+
+        if not channel_filter_flag:
+            raise NotImplementedError('Channel filter is required')
+        
+        result = self.handler.call_discord_api(
+            'get_messages', params=params, filters=filters
+        )
+
+        # filter targets
+        columns = []
+        for target in query.targets:
+            if isinstance(target, ast.Star):
+                columns = []
+                break
+            elif isinstance(target, ast.Identifier):
+                columns.append(target.parts[-1])
+            else:
+                raise NotImplementedError
+
+        if len(columns) == 0:
+            columns = self.get_columns()
+
+        # columns to lower case
+        columns = [name.lower() for name in columns]
+
+        if len(result) == 0:
+            result = pd.DataFrame([], columns=columns)
+        else:
+            # add absent columns
+            for col in set(columns) & set(result.columns) ^ set(columns):
+                result[col] = None
+
+            # filter by columns
+            result = result[columns]
+        return result
+
+    def insert(self, query: ast.Insert) -> None:
+        """Sends messages to a Discord channel.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        insert_statement_parser = INSERTQueryParser(
+            query,
+            supported_columns=['channel_id', 'text'],
+            mandatory_columns=['channel_id', 'text'],
+            all_mandatory=False,
+        )
+        message_data = insert_statement_parser.parse_query()
+        self.send_message(message_data)
+
+    def send_message(self, message_data: List[Dict[Text, Any]]) -> None:
+        """Sends messages to a Discord Channel using the parsed message data.
+
+        Parameters
+        ----------
+        message_data : List[Dict[Text, Any]]
+           List of dictionaries containing the messages to send.
+
+        Returns
+        -------
+        None
+        """
+        for message in message_data:
+            try:
+                params = {'channel_id': message['channel_id'], 'text': message['text']}
+                self.handler.call_discord_api('send_message', params=params)
+                logger.info(f"Message sent to Discord channel successfully.")
+            except Exception as e:
+                logger.error(f"Error sending message to Discord channel: {e}")
+                raise e