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

mindsdb/integrations/handlers/dremio_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
+try:
+    from .dremio_handler import DremioHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Dremio'
+name = 'dremio'
+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/dremio_handler/connection_args.py

@@ -0,0 +1,31 @@
+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 Dremio server.'
+    },
+    port={
+        'type': ARG_TYPE.INT,
+        'description': 'The port that Dremio is running on.'
+    },
+    username={
+        'type': ARG_TYPE.STR,
+        'description': 'The username used to authenticate with the Dremio server.'
+    },
+    password={
+        'type': ARG_TYPE.PWD,
+        'description': 'The password to authenticate the user with the Dremio server.',
+        'secret': True
+    }
+)
+
+connection_args_example = OrderedDict(
+    host='localhost',
+    database=9047,
+    username='admin',
+    password='password'
+)

mindsdb/integrations/handlers/dremio_handler/dremio_handler.py

@@ -0,0 +1,222 @@
+from typing import Optional
+
+import json
+import time
+import requests
+import pandas as pd
+
+from mindsdb_sql_parser import parse_sql
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.integrations.libs.base import DatabaseHandler
+from sqlalchemy_dremio.base import DremioDialect
+
+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 DremioHandler(DatabaseHandler):
+    """
+    This handler handles connection and execution of the Dremio statements.
+    """
+
+    name = 'dremio'
+
+    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 = 'dremio'
+
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+
+        self.base_url = f"http://{self.connection_data['host']}:{self.connection_data['port']}"
+
+        self.connection = None
+        self.is_connected = False
+
+    def __del__(self):
+        if self.is_connected is True:
+            self.disconnect()
+
+    def connect(self) -> dict:
+        """
+        Set up the connection required by the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+
+        headers = {
+            'Content-Type': 'application/json',
+        }
+
+        data = '{' + f'"userName": "{self.connection_data["username"]}","password": "{self.connection_data["password"]}"' + '}'
+
+        response = requests.post(self.base_url + '/apiv2/login', headers=headers, data=data)
+
+        return {
+            'Authorization': '_dremio' + response.json()['token'],
+            'Content-Type': 'application/json',
+        }
+
+    def disconnect(self):
+        """
+        Close any existing connections.
+        """
+
+        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 Dremio, {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
+        """
+
+        query = query.replace('"', '\\"').replace('\n', ' ')
+
+        need_to_close = self.is_connected is False
+
+        auth_headers = self.connect()
+        data = '{' + f'"sql": "{query}"' + '}'
+
+        try:
+            sql_result = requests.post(self.base_url + '/api/v3/sql', headers=auth_headers, data=data)
+
+            job_id = sql_result.json()['id']
+
+            if sql_result.status_code == 200:
+                logger.info('Job creation successful. Job id is: ' + job_id)
+            else:
+                logger.info('Job creation failed.')
+
+            logger.info('Waiting for the job to complete...')
+
+            job_status = requests.request("GET", self.base_url + "/api/v3/job/" + job_id, headers=auth_headers).json()[
+                'jobState']
+
+            while job_status != 'COMPLETED':
+                if job_status == 'FAILED':
+                    logger.error('Job failed!')
+                    break
+
+                time.sleep(2)
+                job_status = requests.request("GET", self.base_url + "/api/v3/job/" + job_id, headers=auth_headers).json()[
+                    'jobState']
+
+            job_result = json.loads(requests.request("GET", self.base_url + "/api/v3/job/" + job_id + "/results", headers=auth_headers).text)
+
+            if 'errorMessage' not in job_result:
+                response = Response(
+                    RESPONSE_TYPE.TABLE,
+                    data_frame=pd.DataFrame(
+                        job_result['rows']
+                    )
+                )
+            else:
+                response = Response(
+                    RESPONSE_TYPE.ERROR,
+                    error_message=str(job_result['errorMessage'])
+                )
+
+        except Exception as e:
+            logger.error(f'Error running query: {query} on Dremio!')
+            response = Response(
+                RESPONSE_TYPE.ERROR,
+                error_message=str(e)
+            )
+
+        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(DremioDialect)
+        query_str = renderer.get_string(query, with_failback=True)
+        return self.native_query(query_str)
+
+    def get_tables(self) -> Response:
+        """
+        Return list of entities that will be accessible as tables.
+        Returns:
+            HandlerResponse
+        """
+
+        query = """
+            SELECT
+                TABLE_NAME,
+                TABLE_SCHEMA,
+                CASE
+                    WHEN TABLE_TYPE = 'TABLE' THEN 'BASE TABLE'
+                    ELSE TABLE_TYPE
+                END AS TABLE_TYPE
+            FROM INFORMATION_SCHEMA."TABLES"
+            WHERE TABLE_TYPE <> 'SYSTEM_TABLE';
+        """
+        return self.native_query(query)
+
+    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
+        """
+
+        query = f"DESCRIBE {table_name}"
+        result = self.native_query(query)
+        df = result.data_frame
+        result.data_frame = df.rename(columns={'COLUMN_NAME': 'Field', 'DATA_TYPE': 'Type'})
+        return result

mindsdb/integrations/handlers/dremio_handler/icon.svg

@@ -0,0 +1,16 @@
+<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="M9.20597 24.8135C8.08654 25.3726 5.84767 26.4908 5.95961 27.8326C6.29544 28.6153 7.19099 27.8326 7.52682 27.4971C8.31042 26.7144 8.87014 25.708 9.20597 24.8135ZM16.1465 21.9062C15.3629 23.9189 13.124 24.8135 12.5643 24.478C12.2284 24.2544 12.5643 23.6953 12.5643 23.248C12.1165 23.4716 11.3329 23.8071 10.8851 23.9189C12.0046 24.7017 12.5643 26.1553 12.5643 27.4971C12.5643 28.839 12.0046 30.069 10.9971 30.9635C12.9001 33.759 11.8926 36.1072 9.31791 38.0081L9.20597 38.12V37.8963C8.87014 36.5545 8.31042 35.4363 7.41488 34.4299C6.9671 33.8708 6.40738 33.4235 5.95961 32.9763C5.28795 32.3054 4.61629 31.7463 4.05658 31.0753C1.48188 28.3917 0.474388 23.6953 0.810218 20.1171C1.0341 18.2161 1.59382 16.427 2.37743 14.8616C3.04909 13.5197 3.94463 12.2897 4.95212 11.2833C7.19099 8.93514 10.2135 7.03422 13.3479 6.02784C16.1465 5.24511 19.2809 5.02147 21.9675 6.3633C22.4153 6.58694 23.0869 6.92239 23.4228 7.25784C23.6467 7.48148 23.8705 7.70513 24.0944 7.92877C24.0944 7.92877 24.0944 7.92877 24.2064 8.04059L36.5201 1.77871C37.5276 1.21961 38.3112 1.2196 38.6471 1.66688C38.9829 2.11416 38.5351 3.00872 37.7515 3.45599L27.1169 11.1715C27.3408 11.7306 27.005 12.6252 26.5572 13.1843C28.0125 13.6315 26.7811 15.7561 26.1094 16.427C24.3183 18.5516 21.072 20.1171 18.1614 21.3471C17.2659 21.5707 16.8181 21.6825 16.1465 21.9062Z" fill="#393C42"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M25.8857 14.7499C26.6693 13.7435 26.1096 13.1844 25.5498 13.7435C24.4304 14.8617 22.8632 15.1971 21.296 14.9735C19.1691 14.6381 19.0571 14.3026 19.393 13.9671C21.9677 14.8617 24.9901 13.6317 26.2215 11.6189C26.7812 10.8362 24.9901 10.2771 23.8707 8.82345C18.8332 2.00248 2.93729 7.92889 1.48202 19.8935C1.03425 23.4718 2.04174 27.4973 4.5045 30.2927C6.40753 32.4173 8.31057 33.3119 9.54195 36.5546C11.7808 34.6537 11.445 32.5291 9.76583 30.6282C12.5644 29.1746 12.1166 25.4845 10.2136 24.3663C9.31806 27.7209 6.0717 30.1809 5.2881 27.8327C4.84033 25.3727 8.75834 23.8072 15.1391 21.459C20.4004 19.3345 23.8707 17.6572 25.8857 14.7499Z" fill="#55BFCE"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M25.886 14.7496C26.6696 13.7433 26.1099 13.1842 25.5502 13.7432C24.6546 14.7496 23.1994 15.0851 21.968 15.0851C19.7291 14.9733 18.05 14.526 16.4828 14.6378C13.3483 14.9733 10.2139 16.986 8.64672 18.6633C5.84814 21.4588 2.82567 27.3852 5.84814 28.5034C5.62425 28.3916 5.40037 28.0561 5.28842 27.7207C4.84065 25.2606 8.75867 23.6952 15.1394 21.347C20.4008 19.3342 23.871 17.6569 25.886 14.7496Z" fill="white"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M12.2286 19.3345C13.9078 20.1172 13.5719 22.9127 13.348 23.6954C16.4825 22.8009 15.475 18.2163 16.9302 16.8745C15.1391 16.7626 11.7808 18.5517 12.2286 19.3345Z" fill="#55BFCE"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M17.49 11.0598C17.9378 10.8362 18.4975 10.948 18.7214 11.3953C18.9453 11.8425 18.8333 12.4016 18.3855 12.6253C17.9378 12.8489 17.3781 12.7371 17.1542 12.2898C16.8183 11.8425 17.0422 11.2834 17.49 11.0598Z" fill="#393C42"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M24.99 11.3952L37.4157 2.78506C37.7515 2.56142 38.1993 2.00233 38.0874 1.77869C37.8635 1.55506 37.3038 1.66688 36.856 1.89052L23.4228 9.15877C22.975 10.0533 23.8706 11.9543 24.99 11.3952Z" fill="#55BFCE"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M23.8713 9.71786L36.8567 2.11415C37.4164 1.77869 37.6403 1.77869 37.9762 1.77869C37.7523 1.55505 37.1926 1.66687 36.8567 1.89051L23.4235 9.15876C23.0877 9.82968 23.5355 11.0597 24.2071 11.507C23.9832 10.836 23.8713 10.277 23.8713 9.71786Z" fill="white"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M4.7278 13.1843C5.17558 13.0725 5.51141 13.4079 5.51141 13.8552C5.51141 14.3025 5.17558 14.7498 4.7278 14.7498C4.28003 14.8616 3.9442 14.5261 3.9442 14.0788C3.9442 13.6316 4.28003 13.1843 4.7278 13.1843Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M7.30308 10.3889C7.63891 10.277 7.97474 10.6125 7.97474 10.948C7.97474 11.2834 7.63891 11.7307 7.30308 11.7307C6.96725 11.8425 6.63142 11.5071 6.63142 11.1716C6.63142 10.8361 6.85531 10.3889 7.30308 10.3889Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M14.9146 6.69887C15.2505 6.69887 15.4744 7.03433 15.4744 7.36979C15.3624 7.70525 15.0266 8.04071 14.5788 8.04071C14.243 8.04071 14.0191 7.70525 14.0191 7.36979C14.131 6.92251 14.5788 6.69887 14.9146 6.69887Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M17.2662 6.25153C17.602 6.36335 17.714 6.58699 17.602 6.92245C17.4901 7.25791 17.1543 7.36972 16.8184 7.36972C16.4826 7.2579 16.3706 7.03426 16.4826 6.6988C16.5945 6.36334 16.9304 6.25153 17.2662 6.25153Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M7.30251 12.0662C7.5264 12.0662 7.75029 12.178 7.75029 12.5135C7.75029 12.849 7.5264 13.0726 7.19057 13.0726C6.96668 13.0726 6.7428 12.9608 6.7428 12.6253C6.85474 12.4017 7.07863 12.178 7.30251 12.0662Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M3.38448 15.309C3.72031 15.309 3.9442 15.4208 3.9442 15.7563C3.9442 16.0917 3.72031 16.3154 3.38448 16.4272C3.04865 16.4272 2.82477 16.3154 2.82477 15.9799C2.82477 15.6444 3.04865 15.4208 3.38448 15.309Z" fill="#25ABAD"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M26.6696 7.36984L26.1099 7.7053C26.1099 8.59985 26.8935 9.60623 27.3412 9.71805C26.8935 9.15895 26.5576 8.04075 26.6696 7.36984ZM29.804 5.69255L29.2443 5.91618C29.3562 6.69892 29.9159 7.59347 30.2518 7.59347C30.0279 7.25801 29.692 6.25164 29.804 5.69255ZM32.8265 4.01526L32.4906 4.23889C32.4906 4.68617 32.8265 5.4689 33.2742 5.58072C33.0503 5.24526 32.7145 4.68617 32.8265 4.01526ZM35.737 2.4498L35.4012 2.67343C35.4012 3.00889 35.8489 3.56798 36.0728 3.6798C35.9609 3.45616 35.737 2.89707 35.737 2.4498Z" fill="#25ABAD"/>
+</svg>

mindsdb/integrations/handlers/dremio_handler/requirements.txt

@@ -0,0 +1 @@
+sqlalchemy_dremio

mindsdb/integrations/handlers/dremio_handler/tests/test_dremio_handler.py

@@ -0,0 +1,35 @@
+import unittest
+from mindsdb.integrations.handlers.dremio_handler.dremio_handler import DremioHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class DremioHandlerTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "host": "localhost",
+            "port": 9047,
+            "username": "minura_punchihewa",
+            "password": "password"
+        }
+        cls.handler = DremioHandler('test_dremio_handler', cls.kwargs)
+
+    def test_0_check_connection(self):
+        assert self.handler.check_connection()
+
+    def test_1_native_query_select(self):
+        query = "SELECT * FROM staging.zips"
+        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('staging.zips')
+        assert columns.type is not RESPONSE_TYPE.ERROR
+
+
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/dropbox_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Dropbox handler"
+__package_name__ = "mindsdb_dropbox_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Dropbox"
+__author__ = "Ton Hoang Nguyen (Bill)"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024 - mindsdb"

mindsdb/integrations/handlers/dropbox_handler/__init__.py

@@ -0,0 +1,30 @@
+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 .dropbox_handler import DropboxHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Dropbox"
+name = "dropbox"
+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/dropbox_handler/connection_args.py

@@ -0,0 +1,17 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    access_token={
+        "type": ARG_TYPE.STR,
+        "description": " Dropbox Access Token",
+        "required": True,
+        "label": "Dropbox Access Token",
+    },
+)
+
+connection_args_example = OrderedDict(
+    access_token="ai.L-wqp3eP6r4cSWVklkKAdTNZ3VAuQjWuZMvIs1BzKvZNVW07rKbVNi5HbxvLc9q9D6qSfsf5VTsqYsNPGUkqSJBlpkr88gNboUNuhITmJG9mVw-Olniu4MO3BWVbEIphVxXxxxCd677Y",
+)

mindsdb/integrations/handlers/dropbox_handler/dropbox_handler.py

@@ -0,0 +1,253 @@
+import io
+import pandas as pd
+import dropbox
+
+from dropbox.exceptions import AuthError, ApiError, BadInputError
+from typing import Dict, Optional, Text
+
+from mindsdb_sql_parser.ast.base import ASTNode
+from mindsdb_sql_parser.ast import Select, Identifier, Insert
+
+from mindsdb.utilities import log
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE,
+)
+
+
+from mindsdb.integrations.libs.api_handler import APIHandler, APIResource
+
+
+class ListFilesTable(APIResource):
+
+    def list(self, conditions=None, limit=None, sort=None, targets=None, **kwargs):
+        files = self.handler._list_files()
+        data = []
+        for file in files:
+            item = {
+                "path": file["path"],
+                "name": file["name"],
+                "extension": file["extension"],
+            }
+            data.append(item)
+        df = pd.DataFrame(data)
+        return df
+
+    def get_columns(self):
+        return ["path", "name", "extension"]
+
+
+class FileTable(APIResource):
+
+    def _get_file_df(self):
+        try:
+            df = self.handler._read_file(self.table_name)
+            if df is None:
+                raise Exception(f"No such file found for the path: {self.dropbox_path}")
+
+            return df
+        except Exception as e:
+            self.handler.logger.error(e)
+
+    def list(self, conditions=None, limit=None, sort=None, targets=None, **kwargs):
+        return self._get_file_df()
+
+    def get_columns(self):
+        df = self.handler._read_file(self.table_name)
+        return df.columns.tolist()
+
+    def insert(self, query: Insert) -> None:
+        columns = [col.name for col in query.columns]
+        data = [dict(zip(columns, row)) for row in query.values]
+        df_new = pd.DataFrame(data)
+        df_existing = self._get_file_df()
+        df_combined = pd.concat([df_existing, df_new], ignore_index=True)
+        self.handler._write_file(self.table_name, df_combined)
+
+
+class DropboxHandler(APIHandler):
+
+    name = "dropbox"
+    supported_file_formats = ["csv", "tsv", "json", "parquet"]
+
+    def __init__(self, name: Text, connection_data: Optional[Dict], **kwargs):
+        super().__init__(name)
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+        self.logger = log.getLogger(__name__)
+        self.dbx = None
+        self.is_connected = False
+        self._files_table = ListFilesTable(self)
+        self._register_table("files", self._files_table)
+
+    def connect(self):
+        try:
+            if self.is_connected:
+                return
+            if "access_token" not in self.connection_data:
+                raise ValueError("Access token must be provided.")
+            self.dbx = dropbox.Dropbox(self.connection_data["access_token"])
+            self.is_connected = True
+            self.logger.info(
+                f"Connected to Dropbox as {self.dbx.users_get_current_account().email}"
+            )
+        except ValueError as e:
+            self.logger.error(f"Error connecting to Dropbox: {e}")
+        except AuthError as e:
+            self.logger.error(f"Authentication error with Dropbox: {e}")
+        except BadInputError as e:
+            self.logger.error(f"Bad input error with Dropbox: {e}")
+        except Exception as e:
+            self.logger.error(f"Error with Dropbox: {e}")
+
+    def check_connection(self) -> StatusResponse:
+        response = StatusResponse(False)
+        try:
+            self.connect()
+            response.success = True
+        except (ApiError, ValueError) as e:
+            self.logger.error(f"Error connecting to Dropbox with Dropbox: {e}")
+            response.error_message = str(e)
+        except AuthError as e:
+            self.logger.error(f"Authentication error with Dropbox: {e}")
+            response.error_message = str(e)
+        except Exception as e:
+            self.logger.error(f"Error with Dropbox Handler: {e}")
+            response.error_message = str(e)
+        return response
+
+    def disconnect(self):
+        if not self.is_connected:
+            return
+        self.dbx = None
+        self.is_connected = False
+        self.logger.info("Disconnected from Dropbox")
+
+    def _read_as_content(self, file_path) -> None:
+        """
+        Read files as content
+        """
+        try:
+            _, res = self.dbx.files_download(file_path)
+            content = res.content
+            return content
+        except ApiError as e:
+            self.logger.error(f"Error when downloading a file from Dropbox: {e}")
+
+    def query(self, query: ASTNode) -> Response:
+
+        if isinstance(query, Select):
+            table_name = query.from_table.parts[-1]
+            if table_name == "files":
+                table = self._files_table
+                df = table.select(query)
+
+                # add content
+                has_content = False
+                for target in query.targets:
+                    if (
+                        isinstance(target, Identifier)
+                        and target.parts[-1].lower() == "content"
+                    ):
+                        has_content = True
+                        break
+                if has_content:
+                    df["content"] = df["path"].apply(self._read_as_content)
+            else:
+                table = FileTable(self, table_name=table_name)
+                df = table.select(query)
+
+            return Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        elif isinstance(query, Insert):
+            table_name = query.table.parts[-1]
+            table = FileTable(self, table_name=table_name)
+            table.insert(query)
+            return Response(RESPONSE_TYPE.OK)
+        else:
+            raise NotImplementedError(
+                "Only SELECT and INSERT operations are supported."
+            )
+
+    def get_tables(self) -> Response:
+        table_names = list(self._tables.keys())
+        df = pd.DataFrame(table_names, columns=["table_name"])
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
+
+    def get_columns(self, table_name: str) -> Response:
+        table = self._get_table(Identifier(table_name))
+        columns = table.get_columns()
+        df = pd.DataFrame(columns, columns=["column_name"])
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
+
+    def _list_files(self, path=""):
+        files = []
+        result = self.dbx.files_list_folder(path, recursive=True)
+        files.extend(self._process_entries(result.entries))
+        while result.has_more:
+            result = self.dbx.files_list_folder_continue(result.cursor)
+            files.extend(self._process_entries(result.entries))
+        return files
+
+    def _process_entries(self, entries):
+        files = []
+        for entry in entries:
+            if isinstance(entry, dropbox.files.FileMetadata):
+                extension = entry.name.split(".")[-1].lower()
+                if extension in self.supported_file_formats:
+                    files.append(
+                        {
+                            "path": entry.path_lower,
+                            "name": entry.name,
+                            "extension": extension,
+                        }
+                    )
+        return files
+
+    def _read_file(self, path) -> pd.DataFrame:
+        try:
+            _, res = self.dbx.files_download(path)
+            content = res.content
+            extension = path.split(".")[-1].lower()
+            if extension == "csv":
+                df = pd.read_csv(io.BytesIO(content))
+            elif extension == "tsv":
+                df = pd.read_csv(io.BytesIO(content), sep="\t")
+            elif extension == "json":
+                df = pd.read_json(io.BytesIO(content))
+            elif extension == "parquet":
+                df = pd.read_parquet(io.BytesIO(content))
+            else:
+                raise ValueError(f"Unsupported file format: {extension}")
+            return df
+        except ValueError as e:
+            self.logger.error(f"Error with file extension: {e}")
+        except ApiError as e:
+            self.logger.error(f"Error when downloading a file from Dropbox: {e}")
+        except Exception as e:
+            self.logger.error(f"Error with Dropbox Handler: {e}")
+
+    def _write_file(self, path, df: pd.DataFrame):
+        try:
+            extension = path.split(".")[-1].lower()
+            buffer = io.BytesIO()
+            if extension == "csv":
+                df.to_csv(buffer, index=False)
+            elif extension == "tsv":
+                df.to_csv(buffer, index=False, sep="\t")
+            elif extension == "json":
+                df.to_json(buffer, orient="records")
+            elif extension == "parquet":
+                df.to_parquet(buffer, index=False)
+            else:
+                raise ValueError(f"Unsupported file format: {extension}")
+            buffer.seek(0)
+            self.dbx.files_upload(
+                buffer.read(), path, mode=dropbox.files.WriteMode.overwrite
+            )
+        except ValueError as e:
+            self.logger.error(f"Error with file extension: {e}")
+        except ApiError as e:
+            self.logger.error(f"Error when writing a file to Dropbox: {e}")
+        except Exception as e:
+            self.logger.error(f"Error with Dropbox Handler: {e}")

mindsdb/integrations/handlers/dropbox_handler/icon.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="43px" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 43 40" version="1.1" height="40px">
+ <path d="m12.5 0l-12.5 8.1 8.7 7 12.5-7.8-8.7-7.3zm-12.5 21.9l12.5 8.2 8.7-7.3-12.5-7.7-8.7 6.8zm21.2 0.9l8.8 7.3 12.4-8.1-8.6-6.9-12.6 7.7zm21.2-14.7l-12.4-8.1-8.8 7.3 12.6 7.8 8.6-7zm-21.1 16.3l-8.8 7.3-3.7-2.5v2.8l12.5 7.5 12.5-7.5v-2.8l-3.8 2.5-8.7-7.3z" fill="#007EE5"/>
+</svg>

mindsdb/integrations/handlers/dropbox_handler/requirements.txt

@@ -0,0 +1 @@
+dropbox