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

mindsdb/integrations/handlers/pinecone_handler/requirements.txt

@@ -0,0 +1 @@
+pinecone-client

mindsdb/integrations/handlers/pinot_handler/__about__.py

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

mindsdb/integrations/handlers/pinot_handler/__init__.py

@@ -0,0 +1,20 @@
+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 .pinot_handler import PinotHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Apache Pinot'
+name = 'pinot'
+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/pinot_handler/connection_args.py

@@ -0,0 +1,49 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    host={
+        'type': ARG_TYPE.STR,
+        'description': 'The host name or IP address of the Apache Pinot cluster.'
+    },
+    broker_port={
+        'type': ARG_TYPE.INT,
+        'description': 'The port that the Broker of the Apache Pinot cluster is running on.'
+    },
+    controller_port={
+        'type': ARG_TYPE.INT,
+        'description': 'The port that the Controller of the Apache Pinot cluster is running on.'
+    },
+    path={
+        'type': ARG_TYPE.STR,
+        'description': 'The query path.'
+    },
+    scheme={
+        'type': ARG_TYPE.STR,
+        'description': 'The URI schema. This parameter is optional and the default will be https.'
+    },
+    username={
+        'type': ARG_TYPE.STR,
+        'description': 'The user name used to authenticate with the Apache Pinot cluster. This parameter is optional.'
+    },
+    password={
+        'type': ARG_TYPE.PWD,
+        'description': 'The password used to authenticate with the Apache Pinot cluster. This parameter is optional.',
+        'secret': True
+    },
+    verify_ssl={
+        'type': ARG_TYPE.STR,
+        'description': 'The flag for whether SSL certificates should be verified or not. This parameter is optional and '
+                       'if specified, it should be either True or False'
+    },
+)
+
+connection_args_example = OrderedDict(
+    host='localhost',
+    broker_port=8000,
+    controller_port=9000,
+    path='/query/sql',
+    scheme='http'
+)

mindsdb/integrations/handlers/pinot_handler/icon.svg

@@ -0,0 +1,7 @@
+<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="M21.879 1.40121C21.6752 1.60503 21.6752 1.60503 21.6752 1.96172C21.6752 2.98083 22.9745 3.03178 23.051 2.01268C23.1019 1.2993 22.3631 0.917133 21.879 1.40121Z" fill="#040404"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M16.0446 3.41398C15.3821 3.77066 15.586 4.91716 16.3248 4.91716C16.9108 4.91716 17.2675 4.20378 16.9363 3.69423C16.6815 3.36302 16.3503 3.26111 16.0446 3.41398Z" fill="#040404"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M22.0318 4.48396C21.9554 4.50944 21.828 4.58587 21.7516 4.66231L21.6497 4.76422L21.6242 8.20371C21.5987 11.3884 21.5987 11.6687 21.5223 11.8215C21.293 12.2547 20.6561 12.3566 20.2994 12.0254C20.0191 11.7706 19.9936 11.7451 19.9936 9.8088V8.02536L19.8662 7.89797C19.586 7.59224 18.7452 7.6432 18.7452 7.94893C18.7452 7.97441 18.7197 8.02536 18.6943 8.02536C18.6688 8.02536 18.6433 9.24829 18.6688 11.6432L18.6943 15.2356L18.8981 15.0827C19.0255 15.0063 19.1274 14.9298 19.1529 14.9298C19.1783 14.9298 19.2038 14.9043 19.2038 14.8789C19.2038 14.8534 19.2548 14.8279 19.3057 14.8279C19.3567 14.8279 19.4076 14.8024 19.4331 14.777C19.4841 14.726 19.7134 14.675 20.2229 14.5222C20.4777 14.4457 21.1147 14.4457 21.4204 14.5222C21.7261 14.5986 22.3885 14.8279 22.4395 14.8534C22.4904 14.9043 22.6433 15.0063 22.7452 15.0317C22.7962 15.0572 22.8217 15.0827 22.8217 15.1082C22.8217 15.1336 22.8471 15.1591 22.8726 15.1591C22.9745 15.1591 23.4076 15.6177 23.7643 16.0763C23.8917 16.2547 24.1465 16.8661 24.1975 17.0699C24.2229 17.1464 24.2484 17.3502 24.2739 17.5031C24.3503 17.8088 24.2994 18.5477 24.2229 18.6241C24.1975 18.6496 24.172 18.777 24.172 18.8789C24.172 19.0063 24.1465 19.0827 24.121 19.0827C24.0955 19.0827 24.0701 19.1082 24.0701 19.1591C24.0701 19.2356 23.8408 19.7196 23.7643 19.7706C23.7389 19.7961 23.6879 19.8725 23.6369 19.9489C23.535 20.1273 23.3312 20.3566 23.1783 20.484C22.8726 20.7642 22.7197 20.8661 22.6688 20.8661C22.6433 20.8661 22.5924 20.8916 22.5924 20.8916C22.5669 20.9426 22.2611 21.0954 22.1847 21.0954C22.1338 21.0954 22.1083 21.1209 22.1083 21.1464C22.1083 21.1719 22.0573 21.1973 21.9809 21.2228C21.9045 21.2483 21.6752 21.2992 21.4968 21.3247C20.8344 21.4776 20.0191 21.3757 19.3312 21.0699C19.1783 20.9935 19.051 20.9426 19.0255 20.9426C19 20.9426 18.9745 20.9171 18.9745 20.8916C18.9745 20.8661 18.949 20.8407 18.9236 20.8407C18.8981 20.8407 18.8471 20.8152 18.7962 20.7642C18.7452 20.7133 18.6943 20.6878 18.6688 20.6878C18.6433 20.6878 18.6178 21.4521 18.6178 22.3948C18.5924 24.0508 18.5924 24.1273 18.4904 24.2547C18.1338 24.7387 17.4968 24.7387 17.1401 24.2801L17.0382 24.1273V15.4139V6.77696L16.8854 6.64957C16.7325 6.52218 16.5541 6.4967 16.2484 6.52218C16.172 6.52218 16.0446 6.59861 15.9427 6.67504L15.7643 6.82791L15.7389 7.59224C15.7389 8.1018 15.7134 8.35657 15.6624 8.38205C15.6369 8.40753 15 8.40753 14.2866 8.40753H12.9618L12.9363 8.50944C12.9108 8.5604 12.8599 8.71326 12.8089 8.84065C12.6815 9.14638 12.6561 9.19734 12.5541 9.55403C12.5032 9.70689 12.4522 9.88524 12.4268 9.93619C12.4013 9.98715 12.3758 10.0891 12.3758 10.1655C12.3758 10.2419 12.3503 10.3184 12.3248 10.3438C12.2994 10.3693 12.2739 10.4712 12.2484 10.5986C12.2229 10.726 12.1975 10.8279 12.172 10.8279C12.1465 10.8279 12.121 10.9043 12.121 11.0063C12.121 11.1082 12.0955 11.2101 12.0701 11.2356C12.0446 11.261 12.0191 11.3375 11.9936 11.4139C11.9682 11.5158 11.9172 11.6942 11.8917 11.847C11.7898 12.2037 11.7389 12.3311 11.6115 12.8661C11.535 13.0954 11.4841 13.3247 11.4586 13.3247C11.4331 13.3502 11.4331 13.4266 11.4331 13.4776C11.4331 13.554 11.4076 13.6559 11.3567 13.7324C11.3057 13.8088 11.2803 13.9107 11.2803 13.9617C11.2803 14.0126 11.2548 14.1145 11.2293 14.1655C11.2038 14.2164 11.1529 14.4203 11.1019 14.5986C10.949 15.2865 10.8981 15.4139 10.8726 15.4394C10.8471 15.4649 10.8471 15.5413 10.8471 15.6177C10.8471 15.6942 10.8217 15.7706 10.7962 15.7961C10.7707 15.8215 10.7452 15.898 10.7452 15.9744C10.7452 16.1018 10.6688 16.433 10.5414 16.7387C10.5159 16.7897 10.4904 16.9171 10.4904 16.9935C10.465 17.0699 10.4395 17.2738 10.3885 17.4266C10.3121 17.7069 10.2611 17.9107 10.1592 18.5222C10.1338 18.7005 10.0828 18.9553 10.0573 19.1082C9.98089 19.4649 9.98089 21.4012 10.0573 21.7833C10.0828 21.9362 10.1338 22.2164 10.1592 22.3438C10.1847 22.4967 10.2102 22.7005 10.2357 22.8024C10.2611 22.9043 10.2866 23.0317 10.3121 23.0827C10.3376 23.1336 10.3885 23.312 10.4395 23.4903C10.4904 23.6432 10.5414 23.8215 10.5669 23.898C10.7962 24.5349 10.8217 24.5859 11.051 25.0445C11.2038 25.3757 11.7643 26.3438 11.8662 26.4203C11.8917 26.4457 11.9427 26.5222 12.0191 26.5986C12.3248 27.0063 12.4268 27.1336 12.8599 27.5413C13.3439 28.0254 13.5478 28.2037 13.8535 28.433C13.9554 28.5094 14.0573 28.5859 14.0573 28.6114C14.0573 28.6368 14.1083 28.6368 14.1338 28.6368C14.1592 28.6368 14.2102 28.6623 14.2357 28.7133C14.2611 28.7642 14.2866 28.7897 14.3376 28.7897C14.3885 28.7897 14.414 28.8152 14.414 28.8152C14.465 28.9426 15.4586 29.5031 16.4522 29.9617C16.6051 30.0381 16.7325 30.1145 16.7325 30.14C16.7325 30.1655 16.7834 30.1655 16.8089 30.1655C16.8854 30.1655 17.1911 30.3184 17.242 30.3693C17.2675 30.3948 17.3185 30.4203 17.3949 30.4712C17.5987 30.5731 18.1083 31.0572 18.2357 31.261C18.2866 31.3629 18.3631 31.4649 18.3631 31.4649C18.3885 31.4903 18.4395 31.5922 18.5159 31.7451C18.5669 31.8725 18.6688 32.0508 18.6943 32.1273C18.7452 32.2037 18.7707 32.3056 18.7707 32.3566C18.7707 32.4075 18.7962 32.4585 18.7962 32.484C18.8981 32.5859 19.051 33.3502 19.1019 33.9107C19.1274 34.1145 19.1529 34.3184 19.1783 34.3438C19.2548 34.4203 19.3312 35.6942 19.3567 36.8916C19.3822 38.14 19.4076 38.0636 18.949 38.191C18.7962 38.2419 18.6178 38.2929 18.5669 38.3184C18.3376 38.4203 17.6497 38.6241 17.5478 38.6241C17.4968 38.6241 17.4459 38.6496 17.4204 38.6496C17.3694 38.7005 16.9108 38.8534 16.8089 38.8534C16.758 38.8534 16.6815 38.8789 16.6561 38.9043C16.6306 38.9298 16.4777 38.9808 16.2994 39.0317C16.1465 39.0827 15.9682 39.1336 15.8917 39.1591C15.6115 39.261 14.9745 39.4649 14.8981 39.4649C14.8471 39.4649 14.7707 39.4903 14.7452 39.5158C14.7197 39.5413 14.6433 39.5668 14.5669 39.5922C14.4904 39.5922 16.8344 39.6177 19.7643 39.6177C22.6943 39.6177 25.0382 39.6177 24.9618 39.5922C24.8854 39.5922 24.7834 39.5413 24.7325 39.5413C24.6815 39.5158 24.4268 39.4394 24.1975 39.3629C23.9427 39.2865 23.7134 39.2101 23.6369 39.1846C23.586 39.1591 23.4076 39.1082 23.2293 39.0572C23.0764 39.0063 22.8981 38.9553 22.8471 38.9298C22.7962 38.9043 22.7197 38.8789 22.6433 38.8789C22.5924 38.8789 22.4904 38.8534 22.4395 38.8024C22.3885 38.7515 22.2866 38.726 22.2357 38.726C22.1847 38.726 22.1083 38.7005 22.1083 38.675C22.1083 38.6496 22.0573 38.6241 21.9809 38.6241C21.9045 38.6241 21.6242 38.5477 21.3694 38.4457C20.8599 38.2674 20.5541 38.1655 20.4013 38.1655C20.1975 38.14 20.0955 37.7324 20.1465 37.1464C20.172 36.8916 20.1975 36.3311 20.2229 35.8725C20.2739 34.9043 20.3758 34.0381 20.4268 33.8852C20.4522 33.8343 20.4777 33.6559 20.4777 33.5285C20.4777 33.4012 20.5032 33.2228 20.5287 33.1464C20.5541 33.07 20.6051 32.8916 20.6306 32.7642C20.7325 32.3566 21.1656 31.3629 21.242 31.3629C21.2675 31.3629 21.293 31.3375 21.293 31.312C21.293 31.1846 22.0318 30.5222 22.1847 30.5222C22.2102 30.5222 22.2357 30.4967 22.2357 30.4712C22.2357 30.4457 22.2611 30.4203 22.3121 30.4203C22.3631 30.4203 22.3885 30.3948 22.3885 30.3693C22.3885 30.3438 22.6433 30.2164 22.949 30.0636C23.7898 29.6559 24.6306 29.2228 24.7325 29.1464C24.8854 29.0445 25.1656 28.8661 25.1911 28.8661C25.2166 28.8661 25.293 28.8152 25.344 28.7387C25.3949 28.6623 25.5223 28.5859 25.5987 28.5604C25.9554 28.3821 27.051 27.3629 27.5096 26.777C27.6624 26.5731 27.8153 26.3948 27.8408 26.3693C27.9936 26.191 28.4268 25.4521 28.4522 25.3757C28.4777 25.2993 28.5032 25.2483 28.5287 25.2483C28.5541 25.2483 28.5796 25.1973 28.5796 25.1464C28.5796 25.0954 28.6051 25.019 28.6561 24.9935C28.707 24.968 28.7325 24.8916 28.7325 24.8407C28.7325 24.7897 28.758 24.7387 28.7834 24.7387C28.8089 24.7387 28.8344 24.6878 28.8344 24.6368C28.8344 24.5859 28.8599 24.484 28.9108 24.4075C29.5478 23.1082 29.7006 20.7133 29.2675 18.3184C29.1911 17.9362 29.1401 17.605 29.1147 17.5795C29.0892 17.5285 29.0637 17.4266 29.0637 17.2992C29.0637 17.1973 29.0127 16.9426 28.9618 16.7642C28.9108 16.5859 28.8599 16.3566 28.8599 16.2292C28.8344 16.1273 28.8089 15.9999 28.7834 15.9744C28.758 15.9489 28.7325 15.8725 28.7325 15.7961C28.7325 15.7196 28.707 15.5922 28.6561 15.5158C28.6051 15.4394 28.5796 15.312 28.5796 15.2356C28.5796 15.1591 28.5541 15.0827 28.5287 15.0827C28.5032 15.0572 28.4777 14.9808 28.4522 14.8789C28.4268 14.777 28.4013 14.5731 28.3503 14.4203C28.2994 14.2674 28.2484 14.0891 28.2484 14.0126C28.2229 13.9362 28.1975 13.8343 28.172 13.7833C28.1465 13.7324 28.0955 13.554 28.0446 13.4012C27.9936 13.2483 27.9172 12.968 27.8662 12.7897C27.8153 12.6114 27.7643 12.4075 27.7643 12.3566C27.7643 12.3056 27.7389 12.2547 27.7134 12.2292C27.6624 12.1782 27.586 11.898 27.4076 11.2356C27.3822 11.1591 27.3567 11.0317 27.3312 10.9553C27.2293 10.726 27.1783 10.4712 27.1783 10.3693C27.1783 10.3184 27.1529 10.2419 27.1274 10.2419C27.1019 10.2164 27.0764 10.14 27.0764 10.0891C27.0764 10.0126 27.051 9.91071 27 9.83428C26.949 9.75785 26.9236 9.65594 26.9236 9.5795C26.9236 9.50307 26.8981 9.42664 26.8726 9.42664C26.8471 9.40116 26.8217 9.32473 26.7962 9.22282C26.7452 8.99352 26.5669 8.58587 26.4904 8.58587C26.465 8.58587 26.414 8.5604 26.414 8.53492C26.414 8.45848 26.0573 8.43301 24.5032 8.38205L23 8.35657L22.9745 6.59861C22.949 4.91708 22.949 4.84065 22.8471 4.71326C22.6943 4.48396 22.3121 4.38205 22.0318 4.48396Z" fill="#040404"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M18.949 4.63686C18.4649 4.91712 18.5159 5.78336 19.0255 6.03814C19.535 6.29291 19.9681 5.93623 19.9681 5.29928C19.9681 4.66234 19.4331 4.33113 18.949 4.63686Z" fill="#040404"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M20.4013 16.2802C20.1974 16.3312 20.0446 16.3822 20.0191 16.3822C19.8662 16.3822 19.3822 16.9172 19.2293 17.1974C19.0255 17.5796 18.9745 18.3694 19.1529 18.5987C19.2038 18.6497 19.2293 18.7516 19.2293 18.8025C19.2293 18.8535 19.2548 18.879 19.2802 18.879C19.3057 18.879 19.3312 18.9045 19.3312 18.9554C19.3312 19.0573 19.7898 19.465 20.0701 19.5923C21.3185 20.1783 23 18.828 22.5414 17.6306C22.5159 17.5796 22.465 17.4267 22.4395 17.2994C22.2866 16.7898 21.293 16.1274 20.8089 16.2038C20.758 16.2038 20.5796 16.2293 20.4013 16.2802Z" fill="#040404"/>
+</svg>

mindsdb/integrations/handlers/pinot_handler/pinot_handler.py

@@ -0,0 +1,223 @@
+from typing import Optional
+
+import pandas as pd
+import pinotdb
+import requests
+from requests.exceptions import InvalidSchema
+import json
+
+from mindsdb_sql_parser import parse_sql
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.integrations.libs.base import DatabaseHandler
+from pinotdb.sqlalchemy import PinotDialect
+
+from mindsdb_sql_parser.ast.base import ASTNode
+
+from mindsdb.utilities import log
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE
+)
+
+
+logger = log.getLogger(__name__)
+
+class PinotHandler(DatabaseHandler):
+    """
+    This handler handles connection and execution of the Apache Pinot statements.
+    """
+
+    name = 'pinot'
+
+    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.parser = parse_sql
+        self.dialect = 'pinot'
+
+        optional_parameters = ['username', 'password']
+        for parameter in optional_parameters:
+            if parameter not in connection_data:
+                connection_data[parameter] = None
+
+        if 'verify_ssl' not in connection_data:
+            connection_data['verify_ssl'] = 'False'
+
+        if 'scheme' not in connection_data:
+            connection_data['scheme'] = 'http'
+
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+
+        self.connection = None
+        self.is_connected = False
+
+    def __del__(self):
+        if self.is_connected is True:
+            self.disconnect()
+
+    def connect(self) -> StatusResponse:
+        """
+        Set up the connection required by the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+
+        if self.is_connected is True:
+            return self.connection
+
+        self.connection = pinotdb.connect(
+            host=self.connection_data['host'],
+            port=self.connection_data['broker_port'],
+            path=self.connection_data['path'],
+            scheme=self.connection_data['scheme'],
+            username=self.connection_data['username'],
+            password=self.connection_data['password'],
+            verify_ssl=json.loads(self.connection_data['verify_ssl'].lower())
+        )
+        self.is_connected = True
+
+        return self.connection
+
+    def disconnect(self):
+        """ Close any existing connections
+
+        Should switch self.is_connected.
+        """
+        self.is_connected = False
+        return
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Check connection to the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+
+        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 Pinot, {e}!')
+            response.error_message = str(e)
+        finally:
+            if response.success is True and need_to_close:
+                self.disconnect()
+            if response.success is False and self.is_connected is True:
+                self.is_connected = False
+
+        return response
+
+    def native_query(self, query: str) -> StatusResponse:
+        """
+        Receive raw query and act upon it somehow.
+        Args:
+            query (str): query in native format
+        Returns:
+            HandlerResponse
+        """
+
+        need_to_close = self.is_connected is False
+
+        connection = self.connect()
+        cursor = connection.cursor()
+
+        try:
+            cursor.execute(query)
+            result = cursor.fetchall()
+            if result:
+                response = Response(
+                    RESPONSE_TYPE.TABLE,
+                    data_frame=pd.DataFrame(
+                        result,
+                        columns=[x[0] for x in cursor.description]
+                    )
+                )
+            else:
+                connection.commit()
+                response = Response(RESPONSE_TYPE.OK)
+        except Exception as e:
+            logger.error(f'Error running query: {query} on Pinot!')
+            response = Response(
+                RESPONSE_TYPE.ERROR,
+                error_message=str(e)
+            )
+
+        cursor.close()
+        if need_to_close is True:
+            self.disconnect()
+
+        return response
+
+    def query(self, query: ASTNode) -> StatusResponse:
+        """
+        Receive query as AST (abstract syntax tree) and act upon it somehow.
+        Args:
+            query (ASTNode): sql query represented as AST. May be any kind
+                of query: SELECT, INTSERT, DELETE, etc
+        Returns:
+            HandlerResponse
+        """
+        renderer = SqlalchemyRender(PinotDialect)
+        query_str = renderer.get_string(query, with_failback=True)
+        return self.native_query(query_str)
+
+    def get_tables(self) -> StatusResponse:
+        """
+        Return list of entities that will be accessible as tables.
+        Returns:
+            HandlerResponse
+        """
+
+        api_url = f"{self.connection_data['host']}:{self.connection_data['controller_port']}/tables"
+        try:
+            result = requests.get(api_url)
+        except InvalidSchema as e:
+            api_url = f"{self.connection_data['scheme']}://{api_url}"
+            result = requests.get(api_url)
+
+        response = Response(
+            RESPONSE_TYPE.TABLE,
+            data_frame=pd.DataFrame(
+                json.loads(result.content)['tables'],
+                columns=['table_name']
+            )
+        )
+
+        return response
+
+    def get_columns(self, table_name: str) -> StatusResponse:
+        """
+        Returns a list of entity columns.
+        Args:
+            table_name (str): name of one of tables returned by self.get_tables()
+        Returns:
+            HandlerResponse
+        """
+
+        api_url = f"{self.connection_data['host']}:{self.connection_data['controller_port']}/tables/{table_name}/schema"
+        try:
+            result = requests.get(api_url)
+        except InvalidSchema as e:
+            api_url = f"{self.connection_data['scheme']}://{api_url}"
+            result = requests.get(api_url)
+
+        df = pd.DataFrame(json.loads(result.content)['dimensionFieldSpecs'])
+        df = df.rename(columns={'name': 'column_name', 'dataType': 'data_type'})
+
+        response = Response(
+            RESPONSE_TYPE.TABLE,
+            data_frame=df
+        )
+
+        return response

mindsdb/integrations/handlers/pinot_handler/requirements.txt

@@ -0,0 +1 @@
+pinotdb

mindsdb/integrations/handlers/pinot_handler/tests/test_pinot_handler.py

@@ -0,0 +1,36 @@
+import unittest
+from mindsdb.integrations.handlers.pinot_handler.pinot_handler import PinotHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class PinotHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "host": "localhost",
+            "broker_port": 8000,
+            "controller_port": 9000,
+            "path": "/query/sql",
+            "scheme": "http"
+        }
+        cls.handler = PinotHandler('test_pinot_handler', cls.kwargs)
+
+    def test_0_check_connection(self):
+        assert self.handler.check_connection()
+
+    def test_1_native_query_select(self):
+        query = "SELECT * FROM baseballStats"
+        result = self.handler.native_query(query)
+        assert result.type is RESPONSE_TYPE.TABLE
+
+    def test_2_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables.type is not RESPONSE_TYPE.ERROR
+
+    def test_3_get_columns(self):
+        columns = self.handler.get_columns('baseballStats')
+        assert columns.type is not RESPONSE_TYPE.ERROR
+
+
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/pirateweather_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB PirateWeather API handler'
+__package_name__ = 'mindsdb_pirateweather_api_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for the PriateWeather API"
+__author__ = 'Patrick Sean Klein'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023- mindsdb'

mindsdb/integrations/handlers/pirateweather_handler/__init__.py

@@ -0,0 +1,29 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __description__ as description
+from .__about__ import __version__ as version
+from .connection_args import connection_args, connection_args_example
+try:
+    from .pirateweather_handler import PirateWeatherAPIHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Pirate Weather"
+name = "pirateweather"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.png"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]

mindsdb/integrations/handlers/pirateweather_handler/connection_args.py

@@ -0,0 +1,14 @@
+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": "Your PirateWeather API key.",
+        "secret": True
+    }
+)
+
+connection_args_example = OrderedDict(api_key="knlsndlknslk")

mindsdb/integrations/handlers/pirateweather_handler/pirateweather_handler.py

@@ -0,0 +1,236 @@
+import os
+from typing import Any
+
+import pandas as pd
+import requests
+from mindsdb_sql_parser import parse_sql
+from mindsdb_sql_parser import ast
+
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb.integrations.utilities.handlers.query_utilities import SELECTQueryParser, SELECTQueryExecutor
+from mindsdb.integrations.libs.api_handler import APIHandler, APITable
+from mindsdb.integrations.libs.response import HandlerResponse, HandlerStatusResponse
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb.utilities.config import Config
+
+
+class PirateWeatherAPIBaseTable(APITable):
+    allowed_select_keys = {}
+    columns = []
+    table_name = ""
+
+    def __init__(self, handler: "PirateWeatherAPIHandler"):
+        super().__init__(handler)
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Select data from the collected weather data and return it as a pandas DataFrame.
+
+        Args:
+            query (ast.Select): The SQL query to be executed.
+
+        Returns:
+            pandas.DataFrame: A pandas DataFrame containing the selected data.
+        """
+        conditions = extract_comparison_conditions(query.where)
+
+        params = {}
+        for op, arg1, arg2 in conditions:
+            if arg1 in self.allowed_select_keys:
+                if op == "=":
+                    params[arg1] = arg2
+                else:
+                    raise NotImplementedError(f"Operator for argument {arg1} is not supported: {op}")
+
+        if "latitude" not in params or "longitude" not in params:
+            raise ValueError("Latitude and longitude are required")
+
+        result = self.handler.call_application_api(method_name=self.table_name, params=params)
+
+        # Reparse the query and run through SELECTQueryExecutor
+        query_parser = SELECTQueryParser(query, table=self.table_name, columns=self.get_columns())
+        selected_columns, where_conditions, order_by_conditions, result_limit = query_parser.parse_query()
+
+        # Remove request parameters from where conditions
+        where_conditions = [c for c in where_conditions if c[1] not in self.allowed_select_keys]
+
+        query_executor = SELECTQueryExecutor(result, selected_columns, where_conditions, order_by_conditions,
+                                             result_limit)
+
+        return query_executor.execute_query()
+
+    def get_columns(self) -> list:
+        return self.columns
+
+
+class PiratePirateWeatherAPIHourlyTable(PirateWeatherAPIBaseTable):
+    allowed_select_keys = {
+        "latitude",
+        "longitude",
+        "time",
+        "units"
+    }
+    columns = [
+        "localtime",
+        "icon",
+        "summary",
+        "precipAccumulation",
+        "precipType",
+        "temperature",
+        "apparentTemperature",
+        "dewPoint",
+        "pressure",
+        "windSpeed",
+        "windBearing",
+        "cloudCover",
+        "latitude",
+        "longitude",
+        "timezone",
+        "offset"
+    ]
+    table_name = "hourly"
+
+
+class PiratePirateWeatherAPIDailyTable(PirateWeatherAPIBaseTable):
+    allowed_select_keys = {
+        "latitude",
+        "longitude",
+        "time",
+        "units"
+    }
+
+    columns = [
+        "localtime",
+        "icon",
+        "summary",
+        "sunriseTime",
+        "sunsetTime",
+        "moonPhase",
+        "precipAccumulation",
+        "precipType",
+        "temperatureHigh",
+        "temperatureHighTime",
+        "temperatureLow",
+        "temperatureLowTime",
+        "apparentTemperatureHigh",
+        "apparentTemperatureHighTime",
+        "apparentTemperatureLow",
+        "apparentTemperatureLowTime",
+        "dewPoint",
+        "pressure",
+        "windSpeed",
+        "windBearing",
+        "cloudCover",
+        "temperatureMin",
+        "temperatureMinTime",
+        "temperatureMax",
+        "temperatureMaxTime",
+        "apparentTemperatureMin",
+        "apparentTemperatureMinTime",
+        "apparentTemperatureMax",
+        "apparentTemperatureMaxTime",
+        "latitude",
+        "longitude",
+        "timezone",
+        "offset"
+    ]
+    table_name = "daily"
+
+
+class PirateWeatherAPIHandler(APIHandler):
+    query_string_template = "https://timemachine.pirateweather.net/forecast/{api_key}/{latitude},{longitude}"
+
+    def __init__(self, name: str, **kwargs):
+        super().__init__(name)
+        self._tables = {}
+
+        args = kwargs.get("connection_data", {})
+        handler_config = Config().get("weather_handler", {})
+
+        connection_args = {}
+
+        for k in ["api_key"]:
+            if k in args:
+                connection_args[k] = args[k]
+            elif f"WEATHER_{k.upper()}" in os.environ:
+                connection_args[k] = os.environ[f"WEATHER_{k.upper()}"]
+            elif k in handler_config:
+                connection_args[k] = handler_config[k]
+
+        self._api_key = connection_args["api_key"]
+
+        # Register tables
+        self._register_table("hourly", PiratePirateWeatherAPIHourlyTable(self))
+        self._register_table("daily", PiratePirateWeatherAPIDailyTable(self))
+
+    def _register_table(self, table_name: str, table_class: Any):
+        self._tables[table_name] = table_class
+
+    def connect(self) -> HandlerStatusResponse:
+        return HandlerStatusResponse(success=True)
+
+    def check_connection(self) -> HandlerStatusResponse:
+        response = HandlerStatusResponse(False)
+
+        try:
+            self.call_application_api(method_name="daily", params=dict(latitude=51.507351,
+                                                                       longitude=-0.127758,
+                                                                       time="1672578052"))
+            response.success = True
+
+        except Exception as e:
+            response.error_message = str(e)
+
+        return response
+
+    def native_query(self, query: Any):
+        ast = parse_sql(query)
+        table = str(ast.from_table)
+        data = self._tables[table].select(ast)
+        return HandlerResponse(RESPONSE_TYPE.TABLE, data_frame=data)
+
+    def call_application_api(
+            self, method_name: str = None, params: dict = None
+    ) -> pd.DataFrame:
+        # This will implement api base on the native query
+        # By processing native query to convert it to api callable parameters
+        if method_name not in ["hourly", "daily"]:
+            raise NotImplementedError(f"Method {method_name} is not implemented")
+
+        if "latitude" not in params or "longitude" not in params:
+            raise ValueError("Latitude and longitude are required")
+
+        opt_params = {
+            "exclude": "currently,minutely,alerts,hourly,daily".replace("," + method_name, ""),
+            "units": params.get("units"),
+        }
+
+        # Build the query
+        query = self.query_string_template.format(
+            api_key=self._api_key,
+            latitude=params["latitude"],
+            longitude=params["longitude"]
+        )
+        if "time" in params:
+            query += f",{params['time']}"
+        # Add optional parameters
+        query += "?" + "&".join([f"{k}={v}" for k, v in opt_params.items() if v])
+
+        # Call the API
+        response = requests.get(query)
+        response.raise_for_status()
+
+        # Parse the response
+        data = response.json()
+        if method_name not in data:
+            raise ValueError(f"API response did not contain {method_name} data. Check your API key. Got response: {data}")
+
+        # Convert to dataframe
+        df = pd.DataFrame(data[method_name]["data"]).assign(
+            latitude=params["latitude"],
+            longitude=params["longitude"],
+            timezone=data["timezone"],
+            offset=data["offset"]
+        )
+        df["localtime"] = pd.to_datetime(df["time"], utc=True, unit="s").dt.tz_convert(data["timezone"])
+        df.drop(columns="time", inplace=True)
+        return df