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

mindsdb/integrations/handlers/youtube_handler/youtube_tables.py

@@ -0,0 +1,448 @@
+from typing import List
+
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb.utilities import log
+
+from mindsdb_sql_parser import ast
+from mindsdb.integrations.utilities.handlers.query_utilities import (
+    SELECTQueryParser,
+    SELECTQueryExecutor,
+    INSERTQueryParser
+)
+
+import pandas as pd
+import re
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtube_transcript_api.formatters import JSONFormatter
+
+logger = log.getLogger(__name__)
+
+
+class YoutubeCommentsTable(APITable):
+    """Youtube List Comments  by video id Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Pulls data from the youtube  "commentThreads()" API endpoint
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+        Returns
+        -------
+        pd.DataFrame
+            youtube "commentThreads()" matching the query
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        select_statement_parser = SELECTQueryParser(query, "comments", self.get_columns())
+
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        channel_id, video_id = None, None
+        for a_where in where_conditions:
+            if a_where[1] == "video_id":
+                if a_where[0] != "=":
+                    raise NotImplementedError("Only '=' operator is supported for video_id column.")
+                else:
+                    video_id = a_where[2]
+            elif a_where[1] == "channel_id":
+                if a_where[0] != "=":
+                    raise NotImplementedError("Only '=' operator is supported for channel_id column.")
+                else:
+                    channel_id = a_where[2]
+
+        if not video_id and not channel_id:
+            raise ValueError("Either video_id or channel_id has to be present in where clause.")
+            
+        comments_df = self.get_comments(video_id=video_id, channel_id=channel_id)
+
+        select_statement_executor = SELECTQueryExecutor(
+            comments_df, 
+            selected_columns, 
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
+            order_by_conditions, 
+            result_limit if query.limit else None
+        )
+
+        comments_df = select_statement_executor.execute_query()
+
+        return comments_df
+    
+    def insert(self, query: ast.Insert) -> None:
+        """Inserts data into the YouTube POST /commentThreads API endpoint.
+
+        Parameters
+        ----------
+        query : ast.Insert
+            Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        
+        insert_query_parser = INSERTQueryParser(query, self.get_columns())
+
+        values_to_insert = insert_query_parser.parse_query()
+
+        for value in values_to_insert:
+            if not value.get('comment_id'):
+                if not value.get('comment'):
+                    raise ValueError(f"comment is mandatory for inserting a top-level comment.")
+                else:
+                    self.insert_comment(video_id=value['video_id'], text=value['comment'])
+
+            else:
+                if not value.get('reply'):
+                    raise ValueError(f"reply is mandatory for inserting a reply.")
+                else:
+                    self.insert_comment(comment_id=value['comment_id'], text=value['reply'])
+
+    def insert_comment(self, text, video_id: str = None, comment_id: str = None):
+        # if comment_id is provided, define the request body for a reply and insert it
+        if comment_id:
+            request_body = {
+                'snippet': {
+                    'parentId': comment_id,
+                    'textOriginal': text
+                }
+            }
+
+            self.handler.connect().comments().insert(
+                part='snippet',
+                body=request_body
+            ).execute()
+
+        # else if video_id is provided, define the request body for a top-level comment and insert it
+        elif video_id:
+            request_body = {
+                'snippet': {
+                    'topLevelComment': {
+                        'snippet': {
+                            'videoId': video_id,
+                            'textOriginal': text
+                        }
+                    }
+                }
+            }
+
+            self.handler.connect().commentThreads().insert(
+                part='snippet',
+                body=request_body
+            ).execute()
+
+    def get_columns(self) -> List[str]:
+        """Gets all columns to be returned in pandas DataFrame responses
+        Returns
+        -------
+        List[str]
+            List of columns
+        """
+        return ['comment_id', 'channel_id', 'video_id', 'user_id', 'display_name', 'comment', "published_at", "updated_at", 'reply_user_id', 'reply_author', 'reply']
+
+    def get_comments(self, video_id: str, channel_id: str):
+        """Pulls all the records from the given youtube api end point and returns it select()
+
+        Returns
+        -------
+        pd.DataFrame of all the records of the "commentThreads()" API end point
+        """
+
+        if video_id and channel_id:
+            channel_id = None
+
+        resource = (
+            self.handler.connect()
+            .commentThreads()
+            .list(part="snippet, replies", videoId=video_id, allThreadsRelatedToChannelId=channel_id, textFormat="plainText")
+        )
+
+        data = []
+        while resource:
+            comments = resource.execute()
+
+            for comment in comments["items"]:
+                replies = []
+                if 'replies' in comment:
+                    for reply in comment["replies"]["comments"]:
+                        replies.append( 
+                            {
+                                "reply_author": reply["snippet"]["authorDisplayName"],
+                                "user_id": reply["snippet"]["authorChannelId"]["value"],
+                                "reply": reply["snippet"]["textOriginal"],
+                            }
+                        )
+                else:
+                    replies.append(
+                        {
+                            "reply_author": None,
+                            "user_id": None,
+                            "reply": None,
+                        }
+                    )
+
+                data.append(
+                    {
+                        "channel_id": comment["snippet"]["channelId"],
+                        "video_id": comment["snippet"]["videoId"],
+                        "user_id": comment["snippet"]["topLevelComment"]["snippet"]["authorChannelId"]["value"],
+                        "comment_id": comment["snippet"]["topLevelComment"]["id"],
+                        "display_name": comment["snippet"]["topLevelComment"]["snippet"]["authorDisplayName"],
+                        "comment": comment["snippet"]["topLevelComment"]["snippet"]["textDisplay"],
+                        "published_at": comment["snippet"]["topLevelComment"]["snippet"]["publishedAt"],
+                        "updated_at": comment["snippet"]["topLevelComment"]["snippet"]["updatedAt"],
+                        "replies": replies,
+                    }
+                )
+
+            if "nextPageToken" in comments:
+                resource = (
+                    self.handler.connect()
+                    .commentThreads()
+                    .list(
+                        part="snippet, replies",
+                        videoId=video_id,
+                        allThreadsRelatedToChannelId=channel_id,
+                        textFormat="plainText",
+                        pageToken=comments["nextPageToken"],
+                    )
+                )
+            else:
+                break
+
+        youtube_comments_df = pd.json_normalize(data, 'replies', ['comment_id', 'channel_id', 'video_id', 'user_id', 'display_name', 'comment', "published_at", "updated_at"], record_prefix='replies.')
+        youtube_comments_df = youtube_comments_df.rename(columns={'replies.user_id': 'reply_user_id', 'replies.reply_author': 'reply_author', 'replies.reply': 'reply'})
+        
+        # check if DataFrame is empty
+        if youtube_comments_df.empty:
+            return youtube_comments_df
+        else:
+            return youtube_comments_df[['comment_id', 'channel_id', 'video_id', 'user_id', 'display_name', 'comment', "published_at", "updated_at", 'reply_user_id', 'reply_author', 'reply']]
+
+
+class YoutubeChannelsTable(APITable):
+
+    """Youtube Channel Info  by channel id Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        select_statement_parser = SELECTQueryParser(query, "channel", self.get_columns())
+
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        channel_id = None
+        for op, arg1, arg2 in where_conditions:
+            if arg1 == "channel_id":
+                if op == "=":
+                    channel_id = arg2
+                    break
+                else:
+                    raise NotImplementedError("Only '=' operator is supported for channel_id column.")
+
+        if not channel_id:
+            raise NotImplementedError("channel_id has to be present in where clause.")
+
+        channel_df = self.get_channel_details(channel_id)
+
+        select_statement_executor = SELECTQueryExecutor(
+            channel_df, 
+            selected_columns, 
+            [where_condition for where_condition in where_conditions if where_condition[1] == 'channel_id'], 
+            order_by_conditions, 
+            result_limit if query.limit else None
+        )
+
+        channel_df = select_statement_executor.execute_query()
+
+        return channel_df
+
+    def get_channel_details(self, channel_id):
+        details = (
+            self.handler.connect().channels().list(part="statistics,snippet,contentDetails", id=channel_id).execute()
+        )
+        snippet = details["items"][0]["snippet"]
+        statistics = details["items"][0]["statistics"]
+        data = {
+            "country": snippet["country"],
+            "description": snippet["description"],
+            "creation_date": snippet["publishedAt"],
+            "title": snippet["title"],
+            "subscriber_count": statistics["subscriberCount"],
+            "video_count": statistics["videoCount"],
+            "view_count": statistics["viewCount"],
+            "channel_id": channel_id,
+        }
+        return pd.json_normalize(data)
+
+    def get_columns(self) -> List[str]:
+        return [
+            "country",
+            "description",
+            "creation_date",
+            "title",
+            "subscriber_count",
+            "video_count",
+            "view_count",
+            "channel_id",
+        ]
+
+
+class YoutubeVideosTable(APITable):
+
+    """Youtube Video info  by video id Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        select_statement_parser = SELECTQueryParser(query, "video", self.get_columns())
+
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        video_id, channel_id = None, None
+        for op, arg1, arg2 in where_conditions:
+            if arg1 == "video_id":
+                if op == "=":
+                    video_id = arg2
+                else:
+                    raise NotImplementedError("Only '=' operator is supported for video_id column.")
+                
+            elif arg1 == "channel_id":
+                if op == "=":
+                    channel_id = arg2
+                else:
+                    raise NotImplementedError("Only '=' operator is supported for channel_id column.")
+
+        if not video_id and not channel_id:
+            raise ValueError("Either video_id or channel_id has to be present in where clause.")
+        
+        if video_id:
+            video_df = self.get_videos_by_video_ids([video_id])
+        else:
+            video_df = self.get_videos_by_channel_id(channel_id)
+
+        select_statement_executor = SELECTQueryExecutor(
+            video_df, 
+            selected_columns, 
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
+            order_by_conditions, 
+            result_limit if query.limit else None
+        )
+
+        video_df = select_statement_executor.execute_query()
+
+        return video_df
+    
+    def get_videos_by_channel_id(self, channel_id):
+        video_ids = []
+        resource = (
+            self.handler.connect()
+            .search()
+            .list(part="snippet", channelId=channel_id, type="video")
+        )
+        while resource:
+            response = resource.execute()
+            for item in response["items"]:
+                video_ids.append(item["id"]["videoId"])
+            if "nextPageToken" in response:
+                resource = (
+                    self.handler.connect()
+                    .search()
+                    .list(
+                        part="snippet",
+                        channelId=channel_id,
+                        type="video",
+                        pageToken=response["nextPageToken"],
+                    )
+                )
+            else:
+                break
+
+        return self.get_videos_by_video_ids(video_ids)
+
+    def get_videos_by_video_ids(self, video_ids):
+        data = []
+
+        if not isinstance(video_ids, list):
+            logger.error(f"video_ids must be a list. Received {type(video_ids)} instead.")
+            return pd.DataFrame()
+
+        # loop over 50 video ids at a time
+        # an invalid request error is caused otherwise
+        for i in range(0, len(video_ids), 50):
+            resource = self.handler.connect().videos().list(part="statistics,snippet,contentDetails", id=",".join(video_ids[i:i+50])).execute()
+            for item in resource["items"]:
+                data.append(
+                    {
+                        "channel_id": item["snippet"]["channelId"],
+                        "channel_title": item["snippet"]["channelTitle"],
+                        "comment_count": item["statistics"]["commentCount"],
+                        "description": item["snippet"]["description"],
+                        "like_count": item["statistics"]["likeCount"],
+                        "publish_time": item["snippet"]["publishedAt"],
+                        "title": item["snippet"]["title"],
+                        "transcript": self.get_captions_by_video_id(item["id"]),
+                        "video_id": item["id"],
+                        "view_count": item["statistics"]["viewCount"],
+                        "duration_str": self.parse_duration(item["id"], item["contentDetails"]["duration"]),
+                    }
+                )
+
+        return pd.json_normalize(data)
+
+    def get_captions_by_video_id(self, video_id):
+        try:
+            transcript_response = YouTubeTranscriptApi.get_transcript(video_id, preserve_formatting=True)
+            json_formatted_transcript = JSONFormatter().format_transcript(transcript_response, indent=2)
+            return json_formatted_transcript
+
+        except Exception as e:
+            logger.error(f"Encountered an error while fetching transcripts for video ${video_id}: ${e}"),
+            return "Transcript not available for this video"
+        
+    def parse_duration(self, video_id, duration):
+        try:
+            parsed_duration = re.search(f"PT(\d+H)?(\d+M)?(\d+S)", duration).groups()
+            duration_str = ""
+            for d in parsed_duration:
+                if d:
+                    duration_str += f"{d[:-1]}:"
+            
+            return duration_str.strip(":")
+        except Exception as e:
+            logger.error(f"Encountered an error while parsing duration for video ${video_id}: ${e}"),
+            return "Duration not available for this video"
+
+    def get_columns(self) -> List[str]:
+        return [
+            "channel_id",
+            "channel_title",
+            "title",
+            "description",
+            "publish_time",
+            "comment_count",
+            "like_count",
+            "view_count",
+            "video_id",
+            "duration_str",
+            "transcript",
+        ]

mindsdb/integrations/handlers/yugabyte_handler/__about__.py

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

mindsdb/integrations/handlers/yugabyte_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 .yugabyte_handler import YugabyteHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'YugabyteDB'
+name = 'yugabyte'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title',
+    'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/yugabyte_handler/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M30.1191 9.93528C27.4048 7.2288 23.7143 5.68564 19.881 5.70938C16.0477 5.70938 12.3572 7.2288 9.6429 9.93528C6.9048 12.6418 5.38099 16.3216 5.38099 20.1439C5.38099 21.9245 5.71433 23.6813 6.33338 25.3195C5.38099 26.2453 4.50004 27.2187 3.66671 28.2396C3.1429 28.8569 2.69052 29.5216 2.26195 30.2101C2.02385 30.5662 1.83338 30.9461 1.69052 31.3497C1.59528 31.5633 1.52385 31.8007 1.47623 32.0382C1.40481 32.323 1.42861 32.6079 1.50004 32.8928C1.52385 32.9641 1.54766 33.0353 1.57147 33.1065L1.59528 33.154C1.59528 33.1777 1.61909 33.1777 1.61909 33.2015C1.66671 33.2727 1.71433 33.3439 1.76195 33.4151C1.881 33.5576 2.04766 33.6763 2.21433 33.7475C2.47623 33.8662 2.78576 33.9137 3.07147 33.9137C3.52385 33.89 3.97623 33.8187 4.4048 33.7C5.19052 33.4626 5.95242 33.154 6.71433 32.7979C7.9048 32.2281 9.04766 31.5871 10.1905 30.8986C12.8572 33.2964 16.3096 34.6022 19.881 34.6022C23.7143 34.6022 27.4048 33.0828 30.1191 30.3763C32.8334 27.6698 34.381 23.99 34.3572 20.1677C34.381 16.3216 32.8572 12.6418 30.1191 9.93528ZM6.66671 26.0792C7.28576 27.4561 8.11909 28.7144 9.11909 29.8302C8.02385 30.495 7.02385 31.0648 6.09528 31.5159C5.42861 31.8482 4.73814 32.1569 4.02385 32.3943C3.71433 32.513 3.381 32.5605 3.04766 32.5842C2.95242 32.5842 2.85719 32.5842 2.76195 32.5605C2.73814 32.5605 2.73814 32.5367 2.73814 32.5367C2.73814 32.5367 2.73814 32.5367 2.73814 32.513C2.71433 32.418 2.71433 32.323 2.73814 32.2281C2.76195 32.0619 2.80957 31.9195 2.85719 31.777C2.97623 31.4446 3.11909 31.1123 3.30957 30.8036C3.66671 30.1389 4.09528 29.4979 4.52385 28.8806C5.16671 27.9547 5.85719 27.0763 6.66671 26.0792ZM14.8334 27.741C16.3334 26.6489 17.5239 25.723 18.5953 24.8446C19.7858 23.895 21 22.8504 22.2143 21.7583L22.3572 21.6159C23.4286 20.595 24.5715 19.5504 25.6429 18.5058C25.7619 18.3871 25.7619 18.1971 25.6667 18.0784C25.5477 17.9597 25.381 17.936 25.2381 18.031C24.0477 18.9569 22.881 19.9065 21.7381 20.8087L21.5477 20.9511C20.4762 21.782 19.3334 22.6842 17.8334 23.8L17.6905 23.895C16.5 24.7734 15.2619 25.6993 14.0239 26.554C12.6191 27.5274 11.4762 28.3108 10.4048 28.9756C8.11909 26.5777 6.85719 23.3964 6.881 20.0727C6.881 16.6302 8.23814 13.3302 10.6905 10.8849C13.1191 8.43959 16.4524 7.06261 19.9048 7.08636C23.3572 7.08636 26.6667 8.43959 29.1191 10.8849C31.5715 13.3065 32.9524 16.6302 32.9286 20.0727C32.9286 23.5151 31.5715 26.8151 29.1191 29.2605C26.6905 31.7058 23.3572 33.0828 19.9048 33.059C16.8334 33.059 13.8572 31.9669 11.5 29.9964C12.6191 29.3317 13.7381 28.5482 14.8334 27.741Z" fill="#322965"/>
+  <path d="M38.0715 6.65897C38.0715 6.65897 34.5953 6.11293 33.4525 7.11005L31.3334 8.96185L31.143 9.12803L31.0477 9.223C31.0477 9.223 27.4287 8.98559 26.643 9.67408L25.8334 10.3626L25.5239 10.6237L25.1906 10.9086L25.0953 10.9798L26.7858 12.9029C26.262 13.3539 26.643 14.6122 27.6191 15.7518C28.5953 16.8676 29.8096 17.4136 30.3334 16.9626L32.0239 18.8856L32.0715 18.8381L32.7144 18.2683L33.5239 17.5798C34.3096 16.8913 34.5715 13.2827 34.5715 13.2827L34.762 13.1165L34.9287 12.9741L36.9763 11.1935C38.143 10.1726 38.0715 6.65897 38.0715 6.65897ZM27.643 12.1669L27.762 12.0719L27.643 12.1669ZM34.1191 13.6626L34.0001 13.7575L34.1191 13.6626Z" fill="#ED5735"/>
+</svg>

mindsdb/integrations/handlers/yugabyte_handler/tests/test_yugabyte_handler.py

@@ -0,0 +1,49 @@
+import unittest
+from mindsdb.integrations.handlers.yugabyte_handler.yugabyte_handler import YugabyteHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class YugabyteHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "connection_data": {
+                "host": "localhost",
+                "port": 5433,
+                "user": "admin",
+                "password": "",
+                "database": "yugabyte"
+            }
+        }
+        cls.handler = YugabyteHandler('test_yugabyte_handler', cls.kwargs)
+
+    def test_0_connect(self):
+        self.handler.connect()
+
+    def test_1_drop_table(self):
+        res = self.handler.query("DROP TABLE IF EXISTS PREM;")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_2_create_table(self):
+        res = self.handler.query("CREATE TABLE IF NOT EXISTS PREM (Premi varchar(50));")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_3_insert_table(self):
+        res = self.handler.query("INSERT INTO PREM VALUES('Radha <3 Krishna');")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_4_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables.type is not RESPONSE_TYPE.ERROR
+ 
+    def test_5_select_query(self):
+        query = "SELECT * FROM PREM;"
+        result = self.handler.native_query(query)
+        assert result.type is RESPONSE_TYPE.TABLE or RESPONSE_TYPE.OK
+
+    def test_6_check_connection(self):
+        self.handler.check_connection()
+
+        
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/yugabyte_handler/yugabyte_handler.py

@@ -0,0 +1,60 @@
+from collections import OrderedDict
+from typing import Optional
+
+from mindsdb_sql_parser import parse_sql
+from mindsdb_sql_parser.ast.base import ASTNode
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from pandas import DataFrame
+
+from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
+    PostgresHandler,
+)
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+class YugabyteHandler(PostgresHandler):
+    """
+    This handler handles connection and execution of the YugabyteSQL statements.
+    """
+
+    name = 'yugabyte'
+
+    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 YugabyteDB server/database.',
+    },
+    user={
+        'type': ARG_TYPE.STR,
+        'description': 'The user name used to authenticate with the YugabyteDB server.',
+    },
+    password={
+        'type': ARG_TYPE.STR,
+        'description': 'The password to authenticate the user with the YugabyteDB server.',
+    },
+    port={
+        'type': ARG_TYPE.INT,
+        'description': 'Specify port to connect YugabyteDB server',
+    },
+    database={
+        'type': ARG_TYPE.STR,
+        'description': 'Specify database name  to connect YugabyteDB server',
+    },
+    schema={
+        'type': ARG_TYPE.STR,
+        'description': '(OPTIONAL) comma seperated value of schema to be considered while querying',
+    },
+    sslmode={
+        'type': ARG_TYPE.STR,
+        'description': ''' (OPTIONAL) Specifies the SSL mode for the connection, determining whether to use SSL encryption and the level of verification required
+        (e.g., "**disable**", "**allow**", "**prefer**", "**require**", "**verify-ca**", "**verify-full**")''',
+    },
+)
+
+connection_args_example = OrderedDict(
+    host='127.0.0.1', port=5433, password='', user='admin', database='yugabyte'
+)

mindsdb/integrations/handlers/zendesk_handler/__about__.py

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

mindsdb/integrations/handlers/zendesk_handler/__init__.py

@@ -0,0 +1,28 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+try:
+    from .zendesk_handler import ZendeskHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Zendesk"
+name = "zendesk"
+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/zendesk_handler/connection_args.py

@@ -0,0 +1,33 @@
+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",
+        "required": True,
+        "label": "api_key",
+        "secret": True
+    },
+    sub_domain={
+        "type": ARG_TYPE.STR,
+        "description": "Sub-domain",
+        "required": True,
+        "label": "sub_domain",
+        "secret": True
+    },
+    email={
+        "type": ARG_TYPE.STR,
+        "description": "Email ID",
+        "required": True,
+        "label": "email"
+    }
+)
+
+connection_args_example = OrderedDict(
+    api_key="api_key",
+    sub_domain="sub_domain",
+    email="email"
+)

mindsdb/integrations/handlers/zendesk_handler/icon.svg

@@ -0,0 +1 @@
+<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 363.2 259.5" width="2500" height="1786"><style>.st0{fill:#03363d}</style><title>golion-z-sourcefile-algae</title><path class="st0" d="M173.8 40.5v112.9H80.3zM173.8 0c0 25.8-20.9 46.7-46.7 46.7S80.3 25.8 80.3 0h93.5zM189.2 153.4c0-25.8 20.9-46.7 46.7-46.7 25.8 0 46.7 20.9 46.7 46.7h-93.4zM189.2 112.9V0h93.5zM241.5 249.9c4.8.1 9.5-1.7 13-5l6.4 6.9c-4.2 4.4-10.1 7.6-19.3 7.6-15.7 0-25.8-10.4-25.8-24.5-.3-13.3 10.3-24.2 23.5-24.5h.8c15.6 0 24.4 11.8 23.6 28.3H227c1.3 6.9 6.1 11.3 14.5 11.2m11.2-18.9c-1-6.4-4.8-11.1-12.4-11.1-7.1 0-12 4-13.3 11.1h25.7zM0 249.4l28.3-28.8H.7v-9h40.7v9.2l-28.3 28.8h28.7v9H0zM73.6 249.9c4.8.1 9.5-1.7 12.9-5l6.4 6.9c-4.2 4.4-10.1 7.6-19.3 7.6-15.7 0-25.8-10.4-25.8-24.5-.3-13.3 10.3-24.2 23.5-24.5h.8c15.6 0 24.4 11.8 23.6 28.3H59.1c1.3 6.9 6.1 11.3 14.5 11.2M84.8 231c-1-6.4-4.8-11.1-12.4-11.1-7.1 0-12 4-13.3 11.1h25.7zM157 235c0-15 11.2-24.4 23.6-24.4 6-.1 11.7 2.5 15.7 7v-27.7h10v68.6h-10V252c-3.9 4.7-9.7 7.5-15.8 7.4-12 0-23.5-9.5-23.5-24.4m39.8-.1c-.2-8.2-7.1-14.7-15.3-14.5-8.2.2-14.7 7.1-14.5 15.3.2 8.1 6.8 14.5 14.9 14.5 8.6 0 14.9-6.8 14.9-15.3M270.3 248.5l9.1-4.7c2.4 4.4 7.1 7 12.1 6.9 5.7 0 8.6-2.9 8.6-6.2 0-3.8-5.5-4.6-11.4-5.8-8-1.7-16.3-4.3-16.3-14 0-7.4 7.1-14.3 18.2-14.2 8.8 0 15.3 3.5 19 9.1l-8.4 4.6c-2.4-3.5-6.4-5.5-10.6-5.4-5.4 0-8.1 2.6-8.1 5.6 0 3.4 4.3 4.3 11.1 5.8 7.7 1.7 16.5 4.2 16.5 14 0 6.5-5.7 15.2-19.1 15.1-9.8.1-16.7-3.8-20.7-10.8M337.2 237.6l-7.9 8.7v12.2h-10v-68.6h10v44.9l21.2-23.3h12.2l-18.4 20.1 18.9 26.9h-11.3zM126.8 210.5c-11.9 0-21.9 7.7-21.9 20.5v27.5h10.2v-26.2c0-7.7 4.4-12.3 12-12.3s11.3 4.6 11.3 12.3v26.2h10.1V231c.1-12.8-9.9-20.5-21.7-20.5"/></svg>